text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Типы значений в CSS. Абсолютные, относительные и всякие другие
#### Разберёмся, какие бывают типы значений у CSS-свойств, и определим, чем отличаются абсолютные и относительные значения свойств (все эти em, rem, vh, vw), как задаются цвета, и зачем нужны CSS-директивы.
Эта статья — часть учебника из курса профессиональной вёрстке сайтов от HTML Academy.
### Абсолютные значения
Самый простой тип значений — абсолютные. Например, значения в пикселях. Они могут задавать размеры элементов, размеры текста и так далее.
```
width: 1000px;
font-size: 16px;
```
Абсолютные значения хороши тем, что это итоговые значения, понятные и легко представимые. Этот как расстояние в метрах. Если до магазина 100 метров, то это близко, а если 10 000 метров, то это далековато. Чего не скажешь про относительные значения.
**Интерактивные тренажёры по теме:**
* [Меняем значения CSS-свойств](https://htmlacademy.ru/courses/297/run/6?utm_source=habr&utm_medium=special&utm_campaign=css211021)
* [Меняем свойства в CSS-правилах](https://htmlacademy.ru/courses/297/run/7?utm_source=habr&utm_medium=special&utm_campaign=css211021)
* [Создаём своё CSS-правило](https://htmlacademy.ru/courses/297/run/8?utm_source=habr&utm_medium=special&utm_campaign=css211021)
### Относительные значения
> *— Далеко ехать?*
>
> *— В два раза дальше, чем в прошлый раз!*
>
>
Такое значение сразу и не представишь: сначала нужно узнать, какое расстояние было в прошлый раз, потом перемножить на два, получить итоговое расстояние и только потом делать выводы.
Поэтому относительные значения — это более сложный тип. Эти значения, в отличие от абсолютных, не являются конечными или итоговыми, а зависят от других значений. Например, ширина элемента, заданная в процентах, зависит от ширины родительского элемента. Браузер вычисляет ширину такого элемента, умножая ширину родителя на значение в процентах, и получает абсолютное значение в пикселях. Надо сказать, что при отрисовке страницы все относительные значения в итоге превращаются в абсолютные, иначе страницу просто не отрисовать.
Проценты ведут себя достаточно сложно и вычисляются по-разному в зависимости от того, в каком свойстве используются. Например:
* если задать ширину в процентах, она вычисляется от ширины родителя,
* если задать размер шрифта в процентах, он вычисляется от размера шрифта родителя,
* если задать вертикальный внутренний отступ в процентах, он вычисляется от ширины родителя (а не от его высоты).
Помимо процентов есть и другие относительные единицы измерения.
```
width: 50%; /* От ширины родителя /
width: 100vw; / От ширины вьюпорта /
height: 100vh; / От высоты вьюпорта /
font-size: 2em; / От размера шрифта родителя /
font-size: 2rem; / От размера шрифта корневого элемента (html) /
```
Единицы `vh` и `vw` задают зависимость от размеров вьюпорта (видимой области окна браузера). Единица `vh` зависит от высоты вьюпорта и часто применяется, когда нужно делать полноэкранные секции. Единица `vw` задаёт зависимость от ширины вьюпорта и применяется намного реже.
Единица `em` задаёт зависимость от размеров шрифта родительского элемента. Если у родителя размер шрифта `20px`, а у вложенного элемента размер шрифта `2em`, то вычисленный размер шрифта будет `40px`.
Похожая единица `rem` задаёт зависимость от размера шрифта так называемого «корневого элемента». В случае обычной страницы — это тег `html`. Бывают и более сложные случаи, связанные с корневым элементом, но в эти тонкости мы сейчас углубляться не будем. Да и встретитесь вы с ними не так скоро. Если у корневого элемента страницы размер шрифта `16px`, а у какого-то тега на странице мы задаём размер шрифта `2rem`, то вычисленный размер шрифта будет `32px`.
Работа с относительными значениями — это частая прикладная задача, которую используют все. Но стоит помнить, при неумелом использовании относительные единицы измерения усложняют код и делают его поддержку более дорогой.
***Дополнительные материалы***
[Тренажёр «Типы CSS-значений»](https://htmlacademy.ru/courses/307/run/8?utm_source=habr&utm_medium=special&utm_campaign=css211021)
[Курс «Анатомия каскада» (ранний доступ)](https://l.htmlacademy.ru/anatomy-of-cascade-early-bird?utm_source=habr&utm_medium=special&utm_campaign=css211021)
### Значения с ключевыми словами
Следующий тип значений — ключевые слова. Они несложные, их нужно просто постепенно запоминать.
```
text-transform: uppercase;
text-align: center;
display: block;
color: red;
```
[*CSS Keywords*](https://webplatform.github.io/docs/css/data_types/keyword/)
### Как задаются цвета
Ещё один особый тип значений — цвета, которые встречаются сразу в нескольких вариантах.
```
color: #f00; / #f 0 0 /
color: #ff0000; / #ff 00 00 /
color: rgb(255, 0, 0);
color: rgba(255, 0, 0, 0.5);
color: hsl(0, 100%, 50%);
color: hsla(0, 100%, 50%, 0.5);
```
50 оттенков одного и того же цветаВ шестнадцатеричной записи, например, `#ff0000`, каждые две шестнадцатеричные цифры кодируют красный, зелёный и синий цветовой канал значением от `0` до `ff` (то есть от 0 до 255).
В сокращённой шестнадцатеричной записи каждая цифра дублируется. Например, `#f00` переводится в `#ff0000`.
Также есть форматы `rgb` и `rgba`. В rgb-формате цветовые каналы кодируются не шестнадцатеричными числами, а десятичными, тоже от `0` до `255`. Да и вообще этот формат легче воспринимается человеком. Сравните: `color: #ff0000` и `color: rgb(255, 0, 0)`.
В формате `rgba` в скобках появляется четвёртая часть, которая принимает значение от нуля до единицы и задаёт степень непрозрачности цвета. При нуле цвет полностью прозрачен (или непрозрачен на 0%), при единице цвет полностью непрозрачен.
Так как `rgba` — это цветовое значение, оно может быть задано любым свойствам, которые принимают цвет (цвет рамки, цвет фона, цвет текста и так далее). И этот цвет вы можете сделать полупрозрачным. Эр-Джи-Би-Эй — полупрозрачная рамка ещё никогда не делалась так просто!
Форматы `hsl` и `hsla` похожи на `rgb` и `rgba` и они привычны для дизайнеров-полиграфистов. И ещё цвета можно задавать с помощью ключевых слов.
### Значения-функции
Следующий тип значений — функции. Их не так много. Но особенно полезны функции `calc` и `linear-gradient`.
```
/ Получает содержимое атрибута /
content: attr(href);
/ Любые расчёты /
width: calc(100% - 100px);
/ Линейный градиент */
background-image:
linear-gradient(45deg, yellow, green);
```
С помощью `calc` можно добиваться очень сложного поведения. Например, вычислять размер элемента, используя разные единицы измерения: «ширина 200px плюс 10em».
Функция `attr` используется намного реже.
### Значения в виде произвольных строк
И последний на сегодня тип значений — произвольные строки. Обычно это названия шрифтов или значение свойства content.
```
font-family: "Times New Roman", serif;
content: "Привет!";
```
Однако `content` — это свойство, которое работает только у псевдоэлементов. Псевдоэлементы чаще всего используются для создания декоративных эффектов, в которых текстовое содержание не нужно, поэтому для `content` задаётся пустая строка.
### CSS-директивы
Это специальные конструкции, которые начинаются с символа `@`. Директивы чаще всего влияют на весь документ, но сами по себе ничего не стилизуют. Например, директива `@font-face` позволяет подключать на страницу нестандартные шрифты, которые потом можно использовать в свойстве `font-family`. Или директива `@media`, которая при определённых условиях активирует или деактивирует какие-то CSS правила. С помощью `@media` делают адаптивную вёрстку.
```
@font-face {
font-family: "Open Sans";
src:
url("OpenSans-Regular.woff2") format("woff2"),
url("OpenSans-Regular.woff") format("woff");
}
@media (max-width: 600px) {
.sidebar {
display: none;
}
}
```
---
На этом сегодня всё. Подпишитесь на нас на Хабре, чтобы не пропустить другие полезные шпаргалки по веб-разработке. И помните, что промокод SKUCHNO даёт скидку 1000 ₽ на все профессиональные курсы HTML Academy. Один из них — курс по [профессиональной вёрстке сайтов](https://htmlacademy.ru/intensive/htmlcss?utm_source=habr&utm_medium=special&utm_campaign=css211021), который недавно сильно обновился. | https://habr.com/ru/post/584786/ | null | ru | null |
# Кошерная организация туннелей в OpenWRT
Итак нам требуется организовать туннель между двумя linux-хостами, одним из которых является наш soho-роутер с этой замечательной прошивкой на борту. Сразу оговоримся, что для нас самое важное — скорость соединения и уменьшение накладных расходов. Посему, о установке пакетов которые реализуют аутентификацию, шифровку трафика, но занимают большое количество заветных килобайт в памяти роутера, мы забудем.Рассматривать мы будем только ipv4-туннели. Стандартно ядром поддерживаются:* ipip — инкапсулирует только unicast'овый IPv4-трафик
* gre — IPv4/IPv6 unicast/multicast трафик, одним словом — красота!
Выбор за вами, помимо некоторого естественного overhead'а в виде снижения скорости и увеличения нагрузки на систему, аргументов в пользу того или иного может служить ваш провайдер, он может просто блокировать один из протоколов.Насчёт снижения скорости, вот такая табличка получилась у меня при тестирование iperf'ом с стандартными настройками, значения в мегабитах:
| туннель | среднее | минимум | максимум |
| --- | --- | --- | --- |
| без туннеля | 30.9 | 29.8 | 31.9 |
| ipip | 24.8 | 24.4 | 25.3 |
| gre | 24.0 | 22.3 | 24.9 |
#### Подготовка системы
```
opkg update #обновляем список доступных пакетов
opkg install ip #вот так незамысловато называется пакет, более известный как iproute2 - "must have"-утилита на любом linux-роутере
opkg install kmod-gre #поддержка gre-протокола(№47, для справки, если вы решите поработать с трафиком средствами iptables)
opkg install kmod-ipip #поддержка ipip-протокла(№4)
```
В OpenWRT настройки сетевых интерфейсов описываются в файле `/etc/config/network`. Я предлагаю придерживаться стиля свойственного этой системе, зададим настройки именно там, но вот незадача — нет стандартной возможности описать туннель, с той же лёгкость как это можно сделать для ifup. На помощь нам приходит [мануал](http://wiki.openwrt.org/doc/devel/network-scripting), в котором подробно описано как определить новый протокол.#### Описание интерфейса
Вот так, в итоге, у меня выглядит описание нашего туннеля, в моём случае — gre:
```
#все строки не начинающиеся с решётки - обязательны
config 'interface' 'gretunnel'
option 'proto' 'tunnel' #строка, сигнализирующая нашей системе о используемомо протоколе связи
option 'tunnel_end' '1.2.3.4' #адрес удалённого конца туннеля
option 'tunnel_start' '5.6.7.8'
option 'remote_address' '192.168.0.1' #удалённый адрес соединения точка-точка
option 'local_address' '192.168.0.2'
option 'mtu' '1476'
option 'mode' 'gre' #gre/ipip
#option 'gateway' '192.168.0.1' #возможность назначить маршрут по умолчанию на этот интерфейс
```
Опять-же стандартным способом, в моём случае для ubuntu server'а, поднимаем второй конец туннеля:
```
auto gretunnel
iface gretunnel inet static
address 192.168.0.1
netmask 255.255.255.255 #знатоки, пожалуйста поясните зачем задавать маску, если она однозначно определяется следующей строкой?
pointopoint 192.168.0.2
mtu 1476
pre-up ip tunnel add gretunnel mode gre remote 5.6.7.8 local 1.2.3.4
post-down ip tunnel del gretunnel
```
#### Определям новый протокол
В гайде описаны четыре процедуры, полностью описывающие жизненный цикл сетевого интерфейса. Хотя их можно дописать в любой из файлов находящихся в каталоге `/lib/network/`, я предлагаю создать отдельный `tunnel.sh`, чтобы при возможном апгрейде системы или отдельных пакетов изменения сохранились.##### Scan
Протоколы создающие виртуальные интерфейсы(например — PPP, 6in4 или наш IP-туннель) должны реализовать процедуру `scan` для синтеза атрибута `ifname` нашей конфигурации интерфейса, необходимого для обработчиков событий `ifup/ifdown` в системе `hotplug`. На самом деле, можно напрямую прописать в конфигурации `option ifname tunnel_name`, но зачем?)
```
scan_tunnel() {
config_set "$1" ifname "$1"
}
```
То-есть просто даём интерфейсу тоже имя, что и названию конфигурации.##### Coldplug
По умолчанию, только интерфейсы присутствующие в `/proc/net/dev/` поднимаются при загрузке системы. Именно здесь мы создаём наш интерфейс, практически полностью конфигурируя его — не задаём лишь point-o-point адреса, так как они всё равно будет сброшены в процедуре `prepare_interface` определённой в `/lib/network/config.sh`.
```
coldplug_interface_tunnel() {
local mtu, tunnel_start, tunnel_end, mode, ifname
config_get mode "$1" mode
([[ "$mode" == "ipip" ]] && insmod ipip) || insmod ip_gre
config_get mtu "$1" mtu
config_get tunnel_end "$1" tunnel_end
config_get tunnel_start "$1" tunnel_start
config_get ifname "$1" ifname
ip tunnel add "$ifname" mode "$mode" local "$tunnel_start" remote "$tunnel_end"
}
```
##### Setup
Здесь интерфейс поднимается и конфигурируется до конца
```
setup_interface_tunnel() {
local alocal, aremote, mtu, defroute
config_get alocal "$2" local_address
config_get aremote "$2" remote_address
config_get mtu "$2" mtu
ip link set dev "$1" up mtu "$mtu"
ip address add dev "$1" "$alocal" peer "$aremote"
config_get defroute "$2" gateway
[[ -n "$defroute" ]] && ip route add default via "$aremote" dev "$1"
env -i ACTION="ifup" INTERFACE="$2" DEVICE="$1" PROTO=tunnel /sbin/hotplug-call "iface" &
}
```
В последней строчке запускается механизм, устанавливающий важный атрибут `up` в булеву истину, что в свой черёд позволяет работать с интерфейсом в штатном фаерволе, а также появляется возможность назначить маршруты через этот интерфейс.##### Stop
Опускаем интерфейс
```
stop_interface_tunnel() {
local ifname "$1" ifname
ip link set dev "$ifname" down
}
```
#### Работа с firewall'ом
По умолчанию в таблице `filter` стоит `DROP` политикой по умолчанию, впрочем как и в любой нормальной linux-системе. Нам надо описать работу с трафиком гуляющего через вышеописанный интерфейс `gretunnel`. Для этого создаём зону в файле `/etc/config/firewall`:
```
config 'zone'
option 'name' 'gretunnel'
option 'output' 'ACCEPT'
option 'forward' 'ACCEPT'
option 'mtu_fix' '1'
option 'input' 'ACCEPT'
```
Чьё имя совпадает с названием интерфейса, не забываем про `mtu` отличный от стандартных 1500 байт. Через `-j MASQUERADE` у меня не вышло(может кто-нибудь подскажет почему?), поэтому будем `SNAT'ить` пакеты, тем-более это быстрее. Для этого описываем соответствующее правило:
```
config redirect
option src lan
option dest gretunnel
option src_dip 192.168.0.2
option proto 'udp icmp tcp'
option target SNAT
```
У вас может возникнуть очевидный вопрос — «почему бы в опции `proto` не поставить `all`?» — к сожалению, ответа у меня нет, с такой опцией не работает, хотя вроде бы и должно :( Наконец разрешим `forward'ить` трафик из локальной сети на второй конец туннеля.
```
config 'forwarding'
option 'src' 'lan'
option 'dest' 'gretunnel'
```
#### Маршрутизация или зачём всё это вообще было надо
Начнём с канонического случая — объединение двух территориально разнесённых хоста/сетей в одну локальную сеть. Предчувствую нападки security-специалистов, мол трафик не защищён, да и пофиг, мне важна лишь простота и скорость, шифрование оставим для другого топика. Прописываем в `/etc/config/network` что-то наподобие:
```
config 'route'
option 'interface' 'gretunnel'
option 'target' '192.168.2.0'
option 'netmask' '255.255.255.0'
option 'gateway' '192.168.0.1'
```
И на втором конце производим похожие манипуляции, всё — сети/хосты связанны.Теперь рассмотрим случай, который лично меня и подтолкнул перепрошить свой dlink-320. Мой провайдер 1-го числа не отключает абонентов от сети физически — на порту свитча — вместо этого он оставляет полноценный доступ к локальной сети, при этом ограничивая доступ к интернет-ресурсам и некоторым внутренним. Хорошо, поступим следующим образом — будем маршрутизировать весь «легальный трафик» на шлюз провайдера, а всё остальное в наш туннель. Местные старожилы советуют смотреть сети вашего провайдера [тут](http://www.robtex.com/as/). Приступаем, в файле `/etc/config/network` комментируем опцию указывающую на маршрут по умолчанию назначенный шлюзу провайдера:
```
config 'interface' 'wan'
option 'ifname' 'eth0.1'
option 'proto' 'static'
option 'ipaddr' '5.6.7.8'
option 'netmask' '255.255.255.252'
# option 'gateway' '5.6.7.7'
option 'defaultroute' '0'
option 'peerdns' '0'
option 'dns' '8.8.4.4'
```
и раскомментируем соответствующую опцию в описание нашего туннеля
```
option 'gateway' '192.168.0.1'
```
Не забывая про «легальный» трафик
```
config 'route'
option 'interface' 'wan'
option 'target' '5.6.7.6'
option 'netmask' '255.255.255.252'
option 'gateway' '5.6.7.7'
#ну и например
config 'route'
option 'interface' 'wan'
option 'target' '10.0.0.0'
option 'netmask' '255.0.0.0'
option 'gateway' '5.6.7.7'
```
Всё, теперь у нас халявный интернет :)На самом деле, «халява» предоставленная моим провайдером не бесконечная, увы и ах. Через 45-ь дней порт таки блокируется, но благодаря тому что они клиентоориентированны по самое не балуй, они ещё и перерасчёт делают — я могу заплатить лишь за полмесяца пользования их услугами. Вот так и имею, «халявные» 8-ь мегабит)После прочтения данной статьи, у вас опять же может возникнуть вопрос — «а зачем так городить, если тоже самое можно было сделать в 10-ь строчек вынесенные в какой-нибудь initscript?» — к счастью, на этот вопрос у меня ответ имеется, хотя возможно и спорный — я считаю, что с системой надо работать в рамках идеологии принятой там, стараясь обойтись без хаков, кашерно так сказать)Ах да, есть же ещё «халявное» телевидение, но это тема для другого топика. | https://habr.com/ru/post/128680/ | null | ru | null |
# Параллельные вычисления в Apache Spark
Всем привет!
Иногда кажется, что для решения проблемы недостаточно простого выполнения расчётов в Spark и хочется более эффективно использовать доступные ресурсы. Меня зовут Илья Панов, я инженер данных в продукте CVM5 (Customer Value Management торговой сети Пятёрочка) группы X5, и хочу поделиться некоторыми подходами параллельных вычислений в Apache Spark.
#### Содержание
[Параллельное выполнение методов](#parallel)
[Настройка равномерного выделения ресурсов](#config)
[Join множества признаков](#join)
Постановка задачи продиктована потребностью разрабатываемого продукта, а именно - необходимо создать витрину со множеством признаков и поддерживать регулярное её перестроение. Признаки (или группы признаков) для витрины можно получить с помощью отдельных методов, которые в целом независимы и не пересекаются между собой. Результат каждого метода представляет собой датафрейм, в котором есть идентификатор гостя (так в торговых сетях называют всех посетителей) и список значений. После выполнения методов все данные следует собрать в общую таблицу и зарелизить витрину.
Если формализовать цели, то их две:
1. Вычисление независимых методов.
2. Объединение отдельных признаков в общую витрину.
Способы решения, которые приходят в голову, такие:
1. Провести вычисления последовательно.
2. Провести вычисления параллельно. Существует две опции:
1. Считать в параллельных Spark приложениях.
2. Считать параллельно в одном приложении.
Очевидно, что делая всё последовательно, получим успех. Но что по времени? Кажется, что параллельные подходы могут оказаться более эффективными. В параллельных подходах есть два варианта. Можно разделить методы на отдельные группы и запустить расчёт групп в параллельных приложениях. Такой подход имеет два существенных недостатка. Во-первых, отдельное приложение требует дополнительного оверхеда ресурсов на запуск. А во-вторых, приложения запускаются в некотором оркестраторе, например, Airflow, и каждое приложение требует отдельный слот выполнения, что может привести к долгому блокированию оркестратора и, как следствие, очереди из других пайплайнов.
Параллельные расчёты в рамках одного приложения лишены указанных недостатков, и в настоящей статье будет рассмотрен именно такой подход.
Параллельное выполнение методов
-------------------------------
Отмечу, что в статье все примеры для PySpark, но и для Scala (Java) интерфейса это будет актуально. Также стоит отметить, что в статье описан опыт использования Spark-2.4, живущем в "железном" кластере Hadoop, однако, полагаю, рассуждения и подходы будут справедливы и для cloud native решения.
Для иллюстрации рассмотрим следующий код. Предположим, у нас есть исходные данные в виде датафрейма с ключом v и квадратом этого ключа v2:
```
from pyspark.sql import DataFrame, functions as F
def get_df() -> DataFrame:
data = range(10)
data = map(lambda v: (v, v*v), data)
df = spark.createDataFrame(data, ["v", "v2"])
return df
df = get_df().cache()
df.show()
+---+---+
| v| v2|
+---+---+
| 0| 0|
| 1| 1|
| 2| 4|
...
| 9| 81|
+---+---+
```
Далее в процессе работы команды аналитиков появляется метод *method*, умеющий из квадрата значения получать четвёртую степень:
```
# Некоторый полезный код, который совершает сложный расчёт
@F.udf(returnType="integer")
def pow_udf(v):
return v*v
# Метод, который совершает расчёт признака
def method(df: DataFrame):
result = df.withColumn("v4", pow_udf("v2"))
result.count()
```
Допустим, четвёртую степень можно посчитать исключительно задействовав user defined functions (конечно, нет). И ещё одно замечание - нам нужно из кода метода материализовать данные. В реальном пайплайне это происходит через сохранение предрасчёта в stage-area (например, parquete в HDFS), но для иллюстрации сгодится запуск вычислений через вызов *.count()*.
Итак, вызовем наш метод последовательно три раза:
```
for _ in range(3):
method(df)
```
В итоге в веб-интерфейсе Spark в timeline увидим, что расчёты производились последовательно:
Добавим параллельности - вызовем метод из параллельных потоков:
```
from concurrent import futures
executor = futures.ThreadPoolExecutor(max_workers=5)
for _ in range(3):
future = executor.submit(method, (df))
```
И в результате на timeline видим, что расчёты действительно выполнялись параллельно:
Таким образом, в рамках одного Spark-приложения можно одновременно выполнять сразу несколько методов. Это возможно благодаря тому, что из параллельных потоков можно обращаться как к отдельному датафрейму, так и к SparkSession.
Однако, если подобный подход применить к реальным методам с тяжёлыми вычислениями над большими массивами данных, нас ждёт неприятный сюрприз. Вот как выглядит типичная картина для параллельно выполняемых методов:
Некоторые задачи получают много ресурсов, а некоторые просто стоят и ждут своей очереди. Это сводит всю параллельность обратно к последовательному выполнению: задачи выполняются "почти" последовательно, согласно выделяемым им ресурсам.
Проблема заключается в том, что Spark для выделения ресурсов (ядер) использует свой внутренний планировщик по-умолчание. А именно FIFO Scheduler - планировщик по типу очереди - первая большая задача забирает множество ядер, а остальным достаются остатки.
Чтобы исправить эту проблему и уравнять распределение ядер по задачам, необходимо перенастроить планировщик.
Настройка равномерного выделения ресурсов
-----------------------------------------
В недрах Spark существует cправедливый (fair) планировщик, более пригодный для параллельного выполнения методов. Для его включения необходимо при запуске Spark передать небольшой конфиг *fair-scheduler.xml*, описывающий ресурсный пул:
```
xml version="1.0"?
FAIR
1
1
```
Здесь указаны следующие параметры:
* *weight* - задаёт вес конфигурируемого нами пула относительно других. Вес позволяет задать пропорции, согласно которым пулы "расходуют" ресурсы для задач, которые в них запускаются. По-умолчанию, это 1. Так и оставим, чтобы наш пул мог "забирать" ресурсы наравне с другими;
* *minShare* - задаёт минимальное количество ядер, выделяемых для задачи. Пусть будет хотя бы 1 ядро на задачу;
* *schedulingMode* - задаёт тот самый параметр, благодаря которому ресурсы в рамках пула должны делиться равномерно между задачами.
Подробнее про конфигурацию ресурсных пулов можно почитать в первоисточнике - [документации](https://spark.apache.org/docs/2.4.4/job-scheduling.html#scheduling-within-an-application) к Spark.
Кроме конфигурации своего справедливого пула, нужно перевести и сам Spark в FAIR режим. Всё вместе это выглядит примерно так:
```
pyspark \
--conf spark.scheduler.mode=FAIR \
--conf spark.scheduler.allocation.file=./fair-scheduler.xml
```
Что же касается кода приложения, то изменения минимальны - нужно в потоке-воркере добавить инициализацию параметра *spark.scheduler.pool* и задать наш пул:
```
def method_fair(df: DataFrame):
spark.sparkContext.setLocalProperty("spark.scheduler.pool", "fair-pool")
df.withColumn("v4", pow_udf("v2")).count()
```
Теперь выполняемые методы будут получать ресурсы из нашего fair-пула, что приводит к максимально равномерному распределению ядер между нашими задачами:
### Зачем всё это?
Возможно, существует некоторая теория, которая позволяет построить метрику для сравнения производительности системы, выполняющей последовательные или параллельные вычисления с одинаковыми ограничениями по доступным ресурсам. Но мне такая теория неизвестна (либо я не догадываюсь про неё), поэтому приходится руководствоваться экспериментами и капелькой здравомыслия для попытки описать результаты. Если кто-то знает, как это можно формализовать, прошу в комментариях поделиться.
Стоит отметить, что проведение экспериментов в высококонкурентной среде, коим является Hadoop-кластер, - это то ещё удовольствие. Каждый тестовый запуск не похож на предыдущий, т.к. постоянно кто-то ещё что-то считает. И мой i-ый тестовый запуск может получить ресурсов меньше/больше, чем i-1. Также скорость получения ресурсов неодинаковая: можно со старта получить 100 ядер, а можно эти 100 ядер добирать на протяжении долгого времени.
Таким образом для объективного сравнения двух подходов проводилось множество экспериментов на протяжении достаточно долгого времени (более недели). А также сами запуски проводились в различное время: и утром, и ночью, и в самые часы-пик.
В итоге подход с параллельным выполнением методов **всегда** превосходил последовательный. В самом худшем раскладе параллельное выполнение на 40% быстрее. В самом лучшем - когда сошлись все звёзды - получалось 3х-кратное превосходство. Если взять средние показатели для целевого времени расчёта признаков (раннее утро), то параллельный подход выигрывает примерно в 2 раза.
### Как можно объяснить?
Моё предположение состоит из двух составляющих.
Во-первых, параллельное выполнение обеспечивает максимальную утилизацию вычислительных ресурсов. Простои выделенных ядер сводятся к минимуму, потому что почти отсутствуют временные моменты, когда следующая задача должна дождаться выполнения предыдущей. На эти мысли наводит старенькая [статья](https://blog.cloudera.com/how-to-tune-your-apache-spark-jobs-part-2/) в блоге Cloudera.
Во-вторых, кажется, что для одной задачи прирост производительности от увеличения количества ядер не является линейным, а постепенно замедляется. Таким образом, большей эффективности получается добиться от параллельного запуска нескольких методов.
Join множества признаков
------------------------
Итак, мы умеем выполнять методы параллельно, теперь из результатов этих методов необходимо собрать витрину. Заодно разберём ещё один подход к параллельному вычислению.
Предположим у нас есть список датафреймов с признаками, которые можно джойнить по общему ключу:
```
frames = []
for _ in range(10):
df = get_df()
frames.append(df)
```
Самое естественное решение в духе доступного интерфейса Spark - последовательный join:
```
def merge(frames: List[DataFrame]) -> DataFrame:
union = frames[0]
for df in frames[1:]:
union = union.join(df, on=["v"], how="full")
return union
```
План выполнения такого расчёта будет выглядеть так:
На вход следующего шага поступает результат предыдущего. Всё ожидаемо, хотя Spark мог бы попробовать это оптимизировать. Но он так явно не умеет.
Реализуем свой Join с параллельностью. Будем иерархически на каждом шаге проводить попарный join признаков. Таким образом, получим древовидную структуру, в которой каждая вершина совершает join своих потомков.
Класс вершины - хранит пару (или один) датафреймов, для которых выполняется join:
```
class Node(object):
def __init__(self):
self.children: List[DataFrame] = []
def add_child(self, child: DataFrame):
self.children.append(child)
def join(self) -> DataFrame:
if len(self.children) == 1:
return self.children[0]
else:
df1 = self.children[0]
df2 = self.children[1]
df = df1.join(df2, on=["v"], how="full")
return df
```
В итоге получится метод, похожий на построение турнирной таблицы - участники (датафреймы) находясь внизу турнирной таблицы, продвигаются вверх через попарный join. И в итоге в вершине таблицы (в корне) получается датафрейм с общим набором признаков.
```
def tournament_merge(leafs: List[DataFrame]=[]) -> DataFrame:
nodes = []
while(len(nodes) != 1):
nodes = []
for i in range(0, len(leafs), 2):
pair = leafs[i : i+2]
node = Node()
for v in pair:
node.add_child(v)
nodes.append(node)
leafs = []
for n in nodes:
leaf = n.join()
leafs.append(leaf)
root = nodes[0]
union = root.join()
return union
```
Вместо тысячи слов про деревья и турнирные таблицы предлагаю посмотреть на анимированный пример:
В этом методе не используются параллельные потоки для отдельных джойнов, потому что общий план выполнения будет выглядеть примерно так:
Два параллельных join'а идут на вход третьему. Что в результате реального запуска приведёт к параллельному вычислению в Spark. А так как используется fair-пул, то параллельные джойны будут стремиться выполняться на равном количестве ядер.
Применение *tournament\_merge* достигает трёхкратного превосходства над последовательным подходом. Объяснение этому, по моему мнению, заключается в том, что, конечно, количество джойнов будет одинаковым, но некоторые из них выполняются параллельно относительно друг друга. Это приводит к экономии общего времени.
### Заключение
В статье рассмотрены некоторые подходы к параллельному выполнению методов в Spark. Основная идея заключается в возможности использовать SparkSession в параллельных потоках. И для истинной параллельности необходимо немного поправить конфиг в Spark. Проведённые эксперименты показывают существенный прирост производительности от использования параллельности.
**Автор:** [Илья Панов](https://www.linkedin.com/in/ilya-panov/) | https://habr.com/ru/post/684024/ | null | ru | null |
# Заряжай Patroni. Тестируем Patroni + Zookeeper кластер (Часть первая)
Кадр из фильма «Рембо IV»Вступление
----------
Если вы работаете с crucial data, то рано или поздно задумаетесь о том, что неплохо бы поднять кластер отказоустойчивости. Даже если основной сервер с базой улетит в глухой нокаут, show must go on, не так ли? При этом мы подразумеваем две вещи:
* база данных со всей ее структурой нам по-прежнему доступна;
* все данные находятся в состоянии максимально близком к тому, которое было на героически павшем лидере.
Patroni лишь одно из решений проблемы. До него я попробовал несколько других сервисов и на Github одного из них (не буду показывать курсором) до сих пор висит без ответа открытый мной баг репорт, хотя прошло уже несколько месяцев. У другого была не самая полная документация. Какие-то мне показались недостаточно надежными.
По Patroni же действительно много инфы, и он качественно поддерживается разработчиками. Также он использует DCS для синхронизации нод, что должно предотвращать ситуации со «split brain».
Из минусов совершенно точно нужно назвать то, что это не «out of the box solution. Как сказано в доке:
> “Patroni is a template for you to create your own customized, high-availability solution using Python...”
>
>
И ключевое здесь слово «template». То есть все придется собирать самому. Но в каком-то смысле это плюс — по крайней мере, мы детально будем знать, что именно идёт в прод.
По специализации, кстати, я не DevOps инженер. Когда появилась необходимость поднять отказоустойчивый кластер мне пришлось собрать все ямы и столбы какие только были на этом пути. Надеюсь, этот туториал поможет вам достичь результата, испытав в разы меньше страданий и боли, чем довелось мне.
Если вы устали уже от вступлений и рветесь в бой, смело переходите к следующей главе.
Если нет, то предлагаю под спойлером прочесть короткие заметки по конфигурации кластера, которую я выбрал для деплоя.
Что, ещё один туториал о Patroni?#### Зачем читать именно этот туториал?
Есть уже немало туториалов, которые рассказывают, как поднять кластер Patroni. Этот затрагивает вопросы деплоя в среде docker swarm и использования Zookeeper в качестве DCS.
#### Почему Zookeeper?
Я считаю, это один из моментов, которые стоит рассмотреть всерьез, прежде чем выбрать конечный сетап для продакшена. Дело в том, что Patroni использует сторонние сервисы чтобы установить и обслуживать коммуникацию между своими нодами. Их общее название — DCS (Dynamic Configuration Storage).
Если вы уже смотрели какие-то из туториалов о Patroni, то, должно быть, заметили, что самый частый кейс — это когда в качестве DCS используют Etcd кластер.
Интересный момент в работе Etcd кластера заключается в том, что:
> Since etcd writes data to disk, its performance strongly depends on disk performance. For this reason, SSD is highly recommended.
>
> (из документации Etcd)
>
>
Словом, если у вас нет по SSD диску на каждой машине, где будут работать ноды Etcd, то вы в зоне опасности. Конечно, пока нагрузка небольшая, то ничего критичного происходить не будет, но если это рабочий, нагруженный прод, то очень возможно (и даже вероятно), что вы просто перегрузите Etcd кластер. А это приведет к IO ошибкам при доступе к базе. Звучит скверно? На самом деле так и есть. Ловить такие ошибки на проде очень неприятно.
Здесь нам на помощь и может прийти Zookeeper, который ничего не пишет на диск и хранит все данные в памяти. Такой вариант оптимален в ситуации, когда не на всех серверах есть SSD, зато RAM хватает.
#### Почему Docker Swarm?
У меня не было выбора, так как одним из ключевых требований было, чтобы кластер был развернут в Swarm’е. Так что, если это и ваш кейс тоже, то вы в правильном месте!
Для тех же, кто открыл пост с желанием потестировать технологию, выбор Docker Swarm’а тоже может быть вполне органичным. Хотя бы по той причине, что вам не придется устанавливать и настраивать никаких сторонних сервисов (ну за исключением самого Docker’а, разумеется) или тянуть на локальную машину ворох непонятных зависимостей. Полагаю, недалеко от истины утверждение, что Docker у нас у всех и так уже настроен везде где только можно, мы все знаем, как он работает, так что почему бы не использовать его.
Потребуется лишь одна команда, чтобы сделать тюнинг Docker’а, который позволит развернуть на локальной машине кластер Patroni на 3 ноды без виртуальных машин, Kubernetes или подобных вещей.
Если вы не хотите копать в сторону каких-то еще инструментов за пределами Docker’а и хотите сделать все чисто и аккуратно, то данный туториал вам более чем подойдет.
#### А в конце будет небольшой бонус
Во [второй части](https://habr.com/ru/company/vsrobotics/blog/534840/) туториала я покажу различные варианты проверки статуса кластера (целых 3), и в конце дам простой скрипт с инструкциями для быстрого теста кластера.
Окей, достаточно разговоров. Давайте перейдем к практике.
Docker Swarm
------------
Для быстрого и приближенного к реальности теста, нам, на самом деле, достаточно одной ноды в Swarm кластере. Поскольку мы можем очень легко поднимать и ронять сервисы, запущенные в Swarm’е, мы сможем имитировать падение сервера с нодой, имея в распоряжении только одну локальную машину.
Я исхожу из предположения, что у вас уже установлен и настроен Docker Engine. В таком случае, нужно только выполнить следующую команду:
```
docker swarm init
//now check your single-node cluster
docker node ls
ID HOSTNAME STATUS AVAILABILITY
a9ej2flnv11ka1hencoc1mer2 * floitet Ready Active
```
Одна из важных фич Swarm’а заключается в том, что теперь мы можем использовать не только обычные Docker контейнеры, но и так называемые сервисы. Сервисы — это по сути дела абстракция над контейнерами. Если отталкиваться от аналогии с ООП, то сервис — это класс, а контейнер конкретный объект класса. Параметры и правила сервиса задаются при деплое из yml-файла.
Рекомендую запомнить hostname ноды — потом мы используем его для указания ‘constraint’ в конфигурационном файле.
В целом, это все приготовления в части Docker Swarm’а, которые нужно сделать. Здесь никаких проблем быть не должно. Так что двинемся дальше.
Zookeeper
----------
Прежде чем мы начнем деплой самого Patroni, нам нужно сначала развернуть кластер с DCS (в нашем случае, как мы помним, это Zookeeper). Я взял версию 3.4, и она работает вполне стабильно. Далее идет docker-compose конфиг и некоторые комментарии по моментам, которые, как мне кажется, имеет смысл отдельно упомянуть.
* **docker-compose-zookeeper.yml**
docker-compose-zookeeper.yml
```
version: '3.7'
services:
zoo1:
image: zookeeper:3.4
hostname: zoo1
ports:
- 2191:2181
networks:
- patroni
environment:
ZOO_MY_ID: 1
ZOO_SERVERS: server.1=0.0.0.0:2888:3888 server.2=zoo2:2888:3888 server.3=zoo3:2888:3888
deploy:
replicas: 1
placement:
constraints:
- node.hostname == floitet
restart_policy:
condition: any
zoo2:
image: zookeeper:3.4
hostname: zoo2
networks:
- patroni
ports:
- 2192:2181
environment:
ZOO_MY_ID: 2
ZOO_SERVERS: server.1=zoo1:2888:3888 server.2=0.0.0.0:2888:3888 server.3=zoo3:2888:3888
deploy:
replicas: 1
placement:
constraints:
- node.hostname == floitet
restart_policy:
condition: any
zoo3:
image: zookeeper:3.4
hostname: zoo3
networks:
- patroni
ports:
- 2193:2181
environment:
ZOO_MY_ID: 3
ZOO_SERVERS: server.1=zoo1:2888:3888 server.2=zoo2:2888:3888 server.3=0.0.0.0:2888:3888
deploy:
replicas: 1
placement:
constraints:
- node.hostname == floitet
restart_policy:
condition: any
networks:
patroni:
driver: overlay
attachable: true
```
DetailsКонечно же, важно дать каждой ноде уникальное имя и внешний порт. Hostname лучше ставить одинаковое с именем сервиса.
```
zoo1:
image: zookeeper:3.4
hostname: zoo1
ports:
- 2191:2181
```
Стоит отметить и то, как мы перечисляем host’ы в строке ниже: для первого сервиса server.1 будет привязан к 0.0.0.0, а, например, для zoo2 это уже будет server.2 соответственно и т.д.
```
ZOO_SERVERS: server.1=0.0.0.0:2888:3888 server.2=zoo2:2888:3888 server.3=zoo3:2888:3888
```
А таким образом мы контролируем распределение сервисов по нодам. Поскольку нода у нас сейчас только одна, мы спокойно могли бы убрать эти строчки из конфига, но когда серверов будет несколько, можно будет менять node.hostname и тем самым определять на какую ноду пойдет сервис.
```
placement:
constraints:
- node.hostname == floitet
```
И последний момент, который мы здесь обсудим, это network. Я намерен деплоить все сервисы Zookeeper’а и все сервисы Patroni в одну сеть с драйвером overlay, чтобы они были изолированы от других сервисов и могли общаться между собой по именам, а не по IP (как это выглядит, будет видно дальше).
```
networks:
patroni:
driver: overlay
// мы должны отметить сеть как attachable
// чтобы потом можно было присоединять к ней остальные сервисы
attachable: true
```
Итак, можно задеплоить Zookeeper:
```
sudo docker stack deploy --compose-file docker-compose-zookeeper.yml patroni
```
Теперь нужно проверить, что все работает. Первое что можно сделать это просто посмотреть список сервисов:
```
sudo docker service ls
gxfj9rs3po7z patroni_zoo1 replicated 1/1 zookeeper:3.4 *:2191->2181/tcp
ibp0mevmiflw patroni_zoo2 replicated 1/1 zookeeper:3.4 *:2192->2181/tcp
srucfm8jrt57 patroni_zoo3 replicated 1/1 zookeeper:3.4 *:2193->2181/tcp
```
И следующим шагом можно сделать пинг сервисов с помощью специальной команды mntr:
```
echo mntr | nc localhost 2191
// with the output being smth like this
zk_version 3.4.14-4c25d480e66aadd371de8bd2fd8da255ac140bcf, built on 03/06/2019 16:18 GMT
zk_avg_latency 6
zk_max_latency 205
zk_min_latency 0
zk_packets_received 1745
zk_packets_sent 1755
zk_num_alive_connections 3
zk_outstanding_requests 0
zk_server_state follower
zk_znode_count 16
zk_watch_count 9
zk_ephemerals_count 4
zk_approximate_data_size 1370
zk_open_file_descriptor_count 34
zk_max_file_descriptor_count 1048576
zk_fsync_threshold_exceed_count 0
```
Также можно проверить логи сервиса, если есть желание:
```
docker service logs $zookeeper-service-id
// service-id comes from 'docker service ls' command.
// in my case it could be
docker service logs gxfj9rs3po7z
```
Отлично, вот мы и разобрались с Zookeeper’ом. Теперь можно переходить к самому Patroni.
Patroni
-------
Мы наконец добрались до основной части туториала, где нам предстоит поднимать кластер Patroni. Первое что нужно сделать — это билд кастомного имейджа Patroni, чтобы нам было что деплоить. Мы включим в сборку только самые необходимые вещи, и я постараюсь объяснить все шаги как можно более подробно, чтобы в дальнейшем вам легко было работать с этим образом и апгрейдить его по своему желанию.
Сначала создадим отдельную директорию ’patroni-test’ и перейдем в неё. Для того чтобы успешно сбилдить рабочий имейдж нам понадобится пара дополнительных файлов, с них и начнем.
* **patroni.yml**
Это основной конфигурационный файл. Одна из особенностей Patroni, что мы можем задавать параметры для кластера из разных мест и patroni.yml — одно из них. Этот файл мы будем копировать в кастомный имейдж, так что любые изменения, внесенные в него, требуют ребилда образа.
Я в итоге пришел к идее, что буду хранить здесь только те параметры, которые наверняка почти никогда не буду трогать, поэтому складываю здесь только самые необходимые настройки. Ниже я привожу базовый конфиг. Если захочется, то можно добавить в него каких-то параметров, допустим, для движка Posgtres’а (например, max\_connections и т.п.). Но для тестового стенда этого вполне достаточно.
patroni.yml
```
scope: patroni
namespace: /service/
bootstrap:
dcs:
ttl: 30
loop_wait: 10
retry_timeout: 10
maximum_lag_on_failover: 1048576
postgresql:
use_pg_rewind: true
postgresql:
use_pg_rewind: true
initdb:
- encoding: UTF8
- data-checksums
pg_hba:
- host replication all all md5
- host all all all md5
zookeeper:
hosts:
- zoo1:2181
- zoo2:2181
- zoo3:2181
postgresql:
data_dir: /data/patroni
bin_dir: /usr/lib/postgresql/11/bin
pgpass: /tmp/pgpass
parameters:
unix_socket_directories: '.'
tags:
nofailover: false
noloadbalance: false
clonefrom: false
nosync: false
```
DetailsВажно указать Patroni путь к бинарным файлам Postgres’а. В моем случае, так как я использую Postgres 11, директория выглядит так: ’/usr/lib/postgresql/11/bin’.
В директории, внутри уже созданного контейнера, Patroni будет искать файлы Postgres’а. Без этой настройки скорее всего ничего не взлетит (по крайней мере у меня не взлетело). И также еще есть ’data\_dir’ — это место в контейнере, где будут храниться данные. Позже мы сделаем mount этой директории к месту на локальном жестком диске, чтобы не потерять все полимеры, если кластер все же упадет безнадежно. Это добавит нам работы по созданию этих папок локально, но, по-моему, оно того стоит.
```
postgresql:
data_dir: /data/patroni
bin_dir: /usr/lib/postgresql/11/bin
```
Также я перечисляю все сервера Zookeeper’а в этом конфиг файле, чтобы потом передать информацию о них утилите patronictl. Стоит отметить, что если не указать их в patroni.yml, то мы останемся в итоге с нерабочим patronictl. Как вы видите, перечисляя сервера, я не пишу никакие IP, а использую их имена. Это та самая фича Docker Swarm’а о которой я рассказывал выше.
```
zookeeper:
hosts:
- zoo1:2181
- zoo2:2181
- zoo3:2181
```
* **patroni-entrypoint.sh**
Из следующего файла подтягивается большая часть настроек в моей конфигурации. Это небольшой скрипт, который будет выполнен, когда контейнер сервиса окажется создан.
patroni-entrypoint.sh
```
#!/bin/sh
readonly CONTAINER_IP=$(hostname --ip-address)
readonly CONTAINER_API_ADDR="${CONTAINER_IP}:${PATRONI_API_CONNECT_PORT}"
readonly CONTAINER_POSTGRE_ADDR="${CONTAINER_IP}:5432"
export PATRONI_NAME="${PATRONI_NAME:-$(hostname)}"
export PATRONI_RESTAPI_CONNECT_ADDRESS="$CONTAINER_API_ADDR"
export PATRONI_RESTAPI_LISTEN="$CONTAINER_API_ADDR"
export PATRONI_POSTGRESQL_CONNECT_ADDRESS="$CONTAINER_POSTGRE_ADDR"
export PATRONI_POSTGRESQL_LISTEN="$CONTAINER_POSTGRE_ADDR"
export PATRONI_REPLICATION_USERNAME="$REPLICATION_NAME"
export PATRONI_REPLICATION_PASSWORD="$REPLICATION_PASS"
export PATRONI_SUPERUSER_USERNAME="$SU_NAME"
export PATRONI_SUPERUSER_PASSWORD="$SU_PASS"
export PATRONI_approle_PASSWORD="$POSTGRES_APP_ROLE_PASS"
export PATRONI_approle_OPTIONS="${PATRONI_admin_OPTIONS:-createdb, createrole}"
exec /usr/local/bin/patroni /etc/patroni.yml
```
Details. Важно!На самом деле, основной смысл вообще делать такой скрипт заключается в том, что мы просто не сможем стартануть сервис с Patroni, не зная IP адрес host’а. И в том случае, когда host’ом оказывается Docker-контейнер, нам как-то нужно сначала узнать какой же IP этот контейнер получил, и только потом мы можем запустить Patroni. Эта потребность закрывается вот здесь:
```
readonly CONTAINER_IP=$(hostname --ip-address)
readonly CONTAINER_API_ADDR="${CONTAINER_IP}:${PATRONI_API_CONNECT_PORT}"
readonly CONTAINER_POSTGRE_ADDR="${CONTAINER_IP}:5432"
...
export PATRONI_RESTAPI_CONNECT_ADDRESS="$CONTAINER_API_ADDR"
export PATRONI_RESTAPI_LISTEN="$CONTAINER_API_ADDR"
export PATRONI_POSTGRESQL_CONNECT_ADDRESS="$CONTAINER_POSTGRE_ADDR"
```
Как я уже говорил раньше, параметры конфига Patroni можно передавать разными способами. В этом скрипте мы пользуемся тем, что один из таких способов — это ’Environment configuration’. ’PATRONI*RESTAPI*CONNECTADDRESS’, ’PATRONI*RESTAPI*LISTEN’, ’PATRONI*POSTGRESQLCONNECT*ADDRESS’ — специальные переменные среды, о которых Patroni знает заранее и которые будут считаны. И кстати, они переписывают локальные настройки из patroni.yml, так что be aware!
И еще момент. Документация Patroni не рекомендует использовать superuser’а для подключения к базе приложений. Т.е. нужно создать отдельного юзера, который мы будем использовать непосредственно для коннекта, а superuser’а и replicator’а трогать не будем совсем. Создать такого юзера можно также через переменную среды. Если хотите, чтобы юзер назывался как-то иначе чем ‘approle’, просто замените в этой строке ‘approle’ на что-то другое.
```
export PATRONI_approle_PASSWORD="$POSTGRES_APP_ROLE_PASS"
export PATRONI_approle_OPTIONS="${PATRONI_admin_OPTIONS:-createdb, createrole}"
```
И в последней строчке, когда всё уже готово к старту, мы делаем запуск Patroni сервиса с указанием откуда брать основной конфиг файл:
```
exec /usr/local/bin/patroni /etc/patroni.yml
```
* **Dockerfile**
Dockerfile я решил сделать настолько простым, насколько это только возможно. Но этого вполне достаточно, чтобы сделать билд рабочего Docker-образа. Давайте глянем, что в нем все-таки происходит.
Dockerfile
```
FROM postgres:11
RUN apt-get update -y\
&& apt-get install python3 python3-pip -y\
&& pip3 install --upgrade setuptools\
&& pip3 install psycopg2-binary \
&& pip3 install patroni[zookeeper] \
&& mkdir /data/patroni -p \
&& chown postgres:postgres /data/patroni \
&& chmod 700 /data/patroni
COPY patroni.yml /etc/patroni.yml
COPY patroni-entrypoint.sh ./entrypoint.sh
USER postgres
ENTRYPOINT ["bin/sh", "/entrypoint.sh"]
```
DetailsОдна из главных деталей здесь это директория, которую мы указываем создать внутри контейнера, а также ее владелец и его права. Позже, когда будем деплоить Patroni, нужно будет подобным же образом создать папки на локальной машине, куда мы сможем сделать mount этой директории из контейнера.
```
// владелец должен быть 'postgres', а mode 700
mkdir /data/patroni -p \
chown postgres:postgres /data/patroni \
chmod 700 /data/patroni
...
// устанавливаем в кач-ве активного юзера внутри контейнера
// юзера postgres
USER postgres
```
Файлы, которые мы создали, ранее копируются в имейдж в этих строчках:
```
COPY patroni.yml /etc/patroni.yml
COPY patroni-entrypoint.sh ./entrypoint.sh
```
И, как я уже упомянул ранее, мы хотим запустить этот скрипт сразу после создания контейнера:
```
ENTRYPOINT ["bin/sh", "/entrypoint.sh"]
```
Вот, пожалуй, и вся основная подготовка. Теперь мы готовы создать наш кастомный Patroni имейдж.
```
docker build -t patroni-test .
```
Самое время обсудить последний по списку, но не по важности файл для Patroni — compose yml.
* **docker-compose-patroni.yml**
Правильно написанный compose файл — важная часть общей картины. Разберем, что нам нужно иметь ввиду, настраивая конфигурацию.
docker-compose-patroni.yml
```
version: "3.4"
networks:
patroni_patroni:
external: true
services:
patroni1:
image: patroni-test
networks: [ patroni_patroni ]
ports:
- 5441:5432
- 8091:8091
hostname: patroni1
volumes:
- /patroni1:/data/patroni
environment:
PATRONI_API_CONNECT_PORT: 8091
REPLICATION_NAME: replicator
REPLICATION_PASS: replpass
SU_NAME: postgres
SU_PASS: supass
POSTGRES_APP_ROLE_PASS: appass
deploy:
replicas: 1
placement:
constraints: [node.hostname == floitet]
patroni2:
image: patroni-test
networks: [ patroni_patroni ]
ports:
- 5442:5432
- 8092:8091
hostname: patroni2
volumes:
- /patroni2:/data/patroni
environment:
PATRONI_API_CONNECT_PORT: 8091
REPLICATION_NAME: replicator
REPLICATION_PASS: replpass
SU_NAME: postgres
SU_PASS: supass
POSTGRES_APP_ROLE_PASS: appass
deploy:
replicas: 1
placement:
constraints: [node.hostname == floitet]
patroni3:
image: patroni-test
networks: [ patroni_patroni ]
ports:
- 5443:5432
- 8093:8091
hostname: patroni3
volumes:
- /patroni3:/data/patroni
environment:
PATRONI_API_CONNECT_PORT: 8091
REPLICATION_NAME: replicator
REPLICATION_PASS: replpass
SU_NAME: postgres
SU_PASS: supass
POSTGRES_APP_ROLE_PASS: appass
deploy:
replicas: 1
placement:
constraints: [node.hostname == floitet]
```
DetailsПервое, о чем хочется сказать, это момент с external network, о котором говорилось ранее. Мы хотим разместить Patroni сервисы там же, где мы держим и сервисы Zookeeper. Таким образом мы сможем обращаться к сервисам по именам, и все имена: ’zoo1′, ’zoo2′, ’zoo3′, — которые мы перечислили в patroni.yml, задавая сервера Zookeeper’а, будут работать, как надо.
```
networks:
patroni_patroni:
external: true
```
Нужно отметить, что у нас будут два end point’а: сама база данных и API. И для того и для другого требуется открыть порты:
```
ports:
- 5441:5432
- 8091:8091
...
environment:
PATRONI_API_CONNECT_PORT: 8091
// также нужно убедиться, что в PATRONI_API_CONNECT_PORT мы передаем
// тот же самый, который мы открываем для сервиса
```
Также, нам, конечно, нужно передать все переменные среды, которые мы заявили в entrypoint скрипте. Но и это еще не всё. Есть вопрос с директорией для mount’а, который мы тоже здесь решаем:
```
volumes:
- /patroni3:/data/patroni
```
Как видно из этой строки, ту директорию ’/data/patroni’, которая была создана в Dockerfile, мы монтируем к локальной директории. Так вот эту локальную директорию нам нужно создать. И не только создать, но и выставить правильного юзера и режим доступа, например так:
```
sudo mkdir /patroni3
sudo chown 999:999 /patroni3
sudo chmod 700 /patroni3
// 999 это дефолтный uid для юзера postgres
// эти шаги нужно повторить для каждой ноды Patroni
```
Мы наконец готовы деплоить Patroni кластер:
```
sudo docker stack deploy --compose-file docker-compose-patroni.yml patroni
```
После деплоя в логах сервиса мы должны увидеть что-то в таком ключе:
```
INFO: Lock owner: patroni3; I am patroni1
INFO: does not have lock
INFO: no action. i am a secondary and i am following a leader
```
Было бы печально, если бы мы могли проверить статус кластера и ноды только читая логи. Так что предлагаю коснуться немного способов проверки состояния кластера и начать с самого простого — patronictl. Для этого нужно сначала получить id любого контейнера Patroni:
```
sudo docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a0090ce33a05 patroni-test:latest "bin/sh /entrypoint.…" 3 hours ago Up 3 hours 5432/tcp patroni_patroni1.1.tgjzpjyuip6ge8szz5lsf8kcq
...
```
И потом зайти в контейнер с помощью exec команды:
```
sudo docker exec -ti a0090ce33a05 /bin/bash
// при вызове команды мы должны передать имя кластера
// это параметр 'scope' в patroni.yml ('patroni' в нашем случае)
patronictl list patroni
// и тут ошибка...
Error: 'Can not find suitable configuration of distributed configuration store\nAvailable implementations: exhibitor, kubernetes, zookeeper'
```
Команда patronictl полагается на patroni.yml, чтобы получить информацию о серверах Zookeeper’а. Он не знает, где мы этот файл положили. Так что явно укажем ему путь:
```
patronictl -c /etc/patroni.yml list patroni
// and here is the nice output with the current states
+ Cluster: patroni (6893104757524385823) --+----+-----------+
| Member | Host | Role | State | TL | Lag in MB |
+----------+-----------+---------+---------+----+-----------+
| patroni1 | 10.0.1.93 | Replica | running | 8 | 0 |
| patroni2 | 10.0.1.91 | Replica | running | 8 | 0 |
| patroni3 | 10.0.1.92 | Leader | running | 8 | |
+----------+-----------+---------+---------+----+-----------+
```
PostgreSQL Connection
---------------------
Готово! Теперь мы можем подключаться к Postgres и что-то туда писать. Но делать это мы сможем только из нашей сети «patroni\_patroni». Так что сначала создаем контейнер с подходящим образом, и потом из него уже выполняем команды:
```
docker run --rm -ti --network=patroni_patroni postgres:11 /bin/bash
// доступ к конкретной ноде
psql --host patroni3 --port 5432 -U approle -d postgres
// доступ к лидеру через haproxy
// так что нужно указать какую-либо через флаг '-d'
```
Вот мы и настроили сам кластер Patroni. Но наш сетап был бы неполным, если бы мы на этом и остановились. Есть ещё несколько важных моментов, которые мы должны закрыть, но об этом во [второй части](https://habr.com/ru/company/vsrobotics/blog/534840/).
Все config файлы для первой части можно забрать [отсюда](https://gist.github.com/PeterGriffitz/5347fe26b9839f54e2eed1fe6626e0ef). | https://habr.com/ru/post/534828/ | null | ru | null |
# Ленивые свойства объекта
Возможно, не самый умный экземпляр для линча, но хотелось с чего-нибудь начать)
Для красоты кода и удобства написания модулей, реализовал классы по работе с отдельными информационными сущностями. К примеру, такая вещь как язык интерфейса имеет свой ID, и для большинства операций этой информации вполне достаточно. В то же время, возникают редкие ситуации, когда требуется получить дополнительные сведения о нём (RFC-код, к примеру, узнать который можно, обратившись к отдельной таблице или файлу). Не особо задумываясь, поставил инициализацию переменных в конструктор класса… Проблемы начались, когда переехал на машину с тормозящим SQL-сервером (очень полезное занятие, как оказалось) – тестовая машина падала в таймаут при совершенно безобидных операциях. Не комильфо – процессорное время и SQL-соединения хотелось бы использовать более рационально :) Но использовать специальные методы для подгрузки вроде Fill() тоже не особо хотелось. В итоге пришел к наиболее простому (на мой взгляд) решению из доступных:
> `public class Лентяй
>
> {
>
> private String коллектор;
>
>
>
> public String Значение
>
> {
>
> get
>
> {
>
> if (коллектор == null)
>
> {
>
> коллектор = РесурсоёмкийКодПолученияИнформации();
>
> }
>
> return коллектор;
>
> }
>
> }
>
> }`
Таким образом, практически не производится изменений кода (при создании свойства с именем старой переменной, и последующем переименовании переменной), и в отдельных случаях избыточная нагрузка снижается до нуля. Но сомнения насчёт рациональности всё же остались. | https://habr.com/ru/post/10550/ | null | ru | null |
# Транзакционная память: история и развитие
#### Определение
Параллельное программирование сложно. При использовании систем с общей памятью не обойтись без синхронизации доступа параллельных процессов/потоков к общему ресурсу (памяти). Для этого используются:
* блокировки (mutex);
* алгоритмы без блокировки (lockless, lock-free);
* транзакционная память.
Транзакционная память — технология синхронизации конкурентных потоков. Она упрощает параллельное программирование, выделяя группы инструкций в атомарные транзакции. Конкурентные потоки работают параллельно1, пока не начинают модифицировать один и тот же участок памяти. К примеру, операции добавления узлов в красно-чёрное дерево (анимация в заголовке) способны работать параллельно в нескольких потоках.
**Скрытый текст**
```
/* Move item from one list to another */
int move(list *from, list *to) {
__transaction_atomic {
node *n = pop(from);
push(to, n);
}
}
```
Подход к управлению конкурентностью с использованием транзакционной памяти называют оптимистичным: мы считаем, что потоки работают независимо друг от друга и в редких случаях изменяют одни и те же данные. В таком случае большинство транзакций заканчивается успешно. В противоположность этому, подходы с использованием блокировок пессимистичны: мы полагаем, что потоки будут конфликтовать всегда и всегда запрещаем им находиться в критической секции одновременно.
Если происходит конфликт данных, транзакция отменяется. Отмена транзакции приводит к отмене действий, которые совершал поток за время транзакции. После этого транзакция обычно перезапускается, либо вызывается функция, заранее указанная как «запасной выход», чаще всего откат на использование блокировок.
Плюсы транзакционной памяти:
* относительная простота использования (заключение целых методов в блок транзакции);
* полное отсутствие блокировок и взаимных блокировок;
* повышение уровня параллелизма, а следовательно, и производительности.
Транзакционная память — не серебряная пуля. Есть и минусы:
* при неправильном использовании возможно падение производительности и некорректная работа;
* ограниченность применения — в транзакции нельзя выполнять операции, действие от которых невозможно отменить;
* сложность отладки — поставить breakpoint внутри транзакции невозможно.
#### Рождение технологии
Транзакции в базах данных существуют уже несколько десятилетий. Впервые идея переноса транзакций из мира баз данных в мир параллельного программирования возникла в 1980-х. Развивали и популяризовали технологию [Maurice Herlihy](http://cs.brown.edu/people/mph/), [Ravi Rajwar](http://pages.cs.wisc.edu/~rajwar/), [Nir Shavit](http://people.csail.mit.edu/shanir/). Первые исследования предлагали аппаратные реализации транзакционной памяти, которым не суждено было родиться ещё 30 лет.
В 1990-х появились первые программные реализации технологии, аппаратные реализации подтянулись к 2000-ым.
#### Программные реализации (Software Transactional Memory, STM)
Среди множества реализаций программной транзакционной памяти я хотел бы выделить четыре. Примеры доступны на github: [JIghtuse/tm-experiments](https://github.com/JIghtuse/tm-experiments).
##### Clojure
Clojure — единственный язык, ядро которого поддерживает транзакционную память. Основные конструкции STM: `ref` (ссылка на данные, через которую данные меняются только в транзакции) и `dosync` (блок транзакции).
Подход к STM в Clojure называется управлением конкурентным доступом с помощью многоверсионности (MultiVersion Concurrency Control, [MVCC](http://en.wikipedia.org/wiki/Multiversion_concurrency_control)): хранятся множественные логические версии данных, используемых в транзакции. В течение транзакции поток наблюдает снимок данных на момент её начала.
**Скрытый текст**
Диаграмма версий ссылок в транзакции Clojure.
Транзакции 1 и 2 начинаются в одно и то же время, получая одну копию версии `ref v0`. Внутри транзакций происходит обработка данных, которая меняет значение `ref`. Первая транзакция заканчивается раньше и выигрывает гонку за обновление `ref` новым значением. Затем заканчивается вторая транзакция, и её попытка обновить `ref` проваливается (красная стрелка на диаграмме), поскольку версия `ref` была не той, которая ожидалась. В этом случае транзакция перезапускается, получая копию новой версии `ref`. Поскольку ни одна другая транзакция не пытается изменить `ref`, во второй раз транзакция 2 успешно завершается.
Вычисления в транзакции 3 не меняют значения `ref`, поэтому перезапуск не вызывается и она успешно завершается.
Рассмотрим пример перевода средств между банковскими аккаунтами:
**Скрытый текст**Программа работает в одном потоке, но потокобезопасно.
```
(def account1 (ref 100))
(def account2 (ref 0))
; для чтения текущего значения 'ref' используется (deref refname):
(deref account1)
100
; @refname - эквивалент (deref refname)
@account2
0
(defn transfer [amount from to]
(dosync
(alter from - amount)
(alter to + amount)))
(transfer 100 account1 account2)
100
```
Существуют варианты использования конкурентности, при которых среде позволяется «расслабиться» для достижения дополнительной производительности. К примеру, представьте что вы храните журнал транзакций за день. Порядок транзакций в журнале не важен, если вы знаете, что конечный баланс будет корректным. Если вы получаете два взноса в $100 и $50, очерёдность внесения их в журнал не играет роли. Взнос от двух транзакций коммутативен, и clojure предоставляет конкурентную операцию `commute` как раз для таких случаев.
**Скрытый текст**
```
(defn log-deposit [account amount]
(dosync
(println "Depositing $" amount " into account, balance now: "
(commute account + amount))))
(def myaccount (ref 0))
(log-deposit myaccount 100)
(log-deposit myaccount 50)
; (as good as) equivalent to
(log-deposit myaccount 50)
(log-deposit myaccount 100)
```
##### Haskell
Транзакционная память в Haskell содержится в библиотеке STM, которая входит в Haskell Platform. Некорректное использование транзакционных типов определяется на этапе компиляции программы.
Haskell обладает мощной системой типов. Язык разделяет функции с побочными эффектами и чистые функции. Любое значение типа `IO t` называется действием. Для выполнения какого-либо действия атомарно в Haskell, действие предваряется словом atomically. Вызов atomically с действием в качестве аргумента даёт две гарантии:
* атомарность — эффект от `atomically act` будет виден другим потокам сразу и целиком. Ни один другой поток не способен увидеть состояние внутри атомарного действия, лишь конечное состояние.
* изоляция — во время вызова `atomically act` действие `act` выполняется абсолютно независимо от других потоков. Оно снимает состояние мира при запуске и выполняется в этом состоянии.
`atomically` имеет тип `atomically :: STM a -> IO a`. Действие типа `STM a` — аргумент. Как и действие `IO`, действие `STM` имеет побочные эффекты, но их диапазон значительно уже. В основном в действии `STM` происходит запись или чтение транзакционной переменной `TVar a`:
* `readTVar :: TVar a -> STM a`
* `writeTVar :: TVar a -> a -> STM ()`
Рассмотрим пример перевода средств между аккаунтами банка.**Скрытый текст**
```
import System.IO
import Control.Concurrent.STM
-- Система типов защищает от чтения или записи переменные типа TVar вне транзакции
type Account = TVar Int
withdraw :: Account -> Int -> STM ()
withdraw acc amount = do
bal <- readTVar acc
writeTVar acc (bal - amount)
deposit :: Account -> Int -> STM ()
deposit acc amount = withdraw acc (- amount)
transfer :: Account -> Account -> Int -> IO ()
-- Перевести ’amount’ с аккаунта ’from’ на аккаунт ’to’
transfer from to amount
= atomically (do deposit to amount
withdraw from amount)
showAccount :: Account -> IO Int
showAccount acc = atomically (readTVar acc)
main = do
from <- atomically (newTVar 200)
to <- atomically (newTVar 100)
transfer from to 50
v1 <- showAccount from
v2 <- showAccount to
putStrLn $ (show v1) ++ ", " ++ (show v2)
-- Программа распечатает "150, 150"
```
##### Scala
Реализация STM для Scala (ScalaSTM) разрабатывалась под впечатлением от реализаций в Haskell и Clojure. Помимо Scala, ScalaSTM вызывается из Java и Clojure. Реализация используется в популярном фреймворке для написания параллельных программ Akka.
ScalaSTM предоставляет ячейку `Ref`, изменяемую исключительно внутри транзакции. Структуры данных на основе неизменяемых объектов и `Ref` используются многими потоками.
Рассмотрим реализацию двусвязного потокобезопасного списка с использованием транзакционной памяти. К сожалению, собрать пример на Scala мне не удалось, оставляю это занятие читателю.
**Скрытый текст**Полный пример на github: [github.com/nbronson/scala-stm/blob/master/src/test/scala/scala/concurrent/stm/examples/ConcurrentIntList.scala](https://github.com/nbronson/scala-stm/blob/master/src/test/scala/scala/concurrent/stm/examples/ConcurrentIntList.scala)
Для реализации разделяемой структуры указатели на следующий и предыдущий узел делают потокобезопасными. Если существует возможность того, что один поток записывает переменную в то же время, когда другой получает к ней доступ (читает или записывает), то используют `Ref`. Определим класс для узла списка и инициализируем голову списка. Список кольцевой: при создании указатели головного списка указывают на него же. Эти указатели никогда не равны `null`.
```
import scala.concurrent.stm._
class ConcurrentIntList {
private class Node(val elem: Int, prev0: Node, next0: Node) {
val isHeader = prev0 == null
val prev = Ref(if (isHeader) this else prev0)
val next = Ref(if (isHeader) this else next0)
}
private val header = new Node(-1, null, null)
```
Если `x` является `Ref`, то `x()` получает значение, сохранённое в `x`, а `x() = v` задаёт его равным величине `v`.
`Ref` читаются и записываются только внутри атомарного блока (транзакции). Это проверяется во время компиляции. Далее демонстрируется использование транзакции.
```
def addLast(elem: Int) {
atomic { implicit txn =>
val p = header.prev()
val newNode = new Node(elem, p, header)
p.next() = newNode
header.prev() = newNode
}
}
```
Scala объединяет идеи многих парадигм программирования. Неудивительно, что и в области транзакционной памяти язык имеет самобытные технологии. Вышеупомянутый фреймворк Akka объединяет возможности акторов и транзакционной памяти, получая [агенты](http://doc.akka.io/docs/akka/2.0.4/scala/agents.html#agents-scala) и [транзакторы](http://doc.akka.io/docs/akka/2.0.4/scala/transactors.html#transactors-scala), которые окончательно взорвут вам мозг.
##### C/C++ (GCC 4.7+)
Начиная с версии 4.7, GCC поддерживает транзакционную память. Реализация представляет собой библиотеку времени выполнения libitm, для компиляции указывается флаг -fgnu-tm (-mrtm, -mhle). Библиотека разрабатывалась с оглядкой на [черновик](https://sites.google.com/site/tmforcplusplus/C%2B%2BTransactionalConstructs-1.1.pdf) транзакционных конструкций для C++ (предлагается включение в стандарт языка).
Большинство реализаций аппаратной транзакционной памяти используют принцип наибольшего усилия. Поэтому практичные реализации используют объединение технологий аппаратурной и программной транзакционной памяти. Такие системы называют системами «гибридной транзакционной памяти». К ним относится, в частности, реализация GCC.
В язык вводятся ключевые слова:
* `__transaction_atomic { … }` — указание, что блок кода — транзакция;
* `__transaction_relaxed { … }` — указание, что небезопасный код внутри блока не приводит к побочным эффектам;
* `__transaction_cancel` — явная отмена транзакции;
* `attribute((transaction_safe))` — указание транзакционно-безопасной функции;
* `attribute((transaction_pure))` — указание функции без побочных эффектов.
Для демонстрации использования транзакционной памяти в C будем заполнять гистограмму данных в конкурентных потоках.
**Скрытый текст**Полная реализация на github: [github.com/JIghtuse/tm-experiments/blob/master/histogram/src/hist.c](https://github.com/JIghtuse/tm-experiments/blob/master/histogram/src/hist.c)
Используется один блок транзакции на цикл обновления гистограммы. Библиотека времени выполнения (либо аппаратное обеспечение) определит, когда и какие транзакции перезапустить.
```
#ifdef _USE_TSX
__transaction_atomic {
#endif
for (i = 0; i < d->sz; ++i) {
struct pixel p = d->pixels[i];
unsigned int luminance = rY * p.red + gY * p.green + bY * p.blue;
#if defined _USE_TSX
++histogram[luminance/BORDER];
#elif defined _USE_MUTEX
pthread_mutex_lock(&mut);
++histogram[luminance/BORDER];
pthread_mutex_unlock(&mut);
#endif
}
#ifdef _USE_TSX
}
#endif
```
#### Аппаратные реализации (Hardware Transactional Memory, HTM)
Лишь в последнее время начали появляться аппаратные реализации транзакционной памяти.
### Sun Rock (SPARC v9) 2007-2008
Микропроцессор Rock от компании Sun Microsystems был первым микропроцессором с аппаратной поддержкой транзакционной памяти. 64-разрядный процессор архитектуры SPARC v9 имел 16 ядер.
В 2007 компания объявила о поддержке технологии. Для функционирования транзакционной памяти были добавлены две новые инструкции `chkpt` и `commit` и один новый статусный регистр `cps`. Инструкция `chkpt` использовалась для начала транзакции, а инструкция `commit` для её завершения. При отмене транзакции происходил переход на , в это время можно было проверить регистр `cps` для определения причины отмены. Транзакции прерывались по причинам конфликтов данных, промахов TLB, прерываний, сложных инструкций. Тем не менее, во многих случаях использование транзакционной памяти в процессоре Rock давало преимущества в синхронизации.
В 2008 инженеры Sun представили интерфейс транзакционной памяти и симулятор Adaptive Transactional Memory Test Platform. После покупки компании Sun корпорацией Oracle проект Rock был закрыт: «Этот процессор имел два потрясающих свойства: он был невероятно медленным и потреблял громадное количество энергии. Он был настолько горячим, что им пришлось поставить сверху 12 дюймов охлаждающих вентиляторов, чтобы процессор не перегревался. Было бы безумием продолжать этот проект.»2
### IBM BlueGene/Q (PowerPC A2) 2011
Суперкомпьютер Sequoia с архитектурой BlueGene/Q стал первой коммерческой системой с аппаратной поддержкой транзакционной памяти. Технология работает в 32-мегабайтном кэше второго уровня процессора PowerPC A2 (PowerPC BQC 16C). Данные в кэше имеют метку “версия”, и кэш способен хранить несколько версий одних и тех же данных.
Программа сообщает процессору о начале транзакции, делает свою работу и сообщает, что транзакцию нужно завершить (commit). В случае если другие потоки изменяли те же данные — создавая версии — кэш отклоняет транзакцию и поток пытается провести её вновь. Если других версий данных не появилось, данные модифицируются и транзакция завершается успешно.
Технология версионных меток в PowerPC A2 также используется для спекулятивного выполнения. Вместо ожидания новой версии данных поток может выполнить вычисления с имеющимися данными, спекулятивно производя полезную работу. Если данные были такими же, как и после обновления, поток завершает (commit) работу из кэша. Производительность выше: поток выполнил работу до получения финального значения. В противном случае результаты спекулятивной работы отклоняются и поток производит вычисления с корректными значениями.
Поддержка транзакционной памяти — в некотором роде логическое расширение возможности, давно присутствующей в процессорах PowerPC — “load-link/store-conditional”, или LL/SC. LL/SC — примитивная операция, которая может использоваться как строительный блок для всех потокобезопасных конструкций. Первая часть LL/SC — load-link — используется программой для получения данных из памяти. Далее поток изменяет данные и записывает их обратно в память с помощью store-conditional. Команда завершается успешно, если данные не менялись. В противном случае программа повторяет действия с данными с начала.
Транзакционная память — LL/SC на стероидах: потоки выполняют операции LL на множестве различных областей памяти, а операция завершения транзакции атомарно изменяет все области памяти или отменяет транзакцию (как SC).
Ruud Haring, который представил работу IBM по транзакционной памяти на [Hot Chips](http://www.hotchips.org/), признался, что при реализации компания столкнулась со множеством нетривиальных проблем. При всей сложности, реализация имеет ограничения: она не предоставляет межпроцессорной поддержки транзакций. Проблема не актуальна для Sequoia и в то же время позволяет оценить выигрыш от использования транзакционной памяти.
### IBM zEnterprise EC12 (Z/Architecture) 2012
Первый коммерческий сервер с поддержкой инструкций транзакционной памяти. При использовании транзакционной памяти IBM обнаружила рост производительности в 45% по сравнению с машиной z196 в базе данных DB2 и работах в виртуализированных серверных нагрузках.
### IBM Power8 (Power) 2013
Контроллеры памяти Power 8 поддерживают транзакционную память. Поддержка технологии в ядре Linux появилась начиная с версии ядра 3.9.
*Информации по HTM в Power8 удалось найти не так много, надеюсь она ещё появится.*
### Intel Haswell (x86) 2013
В 2012 компания Intel объявила о введении расширений транзакционной синхронизации (Transactional Syncrhonization Extensions, TSX) в набор инструкций x86. Расширения позволяют программистам помечать отдельные участки кода как транзакции.
В 2013 с выходом поколения процессоров Haswell аппаратная поддержка транзакционной памяти впервые становится доступной на потребительском уровне.
Haswell управляет наборами чтения и записи с гранулярностью линии кэша, отслеживая адреса кэша данных L1. Конфликты определяются с помощью протокола когерентности кэша. Что логично предположить, поскольку задачи определения конфликтов транзакций и поддержки когерентности кэшей очень близки: если значение меняется в одном потоке, но не в других, то что-то неладно.
TSX состоит из двух частей. Аппаратное исключение блокировок (Hardware Lock Elision, HLE) предоставляет простую конвертацию программ на основе блокировок в транзакционные программы, причём полученные программы будут обратно совместимы с существующими процессорами. Ограниченная транзакционная память (Restricted Transactional Memory, RTM) является более полной реализацией транзакционной памяти.
###### Hardware Lock Elision
HLE слегка модифицирует инструкции для изменения участка памяти. Технология добавляет префиксы — инструкции, не производящие каких-либо действий, но меняющие интерпретацию следующей инструкции — для модификации инструкций взятия и освобождения блокировки (XACQUIRE и XRELEASE соответственно).
Между взятием и освобождением блокировки процессор отслеживает участки памяти, которые читают и записывают потоки. В случае конфликта — если два потока модифицируют одни данные, или один поток читает данные, которые другой записывает — процессор отменяет транзакцию при освобождении блокировки. В противном случае, выполнение продолжается нормально.
Таким образом, HLE позволяет общепринятому коду на основе блокировок работать оптимистично. Каждый поток будет считать, что получил блокировку, в то время как остальные потоки могут работать одновременно. До тех пор пока это безопасно, транзакции не отменяются.
Технология обратно совместима с процессорами без поддержки HTM. Операции по управлению блокировкой остаются, но со специальным префиксом. Процессоры Haswell будут учитывать префикс и использовать транзакционное исполнение вместо манипуляций с блокировками. Любой другой процессор будет игнорировать префикс и просто управлять блокировкой, используя традиционное поведение на основе блокировок. Инструкции XACQUIRE и XRELEASE уже существуют, но не несут какого-либо смысла, пока не используются со специфичными инструкциями.
HLE позволяет писать программы и операционные системы, которые будут использовать транзакции на Haswell, повышая уровень параллелизма без блокировок. Код будет работать корректно на текущих процессорах. В итоге, ввод новой возможности будет простым и безопасным.
**HLE на простом примере**Операционные системы реализуют блокировки в ядре как участки памяти, обычно используя типичный для процессора целый тип. Берущий блокировку поток делает нечто с этим участком памяти, к примеру увеличивает значение с 0 на 1. Для освобождения блокировки применяется обратная операция (к примеру, декремент с 1 до 0). Изменения видимы каждому процессорному ядру и каждому потоку в системе, поэтому другие потоки сразу же определяют, что не могут взять блокировку и должны ждать её освобождения (приобретение значения 0).
С префиксами XACQUIRE/XRELEASE попытка взятия блокировки завершается успешно, и процесс полагает, что блокировка принадлежит ему и работает далее. Однако глобального изменения значения блокировки не происходит. Таким образом, поток с блокировкой будет полагать, что её значение равно 1, а остальные потоки системы будут по-прежнему видеть 0. Это позволяет другим потокам одновременно брать блокировку, и процессор вновь будет им лгать. Поток будет видеть блокировку взятой, а другие потоки так не будут считать.
Такое поведение объясняет название HLE: вместо изменения значения с 0 на 1 и обратно, оно просто остаётся равным 0. “Необязательная” запись исчезла.
###### Restricted Transactional Memory
RTM требует большего участия: он уходит от обратной совместимости и вводит три новых инструкции. В то время как HLE неявно использует транзакции, позволяя коду на основе блокировок работать параллельно, RTM делает начало, завершение и прерывание транзакций явными. Поток начинает транзакцию инструкцией XBEGIN, предоставляя “запасную” функцию, которая запускается в случае прерывания транзакции. Транзакция завершается инструкцией XEND, при этом процессор проводит транзакцию если не было конфликтов или прерывает её, переходя в запасную функцию. Транзакции явно прерываются в программе инструкцией XABORT.
Благодаря явному использованию границ и “запасному выходу”, RTM позволяет контролировать транзакции полнее, чем HLE. В долгосрочной перспективе RTM упростит реализацию возможностей транзакций.
#### Выводы
Использование транзакционной памяти — жизнеспособная альтернатива существующим методам синхронизации, которая позволяет упростить параллельное программирование.
*О неточностях перевода, стилистики, и об опечатках просьба писать в личном сообщении.*
#### Примечания
1. О разнице понятий «конкурентность» и «параллелизм» грамотно выразился Rob Pike в выступлении "[Concurrency is not Parallelism](http://talks.golang.org/2012/waza.slide)": «Конкурентность — работа с множеством вещей за один раз, параллелизм — выполнение множества вещей за один раз»
2. Да-да, помимо пачки отличных программных продуктов (OpenSolaris, MySQL, OpenOffice) Oracle забросила и перспективную аппаратную технологию
#### Источники
* [Software transactional memory — Wikipedia](http://en.wikipedia.org/wiki/Software_transactional_memory)
* [Clojure STM — What? Why? How? — sw1nn](http://sw1nn.com/blog/2012/04/11/clojure-stm-what-why-how/)
* [Software transactional memory — HaskellWiki](http://www.haskell.org/haskellwiki/Software_transactional_memory)
* [Software Transactional Memory — School of Haskell | FP Complete](https://www.fpcomplete.com/school/advanced-haskell/beautiful-concurrency/3-software-transactional-memory)
* [ScalaSTM — Quick Start](http://nbronson.github.io/scala-stm/quick_start.html)
* [Software Transactional Memory in GCC](http://www-users.cs.umn.edu/~boutcher/stm/)
* [Web Resources about Intel® Transactional Synchronization Extensions](https://software.intel.com/en-us/blogs/2013/06/07/resources-about-intel-transactional-synchronization-extensions)
* [Rock (processor) — Wikipedia](http://en.wikipedia.org/wiki/Rock_(processor))
* [Rock (процессор) — Википедия](http://ru.wikipedia.org/wiki/Rock_(%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81%D0%BE%D1%80)
* [Sequoia — BlueGene/Q, Power BQC 16C 1.60 GHz, Custom | TOP500 Supercomputer Sites](http://top500.org/system/177556)
* [IBM’s new transactional memory: make-or-break time for multithreaded revolution | Ars Technica](http://arstechnica.com/gadgets/2011/08/ibms-new-transactional-memory-make-or-break-time-for-multithreaded-revolution/)
* [IBM Sequoia named world's fastest supercomputer — E & T Magazine](http://eandt.theiet.org/news/2012/jun/ibm-sequoia.cfm/)
* [You won't find this in your phone: A 4GHz 12-core Power8 for badass boxes • The Register](http://www.theregister.co.uk/2013/08/27/ibm_power8_server_chip/)
* [Transactional Synchronization Extensions — Wikipedia](http://en.wikipedia.org/wiki/Transactional_Synchronization_Extensions)
* [Transactional memory going mainstream with Intel Haswell | Ars Technica](http://arstechnica.com/business/2012/02/transactional-memory-going-mainstream-with-intel-haswell/)
* [Intel's Haswell brings transactional memory tech | bit-tech.net](http://www.bit-tech.net/news/hardware/2012/02/09/intel-haswell-tsx/) | https://habr.com/ru/post/221667/ | null | ru | null |
# Разбор задач. Бинпоиск_1
Здравствуйте, уважаемые хабровчане. Серия статей содержит разбор задач, которые дают в 8 классе на уроках информатики в Челябинском физико-математическом лицее №31. Немного истории… Наш лицей — одно из сильнейших учебных заведений России, который в рейтинге по конкурентоспособности выпускников занимает 5 место, уступив школам Москвы и Санкт-Петербурга. Ученики регулярно побеждают на олимпиадах всероссийского и международного уровня.
Данная статья лишена теории, она содержит только способы решения задач. [Подробно про бинпоиск описано здесь.](https://neerc.ifmo.ru/wiki/index.php?title=%D0%A6%D0%B5%D0%BB%D0%BE%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9_%D0%B4%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D1%8B%D0%B9_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA)
**Так вот, перейдем к задачам.** Эти задачи подразумевают собой использование бинарного поиска, в том числе бинпоиска по ответам. Как мы знаем бинпоиск — это алгоритм поиска объектов по заданному признаку в множестве объектов. Применяем для отсортированных по возрастанию/убыванию списков. Всего 4 задачи, 2 из которых направлены на применение *"алгоритма без изюминок"*.
#### [**Левый и правый двоичный поиск**](https://informatics.mccme.ru/mod/statements/view3.php?chapterid=111728#1)
В этой задаче сначала нужно считать длины первой и второй строки, затем каждую следующую строку записать в список. После мы берем каждый элемент второго списка и ищем для него правую и левую границу. Можно заметить, что если число отсутствует в списке, итоговые значения левой границы и правой границы в левом и правом бинпоиске равны.
```
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
for x in b:
left = -1
right = len(a)
#левый бинпоиск, который ищет левую границу
while right - left > 1:
middle = (right + left) // 2
if a[middle] < x:
left = middle
else:
right = middle
left_1 = -1
right_1 = len(a)
#правый бинпоиск, который ищет правый границу
while right_1 - left_1 > 1:
middle = (right_1 + left_1) // 2
if a[middle] <= x:
left_1 = middle
else:
right_1 = middle
if left == left_1 and right == right_1:
print(0)
#возращение к следующей итерации с пропуском, что идет после него
continue
if right == left_1:
print(right + 1, right + 1)
else:
print(right + 1, left_1 + 1)
```
#### [**Приближенный двоичный поиск**](https://informatics.mccme.ru/mod/statements/view3.php?chapterid=2#1)
Вот эта задачка с изюминкой! Тут надо так преобразовать поиск, чтобы выполнялось даже для чисел, которых нет в данном для поиска списке. Здесь мы также ищем середину в “граничном списке”, затем элемент, который посередине сравниваем с числом, если он меньше него, мы записываем в левую границу(который индекс) индекс середины + 1(то есть не включаем прошлую середину в граничный список), в ином случае в правую границу записываем индекс середины. Все это делаем, пока левая граница меньше правой. После нахождения left и right рассматриваем случай, когда числа нет в списке и расстояние до того, что левее меньше или равно, чем то, что правее. Поэтому выводим a[left — 1], в ином случае a[left].
```
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
for x in b:
left = 0
right = n - 1
while left < right:
middle = (left + right) // 2
if a[middle] < x:
left = middle + 1
else:
right = middle
if left > 0 and a[left] != x and abs(a[left - 1] - x) <= abs(a[left] - x):
print(a[left - 1])
else:
print(a[left])
```
#### [**Квадратный корень и квадратный квадрат**](https://informatics.mccme.ru/mod/statements/view3.php?chapterid=111403#1)
Тадам! Задача на бинарный поиск по ответу. Для начала из библиотеки math подключим функцию sqrt, которая вычисляет квадратный корень, после определим для левой границы 0, а для правой 1e10, то есть 10 миллиардов, исходя из ограничений, которые указаны в условии. Далее как в типичном бинпоиске ищем середину, позже сравниваем. Но что тут интересного? Тут middle — это x в уравнении. Ввиду этого определяем значение уравнения и сверяем с реальным ответом(т.е. С). Ну и двигаем границы, до тех пор, пока разность границ не будет меньше или равна 10-ти миллиардным, это и есть точность измерения. Позже умножаем на миллион, округляем, переводим в int и вещественное деление на тот же миллион.
```
from math import sqrt
c = float(input())
left = 0
right = 1e10#1 c 10-тью нулями
while right - left > 10e-10:#10 нулей и 1
middle = (left + right) / 2
if middle * middle + sqrt(middle) >= c:
right = middle
else:
left = middle
#умножаем на 10e6, округляем, преобразуем в int, делим на 10e6
print(int(round(left*10e6))/10e6)
```
#### [**Очень Легкая Задача**](https://informatics.mccme.ru/mod/statements/view3.php?chapterid=490#1)
Разбор на эту задачу уже есть, поэтому приложу только код.
```
n, x, y = map(int, input().split())
min1 = min(x, y)
if n == 1:
print(min1)
else:
left = 0
right = n * (x + y - min1 + 1)
while right - left > 1:
middle = (right + left) // 2
if n - 1 <= middle // x + middle // y:
right = middle
else:
left = middle
print(min1 + left + 1)
```
[Для закрепления материала можно порешать задачи отсюда.](https://informatics.mccme.ru/course/view.php?id=3) | https://habr.com/ru/post/443244/ | null | ru | null |
# Какая фигура из одинаковых плоских предметов будет дальше всего выглядывать за край стола?
В ноябре журнал Quanta озадачил своих читателей вопросами, касающимися составления фигур из одинаковых плоских предметов (таких, как монеты или костяшки домино). В этой статье даны как вопросы, так и подробные ответы на них.
Вопрос 1
--------
> В классической задаче построения нависающей фигуры все блоки должны быть однородными, одинаковыми по размеру и форме, и их длина принимается за единицу. На каждом уровне фигуры может быть только один блок. Блоки нельзя соединять или склеивать. Если у вас есть пять таких блоков, на какую максимальную длину может высунуться конец верхнего блока за край стола, на котором они лежат? Можете ли вы вывести формулу для максимального нависания при использовании n блоков?
Физически задача требует сбалансировать крутящий момент фигуры с двух сторон края стола. Крутящий момент каждой стороны находится произведением массы этой стороны и расстояния от центра масс до края. Когда центр масс всей фигуры находится над краем, на обе её стороны действует одинаковый момент, и общий крутящий момент системы равен нулю. Для составного объекта общий крутящий момент для любой грани можно найти, сложив крутящие момент всех составных частей. Поэтому мы можем разделить и властвовать над изначальной задачей, рассматривая только изменения, происходящие при добавлении нового блока к существующей стопке, нечто вроде математической индукции (назовём это физической индукцией).
Рассмотрим стопку из n-1 блоков, каждый из которых весит одну единицу веса и имеет длину в одну единицу длины. Стопка сбалансирована на краю стола. Представьте, что линия взгляда направлена вдоль края стола, и стол слева – то есть, свисающие концы блоков высовываются вправо. Поскольку стопка сбалансирована на краю, центр масс находится прямо над краем, и её крутящий момент равен нулю. Теперь представим, что мы подняли всю стопку вертикально, и расположили ещё один блок под ней так, чтобы его правый край был вровень с краем стола. На практике это может оказаться сложным, но в мысленном эксперименте это просто.
Мы добавили немного стабильности стопке, добавив n-ный блок снизу, поскольку центр масс всей стопки немного сместился влево. Обозначим это смещение х. n блоков весят n единиц, и у них появился общий крутящий момент x\*n вокруг края стола, направленный влево. Вспомним, что у стопки из n-1 блоков общий момент нулевой. Мы добавили только момент нового блока – массой в одну единицу массы и с расстоянием до центра масс от края стола в половину единицы длины.
Получается, что x\*n = 1/2, а значит, x = 1/2n, где x – расстояние до нового центра масс от края стола.
Это значит, что если вы сдвинете всю стопку из n блоков вправо на 1/2n длины, она будет идеально сбалансирована на краю – и это максимально возможный сдвиг. Для завершения построения индукции отметим, что максимальный свес первого блока с края стола составляет 1/2 единицы длины.
Поэтому, для пяти блоков мы подставляем в формулу n для каждого уровня от 1 до пяти, чтобы получить максимальный свес:
```
x=1/2+1/4+1/6+1/8+1/10=137/120=1,141(6)
```
Видно, что если начать сверху и затем добавлять блоки вниз, каждый сдвиг составит половину от обратного количества имеющихся блоков. Такие последовательности из обратных чисел известны, как гармонические ряды. Такой ряд медленно расходится, и при устремлении n к бесконечности тоже стремится к бесконечности.
Общая формула суммы для n блоков получается суммированием всех членов ряда. Получается половина n-ного гармонического члена, который можно записать, как:
Вопрос 2
--------
> Представьте, что у вас есть те же пять блоков, и вы хотите поставить на самый верхний из них некое украшение, в точке, удалённой на четверть длины блока от свисающего конца. Все блоки весят по одной единице веса, а украшение весит одну пятую от блока. Какая теперь длина максимального нависания? Как это меняет основную формулу?
Сначала рассмотрим первый блок с украшением, стоящим на нём, и лежащий так, что его правый край находится на одном уровне с краем стола. Центр масс блока без украшения находится в половине единицы длины от края стола. Украшение сдвинет его вправо, допустим, на x. Масса украшения 1/5, а его расстояние от нового центра масс будет 1/4-х. Приравняем моменты и получим х = 1/5\*(1/4-х), следовательно, х = 1/24. Из-за украшения необходимо подвинуть первый блок влево на 1/24 длины, поэтому максимальный свес составляет теперь 11/24 вместо 1/2.
Для последующих блоков можно применить ту же индукцию, что и в первом вопросе. Получаем уравнение х(n+1/5) = 1/2, которое для n блоков упрощается до 1/2(n+1/5). Это даёт нам последовательность 1/24 + 5/12 + 5/22 + 5/32 + 5/42…, что приводит к максимальному нависанию в 1,057 для пятиуровневой фигуры. Отметим, что нависание первого блока не укладывается в общую схему благодаря дополнительному весу украшения. Тем не менее, появляется простая гармоническая последовательность, через которую легко можно высчитать окончательную сумму.
Вопрос 3
--------
> Представьте, что вы соревнуетесь с другом в игре, в которой необходимо создавать нависающие структуры. Сначала у вас есть по одному блоку. Вы ставите свои блоки с любым нависанием от края стола. Затем вам выдают случайное, но одинаковое количество дополнительных блоков от одного до четырёх. Каждый ход начинается с изначального блока в качестве основы, положение которого потом менять нельзя, и с дополнительного набора от одного до четырёх блоков. Как сильно вам нужно вынести изначальный блок за край стола, чтобы у вас оказался максимально возможный свес после большого количества ходов?
Поскольку вероятность наличия от двух до пяти блоков одинакова, вам нужно максимизировать сумму, обозначающую максимальный свес для этих четырёх случаев. Для стопки из 2-5 блоков есть оптимальная позиция первого блока, дающая максимальный свес всей стопки. Если построить на графике наибольший свес для каждого из четырёх возможных размеров следующей стопки, получится два линейных графика и два графика в виде перевёрнутой V. Их вершины указывают оптимальную начальную позицию изначального блока для стопок из 3-4 блоков. Просуммировав графики, получим общий график свеса, резко меняющий направление в каждой из четырёх оптимальных позиций. Оказывается, что наилучший общий свес достигается в оптимальной позиции для трёх блоков, после которой график идёт вниз. Поэтому нужно располагать изначальный блок в предположении, что вам дадут три дополнительных блока, и свес составит 1/6 единицы длины.
Читатели указали несколько ограничений, запрещающих этому гипотетическому математическому мосту уходить в бесконечность: ветер, неравномерность, отсутствие бесконечной точности, эластичность или недостаточная твёрдость блоков и стола, и т.д. Это, конечно, правильно. К этому можно добавить кривизну Земли и отсутствие бесконечного пространства. Какое из этих ограничений быстрее всего обвалит нашу стопку? Для ответа на этот вопрос полезно изучить смежный с ним: если забыть о свесах с края и просто складывать блоки Jenga один на другой, математически ограничения на высоту башни нет. Но развалят её небольшие несовершенства в блоках и неточность в их построении, а роль последней соломинки сыграет вибрация или ветер. То же верно и для нашей свешивающейся фигуры. Если скорректировать все эти факторы, в какой-то момент сыграет и жёсткость блоков, когда нижние блоки немного искривятся и отойдут от горизонтали из-за общего крутящего момента всех блоков выше, что приведёт к соскальзыванию верхних блоков.
Я упоминал, что достичь наибольшего свеса можно, если допустить использование нескольких блоков на одном уровне. Как отметило несколько читателей, оптимальное решение этой задачи описано в работе 2009 года «Максимальный свес» [[Maximum Overhang](http://www.maa.org/sites/default/files/pdf/upload_library/22/Robbins/Patterson2.pdf), by Paterson, Peres, Thorup, Winker and Zwick]. Мне небольшие конструкции, сделанные по методике Патерсона-Цвика, напоминают зимородка. Большие выглядят как волшебные лампы. Для свеса в две единицы длины эти схемы в 2-3 раза эффективнее классических гармонических свесов, и достигают такого свеса при помощи 14 блоков вместо 32. К сожалению, их математика слишком сложна для данной статьи.
 | https://habr.com/ru/post/400153/ | null | ru | null |
# Аудит безопасности на сервере. Поиск по жураналу безопасности. Power Powershell
Аудит журнала безопасности помог моему коллеге контролировать практически любые действия сотрудников, которые имеют хоть какой-то доступ к серверам или ActiveDirectory.
В топике будет много кода, который, надеюсь, будет вам полезен.
Первым делом необходимо было определить список событий, которые необходимо было отслеживать. Чтобы уменьшить количество текста, я создала процедуру, которая по ID события выдает ее описание:
```
Function DefineReason ($Id){
switch ($Id){
4741{ Return "Создана учетна запись компьютера"}
4742{ Return "Изменена учетна запись компьютера" }
4743{ Return "Удалена учетная запись компьютера"}
4727{ Return "Создана глобальная группа с включенной безопасностью"}
4728{ Return "Добавлен пользователь к глобальной группе с включенной безопасностью"}
4729{ Return "Удален пользователь из глобальной группы с включенной безопасностью"}
4730{ Return "Удалена глобальная группа с включенной безопасностью"}
4731{ Return "Создана локальная группа с включенной безопасностью"}
4732{ Return "Добавлен пользователь в локальную группу с включенной безопасностью"}
4733{ Return "Удален пользователь из локальной группы с включенной безопасностью"}
4734{ Return "Удалена локальная группа с включенной безопасностью"}
4735{ Return "Изменена локальная группа с включенной безопасностью"}
4737{ Return "Изменена глобальная группа с включенной безопасностью"}
4743{ Return "Удалена учетная запись компьютера"}
4754{ Return "Создана универсальная группа с включенной безопасностью" }
4755{ Return "Изменена универсальная группа с включенной безопасностью"}
4756{ Return "Добавлен пользователь к универсальной группе с включенной безопасностью"}
4757{ Return "Удален пользователь из универсальной группы с включенной безопасностью"}
4758{ Return "Удалена универсальная группа с включенной безопасностью"}
4764{ Return "Изменен тип группы"}
4720{ Return "Создана учетна запись"}
4722{ Return "Включена учетна запись"}
4724{ Return "Сброс пароля пользователя"}
4725{ Return "Учетна запись пользователя отключена"}
4726{ Return "Учетна запись пользователя удалена"}
4738{ Return "Изменена учетна запись"}
4740{ Return "Учетна запись пользователя заблокирована"}
4767{ Return "Учетна запись пользователя разблокирована"}
4780{ Return "Список управления Доступом был установлен на учетные записи, которые являются членами группы администраторов"}
4781{ Return "Было изменено имя учетной записи"}
4794{ Return "Была предпринята попытка задать режим восстановления служб каталогов"}
5376{ Return "Диспетчер учетных данных: учетные данные были сохранены"}
5377{ Return "Диспетчер учетных данных: учетные данные были востановлены из резервной копии"}
4825{ Return "Запрeщен доступ к удаленному рабочемо столу, не входит в группу RDP"}
1102{ Return "Удален журнал Security"}
}
}
```
Затем понадобилось описать события, которые отслеживаются по маске доступа:
```
# Функция определения описания события по маске доступа
Function DefineReasonByAccessMask ($AccessMask){
switch($AccessMask){
"0xc0000064" { Return "Имя пользователя не существует" }
"0xc000006A" { Return "Верное имя, но не правильный пароль"}
"0xc0000234" { Return "Пользователь заблокирован" }
"0xc0000072" { Return "Учетка деактивирована"}
"0xc0000006F" { Return "Вход вне рабочее время"}
"0xc00000070" { Return "Ограничение локальной станции"}
"0xc00000193" { Return "Срок действия учетной записи истек"}
"0xc00000071" { Return "Срок действия пароля Истек"}
"0xc00000224" { Return "Необходимо сменить пароль при следующем входе"}
"0xc000015b" { Return "Пользователю запрещен вход на этой машине"}
"0xc000006d" { Return "Неверный пароль"}
}
}
```
Теперь мы знаем, за чем хотим следить. Следующий шаг при разработке скрипта по аудиту — это получение журнала безопасности в формате XML, так как если событий много, то построчная обработка занимает достаточно большое количество времени.
Чтобы получить события из журнала можно использовать одну из команд, в каждой из которых есть свои преимущества и недостатки:
#### 1. Get-LogEvent security
Преимущества:
— быстрый доступ к свойствам события;
— не нужна предварительная обработка для доступа к свойствам события.
Недостатки:
— доступ только с системному журналу безопасности, который хранится по пути: Windows/System32/winevt/security.evtx;
— долгая обработка содержимого тега . Обработка происходит путем построчной сепарации с ликвидацией спецсимволов.
#### 2. Get-WinEvent –path “D:/”
Преимущества:
— быстрая обработка журнала;
— доступ к любому журналу. Главное прописать полный путь.
Недостатки:
— для обработки полученного журнала требуется предварительная обработка.
```
Try {
$Events = Get-WinEvent -FilterHashTable $MyFilter
} Catch {"No events were found in $Log"; Continue}
ForEach ($Raw_Event in $Events)
{
Try{
$EventXML = [xml]$Raw_Event.ToXML()
} Catch {Write-Host "Unable to convert an event to XML"}
$Event = @{}
ForEach ($object in $EventXML.Event.EventData.Data) {
$Event.Add($object.name,$object.'#text')
}
$Event.Add("ID",$Raw_Event.ID)
$Event.Add("TimeCreated",$Raw_Event.TimeCreated)
```
Следующий шаг после того как мы получили доступ к журналу, это вытягивать из журнала требуемые события и принимать по ним соответствующие решения. В большинстве случаев – это отправка информационного сообщения на почту или логирование в отдельный файл.
Задать параметры, по которым будем вытягивать информацию, возможно, используя интерфейсное решения. Диалоговое окно с вводом параметров.
1. Первый параметр предполагает, что журналы периодически экспортируются в определенный каталог, который и следует задать. Если журнал один, то задается стандартный каталог для хранения журналов: «C:\Windows\System32\winevt\Logs».
2. Второй параметр определяет сервер, по которому будет искаться логи. Если сервер один, то ставим «\*».
3. Третий параметр предельно понятен: \* — ищем события за весь период, если задана дата, например, 30.11.2015, то ищем за эту дату. Поиск за период осуществляется вводом начальной и конечной даты через тире (01.11.2015-30.11.2015).
4. Указываем путь для сохранения результата работы, например, «D:\log.log». Ниже приведен код, позволяющий построить интерфейс для скрипта:
```
$objForm = New-Object System.Windows.Forms.Form
$objForm.Text = "Ввод исходных данных"
$objForm.Size = New-Object System.Drawing.Size(300,450)
$objForm.StartPosition = "CenterScreen"
# Events path
$objLabel1 = New-Object System.Windows.Forms.Label
$objLabel1.Location = New-Object System.Drawing.Size(10,20)
$objLabel1.Size = New-Object System.Drawing.Size(280,40)
$objLabel1.Text = "Введите полный путь к журналам в формате`nD:/.../.../ :"
$objForm.Controls.Add($objLabel1)
$objTextBox1 = New-Object System.Windows.Forms.TextBox
$objTextBox1.Location = New-Object System.Drawing.Size(10,60)
$objTextBox1.Size = New-Object System.Drawing.Size(280,20)
$objForm.Controls.Add($objTextBox1)
#Find Server mode
$objLabel2 = New-Object System.Windows.Forms.Label
$objLabel2.Location = New-Object System.Drawing.Size(10,90)
$objLabel2.Size = New-Object System.Drawing.Size(280,30)
$objLabel2.Text = "1. * - по всем серверам.`n2. Укажите Сервер."
$objForm.Controls.Add($objLabel2)
$objTextBox2 = New-Object System.Windows.Forms.TextBox
$objTextBox2.Location = New-Object System.Drawing.Size(10,120)
$objTextBox2.Size = New-Object System.Drawing.Size(280,30)
$objForm.Controls.Add($objTextBox2)
#Type Events Mode
$objLabel3 = New-Object System.Windows.Forms.Label
$objLabel3.Location = New-Object System.Drawing.Size(10,150)
$objLabel3.Size = New-Object System.Drawing.Size(280,45)
$objLabel3.Text = "1. * - по всем событиям.`n2. Укажите событие.`n3. Перечислите через запятую события"
$objForm.Controls.Add($objLabel3)
$objTextBox3 = New-Object System.Windows.Forms.TextBox
$objTextBox3.Location = New-Object System.Drawing.Size(10,195)
$objTextBox3.Size = New-Object System.Drawing.Size(280,30)
$objForm.Controls.Add($objTextBox3)
#Date Events mode
$objLabel4 = New-Object System.Windows.Forms.Label
$objLabel4.Location = New-Object System.Drawing.Size(10,225)
$objLabel4.Size = New-Object System.Drawing.Size(280,60)
$objLabel4.Text = "1. * - за весь период.`n2. Укажите дату в формате ДД.ММ.ГГГГ.`n3. Укажите интервал в формате ДД.ММ.ГГГГ-ДД.ММ.ГГГГ"
$objForm.Controls.Add($objLabel4)
$objTextBox4 = New-Object System.Windows.Forms.TextBox
$objTextBox4.Location = New-Object System.Drawing.Size(10,285)
$objTextBox4.Size = New-Object System.Drawing.Size(280,30)
$objForm.Controls.Add($objTextBox4)
#Save Result
$objLabel5 = New-Object System.Windows.Forms.Label
$objLabel5.Location = New-Object System.Drawing.Size(10,315)
$objLabel5.Size = New-Object System.Drawing.Size(280,30)
$objLabel5.Text = "Путь для сохранения результата поиска"
$objForm.Controls.Add($objLabel5)
$objTextBox5 = New-Object System.Windows.Forms.TextBox
$objTextBox5.Location = New-Object System.Drawing.Size(10,345)
$objTextBox5.Size = New-Object System.Drawing.Size(280,30)
$objForm.Controls.Add($objTextBox5)
# Кнопки ОК и Отмена. Обработчки добавлен только на нажатие кнопки ОК.
$OKButton = New-Object System.Windows.Forms.Button
$OKButton.Location = New-Object System.Drawing.Size(75,380)
$OKButton.Size = New-Object System.Drawing.Size(75,23)
$OKButton.Text = "OK"
$OKButton.Add_Click({$objForm.Close()})
$objForm.Controls.Add($OKButton)
$OKButton.DialogResult=[System.Windows.Forms.DialogResult]::OK
$CancelButton = New-Object System.Windows.Forms.Button
$CancelButton.Location = New-Object System.Drawing.Size(150,380)
$CancelButton.Size = New-Object System.Drawing.Size(75,23)
$CancelButton.Text = "Cancel"
$CancelButton.Add_Click({$objForm.Close()})
$objForm.Controls.Add($CancelButton)
$objForm.Topmost = $True
$objForm.Add_Shown({$objForm.Activate()})
$dialogResult = $objForm.ShowDialog()
# Описание интерфейса закончено
```
Получаем введенные данные:
```
# Определяем входящие параметры
if ($dialogResult -eq "OK"){
$Log_Path = $objTextBox1.Text
$FindServerMode = $objTextBox2.Text
$TypeEventsMode = $objTextBox3.Text
$DateEventsmode = $objTextBox4.Text
$SaveResult = $objTextBox5.Text
}
```
Если в поле дата есть символ "-", значит введен интервал, если этот символ введен ошибочно — ваши проблемы. Проводим сепарацию по символу "-", определяем начальную и конечную дату диапазона.
```
if ($DateEventsmode -match "-"){
$x = $DateEventsmode.split("-")
$StartDate = $x[0]
$EndDate = $x[1]
$StartDate = [DateTime]::parse($StartDate)
$StartDate
$EndDate = [DateTime]::parse($EndDate)
$EndDate
}
```
Если во введенном поле нет ни "-", ни "\*", то значит введена конкретная дата.
```
if ($DateEventsmode -notmatch "-" -and $DateEventsmode -ne "*"){
$StartDate1 = [DateTime]::parse($DateEventsmode)
}
```
1. Поиск по всем серверам, по всем событиям, за весь период:
```
if ($FindServerMode -eq "*" -and $DateEventsmode -eq "*" -and $TypeEventsMode -eq "*" -and $Log_Path -ne ""){
Write-host "вошли в 1"
$ALL_LOGS = Get-ChildItem -Path $Log_Path -recurse| Where {$_.Extension -eq ".evtx"} | Sort LastWriteTime
$ALL_LOGS
foreach ($Log in $ALL_LOGS){
$LogFile = "Audit EventLog Security" +"`n"
($Log).FullName
$MyFilter = @{Path=($Log).FullName}
$i=0
Try {$Events = Get-WinEvent -FilterHashTable $MyFilter} Catch {"No events were found in $Log"; Continue}
ForEach ($Raw_Event in $Events){
Try{$EventXML = [xml]$Raw_Event.ToXML()} Catch {Write-Host "Unable to convert an event to XML"}
$Event = @{}
ForEach ($object in $EventXML.Event.EventData.Data) {
$Event.Add($object.name,$object.'#text')
}
$Event.Add("ID",$Raw_Event.ID)
$Event.Add("TimeCreated",$Raw_Event.TimeCreated)
$LogFile+= "EventID: " + $Raw_Event.ID +"`n"
$LogFile+= "Target User Name: " + $Event.TargetUserName +"`n"
$LogFile+= "Target Domain Name: " + $Event.TargetDomainName +"`n"
$LogFile+= "Status: " + $Event.Status +"`n"
$LogFile+= "TimeGenerated: " + $Event.TimeCreated +"`n"
$LogFile+= "Workstation Name: " + $Event.WorkstationName +"`n"
$LogFile+= "IpAddress: " + $Event.IpAddress +"`n"
$LogFile+= "Computer: " + [xml]$Raw_Event.ToXML().Event.System.Computer +"`n"
$Reason = DefineReason -Id $Raw_Event.ID
$AccessM = DefineReasonByAccessMask -AccessMask $Event.Status
$LogFile+= "Reason(RU): " + $Reason + " "+ $AccessM +"`n"
$LogFile+= "Reason(SYS): " + $Event.Message +"`n"
$LogFile+= "----------------------------------------------------------------`n"
$i++
}
}
}
```
2. Поиск по всем серверам, по фильтру событий, за весь период:
```
if ($FindServerMode -eq "*" -and $DateEventsmode -eq "*" -and $TypeEventsMode -ne "*" -and $Log_Path -ne ""){
Write-host "вошли в 2"
$ALL_LOGS = Get-ChildItem -Path $Log_Path | Where {$_.Extension -eq ".evtx"} | Sort LastWriteTime
$ALL_LOGS
foreach ($Log in $ALL_LOGS){
$LogFile = "Audit EventLog Security" +"`n"
($Log).FullName
$MyFilter = @{Path=($Log).FullName;ID=$TypeEventsMode}
Try {$Events = Get-WinEvent -FilterHashTable $MyFilter} Catch {"No events were found in $Log"; Continue}
ForEach ($Raw_Event in $Events){
Try{$EventXML = [xml]$Raw_Event.ToXML()} Catch {Write-Host "Unable to convert an event to XML"}
$Event = @{}
ForEach ($object in $EventXML.Event.EventData.Data) {
$Event.Add($object.name,$object.'#text')
}
$Event.Add("ID",$Raw_Event.ID)
$Event.Add("TimeCreated",$Raw_Event.TimeCreated)
$LogFile+= "EventID: " + $Event.ID +"`n"
$LogFile+= "Target User Name: " + $Event.TargetUserName +"`n"
$LogFile+= "Target Domain Name: " + $Event.TargetDomainName +"`n"
$LogFile+= "Status: " + $Event.Status +"`n"
$LogFile+= "TimeGenerated: " + $Event.TimeCreated +"`n"
$LogFile+= "Workstation Name: " + $Event.WorkstationName +"`n"
$LogFile+= "IpAddress: " + $Event.IpAddress +"`n"
$LogFile+= "Computer: " + [xml]$Raw_Event.ToXML().Event.System.Computer +"`n"
$Reason = DefineReason -Id $Raw_Event.ID
$AccessM = DefineReasonByAccessMask -AccessMask $Event.Status
$LogFile+= "Reason(RU): " + $Reason + " "+ $AccessM +"`n"
$LogFile+= "Reason(SYS): " + $Event.Message +"`n"
$LogFile+= "----------------------------------------------------------------`n"
}
}
}
```
3. Поиск по всем серверам, по всем событиям, за диапазон:
```
if ($FindServerMode -eq "*" -and $DateEventsmode -match "-" -and $TypeEventsMode -eq "*" -and $Log_Path -ne ""){
Write-host "вошли в 3"
$ALL_LOGS = Get-ChildItem -Path $Log_Path -Recurse| Where {$_.Extension -eq ".evtx" } | Sort LastWriteTime
$ALL_LOGS
foreach ($Log in $ALL_LOGS){
$LogFile = "Audit EventLog Security" +"`n"
($Log).FullName
$StartDate
$EndDate
$MyFilter = @{Path=($Log).FullName}
Try {$Events = Get-WinEvent -FilterHashTable $MyFilter} Catch {"No events were found in $Log"; Continue}
ForEach ($Raw_Event in $Events){
Try{$EventXML = [xml]$Raw_Event.ToXML()} Catch {Write-Host "Unable to convert an event to XML"}
$Event = @{}
ForEach ($object in $EventXML.Event.EventData.Data) {
$Event.Add($object.name,$object.'#text')
}
$Event.Add("ID",$Raw_Event.ID)
$Event.Add("TimeCreated",$Raw_Event.TimeCreated)
$Event.TimeCreated
if ($Event.TimeCreated -gt $StartDate -and $Event.TimeCreated -lt $EndDate){
$LogFile+= "EventID: " + $Raw_Event.ID +"`n"
$LogFile+= "Target User Name: " + $Event.TargetUserName +"`n"
$LogFile+= "Target Domain Name: " + $Event.TargetDomainName +"`n"
$LogFile+= "Status: " + $Event.Status +"`n"
$LogFile+= "TimeGenerated: " + $Event.TimeCreated +"`n"
$LogFile+= "Workstation Name: " + $Event.WorkstationName +"`n"
$LogFile+= "IpAddress: " + $Event.IpAddress +"`n"
$LogFile+= "Computer: " + [xml]$Raw_Event.ToXML().Event.System.Computer +"`n"
$Reason = DefineReason -Id $Raw_Event.ID
$AccessM = DefineReasonByAccessMask -AccessMask $Event.Status
$LogFile+= "Reason(RU): " + $Reason + " "+ $AccessM +"`n"
$LogFile+= "Reason(SYS): " + $Event.Message +"`n"
$LogFile+= "----------------------------------------------------------------`n"
}
}
}
}
```
4. Поиск по всем серверам, по всем событиям, за определенную дату:
```
if ($FindServerMode -eq "*" -and $DateEventsmode -notmatch "-" -and $DateEventsmode -ne "*" -and $TypeEventsMode -eq "*" -and $Log_Path -ne ""){
Write-host "вошли в 5"
$ALL_LOGS = Get-ChildItem -Path $Log_Path -Recurse| Where {$_.Extension -eq ".evtx" -and $StartDate1 -ne "null" } | Sort LastWriteTime
$ALL_LOGS
foreach ($Log in $ALL_LOGS){
$LogFile = "Audit EventLog Security" +"`n"
($Log).FullName
$Log.LastWriteTime
$StartDate
$EndDate
$MyFilter = @{Path=($Log).FullName}
Try {$Events = Get-WinEvent -FilterHashTable $MyFilter} Catch {"No events were found in $Log"; Continue}
ForEach ($Raw_Event in $Events){
Try{$EventXML = [xml]$Raw_Event.ToXML()} Catch {Write-Host "Unable to convert an event to XML"}
$Event = @{}
ForEach ($object in $EventXML.Event.EventData.Data) {
$Event.Add($object.name,$object.'#text')
}
$Event.Add("ID",$Raw_Event.ID)
$Event.Add("TimeCreated",$Raw_Event.TimeCreated)
if ($Event.TimeCreated.Day -eq $StartDate1.Day -and $Event.TimeCreated.Month -eq $StartDate1.Month -and $Event.TimeCreated.Year -eq $StartDate1.Year){
$LogFile+= "EventID: " + $Raw_Event.ID +"`n"
$LogFile+= "Target User Name: " + $Event.TargetUserName +"`n"
$LogFile+= "Target Domain Name: " + $Event.TargetDomainName +"`n"
$LogFile+= "Status: " + $Event.Status +"`n"
$LogFile+= "TimeGenerated: " + $Event.TimeCreated +"`n"
$LogFile+= "Workstation Name: " + $Event.WorkstationName +"`n"
$LogFile+= "IpAddress: " + $Event.IpAddress +"`n"
$LogFile+= "Computer: " + [xml]$Raw_Event.ToXML().Event.System.Computer +"`n"
$Reason = DefineReason -Id $Raw_Event.ID
$AccessM = DefineReasonByAccessMask -AccessMask $Event.Status
$LogFile+= "Reason(RU): " + $Reason + " "+ $AccessM +"`n"
$LogFile+= "Reason(SYS): " + $Event.Message +"`n"
$LogFile+= "----------------------------------------------------------------`n"
}
}
}
}
```
5. Поиск по всем серверам, по фильтру событий, за определенный период:
```
if ($FindServerMode -eq "*" -and $DateEventsmode -match "-" -and $DateEventsmode -ne "*" -and $TypeEventsMode -ne "*" -and $Log_Path -ne ""){
Write-host "вошли в 4"
$ALL_LOGS = Get-ChildItem -Path $Log_Path -Recurse| Where {$_.Extension -eq ".evtx" -and $StartDate1 -ne ""} | Sort LastWriteTime
$ALL_LOGS
foreach ($Log in $ALL_LOGS){
$LogFile = "Audit EventLog Security" +"`n"
($Log).FullName
$Log.LastWriteTime
$StartDate
$EndDate
$MyFilter = @{Path=($Log).FullName;ID=$TypeEventsMode}
Try {$Events = Get-WinEvent -FilterHashTable $MyFilter} Catch {"No events were found in $Log"; Continue}
ForEach ($Raw_Event in $Events){
Try{$EventXML = [xml]$Raw_Event.ToXML()} Catch {Write-Host "Unable to convert an event to XML"}
$Event = @{}
ForEach ($object in $EventXML.Event.EventData.Data) {
$Event.Add($object.name,$object.'#text')
}
$Event.Add("ID",$Raw_Event.ID)
$Event.Add("TimeCreated",$Raw_Event.TimeCreated)
if ($Event.TimeCreated.Day -eq $StartDate1.Day -and $Event.TimeCreated.Month -eq $StartDate1.Month -and $Event.TimeCreated.Year -eq $StartDate1.Year){
$LogFile+= "EventID: " + $Raw_Event.ID +"`n"
$LogFile+= "Target User Name: " + $Event.TargetUserName +"`n"
$LogFile+= "Target Domain Name: " + $Event.TargetDomainName +"`n"
$LogFile+= "Status: " + $Event.Status +"`n"
$LogFile+= "TimeGenerated: " + $Event.TimeCreated +"`n"
$LogFile+= "Workstation Name: " + $Event.WorkstationName +"`n"
$LogFile+= "IpAddress: " + $Event.IpAddress +"`n"
$LogFile+= "Computer: " + [xml]$Raw_Event.ToXML().Event.System.Computer +"`n"
$Reason = DefineReason -Id $Raw_Event.ID
$AccessM = DefineReasonByAccessMask -AccessMask $Event.Status
$LogFile+= "Reason(RU): " + $Reason + " "+ $AccessM +"`n"
$LogFile+= "Reason(SYS): " + $Event.Message +"`n"
$LogFile+= "----------------------------------------------------------------`n"
}
}
}
}
```
6. Поиск по всем серверам, по фильтру событий, за определенную дату:
```
if ($FindServerMode -eq "*" -and $TypeEventsMode -ne "*" -and $DateEventsmode -notmatch "-" -and $DateEventsmode -ne "*" -and $Log_Path -ne "") {
Write-host "вошли в 6"
$ALL_LOGS = Get-ChildItem -Path $Log_Path -Recurse| Where {$_.Extension -eq ".evtx" -and $StartDate1 -ne "" } | Sort LastWriteTime
$ALL_LOGS
foreach ($Log in $ALL_LOGS){
$LogFile = "Audit EventLog Security" +"`n"
($Log).FullName
$Log.LastWriteTime
$StartDate
$EndDate
$MyFilter = @{Path=($Log).FullName;ID=$TypeEventsMode}
Try {$Events = Get-WinEvent -FilterHashTable $MyFilter} Catch {"No events were found in $Log"; Continue}
ForEach ($Raw_Event in $Events){
Try{$EventXML = [xml]$Raw_Event.ToXML()} Catch {Write-Host "Unable to convert an event to XML"}
$Event = @{}
ForEach ($object in $EventXML.Event.EventData.Data) {
$Event.Add($object.name,$object.'#text')
}
$Event.Add("ID",$Raw_Event.ID)
$Event.Add("TimeCreated",$Raw_Event.TimeCreated)
if ($Event.TimeCreated.Day -eq $StartDate1.Day -and $Event.TimeCreated.Month -eq $StartDate1.Month -and $Event.TimeCreated.Year -eq $StartDate1.Year){
$LogFile+= "EventID: " + $Raw_Event.ID +"`n"
$LogFile+= "Target User Name: " + $Event.TargetUserName +"`n"
$LogFile+= "Target Domain Name: " + $Event.TargetDomainName +"`n"
$LogFile+= "Status: " + $Event.Status +"`n"
$LogFile+= "TimeGenerated: " + $Event.TimeCreated +"`n"
$LogFile+= "Workstation Name: " + $Event.WorkstationName +"`n"
$LogFile+= "IpAddress: " + $Event.IpAddress +"`n"
$LogFile+= "Computer: " + [xml]$Raw_Event.ToXML().Event.System.Computer +"`n"
$Reason = DefineReason -Id $Raw_Event.ID
$AccessM = DefineReasonByAccessMask -AccessMask $Event.Status
$LogFile+= "Reason(RU): " + $Reason + " "+ $AccessM +"`n"
$LogFile+= "Reason(SYS): " + $Event.Message +"`n"
$LogFile+= "----------------------------------------------------------------`n"
}
}
}
}
```
7. Поиск на определенном, сервере поиск по всем событиям, за весь период:
```
if ($FindServerMode -ne "*" -and $DateEventsmode -eq "*" -and $TypeEventsMode -eq "*" -and $Log_Path -ne ""){
Write-host "вошли в 7"
$ALL_LOGS = Get-ChildItem -Path $Log_Path -Recurse| Where {$_.Extension -eq ".evtx" -and $_.FullName -match $FindServerMode} | Sort LastWriteTime
$ALL_LOGS
foreach ($Log in $ALL_LOGS){
$LogFile = "Audit EventLog Security" +"`n"
($Log).FullName
$MyFilter = @{Path=($Log).FullName}
Try {$Events = Get-WinEvent -FilterHashTable $MyFilter} Catch {"No events were found in $Log"; Continue}
ForEach ($Raw_Event in $Events){
Try{$EventXML = [xml]$Raw_Event.ToXML()} Catch {Write-Host "Unable to convert an event to XML"}
$Event = @{}
ForEach ($object in $EventXML.Event.EventData.Data) {
$Event.Add($object.name,$object.'#text')
}
$Event.Add("ID",$Raw_Event.ID)
$Event.Add("TimeCreated",$Raw_Event.TimeCreated)
$LogFile+= "EventID: " + $Raw_Event.ID +"`n"
$LogFile+= "Target User Name: " + $Event.TargetUserName +"`n"
$LogFile+= "Target Domain Name: " + $Event.TargetDomainName +"`n"
$LogFile+= "Status: " + $Event.Status +"`n"
$LogFile+= "TimeGenerated: " + $Event.TimeCreated +"`n"
$LogFile+= "Workstation Name: " + $Event.WorkstationName +"`n"
$LogFile+= "IpAddress: " + $Event.IpAddress +"`n"
$LogFile+= "Computer: " + [xml]$Raw_Event.ToXML().Event.System.Computer +"`n"
$Reason = DefineReason -Id $Raw_Event.ID
$AccessM = DefineReasonByAccessMask -AccessMask $Event.Status
$LogFile+= "Reason(RU): " + $Reason + " "+ $AccessM +"`n"
$LogFile+= "Reason(SYS): " + $Event.Message +"`n"
$LogFile+= "----------------------------------------------------------------`n"
}
}
}
```
8. Поиск на определенном сервере, по фильтру событий, за весь период:
```
if ($FindServerMode -ne "*" -and $DateEventsmode -eq "*" -and $TypeEventsMode -ne "*" -and $Log_Path -ne ""){
Write-host "вошли в 8"
$ALL_LOGS = Get-ChildItem -Path $Log_Path -Recurse| Where {$_.Extension -eq ".evtx" -and $_.FullName -match $FindServerMode} | Sort LastWriteTime
$ALL_LOGS
foreach ($Log in $ALL_LOGS){
$LogFile = "Audit EventLog Security" +"`n"
($Log).FullName
$MyFilter = @{Path=($Log).FullName;ID=$TypeEventsMode}
Try {$Events = Get-WinEvent -FilterHashTable $MyFilter} Catch {"No events were found in $Log"; Continue}
ForEach ($Raw_Event in $Events){
Try{$EventXML = [xml]$Raw_Event.ToXML()} Catch {Write-Host "Unable to convert an event to XML"}
$Event = @{}
ForEach ($object in $EventXML.Event.EventData.Data) {
$Event.Add($object.name,$object.'#text')
}
$Event.Add("ID",$Raw_Event.ID)
$Event.Add("TimeCreated",$Raw_Event.TimeCreated)
$LogFile+= "EventID: " + $Event.ID +"`n"
$LogFile+= "Target User Name: " + $Event.TargetUserName +"`n"
$LogFile+= "Target Domain Name: " + $Event.TargetDomainName +"`n"
$LogFile+= "Status: " + $Event.Status +"`n"
$LogFile+= "TimeGenerated: " + $Event.TimeCreated +"`n"
$LogFile+= "Workstation Name: " + $Event.WorkstationName +"`n"
$LogFile+= "IpAddress: " + $Event.IpAddress +"`n"
$LogFile+= "Computer: " + [xml]$Raw_Event.ToXML().Event.System.Computer +"`n"
$Reason = DefineReason -Id $Raw_Event.ID
$AccessM = DefineReasonByAccessMask -AccessMask $Event.Status
$LogFile+= "Reason(RU): " + $Reason + " "+ $AccessM +"`n"
$LogFile+= "Reason(SYS): " + $Event.Message +"`n"
$LogFile+= "----------------------------------------------------------------`n"
}
}
}
```
9. Поиск на конкретном сервере, по всем событиям, за период:
```
if ($FindServerMode -ne "*"-and $DateEventsmode -match "-" -and $TypeEventsMode -eq "*" -and $Log_Path -ne ""){
Write-host "вошли в 9"
$ALL_LOGS = Get-ChildItem -Path $Log_Path -Recurse| Where {$_.Extension -eq ".evtx" -and $_.FullName -match $FindServerMode -and $StartDate -ne "null" -and $EndDate -ne "null"} | Sort LastWriteTime
$ALL_LOGS
foreach ($Log in $ALL_LOGS){
$LogFile = "Audit EventLog Security" +"`n"
($Log).FullName
$Log.LastWriteTime
$StartDate
$EndDate
$MyFilter = @{Path=($Log).FullName}
Try {$Events = Get-WinEvent -FilterHashTable $MyFilter} Catch {"No events were found in $Log"; Continue}
ForEach ($Raw_Event in $Events){
Try{$EventXML = [xml]$Raw_Event.ToXML()} Catch {Write-Host "Unable to convert an event to XML"}
$Event = @{}
ForEach ($object in $EventXML.Event.EventData.Data) {
$Event.Add($object.name,$object.'#text')
}
$Event.Add("ID",$Raw_Event.ID)
$Event.Add("TimeCreated",$Raw_Event.TimeCreated)
if ($Event.TimeCreated -gt $StartDate -and $Event.TimeCreated -lt $EndDate){
$LogFile+= "EventID: " + $Raw_Event.ID +"`n"
$LogFile+= "Target User Name: " + $Event.TargetUserName +"`n"
$LogFile+= "Target Domain Name: " + $Event.TargetDomainName +"`n"
$LogFile+= "Status: " + $Event.Status +"`n"
$LogFile+= "TimeGenerated: " + $Event.TimeCreated +"`n"
$LogFile+= "Workstation Name: " + $Event.WorkstationName +"`n"
$LogFile+= "IpAddress: " + $Event.IpAddress +"`n"
$LogFile+= "Computer: " + [xml]$Raw_Event.ToXML().Event.System.Computer +"`n"
$Reason = DefineReason -Id $Raw_Event.ID
$AccessM = DefineReasonByAccessMask -AccessMask $Event.Status
$LogFile+= "Reason(RU): " + $Reason + " "+ $AccessM +"`n"
$LogFile+= "Reason(SYS): " + $Event.Message +"`n"
$LogFile+= "----------------------------------------------------------------`n"
}
}
}
}
```
10. Поиск на конкретном сервере, по фильтру событий, за период:
```
if ($FindServerMode -ne "*" -and $DateEventsmode -match "-" -and $DateEventsmode -ne "*" -and $TypeEventsMode -ne "*" -and $Log_Path -ne ""){
Write-host "вошли в 10"
$ALL_LOGS = Get-ChildItem -Path $Log_Path | Where {$_.Extension -eq ".evtx" -and $_.FullName -match $FindServerMode -and $StartDate -ne "null" -and $EndDate -ne "null"} | Sort LastWriteTime
$ALL_LOGS
foreach ($Log in $ALL_LOGS){
$LogFile = "Audit EventLog Security" +"`n"
($Log).FullName
$Log.LastWriteTime
$StartDate
$EndDate
$MyFilter = @{Path=($Log).FullName;ID=$TypeEventsMode}
Try {$Events = Get-WinEvent -FilterHashTable $MyFilter} Catch {"No events were found in $Log"; Continue}
ForEach ($Raw_Event in $Events){
Try{$EventXML = [xml]$Raw_Event.ToXML()} Catch {Write-Host "Unable to convert an event to XML"}
$Event = @{}
ForEach ($object in $EventXML.Event.EventData.Data) {
$Event.Add($object.name,$object.'#text')
}
$Event.Add("ID",$Raw_Event.ID)
$Event.Add("TimeCreated",$Raw_Event.TimeCreated)
if ($Event.TimeCreated -gt $StartDate -and $Event.TimeCreated -lt $EndDate){
$LogFile+= "EventID: " + $Raw_Event.ID +"`n"
$LogFile+= "Target User Name: " + $Event.TargetUserName +"`n"
$LogFile+= "Target Domain Name: " + $Event.TargetDomainName +"`n"
$LogFile+= "Status: " + $Event.Status +"`n"
$LogFile+= "TimeGenerated: " + $Event.TimeCreated +"`n"
$LogFile+= "Workstation Name: " + $Event.WorkstationName +"`n"
$LogFile+= "IpAddress: " + $Event.IpAddress +"`n"
$LogFile+= "Computer: " + [xml]$Raw_Event.ToXML().Event.System.Computer +"`n"
$Reason = DefineReason -Id $Raw_Event.ID
$AccessM = DefineReasonByAccessMask -AccessMask $Event.Status
$LogFile+= "Reason(RU): " + $Reason + " "+ $AccessM +"`n"
$LogFile+= "Reason(SYS): " + $Event.Message +"`n"
$LogFile+= "----------------------------------------------------------------`n"
}
}
}
}
```
11. Поиск по конкретному серверу, по всем событиям, за определенную дату:
```
if ($FindServerMode -ne "*" -and $DateEventsmode -notmatch "-" -and $DateEventsmode -ne "*" -and $TypeEventsMode -eq "*" -and $Log_Path -ne ""){
Write-host "вошли в 11"
$ALL_LOGS = Get-ChildItem -Path $Log_Path -Recurse| Where {$_.Extension -eq ".evtx" -and $StartDate1 -ne "null" } | Sort LastWriteTime
$ALL_LOGS
foreach ($Log in $ALL_LOGS){
$LogFile = "Audit EventLog Security" +"`n"
($Log).FullName
$Log.LastWriteTime
$StartDate
$EndDate
$MyFilter = @{Path=($Log).FullName}
Try {$Events = Get-WinEvent -FilterHashTable $MyFilter} Catch {"No events were found in $Log"; Continue}
ForEach ($Raw_Event in $Events){
Try{$EventXML = [xml]$Raw_Event.ToXML()} Catch {Write-Host "Unable to convert an event to XML"}
$Event = @{}
ForEach ($object in $EventXML.Event.EventData.Data) {
$Event.Add($object.name,$object.'#text')
}
$Event.Add("ID",$Raw_Event.ID)
$Event.Add("TimeCreated",$Raw_Event.TimeCreated)
if ($Event.TimeCreated.Day -eq $StartDate1.Day -and $Event.TimeCreated.Month -eq $StartDate1.Month -and $Event.TimeCreated.Year -eq $StartDate1.Year){
$LogFile+= "EventID: " + $Raw_Event.ID +"`n"
$LogFile+= "Target User Name: " + $Event.TargetUserName +"`n"
$LogFile+= "Target Domain Name: " + $Event.TargetDomainName +"`n"
$LogFile+= "Status: " + $Event.Status +"`n"
$LogFile+= "TimeGenerated: " + $Event.TimeCreated +"`n"
$LogFile+= "Workstation Name: " + $Event.WorkstationName +"`n"
$LogFile+= "IpAddress: " + $Event.IpAddress +"`n"
$LogFile+= "Computer: " + [xml]$Raw_Event.ToXML().Event.System.Computer +"`n"
$Reason = DefineReason -Id $Raw_Event.ID
$AccessM = DefineReasonByAccessMask -AccessMask $Event.Status
$LogFile+= "Reason(RU): " + $Reason + " "+ $AccessM +"`n"
$LogFile+= "Reason(SYS): " + $Event.Message +"`n"
$LogFile+= "----------------------------------------------------------------`n"
}
}
}
}
```
12. Поиск по конкретному серверу, по фильтру событий, за определенную дату:
```
if ($FindServerMode -ne "*" -and $TypeEventsMode -ne "*" -and $DateEventsmode -notmatch "-" -and $DateEventsmode -ne "*" -and $Log_Path -ne ""){
Write-host "вошли в 12"
$ALL_LOGS = Get-ChildItem -Path $Log_Path -Recurse| Where {$_.Extension -eq ".evtx" -and $StartDate1 -ne "null" } | Sort LastWriteTime
$ALL_LOGS
foreach ($Log in $ALL_LOGS){
$LogFile = "Audit EventLog Security" +"`n"
($Log).FullName
$Log.LastWriteTime
$StartDate
$EndDate
$MyFilter = @{Path=($Log).FullName;ID=$TypeEventsMode}
Try {$Events = Get-WinEvent -FilterHashTable $MyFilter} Catch {"No events were found in $Log"; Continue}
ForEach ($Raw_Event in $Events){
Try{$EventXML = [xml]$Raw_Event.ToXML()} Catch {Write-Host "Unable to convert an event to XML"}
$Event = @{}
ForEach ($object in $EventXML.Event.Message) {
$Event.Add($object.name,$object.'#text')
}
$Event.Add("ID",$Raw_Event.ID)
$Event.Add("TimeCreated",$Raw_Event.TimeCreated)
$Event
if ($Event.TimeCreated.Day -eq $StartDate1.Day -and $Event.TimeCreated.Month -eq $StartDate1.Month -and $Event.TimeCreated.Year -eq $StartDate1.Year){
$LogFile+= "EventID: " + $Raw_Event.ID +"`n"
$LogFile+= "Target User Name: " + $Event.TargetUserName +"`n"
$LogFile+= "Target Domain Name: " + $Event.TargetDomainName +"`n"
$LogFile+= "Status: " + $Event.Status +"`n"
$LogFile+= "TimeGenerated: " + $Event.TimeCreated +"`n"
$LogFile+= "Workstation Name: " + $Event.WorkstationName +"`n"
$LogFile+= "IpAddress: " + $Event.IpAddress +"`n"
$LogFile+= "Computer: " + [xml]$Raw_Event.ToXML().Event.System.Computer +"`n"
$Reason = DefineReason -Id $Raw_Event.ID
$AccessM = DefineReasonByAccessMask -AccessMask $Event.Status
$LogFile+= "Reason(RU): " + $Reason + " "+ $AccessM +"`n"
$LogFile+= "Reason(SYS): " + $Event.Message +"`n"
$LogFile+= "----------------------------------------------------------------`n"
}
}
}
}
```
В конце месяца (период индивидуально задается администраторами) журнал безопасности архивируется на сервер-хранилище, с указанием имени сервера и даты архивации.
После того как мы описали все варианты поиска событий. Полученный результат нам необходимо сохранить в файл, путь к которому прописал пользователь в последнем поле. Если путь задан, то результат сохраняется в файл. После отработки скрипта файл автоматически запускается. Если путь для сохранения результата не задан, то лог будет сохранен в рабочем каталоге под именем «log.log».
```
if ($SaveResult -ne ""){
$LogFile | Out-File $SaveResult -Encoding utf8
Invoke-Item $SaveResult
$Event2= @{}
$Event = @{}
$Log_Path=""
}
else{
$LogFile | Out-File ".\log.log" -Encoding utf8
Write-Host $LogFile
$Event2= @{}
$Event = @{}
$Log_Path=""
}
```
Спасибо за внимание.
Во время написания скрипта очень полезной оказалась статья "[PowerShell и аудит безопасности](http://habrahabr.ru/post/118644/)", спасибо автору. | https://habr.com/ru/post/271963/ | null | ru | null |
# OutOfMemoryError: поймай, если сможешь
Всем привет! Сегдня хотел бы поделиться опытом обратоки ошибки ООМ. Эту статью меня побудила написать проблема, с которой я столкнулся. И которая, как позже выяснилось, долгое время оставалсь незамеченой. Меня заинтересовал этот вопрос, так что я решил изучить его немного глубже.
Предистория
-----------
У нас есть сервис, который по расписани закидывает задачу по обработке данных в *ExecutorService*. Это достаточно тяжелая задача. И в один прекрасный момент информации просто стало больше и она не влезла в наш *-Xmx*.
ООМ своими руками
-----------------
Для тестирования мне необходимо забить всю память объектами, которые GC будет считать живыми. Для этого я использовал следующий код:
```
public class MemoryGrabber {
static final List arrays = new LinkedList<>();
public static void grabAllMemory() {
for (; ; ) {
arrays.add(new Object[100]);
}
}
}
```
Тут тоже присутствует некоторая проблема, но об этом позже.
Обычный код
-----------
```
public class BadExecutor {
private static final Logger logger = LogManager.getLogger(BadThread.class);
private static final ExecutorService executor = Executors.newFixedThreadPool(5);
public static void main(String[] args) throws Exception {
executor.submit(() -> {
try {
grabAllMemory();
} catch (Exception e) {
logger.error(e.getMessage());
}
});
}
}
```
Этот код вроде бы выглядит неплохо, ничего особенного тут нет. Наверное, многие писали что-то подобное не один раз. Но проблема в том, что прм ООМ, не будет выведено вообще ничего. Ни в лог ни в поток вывода.
Лови Throwable — говорили они
-----------------------------
Да точно, ведь OutOfMemoryError — это Error, а не Exception. Поэтому тут он успешно прлетает мимо *catch* блока и перехватывается уже в коде *ThreadPoolExecutor*. Где проглатывается, а сам поток начинает ждать новой задачи. Всем известно, что в самой корневой точке кода лучше ловить *Throwable*.
К сожалению, если вместо *Exception* в данной ситуации поймать *Throwable*, ничего не изменится. При вызове *logger.error()*, мы просто получим новый ООМ, который так же канет в недрах *ThreadPoolExecutor*.
Стоит заметить, что если бы вместо *ExecutorService* создавался бы новый *Thread*, то все ошибки в конечном счете были бы обработаны *UncaughtExceptionHandler* в случае смерти потока, и в stderr была бы информация. *ThreadPoolExecutor* же пытается переиспользовать потоки, что в принципе ожидаемо.
Потерянный OutOfMemoryError
---------------------------
Закидывая задачу в *ExecutorService*, мы забыли очень важную вещь — воспользоваться *Future*, который возвращает метод *submit()*.
```
public class GetFuture {
private static final Logger logger = LogManager.getLogger(BadThread.class);
private static final ExecutorService executor = Executors.newFixedThreadPool(5);
public static void main(String[] args) throws Exception {
try {
executor.submit(MemoryGrabber::grabAllMemory).get();
} catch (Throwable e) {
logger.error(e);
}
}
}
```
Теперь стало немного лучше. Если *logger.error()* выкинет новый ООМ, то *main* поток свалится и, возможно, выведет ошибку. Это помогает вытащить результат из *ExecutorService* наружу. Все видели что-то подобное:
```
Exception in thread "main"
Exception: java.lang.OutOfMemoryError thrown from the UncaughtExceptionHandler in thread "main"
```
Это сообщение выводит обработчик ошибок по умолчанию, который вызывается в случае непредвиденной смерти потока.
UncaughtExceptionHandler — не панацея
-------------------------------------
Не стоит радоваться раньше вреени, т.к. лучше стало совсем немного. Если не переопределить обработчик, то вызывается *ThreadGroup.uncaughtException()*, в котором есть следующий код:
```
System.err.print("Exception in thread \""
+ t.getName() + "\" ");
e.printStackTrace(System.err);
```
Первая же строка создает новый объект при помощи конкатенации и, если там не вылетит новый ООМ, то есть большая вероятность получить его в *printStackTrace()*. Тут все зависит от обстоятельств. Но суть в том, что даже получив ООМ в главном потоке, есть шанс ничего о нем не узнать.
Финализируй это
---------------
Итак, теперь наша проблема в том, что нет памяти для логирования. Из-за чего получаем вторую ошибку. Так может быть попробуем освободить пространство? Проблема заключчается в том, что *MemoryGrabber.array* — статическая переменная. И объекты доступные через нее GC считает живыми. Попробую ее почистить.
```
public class FinalizeIt {
private static final Logger logger = LogManager.getLogger(BadThread.class);
private static final ExecutorService executor = Executors.newFixedThreadPool(5);
public static void main(String[] args) throws Exception {
try {
executor.submit(() -> {
try {
grabAllMemory();
} finally {
MemoryGrabber.arrays.clear(); // Очищаем память
}
}).get();
} catch (Throwable e) {
logger.error(e);
}
executor.shutdownNow();
}
}
```
Теперь во время логирования будет вызван сборщик мусора, который уже сможет удалить ненужную структуру данных.
Ода функциональному программированию
------------------------------------
Вначале я сказал, что в *MemoryGrabber* есть проблема. Она заключается в статической переменной *array*. Дело в том, что эта переменная продолжает жить после того момента, как все свалилось с ошибкой. Очевыдным костылем является ее обнуление в блоке *finaly*. Было бы намного лучше, если она хранилась на стеке вызова.
```
public class FunctionalGrabber {
public static void grabAllMemory() {
List arrays = new LinkedList<>();
for (; ; ) {
arrays.add(new Object[10]);
}
}
}
```
Теперь нашь лист *List* превратится в мусор как только завершится метод *grabAllMemory*. Не важно, с ошибкой или без. Почти Scala.
Как надо делать
---------------
Надеюсь, мне удалось донести мысль о том, что попытки поймать и обработать OutOfMemoryError в коде — сомнительная затея по ряду причин. Для этих целей лучше полагаться на следующие параметры JVM:
* **-XX:+HeapDumpOnOutOfMemoryError** и **-XX:HeapDumpPath** — сгенерируют дамп кучи во время ООМ, даже если приложение осталось работать
* **-XX:+ExitOnOutOfMemoryError** и **-XX:ExitOnOutOfMemoryErrorExitCode** — позволяют просто завершить процесс с определенным кодом
* **-XX:+CrashOnOutOfMemoryError** — остановит с ошибкой и создаст лог JVM
Последние два параметра появились только в JDK 8u92, остальные еще в 1.4. Оптимальным поведением является завершение процесса в случае OutOfMemoryError. Такая логика — самая понятная для всех разработчиков и тех, кто будет поддерживать приложение. Попытки обработать подобные ошибки могут привести к последствиям, неочевидным даже для самого автора.
Выводы
------
В статье я постарался разобраться в некоторых ошибках, из-за которых могут возникнуть проблемы при появлении ООМ. Чтобы их избежать, нужно иметь в виду:
* Процесс нужно правильно конфигурировать, чтобы завершить его работу, если память закончится
* При определенных условиях можно не получить явных доказательст ООМ, даже если есть логирование и вывод перенаправлен в файл
* Можно попытаться отловить OutOfMemoryError и продолжить работу, технически это возможно, но о таком код называют дурно пахнущим. | https://habr.com/ru/post/359300/ | null | ru | null |
# Что хотят от кандидатов на собеседовании по написанию кода?
*Привет, хабровчане. В преддверии старта курса [«Java QA Engineer»](https://otus.pw/rEa7/) делимся с вами продолжением [вот этого материала](https://habr.com/ru/company/otus/blog/480800/)*.
---
На первых своих собеседованиях я этого не знал. А ведь разработчики не просто наблюдали за мной — они ожидали. Ожидали, что я буду действовать по следующему алгоритму:
**Уточнить задание**
* Спросите: «Что вы подразумеваете под словом палиндром?».
* *Это отвечает на вопрос: приступит ли кандидат к решению задачи немедленно — даже не осознавая, что ее технические условия не ясны до конца? Или немного подумает и уточнит требования?»*
«Мы имеем в виду такую последовательность, которая читается одинаково слева направо и справа налево. Ваше решение должно быть чувствительно к регистру: маленькая r не идентична большой R».
**Начните с примеров**
* Спросите: «В качестве примеров приведены слова «доход» и «шалаш». А что насчет фраз вроде «А роза упала на лапу Азора?». Что насчет пустой строки или строки из одного символа?
* *Это отвечает на вопрос: примет ли кандидат во внимание достаточное количество пограничных случаев? Насколько точным и внимательным он будет?*
### Прежде чем приступить к описанию кода, кратко ознакомьте интервьюера с алгоритмом
*Как кандидат подходит к решению проблемы? Проговаривает ли он свои мысли вслух, чтобы интервьюер их услышал?*
Например, `string s = "alla"`.
Мы можем воспользоваться вспомогательным методом для Строки Java, charAt(int i). Введите индекс строки в метод, и он выведет символ в таком индексе:
```
s.charAt(0) == 'a'
s.charAt(1) == 'l'
s.charAt(2) == 'l'
s.charAt(3) == 'a'
```
Чтобы узнать длину строки, можно использовать метод `length()`:
`s.length == 4`
Чтобы узнать последний символ, можно использовать:
```
int len = s.length
s.charAt(len - 1)
```
Мы начали отсчет с 0, поэтому последний символ будет «длина минус 1».
Давайте назовем первый символ «first», а последний «last».
* Если первый символ s.charAt(first) не совпадает с s.charAt(last), то это не палиндром. Выводим false.
* Если первый символ s.charAt(first) совпадает с s.charAt(last), мы переходим к оценке следующего набора символов, сдвигаясь на один символ от «first» и от «last». Если все совпадает, вывести true.
* Проверив алгоритм вместе с интервьюером, можно приступать к написанию кода:
```
public boolean isPalindrome(String s) {
int first = 0;
int last = s.length() - 1;
while (first < last) {
if (s.charAt(first) != s.charAt(last)) {
return false;
}
first++;
last--;
}
return true;
}
```
### Отладка и тестирование
* Возьмите изначальные тестовые примеры и попытайтесь представить: что произойдет, если вставить их в код.
* Интервьюеры проверяют вашу внимательность при отладке. (*Заметите ли вы ошибки в собственном коде без подсказок со стороны?*).
* Интервьюеры будут давать подсказки, если вы сумели произвести на них хорошее впечатление. (*Если мы будем давать кандидату подсказки, воспользуется ли он ими? Готов ли он прислушаться к чужому мнению? Умеет ли он работать с людьми, занимающими более высокие должности?*).
### Покажите свой код другим людям и соберите их отзывы
Я показал свое решение задачи про палиндром своему другу-разработчику. Он скорчил гримасу: «Зачем ты использовал переменные «first» и «last»? И зачем задействовал цикл «loop», если можно обойтись «for»? Все можно было сделать короче, элегантнее и быстрее:
```
public boolean isPalindrome(String s) {
int len = s.length;
for (int i = 0; i < len / 2; i++) {
if ( s.charAt(i) != s.charAt(len - 1 - i)) {
return false;
}
}
return true;
}
```
### Что дальше
Овладеть языком программирования в одночасье не получится. Поэтому лучше следовать такому алгоритму:
* Найти в интернете задачи по программированию базового уровня.
* Попробовать решить их с помощью бумаги и ручки.
* Если вы не можете их решить, ознакомьтесь с официальной документацией языка программирования и посмотрите, какие встроенные методы могут помочь вам.
* Сформулируйте собственное решение перед тем, как искать чужое. Если вы сами будете собирать информацию и изучать ее, появится вероятность того, что эта информация навсегда осядет в вашей голове.
* Не устраивайте сеансы зубрежки. Так вы просто сохраните информацию в краткосрочной памяти.
* Практикуйтесь короткими заходами, по 15 минут в день. Так информация переместится в долгосрочную память, и вы сможете вспомнить ее даже при экстремальном стрессе на собеседовании.
* Не подвергайте себя всем этим мучениям только ради того, чтобы пройти тест на доске. Цельтесь выше! Поставьте перед собой задачу стать более профессиональным программистом! | https://habr.com/ru/post/481210/ | null | ru | null |
# Использование webrtc для взаимодействия с asterisk-сервером или как заставить рации говорить с браузером
Доброго времени суток, хабравчане.
Сегодня я расскажу вам о работе sip-телефонии, а именно о том, как я организовывал звуковой сеанс между мобильными рациями (или ИКН) о которых вы слышали ранее из других статей нашей компании и web-клиентом через webRTC с использованием sipML5 в качестве библиотеки и asterisk 11 в качестве АТС.
Всем кому небезразлична данная тема — добро пожаловать под кат.
### Немного предыстории
К нам в отдел поступило оперативное задание разработать sip-клиент, который работал бы на asterisk, и как минимум на google chrome (как мобильной, так и десктопной его версии). С этого и закрутилось.
В системе локального позиционирования RealTrac существуют мобильные устройства типа рация, или, как мы их называем, ИКН (интерком носимый), который обеспечивает использование как дуплексной связи, так и широковещательной полудуплексной связи с другими устройствами. Эти устройства взаимодействуют с коммуникационным сервером INCPd, основная задача которого – обработка пакетов протокола INCP, посредством которого обеспечивается обмен информацией с устройствами системы RealTrac. В том числе, данный сервер обрабатывает поступающий голосовой трафик, и перепаковывает его в sip-пакеты, для дальнейшей работы со сторонним софтом.
В качестве коммутатора выступает asterisk.
### Инструментарий
SipML5 был выбран нами неслучайно. Во-первых, данная библиотека хорошо подходит для интеграции с asterisk. Во-вторых, мы уже имели опыт работы с подобными системами, однако, из-за того, что наша компания поддерживала Debian 7 в качестве ОС для нашего программного обеспечения имелись определенные сложности. В дистрибутиве Debian 7 доступен только asterisk 1.8 в то время как webRTC без танцев с бубном, в виде webrtc2sip, работает только с 11 версии asterisk, что нас несильно устраивало, так как это могло бы стать полигоном проблем для будущих инсталляций.
С релизом Debian 8 было решено продолжить движение в направлении данного функционала.
В качестве инструментария создания ui-части выступал React.js, так как он удобен для отображения различных динамических объектов, имеющих большое количество внутренних состояний.
### Небольшое введение по sipML5
В основе клиента используется две основные сущности, это SIPml.Stack и SIPml.Session.
SIPml.Stack является управляющим потоком данных. Данный объект будет выступать в качестве основного при создании сессий с сервером.
SIPml.Session является потоком sip-сеанса с сервером. Используется непосредственно для передачи данных между сервером и клиентской частью.
**Алгоритм работы с sipML5:**
Инициализация библиотеки:
```
SIPml.init(readyCallback, errorCallback);
```
**Создание Stack**
Stack является ключевым источником данных для работы клиента.
```
RtlsSip.stack = new SIPml.Stack({
realm: Data.property.realm,
impi: Data.property.impi,
impu: Data.property.impu,
password: Data.property.password,
display_name: Data.property.display_name,
websocket_proxy_url: Data.property.websocket_proxy_url,
events_listener: { events: '*', listener: eventsListener },
sip_headers: [
{ name: 'User-Agent', value: 'IM-client/OMA1.0 sipML5-v1.0.0.0' },
{ name: 'Organization', value: 'RTLS' }
]
})
```
При создании stack необходимо указывать большое количество конфигурационных данных, часть из которых является опциональной. Полную информацию по stack можно посмотреть [здесь](https://www.doubango.org/sipml5/docgen/symbols/SIPml.Stack.html)
После создания stack-объекта необходимо его запустить:
```
RtlsSip.stack.start();
```
Важно отметить, что функция start() является асинхронной, поэтому, перед тем как начать совершать звонки, необходимо дождаться события запуска stack.
Полный перечень событий представлен тут [много](https://www.doubango.org/sipml5/docgen/symbols/SIPml.EventTarget.html#addEventListener), и перечислять их все не имеет смысла.
После события создания stack необходимо создать сессию регистрации:
```
RtlsSip.stack.newSession('register', {
events_listener: { events: '*', listener: registerListeners} });
RtlsSip.sessions.register();
```
В ходе этой операции происходит sip запрос для входа пользователя в систему.
После выполнения данных действий мы готовы совершать или принимать звонки от пользователей.
**Прием звонков**
Входящий звонок в sipML5 инициализирует событие ”i\_new\_call” объекта SIPml.Stack.
В общем случае обработчик ответа на звонок выглядит следующим образом:
```
var eventCallback = function(е){
RtlsSip.callSession = e.newSession;
RtlsSip.callSession.events_listener({events: '*', listener: RtlsSip.sessionEventListener})
RtlsSip.callSession.accept(
{audio_remote: document.getElementById('audio_remote'),
events_listener: { events: '*', listener: RtlsSip.sessionEventListener}})
}
```
e.newSession — содержит в себе дополнительный объект сеанса связи, для события “i\_new\_call” это будет объект SIPml.Session.Call.
Функция accept() необходима для принятия звонка. В качестве параметра принимает объект SIPml.Session.Configuration
**Инициализация звонков**
Инициализация звонка сводится к созданию новой сессии типа SIPml.Session.Call
```
RtlsSip.callSession = RtlsSip.stack.newSession('call-audio', {
audio_remote: document.querySelector('#audio_remote'),
events_listener: { events: '*', listener: RtlsSip.sessionEventListener }
});
```
После инициализации можно приступать к вызову абонента, через его идентификатор, номер или url (e.g. 'sip:johndoe@example.com' or 'johndoe' or '+33600000000').:
```
RtlsSip.callSession.call(number);
```
**Управление звонком**
Управление звонком это методы класса SIPml.Session.Call
Основные из них:
● .hangup() — завершение звонка
● .hold() / .resume() — удержание/возобновление звонка
● .mute(media, mute) — отключение входящего звука, где media — тип контента для отключения; mute — boolean — активация/деактивация mute.
RtlsSip.callSession.mute('audio', true);
Есть также множество других функций, информацию о которых вы найдете [здесь](https://www.doubango.org/sipml5/docgen/symbols/SIPml.Session.Call.html#acceptTransfer).
### Схема приложения:
Схема приложения имеет достаточно простую архитектуру. В качестве идеологии однонаправленность данных и отсутствия взаимных зависимостей между элементами.
### Интеграция в систему
Настройки для asterisk сервера я здесь описывать не буду, так как их несложно найти на просторах сети.
Для абонентов типа web-client был выделен собственный список номеров. Номера из пула устанавливаются диспетчерам при создании аккаунта пользователя.
Диспетчер может совершать звонки как в полудуплексном, так и в дуплексном режиме, а также связываться с другими диспетчерами в случае необходимости.
Устройство по умолчанию звонит в полудуплексном режиме. Диспетчер, которому звонит устройство выбирается в зависимости от геосегмента в котором находится устройство в текущий момент времени.
Все это позволяет добиться максимального комфорта в использовании системы.
**Итоги:**
На данный момент, эта технология проходит у нас процесс интеграции и тестирования. Уверен, что в процессе работы найдется немало помех и проблем.
Вполне возможно, что в будущем мы попробуем решение на основании других технологий, предоставляющих тот же функционал.
**by Sinires** | https://habr.com/ru/post/302998/ | null | ru | null |
# Самое простое объяснение принципа работы современных алгоритмов симметричного шифрования
*(Нашёл в твиттере тред с очень крутым объяснением работы симметричных шифров. Его написал Colm MacCárthaigh один из основных контрибьюторов Apache. Я спросил разрешение Колма на перевод, он любезно согласился).*
Я объясню вам доступным языком, что происходит при шифровании данных. Надеюсь, что без мистики и сложных штук, которые были придуманы криптографами.
Итак, симметричное шифрование — это именно то, что мы используем в большинстве случаев, когда хотим зашифровать кучу данных. Ваш браузер отправляет и получает данные, используя симметричное шифрование. Если вы шифруете файлы или диск, в этом случае тоже работает симметричное шифрование. iMessage, Signal, WhatsApp — все они используют симметричное шифрование для безопасности вашей переписки.
Если вы думаете, что при шифровании данные перемешиваются так, что их никто не может прочитать без ключа, так оно и происходит на самом деле.
Вот простой пример. Допустим, у меня есть строка "Ovaltine" и я хочу её зашифровать. Я мог бы воспользоваться rot13 — очень простым олдскульным шифром Цезаря, который делает хоровод из букв, где a и z держатся за ручки, и заменяет каждую букву другой буквой алфавита, которая находится от заменяемой буквы на расстоянии 13 символов. Таким образом "O" превращается в "B", а "v" становится "i", в итоге "Ovaltine" превращается в "Binygvar". Конечно, это не очень безопасно. Это наивный пример, который очень легко взломать, так как атакующий может выяснить, какая буква встречается чаще всего (обычно в оригинальном тексте это "e") и найти оставшиеся буквы подобным образом.
Сейчас вы можете представить, что должны существовать более хитрые способы "перемешивания" букв. Например, некая сложная схема, в которой "a" переходит в "p", но при повторном шифровании — в "f". Может даже иногда эта схема начинает шифровать "a" двумя буквами, например "jd" или в что-нибудь другое. Таким образом эта усложнённая схема может зашифровать "Ovaltine" в строку "FGyswDmweeRq" (заметьте, что она стала длиннее). В прошлом появлялись алгоритмы шифрования, которые работали подобным образом, но это совсем не так, как работает современное шифрование.
Вместо "перемешивания" букв современное шифрование берёт вашу секретную строку и хитро комбинирует её со случайными данными. Это похоже на rot13 только в двух моментах: шифрование и расшифровка по сути одна и та же операция, и всё происходит "на месте". Действительно, вы заметили что rot13 является одновременно алгоритмом шифрования и расшифровки? rot13(Ovaltine) -> Binygvar, rot13(Binygvar) -> Ovaltine. Я считаю, что это очень красивая симметрия в симметричном шифровании. Но всё же вернёмся к нашей теме. Хитрость заключается в том, что мы используем побитовую операцию XOR. В криптографии, формальной логике и коде программ XOR может обозначаться по разному, но я буду использовать такую нотацию, с которой вы вероятнее всего знакомы. Она выглядит вот так: ^.
XOR — это сокращение от "exclusive OR" (исключающее ИЛИ). Это оператор (или функция, если вам так удобнее думать), которая принимает два аргумента и возвращает результат. A ^ B = C. Этот оператор называется "побитовым", так как применяется к соответствующим друг другу битам. Если A и B байты, то мы можем считать, что A ^ B = C по сути 8 разных операций, которые происходят одновременно. ^ сравнивает первый бит A и первый бит B, а затем помещает результат в первый бит C. Он повторяет тоже самое ещё 7 раз для оставшихся бит. Правила простые: если бит из A "1" ИЛИ бит из B "1", тогда мы устанавливаем соответствующий бит C в "1", но только в том случае, когда "A" и "B" одновременно не являются "1". Это и есть исключающая часть. Вот олдскульная таблица истинности:
```
A|B|C
0|0|0
1|0|1
0|1|1
1|1|0
```
Самая клёвое в XOR то, что он похож на rot13. Мы можем использовать его для шифрования и расшифровки. Покажу это на простом примере. Давайте представим, что мы хотим зашифровать обычное число "3" и что наш ключ шифрования другое число "7". Таким образом 3 ^ 7 = 4. То есть результат шифрования — "4". Давайте теперь расшифруем число. Я просто сделаю тоже самое снова: 4 ^ 7 = 3. Возьмите любое число, которое вам нравится или любые данные, и это всегда будет работать — XOR всегда сможет расшифровать себя.
Бит за битом — вот как мы в действительности шифруем и расшифровываем данные, нет никакого перемешивания, только XOR-инг. Трудная часть — поиск данных, к которым мы можем применить XOR. Один из подходов заключается в том, чтобы взять большой кусок секретных данных, лежащих под рукой, и использовать его в качестве второго аргумента XOR. При этом все участники процесса передачи зашифрованных данных должны использовать один и тот же набор секретных данных для шифрования и расшифровки. И это будет работать. Правда есть несколько проблем.
Первая проблема. Секретные данные должны казаться случайными. Вы не можете взять текст из книги или что-то в этом роде. Любые паттерны будут проявляться в зашифрованных данных. Это именно то, благодаря чему союзные войска получили преимущество во Второй мировой войне.
Вторая проблема. Вам нельзя переиспользовать секретные данные, так как паттерны проявятся снова. Таким образом вы как-то должны предоставлять большие куски секретных данных для всех, кто в них нуждается как в шифре Вернама (One-time pad). Это слишком трудно.
В современном шифровании мы "генерируем" нужные нам секретные данные из маленьких ключей. Эти ключи гораздо проще таскать с собой и защищать. Вот чем в действительности являются алгоритмы симметричного шифрования — схемами для детерминированной генерации случайных данных из ключа. Часть про "детерминированность" очень важна: два человека с одним и тем же ключом должны генерировать абсолютно один и тот же набор данных, иначе они не смогут понять друг друга. Вероятно, вы слышали про такие алгоритмы: AES, 3DES, DES, RC4, ChaCha20. Все они делают это.
Оказывается, что математическая задача генерации случайного потока данных (в котором нет паттернов в любом предсказуемом виде) с помощью ключа очень сложна. Из этого списка сегодня считаются безопасными только AES и ChaCha20. Другие алгоритмы были взломаны: люди смогли предсказывать их. Причём AES имеет немного запятнанную репутацию, потому что криптографы говорят следующее:
> AES — основной и наиболее проанализированный алгоритм шифрования. Абсолютно золотой стандарт! :dark\_sunglasses:
Но при этом добавляют:
> Реализации AES в программном обеспечении (не в аппаратном) или небезопасны, или медленны, а иногда и не безопасны, и медленны. Он не был разработан с учётом того, что его взлом можно осуществить с помощью анализа кэша. :facepalm:
Не пугайтесь слишком сильно, если это вам непонятно. Главная мысль заключается в следующем: AES шикарен с точки зрения математики, но очень сложен в программной реализации. Но не надо беспокоиться — у нас почти всегда есть поддержка AES на уровне аппаратного обеспечения (список всех процессоров с аппаратной поддержкой AES можно посмотреть тут <https://en.wikipedia.org/wiki/AES_instruction_set>, — прим. переводчика).
Как бы то ни было, продолжаем… Как эти алгоритмы работают в действительности? Каким образом мы можем взять ключ и безопасно сгенерировать случайный поток данных? Я буду тут немного упрощать и начну с блоков.
Эти алгоритмы получают на вход три параметра и на выходе отдают зашифрованный текст. Входные параметры — ключ, шифруемый текст и… сюрприз — что-то странное под названием "вектор инициализации" (initialization vector, IV).
```
AES(key, IV, plaintext) -> encrypted_data.
```
Ключ и IV комбинируются между собой, чтобы создать набор "стартовых условий" для алгоритма; это подобно начальной перестановке или перемешиванию плиток в игре Скрэббл. Одинаковая комбинация ключа и IV всегда будет создавать одинаковый набор стартовых условий. Спрашиваете, почему нам вообще тогда понадобился IV? Нам нужен IV, чтобы мы могли шифровать множество сообщений, используя одинаковый ключ. Без IV, каждый генерируемый поток данных был бы одинаков, и это плохо. Это бы нарушило одно из правил, про которое мы говорили ранее: мы не можем переиспользовать одни и те же данные при шифровании. Таким образом нам нужен IV для перемешивания результата. Но в отличии от ключа IV может быть публичным.
Итак, когда вы шифруете сообщение и отправляете его кому-нибудь, вы также можете добавить: "Эй, а вот IV, который я использовал". При этом всё ещё критично, чтобы мы не переиспользовали комбинацию ключа и IV, потому что они дали бы нам повторяющиеся случайные данные. Для достижения этого условия есть два пути: 1) IV это некий счётчик, который мы увеличиваем с каждым новым сообщением. 2) IV генерируется случайно, при этом у него достаточно большое значение, поэтому нам не надо сильно беспокоиться о коллизиях. Как бы то ни было, я упомянул, что я буду говорить о блоках.
Ключи и IV "смешиваются" или комбинируются таким образом, чтобы создать набор стартовых условий… эти условия на самом деле являются начальным "блоком" случайных данных. Длина этого блока для AES128 128 бит, для AES256 — 256 бит, для ChaCha20 — 512 бит. И вот тут проявляется настоящая магия и индивидуальность конкретного алгоритма шифрования. В действительности их суть заключается в том, каким образом генерируется последовательность блоков и как каждый блок связан со своими соседями. Отношения между этими блоками остаются предсказуемы даже для тех, у кого нет ключа.
Я не буду глубоко погружаться в то, как именно работают эти алгоритмы, но если вы хотите узнать больше, я советую вам начать изучение этой темы с линейного конгруэнтного метода (linear congruential generators, LCG). LCG представляет собой функцию, которая создаёт "циклические" блоки данных в случайном и неповторяющемся виде. Затем взгляните на cеть Фе́йстеля (Feistel networks) — следующий уровень развития LCG. Затем разберитесь с S-Boxes, а потом посмотрите на то как Salsa20 создаёт чередование в алгоритме ChaCha20. Всё это гораздо доступнее, чем вы можете подумать!
Итак, мы теперь знаем, как случайный поток данных может быть скомбинирован с текстом, чтобы его зашифровать и расшифровать, и мы уже немного в теме того, как эти случайные потоки данных создаются. Разве это не всё, что нам надо? Для шифрования диска, это, действительно, почти всё. Мы можем шифровать каждый блок или сектор хранилища с использованием одного ключа и IV, который может быть получен из "позиции" на диске. Таким образом мы можем всегда расшифровать любой блок данных в любом месте на диске, до тех пор пока у нас есть ключ. Но тут есть одна проблемка… кто-нибудь может испортить наши зашифрованные данные. Если я изменю значение любого байта, даже если у меня не будет ключа, то в итоге мы не сможем расшифровать блок. И нет защиты против вмешательства такого вида. В случае отправки сообщений и данных по сети, это становится ещё критичнее. Мы не хотим, чтобы кто-нибудь мог испортить наши передаваемые данные. Таким образом нам надо добавить проверку целостности! Есть несколько схем, для того чтобы это сделать.
HMAC, GCM и Poly1305 — наиболее распространённые современные схемы для проверки целостности. Эти алгоритмы по большому счёту работают так: им на вход подаются данные и другой ключ (так называемый ключ целостности). После вычислений они выдают на выходе MAC (message authentication code) или тэг, который в свою очередь просто другой кусочек данных, выступающий подписью.
Таким образом для шифрования и защиты наша схема может выглядеть так:
```
AES(key, IV, "Ovaltine") -> encrypted_output
HMAC(key, encrypted_output) -> MAC
```
и затем по проводам мы отправляем:
```
IV | encrypted_output | MAC
```
Для расшифровки мы проверяем MAC, генерируя его снова и сравнивая результат с полученным MAC, а затем расшифровываем данные. Есть внутренние различия в том, как HMAC, GCM и Poly1305 генерируют эти подписи, но вам не надо об этом беспокоиться. На сегодняшний день эту комбинацию операций обычно оборачивают в функцию с именем "AEAD" (Authenticated Encryption with Additional Data). Под капотом она делает всё то, про что я говорил ранее:
```
AEAD(key, IV, plaintext, additional_data) -> IV_encrypted_data_MAC
```
Штука под названием "additional\_data" — всего лишь данные, с помощью которых вы можете убедиться в том, что эти данные есть у отправляющей стороны, хотя они и не были им отправлены. Это как мета-данные, с помощью которых устанавливаются права доступа. Часто это поле оставляют пустым.
Но тем не менее вы можете поиметь проблемы с AEAD, если будете использовать один и тот же IV. Это плохо! Есть попытки для улучшения этой ситуации: мой коллега, которого зовут Шай, работает над клёвой схемой SIV, добавляющей уровень защиты от этой проблемы. Но если вы используете уникальный IV, современное шифрование очень безопасно. То есть вы можете опубликовать зашифрованный текст в Нью-Йорк Таймс, и никто не сможет его взломать. Шифр будет оставаться неприступен, даже если "некоторая" часть текста будет известна. Например, в интернет-протоколах большое количество текста известно. HTTP-сервера всегда отвечают одинаково и первые байты всегда известны. Но этот факт совсем не имеет значения — он не поможет атакующему узнать ни кусочка оставшихся данных… Мы прошли долгий путь со времён Второй мировой войны.
Но есть атаки, которые работают! Если вы отправляете данные по сети и кто-то отслеживает время и размер сообщений, то зашифрованные данные могут быть взломаны с помощью анализа трафика.
Давайте сначала разберёмся с длиной. Очевидно, что длина — это не скрытая характеристика. И это нормально, если вы пытаетесь защитить свой пароль или номер кредитной карты где-то в середине сообщения. Не очень то и большая проблема. Но это означает, что потенциально любой человек может определить тип контента, который вы отправляете. Простой пример: если вы отправляете gif с помощью мессенджера и если размер этого изображения уникален, атакующий, перехватывающий ваши данные, может предположить какая именно гифка была только что отправлена. Есть более хитрые версии этой атаки для Google Maps, Netflix, Wikipedia и т.п. Для защиты от этой атаки можно "добивать" отправляемые сообщения дополнительными байтами, таким образом, чтобы все отправляемые сообщения были одинаковой длины несмотря ни на что. Шифрование, которое используется в военных сетях, всегда "добивает" трафик дополнительными данными, то есть для перехватчика он всегда выглядит одинаковым! Ещё одна проблема, связанная с длиной, заключается в том, что если вы используете сжатие и даёте атакующему возможность изменять любую часть контента на странице, которую видит пользователь, то это даёт возможность атакующему разузнать даже самые маленькие секреты. Поищите атаку под названием "CRIME". Она шикарна и страшна.
Я ещё говорил о том, что другая проблема — тайминг. Очевидно, что время отправки каждого сообщения открытая информация. Это может быть проблемой? Может! Например, если вы отправляете сообщение на каждое нажатие клавиши, тогда тривиально выяснить, что именно печатается с помощью анализа времени. Круто! Другой пример — VOIP. Если ваше приложение для звонков отправляет данные только тогда, когда люди говорят, но не во время молчания, этого достаточно для того, чтобы восстановить 70% английской речи. Всего лишь из тишины. Страшно клёво.
Эти примеры всего лишь верхушка айсберга. Даже когда вы используете алгоритмы и схемы шифрования, которые улучшались в течение 80 лет, всё равно остаются пробелы, с помощью которых можно взломать защиту. Вот почему про это ценно знать!
Как бы то ни было, это тот уровень объяснения, на котором я хочу сейчас остановиться, но мы рассмотрели самое необходимое, что надо знать. Если вы дочитали до этого момента — спасибо! Сейчас у вас должно быть большее понимание того, что происходит при шифровании и чего следует остерегаться.
[Не стесняйтесь задавать вопросы](https://twitter.com/colmmacc)
*Перевод публикуется под лицензией CC BY-NC-SA 4.0* | https://habr.com/ru/post/443050/ | null | ru | null |
# PhpStorm 2020.1: поддержка composer.json, инструменты для PHPUnit, покрытие кода с PCOV и PHPDBG, Grazie и другое
[](https://habr.com/ru/company/JetBrains/blog/497358/)
Привет, Хабр! Рады представить первый мажорный релиз PhpStorm в этом году!
Под катом подробный разбор всех заметных изменений и новых возможностей. Осторожно — много картинок.
> Скачать PhpStorm 2020.1 можно на [сайте](https://www.jetbrains.com/ru-ru/phpstorm/whatsnew/) или с помощью [Toolbox App](https://www.jetbrains.com/ru-ru/toolbox-app/). Там же 30-дневная пробная версия. Все продукты JetBrains доступны бесплатно для [студентов](https://www.jetbrains.com/ru-ru/student/) и [разработчиков](https://www.jetbrains.com/ru-ru/community/opensource/?product=phpstorm) опенсорсных проектов.
Поддержка composer.json
-----------------------
Все действия по работе с зависимостями теперь доступны непосредственно в файле `composer.json` и работают прямо в редакторе.
**Создать новый файл composer.json** можно из контекстного меню или горячей клавишей `Ctrl(⌘)+N`. Шаблон этого файла находится в настройках *Preferences/Settings | Editor | File and Code Templates*.
**Управление зависимостями**
Чтобы добавить зависимость, достаточно просто начать писать имя вендора и пакета, и появится список автодополнения с подходящими вариантами.
В поле **версии** будут предложены доступные версии этого пакета. Пока карет (^) или другой символ для указания диапазона версий придется добавлять вручную, но в следующих выпусках мы это исправим.
Для требований по версии PHP или наличия расширений автодополнение тоже будет работать.
**Обновление и установка пакетов**
Если файла `composer.lock` еще нет и пакеты не установлены, то PhpStorm будет подсвечивать название секции `require` и `require-dev`. Чтобы установить их, можно нажать кнопку *Install* в тулбаре над редактором. Или воспользоваться быстрым действием по нажатию `Alt(⌥)+Enter` и выбрать *Install packages*`.`
А вот если установлены не все пакеты, то PhpStorm подсветит недостающие. Тогда `Alt(⌥)+Enter` можно вызвать на любом из них и выбрать *Update package* или *Update all packages*.
Рядом с указанным требованием по версии серым будет написана версия пакета, которая реально установлена. А во всплывающем диалоге для пакетов будет информация с packagist.org о числе скачиваний и звездочек.
Всю информацию о пакетах и их версиях PhpStorm берет с packagist.org и кеширует.
**Навигация к файлам и папкам**
Наверняка вы знаете, что по нажатию `Ctrl(⌘)+Click` и `Ctrl(⌘)+B` можно переходить к определению сущностей или искать их использования.
В `composer.json` это тоже будет работать. Если нажать `Ctrl(⌘)+Click` на пакете, то соответствующая директория будет подсвечена в Project Tree. А если на файле, то он будет открыт в редакторе.
Нажатие `Ctrl(⌘)+Click` или `Ctrl(⌘)+B` на любой ссылке в `composer.json` ожидаемо откроет ее в браузере.
**Автодополнение** **в секциях autoload(-dev)**
Для неймспейсов и путей работает автодополнение на основе информации из классов и структуры директорий проекта.
`Ctrl(⌘)+Click` и `Ctrl(⌘)+B` для перехода к файлам и папкам здесь тоже работает.
**Улучшения для скриптов**
Во-первых, таким же образом работают переходы к файлам/папкам/методам. Во-вторых, поддерживаются алиасы для команд. И, в-третьих, скрипты можно запускать из редактора нажатием кнопки [play] напротив имени скрипта.
При этом автоматически создается Run-конфигурация. Это значит, что повторно запускать скрипт можно горячей клавишей `Ctrl(⌃)+R`, что довольно удобно при отладке:
**Установка инструментов качества кода**
Если в dev-зависимостях есть `FriendsOfPHP/PHP-CS-Fixer`, то PhpStorm проверит, включена ли соответствующая инспекция и установлен ли набор правил. Если нет, можно будет вызвать `Alt(⌥)+Enter`, чтобы всё исправить:
Улучшения вывода типов PHP
--------------------------
Движок вывода типов — это основа PhpStorm, и в этой версии в нем было сделано несколько заметных изменений.
**Подсветка лишних тегов [var](https://habr.com/ru/users/var/)**
Добавлять теги `@var` — хороший способ подсказать PhpStorm тип переменной. Но мы постоянно улучшаем вывод типов, и некоторые такие объявления вполне могут оказаться избыточными, т. к. PhpStorm уже знает тип переменной.
Такие случаи будут подсвечены, и их можно удалить с помощью квик-фикса `Alt(⌥)+Enter` -> *“Remove [var](https://habr.com/ru/users/var/)”*:
**Отслеживание null-типов** — сложная задача, и были места, где PhpStorm не справлялся. Теперь в 2020.1 PhpStorm знает, когда переменная может быть null, а когда нет.
Вот примеры:
**Автодополнение для инициализированного массива**
Допустим, у вас есть массив с известными элементами, и позже вы пытаетесь итерироваться по нему. Раньше здесь не работало автодополнение, так как информация о типе терялась В 2020.1 всё работает:
**Автодополнение в array\_map/array\_filter**
В теле замыкания, которое передано в функции array\_map() и array\_filter(), теперь работает дополнение для аргументов.
Покрытие кода с помощью PCOV и PHPDBG
-------------------------------------
Строить покрытие кода можно с помощью [Xdebug](https://xdebug.org/). Но поскольку это прежде всего отладчик, то у него есть приличные накладные расходы. Чтобы ускорить получение отчета о покрытии, можно использовать более легковесные инструменты: расширение [krakjoe/pcov](https://github.com/krakjoe/pcov) или встроенный в PHP 5.6+ PHPDBG.
Оба теперь поддерживаются в PhpStorm. Нужно создать Run-конфигурацию для тестов и в настройках выбрать желаемый драйвер покрытия. Затем запустить тесты с подсчетом покрытия нажав кнопку :
> Подробнее о различиях в подсчете покрытия между Xdebug, PCOV, and phpdbg можно прочитать [в README](https://github.com/krakjoe/pcov#differences-in-reporting).
Инструментарий PHPUnit
----------------------
В недавно вышедшем PHPUnit 9 (и уже 9.1) много возможностей было удалено или объявлено устаревшими. Чтобы ускорить миграцию и предотвратить ошибки, мы добавили пачку инспекций и квик-фиксов.
**Создать новый тест для класса**
Вызвав `Alt(⌥)+Enter` на объявлении класса и выбрав *Create New PHP Test* можно быстро получить скелет для теста.
Метаданные
----------
Метаданные в файле `.phpstorm.meta.php` позволяют предоставить PhpStorm дополнительные сведения о вашем проекте и тем самым улучшить автодополнение кода. Например, эта возможность используется в [плагине Symfony](https://github.com/King2500/symfony-phpstorm-meta) и в [Laravel IDE Helper](https://github.com/barryvdh/laravel-ide-helper#phpstorm-meta-for-container-instances).
> Больше о возможностях метаданных можно узнать из доклада [PHP как инструмент разработки PhpStorm](https://www.youtube.com/watch?v=px7y0iRdNUY) на PHP Russia 2019.
В PhpStorm 2020.1 добавлен ряд улучшений для метаданных.
**Индекс параметра в директивах override, map, и type**
Раньше с помощью `override()`, `map()`, и `type()` можно было изменить поведение первого аргумента функций. В PhpStorm 2020.1 можно указать произвольный индекс параметра:
**Доступ к свойствам через \_\_get**
Если вы получали значения свойств через магический `__get()`, то информация о типе терялась. Можно было использовать дополнительные теги `@var` или `@property`, но не всегда это спасало. Теперь можно указать всё через метаданные.
**Автодополнение ключей в объектах, реализующих** **ArrayAccess**
Метаданные поддерживали объекты ArrayAccess, но подсказывали только тип значений. Теперь возможные ключи тоже автодополняются.
**Кастомные точки выхода**
PhpStorm рассматривает функции типа `die()` и `exit()` или бросание исключений как завершающие выполнение. Но в приложениях могут быть более сложные точки выхода. Например, простая `dd()` или функция [trigger\_error](https://www.php.net/manual/ru/function.trigger-error.php) с аргументом [E\_USER\_ERROR](https://www.php.net/manual/en/errorfunc.constants.php#errorfunc.constants.errorlevels.e-user-error).
В PhpStorm 2020.1 можно помечать функции как точки выхода, и это соответствующим образом скорректирует анализ потока выполнения.
**Иконки для функций, переопределенных через метаданные**
Напротив объявлений функций, чье поведение было изменено с помощью `override()`, `exitPoint()` или `expectArguments()`, будет отображаться иконка. Нажатие иконки откроет файл `.phpstorm.meta.php`, в котором и меняется поведение, т. к. файлов может быть несколько.
Иконки можно спрятать в *Preferences/Settings | Editor | General | Gutter Icons*.
Машинное обучение для сортировки списка дополнений
--------------------------------------------------
Добавили ранжирование вариантов автодополнения на основе машинного обучения.
**Как увидеть ML в действии?**
По умолчанию автодополнение с ML отключено. Не хотим, чтобы роботы лишили нас работы! Чтобы включить, надо зайти в настройки *Preferences/Settings | Editor | General | Code Completion* и включить опции *Rank completion suggestions based on Machine Learning* и *PHP*.
Если еще включить опцию *Show position changes in completion popup*, то тогда в списке автодополнения будет показано, как именно изменился порядок элементов.
Мы планируем предотвратить восстание машин продолжить работу в этом направлении в следующих версиях.
Новые инспекции
---------------
**Приватное свойство может быть локальной переменной**
Определение свойства будет подсвечено, если оно используется только в одном методе и сразу же в нем перезаписывается. Чтобы исправить, можно вызвать квик-фикс `Alt(⌥)+Enter` *“Replace property with local variable”*.
**Лишняя инициализация свойства**
Допустим, в классе у приватного свойства есть значение по умолчанию, но в конструкторе оно сразу же перезаписывается другим значением. В этом случае значение по умолчанию является избыточным и добавляет только шум.
Неиспользуемый инициализатор будет подсвечен, и его можно удалить квик-фиксом `Alt(⌥)+Enter` *“Remove redundant initializer”*.
**Изменить тип свойства в PHP 7.4 в соответствии со значением по умолчанию**
**Избыточный тернарный оператор**
PhpStorm подсветит тривиальные тернарные выражения и с помощью квик-фикса `Alt(⌥)+Enter` их можно заменить на более простые:
**Избыточная передача по ссылке**
Использование передачи по ссылке может привести к неожиданным последствиям, и это одна из причин, по которой Никита Попов предложил разрешить [явную передачу по ссылке при вызове функций](https://wiki.php.net/rfc/explicit_send_by_ref) в PHP.
Ну а пока, PhpStorm 2020.1 подсветит параметры объявленные как передаваемые по ссылке, но при этом не используемые в качестве таковых. Их можно безопасно удалить квик-фиксом `Alt(⌥)+Enter`.
То же самое будет работать и для массивов со ссылкой в foreach-цикле:
**Удалить лишний** **PHPDoc, в котором только объявление типов** теперь тоже довольно просто благодаря соответствующему квик-фиксу.
Правда, по умолчанию инспекция стоит на уровне *Info*, то есть подсвечивать не будет. Если вы хотите, чтобы лишние блоки PHPDoc подсвечивались, то для инспекции *Redundant PHPDoc comment* в *Preferences | Editor | Inspections* установите уровень *Weak Warning* или выше.
Обновленный рефакторинг “Move method”
-------------------------------------
Иногда может быть необходимо перенести метод в другой класс. Если этот метод используется много раз в коде проекта, то PhpStorm может тут помочь.
Раньше сначала нужно было сделать метод статическим, а потом уже вызвать еще одно действие, чтобы перенести его. В PhpStorm 2020.1 рефакторинг *“Move method”* переработан в одно атомарное действие. Убрали лишние шаги и попапы, и всё делается за один раз.
Наведите курсор на метод и нажмите `F6` (или `Ctrl+T`, `3`). Затем выберите целевой класс и всё готово.
> Чтобы посмотреть все [доступные рефакторинги](https://www.jetbrains.com/help/phpstorm/refactoring-source-code.html), можно нажать `Ctrl+T` в любом месте кода.
PHP Debug in HTTP Client
------------------------
Теперь, чтобы выборочно включать отладку, не нужно возиться с параметрами запроса или ставить расширение в браузере. Достаточно создать HTTP-запрос в файле `.http` и отправить его командой *PHP Debug*, которая доступна в меню `Alt(⌥)+Enter` или по нажатию иконки. В результате к запросу будет автоматически добавлена кука `XDEBUG_SESSION`.
И еще несколько мелочей для PHP
-------------------------------
**@deprecated-элементы отображаются как** **зачеркнутые** **в Structure tree view**
`Ctrl(⌘)+F12`
**Подсветка совпадающих тегов php / ?**
**Прыжок к открывающей/закрывающей скобке**
`Shift+Ctrl+M (⌃+M)`
**Кастомизация Lexer для Twig**
Иногда может понадобиться изменить символы тегов для шаблонов Twig, например если используется еще и Angular, у которого такой же синтаксис.
Сделать это можно в настройках *Preferences/Settings | Languages & Frameworks | PHP | Twig*.
IDE
---
### Продвинутый корректор правописания и грамматики Grazie
В PhpStorm из коробки включен плагин Grazie, которые проверяет текст не только на орфографические ошибки, но также на грамматику и стиль. Причем поддерживаются 16 языков, и все проверки выполняются локально без отправки ваших данных куда-либо.
По умолчанию проверки включены для Markdown-файлов.
Можно включить их также для всех строковых литералов, комментариев, блоков PHPDoc и сообщений коммитов.
Для PHP включить можно в ***Settings/Preferences******|******Editor | Proofread | Grammar***.
### Режим LightEdit
Иногда бывает нужно быстро посмотреть/поправить файл и открывать для этого целую IDE кажется слишком, но привычную подсветку и функции иметь хочется. Именно для таких случаев мы работаем над легковесным режимом LightEdit.
Работает это так: если вы открываете файл из командной строки или контекстного меню операционной системы, при этом PhpStorm не запущен, то файл откроется в LightEdit. Ну а если полноценный PhpStorm уже работает, то файл просто откроется в нем.
### [JetBrains Mono](https://www.jetbrains.com/lp/mono/) — шрифт по умолчанию
### Режим Zen
Новый режим сочетает в себе Distraction Free и Fullscreen для глубокого погружения в код.
*View | Appearance | Enter Zen Mode*
Интерфейс
---------
### Разделение окна терминала
Вместо открытия новых вкладок и переключения между ними, теперь можно разделить экран и открыть несколько сессий в одной вкладке. Для этого из контекстного меню терминала выбрать ***Split Horizontally / Vertically***.
**Тема IntelliJ Light**
Светлая тема немного обновлена и унифицирована, чтобы выглядеть одинаково на всех ОС, а ее название сменилось на *IntelliJ Light*.
**Кастомизация статусбара**
Из контекстного меню можно выбрать, какая информация будет на нем отображаться.
Конфигурация
------------
### Унифицированная конфигурация SSH
Раньше, если SSH-подключение переиспользовалось в деплойменте, Remote-интерпретаторе или SSH-терминале, его каждый раз приходилось конфигурировать заново.
Теперь все SSH-подключения можно добавлять/редактировать в разделе настроек *Preferences/Settings | Tools | SSH Configuration*, а затем использовать их многократно там, где они нужны.
### Изменился путь к конфигам IDE
Например, на macOS:
```
- ~/Library/Preferences/PhpStorm2019.3
+ ~/Library/Application Support/JetBrains/PhpStorm2020.1
```
Подробнее в [хелпе](https://www.jetbrains.com/help/phpstorm/2020.1/tuning-the-ide.html#default-dirs).
### Кастомный путь для сохранения Run-конфигураций
Раньше Run-конфигурации хранились в папке `.idea`, которую многие полностью добавляют в .gitignore (лучше [вот так](https://github.com/github/gitignore/blob/master/Global/JetBrains.gitignore)). Теперь можно выбрать любой путь и расшарить Run-конфигурацию с коллегами через систему контроля версий.
Может быть особенно удобно при онбординге новых сотрудников: стянул проект, открыл в PhpStorm, запустил одной кнопкой.
Чтобы сделать это, в диалоге Run/Debug-конфигурации нужно отметить опцию *Store as project file*, а по нажатии шестеренки можно выбрать желаемый путь в проекте.
Контроль версий
---------------
### Новый Commit
Окно Commit доступно в немодальном режиме и отображается слева. Таким образом оно не блокирует работу над другими файлами во время подготовки коммита, а на экране помещается больше информации об изменениях.
Новый Commit включен по умолчанию для новых пользователей и выключен для тех, у кого уже был установлен PhpStorm.
Включается опцией *Use non-modal commit interface* в *Preferences / Settings | Version Control | Commit*.
### Улучшения для работы с ветками Git
В нижнем правом углу окна IDE указана текущая ветка Git. Если нажать на нее, то откроется окно *VCS | Git | Branches*.
Здесь добавили поле для поиска. Кнопка Refresh обновляет список remote-веток. И для каждого коммита добавлен индикатор: входящий (синий) или исходящий (зеленый).
### Переработан интерактивный Rebase
Git Rebase позволяет переписать историю коммитов. Теперь можно быстро избавиться от «временных» коммитов, поправить сообщение или порядок коммитов. Конечно, всё это можно сделать и из консоли вручную, но PhpStorm позволяет тут же смотреть, что было изменено в том или ином коммите.
Чтобы начать, в истории коммитов нужно выбрать желаемый базовый коммит и из контекстного меню выбрать *Interactively rebase from here*.
Инструменты БД
--------------
PhpStorm включает в себя почти все возможности [DataGrip](https://www.jetbrains.com/datagrip/) «из коробки», так что можно посмотреть [обзор релиза DataGrip 2020.1](https://habr.com/ru/company/JetBrains/blog/495474/) от наших коллег.
Веб
---
И, как всегда, [все обновления из WebStorm 2020.1](https://habr.com/ru/company/JetBrains/blog/495228/) тоже входят в PhpStorm.
Полный список изменений можно найти в очень больших [release notes](https://confluence.jetbrains.com/display/PhpStorm/PhpStorm+2019.2+Release+Notes).
Обзор релиза можно также посмотреть на странице “[What’s new](https://www.jetbrains.com/ru-ru/phpstorm/whatsnew/)” и если у вас всего несколько минут, то вот короткий ролик (на английском) с демонстрацией главных фич релиза:
А на этом всё на этот раз. Спасибо, что дочитали до конца! Будем рады вопросам, пожеланиям, баг-репортам и просто мыслям в комментариях.
Берегите себя!
Ваша команда JetBrains PhpStorm | https://habr.com/ru/post/497358/ | null | ru | null |
# Использование Dynamic Data совместно с Entity Framework 5
Добрый день!
Как известно, уже вышла релиз-версия [.NET Framework 4.5](http://www.microsoft.com/net), а также стала доступна для загрузки финальная версия [Visual Studio 2012](http://www.microsoft.com/visualstudio/11/en-us).
Познакомиться с новой Visual Studio я успел еще с beta версии, а после релиза начал использовать rtm релиз Visual Studio и .NET Framework 4.5 в реальной работе.
В новую версию .NET Framework входит так же новая версия Entity Framework. Уже пятая. Точнее она туда не совсем входит — у меня при создании проекта файлы подгружаются из репозитория NuGet. Но в любом случае в новом проекте используется именно 5 версия библиотеки.
Прежде чем продолжить, хочу вкратце рассказать, что же нового появилось в EF5 и почему я решил начать использовать эту версию.
#### Что нового в Entity Framework 5.0
* Значительное повышение производительности — до 67%.
* Поддержка свойств типа enum, которая доступна для использования во всех подходах: Model, Database и Code First.
* Поддержка пространственные типов данных с использованием DbGeography и DbGeometry типов. Они также доступны в Model, Database и Code First подходах.
* При генерации кода редактор Visual Studio теперь будет использовать по умолчнию DbContext в качестве базового класса для новых моделей. Это означает, что любые новые модели, созданные с помощью конструктора EF будут создавать производные от DbContext и POCO классы по умолчанию. При это остается возможность вернуться к генерации кода на основе ObjectContext если это необходимо. Существующие модели не будет автоматически изменяться в поколение код DbContext.
* Функции теперь могут возвращающать пользовательские таблицы при применении подхода Database First.
Это не полный перечень, но и эти возможности заинтересовали меня достаточно сильно.
Более подробно о нововведениях можно узнать [тут](http://blogs.msdn.com/b/adonet/archive/2012/08/15/ef5-released.aspx).
#### Суть задачи
Во многих своих проектах для управления данными я применяю решение созданное на основе ASP.NET Dynamic Data (о том как именно можно применять это решение, и в целом инструменты реализующие технологию скаффолдинга — [я писал ранее](http://habrahabr.ru/post/141207/)). Как уже было сказано, в новой версии Entity Framework даже при использовании режима Database First теперь генерирует контекст на основе класса [DbContext](http://msdn.microsoft.com/en-us/library/system.data.entity.dbcontext.aspx), а не [ObjectContext](http://msdn.microsoft.com/en-us/library/system.data.objects.objectcontext.aspx), как было раньше. Dynamic Data предполагает же, что в качестве базового класса контекста используется именно ObjectContext.
В связи с этим, для корректной работы Dynamic Data пришлось немного изменить инициализацию контекста и работу некоторых контролов. Очень хорошую статью по этому поводу я нашел в [блоге Пранава Растоги](http://blogs.msdn.com/b/webdev/archive/2012/08/15/using-dynamic-data-with-entity-framework-dbcontext.aspx),
Думаю что эта информация пригодится тем, кто использует Dynamic Data и планирует переходить на новую версию Entity Framework.
#### Настройка ASP.NET Dynamic Data для взаимодействия с контекстом на основе DbContext
Для того, что бы Dynamic Data корректно работал с новым форматом необходимо сделать три простых шага.
##### 1. Измените код Global.asax в корне проекта
```
DefaultModel.RegisterContext(() =>
{
return ((IObjectContextAdapter)new YourContextType()).ObjectContext;
}, new ContextConfiguration() { ScaffoldAllTables = true });
```
##### 2. Измените код контрола ManyToMany.ascx.cs в директории Dynamicdata\Fieldtemplates
```
protected override void OnDataBinding(EventArgs e)
{
base.OnDataBinding(e);
object entity;
ICustomTypeDescriptor rowDescriptor = Row as ICustomTypeDescriptor;
if (rowDescriptor != null)
{
// Get the real entity from the wrapper
entity = rowDescriptor.GetPropertyOwner(null);
}
else
{
entity = Row;
}
// Get the collection and make sure it's loaded
var entityCollection = Column.EntityTypeProperty.GetValue(entity, null);
var realEntityCollection = entityCollection as RelatedEnd;
if (realEntityCollection != null && !realEntityCollection.IsLoaded)
{
realEntityCollection.Load();
}
// Bind the repeater to the list of children entities
Repeater1.DataSource = entityCollection;
Repeater1.DataBind();
}
public override Control DataControl
{
get
{
return Repeater1;
}
}
```
##### 3. Измените код контрола ManyToMany\_Edit.ascx.cs в директории Dynamicdata\Fieldtemplates
```
protected ObjectContext ObjectContext { get; set; }
public void Page_Load(object sender, EventArgs e)
{
// Register for the DataSource's updating event
EntityDataSource ds = (EntityDataSource)this.FindDataSourceControl();
ds.ContextCreated += (_, ctxCreatedEnventArgs)
=> ObjectContext = ctxCreatedEnventArgs.Context;
// This field template is used both for Editing and Inserting
ds.Updating += DataSource_UpdatingOrInserting;
ds.Inserting += DataSource_UpdatingOrInserting;
}
void DataSource_UpdatingOrInserting(object sender, EntityDataSourceChangingEventArgs e)
{
MetaTable childTable = ChildrenColumn.ChildTable;
// Comments assume employee/territory for illustration, but the code is generic
if (Mode == DataBoundControlMode.Edit)
{
ObjectContext.LoadProperty(e.Entity, Column.Name);
}
// Get the collection and make sure it's loaded
dynamic entityCollection = Column.EntityTypeProperty.GetValue(e.Entity, null);
// Go through all the territories (not just those for this employee)
foreach (dynamic childEntity in childTable.GetQuery(e.Context))
{
// Check if the employee currently has this territory
var isCurrentlyInList = ListContainsEntity(childTable, entityCollection, childEntity);
// Find the checkbox for this territory, which gives us the new state
string pkString = childTable.GetPrimaryKeyString(childEntity);
ListItem listItem = CheckBoxList1.Items.FindByValue(pkString);
if (listItem == null)
continue;
// If the states differs, make the appropriate add/remove change
if (listItem.Selected)
{
if (!isCurrentlyInList)
entityCollection.Add(childEntity);
}
else
{
if (isCurrentlyInList)
entityCollection.Remove(childEntity);
}
}
}
private static bool ListContainsEntity(MetaTable table, IEnumerable list, object entity)
{
return list.Any(e => AreEntitiesEqual(table, e, entity));
}
private static bool AreEntitiesEqual(MetaTable table, object entity1, object entity2)
{
return Enumerable.SequenceEqual(
table.GetPrimaryKeyValues(entity1), table.GetPrimaryKeyValues(entity2));
}
protected void CheckBoxList1\_DataBound(object sender, EventArgs e)
{
MetaTable childTable = ChildrenColumn.ChildTable;
// Comments assume employee/territory for illustration, but the code is generic
IEnumerable entityCollection = null;
if (Mode == DataBoundControlMode.Edit)
{
object entity;
ICustomTypeDescriptor rowDescriptor = Row as ICustomTypeDescriptor;
if (rowDescriptor != null)
{
// Get the real entity from the wrapper
entity = rowDescriptor.GetPropertyOwner(null);
}
else
{
entity = Row;
}
// Get the collection of territories for this employee and make sure it's loaded
entityCollection = (IEnumerable)Column.EntityTypeProperty.GetValue(entity, null);
var realEntityCollection = entityCollection as RelatedEnd;
if (realEntityCollection != null && !realEntityCollection.IsLoaded)
{
realEntityCollection.Load();
}
}
// Go through all the territories (not just those for this employee)
foreach (object childEntity in childTable.GetQuery(ObjectContext))
{
// Create a checkbox for it
ListItem listItem = new ListItem(
childTable.GetDisplayString(childEntity),
childTable.GetPrimaryKeyString(childEntity));
// Make it selected if the current employee has that territory
if (Mode == DataBoundControlMode.Edit)
{
listItem.Selected = ListContainsEntity(childTable, entityCollection, childEntity);
}
CheckBoxList1.Items.Add(listItem);
}
}
public override Control DataControl
{
get
{
return CheckBoxList1;
}
}
```
После проделанных изменений Dynamic Data как ни в чем не бывало продолжит работать и вы сможете и дальше наслаждаться процессом разработки.
---
#### Источники
Ниже привожу список ссылок, по теме статьи. Надеюсь они окажутся полезными.
* [blogs.msdn.com/b/webdev/archive/2012/08/15/using-dynamic-data-with-entity-framework-dbcontext.aspx](http://blogs.msdn.com/b/webdev/archive/2012/08/15/using-dynamic-data-with-entity-framework-dbcontext.aspx)
* [msdn.microsoft.com/ru-RU/data/ef](http://msdn.microsoft.com/ru-RU/data/ef)
* [blogs.msdn.com/b/adonet/archive/2012/08/15/ef5-released.aspx](http://blogs.msdn.com/b/adonet/archive/2012/08/15/ef5-released.aspx)
* [andrey.moveax.ru/news/2012-05-17/entity-framework-5-0-release-candidate](http://andrey.moveax.ru/news/2012-05-17/entity-framework-5-0-release-candidate/) | https://habr.com/ru/post/150012/ | null | ru | null |
# StereoPi — наша железка для изучения компьютерного зрения, дронов и роботов
Всем привет!
Сегодня я бы хотел рассказать вам о нашей новой железке на базе Raspberry Pi Compute Module, предназначенной для изучения компьютерного зрения и установки на роботов и дронов. По сути это «умная» стереокамера — она поддерживает работу с двумя камерами одновременно, имеет в качестве «сердца» настоящую малину и, самое важное – работает со стоковой версией Raspbian.
Вот как выглядит собранное решение, с установленными двумя камерами и Pi Compute модулем.
Устройство работает со стоковой версией Raspbian. Вам нужно только скопировать наш файлик dtblob.bin для того, чтобы включить поддержку двух камер.
Это означает, что вы можете использовать привычные raspivid, raspistill и другие утилиты для работы с изображениями и видео.
Для справки, поддержка режима стерео появилась в Raspbian аж в 2014 году, одновременно с выходом первой версии Raspberry Pi Compute. Вы можете посмотреть историю разработки поддержки стереорежима [на форуме Raspberry.](https://www.raspberrypi.org/forums/viewtopic.php?f=43&t=85012)
Перед описанием технических деталей позвольте показать вам несколько реальных примеров работы устройства.
1. Захват изображения
---------------------
Код:
```
raspistill -3d sbs -w 1280 -h 480 -o 1.jpg
```
и вы получаете следующее:
Вы можете скачать оригинальное захваченное изображение [вот тут](http://stereopi.com/sites/default/files/photo_1280_480.jpg).
2. Захват видео
---------------
Код:
```
raspivid -3d sbs -w 1280 -h 480 -o 1.h264
```
и вы получаете следующее:
Вы можете скачать оригинальный видеофайл (конвертирован в mp4) [по этой ссылке](http://stereopi.com/sites/default/files/1.h264.mp4).
3. Использование Python и OpenCV для построения карты глубин
------------------------------------------------------------
В этом случае я использовал слегка модифицированный код из предыдущего проекта 3Dberry (<https://github.com/realizator/3dberry-turorial>).
Для получения этих картинок и видео мы использовали вот такую пару камер:
Для установки на дронов чаще используем широкоугольные (160 градусов), вот такие:
Теперь чуть подробнее про саму железку
--------------------------------------
Технические детали
------------------
Вид спереди:
Вид сверху:
**Основные характеристики:**
**Размеры:** 90x40 mm
**Камеры:** 2 x CSI 15 lanes cable
**GPIO:** 40 classic Raspberry PI GPIO
**USB:** 2 x USB type A, 1 USB on a pins
**Ethernet:** RJ45
**Память:** Micro SD (for CM3 Lite), у остальных NAND (flash)
**Монитор:** HDMI out
**Питание:** 5V DC
**Поддерживаемые малины:** Raspberry Pi Compute Module 3, Raspberry Pi CM 3 Lite, Raspberry Pi CM 1
**Типы поддерживаемых камер:** Raspberry Pi camera OV5647, Raspberry Pi camera Sony IMX 219, HDMI In (одиночный режим)
**Для прошивки NAND:** MicroUSB connector
**Выключатель питания:** Да-да, это он. Больше никаких втыканий-вытыканий MicroUSB провода для ребута по питанию!
Немножко истории
----------------
Вообще затея сама появилась еще в 2015 году. Первая версия родилась в конце 2015 года. Некоторые знают, что у нашей команды есть «пунктик» на удаленном управлении разными механическими штуковинами, поэтому в первом релизе на борту был установлен дополнительный чип, дававший нам 16 PWM выходов — для руления сервами, моторчиками и прочими полезностями.
К тому моменту на рынке была только первая версия Compute модуля, на борту которой стоял старый процессор от самой первой распберри. Железка прекрасно справлялась с захватом, сжатием и стримом видео, но в конце концов мы уперлись именно в процессор. Например, её уже не хватало для одновременно стрима h264 пилоту и RTMP стрима на сервер. А для роботостроителей основной хотелкой стало построение карты пространства по карте глубин и SLAM — тут процессора не хватало совсем.
У тут на тебе — выходит версия Compute Module 3. Они сразу «перепрыгнули» с первой версии на третью, поставив процессор от третьей Raspberry. Теперь его мощности уже было достаточно, чтобы что-то обсчитывать на лету.
Однако оказалось что поколения вроде как и совместимы, а вроде как и не очень. Тот факт, что Compute Module 3 был на миллиметр шире нас не смутил. А вот требования к питанию серьезно поменялись.
К тому же у нас уже набралось замечаний по результатам работы с первой версией, и мы решили выпустить новую, в которой внесли все накопившиеся изменения.
Что исправлено во втором поколении
----------------------------------
**Добавили поддержку Compute Module 3**
У нас переключаемая схема питания, так что при желании можно работать и с первой малиной. Выбор тут простой: если нужно только транслировать видео — прекрасно хватает первой малины. В качестве бонуса идет её почти в три раза меньшее энергопотребление и тепловыделение. А нужно посчитать что-то посерьезнее (несколько видео либо компьютерное зрение) — ставим третью.
**Развернули модуль «чипами от платы»**
В первой версии перепутали тип разъема SoDIMM на плате, в результате компьют-модуль вставал чипами «к мамке». На Compute Module 1 это проблем не вызывало — проц грелся слабо, и узкого места между платами ему хватало для нормлаьного охлаждения. С третьим такой фокус бы не прокатил, поэтому мы «перевернули» коннектор, что повлекло за собой переразводку всей платы с чистого листа.
**Штатная поддержка MicroSD**
Первый компьют-модуль по умолчанию имел встроенную FLASH на борту и с микросд работать не умел. Мы попытались привесить туда MicroSD как второй накопитель, но столкнулись с большим головняком по его поддержке. Общение с кернельщиками на малиновом форуме показало, что проблема непростая (при загрузке модуль рандомно выбирал NAND или MicroSD для бута). В итоге на текущей ревизии мы сделали разводку как на референсной devboard от малины. Если Compute Module **Lite** — без встроенной NAND — работаем с микросд как в обычной малине. Если версия не Lite или первый модуль — микросд недоступна.
**Переместили коннекторы камер наверх и разнесли на 65 мм**
В первой версии коннекторы были направлены вдоль плоскости платы. Мелочь, но после множества установок в корпуса выяснилось несколько проблем.
* Из коннекторов торчит шлейф камеры, который желательно не гнуть (особенно синюю армированную часть). Это тупо занимало ненужное место в корпусе и мешало установке.
* Коннекторы были совсем рядом — это мешало работать со шлейфами.
* Камеры в корпусе обычно стоят на 65 мм стереобазу, а шлейфы на плате были рядом. Получается что каждый шлейф приходилось неестественно изгибать — надломы, разрывы, выскакивание из коннекторов.
**Убрали чип и дополнительные 16 PWM**
Проанализировав множество последних проектов поняли, что фича эта неактуальна. Чаще всего хватает и программных PWM малины.
**Добавили выключатель питания**
Те кто хоть немного работал с малиной понимают о чем речь :-)
**Добавили третий USB на пинах сбоку**
В наших малиновых проектах нам часто нужны USB донглы на борту. Если их втыкать в разъемы на плате — имеем торчащий далеко наружу модуль. Попытка воспользоваться USB удлинителем еще больше усугубляет проблему. Оставался один вариант — пайка проводками напрямую к малине. Добавленные нами боковые пины позволяют сделать простой удлинитель и расположить USB донгл (чаще WiFi или 4G) прямо вдоль платы, и всё это хозяйство прекрасно помещается в компактный корпус.
Вот такую вот историю я хотел вам сегодня поведать. Спасибо за внимание и готов ответить на вопросы. | https://habr.com/ru/post/415587/ | null | ru | null |
# В каких случаях не нужно использовать списки в Python
***Перевод статьи подготовлен в преддверии старта базового курса [«Разработчик Python»](https://otus.pw/EKMg/).***
---
В Python, наверное, самым популярным контейнером данных будет список (**list**). Он настолько гибкий, что его можно использовать в проектах почти повсеместно и хранить в нем данные различного типа: целые числа, строки и экземпляры пользовательских классов. Помимо этого, список мутабелен, что позволяет нам добавлять или удалять элементы по мере необходимости. По вышеперечисленным причинам некоторые программисты склонны слишком часто использовать списки и даже не рассматривать жизнеспособные альтернативы.
В этой статье, я хотел бы выделить пять вариантов использования, в которых можно найти лучшую альтернативу спискам.
1. Иммутабельность данных и хэширование – кортежи
-------------------------------------------------
Нам не всегда нужна возможность изменять контейнер данных. Иногда мы наоборот этого не хотим. В этом случае нам понадобится иммутабельный контейнер для хранения наших данных. Допустим, пользователь выбирает 4 цифры в качестве пароля в нашем приложении. Теоретически мы можем использовать объект типа **list** для хранения этих цифр. Однако иногда случаются непредвиденные обстоятельства и пароль каким-либо образом изменяется. Рассмотрим следующий фрагмент кода.
```
>>> code_list_saved = [5, 9, 0, 3]
>>> code_list_entered = [5, 9, 0, 3]
>>> code_list_saved == code_list_entered
True
>>> code_list_saved[2] = 7
>>> code_list_saved == code_list_entered
False
```
Изначально эти два списка расценивались как одинаковые, и пользователь мог с помощью этой комбинации разблокировать защищенную информацию. Однако теперь мы меняем одну цифру в сохраненном пароле, и пользователь теряет доступ. Таким образом, логично, что мы хотим, чтобы сохраненный пароль был неизменяемым.
В таком случае стоит рассмотреть использование кортежей. Как известно, они являются неизменяемыми объектами в Python, что означает, что значения в них нельзя изменить после создания. Альтернативная реализация с помощью кортежей показана ниже.
```
>>> code_tuple_saved = (5, 9, 0, 3)
>>> code_tuple_entered = (5, 9, 0, 3)
>>> code_tuple_saved == code_tuple_entered
True
>>> code_tuple_saved[2] = 7
Traceback (most recent call last):
File "", line 1, in
TypeError: 'tuple' object does not support item assignment
```
Как видно из кода выше, сохраненный пароль теперь хранится в кортеже (tuple). Попытка изменить одну из цифр вызывает ошибку **TypeError**, которая предотвратит любое непреднамеренное изменение данных. К тому же, в качестве простенькой меры безопасности, кортеж можно хэшировать прямо в Python. Храня пароли в объекте типа tuple, вы сможете получить хэш-значение для его представления, что сделает ваше приложение чуть более сложным для взлома. Посмотрите на упрощенную реализацию:
```
>>> code_picked = (5, 9, 0, 3)
>>> stored_code = hash(code_picked)
>>> -8016007988208603090
>>>
>>> code_attempt1 = (9, 5, 0, 3)
>>> hashed_attempt1 = hash(code_attempted)
>>> code_attempt2 = (5, 9, 0, 3)
>>> hashed_attempt2 = hash(code_attempt2)
>>> stored_code == hashed_attempt1
False
>>> stored_code == hashed_attempt2
True
>>> code_picked_list = [5, 9, 0, 3]
>>> hash(code_picked_list)
Traceback (most recent call last):
File "", line 1, in
TypeError: unhashable type: 'list'
```
2. Проверка принадлежности – множества
--------------------------------------
В зависимости от бизнес-задач вашего приложения часто случается такое, что нужно проверить есть ли в контейнере какой-то конкретный искомый элемент. Конечно, у списков есть все необходимые методы для проверки принадлежности. Как показано в коде ниже, мы можем просто использовать ключевое слово **in** для выполнения проверки, которая вернет логическое значение:
```
>>> integers = [1, 2, 3, 4, 5]
>>> 5 in integers
True
>>> 9 in integers
False
```
Однако, если в вашем приложении механика проверки принадлежности встречается достаточно часто, то следует рассмотреть возможность использования множеств (set) вместо списков. Множества – это еще один важный тип контейнера в Python. Отличительная особенность множества в том, что все элементы в нем уникальные и хэшируемые. Требование к хэшируемости выполняется поскольку под капотом Python реализует множества в виде хэш-таблиц. Одним из наиболее существенных преимуществ использования хэш-таблиц является реализация механизма константного времени поиска конкретных элементов.
Давайте проведем простое сравнение и посмотрим, насколько множества обойдут списки в производительности, когда речь зайдет о миллионах элементов в контейнерах:
```
>>> # Import needed modules
>>> from random import randint
>>> from timeit import timeit
>>>
>>> # Declare a function to measure the time for membership testing
>>> def time_membership_testing(n):
... integers_list = list(range(n))
... integers_set = set(range(n))
... t_list = timeit(lambda : randint(0, 2*n) in integers_list, number=10000)
... t_set = timeit(lambda : randint(0, 2*n) in integers_set, number=10000)
... return f"{n: <9} list: {t_list:.4} | set: {t_set:.4}"
...
>>> numbers = (100, 1000, 10000, 100000)
>>> for number in numbers:
... print(time_membership_testing(number))
...
100 list: 0.02304 | set: 0.01333
1000 list: 0.1042 | set: 0.01309
10000 list: 0.9028 | set: 0.01713
100000 list: 8.867 | set: 0.01932
```
Как видите, с увеличением количества элементов в списке, время проверки на принадлежность линейно увеличивается. Однако этого не скажешь о множестве, где время проверки принадлежности остается постоянным, и что важнее, необходимое время куда меньше, чем в случае списков.
3. Поиск значений – словари
---------------------------
По аналогии с множествами, о которых мы говорили выше, другой встроенный тип данных – **dict**, требует, чтобы его ключи были хэшируемыми.
Хэшируемость ключей подразумевает, что данные, хранящиеся в словарях, реализуются под капотом как хэш-таблицы. Как и другие популярные языки (например, Java, Swift, Kotlin), Python работает со словарями с использованием хэш-таблиц. Однако, в отличие от множеств, словари хранят в себе пары ключ-значение, и требование к хэшируемости ключей является фундаментом построения хэш-таблиц.
При использовании механизма хэширования, время, необходимое для извлечение конкретной пары ключ-значение, остается постоянным при временной сложности **O(1)** – в записи в нотации [Big-O](https://medium.com/swlh/time-complexity-of-algorithms-big-o-notation-explained-in-plain-english-e12a11dc4a4f). Временная сложность **O(1)** означает, что вне зависимости от того, сколько элементов в словаре, время извлечения конкретного элемента всегда останется одной и той же величиной. Сравнение вы видите ниже:
```
>>> # Import needed modules
>>> from random import randint
>>> from timeit import timeit
>>>
>>> # Declare a function to measure the time for value retrieval
>>> def time_value_retrieval_testing(n):
... id_list = list(range(n))
... score_list = list(range(n))
... scores_dict = {x: x for x in range(n)}
... t_list = timeit(lambda : score_list[id_list.index(randint(0, n-1))], number=10000)
... t_dict = timeit(lambda : scores_dict[randint(0, n-1)], number=10000)
... return f"{n: <9} list: {t_list:.4} | dict: {t_dict:.4}"
...
>>> numbers = (100, 1000, 10000, 100000)
>>> for number in numbers:
... print(time_value_retrieval_testing(number))
...
100 list: 0.02423 | dict: 0.01309
1000 list: 0.07968 | dict: 0.01322
10000 list: 0.625 | dict: 0.01565
100000 list: 6.223 | dict: 0.01583
```
Допустим, нам нужно сохранить оценки группы студентов. Если использовать тип **list**, то у нас будет один список, который будет хранить номера студенческих билетов, и второй – оценки, и элементы в этих списках будут располагаться в соответствии друг с другом. Чтобы узнать оценку конкретного студента, нужно будет узнать индекс студента из списка номеров студенческих билетов, а потом достать оценку из второго списка по этому индексу. В подходе со словарями мы просто будем хранить пары **student\_id-score**, где номер студенческого билета будет ключом. Как мы видели выше, в данном случае приоритетнее использовать словарь, а не список, особенно, когда количество записей большое.
Однако нужно отметить, что раз словари хранят пары ключ-значение, то ваша модель данных должна содержать осмысленную информацию, которая могла бы помочь идентифицировать значения. Кроме того, ключи в словаре должны быть уникальными, а вот значения могут быть одинаковыми.
4. First-In-First-Out – двусторонняя очередь
--------------------------------------------
Бывают ситуации, когда нужно часто добавлять элементы с одной, а удалять с другой стороны последовательности. То есть подразумевается порядок обработки элементов FIFO (First-in-first-out). Другими словами, первый добавленный элемент будет обработан первым. На списках мы можем реализовать эту конструкцию с помощью функции **pop(0)**. Однако ее выполнение требует больших временных затрат, поскольку элементы должны сдвигаться, что по сложности будет соответствовать **O(n)**.
Тип данных **deque**, напротив, является двусторонней очередью, которая предназначена для быстрого добавления и удаления элементов с обоих концов последовательности. Чтобы выполнить операцию FIFO, Python может непосредственно удалить элемент в начале очереди без необходимости сдвигать все элементы. Значит, операция FIFO будет выполнена быстро. Обратимся к сравнению ниже:
```
>>> # Import needed modules
>>> from collections import deque
>>> from timeit import timeit
>>>
>>> # Declare a function to measure the time for FIFO
>>> def time_FIFO_testing(n):
... integer_list = list(range(n))
... integer_deque = deque(range(n))
... t_list = timeit(lambda : integer_list.pop(0), number=n)
... t_deque = timeit(lambda : integer_deque.popleft(), number=n)
... return f"{n: <9} list: {t_list:.4} | deque: {t_deque:.4}"
...
>>> numbers = (100, 1000, 10000, 100000)
>>> for number in numbers:
... print(time_FIFO_testing(number))
...
100 list: 3.41e-05 | deque: 1.645e-05
1000 list: 0.0004852 | deque: 0.0003466
10000 list: 0.01762 | deque: 0.002618
100000 list: 2.059 | deque: 0.02067
```
5. Большие объемы табличных данных – массивы
--------------------------------------------
Python со временем стал широко использоваться в области Data Science для обработки, анализа и моделирования данных. Одной из причин быстро растущей популярности является разработка различных пакетов с открытым исходным кодом. Важно отметить, что есть реализованные кастомные классы для больших наборов данных. Поэтому вместо списков мы должны рассмотреть альтернативы, специально предназначенные для задач, связанных с вычислениями.
Например, если вам нужно обрабатывать большое количество числовых данных, можно подумать об использовании массивов **NumPy**, которые являются основным типом данных, реализованном в пакете **NumPy**. Если вам нужно работать со структурированными данными, где типы данных смешаны (например, строки, даты и числа), вы можете обратить внимание на **DataFrame из Pandas**, которые также являются основным типом данных для пакета **Pandas**. Если вы занимаетесь машинным обучением, вам определенно стоит углубиться в **тензоры**, которые считаются наиболее важными типами данных в популярных фреймворках машинного обучения, таких как **TensorFlow** и **PyTorch**.
В интернете вы можете найти множество туториалов и подробных описаний этих структур данных, поскольку разговор о них так или иначе выходит за рамки текущей статьи. Моя мнение таково, что, если вы работаете с большим количеством данных, вам определенно стоит обратить внимание на эти альтернативы. У них имеются реализации и на более низком уровне, что поможет оптимизировать большое количество операций.
Заключение
----------
Сегодня мы рассмотрели пять альтернатив спискам в Python.
Нужно помнить, что мы не должны ограничиваться использованием списков, поскольку Python и его пакеты предоставляют нам иные структуры данных, которые могут предложить более оптимальные решения для конкретных бизнес-задач.
Мой совет – будьте открыты к новому и убедитесь, что знаете свои возможности.
---
***Узнать подробнее о базовом курсе [«Разработчик Python»](https://otus.pw/bc8n/).***
--- | https://habr.com/ru/post/510350/ | null | ru | null |
# Security микросервисов с помощью Spring Cloud Gateway и TokenReley
Данная статья результат поиска некоего каноничного решения организации безопасности доступа к ресурсам в микросервисной архитектуре, построенной в экосистеме Spring. После прочтения десятка статей по данной тематике, к сожалению, не нашел то, что искал. Spring Security оказался одной из самых недопонятых технологий. Основная проблема у всех - изобретение своего велосипеда поверх стандартного функционала Spring Security. Зачастую, данные статьи сопровождаются комментариями никогда так не делать. И у многих, наверно, возникает вопрос, а как собственно можно делать. Ситуацию несколько прояснила официальная документация. Взяв её за основу, я хочу показать, как можно организовать безопасность микросервисов максимально простым и быстрым способом.
Для начала рассмотрим реализуемую схему authorization flow:
Как видно на картинке, дизайн состоит из трех служб: единой точки входящих запросов от пользователей, реализующей Gateway API, IDP сервера (Identity Provider), который аутентифицирует пользователей и выдает токен доступа и сервера ресурсов, который отдает данные. Входящий запрос, не прошедший проверку подлинности, поступает на Gateway и инициирует authorization flow. Gateway делегирует управление учетными записями пользователей и авторизацию IDP серверу. IDP сервер проверяет учетную запись пользователя и возвращает на Gateway токен доступа. Gateway прикрепляет токен к запросу пользователя и отправляет на сервер ресурса. Сервер ресурсов получает от IDP сервера открытый ключ для самостоятельной валидации токена и в случае успешной валидации возвращает запрашиваемые данные. В этой схеме нет ничего необычного, стандартный OAuth 2.0 подход, основная фишка здесь в том, что практически весь этот функционал доступен из коробки и реализуется подключением нужных зависимостей и конфигурированием property, без необходимости писать какой-то сложный код. Далее я приведу пример, как это можно реализовать, создав три соответствующих данной схеме микросервиса. Весь приведенный код доступен на [GitHub](https://github.com/Arjun7682/security-template).
### Spring Authorization Server
В качестве Single Sign-On Identity-провайдера я буду использовать **Spring Authorization Server**, как максимально простой способ поднять сервер авторизации в виде простого Spring Boot приложения, без дополнительных приседаний. При желании, здесь может быть Keyclock или другая сторонняя служба. Для создания сервера нам потребуются следующие зависимости:
```
org.springframework.boot
spring-boot-starter-security
org.springframework.boot
spring-boot-starter-web
org.springframework.security
spring-security-oauth2-authorization-server
0.3.1
```
В application.yml укажем порт:
```
server:
port: 9000
```
Далее мы создадим конфигурацию bean-компонентов Spring специфичных для OAuth.
```
@Configuration(proxyBeanMethods = false)
public class AuthorizationServerConfig {
@Bean
@Order(Ordered.HIGHEST_PRECEDENCE)
public SecurityFilterChain authServerSecurityFilterChain(HttpSecurity http) throws Exception {
OAuth2AuthorizationServerConfiguration.applyDefaultSecurity(http);
return http.formLogin(Customizer.withDefaults()).build();
}
@Bean
public RegisteredClientRepository registeredClientRepository() {
RegisteredClient registeredClient = RegisteredClient.withId(UUID.randomUUID().toString())
.clientId("gateway")
.clientSecret("{noop}secret")
.clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC)
.authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
.authorizationGrantType(AuthorizationGrantType.REFRESH_TOKEN)
.redirectUri("http://127.0.0.1:8080/login/oauth2/code/gateway")
.scope(OidcScopes.OPENID)
.scope("resource.read")
.build();
return new InMemoryRegisteredClientRepository(registeredClient);
}
@Bean
public JWKSource jwkSource() {
RSAKey rsaKey = generateRsa();
JWKSet jwkSet = new JWKSet(rsaKey);
return (jwkSelector, securityContext) -> jwkSelector.select(jwkSet);
}
private static RSAKey generateRsa() {
KeyPair keyPair = generateRsaKey();
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
return new RSAKey.Builder(publicKey)
.privateKey(privateKey)
.keyID(UUID.randomUUID().toString())
.build();
}
private static KeyPair generateRsaKey() {
KeyPair keyPair;
try {
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(2048);
keyPair = keyPairGenerator.generateKeyPair();
} catch (Exception ex) {
throw new IllegalStateException(ex);
}
return keyPair;
}
@Bean
public ProviderSettings providerSettings() {
return ProviderSettings.builder()
.issuer("http://localhost:9000")
.build();
}
}
```
В `authServerSecurityFilterChain` настраиваем bean-компонент для применения безопасности OAuth по умолчанию и создадим страницу входа в форму.
В `registeredClientRepository` настраиваем репозиторий клиентских сервисов. В нашей архитектуре клиентом будет **Spring Cloud Gateway**, и соответственно здесь мы задаем интеграцию с ним:
* Client ID — Spring будет использовать его для определения того, какой клиент пытается получить доступ к ресурсу.
* Client secret code — секрет, известный клиенту и серверу, который обеспечивает доверие между ними.
* Authentication method — в нашем случае мы будем использовать обычную аутентификацию, которая представляет собой просто имя пользователя и пароль.
* Authorization grant type — мы хотим, чтобы клиент мог генерировать как код авторизации, так и токен обновления.
* Redirect URI — клиент будет использовать его в потоке на основе перенаправления.
* Scope — этот параметр определяет полномочия, которые может иметь клиент. В нашем случае у нас будет обязательный OidcScopes.OPENID и наш пользовательский resource.read.
В `jwkSource` настраиваем ключ подписи для токенов для сервера авторизации.
В `providerSettings` зададим URL-адрес, который провайдер будет использовать в качестве своего идентификатора.
Затем добавим дефолтный конфиг Spring Security:
```
@EnableWebSecurity
public class DefaultSecurityConfig {
@Bean
SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {
http
.authorizeRequests(authorizeRequests ->
authorizeRequests
.anyRequest()
.authenticated()
)
.formLogin(withDefaults());
return http.build();
}
@Bean
UserDetailsService users() {
UserDetails user = User.withDefaultPasswordEncoder()
.username("admin")
.password("password")
.roles("USER")
.build();
return new InMemoryUserDetailsManager(user);
}
}
```
Здесь, в `defaultSecurityFilterChain` мы вызываем uthorizeRequests.anyRequest().authenticated(), чтобы требовать аутентификацию для всех запросов. Мы также предоставляем аутентификацию на основе форм, вызывая метод formLogin(defaults()).
В `users` мы определим набор пользователей, которых мы будем использовать для тестирования. Для этого примера мы создадим репозиторий только с одним пользователем-администратором.
На этом, с сервером авторизации всё.
### Spring Cloud Gateway
Здесь будет происходить самое интересное. Помимо своей стандартной функции маршрутизации входящих запросов, Spring Cloud Gateway будет интегрирован с сервисом авторизации и будет реализовывать механизм Token Reley - как только сервер авторизации передаст шлюзу токен, шлюз помещает его в заголовок запроса к сервису, который проксирует. Для создания сервера нам потребуются следующие зависимости:
```
org.springframework.boot
spring-boot-starter-oauth2-client
org.springframework.cloud
spring-cloud-starter-gateway
```
Далее настроим application.yml:
```
server:
port: 8080
spring:
cloud:
gateway:
routes:
- id: resource
uri: http://127.0.0.1:8090
predicates:
- Path=/resource
filters:
- TokenRelay=
- RemoveRequestHeader=Cookie
security:
oauth2:
client:
registration:
gateway:
provider: spring
client-id: gateway
client-secret: secret
authorization-grant-type: authorization_code
redirect-uri: "{baseUrl}/login/oauth2/code/{registrationId}"
scope: openid,resource.read
provider:
spring:
issuer-uri: http://localhost:9000
```
В секции`spring.cloud.gateway.routes` мы задаем конфигурацию маршрута до микросервиса ресурсов. Помимо собственно маршрута, здесь интересны два момента:
* Фильтр `- TokenRelay=` задает бин TokenRelayGatewayFilterFactory в качестве фильтра в конфигурации маршрута для нашего сервера ресурсов, который будет осуществлять пересылку токена.
* Фильтр `- RemoveRequestHeader=Cookie` сообщает шлюзу удалить за ненадобностью куки из запроса, для получения доступа нам достаточно токена.
В секции `spring.oauth2.client.registration` мы задаём интеграцию с Identity-провайдером, в нашем случае со Spring Authorization Server. Информация, указанная здесь, будет сопряжена с той, что мы указывали в бине RegisteredClientRepository, когда конфигурировали AuthorizationServerConfig при создании сервера авторизации, поэтому отдельно описывать каждый пункт не буду, они аналогичны. Дополню только, что в `issuer-uri` мы должны указать адрес нашего Identity-провайдера.
На этом здесь всё, переходим к серверу ресурсов.
### Resource Server
Сервер ресурсов будет валидировать токен и отдавать данные по REST. Перейдем к созданию, нам потребуются следующие зависимости:
```
org.springframework.boot
spring-boot-starter-oauth2-resource-server
org.springframework.boot
spring-boot-starter-security
org.springframework.boot
spring-boot-starter-web
```
Далее настроим application.yml:
```
server:
port: 8090
spring:
security:
oauth2:
resourceserver:
jwt:
issuer-uri: http://localhost:9000
```
Здесь мы указываем порт приложения и адрес нашего Identity-провайдера, с которого сервер ресурсов будет получать открытую часть ключа для самостоятельной валидации JWT токена.
Далее настроим WebSecurityConfig:
```
@EnableWebSecurity
public class ResourceServerConfig {
@Bean
SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
http
.mvcMatcher("/resource/**")
.authorizeRequests()
.mvcMatchers("/resource/**")
.access("hasAuthority('SCOPE_resource.read')")
.and()
.oauth2ResourceServer()
.jwt();
return http.build();
}
}
```
Здесь мы указываем, что каждый запрос к ресурсам должен быть авторизован и иметь права resource.read. `oauth2ResourceServer()` настраивает соединение с Identity-провайдером на основе данных, которые мы указали в application.yml.
Далее создаем REST контроллер:
```
@RestController
public class ResourceController {
@GetMapping("/resource")
public String getResource() {
return "Resource";
}
}
```
Здесь мы будем просто возвращать строку.
На этом всё, теперь запустим и посмотрим как это работает.
### Запуск и тестирование:
Откроем браузер и перейдем по ссылке 127.0.0.1:8080/resource. Порт в URL указываем принадлежащий Gateway серверу. После перехода по ссылке нас редиректит на форму ввода логина и пароля:
После ввода логина и пароля у нас происходит успешная авторизация и мы получаем данные:
На этом всё, надеюсь, было полезно, если есть какие-то замечания - пишите.
Для подготовки статьи использовались следующие материалы:
* [Spring Security OAuth Authorization Server](https://www.baeldung.com/spring-security-oauth-auth-server)
* [Using Spring Cloud Gateway with OAuth 2.0 Patterns](https://www.baeldung.com/spring-cloud-gateway-oauth2)
* [Securing Services with Spring Cloud Gateway](https://spring.io/blog/2019/08/16/securing-services-with-spring-cloud-gateway)
* [Client Token Relay in Spring Cloud Gateway](https://docs.spring.io/spring-cloud-security/docs/current/reference/html/#_token_relay)
[Ссылка проекта на GitHub](https://github.com/Arjun7682/security-template) | https://habr.com/ru/post/701912/ | null | ru | null |
# Kali Linux NetHunter на Android Ч.2: атаки на беспроводные сети
**Статьи из цикла**
[Kali Linux NetHunter на Android: зачем и как установить](https://habr.com/ru/company/tomhunter/blog/465045/)
[Kali Linux NetHunter на Android Ч.2: атаки на беспроводные сети](https://habr.com/ru/company/tomhunter/blog/471260/)
[Kali Linux NetHunter на Android Ч.3: нарушение дистанции](https://habr.com/ru/company/tomhunter/blog/513226/)
И снова здравствуй, мой любознательный друг! Как ты, наверняка, помнишь, в прошлой [статье](https://habr.com/ru/company/tomhunter/blog/465045/) мы говорили об установке NetHunter на Android устройство. Сейчас мы займемся практической частью и обзором возможностей NetHunter. В этой статье рассмотрим некоторые атаки на беспроводные сети, с использованием исключительно Android-устройства с установленным NetHunter, с оглядкой на практический смысл для начинающего пентестера/специалиста ИБ. Вся информация представлена исключительно в ознакомительных целях, и автор не несет никакой ответственности за ее использование.
Для удобства работы с NetHunter в домашних условиях советую использовать microUSB-USB-хаб с возможностью подведения внешнего питания (например, Ginzzu OTG USB hub), внешнюю USB клавиатуру, мышь и дополнительный USB WiFi-адаптер из [списка поддерживаемых](https://github.com/offensive-security/kali-nethunter/wiki/Wireless-Cards) (понадобится для некоторых атак, если твоя сетевая карта на устройстве не имеет режима мониторинга). Я использовал TP-Link TLWN722N. Если нет возможности подключить физическую клавиатуру, используй приложение “Hacker`s keyboard”, эта клавиатура гораздо больше подходит для работы с терминалом. А еще загляни в [магазин приложений NetHunter](https://store.nethunter.com/en/packages/index.html), он небольшой, но там все очень нужное.
Подмена MAC
или
когда на интернет не осталось денег
------------------------------------------------------
Некоторое время назад был принят ряд законов, который предусматривает обязательную авторизацию при использовании общедоступных беспроводных сетей. Самая популярная схема авторизации: подключаешься к открытому WiFi, тебя перенаправляет на страницу авторизации, вводишь номер телефона (привязан к твоим паспортным данным), вводишь код из СМС, маршрутизатор авторизует тебя по MAC-адресу, пользуешься Интернетом. Похожая схема может работать и в сетях с платным доступом в Интернет. В общем случае маршрутизатор распознает авторизованного пользователя именно по MAC-адресу. Теме авторизации в общедоступных сетях посвящено несколько интересных статей ([статья 1](https://habr.com/ru/post/423931/), [статья 2](https://habr.com/ru/post/358866/), [статья 3](https://habr.com/ru/post/459348/)).
Следовательно, если прослушивая эфир, поймать MAC-адрес авторизованного пользователя и подменить им свой MAC, а затем подключиться к этой сети, когда уже авторизованный пользователь отключился, то получится сидеть в Интернете без регистрации и СМС. Это один из возможных сценариев. Еще с помощью подмены MAC-адреса можно обходить фильтрацию по MAC на роутерах. Относительно простая и достаточно полезная штука, поэтому давай посмотрим, как это работает.
Первым делом надо узнать интерфейс WiFi-адаптера. Заходим в Терминал (предустановленное приложение Nethunter), выбираем shell “Kali” и набираем команду:
```
iwconfig
```
*Беспроводные сетевые интерфейсы*
Помимо прочего, видно 2 интерфейса: wlan0 — встроенная сетевая карта, wlan1 — подключенная сетевая карта.
Будем пользоваться внешней сетевой картой, так как встроенная у моего гаджета (Nexus 10) не поддерживает режим мониторинга сети.
```
airmon-ng start wlan1
```
> После начала мониторинга имя интерфейса может поменяться. А может и не поменяться, у меня и такое было :)
Получим список сетей:
```
airodump-ng wlan1mon
```
*Aircrack-ng. Список найденных сетей.*
А вот и тренировочная сеть “Asus”. Определим клиентов этой сети:
```
airodump-ng -c CHANEL --bssid F4:**:**:**:**:A4 wlan1mon
```
*Aircrack-ng. Клиенты выбранной сети*
Мы получили MAC-адреса подключенных устройств. Чтобы не отключать уже имеющиеся устройства от сети, упростим задачу: подключимся к сети с произвольным MAC. Если мы смогли подключиться с выбранным нами MAC, то сможем подключиться и с MAC-адресом жертвы.
В сети мы обнаружили MAC 20:\*\*:\*\*:\*\*:\*\*:7B, подключимся с MAC 20:\*\*:\*\*:\*\*:\*\*:7C.
Смена MAC-адреса обычно требует наличия root-прав (на некоторых устройствах данная операция возможна и без root). У нас же root установлен и есть приложение NetHunter с пунктом в меню “MAC Changer”, воспользуемся им.
Установим на интерфейс wlan0 (для подключения к сети через графический интерфейс), выберем пункт Custom MAC и введем нужное нам значение.
*Скриншот со старым MAC-адресом интерфейса wlan0*
*Скриншот с новым MAC-адресом интерфейса wlan0*
И теперь подключаемся к нашей тестовой сети.
*Проверка смены MAC-адреса через терминал*
Ты великолепен! MAC сменен, и мы даже получили новый IP.
> 1. MAC возвращается на исходный после перезагрузки устройства.
> 2. После смены MAC у меня возникли проблемы с подключением в защищенные сети. К сетям без пароля устройство подключается на раз. Возможно, у тебя данной проблемы не будет, не могу протестировать работу на других устройствах.
>
### Взлом WiFi сети
Предисловие: сразу оговорюсь, если будешь экспериментировать в деревне у бабушки, где мобильный Интернет ловит только с ближайшей сосны, а соседский Wi-Fi так и манит, стоит сразу запастись хорошим словарем типа **rockyou**.
#### Wifite
Консольная утилита, которая “делает все сама”. Тебе остается только запустить ее, выбрать интерфейс и сеть для атаки. В случае, если в словаре присутствует пароль, программа сообщит нам об успешном взломе и покажет пароль.
*wifite. Доступные сети*
*wifite. Взлом пароля сети*
#### Aircrack-ng + wpaclean
“Ручной способ” взлома WiFi помогает глубже окунуться в механику работы волшебных волн. Дальше мы будем мониторить эфир, найдем интересующую сеть, посмотрим ее клиентов и отключим кого-нибудь, чтобы перехватить заветный handshake при повторном подключении жертвы. Дальше с помощью словаря и утилиты aircrack-ng будем локально его взламывать. Итак, приступим.
Открываем приложение терминала, запускаем Kali shell и начинаем работать. Переводим карту в режим мониторинга и ищем жертву:
```
airmon-ng start wlan1
airodump-ng wlan1mon
```
*Aircrack-ng. Список доступных сетей*
Определившись с целью, начинаем прослушивать эфир с целью поиска и записи “хендшейка”.
```
airodump-ng wlan1 --bssid F4:**:**:**:**:A4 --channel 4 --write handshake --wps
```
Он передается, когда кто-нибудь пытается заново подключиться к точке доступа. Поэтому поможем одному из клиентов это сделать, отправив запрос на деаутентификацию в соседнем окне терминала:
```
aireplay-ng -0 10 –a F4:**:**:**:**:A4 –c 20:**:**:**:**:7B wlan1mon
```
Если все сделано правильно, то в первом окне получим запись о пойманном хендшейке.
*Aircrack-ng. Перехват хендшейка*
Файлы перехвата сохраняются в корневой директории root с маской handshake-\*\*.cap. Скопируем для удобства в другую папку:
```
mkdir work
cp handshake-01.cap work/wpa.cap
cd work
```
Очищаем файл для дальнейшего брутфорса:
```
wpaclean wpaclean.cap wpa.cap
```
И поиск пароля через брутфорс:
```
aircrack-ng wpa.cap –w /usr/share/dict/wordlist.txt
```
*Aircrack-ng. Пароль от WiFi-сети*
И снова ты великолепен!
#### Hijacker
На моем устройстве (Nexus 10) это приложение работало крайне нестабильно, поэтому его использование для данной задачи пришлось прервать. Кое-как получилось просканировать сети с использованием внешней сетевой карты и все.
Данная программа имеет графический интерфейс и предназначена для атак на WiFi, работает на основе пакета aircrack-ng, дополнительно устанавливает утилиту Nexmon, которая на некоторых встроенных сетевых картах устройств добавляет режим мониторинга (например: Nexus 5, Nexus 6, Nexus 6P и [другие](https://github.com/seemoo-lab/nexmon)).
### Сбор информации
Итак, мы получили пароль и подключились к сети. Что дальше? Нужно понять, куда мы попали и начать искать новую жертву. Тут вариантов масса:
* zAnti — просканирует, да еще и эксплойты подберет;
* cSploit — схожий с zAnti функционал;
* nmap — любимый сетевой сканер, куда ж без него;
* и другие.
Этого набора вполне хватит, чтобы понять, какие устройства есть в сети и куда дальше двигаться. Выберем роутер и попробуем получить доступ к его админке.
*zAnti. Пример интерфейса*
*cSploit. Пример интерфейса*
*nmap. Пример интерфейса*
### Bruteforce (взлом админки)
Если сосед твоей бабушки немного пытался в информационную безопасность и настроил фильтрацию по MAC или еще почему-то, но тебе понадобилось попасть в админку роутера, не зная пароль, то тебе пригодятся атаки перебора (bruteforce). Для этого нам нужно:
1. Анализатор трафика.
2. Программа для атаки перебором.
3. Мощный словарик.
Перед атакой частенько нужно посмотреть, как выглядит запрос, отправляющий введенную информацию (авторизационные формы). Можем перехватывать трафик интерфейса (Intercepter-ng, tshark), но тут будут проблемы при пользовании сайтом HTTPS. А можно использовать прокси и видеть непосредственно запросы-ответы приложений.
Поэтому я советую [Debug Proxy](https://www.amazon.com/Prixy-Apps-Debug-Proxy/dp/B07B8LPT7M). К нему необходимо отдельно установить сертификат приложения, выбрать отслеживаемые приложения и нажать на треугольник Play для запуска прокси. Приложение перенаправляет трафик с выбранных приложений на ваш прокси (поднимается на устройстве) с помощью фейкового VPN-соединения. И все тайное становится явным, (я про HTTPS). Правда, приложения со встроенным сертификатом (SSL pinning), такие как Facebook и Instagram работать через этот прокси не будут.
Чаще всего встречаются аутентификация через HTTP Basic и HTTP Post (Get) Request, их и разберем.
Так как у нас есть в наличии терминал Kali, мы можем использовать почти любые инструменты для брутфорса, которые работают на этой платформе. Я выбрал [Patator](https://github.com/lanjelot/patator).
#### HTTP Basic auth
Приблизительно так выглядит аутентификация HTTP Basic для пользователя:
*Пример аутентификации HTTP Basic*
Запрос аутентификации выглядит следующим образом:
*Debug Proxy. Запрос HTTP Basic аутентификации*
Команда для Patator выглядит следующим образом:
`python patator.py http_fuzz auth_type=basic url=http://192.168.2.1 user_pass=FILE0:FILE1 -x ignore:code=401 0=/usr/share/dict/users.txt 1=/usr/share/dict/wordlist.txt`
Результат успешной атаки — полученные учетные данные администратора роутера.
*Patator. Подобранные логин и пароль*
**Аутентификация через POST-запрос**
*Пример формы POST*
Наш POST-запрос.
*Debug Proxy. Запрос HTTP POST аутентификации*
В нем есть все необходимые данные для проведения атаки.
Команда для Patator:
```
python patator.py http_fuzz url="http://192.168.1.139/dvwa/" method=POST body="username=FILE0&password=FILE1&Login=Login" accept_cookie=1 header="Cookie: security=low; PHPSESSID=***" 0=/usr/share/dict/users.txt 1=/usr/share/dict/wordlist.txt -x ignore:fgrep="login.php"
```
И снова успех, учетные данные получены.
*Patator. Подобранные логин и пароль*
### Подитог
NetHunter обеспечивает достаточно большой функционал, мало чем уступая полноценному дистрибутиву Kali Linux. Комбинация из приложений для Android, терминала Kali Linux и большой мобильности открывает, мой любознательный друг, интересные возможности.
Позже мы рассмотрим другие атаки, которые можно провести с помощью NetHunter, будет интересно :)
И помни, ты потрясающий!
**Статьи из цикла**
[Kali Linux NetHunter на Android: зачем и как установить](https://habr.com/ru/company/tomhunter/blog/465045/)
[Kali Linux NetHunter на Android Ч.2: атаки на беспроводные сети](https://habr.com/ru/company/tomhunter/blog/471260/)
[Kali Linux NetHunter на Android Ч.3: нарушение дистанции](https://habr.com/ru/company/tomhunter/blog/513226/) | https://habr.com/ru/post/471260/ | null | ru | null |
# Joomla 4: мощь CLI приложений
Эта статья - дополненный (комментариями и скриншотами) перевод статьи июньского номера Joomla Community Magazine за 2022 год, автор - [Brendan Hedges](https://magazine.joomla.org/authors/brendanhedges). Далее повествование автора.
В Joomla 4 из коробки поставляется новый, улучшенный CLI (интерфейс командной строки), который входит в состав в ядра. Теперь вы можете выполнять задачи технического обслуживания, даже не заходя на свой веб-сайт. Давайте выясним, как это сделать.
"Одна Joomla для всех" - это громкое заявление! Но это действительно так. С одной стороны, Joomla - это удобная CMS с интуитивно понятной панелью администратора даже для начинающих пользователей. И в то же время Joomla - это мощное CMS-приложение [*под капотом - полноценный PHP-фреймворк - Т.С.*], которое обладает множеством функций для продвинутых пользователей. Таким образом, Joomla идеально подходит для всех веб-приложений: от простых 5-страничных сайтов-визиток до сложных и высоконагруженных интернет-магазинов. [*Кстати, по теме:* [*История взлёта и падения новостного сайта от 10 тысяч до 1 млн уников в сутки и обратно и при чём тут Joomla!*](https://vc.ru/life/428975-istoriya-vzleta-i-padeniya-novostnogo-sayta-ot-10-tysyach-do-1-mln-unikov-v-sutki-i-obratno-i-pri-chem-tut-joomla) *- Т.С.*]
На самом деле, если вы просмотрите [JED](http://extensions.joomla.org/) (каталог расширений Joomla), Вы найдёте там расширения, позволяющие сделать практически всё, что бы Вы ни захотели создать. Если для вашего будущего веб-сайта нет расширения - не волнуйтесь. Существуют доступные расширения, которые помогут вам создать свое собственное индивидуальное расширение для Joomla.
Вы даже можете начать с нуля и использовать стандартную и хорошо структурированную платформу Joomla для создания собственного расширения. В случае успеха вы можете добавить его в JED и позволить другим пользователям использовать ваше расширение.
### Это было бы круто, правда?
Одна из особенностей Joomla, в частности Joomla 4, дающая такие возможности - это новый улучшенный [*по сравнению с Joomla 3 - Т.С.*] CLI (интерфейс командной строки), поставляемый в ядре Joomla 4.
Давайте посмотрим на CLI и узнаем для чего его можно использовать.
С годами технологии совершенствуются, Joomla позволяет выполнять определенные задачи все легче и проще, даже не заходя в админку сайта. Недавно мы говорили о [планировщике задач Joomla](https://magazine.joomla.org/all-issues/march-2022/get-to-know-the-new-joomla-task-scheduler) [*Joomla Community Magazine: Get to know the new Joomla! Task Scheduler - текст на английском языке - Т.С.*], который позволяет настраивать задания Cron для повторяющихся задач из самой Joomla. Существует также Joomla API, который можно использовать для управления Joomla с удаленного источника / веб-сайта. Существует также интерфейс командной строки Joomla.
Joomla CLI - это способ подключения к вашему сайту на Joomla и выполнения задач с удаленного терминала, например, по SSH с панели управления хостингом вашего веб-сайта.
Это особенно удобно и экономит время, если вы запускаете несколько сайтов с одного аккаунта хостинга.
Давайте начнем со знакомства с интерфейсом командной строки.
Что такое CLI?
--------------
Интерфейс командной строки (CLI) - это текстовый пользовательский интерфейс (UI), который используется для запуска программного обеспечения, управления компьютерными файлами и взаимодействия с компьютером /сервером. Интерфейс командной строки позволяет пользователю отвечать на визуальные подсказки, вводя отдельные команды в интерфейсе, а затем получать ответы таким же образом. Командная строка Windows - это интерфейс, с которым вы уже знакомы.
Консоль командной строки в WindowsПользователи реагируют на визуальные подсказки, вводя команду в указанной строке и получая ответ от операционной системы. Это программное обеспечение выдает подсказку, пользователи отвечают, а затем приложение последовательно реагирует на команды. Благодаря этому взаимодействию команд и ответов пользователь может выдавать набор команд, которые выполняются системой или приложением, таким как Joomla.
Доступные подсказки и команды зависят от вашей операционной системы и конкретного интерфейса командной строки, но могут быть сотни, если не тысячи, различных исполняемых команд. Многие команды одинаковы для разных платформ, и вы вполне можете быть знакомы с некоторыми из них. Однако есть некоторые команды, которые специфичны для конкретного интерфейса командной строки и используемого вами приложения.
Возможно, вы уже знакомы с различными приложениями, в которых можно использовать интерфейс командной строки. Распространенные приложения включают в себя "Терминал" на компьютерах Mac, в Windows он известен как "командная строка", а на вашем веб-сервере в панели управления его называют как SSH.
Ввод текстовых команд для управления вашим приложением на первый взгляд может показаться сложным, однако этим частенько пользуются в Linux и других операционных системах на базе Unix. Этим навыком стоит овладеть, если вы хотите стать разработчиком сайтов. Как только вы познакомитесь с терминологией использования CLI, вы обнаружите и другие варианты использования, с которыми столкнетесь по мере оттачивания своих навыков.
Например, использование Node.js для создания веб-приложения в среде разработки (такой как [Jet Brains Webstorm](https://www.jetbrains.com/webstorm)) или выполнение команд в облаках Amazone с использованием программ терминала в духе PuTTY или SSH.
Однако существуют доступные "оболочки" с графическим интерфейсом, которые считаются более простыми в использовании новичками. Хотя, строго говоря, термин "оболочка" обычно используется для описания интерпретатора командной строки. Оболочкой может быть любая программа, содержащая пользовательский интерфейс, включая полностью графически ориентированные программы.
Где находится CLI Joomla?
-------------------------
В отличие от многих других расширений Joomla, которые вы можете найти в панели администратора Вашего сайта Joomla, CLI Joomla является частью ядра. Таким образом, нет никаких настроек, с которыми нужно возиться, он просто есть и тихо работает в фоновом режиме вашего веб-сайта Joomla.
Как использовать CLI Joomla?
----------------------------
Сначала о главном. Прежде чем вы сможете получить доступ к интерфейсу Joomla CLI, вам нужно будет создать способ прямого подключения к хосту вашего веб-сайта без фактического входа в Joomla или Cpanel вашего хоста.
Cpanel рекомендует использовать настольное приложение под названием "PuTTY", если вы запускаете Windows на своем компьютере, хотя, если вы используете Windows 10 или более позднюю версию, у него есть собственный SSH-клиент Windows, к которому вы можете получить доступ из командной строки.
Чтобы получить доступ к командной строке, откройте диалоговое окно "Выполнить", нажав клавишу Windows + r. Затем в диалоговом окне Выполнить введите cmd и нажмите кнопку ОК, чтобы открыть окно командной строки.
Если вы используете Linux или используете Mac, вполне возможно, что у вас уже установлено программное обеспечение для прямого подключения к серверу вашего веб-сайта. На основе этой статьи я предположу, что вы используете Windows, как и я.
Каждый способ доступа к серверу вашего веб-сайта похож, но вам придется сначала настроить SSH-доступ на панели управления вашего веб-хостинга, прежде чем вы сможете подключиться к CLI Joomla.
В этой статье я буду использовать "PuTTY", поскольку нахожусь на компьютере с Windows 8, и есть несколько проблем, которые мне пришлось решить на этом пути, поэтому я поделюсь некоторыми из них с вами, чтобы сэкономить вам время на настройке SSH-доступа к серверу вашего веб-сайта.
Поэтому перейдите на [страницу загрузки "PuTTY"](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html) и при необходимости установите "PuTTY" на свой компьютер.
Следующий шаг - [активировать SSH на Cpanel](https://docs.cpanel.net/cpanel/security/ssh-access/) вашего веб-хостинга или другой панели управления веб-хостингом, например, Plesk. Мы будем придерживаться Cpanel, поскольку она самая популярная.
Настройте свои ключи доступа SSH
--------------------------------
Чтобы использовать SSH, вам нужно настроить пару открытых/закрытых ключей в Cpanel и управлять ими. На первый взгляд инструкции кажутся сложными, но на самом деле они довольно просты. На веб-сайте A2 Hosting есть [хорошая статья](https://www.a2hosting.com/kb/cpanel/cpanel-security-features/configuring-ssh-keys-with-cpanel) с большим количеством информации для различных операционных систем. Инструкции могут немного отличаться от хоста к хосту, поэтому я бы посоветовал вам изучить это для вашего конкретного случая использования.
Также стоит помнить, что вам придется загрузить свой закрытый ключ на свой компьютер, поэтому помните, куда вы его положили. Если вы используете собственный SSH-клиент в Mac / Linux или Windows 10, вам следует сохранить файл ключа в:
* **Mac/Linux:** каталог /home/username/.ssh. (Замените имя пользователя своим собственным именем пользователя.)
* **Windows 10**: каталог \Users\username.ssh (замените имя пользователя на свое собственное имя пользователя.)
Это делается для того, чтобы ваша терминал знал, где найти ваш ключ.
Если вы используете "PuTTY", то просто помните, где он был загружен, так как вам нужно будет указать его в настройках "PuTTY".
Настройте PuTTY ДЛЯ доступа к серверу
-------------------------------------
Если вы уже установили "PuTTY", найдите значок на рабочем столе и откройте программу. Если нет, установите его прямо сейчас. Значок на рабочем столе для открытия PuTTY выглядит следующим образом:
Настроить PuTTY для доступа к вашему серверу несложно, вам нужно ввести всего 3 вещи. Они могут незначительно отличаться в зависимости от хостинга вашего веб-сайта, поэтому вам придется проверить это для ваших собственных обстоятельств. В моем случае мне нужно сделать следующее:
1. Ввести имя пользователя для моей учетной записи хостинга вместе с доменом, к которому я хочу получить доступ. Это должно быть указано в поле "Имя хоста (или IP-адрес)" на вкладке категории "Сеанс".
2. Затем в поле ‘Порт’ введите номер порта вашего SSH-соединения. Значение по умолчанию равно 22, но многие хосты меняют это значение, чтобы повысить безопасность соединения. Мой номер 7822.
3. Теперь вам нужно открыть новую вкладку в дереве настроек слева, прокрутите вниз до "SSH", затем откройте ‘Auth’. В нижней части вкладки перейдите в папку, в которую вы сохранили загруженный закрытый ключ SSH, выделите его и нажмите "Открыть’.
4. Вернитесь на вкладку "Сеанс" и в поле "Сохраненные сеансы" добавьте к нему запоминающееся имя. Затем нажмите кнопку ‘Сохранить’.
5. Теперь вы готовы подключиться к SSH-клиенту вашего веб-хостинга с помощью "PuTTY". Вы можете либо дважды щелкнуть по своему сохраненному запоминающемуся имени, либо нажать кнопку Открыть.
Если все прошло по плану, теперь вы должны увидеть окно терминала PuTTY. Это должно выглядеть примерно так:
С этого момента окно терминала должно выглядеть одинаково, независимо от используемой операционной системы или SSH-клиента. Команды, которые вы будете выполнять, также будут одинаковыми. Далее мы будем просто говорить ‘терминал’.
Следующим шагом будет ввод пароля, который вы создали при настройке открытых/закрытых ключей в Cpanel. Если вы не сделаете этого в течение установленного периода времени, сервер вашего веб-сайта закроет соединение с вашим терминалом, и вы получите сообщение об ошибке, подобное этому:
> Вот одна из особенностей использования терминала для подключения к серверу вашего веб-сайта. При вводе вашего пароля ничего не отображается! Ни звездочек, ни черточек, ничего. Я также заметил, что я также не могу скопировать и вставить свой пароль в окно терминала (хотя это может быть специфично для "PuTTY’).
>
>
Я сторонник сверхдлинных надежных паролей, но это может быть исключением из правил! Хотя я бы все же посоветовал вам следовать рекомендациям вашей Cpanel относительно надежности созданного пароля. Как упоминалось в предыдущих статьях, пароль `john123` недостаточно хорош. В зависимости от ваших SSH-ключей, операционной системы и экземпляра Cpanel Вам может потребоваться ввести пароль только для первоначального подключения. Но последующие сеансы не будут запрашивать ваш пароль. Это может касаться вас, а может и не касаться.
### Использование вашего терминала для доступа к интерфейсу Joomla
Итак, продолжаем, вводим свой пароль, затем нажимаем "Enter" на клавиатуре.
Если все прошло хорошо, вы должны увидеть новую строку информации, которая выглядит следующим образом:
```
username@123host [~] #
```
Это корневой каталог для файлов вашего веб-сайта. В зависимости от вашего хостинга, сайт, скорее всего, будет находиться в вашей папке ‘`public_html`’.
Если вы установили Joomla в другую папку на сервере, Вам нужно будет перейти в неё. Это также верно и для тех случаев, когда Вы используете более одного экземпляра Joomla на одном и том же аккаунте хостинга.
> Пришло время смахнуть пыль с вашего старого руководства по DOS!
>
>
В моем случае мой домен [designwebs.co.uk](http://designwebs.co.uk) находится в папке, которая находится снаружи моей папки `public_html`, например:
Если вы помните команды DOS, вы можете просто ввести `cd [имя вашей папки здесь]`, поэтому в моем случае команда cd будет выглядеть как `cd desighwebs.co.uk` там, где курсор мигает в окне вашего терминала. CD - это краткая команда, которая просто означает “Change Directory”.
Теперь я нахожусь в правильном каталоге для работы с Joomla CLI. Если вы хотите проверить, что находитесь в том же каталоге, что и Joomla, вы можете просто ввести команду ‘`dir`’ (сокращенно от 'directory') в командной строке, и увидите список уже более знакомых файлов и папок Joomla в этом каталоге. Вот так:
Начнем пользоваться Joomla CLI
------------------------------
Кажется, потребовалось много времени, чтобы добраться до этого момента, но это не должно занять слишком много времени, как только вы освоите использование окна вашего терминала или SSH-клиента, такого как ‘PuTTY’. Весь смысл интерфейса командной строки Joomla заключается в ускорении выполнения задач, особенно тех, которые связаны с ожиданием их завершения. Резервное копирование вашего веб-сайта - хороший пример использования CLI Joomla. Мы вернемся к этому позже.
Итак, давайте сделаем наше первое обращение в CLI Joomla и убедимся, что мы подключены и все работает так, как предполагается.
Стандартный формат подключения к CLI Joomla начинается с:
```
php cli/joomla.php
```
Хотя, если вы войдете в каталог cli (команда `cd my-website-folder-name/cli`), вместо того, чтобы работать из корневого каталога Joomla, вы можете использовать:
```
php joomla.php
```
Обновленная [документация Joomla по CLI](https://docs.joomla.org/J4.x:CLI_Update) содержит больше информации о задачах, которые вы можете выполнить с помощью командной строки в Joomla.
Хорошей задачей для проверки нашего подключения было бы выяснить, на какой версии Joomla работает веб-сайт.
Итак, в командной строке введите:/
```
php cli/joomla.php core:check-updates
```
и нажмите "Enter".
> **Примечание по PuTTY:**
>
> Если вы копируете команду Joomla CLI с помощью функции копировать/вставить, всё, что вам нужно сделать, чтобы вставить ее в терминал PuTTY, - это один клик правой кнопкой мыши по курсору.
>
>
Если всё подключено и работает, терминал Вас обрадует сообщением с подробным описанием версии Joomla, на которой работает ваш сайт.
Формат CLI команд Joomla
------------------------
При вводе команды в терминал для доступа к CLI Joomla используется определённый формат, который может состоять из 2 или более частей, в зависимости от того, что вы хотите сделать, и сколько информации вам требуется вернуть.
Каждый разработчик компонентов Joomla может предлагать различные уровни управления и извлечения данных для своего программного обеспечения на основе CLI Joomla. Одним из первых пользователей этой функциональности Joomla является Akeeba, поэтому, используя [Akeeba Backup](https://extensions.joomla.org/extension/akeeba-backup/) в качестве примера, вы можете ознакомиться практически со всеми функциями со своего терминала.
Следующая команда CLI запрашивает данные резервной копии, хранящиеся для конкретной резервной копии:
```
php cli/joomla.php akeeba:backup:info 1 --format=json
```
Давайте разложим по полочкам, что это всё означает:
| | |
| --- | --- |
| `php cli/joomla.php` | URL-адрес, необходимый для запуска CLI Joomla |
| `akeeba` | уникальное имя команды |
| `backup` | Конкретное программное обеспечение |
| `info` | action - действие, которое нужно выполнить. |
| `1` | аргумент для команды (если нужен) |
| `--format=json` | одна или несколько опций для команды. В данном случае выходные данные нашей команды CLI будут в формате Json. |
Обязательно обратите внимание на пробелы и двоеточия в команде, чтобы она работала должным образом.
Команды CLI Joomla следуют аналогичному принципу аргументов и опций, но поскольку они являются "базовыми" командами, они немного проще.
На данный момент команды CLI Joomla делятся на 11 категорий:
* Кэш (cache),
* Основные настройки (config)
* Ядро (core),
* База данных (database),
* Расширения (extension),
* Поиск (умный поиск, finder),
* Планировщик задач (Scheduler),
* Сессия пользователя (Session),
* Сайт (Site),
* Обновление (Update)
* Пользователь (User)
Каждая из них имеет свои собственные функции:
```
php cli/joomla.php core:check-updates # Проверяет обновления Joomla
php cli/joomla.php site:down # Переведет сайт в режим оффлайн
```
Добавление опций к параметрам команды CLI поможет получить более подробные результаты. Например, если вы хотите узнать, какие расширения установлены на Вашем сайте, Вам следует использовать команду:
```
php cli/joomla.php extension:list
```
Но, если вы хотите найти только определенные расширения определенного типа, например, установленные языки, Вы можете добавить в ту же команду опцию `--type=language`:
```
php cli/joomla.php extension:list --type=language
```
Эта команда вернет следующую информацию:
**Совет: если ввести в терминал** `php cli/joomla.php` **, то Вы получите список всех команд и описаний Joomla CLI.**
### Перейдём к практике
Мы собираемся выполнить 4 основные задачи по техническому обслуживанию, которые вы должны регулярно выполнять на нашем веб-сайте Joomla. Все это из терминала, без входа в панель администратора Joomla. Мы собираемся использовать 4 простые команды CLI для выполнения этих задач.
Во-первых, нам нужно собрать команды, которые мы будем использовать. Вы можете найти текущие команды Joomla CLI в приведенной ниже шпаргалке. Поскольку Akeeba Backup является наиболее широко используемым расширением для резервного копирования Joomla, мы будем использовать его для создания резервной копии.
Нужные нам CLI команды:
* **php cli/joomla.php update:extensions:check**
* **php cli/joomla.php akeeba:backup:take**
* **php cli/joomla.php extension:discover:install**
* **php cli/joomla.php cache:clean**
Если вы еще этого не сделали, войдите в выбранный вами терминал и убедитесь, что вы находитесь в корневом каталоге Joomla.
#### Задача первая: Проверить наличие обновлений расширений
Введите `php cli/joomla.php update:extensions:check` в своём терминале.
В моем случае обновления не были доступны для установки. Сообщение об успешном завершении отображается зеленым цветом. Отмечу, что моё время, затраченное на выполнение этой команды, составило менее 3 секунд.
#### Задача вторая: создание бэкапа
Теперь пришло время сделать резервную копию с помощью Akeeba Backup. Введите `php cli/joomla.php akeeba:backup:take` в своём терминале.
Очевидно, что создание резервной копии сайта занимает немного больше времени. Во время процесса резервного копирования ход выполнения подробно описывается в окне терминала во многом так же, как вы видите в бэкэнде администратора Joomla.
Успешное выполнение резервного копирования отображается зеленым цветом. Из временных меток вы можете видеть, что для завершения потребовалось всего 1 минута 10 секунд. Что довольно неплохо.
#### Задача третья: установка обновлений расширений
Пришло время обновить наши расширения. Введите `php cli/joomla.php extension:discover:install` в терминале.
В моем случае все уже обновлено, так что устанавливать нечего. В этом случае CLI может дать советы о том, что Вы могли бы сделать ещё. Мне CLI Joomla предложил попробовать запустить `extension:discover`. Это работает так же, как запуск опции "Установка расширений -> поиск" в панели администратора.
#### Задача четвёртая: очистка кэша Joomla
Наконец, попробуем очистить кэш Joomla. Введите `php cli/joomla.php cache:clean` в своём терминале.
Как только кэш будет очищен, вы снова увидите зеленое сообщение об успешном завершении.
### Сообщения об ошибках
Если вы допустите опечатку при вводе команды или введете неизвестную команду, вы получите сообщение об ошибке, выделенное красным цветом. Сообщение будет содержать небольшую полезную информацию, которая поможет вам разобраться в том, что пошло не так. Вы можете увидеть на изображении ниже, что там написано:
* **Command “cache:clea” is not defined**
* **The command “cache:clea” does not exist**
Конечно, команда "`cache:clea`", не существует в Joomla CLI, поэтому она не выполнена и интерфейс Joomla выдает ошибку.
### Проверка Akeeba Backup в панели администратора
Не всегда бывает возможно проверить, действительно ли была запущена команда CLI, без некоторого копания в файлах и настройках Joomla. Но некоторые расширения упрощают это. В панели администратора Joomla в компоненте Akeeba Backup есть панель "Статистика резервного копирования" с правой стороны. Здесь можно увидеть, что последнее резервное копирование было инициировано из командной строки. В нем также содержится подробная информация о сделанной резервной копии и времени, в течение которого она была сделана.
Каковы преимущества использования CLI Joomla?
---------------------------------------------
В этой статье, как и во многих других статьях Joomla Community Magazine, описана лишь малая часть того, что происходит "под капотом" Joomla. Как и во многих других статьях, мы лишь ‘приоткрыли занавес’ для этой обновленной функции Joomla 4.
Я думаю, что самое большое преимущество знакомства с интерфейсом CLI Joomla заключается в том, насколько быстро можно выполнять самые необходимые задачи. От начала до конца четыре задачи, описанные выше, заняли около 2 минут, и это включало в себя запуск терминала "Putty", подключение к моему серверу через SSH, ручной ввод пароля для входа и копирование / вставку каждой из четырех команд по очереди.
Если вы умножите выполнение одних и тех же задач на несколько веб-сайтов, это сэкономит много времени.
Для продвинутых пользователей командная строка и терминал дают вам возможность автоматизировать повторяющиеся задачи на нескольких веб-сайтах, к которым у вас есть полный доступ. Вы можете быстро и легко просматривать их каталоги и выполнять для них одну и ту же команду Joomla CLI.
Представьте, сколько времени потребуется, чтобы вручную войти в систему администратора Joomla и запустить Akeeba Backup индивидуально для 100 различных веб-сайтов в вашем портфолио?
> В этом весь смысл приложения командной строки. Оно очень способствует бесконечной настройке. В сочетании с чем-то вроде [Ansible](https://www.ansible.com/) его можно даже использовать для выполнения команд через парк, состоящий из сотен серверов, на которых работают тысячи сайтов.
>
> Инструменты командной строки работают вместе, чтобы дать вам сверхспособности.
>
> Nicholas, Akeeba Ltd
>
>
Лично я, теперь, когда я настроил "PuTTY", я собираюсь добавить SSH-доступ ко всем своим веб-сайтам и запускать эти обновления, резервные копии и очистку кэша каждый раз, когда я получаю одно из тех писем с обновлениями "Это отправлено с вашего сайта", которые засоряют мой почтовый ящик. Я думаю, что изначально стоит потратить время на создание ключей доступа SSH и настройку терминала. Я могу даже потратить время на написание пакетной команды для пакетной работы с моими сайтами!
Шпаргалка Joomla CLI
--------------------
```
php cli/joomla.php # + команда из списка ниже
```
### Cache
`cache:clean` - Очистка элементов кэша с истекшим сроком действия
### Config
`config:get` - Отображение текущих параметров конфигурации
`config:set` - Установка параметров конфигурации
### Core
`core:check-updates` - Проверка обновлений Joomla
`core:update` - Обновление Joomla
### Database
`database:export` - экспорт базы данных
`database:import` - импорт базы данных
### Extension
`extension:discover` - поиск расширений для установки
`extension:discover:install` - установка найденных расширений
`extension:discover:list` - список найденных для установки расширений
`extension:install` - установка расширения из указанного URL или пути
`extension:list` - список установленных расширений
`extension:remove` - удаление расширения
### Finder
`finder:index` - очистка индекса и запуск переиндексации умного поиска
### Scheduler
**Примечание от переводчика:** *в Joomla 4.1 появился встроенный планировщик заданий. Функционал для создания задач расширяется с помощью плагинов. Ранее на хабре была статья* [*Создание WebCron плагина для Joomla 4 (Task Scheduler Plugin)*](https://habr.com/ru/post/676902/)*. Из панели администратора есть возможность включить выполнение задач по URL (посещение URL с ключом) или с использованием WebCron - при активности пользователей на сайте и в админке.* ***Однако, в этом случае задачи запускает и выполняет web-сервер, у которого в большинстве случаев есть ограничение на время выполнения скрипта в 60 секунд****.* ***Возможность запустить задания Планировщика задач Joomla через CLI позволяет использовать на сайте любые "тяжелые" задачи, которые не будут нагружать веб-сервер.*** *Постановка CLI-приложения с запуском задачи на CRON открывает широчайшие возможности при создания сайтов на Joomla 4. Серверный CRON настраивается по частоте запуска самой частой задачи* ***один раз****. Все остальные настройки выполняются уже из админки Joomla.*
`scheduler:list` - список поставленных на выполнение задач
`scheduler:run` - запуск одной или нескольких задач
Пример постановки запуска задач Планировщика Joomla 4 на cron - crontab -e. В этом примере CRON обращается раз в минуту. Частота запуска задач полностью настраивается через админку Joomla.`scheduler:state` - включение, выключение или удаление запущенных задач.
### Session
`session:gc` - запуск garbage collection сессии
`session:metadata:gc` - запуск session metadata garbage collect
### Site
`site:down` - переводит сайт в оффлайн режим
`site:up` - включает сайт обратно
### Update
`update:extensions:check` - проверка расширений, ожидающих обновления
`update:joomla:remove-old-files` - удаление старых системных файлов
### User
`user:add` - добавляет пользователя
`user:addtogroup` - добавляет пользователя в группу
`user:delete` - удаляет пользователя
`user:list` - список всех пользователей
`user:removefromgroup` - удаление пользователя из группы
`user:reset-password` - изменение пароля пользователя
### Akeeba Backup CLI
`akeeba:backup:alternate` - создание бэкапа с помощью функции из фронтенда (Take a backup with Akeeba Backup's frontend backup feature)
`akeeba:backup:alternate_check` - проверка наличия бэкапов с ошибкой с помощью функции из фронтенда (Check for failed Akeeba Backup backups with its front-end feature)
`akeeba:backup:check` - проверка неудачных попыток создания бэкапов
`akeeba:backup:delete` - удаляет запись о бэкапе, сделанную Akeeba Backup, или только ее файлы.
`akeeba:backup:download` - возвращает архив бэкапа.
`akeeba:backup:fetch` - скачивает бэкап из удаленного хранилища обратно на сервер
`akeeba:backup:info` - отображает инфомрацию о бэкапе Akeeba
`akeeba:backup:list` - отображает список бэкапов Akeeba
`akeeba:backup:modify` - изменяет бэкап
`akeeba:backup:take` - создает бэкап
`akeeba:backup:upload` - повторная попытка загрузить бэкап на удаленное хранилище
`akeeba:filter:delete` - удаляет значение фильтра
`akeeba:filter:exclude` - устанавливает исключающее условие в фильтре
`akeeba:filter:include-database` - добавляет дополнительную базу данных для включения в бэкап
`akeeba:filter:include-directory` - добавляет директорию за пределами сайта для включение в бэкап
`akeeba:filter:list` - список значений фильтров
`akeeba:log:get` - извлечение файла логов
`akeeba:log:list` - список файлов логов Akeeba Backup
`akeeba:migrate` - запуск миграции настроек со старых версий Akeeba Backup
`akeeba:option:get` - получение значения опции из конфига профиля Akeeba Backup
`akeeba:option:list` - отображает параметры конфигурации профиля Akeeba backup, включая названия
`akeeba:option:set` - устанавливает значение опции в конфиг профиля Akeeba Backup
`akeeba:profile:copy` - создаёт копию профиля Akeeba Backup
`akeeba:profile:create` - создаёт профиль Akeeba Backup
`akeeba:profile:delete` - удаляет профиль Akeeba Backup
`akeeba:profile:export` - экспорт профиля Akeeba Backup в JSON строку
`akeeba:profile:import` - импорт профиля Akeeba Backup из JSON
`akeeba:profile:list` - список профилей резервного копирования
`akeeba:profile:modify` - изменение профиля резервного копирования
`akeeba:profile:reset` - сброс профиля
`akeeba:sysconfig:get` - получение значения из глобального конфига Akeeba Backup (на уровне всего компонента)
`akeeba:sysconfig:list` - список опций глобального конфига Akeeba Backup (на уровне всего компонента)
`akeeba:sysconfig:set` - установка значений в глобальный конфиг Akeeba Backup
Дополнительные ресурсы
----------------------
* <https://docs.cpanel.net/cpanel/security/ssh-access/>
* <https://support.plesk.com/hc/en-us/articles/115000172834-How-to-connect-to-a-Plesk-server-via-SSH-with-available-server-s-credentials>
* <https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html>
* <https://www.a2hosting.com/kb/cpanel/cpanel-security-features/configuring-ssh-keys-with-cpanel>
* <https://www.digitalcitizen.life/command-prompt-how-use-basic-commands/>
* <https://docs.joomla.org/J4.x:CLI_Update>
* <https://docs.joomla.org/J4.x:CLI_Database_Exporter_Importer>
* <https://docs.joomla.org/J4.x:Writing_A_CLI_Application>
* <https://symfony.com/doc/current/console/style.html>
* <https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html>
* <https://www.akeeba.com/documentation/akeeba-backup-joomla/akeeba-backup-cli.html>
* <https://www.ansible.com/>
От переводчика
--------------
Замечания и пожелания к переводу приветствуются.
Так же полезные ресурсы
-----------------------
### Ресурсы сообщества:
* [форум русской поддержки Joomla](https://joomlaforum.ru/).
* [интернет-портал Joomla-сообщества](https://joomlaportal.ru/).
* <https://vc.ru/s/1146097-joomla> - Сообщество Joomla на VC.
### Telegram:
* [чат сообщества «Joomla! по-русски»](https://t.me/joomlaru).
* [Joomla для профессионалов, разработчики Joomla](https://t.me/projoomla).
* [Новости о Joomla! и веб-разработке по-русски](https://t.me/joomlafeed).
* [вакансии и предложения работы по Joomla](https://t.me/joomla_jobs): фуллтайм, частичная занятость и разовые подработки. Размещение вакансий [здесь](https://jpath.ru/jobs/add).
* [Англоязычный чат сообщества](https://t.me/joomlatalks). | https://habr.com/ru/post/696222/ | null | ru | null |
# Discord бот с экономикой с sqlite
Привет, Хабр!
-------------
Хотел поделиться опытом, как я писал бота c экономикой для discord сервера с использованием sqlite и другой мелочи.
Подготовительный этап
---------------------
#### Создание бота
Итак, перед тем, как написать бота, нам нужно его создать и получить токен:
1. Перейти на сайт [для разработчиков](https://discordapp.com/developers/applications/)
2. Нажать на кнопку «New Application» и назвать бота
3. Получить токен бота, войдя в вашего бота и найдя в списке «Settings» вкладку «Bot»
#### Необходимые модули
Как-никак мы пишем на python, а не на ASM, поэтому нам будут необходимы некоторые модули
```
$ pip install discord.py #само api для работы с ботом
```
```
$ pip install tabulate #небольшой модуль для красивых таблиц
```
Этап написания
--------------
#### Импорт модулей
Импортировать модули также просто, как и написать одну страницу на HTML+CSS.
```
import sqlite3 #модуль sqlite
import discord #модуль discord api
from discord.ext import commands #необходимый класс для обработки команд
from tabulate import tabulate #удобный модуль для рисования таблиц
import json #используется только для обработки инвентаря, но ему можно найти и другое применение
```
#### Подключение к sqlite
Здесь нет ничего сложного. Просто после импорта прописываем следующее:
```
conn = sqlite3.connect("Discord.db") # или :memory:
cursor = conn.cursor()
```
#### Подготовка базы данных
В базе данных будет 2 таблицы shop и users.
```
CREATE TABLE "shop" (
"id" INT,
"type" TEXT,
"name" TEXT,
"cost" INT
)
```
```
CREATE TABLE "users" (
"id" INT,
"nickname" TEXT,
"mention" TEXT,
"money" INT,
"rep_rank" TEXT,
"inventory" TEXT,
"lvl" INT,
"xp" INT
)
```
#### Подготовка к написанию логики бота
Создаем переменную bot.
```
bot = commands.Bot(command_prefix="_")#в строчке command_prefix можно указать любые знак, букву, слово, словосочетания и т.д.
```
В конце всего кода мы пишем метод, который запускает нашего бота.
```
bot.run("Здесь токен, который вы получили на этапе создания бота")
```
Теперь начнем писать нашего бота.
```
bot = commands.Bot(command_prefix="_")
#Здесь будет логика вашего бота
bot.run("Здесь токен, который вы получили на этапе создания бота")
```
Дальше пишем событие on\_ready(), отвечающее за готовность бота.
```
@bot.event
async def on_ready():
print("Bot Has been runned")#сообщение о готовности
for guild in bot.guilds:#т.к. бот для одного сервера, то и цикл выводит один сервер
print(guild.id)#вывод id сервера
serv=guild#без понятия зачем это
for member in guild.members:#цикл, обрабатывающий список участников
cursor.execute(f"SELECT id FROM users where id={member.id}")#проверка, существует ли участник в БД
if cursor.fetchone()==None:#Если не существует
cursor.execute(f"INSERT INTO users VALUES ({member.id}, '{member.name}', '<@{member.id}>', 50000, 'S','[]',0,0)")#вводит все данные об участнике в БД
else:#если существует
pass
conn.commit()#применение изменений в БД
```
После этого стоит, чтобы лишний раз не перезапускать бота, написать метод on\_member\_join()
```
@bot.event
async def on_member_join(member):
cursor.execute(f"SELECT id FROM users where id={member.id}")#все также, существует ли участник в БД
if cursor.fetchone()==None:#Если не существует
cursor.execute(f"INSERT INTO users VALUES ({member.id}, '{member.name}', '<@{member.id}>', 50000, 'S','[]',0,0)")#вводит все данные об участнике в БД
else:#Если существует
pass
conn.commit()#применение изменений в БД
```
Если бот у нас экономический, значит должна быть валюта, ее заработок и ее трата. Заработок можно организовать с помощью experience системы.
```
@bot.event
async def on_message(message):
if len(message.content) > 10:#за каждое сообщение длиной > 10 символов...
for row in cursor.execute(f"SELECT xp,lvl,money FROM users where id={message.author.id}"):
expi=row[0]+random.randint(5, 40)#к опыту добавляется случайное число
cursor.execute(f'UPDATE users SET xp={expi} where id={message.author.id}')
lvch=expi/(row[1]*1000)
print(int(lvch))
lv=int(lvch)
if row[1] < lv:#если текущий уровень меньше уровня, который был рассчитан формулой выше,...
await message.channel.send(f'Новый уровень!')#то появляется уведомление...
bal=1000*lv
cursor.execute(f'UPDATE users SET lvl={lv},money={bal} where id={message.author.id}')#и участник получает деньги
await bot.process_commands(message)#Далее это будет необходимо для ctx команд
conn.commit()#применение изменений в БД
```
Одну из главных частей мы написали. Осталось написать команды по типу аккаунт, магазин и т.д. Думаю дальше интуитивно понятно.
```
@bot.command()
async def account(ctx): #команда _account (где "_", ваш префикс указаный в начале)
table=[["nickname","money","lvl","xp"]]
for row in cursor.execute(f"SELECT nickname,money,lvl,xp FROM users where id={ctx.author.id}"):
table.append([row[0],row[1],row[2],row[3]])
await ctx.send(f">\n{tabulate(table)}")
@bot.command()
async def inventory(ctx):#команда _inventory (где "_", ваш префикс указаный в начале)
counter=0
for row in cursor.execute(f"SELECT inventory FROM users where id={ctx.author.id}"):
data=json.loads(row[0])
table=[["id","type","name"]]
for row in data:
prt=row
for row in cursor.execute(f"SELECT id,type,name FROM shop where id={prt}"):
counter+=1
table.append([row[0],row[1],row[2]])
if counter==len(data):
await ctx.send(f'>\n{tabulate(table)}')
@bot.command()
async def shop(ctx):#команда _shop (где "_", ваш префикс указаный в начале)
counter=0
table=[["id","type","name","cost"]]
for row in cursor.execute(f"SELECT id,type,name,cost FROM shop"):
counter+=1
table.append([row[0],row[1],row[2],row[3]])
if counter==4:
await ctx.send(f'>\n{tabulate(table)}')
```
Если есть магазин, значит можно покупать? Не так-ли?
```
async def buy(ctx, a: int):
uid=ctx.author.id
await ctx.send('Обработка... Если ответа не последует, указан неверный id предмета [buy {id}]')
for row in cursor.execute(f"SELECT money FROM users where id={uid}"):
money = row[0]
for row in cursor.execute(f"SELECT id,name,cost FROM shop where id={a}"):
cost=row[2]
if money >= cost:#если у вас достаточно денег,то...
money -=cost
await ctx.send(f'Вы приобрели "{row[1]}" за {row[2]}')
for row in cursor.execute(f"SELECT inventory FROM users where id={uid}"):
data=json.loads(row[0])
data.append(a)
daed=json.dumps(data)
cursor.execute('UPDATE users SET money=?,inventory = ? where id=?',(money,daed,uid))#добавляет предмет вам в инвентарь
pass
if money < cost:#иначе сообщает о недостатке
await ctx.send(f'Недостаточно средств')
pass
conn.commit()#применение изменений в БД
```
Заключение
----------
Вот такой простенький бот у нас получился. Надеюсь это кому-либо поможет.
Я понимаю что в него можно (необходимо) добавить множество функций и фишек, но это голый вариант кода, который могут использовать новички для понимания как работает discord.py, модуль sqlite и встроенные методы python.
Всем спасибо за внимание. До связи! | https://habr.com/ru/post/482290/ | null | ru | null |
# Конвертируем картинку в ANSI
Не знаю, насколько это будет кому-то интересно, но на днях решил поиграться и сделать следующее:
Дано: Картинка (например, BMP) 640 на 400, шрифт 8 на 16
Надо: Перевести ее в ANSI псевдографику в стандартном режиме 80 на 25 символов, символы и фон могут иметь любой цвет (true color).
Благодаря очень хорошим комментариям я обновил версию: [ссылка](http://dimouse.ru/data/ansiconv3.rar)
С ней получаются примерно такие картинки: 
Здесь стоит оговориться, что «тру» EGA текстовый режим с 16 цветами нам не подойдет, так как получится слишком некрасиво из-за низкого разрешения и большого размера символов. Второй аргумент: задача не стоИт максимально приблизить картинку ее символьному представлению, так как тогда можно было бы уменьшать шрифт, увеличивать разрешение и т.д. Задача — сделать именно такой фильтр, который описан выше.
Для чего я здесь это публикую: мне показалось, что начинающим программистам было бы полезно попрактиковаться в понимании алгоритма, поэтому я отметил данный материал, как туториал.
Для реализации нам понадобится какая-нибудь библиотека для работы с графикой, умеющая getpixel и putpixel, то есть считать цвет пикселя с экрана и нарисовать пиксель заданным цветом на экран. Я пользуюсь старенькой, но проверенной библиотекой Allegro (www.allegro.cc), которая легка в обращении, а также позволяет работать в разных ОС (даже в MSDOS!).
Но хватит слов, пора к делу.
```
const int size_x=640;
const int size_y=400;
const int ascii_x=80;
const int ascii_y=25;
```
Устанавливаем константы, отвечающие за размер картинки и размер ее текстового представления.
```
for(int cx=0;cx
```
Начинаем основной цикл, в котором последовательно находим каждый символ из 80 на 25 матрицы. Следующий цикл — по каждому пикселю той области картинки, которая соответствует на экране данному символу из этой матрицы. Как легко сообразить, область эта составляет 640/80=8 на 400/25=16 пикселей. Здесь полезно вспомнить, что это как раз равно размеру нашего шрифта.
В этом втором цикле наша задача — найти средний цвет, который мы установим в качестве цвета фона нашего ANSI символа. Сделать это очень просто: раскладываем цвет на R, G, B компоненты и вычисляем среднее по каждой из них.
```
//find ascii and its color
int rms=100000000;
for(int curch=1;curch<256;curch++){ //loop over ASCII table
int charr=0;
int charg=0;
int charb=0;
//find char color
pixels=0; //number of pixels for char
for(i=0;i
```
Дальше уже более интересно. Нам приходится вставить еще один цикл — по каждому символу из ASCII таблицы (всего их 256). Я беру их из черно-белой картинки с шрифтом, то есть теоретически, там могут быть любые изображения 8 на 16 в качестве символа. Стоит отметить, что в этом месте можно ограничиться только какой-то одной областью символов (например, кириллицей), что сильно повлияет на результат.
В приведенном выше куске кода мы находим цвет символа. Для этого мы считаем сумму как выше, но с небольшим изменением: пиксели берутся по маске, которой является текущий символ из шрифта. Таким образом, второй «средний цвет» соответствует только пикселям, которыми будет нарисован сам символ.
Стоит также отметить, что число таких пикселей может быть равно нулю (например, символ 32 — пробел). С этим надо быть внимательнее.
```
//find rms
int currms=0;
for(i=0;i
```
Ну и, наконец, пришли к самой соли. В этом куске кода мы еще раз проходимся по пикселям заданной области картинки и считаем RMS (среднеквадратичное отклонение) всех трех компонент цвета от цвета фона или символа (в зависимости от того, находится ли данный пиксель на фоне или на символе). Суммарный RMS и будет являться критерием того, насколько данный символ хорошо соответствует данной области картинки.
Далее следует вывод на экран (в двух режимах — с фоном и без ([пример](http://dimouse.ru/images/s.png))), но на нем мы останавливаться не будем, так как там всё самоочевидно.
Программу и исходный код можно скачать здесь: [dimouse.ru/data/ansiconv.rar](http://dimouse.ru/data/ansiconv.rar) (130 Kb).
Как насчет нарисовать это дело в текстовом режиме? Как вы можете увидеть, программа создает файл с результатами (кроме нового bmp) — ascii. Там для каждого символа хранится его значение в ASCII таблице, его цвет и цвет его фона. Я для текстового режима пользуюсь [pdcurses.sourceforge.net](http://pdcurses.sourceforge.net/) (пишите в комментариях, если знаете что-то лучше!), но эта библиотека, хоть и является враппером над SDL (во всяком случае, виндовая версия — точно), не умеет показывать цвета больше 16: тяжелое наследие древности. Как вы, наверное, помните, PDCurses берет свое начало от знаменитой Interactive Fiction игры [Curses](http://en.wikipedia.org/wiki/Curses_(video_game)). Но один товарищ написал усовершенствование этой библиотеки и выложил здесь: [www.projectpluto.com/win32a.htm](http://www.projectpluto.com/win32a.htm)
К сожалению, в ней нельзя использовать bitmap шрифт, только системные (зато можно выбрать любой), что несколько портит впечатление. Но задачу также можно считать выполненной.
Программу для чтения ascii можно скачать здесь: [dimouse.ru/data/ascii.rar](http://dimouse.ru/data/ascii.rar) (70 Kb). | https://habr.com/ru/post/192912/ | null | ru | null |
# Единая точка входа с Keycloak и Яндекс в условиях большого переезда
Так же, как и многие другие компании, мы долго и счастливо использовали целый стек популярных коммерческих облачных сервисов: Github для кода, Slack для общения, Jira для ведения задач, Confluence для внутренней документации, Artifactory и Allure для разработки — и связывал это всё воедино Google Workspace, который не только решал офисные и почтовые задачи, но и выступал в качестве SSO для всех используемых сервисов.
Последние события всю эту идиллию разрушили, и пришлось достаточно быстро искать и реализовывать альтернативу из отечественных сервисов и open source продуктов (хуже ремонта, как известно, только переезд). С учётом того, что альтернатив не так много и вся наша инфраструктура развернута в облаке Яндекс, в итоге мы получили следующий стек:
* Yandex 360 вместо Google Workspace, офисные приложения и почта;
* on-premises Gitlab вместо Github и Jira;
* on-premises Mattermost вместо Slack;
* BookStack вместо Confluence.
При этом — возможно, в силу привычки к Google — хотелось держать базу пользователей в Яндекс: офисные задачи никто не отменял, и время тоже поджимало.
Open source продукты в большинстве случаев поддерживают стандартные протоколы аутентификации OpenID Connect и SAML. Поскольку протокол аутентификации Google соответствует спецификации OpenID Connect, при организации SSО-средствами Google проблем с поддержкой в on-premises, а тем более в облачных решениях не возникает.
Яндекс для реализации SSO использует OAuth2, добавляя к стандартной последовательности OAuth2-авторизации собственную специфику аутентификации пользователя, которую необходимо учитывать на стороне приложения. В большинстве случаев такая поддержка на стороне приложения отсутствует, поскольку авторы предпочитают ограничиваться поддержкой стандартных протоколов.
Таким образом, необходимо некое дополнительное связующее звено, выступающее в качестве адаптера между стандартными протоколами и специфическим протоколом Яндекса.
В качестве такого связующего звена мы выбрали open source продукт Keycloak, позволяющий организовать единую точку входа с поддержкой различных сервисов и протоколов аутентификации, учитывая при этом особенности аутентификации в различных сервисах.
В этой статье мы поговорим о том, с какими проблемами мы столкнулись в процессе перехода и внедрения SSО на базе Keycloak с учётом специфики нашего нового стека сервисов.
Задача-минимум звучала так: связать через единую точку аутентификации Яндекс, Gitlab, Mattermost, Bookstack и хотя бы часть сервисов разработки в некие разумные сроки.
### Собственно, Keycloak
Так получилось, что раньше мы не сталкивались с Keycloak и опыта работы с ним у нас не было. Сам продукт существует давно, в сети по нему много различных статей и рецептов использования, но актуальны далеко не все. Установить и настроить Keycloak в общем-то несложно, но есть некоторые особенности, которые лучше понимать сразу, а не выяснять методом проб и ошибок.
На данный момент Keycloak предусматривает два варианта сборки: устаревший, на базе сервера приложений Wildfly (он же JBoss), и новый, на базе фреймворка Quarkus. Большинство материалов про Keycloak написано про WildFly, и мы начали с него, просто использовав готовый Dockerfile. Лучше сразу использовать Quarkus, потому что:
* Widlfly-вариант прекратит существование осенью этого года ([Keycloak release plans for 2022](https://www.keycloak.org/2022/03/releases));
* итоговый контейнер меньше, потребляет меньше ресурсов и работает быстрее.
Переменные окружения контейнеров и некоторые параметры запуска для Wildfly и Quarkus отличаются, поэтому, читая различные статьи, нужно обращать внимание, о каком варианте сборки идет речь (скорее всего, это будет WildFly). Удобное полное описание конфигурации Quarkus с разделением на параметры сборки и параметры запуска приведено в [документации](https://www.keycloak.org/server/all-config). Ключевой момент здесь — параметры сборки отдельно, параметры запуска отдельно (хотя и есть режим auto-build, позволяющий их сочетать, например, в процессе разработки). Различия между сборками необходимо учитывать также и при размещении Keycloak за reverse-прокси: в Quarkus отказались от использования префиксов auth/ в адресах HTTP-ресурсов, при настройке reverse-прокси имеет смысл сразу ориентироваться на актуальные пути, описанные в [документации](https://www.keycloak.org/server/reverseproxy). В итоге мы стали использовать Quarkus-версию, разместив keycloak за reverse-прокси и используя отдельный домен для административного доступа.
### Расширяемость Keycloak
На самом деле killer feature Keycloak даже не в том, что он очень многое умеет, а в том, что его возможности можно расширять без необходимости внесения изменений непосредственно в код Keycloak. Реализуется это за счёт стандартной технологии Java SPI (Service Provider Interface), и физически выглядит как динамическая загрузка приложением специальным образом подготовленного jar-файла, содержащего, помимо собственно классов Java, текстовые файлы, определяющие связь интерфейса (сервиса) и реализующего его класса (провайдера сервиса в терминологии SPI): [Service Provider Interfaces](https://www.keycloak.org/docs/latest/server_development/#_providers).
Используя механизм расширений, вы можете реализовывать:
* поддержку внешних сервисов авторизации (помимо достаточно большого количества, которое уже поддерживается в стандартной поставке, в том числе Google, Github, OpenShift и т. д.);
* дополнительные шаги процесса аутентификации, в том числе настраиваемые;
* собственные способы хранения информации о пользователях;
* собственные хранилища секретов;
* обработчики событий Keycloak.
В большинстве случаев расширения пишутся на Java, однако в некоторых случаях (например, для дополнительных шагов аутентификации) можно (с некоторыми ограничениями) использовать JavaScript, который будет выполняться встроенным интерпретатором.
### Интеграция с Яндекс
Как уже говорилось, Яндекс использует собственный протокол на базе OAuth2, и соответствующего провайдера в стандартной сборке Keycloak, конечно же, нет.
Поскольку Keycloak — это расширяемая система, поддержку особенностей протокола аутентификации можно реализовать путём создания собственного расширения, реализующего SPI-интерфейсы identity-провайдера. Немного погуглив, можно найти готовую реализацию набора расширений для отечественных облачных сервисов (Яндекс, Mail.ru и т. д.): <https://github.com/playa-ru/keycloak-russian-providers> от компании [playa.ru](https://playa.ru), и мы начали с того, что собрали Keycloak с этим набором расширений. Он действительно работает, и в определённых обстоятельствах его, наверное, можно использовать, но нам он не подошёл:
* нет поддержки ограничений на домен учётной записи пользователя: нам необходимо, чтобы могли авторизовываться только пользователи в корпоративном почтовом домене, а в случае этого набора плагинов авторизоваться может любой с валидной учётной записью в Яндекс;
* хотелось минимизировать зависимости и иметь возможность добавить какую-либо дополнительную функциональность в плагин.
Поэтому, несмотря на то что у нас админская команда и мы не пишем на Java, было решено реализовать собственный провайдер, взяв за основу проект playa.ru и посмотрев на простые провайдеры, реализованные в самом Keyclock, например [identity-провайдер Github](https://github.com/keycloak/keycloak/blob/bfce612641a70e106b20b136431f0e4046b5c37f/services/src/main/java/org/keycloak/social/github/GitHubIdentityProvider.java).
Основная логика OAuth2-авторизации уже реализована в Keycloak в виде абстрактного класса AbstractOAuth2IdentityProvider, от которого мы и наследуем класс провайдера. В унаследованном классе мы определяем набор констант, описывающих ресурсы OAuth2-авторизации на стороне Яндекса, которые будут использованы в конфигурации провайдера:
```
public class YandexIdentityProvider extends
AbstractOAuth2IdentityProvider
implements SocialIdentityProvider {
public static final String AUTH\_URL = "https://oauth.yandex.ru/authorize";
public static final String TOKEN\_URL = "https://oauth.yandex.ru/token";
public static final String PROFILE\_URL = "https://login.yandex.ru/info";
public YandexIdentityProvider(KeycloakSession session, YandexIdentityProviderConfig config) {
super(session, config);
config.setAuthorizationUrl(AUTH\_URL);
config.setTokenUrl(TOKEN\_URL);
config.setUserInfoUrl(PROFILE\_URL);
}
@Override
protected String getProfileEndpointForValidation(EventBuilder event) {
return PROFILE\_URL;
}
// ...
}
```
В нашем собственном классе нам необходимо реализовать выполнение последнего шага авторизации, а именно — получение информации о пользователе. Для этого мы используем соответствующий вызов API Яндекса, используя OAuth token, полученный в результате выполнения предыдущих шагов процесса авторизации, уже реализованных в базовом классе.
```
public static final String PROFILE_URL = "https://login.yandex.ru/info";
@Overrideprotected BrokeredIdentityContext doGetFederatedIdentity(String accessToken) {
log.debug("doGetFederatedIdentity()");
JsonNode profile = null;
try {
profile = SimpleHttp.doGet(PROFILE_URL, session)
.header("Authorization", "OAuth " + accessToken)
.asJson();
return extractIdentityFromProfile(null, profile);
} catch (Exception e) {
throw new IdentityBrokerException("Could not obtain user profile from Yandex: " + e.getMessage(), e);
}
}
```
После этого нам необходимо сформировать значения интересующих нас полей из полученного отклика:
```
@Overrideprotected BrokeredIdentityContext extractIdentityFromProfile(EventBuilder event, JsonNode profile) {
BrokeredIdentityContext user = new BrokeredIdentityContext(getJsonProperty(profile, "id"));
String domain = ((YandexIdentityProviderConfig) getConfig()).getHostedDomain();
String email = getJsonProperty(profile, "default_email");
if (email == null || email.trim().isEmpty()) {
throw new IllegalArgumentException("Can not get user's email.");
}
if (domain != null && !domain.isEmpty() && !email.endsWith("@" + domain)) {
throw new IllegalArgumentException("Hosted domain does not match.");
}
String login = getJsonProperty(profile, "login");
if (login == null || login.trim().isEmpty()) {
user.setUsername(email);
} else {
user.setUsername(login);
}
user.setEmail(email);
user.setFirstName(getJsonProperty(profile, "first_name"));
user.setLastName(getJsonProperty(profile, "last_name"));
user.setIdpConfig(getConfig());
user.setIdp(this);
AbstractJsonUserAttributeMapper.storeUserProfileForMapper(user, profile, getConfig().getAlias());
return user;
}
```
Помимо собственно класса провайдера, нам понадобится класс описания конфигурации провайдера, в котором мы определим параметр конфигурации hostedDomain для проверки домена:
```
public class YandexIdentityProviderConfig extends OAuth2IdentityProviderConfig {
public YandexIdentityProviderConfig(IdentityProviderModel model) {
super(model);
}
public YandexIdentityProviderConfig() {
}
public String getHostedDomain() {
String hostedDomain = getConfig().get("hostedDomain");
return hostedDomain == null || hostedDomain.isEmpty() ? null : hostedDomain;
}
public void setHostedDomain(final String hostedDomain) {
getConfig().put("hostedDomain", hostedDomain);
}
}
```
После этого останется только создать пару классов `YandexIdentityProviderFactory` и `YandexUserAttributeMapper`, которые позволяет использовать наш провайдер в Keycloak, по аналогии с любым другим провайдером.
Для того, чтобы наш класс мог быть погружён механизмом SPI, в создаваемом jar необходимо разместить также текстовые файлы, описывающие связь между SPI-интерфейсами и созданными нами классами:
```
resources/
META.INF/
services/
org.keycloak.broker.provider.IdentityProviderMapper
org.keycloak.broker.social.SocialIdentityProviderFactory
```
Имя файла при этом соответствует интерфейсу, а содержимое — реализации: (`io.arenadata.keycloak.providers.yandex.YandexUserAttributeMapper` и `io.arenadata.keycloak.providers.yandex.YandexIdentityProviderFactory`).
Сборка выполняется с помощью Maven, со следующими зависимостями:
```
org.keycloak
keycloak-core
provided
${version.keycloak}
org.keycloak
keycloak-server-spi
provided
${version.keycloak}
org.keycloak
keycloak-server-spi-private
provided
${version.keycloak}
org.keycloak
keycloak-services
provided
${version.keycloak}
```
Итак, мы реализовали провайдер, добились с его помощью связки с Яндексом и можем переходить, собственно, к интересующим нас сервисам. Тут, казалось бы, всё сразу должно было получиться, но на практике всё оказалось не так просто, как мы рассчитывали.
### Gitlab
Начали мы с Gitlab. Он у нас уже был, поскольку постепенную миграцию на него с Github мы рассматривали уже давно, и в нём уже работала аутентификация Google Workspace, настроенная с использованием протокола SAML. Keycloak тоже поддерживает SAML, поэтому мы, недолго думая, просто перенастроили SAML-аутентификацию с Google на Keycloak, и всё сразу получилось.
Тут надо отметить одно очень полезное качество Gitlab: одна учётная запись Gitlab может быть привязана сразу к нескольким identity-провайдерам, уникальным идентификатором в этом случае является адрес электронной почты. Поэтому, например, можно создать часть пользователей локально и потом связать их с внешним провайдером, можно использовать несколько провайдеров одновременно и т. д. На самом деле, такая гибкость нетипична, гораздо распространённее ситуация, когда учётная запись привязана к какому-то одному провайдеру, и мы столкнулись с этим позже при подключении других сервисов.
Вдохновившись успехом с Gitlab, мы перешли к Mattermost, и вот с ним всё оказалось значительно сложнее.
### Mattermost
Mattermost блокирует сайт для российских IP, так что речь сразу шла об Open Source Team Edition. Возможности этой версии по организации SSO ограничены единственным провайдером, и этот провайдер, как ни странно, — Gitlab (на самом деле никакой странности нет: Mattermost используется в качестве средства общения в дистрибутивах Gitlab).
Gitlab у нас на тот момент уже был, и технически можно было бы использовать его для аутентификации, но процесс получался слишком сложный (аутентификация в Mattermost через аутентифкацию в Gitlab через аутентификацию в Яндекс). Хотелось просто использовать Keycloak в качестве SSO. Опять же, погуглив, мы нашли примеры настройки протокола аутентификации Gitlab в Keycloak, например: [Mattermost Teams Edition— Replacing Gitlab SSO with Keycloak](https://medium.com/@mrtcve/mattermost-teams-edition-replacing-gitlab-sso-with-keycloak-dabf13ebb99e).
И вот тут нас поджидала проблема.
Специфика авторизации Gitlab в Mattermost подразумевает получение от Gitlab уникального числового идентификатора пользователя. Для локального пользователя Keycloak или при использовании LDAP его легко добавить в
виде пользовательского атрибута, главное, чтобы идентификаторы были уникальными. При использовании внешнего identity-провайдера, как в нашем случае, пользователь Keycloak создаётся в момент первой аутентификации, и взять это значение неоткуда.
Задачу нужно было решать быстро, ковыряться в Java не хотелось, и мы решили срезать углы и использовать хак для генерации уникальных числовых идентификаторов, которые могли бы использоваться в качестве идентификаторов пользователей Gitlab в Mattermost. Мы написали триггер для базы данных Keycloak примерно такого содержания:
```
CREATE SEQUENCE IF NOT EXISTS mattermostid AS BIGINT INCREMENT BY 1 MINVALUE 1 NO CYCLE;
CREATE OR REPLACE FUNCTION add_mattermostid()
RETURNS TRIGGER
LANGUAGE PLPGSQL
AS
$$
BEGIN
INSERT INTO user_attribute(id, name,value,user_id) VALUES(
md5(random()::text || clock_timestamp()::text)::uuid::text,
'mattermostid',
nextval('mattermostid'),
NEW.id
);
RETURN NEW;
END;
$$
CREATE TRIGGER user_added AFTER INSERT ON user_entity FOR EACH ROW EXECUTE
PROCEDURE add_mattermostid();
```
При создании пользователя соответствующая запись добавляется в таблицу пользователей, срабатывает триггер, уникальный последовательный идентификатор добавляется в таблицу атрибутов, у пользователя чудесным образом появляется атрибут mattermostid, используемый в настройках клиента Keycloak для Mattermost, и аутентификация в Mattermost работает. Решение простое, в каком-то смысле красивое, позволило включить в работу Mattermost и в итоге оказалось неправильным, но об этом чуть позже. Отметим, что решение тем не менее имеет право на существование, если, например, нужна аутентификация Mattermost Team Edition каким-то внешним провайдером, а Gitlab при этом вообще не используется.
### Импорт сообщений из Slack
Попутно мы решали проблему импорта сообщений из Slack в Mattermost.
Mattermost поддерживает импорт из Slack, при этом он не только копирует каналы и сообщения, но и создаёт пользовательские учётные записи, соответствующие авторам импортируемых сообщений (жаль только, что импортировать полную длительную историю нам не позволили ограничения на стороне сервиса Slack). При этом у пользователя Mattermost может быть только один источник аутентификации, и, как несложно догадаться, в результате импорта мы получили множество локальных пользователей без идентификатора пользователя Gitlab. Радует в этом только то, что импорт — всё-таки разовая операция, и для новых пользователей, не появляющихся в результате импорта, каких-либо проблем не возникает.
К счастью, и у Keycloak, и у Mattermost есть REST API, причём у Mattermost предусмотрен специальный вызов, позволяющий изменить сервис аутентификации учётной записи.
Мы написали несложный скрипт, проверяющий, существует ли импортируемый пользователь в Keycloak, создающий его при необходимости и устанавливающий значение идентификатора пользователя Gitlab в значение атрибута, полученного от Keycloak (при добавлении пользователя оно автоматически сгенерируется триггером). Единственный минус — создаваемый в Keycloak пользователь по умолчанию локальный и может быть привязан к конкретному identity-провайдеру либо отдельным вызовом REST API, либо явной процедурой подтверждения пользователем своего внешнего аккаунта.
Вызов REST API в нашем случае оказался бесполезным, потому что в скрипте у нас не было возможности получить уникальный идентификатор пользователя Яндекс (кстати, на момент миграции API пользователей организации Яндекс ещё не существовал, да и он вряд ли бы нам помог). Поэтому мы решили пойти по пути модификации последовательности действий, выполняемых при первом логине пользователя (First Login Flow).
Keycloak позволяет редактировать существующую последовательность действий или создавать собственные из расширяемого набора предопределённых действий с помощью простого визуального редактора.
Последовательность по умолчанию (First Broker Login) позволяет пользователю привязать свою учётную запись к провайдеру, но требует дополнительных действий по подтверждению аккаунта. На этапе миграции с учётом большого количества пользователей такой сценарий вызывал слишком много организационных проблем. С учётом этого, а также того, что identity-провайдер у нас всего один, на период миграции мы упростили сценарий, сведя его к созданию нового пользователя (Create User If Unique) и автоматической привязке пользователя к провайдеру (Automatically Set Existing User).
Установив новый сценарий в качестве First Login Flow для провайдера Яндекса, мы получили автоматическую привязку локального пользователя с почтовым адресом в домене организации к провайдеру, и таким образом, казалось бы, вопрос аутентификации в ходе миграции на Mattermost был решён.
Но тут мы обнаружили, что проглядели один очень важный момент, и нам опять пришлось вернуться к программированию на Java.
### Интеграция Gitlab и Mattermost
Теперь, когда у нас появились работающие Gitlab и Mattermost, нам захотелось настроить между ними интеграцию для разработчиков. Всякие уведомления о различных событиях в проектах и т. д. И тут мы обнаружили, что с нашим реализованным ранее решением с триггером мы выполнить эту задачу не можем, потому что для её решения требуется, чтобы значения идентификатора пользователя Gitlab, атрибута mattermostid в Keycloak и соответствующего поля в таблице учётных записей Mattermost совпадали. А у нас они не совпадают, потому что у создания пользователей в Gitlab своя история, а у триггера, который генерирует нам идентификаторы для Mattermost, своя.
Тут мы, конечно, приуныли, потому что, во-первых, реализованное решение оказалось неправильным, а во-вторых, интеграция нужна.
Пришлось пересмотреть подход к генерации mattermostid в Keycloak.
Изначально мы не считали необходимым наличие для каждого пользователя учётной записи в Gitlab, потому что не все сотрудники программисты. С другой стороны, с учётом отказа от Jira и переезда задач в Gitlab, становится понятно, что для подавляющего большинства учётная запись в Gitlab рано или поздно понадобится, так что мы решили, что учётная запись в Gitlab вне зависимости от вида деятельности сотрудника нас не напрягает.
По условию задачи нам необходим реальный идентификатор пользователя Gitlab в момент первой аутентификации пользователя в Яндекс. Получается, что в процессе аутентификации нам необходимо:
* запросить Gitlab через REST API, существует ли учётная запись с почтовым адресом пользователя, для которого выполняется аутентификация;
* если такой учётной записи нет, создать её через API;
* получить идентификатор пользователя Gitlab;
* создать пользовательский атрибут mattermostid с полученным значением, который будет использоваться при аутентифкации в Mattermost.
На триггере такого уже, конечно, не реализуешь, так что мы собрали волю в кулак и пошли дальше программировать Keycloak.
В Keycloak логику можно было бы реализовать в двух местах:
* непосредственно в identity-провайдере;
* в дополнительном собственном шаге authentication flow (authenticator).
Первый вариант нам не понравился: у нас есть провайдер для Яндекса, он решает свою задачу, и грузить его какой-то мутной логикой для Gitlab не хотелось.
Второй вариант выглядел более логично: мы создаём дополнительный шаг для процесса аутентификации и можем при необходимости его использовать независимо от Яндекса или иного провайдера.
Собственную логику для authentication flow в Keycloak можно реализовать одним из двух способов:
* на JavaScript, использовав встроенный script authenticator;
* честно написав собственный аутентификатор на Java.
Первый способ наиболее простой, и в ряде случаев он может здорово выручить, если нужно здесь и сейчас быстро получить работающее решение или прототип. Код аутентификатора пишется на встроенной реализации JavaScript, при этом набор необходимых объектов (например, контекст аутентифкации) пробрасывается в скрипт в виде глобальных переменных.
Подключение скрипта требует принятия во внимание некоторых дополнительных моментов:
* по умолчанию поддержка скриптования в Keycloak отключена, необходимо явно включить поддержку с помощью флага --features при сборке или запуске в режиме разработки;
* возможность закачки скриптов администратором также требует дополнительных настроек и не будет поддерживаться в следующих версиях Keycloak;
* для шага аутентификации в виде скрипта нельзя реализовать настройку параметров в виде отдельного режима Configurе, так что если нужна параметризация, то либо использовать переменные окружения, либо вписывать параметры непосредственно в код (и заново разворачивать Keycloak при их изменении). По крайней мере информации о такой возможности мы не нашли, и из реализации кажется, что на уровне JavaScript это невозможно.
Тем не менее вариант с JavaScript вполне рабочий, и с его помощью можно решать реальные задачи. Сам JavaScript в общем-то вполне обыкновенный, единственная специфика — связь с Java API и вызов Java-методов, например, при вызове переопределённого метода необходимо обращаться к конкретной реализации, явно указывая его сигнатуру следующим образом:
```
SimpleHttp = Java.type("org.keycloak.broker.provider.util.SimpleHttp");
String response = SimpleHttp["doGet(String,KeycloakSession)"](url, session).asString();
```
Поскольку хотелось иметь возможность настраивать отдельные параметры, например значение токена для доступа к Gitlab, мы в итоге отказались от практически готового скрипта и переписали решение в виде собственного authenticator на Java. Получилось несколько длиннее, чем в случае провайдера, но удобнее с точки зрения последующего использования. Каких-то простых образцов реализации в виде отдельных проектов мы при этом не нашли и использовали в качестве примера код соответствующих классов в самом Keycloak.
Для реализации собственного шага аутентификации необходимо реализовать два класса — собственно аутентификатор и фабричный класс, реализовав необходимые интерфейсы (`Authenticator`, `AuthenticatoryFactory` и `DisplayTypeAuthenticatorFactory`).
Основной содержательный метод аутентификатора в нашем случае — authenticate, который и выполняет нужные нам действия:
```
public class MattermostIntegrationAuthenticator implements Authenticator {
private static final Logger LOG = Logger.getLogger(MattermostIntegrationAuthenticator.class);
@Override
public void authenticate(AuthenticationFlowContext context) {
UserModel user = context.getUser();
String email = user.getEmail();
Map config = context.getAuthenticatorConfig().getConfig();
int mattermostId = 0;
// Local user without email, e.g. admin, do nothing.
if (email == null || email.trim().isEmpty()) {
context.success();
return;
}
String gitlabToken = config.get(MattermostIntegrationAuthenticatorFactory.GITLAB\_TOKEN);
String gitlabURI = config.get(MattermostIntegrationAuthenticatorFactory.GITLAB\_URI);
try {
JsonNode searchUserResponse = SimpleHttp.doGet(
gitlabURI + "/api/v4/users?search=" + email, context.getSession())
.header("PRIVATE-TOKEN", gitlabToken)
.asJson();
if (searchUserResponse.size() > 0) {
mattermostId = searchUserResponse.get(0)
.get("id").asInt(0);
} else {
GitlabCreateUserRequest createUserRequest = new GitlabCreateUserRequest();
createUserRequest.setEmail(email);
createUserRequest.setName(user.getFirstName() + " " + user.getLastName());
createUserRequest.setUsername(user.getUsername());
JsonNode createUserResponse = SimpleHttp.doPost(gitlabURI + "/api/v4/users", context.getSession())
.header("PRIVATE-TOKEN", gitlabToken)
.json(createUserRequest)
.asJson();
if (createUserResponse != null) {
mattermostId = createUserResponse.get("id").asInt(0);
}
}
if (mattermostId > 0) {
user.setSingleAttribute(
"mattermostid", Integer.toString(mattermostId));
}
} catch (IOException e) {
LOG.error(e.getMessage());
}
context.success();
}
// ...
}
```
Аутентификация всегда завершается успехом: если по каким-то причинам Gitlab в момент аутентификации недоступен, это не лишает пользователя возможности выполнить аутентификацию, привязка к Mattermost в этом случае может быть выполнена при повторной аутентификации.
В фабричном классе описываются в том числе и параметры конфигурации, которые могут быть настроены в административном интерфейсе:
```
public class MattermostIntegrationAuthenticatorFactory implements AuthenticatorFactory, DisplayTypeAuthenticatorFactory {
public static final String PROVIDER_ID = "mattermost-integration";
public static final String GITLAB_TOKEN = "gitlabToken";
public static final String GITLAB_URI = "gitlabURI";
@Override
public List getConfigProperties() {
ProviderConfigProperty gitlab\_uri = new ProviderConfigProperty(
GITLAB\_URI,
"Gitlab URI",
"Gitlab instance URI (https://gitlab.com)",
STRING\_TYPE,
null
);
ProviderConfigProperty gitlab\_token = new ProviderConfigProperty(
GITLAB\_TOKEN,
"Gitlab Token",
"Gitlab private token",
STRING\_TYPE,
null
);
return asList(gitlab\_uri, gitlab\_token);
}
// ...
}
```
### Прочие сервисы
К счастью, с остальными сервисами всё пока прошло без приключений, и больше ничего изобретать не понадобилось.
Для Jenkins (да, мы переходим на Gitlab, но на Jenkins пока ещё завязано очень много процессов) мы использовали [плагин авторизации в Keycloak](https://github.com/jenkinsci/keycloak-plugin), и каких-либо существенных проблем с ним не возникло. Существуют и альтернативные плагины, использующие OpenID Connect, скорее всего, с ними тоже бы всё получилось, в данном случае нас устроил первый полученный результат.
C Bookstack проблем тоже не возникло, достаточно было сделать всё по инструкции.
Было желание на период миграции с Jira так же подключить её к общему SSO, но это оказалось невыполнимо: внешняя авторизация в собственном SSO требует покупки дополнительного продукта, а с учётом перехода это просто не имеет смысла.
### Визуальная тема
Keycloak поддерживает кастомизацию визуальных тем, используемых в том числе в процессе аутентификации, и, честно говоря, реализация тем выглядит в высшей степени переусложненной (Javascript fatigue в полный рост). В итоге мы реализовали собственную тему, в процессе поняв, что:
* за основу имеет смысл брать встроенную тему Keycloak;
* если в команде есть люди, профессионально занимающиеся frontend, и есть возможность выделить определённое время, можно писать целиком собственную тему, используя base; мы не разработчики и позволить себе такое не могли;
* доступные на Github упрощённые темы (например, Alfresco) имеют массу проблем и ограничений, если хочется чего-то в качестве основы, лучше смотреть на темы, базирующиеся на встроенных, например на [тему Linaro](https://github.com/linaro-its/keycloak-linaro-theme).
Мы реализовали собственную визуальную тему, взяв за основу Linaro, изменив шаблон и переопределив цвета, реализация получилась очень избыточной, но мы всё равно решили, что собственная тема при корпоративном использовании имеет смысл и когда-нибудь потом мы её отрефакторим.
### Сборка контейнера
Использование Quarkus всегда предполагает использование multistage-контейнера, включающее по крайней мере два шага: конфигурирование типового образа Keycloak в отдельном контейнере (build) и формирование образа для запуска путём копирования оптимизированного приложения в итоговый контейнер. В нашем случае добавилась ещё сборка собственных расширений и визуальной темы, в итоге наш Dockerfile выглядит примерно так:
```
ARG VERSION
ARG KEYCLOAK_VERSION=17.0.1
# Build extensions.
FROM maven:3-openjdk-17 as builder
ARG VERSION
ARG KEYCLOAK_VERSION
COPY extensions /src/extensions
RUN cd /src/extensions && mvn package
# Configure Keycloak.
FROM quay.io/keycloak/keycloak:${KEYCLOAK_VERSION} as keycloak
ARG VERSION
ARG KEYCLOAK_VERSION
COPY --from=builder \
/src/extensions/target/keycloak-arenadata-${VERSION}.jar \
/opt/keycloak/providers/
COPY themes/arenadata/ /opt/keycloak/themes/arenadata/
RUN /opt/keycloak/bin/kc.sh build \
--db=postgres \
--metrics-enabled=true \
--features=scripts
# Build Keycloak.
FROM quay.io/keycloak/keycloak:${KEYCLOAK_VERSION}
ARG VERSIONARG KEYCLOAK_VERSION
COPY --from=keycloak /opt/keycloak/lib/quarkus/ /opt/keycloak/lib/quarkus/
COPY --from=keycloak /opt/keycloak/providers/ /opt/keycloak/providers/
COPY --from=keycloak /opt/keycloak/themes/ /opt/keycloak/themes/
WORKDIR /opt/keycloak
ENTRYPOINT ["/opt/keycloak/bin/kc.sh"]
```
Мы изменили точку входа итогового контейнера для того, чтобы его проще было использовать в том числе и в режиме разработки.
### Итого
В итоге мы убедились, что Keycloak — это очень гибкое и полезное решение, и, пусть и с приключениями, но реализовали нужную нам функциональность.
Самым проблемным сервисом оказался Mattermost, в первую очередь из-за ограничений Team Edition.
Что мы хотим сделать дальше:
* провести дополнительный аудит безопасности;
* написать дополнительный скрипт аудита, который периодически проверял бы соответствие учётных записей в разных сервисах друг другу;
* отработать протокол увольнения сотрудника;
* реализовать дополнительную логику включения нового пользователя в группы на стороне Gitlab.
Получившееся у нас решение мы выложили в виде [репозитория на Github](https://github.com/arenadata/keycloak-arenadata).
> Хочу поблагодарить за помощь в подготовке этого материала моего коллегу, Сергея Ротару ([@Maunty](/users/maunty)) который принимал участие в обсуждении ряда технических вопросов и провел рецензирование статьи.
>
> | https://habr.com/ru/post/664238/ | null | ru | null |
# Pro Parboiled (Часть 4 заключительная)
**Часть 4. Суровая действительность**
Как заставить Parboiled работать еще быстрее? Каких ошибок лучше не допускать? Что делать с наследством в виде Parboiled1? На эти, а так же другие вопросы призвана ответить заключающая статья серии.
**Структура цикла:**
* [Часть 1. Почему Parboiled?](http://habrahabr.ru/post/270233)
* [Часть 2. Сопоставление текста](http://habrahabr.ru/post/270531)
* [Часть 3. Извлечение данных](http://habrahabr.ru/post/270609)
* Часть 4. Суровая действительность
Производительность
==================
Parboiled2 работает быстро, но иногда он может работать еще быстрее. В этом разделе мы поговорим о доступных микрооптимизациях. Главное при выполнении оптимизаций — своевременность. Но если есть возможность сразу написать чуть более оптимальный код, не потеряв при этом в выразительности — этой возможностью обязательно следует воспользоваться.
Разворачивайте `n.times` для малых n <= 4
-----------------------------------------
Вы можете выиграть в производительности, если для малых *n* вместо оператора повторения `n.times` просто соедините несколько повторяющихся правил в цепочку. Сколько повторений имеет смысл разворачивать — зависит от обстоятельств, но едва ли это число больше четырех.
```
// Медленно
rule { 4 times Digit }
// Быстро
rule { Digit ~ Digit ~ Digit ~ Digit }
```
Актуальность этой оптимизации [объявлена](https://github.com/sirthias/parboiled2/issues/101) самим Матиасом, хотя, гипотетически, оператор `n.times` мог бы и сам ее выполнять.
Ускорение операций со стеком для `n.times`
------------------------------------------
Использование подобной техники позволит вам выжать немножко производительности и при извлечении данных со стека значений. Например, так ее можно применить к предыдущему правилу:
```
def Digit4 = rule {
Digit ~ Digit ~ Digit ~ Digit ~
push(
#(charAt(-4))*1000 +
#(charAt(-3))*100 +
#(charAt(-2))*10 +
#(lastChar)
)
}
```
Не пересоздавайте `CharPredicate`
---------------------------------
Совершенно нормально радоваться новым возможностям класса `CharPredicate`, но создавать свои экземпляры типа `CharPredicate` внутри блока `rule` совершенно не стоит: ваш предикат будет пересоздаваться каждый раз, когда выполняется правило, что драматически испортит производительность вашего парсера. Поэтому, вместо того чтобы создавать символьные предикаты каждый раз, определите их внутри вашего парсера как константу:
```
class MyParser(val input: ParserInput) extends Parser {
val Uppercase = CharPredicate.from(_.isUpper)
...
}
```
или, что еще лучше, отправьте это объявление в объект-компаньон вашего парсера:
```
class MyParser(val input: ParserInput) extends Parser {
...
}
object MyParser {
val Uppercase = CharPredicate.from(_.isUpper)
}
```
Используйте семантические предикаты
-----------------------------------
Особенность данных правил состоит в том, что они не взаимодействуют со стеком значений. Подробно, они описаны в документации, но вот самое главное, что вы должны о них знать:
> При использовании семантических предикатов парсер не совершает прогресса, то есть не перемещает свой курсор на следующий символ. Поэтому при их бездумном использовании парсер может зациклиться.
>
>
Помните пример с объявлением символьного предиката для символов верхнего регистра? Вы можете сделать тоже самое, используя семантический предикат `test`:
```
def JavaUpperCase = rule { oneOrMore(test(currentChar.isUpper) ~ ANY) }
```
Используйте `ANY` там, где хотели бы видеть `CharPredicate.All`
---------------------------------------------------------------
Увы, `CharPredicate.All` работает медленно для больших диапазонов символов, `ANY` работает быстрее. Воспользуйтесь этим знанием.
Используйте инвертирующий предикат
----------------------------------
Представьте, что ваш парсер должен захватывать все символы до перевода строки (для определенности, в стиле Unix). Конечно, это можно сделать при помощи `noneOf`, но инвертирующий предикат будет быстрее:
```
def foo = rule { capture(zeroOrMore(noneOf("\n"))) }
// Быстрее?
def foo = rule { capture(zeroOrMore(!'\n')) }
```
К сожалению, этот замечательно выглядящий пример зациклит, потому что парсер не будет совершать прогресса. Чтобы это исправить, необходимо правило, передвигающее курсор парсера, но при этом не изменяющее стек. Например, вот такое:
```
def foo = rule { capture(zeroOrMore( !'\n' ~ ANY )) }
```
Теперь правило `foo` поглотит абсолютно все, кроме `EOI` и перевода строки.
Отчеты об ошибках
=================
Не думаю, что вам захочется работать с парсером, выдающим бессмысленные сообщения при любых некорректных входных данных. Parboiled2 способен вполне внятно рассказывать об ошибках, если вы ему в этом поможете.
Форматирование
--------------
Итак, если что-то навернулось, парсер передаст в ваше распоряжение объект типа `ParseError`, который можно привести в читаемый вид посредством метода `formatError`:
```
val errorMessage = parser formatError error
```
Если форматирование по умолчанию вас по каким-то причинам не устраивает, свои пожелания следует передать парсеру явным образом:
```
val errorMessage parser.formatError(error, new ErrorFormatter(showTraces = true))
```
Если вы захотите написать свой `ErrorFormatter`, вам придется самостоятельно разобраться со структурой класса `ParseError`, который объявлен в глубине Parboiled таким образом:
```
case class ParseError(position: Position, charCount: Int, traces: Seq[RuleTrace]) extends RuntimeException
```
Также стоит отметить наличие нескольких схем доставки сообщений об ошибке до пользователя: по вашему желанию `ParseError` может быть представлен не только в виде объекта `Try`, а, например, в виде полиморфного типа или `Either`. Подробнее можно ознакомиться [здесь](https://github.com/sirthias/parboiled2/blob/master/README.rst#alternative-deliveryschemes).
```
def Foo = rule { "foo" | fail("Я упаль!") }
```
Тонкая настройка
----------------
Существует опция, позволяющая обойти встроенный механизм формирования сообщений об ошибках. Для этого нужно использовать правило `fail` с сообщением, которое вы хотите увидеть в случае ошибки:
```
def Goldfinger = rule { "talk" | fail("to die") }
```
Тогда при удобном случае вы получите назад свое сообщение об ошибке примерно в такой форме:
```
Invalid input 'Bond', expected to die. (line 1, column 1):
```
Именованные правила
-------------------
Использование подобного типа правил бывает весьма полезным не только в целях отлова ошибок. Данный механизм подробно описан в разделе «Best Practices».
atomic
------
Parboiled2 генерирует парсеры, основанные на PEG. Это означает, что парсеры оперируют символами, а не строками (как многие могли подумать), поэтому и ошибки вам будут показываться на символьном уровне. Согласитесь — сообщение вида «У вас тут X, мы ожидали Y или Z» потребует больше мысленных усилий, чем «У вас тут XX, а мы ожидали увидеть XY или XZ». Для того, чтобы видеть строки в отчетах об ошибках целиком, существует маркер `atomiс`, всего-то и нужно обернуть в него правило:
```
def AtomicRuleTest = rule { atomic("foo") | atomic("fob") | atomic("bar") }
```
Чтобы при лисичках (`foxes`) на входе получить
```
Invalid input "fox", expected "foo", "fob" or "bar" (line 1, column 1):
foxes
^
```
quiet
-----
Когда вариантов для выбора слишком много, не всегда хочется уведомлять пользователя о всех возможных альтернативах. Например, в определенном месте ваш парсер ожидает множество пробельных символов в совокупности с неким правилом. Для устранения избыточности в отчете, вы, возможно, захотите умолчать о пробелах. С использованием маркера `quiet` это очень просто:
```
def OptionalWhitespaces = rule { quiet(zeroOrMore(anyOf(" \t\n"))) }
```
Честно признаюсь — ситуаций, поощряющих использования этого правила, я не встречал. Так же, как и `atomic`, оно подробно [описано в документации](https://github.com/sirthias/parboiled2/blob/master/README.rst#the-quiet-marker).
Восстановление после ошибок
---------------------------
Практически единственный эпизод, где Parboiled1 выигрывает, а у Parboiled2 дела обстоят не очень хорошо: парсер падает уже только от вида первой же встреченной им ошибки. Для большинства сценариев это отлично подходит: это, например, не мешает парсить логи, текстовые протоколы, конфигурационные файлы (для ряда случаев), однако разработчикам DSL или IDE-подобных инструментов такое положение дел будет не по душе. [Матиас обещает это исправить](https://github.com/sirthias/parboiled2/issues/42), поэтому если вам эта функциональность очень сильно нужна уже сегодня — напишите на баг-трекер, возможно это ускорит процесс разработки.
В Parboiled1 имеется [огромное число ParserRunnerов](https://github.com/sirthias/parboiled/wiki/Parse-Error-Handling) на все случаи жизни. Посмотрите в сторону `RecoveringParserRunner`, если вам нужно продолжать парсинг в случае ошибок.
Тестирование
------------
Разработчики Parboiled используют для тестирования фреймворк [specs2](https://etorreborre.github.io/specs2/), который они дополнили своим вспомогательным классом [TestParserSpec](http://bit.ly/1Y5iZ9t). Он покажется неудобным тем, кто использует scalatest, но основную его идею можно и перенять. По секрету от Матиаса, его решение не отличается особенной аккуратностью, так как полагается на изменяемое состояние. Возможно, в будущем нас будет ждать что-то похожее на полноценный каркас для тестирования.
Правила можно тестировать как по отдельности, так и вместе. Лично я предпочитаю писать тесты не на каждое правило, а проверять только главное правило в «особых» случаях:
> Во многих форматах, даже стандартизованных, могут встречаться весьма интересные моменты. Например, в BSD-подобном формате сообщений [RFC 3164](https://www.ietf.org/rfc/rfc3164.txt) под число месяца *всегда* отводится две позиции, даже если само число имеет один разряд. Вот пример из самого RFC:
>
>
>
>
> > If the day of the month is less than 10, then it MUST be represented as a space and then the number. For example, the 7th day of August would be represented as `"Aug 7"`, with two spaces between the `"g"` and the `"7"`.
> >
> >
>
>
Помимо подобного рода «интересных моментов» можно скармливать парсеру строки с незакрытыми скобками, недопустимыми символами, проверять порядок операций со стеком значений.
В тестировании есть еще одна тонкость, с которой вы сразу же столкнетесь. Предположим, вы хотите оттестировать следующее правило:
```
def Decimal: Rule0 = rule {
("+" | "-").? ~ Digit.+ ~ "." ~ Digit.+
}
```
Для этого отправим парсеру заведомо некорректный ввод и будем ждать на выходе ошибку:
```
// Я еще не видел десятичных дробей с двумя разделителями.
val p = new MyParser("12.3.456").Decimal.run() // Success(())
p.isFailure shouldBe true // тест упадет
```
Но при прогоне теста окажется, что парсер вернул удачный результат. Почему так? В нашем правиле нет `EOI`, но если если мы добавим в него `EOI`, то испортим все правила, которые используют `Decimal`. Поэтому придется создать специальное тестирующее правило, например, при помощи хитрого механизма [мета-правил](https://github.com/sirthias/parboiled2/blob/master/README.rst#advanced-techniques). Давайте добавим EOI в конце нашего предыдущего примера, и убедимся в том, что парсер упал с ошибкой:
```
Failure(ParseError(Position(5,1,6), Position(5,1,6), <2 traces>))
```
Недостатки Parboiled
====================
Parboiled2
----------
Если недостатки есть у людей, почему бы их не иметь библиотекам? Здесь Parboiled2 не является исключением.
* Длинные, слишком общие и совершенно непонятные сообщения компилятора об ошибках, в лучших традициях C++. Наглядный пример приведен на рисунке ниже (в правиле нечаянно пропущен оператор `~`). Причина связана с выполнением продвинутых проверок на типах, которые [обещают убрать](https://github.com/sirthias/parboiled2/issues/106) в будущих версиях.
Компилятор грязно ругается
* Эта проблема относится больше не к Parboiled2, а к scalac. Компилятору может снести крышу, если у лямбды, захватывающей значения со стека, явно (не)определены типы аргументов:
```
// Может не сработать
def MyRule = rule { oneOrMore(Visible) ~> {s => "[" + s + "]"} }
// Скорее всего сработает
def MyRule = rule { oneOrMore(Visible) ~> {s: String => "[" + s + "]"} }
```
Что сработает, а что нет — зависит от версии вашего компилятора.
* Многие IDE еще не научились поддерживать макровыражения, а Parboiled2 был построен не без их помощи. Поэтому не стоит верить подчеркиваниям вашей среды разработки. Однажды я, забыв об этом, потратил целый день на поиск несуществующей ошибки буквально на ровном месте.
* Отсутствие механизма восстановления при неудачном разборе. Проектирующих предметно-ориентированные языки, или же тех, кто хочет использовать Parboiled2 в качестве фронтэнда к своему компилятору, это сильно разочарует. Но над этим [работают](https://github.com/sirthias/parboiled2/issues/42). Если вы хотите видеть эту возможность — пишите, это ускорит разработку.
* Я думаю, что многим разработчикам своих небольших IDE и текстовых редакторов хотелось бы видеть более гибкие сообщения об ошибках, чем те, что предоставляются сейчас. На данный [момент](https://github.com/sirthias/parboiled2/issues/96) существует всего два способа повлиять на них:
+ именованные правила,
+ именованные вложенные правила.
Parboiled1
----------
Большинство проектов все еще написаны на Parboiled1, и вряд-ли что-то изменится резко и кардинально (в энтерпрайзе), поэтому может быть полезным знать, как научиться мириться с его недостатками, коих у Parboiled1 немало. Помимо весьма ограниченного DSL, у Parboiled существует проблема «Rule8», которая усложняет написание парсера для логов. Parboiled1 построен так, что на каждое правило с N элементами имеется по классу, по аналогии со скаловскими кортежами (tuples): есть `Rule0`, `Rule1`, вплоть до `Rule7`. Этого вполне достаточно, чтобы распарсить сложные языки программирования, такие как Java, да и вообще не вызывает существенных проблем при разборе древовидных структур. А вот если нужно извлечь данные из линейной структуры, например, сообщения лога-файла, то в это ограничение очень несложно упереться. Решается это использованием кортежа вместо одного результирующего правила. Вот пример:
```
def Event: Rule1[LogEvent] = rule {
Header ~ " " ~ UserData ~ " " ~ Message ~~> {
(header, data, message) => SyslogEvent (
header._1, header._2, header._3, header._4, header._5, data._1, data._2, message
)
}
}
```
Пусть выглядит убого, зато проблема решена.
Best practices
==============
В этом разделе я расскажу о прописных истинах, работающих для любого комбинатора парсеров, а так же о нюансах, специфичных для Parboiled2.
CharUtils
---------
Есть один полезный объект, не затронутый в документации: [CharUtils](http://bit.ly/1NJJ2kd). Он содержит ряд статических методов, способных облегчить вашу жизнь, например: изменение регистра символов, экранирование, преобразование целочисленных значений в соответствующие им символы (строки). и др. Его использование, возможно, сэкономит ваше время.
Пишите модульные тесты
----------------------
Одно небольшое неудачное изменение может сломать вам грамматику и обеспечить острую ректальную боль. Это банальный совет, которым многие пренебрегают. Парсер не так сложно протестировать, как, скажем IO: вам не нужны Mock-объекты и другие ухищрения для этой рутинной, но очень ценной работы. У нас была целая инфраструктура парсеров. И поверьте, первое, что я делал при поиске ошибок — садился и писал тесты, в случае их отсутствия.
Делайте парсеры и правила маленькими
------------------------------------
Разделяйте ваши парсеры на подпарсеры. Каждый компонент должен делать что-то вполне определенное. Например если вы парсите LogEvent, у которого определено поле Timestamp (особенно если этот Timestamp соответствует какому-нибудь Rfc), то не поленитесь и вынесите его отдельно.
* Во-первых, это уменьшит код вашего основного прасера, и сделает его нагляднее.
* Во-вторых, это заметно облегчит тестирование. Вы покроете модульными тестами ваш подпарсер. А после этого приступите к разработке главного парсера
Существуют разные подходы:
* Разбивать парсер на трейты и использовать self-typed reference (предпочитаю этот способ).
* Объявлять парсеры как самостоятельные сущности и использовать композицию.
* Использовать встроенный механизм для создания subParsers.
Правила должны быть максимально компактными, но не компактней. Чем меньше ваши правила, тем легче найти ошибку в грамматике. Очень сложно понять логику разработчика, если он делает правила длинными, и при этом многократно использует `capture`. Усугублять ситуацию может неявный захват. Указание типа правила также помогает при поддержке.
Отправляйте case objects вместо строк в Value stack
---------------------------------------------------
Данный совет можно отнести и к оптимизациям, так как это заставит парсер работать быстрее. Отправляйте в Value stack значимые объекты, а не строки. Это сделает ваш парсер быстрее, а код нагляднее.
Плохо:
```
def logLevel = rule {
capture("info" | "warning" | "error") ~ ':’
}
```
Хорошо:
```
def logLevel = rule {
“info:” ~ push(LogLevel.Info)
| “warning" ~ push(LogLevel.Warning)
| “error" ~ push(LogLevel.Error)
}
```
Используйте упрощенный синтаксис для сборки объекта
---------------------------------------------------
Этот красивый способ появился еще в Parboiled1. Никакой магии, просто конструктор case classа вызывается неявно. Главное, чтобы количество и тип аргументов, помещаемых на Value Stack, совпадали с сигнатурой конструктора case classа.
Плохо:
```
def charsAST: Rule1[AST] = rule { capture(Characters) ~> ((s: String) => AText(s)) }
```
Хорошо:
```
def charsAST = rule { capture(Characters) ~> AText }
```
Именованные правила (named rules)
---------------------------------
Именованные правила заметно упрощают жизнь при получении отчетов об ошибках, так как дают возможность вместо невнятного имени правила использовать псевдоним. Или же помечать правила определенным тегом — «Это выражение» или «Модифицирует стек». В любом случае знать о данной функции будет полезно.
Многие пользователи Parboiled1 уже полюбили эту возможность. Например разработчики Neo4J, использующие Parboiled для разбора языка [Cypher](http://neo4j.com/docs/2.2.3/cypher-introduction.html).
Как это выглядит в Parboiled1:
```
def Header: Rule1[Header] = rule("I am header") { ... }
```
В Parboiled2:
```
def Header: Rule1[Header] = namedRule("header is here") { ... }
```
Так же есть возможность давать имена вложенным правилам:
```
def UserName = rule { Prefix ~ oneOrMore(NameChar).named("username") ~ PostFix }
```
Миграция
========
Миграция — процесс, чаще всего, несложный, но времени отнимает немало. Поэтому я постараюсь хотя бы немного сэкономить драгоценные часы вашей жизни и описать основные подводные камни.
Classpath
---------
Для того, чтобы избежать конфликтов с первой версией, Parboiled2 использует classpath `org.parboiled2` (тогда как classpath для первой версии `org.parboiled`). Мавеновский `groupId`, однако, остался старым: `org.parboiled`. Благодаря этому, можно иметь обе зависимости в одном проекте и осуществлять постепенный переход на новую версию. Что, кстати, работает весьма неплохо при наличии нескольких автономных парсеров. Если же ваши парсеры состоят из множества модулей, переиспользуемых в разных местах (как это было в моем случае) — вам придется делать миграцию сразу и для всех модулей.
Проверка тестов
---------------
Убедитесь в наличии и работоспособности модульных тестов. Они же у вас есть? Нет? Напишите их. В процессе миграции мне приходилось уточнять некоторые грамматики из-за того, что новый DSL стал мощнее, и нечаянные изменения ломали грамматики. Падающие тесты экономили много времени. С серьезными проблемами, вроде поломки всей грамматики целиком, при миграции я не сталкивался. Может быть кто-то поделится опытом, если с ним это произошло.
Код вокруг парсера
------------------
Теперь парсер будет пересоздаваться каждый раз, что не всегда удобно. С PB1 я очень любил создавать парсер единожды, а потом многократно его использовать. Теперь этот номер не пройдет. Поэтому вам придется изменить конструктор парсера и немного переписать использующий его код, и не бойтесь, что это ухудшит производительность.
> **Предупреждение** Parboiled1 позволяет генерировать правила во время выполнения. Поэтому если у вас имеется подобный парсер, то вам, скорее всего, придется его переписать: Parboiled2 использует макровыражения которые делают динамику весьма затруднительной, взамен давая лучшую производительность.
>
>
Композиция
----------
Подход к композиции элементов парсера не изменился, это хорошая новость для мигрирующих. Однако `Parser` теперь не трейт, а абстрактный класс. Трейты (traits) — удобнейшее средство композиции програмных компонентов, в PB1 это позволяло подмешивать `Parser` в любые модули, смешивая модули между собой. Изменение в пользу абстрактного класса на эту возможность никак не повлияло, но теперь для этого нужно использовать [self-typed reference](http://docs.scala-lang.org/tutorials/tour/explicitly-typed-self-references.html):
```
trait Numbers { this: Parser =>
// Ваш код
}
```
Тем, кто подобную возможность языка не использовал и каждый раз подмешивал трейт `Parser`, придется изменить свои вкусовые предпочтения.
В качестве альтернативного способа, вы можете сделать из ваших трейтов полноправные парсеры и импортировать из них нужные правила (как методы) в ваш основной парсер. Я, правда, все равно предпочитаю использовать композиции трейтов, потому как нахожу их более наглядными: мне понятней видеть парсер собранный из кусков, вместо множественных импортов.
Избавляемся от примитивов
-------------------------
В процессе миграции обязательно устройте ревизию своей личной библиотечки примитивных правил: удалите все что имеется в `CharPredicate`. Ваша библиотечка похудеет, однако не исчезнет совсем. Многие хотели бы добавить в parboiled поддержку различных форматов дат, грамматику описывающую электронную почту, заголовки HTTP. Parboiled просто комбинатор парсеров: он таковым был, таким и останется. Однако согласитесь, что выбрасывать старый код очень приятно.
Заключение
==========
В этой серии статей я попытался рассказать вам про самый прогрессивный и перспективный инструмент парсинга, существующий для языка scala. Сделал небольшой туториал и рассказал о проблемах, с которыми мне пришлось столкнуться на практике. Надеюсь, что эта статья в худшем случае окажется для вас полезной, а в лучшем — станет руководством к действию.
Использованные источники
========================
* [Список рассылки проекта Parboiled](https://groups.google.com/forum/#!topic/parboiled-user/Ygb_M6XU5P8)
* [Презентация Александра Мыльцева](http://www.youtube.com/watch?v=qZg4D62K4aQ) и [слайды к ней](http://myltsev.name/ScalaDays2014/#/)
* [Примеры кода из репозитория Parboiled](http://bit.ly/1H2ZQ3A)
* [Парсер языка scala, написаный при помощи Parboiled2](https://github.com/sirthias/parboiled2/tree/master/scalaParser/src)
Благодарности
=============
Хочу выразить благодарность Александру и Матиасу за то, что у меня появился повод для статьи, а так же удобный инструмент. Яна, спасибо тебе за вычитку и правку моих многочисленных ошибок, обещаю буду писать грамотнее. Спасибо [firegurafiku](https://habrahabr.ru/users/firegurafiku/) и Too Taboo за помощь в вертске первой статьи, вычитку, многочисленные исправления, и идеи для примеров в последующих. Спасибо Владу Ледовских, за вычитку и исправления в последней статье серии. Спасибо [nehaev](https://habrahabr.ru/users/nehaev/), за найденную в коде статьи ошибку, и Игорю Кустову за идею разбить огромнейшую статью на части (я долго не хотел этого делать). Особая благодарность Арсению Алесандровичу [primetalk](https://habrahabr.ru/users/primetalk/), за найденные неточности и
полезные предложения. Спасибо и всем тем, кто следил за циклом статей и дошел до последней. Надеюсь работа не была проделана зря. | https://habr.com/ru/post/271003/ | null | ru | null |
# Зачем нужна выделенная Frontend Core команда и как мы внедряли дизайн систему
Всем привет, меня зовут Ростислав, я занимаю должность Front Lead в компании ДомКлик. Хочу поделиться с вами опытом создания Web Core команды и сразу ответить на следующие вопросы:
* Необходима ли такая команда в компании?
После года существования команды Web Core, у всех сложилось понимание, что в больших компаниях это необходимо, а в стартапах — не обязательно.
* Выгодно ли внедрять такую команду?
Безусловно. Изначально было сложно измерить и спрогнозировать выгоду от её создания, все расчеты, P&L были на словах, в цифрах — только примерные предположения. Спустя год мы можем посчитать сэкономленное время, профиты, и все расчеты говорят о том, что это было не зря.
* На долгую перспективу ли эта команда?
Если у вас одна цель — создать дизайн систему и выпустить библиотеку компонентов под ключ, то возможно. Если же вы хотите это всё динамически развивать и расширять зоны ответственности команды, то это точно надолго.
* Чем эта команда занимается?
Основное направление — дизайн система, но по ходу её разработки у нас появилось еще много интересных задач.
Предыстория
-----------
Создание Web Core команды началось с потребности разработать дизайн систему и библиотеку компонентов с последующей поддержкой и развитием, а также внедрить стандарты для frontend — разработки.
У нас в компании немало продуктовых команд, в каждой по несколько продуктов, состоящих из одного или нескольких веб-клиентов, которые могут содержать в себе виджеты и компоненты. Все веб-клиенты собираются в огромную экосистему ДомКлик, и, естественно, возникает вопрос о единообразии дизайна и UX-поведения всех элементов на страницах, чтобы клиент, переходя из продукта в продукт, понимал, что он в одной системе. И еще стоит вопрос об избыточных трудозатратах при разработке новой или доработке старой функциональности.
За всю историю ДомКлик было много попыток собрать библиотеку компонентов для их переиспользования во всех командах. Сначала пытались это делать в лояльном режиме: выделяли из своих проектов компоненты, которые можно переиспользовать, в отдельный репо и публиковали в npm-репозиторий. Затем компания энтузиастов решила собрать базу лучших компонентов в один проект со storybook, с единообразным API, и, по возможности, её поддерживать и дополнять. Но все эти попытки были тщетны до создания выделенной команды Web Core, у которой есть свои цели, обязанности и компетенции.
Дизайн-система и UI-KIT
-----------------------
Какие цели мы хотели достичь при создании дизайн системы:
* увеличить скорость разработки продуктов;
* повысить качество продуктов;
* помочь разработке сконцентрироваться на создании бизнес логики;
* увеличить лояльность аудитории за счет привычки работы с интерфейсом (UX);
* а также иметь возможность трансформировать дизайн всей экосистемы, обновив лишь компоненты у себя в продукте.
Наша дизайн система будет состоять из таких элементов:
* Гайдлайны и руководство по стилю — сетка, типографика, цвета, брейкпоинты.
* UI-KIT — набор элементов пользовательского интерфейса для дизайнеров, основанный на гайдлайнах.
* Шаблоны (паттерны) — композиция элементов UI-KIT для описания типового интерфейса.
* Библиотека компонентов — кодовая база для использования в проектах. Включает в себя сами компоненты, документацию к ним, историю изменений, примеры использования с рекомендациями и правилами применения.
Дизайн
------
В ДомКлик уже было несколько версий дизайн систем, и теперь перед нашим дизайнером стояла непростая задача собрать самую актуальную и полноценную дизайн-систему. Самой большой проблемой было собрать все потребности использования каждого элемента, учесть все возможные состояния и условия, в которых он применяется. Про дизайн и проблемы, решавшиеся на этапе проектирования, нужно писать отдельную статью. Обозначу вкратце атомарность нашего UI-KIT.
Основа всей дизайн системы — гайдлайны.
На основе гайдлайнов строятся базовые элементы. А на основе базовых элементов строятся более сложные элементы.
По такому же принципу мы будем выстраивать нашу библиотеку компонентов, начиная с гайдлайнов и заканчивая сложными элементами.
Разработка
----------
А теперь перейдём к проектированию. Библиотеку компонентов мы разрабатываем на React — стандарте ДомКлик. Будем использовать Typescript для статической типизации, что помогает удобно использовать наши компоненты. Почему нельзя взять готовую библиотеку компонентов и просто интегрировать в нее нашу дизайн-систему? Во-первых, это тяжеловесные библиотеки, которые повлияют на производительность ваших продуктов. Во-вторых, вам постоянно будет не хватать их функциональности и придется их постоянно дорабатывать.
Перед началом разработки мы задали себе несколько задач:
### Версионирование
Мы будем итеративно разрабатывать наши компоненты, улучшать их, добавлять новую функциональность. Вероятно, у нас будет меняться дизайн. Работаем мы по SemVer, т.е. фиксы и улучшения производительности мы выпускаем в патч-версии; добавления нового API и возможностей — в минор-версии; смена API для работы с компонентом, дизайна и его поведения — в мажор-версии.
Есть несколько способов поставки библиотеки компонентов конечному потребителю — продуктовым разработчикам.
Самый популярный вариант: **один пакет** UI-KIT, который ставишь целиком в проект и в дальнейшем обновляешь его при появлении новой версии. В этом случае должен безукоризненно работать tree shaking, иначе при сборке проекта мы получим даже те зависимости, которые не используем.
**Достоинства:**
* Консистентное обновление всех компонентов разом, при котором не нарушается целостность UX в проекте. При патч- и минор-релизах со спокойной душой обновляем UI-KIT, если мы доверяем Web Core-команде.
**Недостатки:**
* При мажорном обновлении версии UI-KIT разработчику необходимо потратить немало времени, чтобы проверить все сценарии использования компонентов на своем проекте, а также поддержать новое API использования. Затраченное время при мажорном обновлении можно рассчитать по формуле *кол-во используемых компонентов* \* *кол-во мест использования* и если вы хотите получить новое обновление, в котором может появиться нужный вам компонент.
* Потребителям придется заложить немало времени на обновление.
Второй вариант — каждый компонент UI-KIT как отдельный пакет. В этом случае каждый отдельно взятый компонент версионируется по SemVer.
**Достоинства:**
* При появлении мажорных версий компонентов потребитель может обновлять итеративно.
* После выхода нового компонента нет необходимости обновлять весь UI-KIT в проекте.
**Недостатки:**
* Если потребителю нужно обновить все компоненты в рамках мажорной версии, то придется обновлять их по отдельности. Но в этом случае нам помогает полезная команда `ncu --filter /@ui-kit/ -mu && npm i`, где `@ui-kit` — scope библиотеки компонентов.
Мы выбрали второй вариант, потому что это менее болезненный путь для наших продуктов. В дальнейшем мы планируем выпустить один npm-пакет, который включает в себя все пакеты для тех команд, которым не страшно обновлять всё и сразу.
Мы будем работать в монорепозитории, потому что одни компоненты переиспользуют другие компоненты. Как мы будем управлять версионированием? Мы решили сравнить два наиболее подходящих инструмента для данной задачи: [Lerna](https://github.com/lerna/lerna) и [RushJS](https://rushjs.io/).
Если смотреть на статистику, то Rush — наименее популярная библиотека. Так почему же мы выбрали её? Lerna была очень непредсказуемой и магической, нигде не было нормально описано, как она работает. Процесс релиза был недетерминирован. В Rush это сделано более системно: благодаря change-файлам ты всегда видишь, что поедет в релиз, и библиотека автоматически генерирует читабельные changelog, на основе которых бампит версии так, как тебе нужно. Также Rush работает с Git как надо. В целом эта библиотека показалась более зрелым инструментом, поэтому мы выбрали её.
Вот как мы работаем с Rush:
### Сборка
Для сборки наших компонентов в формате ESM и ESNext с поддержкой tree-shaking мы используем Rollup, и ожидаем релиза Webpack 5, в котором нам [обещают](https://github.com/webpack/changelog-v5#inner-module-tree-shaking) отличную поддержку этой функциональности. Чтобы у нас во всех пакетах была идентичная сборка и мы могли бы ее поддерживать и улучшать, мы можем везде ссылаться на один файл с конфигурацией. Но мы пошли дальше: создали библиотеку, которая этим занимается. Она гибкая, масштабируемая, и её можно использовать в других проектах для своих нужд. В ней уже соблюдены некоторые стандарты нашей компании: browserlist со списком поддерживаемых браузеров, сборка стилей, оптимизации для сборки библиотек и многое другое. Наши компоненты можно использовать в SSR-приложениях, при этом мы расширили поддержку старых версий NodeJS, собирая наши пакеты еще и в CommonJS-формате.
### Стили
В наших компонентах мы используем CSS-модули и Sass как препроцессор.
О чем стараемся не забывать при этом подходе:
**Версионирование стилей**. Так как мы выбрали путь поставки компонентов по отдельности, а не целой библиотеки компонентов, потребитель может обновить только один пакет, не обновляя другие. В этом случае могут возникнуть конфликты между стилями разных версий компонентов. Поэтому при сборке пакетов в настройках для css-modules прописываем `generateScopedName:'[local]-${projectManifest.version}'`, где `projectManifest` — файл package.json. Так у нас решаются все возможные конфликты.
**Переиспользуемые правила**. Стараемся дедуплицировать стили и выносить переиспользуемые правила в пакет styles-framework, который включает в себя цвета, типографику, брейкпоинты, сброс стилей и много полезных миксинов. Другие команды могут его использовать в отрыве от библиотеки компонентов.
Вы можете сказать, что для этих целей отлично подойдет CSS in JS. Не буду спорить, возможно, мы к этому придем.
### Иконки
Многие задаются вопросом, каким способом предоставлять SVG-иконки. Изначально мы попробовали выгружать их на CDN по отдельности, но в этом случае получали перерисовку контента и много потоков скачивания. При использовании спрайта потребитель получает огромную (и тяжеловесную) портянку иконок, из которых он может использовать только несколько. Поэтому мы решили предоставлять React-компонентами, которые содержат в себе инлайново SVG-иконки. При сборке релиза запускается скрипт, который перегоняет SVG-файлы в IconComponent, заменяя все свойства `fill` на `currentColor` и применяя SVG-oптимизацию, поэтому нашим иконкам легко изменить цвет, задав его родителю.
### Кроссбраузерность
Если вы поддерживаете старые версии браузеров и у вас десятки продуктов, вы тоже можете озадачиться такой проблемой, как [полифилы](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%BB%D0%B8%D1%84%D0%B8%D0%BB). Их вы можете встретить везде: в используемой open-source библиотеке, в пакете, разработанном коллегой из другой команды, и, конечно же, в библиотеке компонентов. В итоге получается, что есть много веб-клиентов, собирающихся с полифилами для стабильной работы во всех браузерах.
Некрасиво, верно? Поэтому мы создали сервис полифилов, который не только позволит убрать их из приложений, но и в зависимости от сегмента браузеров отдавать набор тех полифилов, которые необходимы для стабильной работы приложения.
В зависимости от заголовка user-agent сервис отдает тот или иной набор полифилов. Мы выделили три набора для трех сегментов браузеров.
Размеры наборов составляют непосредственно:
В итоге мы получаем:
* Уменьшение размера пакетов в продуктах в современных браузерах (наша целевая аудитория).
* При входе в один из продуктов в браузере клиента кешируется пакет с полифилами, и при переходе из одного нашего продукта в другой мы улучшаем производительность и экономим трафик клиента.
### Внедрение
Чтобы ваша библиотека компонентов удовлетворяла все потребности потребителей, нужно учесть следующие моменты:
* Понятное API взаимодействия с компонентами с хорошей документацией.
* Отсутствие избыточности. Мы все знаем open source-библиотеки, которые устанавливаем ради одного или нескольких сценариев использования, а вместе с этим получаем тонну ненужного кода. Поэтому мы стараемся создавать отдельно компоненты с базовой функциональностью, и на их основе отдельно создаём другие, с дополнительными «хотелками».
* Небольшой вес пакета. Для нас это имеет значение, мы не хотим, чтобы продукты из-за наших компонентов прибавляли в весе.
* Высокая производительность. Под этим мы понимаем гладкость анимации и наименьшее количество перерисовок.
* Хорошая техническая поддержка. Не всё всегда бывает гладко. У кого-то появились вопросы по работе API, у кого-то выявился баг, а у кого-то расхождение с макетами при использования нашего компонента. На эти случаи мы создали тех. поддержку, где наши разработчики в любую секунду помогут в беде.
### Витрина компонентов
Вся полезная информация о наших компонентах будет представлена на витрине компонентов.
Здесь мы можем увидеть список всех наших компонентов, информацию по ним, показать все их состояния и возможности.
Тут мы можем увидеть нашу историю изменений. Эта информация берется из файлов CHANGELOG.md, которые генерируются с помощью Rush.
В секции Readme выводится информация из файла Readme, там можно увидеть информацию об установке компонента и перечисление всех его свойств.
Численность и состав
--------------------
Изначально наша команда состояла из двух frontend (React)-разработчиков, одного дизайнера и одного product owner’а. Сразу хочется пояснить необходимость PO в команде. Человек с этой ролью не только выстраивает процесс и координирует работу команды, но и формирует позиционирование всей дизайн-системы, собирает потребности от других команд для дальнейшего внедрения в UI-KIT и исследует пользовательский опыт с интерфейсами, построенных на наших компонентах, для улучшения UX/UI. С увеличением кодовой базы, численности и масштабности компонентов мы расширились до пяти разработчиков, и не планируем на этом останавливаться.
Заключение
----------
На дизайн системе список активностей команды Web Core не заканчивается. Мы также создаем омниканальные виджеты, такие как навигация по сайту, выбор региона и т.д. Стараемся выработать правила для стандартизации всей кодовой базы в нашей компании. Разрабатываем библиотеки для сбора метрик, авторизации и регистрации. И этот список можно дополнять и дополнять. Я надеюсь, что вы почерпнули что-то новое для себя и своей команды. Очень буду рад обратной связи! Всем спасибо! | https://habr.com/ru/post/520630/ | null | ru | null |
# Разработчик с мозгом груга
Введение
========
это сборник мыслей о разработке программ собранный разработчиком с мозгом груга
разработчик с мозгом груга не очень умный, но разработчик с мозгом груга программирует много лет и научился кое чему, хоть всё равно часто запутывается
разработчик с мозгом груга хочет собрать знания в маленькую, простую и интересную страницу не только для тебя, молодой груг, но и для себя, потому что разработчик с мозгом груга стареет и забывает важные вещи, например что ел на завтрак или надеть штаны
разработчиков с большим мозгом много, некоторым страница не понравится, скривят кислая рожа
Ещё больше-больше *ДУМАЮТ*, что они разработчики с большим мозгом и им она тоже не понравится
(груг раньше думал груг с большим мозгом, но потом всё понял)
это ладно!
груг надеется, что тебе понравится читать и может ты научишься на много-много ошибка груг совершил за длинную жизнь программиста
Вечный враг: сложность
======================
главный охотник на груга это сложность
сложность плохо
скажу снова:
сложность *очень* плохо
теперь *ты* скажи сам:
сложность *очень*, *очень* плохо
если выбрать между сложность и биться с динозавром, груг выбери динозавр: груг хотя бы видеть динозавра
сложность это демон дух, в кодовую базу его пускают добрые но просящие дубину не груги и менеджеры проектов которые не боятся демона духа сложности или иногда не знают про него
один день кодовая база понятная и груг может делать работу, всё хорошо!
другой день невозможно: демон дух сложности попал в код и очень опасная ситуация!
груг не может видеть демона сложности, но груг чувствует что он в кодовой базе
демон дух сложности дразнит сделай изменение здесь сломай в другом месте не понять где и почему!?! смеётся ха ха смешно очень
груг любит программировать, а не собирать блестящие камни как старший советчик груга
дубина не ломает демона духа сложности, а плохая идея бьёт дубиной разработчика впустившего духа: иногда это сам груг!
жалко, часто это сам груг
поэтому груг говорит и говорит часто: сложность *очень*, *очень* плохо
Говорить «нет»
--------------
лучшее оружие против демона духа сложности это заклинание «нет»
«нет груг не пишет эту фичу»
«нет груг не делает эту абстрацию»
«нет груг не моет тело каждый день и не пьёт меньше чёрной жижи для мыслей хватит повторять»
помни это хороший совет для разработчика но плохой для карьеры: «да» это заклинание чтобы получить больше блестящих камней и тебя назначить вождём большого племени разработчиков
грустно но правда: научись «да» потом обвиняй других гругов когда не получится, лучший совет для карьеры
но груг должен быть настоящий груг, а «нет» заклинание груга. Сначала сложно говорить, особенно если добрый груг и не любит разочаровывать людей (много таких гругов!) но потом проще хотя куча блестящих камней будет не такая большая
это ладно: разве гругу нужно много блестящего камня?
Говорить «ладно»
----------------
иногда компромисс нужен или нет блестящего камня, то есть нет мяса динозавра, нехорошо, жена твердит гругу маленьким гругам нужно крыша, еда, так далее, не хочет пятнадцатый раз слышать груг сердится на демона духа сложности
в этой ситуации груг рекомендует «ладно»
«ладно, груг пишет эту фичу»
потом груг долго думает о [решении 80/20](https://en.wikipedia.org/wiki/Pareto_principle) задачи и пишет его.
решение 80/20 значит решение «80 что нужно в 20 код»: может быть не все звенелки которые хочет менеджер проекта, может быть немного кривой код, но работает и делает почти что нужно, и почти всегда отгоняет демона духа сложности
может иногда лучше не говорить менеджеру проекта и делать 80/20. проще просить прощение чем разрешение, иногда менеджер проекта как золотая рыбка устаёт от работы с много гругов. часто забывает что должна делать фича, берёт другую работу или увольняется или его увольняют: груг видел много таких случаев
но обычно в интересах менеджера проекта чтобы груг не очень огорчался такому подходу
Факторизация кода
-----------------
следующая стратегия очень сложнее: правильно разбивать кодовую базу (красивое другое слово: «правильно факторизировать код»)
тут сложно давать общий совет: каждая система разная. но одно груг знает: не факторизуй приложение слишком рано!
в начале всё в проекте очень абстрактное и как вода: очень мало веток за которые может хвататься мозг груга. постепенно разработай «форму» системы и узнай что вообще происходит. груг пытается не факторизировать проект рано, рано или поздно в кодовой базе появляются линии для разреза
хорошая линия для разреза имеет узкий интерфейс с остальной системой: маленькое количество функций или абстракций прячут демона сложности внутрь, как будто он попался в кристалл
гругу нравится когда демона сложности ловят в кристалл. лучше некуда поймать смертельного врага!
груг пытается терпеливо ждать появления в коде линий для разреза и медленно рефакторит, а кодовая база постепенно с опытом принимает форму. тут нет точных правил: груг узнаёт линию разреза когда видит линию разреза, учись смотреть и терпению
иногда груг торопится и делает неправильную абстракцию, поэтому груг лучше подождёт больше
разработчики с большим мозгом часто это не любят и изобретают много абстракций с начала проекта
груг хочет схватить дубину и орать «большой мозг не поддерживает код! большой мозг уходит в другой комитет по архитектуре а груг возись с кодом!»
но груг учится управлять чувствами, основное различие груга и животного
вместо этого груг пытается снизить опасность разработчика с большим мозгом в начале проекта дав ему что-нибудь наподобие UML-диаграммы (не вредит коду, наверно, её всё равно выбросят) или потребовав сделать завтра рабочее демо
рабочее демо очень хорошая хитрость: заставляет большой мозг сделать то, что можно обсудить и посмотреть на код, помогает большому мозгу быстрее увидеть реальность
помни! у большого мозга большой мозг! его нужно ограничивать только для добра а не помогать демону духу сложности, такое много раз бывало
(лучший мозг груга может гнать стадо большого мозга в нужном направлении и делать много кристаллов ловушек для демона сложности, большая куча блестящих камней ждёт такого груга!)
иногда называй демо «прототипом»: менеджеру проекта так приятнее
груг говорит: делай прототип в начале разработки, *особенно* если много больших мозгов
Тестирование
============
груг любит и ненавидит тест: тест экономит гругу много бесчисленного времени и груг любит и уважает тест
жалко что есть много шаманов тестов. некоторые шаманы тестов делают из тестов идолов, требуют «делай тесты» ещё когда груг не начал писать код или когда груг ещё не знает хорошо область применения!
как груг тестирует если груг ещё не понимает область применения?
«не бойся: тесты покажут что тебе нужно делать»
груг снова сдержал груга медленно берущего дубину, но груг остаётся спокойный
груг предпочитает писать большинство тестов после этапа прототипа, когда код начинает становиться чётче
но хорошо запомни: тут груг должен быть очень дисциплинированный!
груг легко может пойти дальше и не писать тесты потому что «всё работает на машине груга»!
оно очень, очень плохо: нет гарантии работы на другой машине, нет гарантии работы на машине груга в будущем, много раз
шаман тестов правильно говорит о важности теста, даже если шаман тестов за всю жизнь не сделал ничего полезного готового и только всегда говорит о тесте, заслуживает дубины, но сердце его доброе
ещё шаман тестов часто говорит про юнит-тесты, но груг не думает, что они очень полезные. опыт груга говорит, что идеальные тесты это не юнит-тест и не сквозной тест, а промежуточный тест
[юнит-тесты](https://en.wikipedia.org/wiki/Unit_testing) хорошо, ладно, но ломаются после изменения реализации (совсем как api!) и делают сложным рефакторинг, к тому же многие баги всё равно из-за взаимодействия с другим кодом. часто приходится выбрасывать, когда меняется код.
груг пишет юнит-тест в основном в начале проекта, помогает развитию, но не привыкай к ним и не ожидай долговременную пользу
[сквозные тесты](https://smartbear.com/solutions/end-to-end-testing/) хорошие, показывают работу всей системы, но! сложно понимать когда ломаются и очень часто злят груга, иногда груг просто перестаёт обращать на них внимание потому что «ой, всегда ломаются» — очень плохо!
груг слышал, шаман называет промежуточные тесты [интеграционным тестированием](https://en.wikipedia.org/wiki/Integration_testing), иногда с кислой рожей. но груг считает, что интеграционный тест лучший по мнению груга: достаточно высокий уровень, чтобы хорошо тестировать правильность системы, достаточно низкий уровень, чтобы с хорошим отладчиком легко видеть что сломалось
груг предпочитает немного юнит-тестов, особенно в начале, но тест не 100% всего кода и точно не «сначала тест». «тест по ходу дела» вполне подходит гругу, особенно пока груг разбирается в системе
груг пишет самые свирепые интеграционные тесты когда появляются точки разреза и система стабилизированная! api линии разреза обычно стабильнее реализации и интеграционный тест остаётся полезный много длинное время и легко отлаживать
ещё полезный хорошо проверяемый набор сквозных тестов чтобы работал постоянно. главное делай важный сквозной тест для самых общих фич UI и нескольких самых важных пограничных случаев, но не очень много иначе становится невозможно поддерживать и потом бросают
оно идеальный набор теста для груга
ты можешь не любить, но это лучшее тестирование груга
ещё гругу не нравится [mock-объект](https://en.wikipedia.org/wiki/Mock_object) в тесте, нужен только в крайнем случае (редко/никогда) и при грубом макетировании (линий разреза/систем), только так
одно исключение для нелюбимого гругом «сначала тестируй»: когда нашёл баг. груг всегда пытается сначала воссоздать баг при помощи регрессионного теста, *потом* устранять баг, только такой способ почему-то работает лучше
Agile
=====
груг думает agile не плохой и не хороший
не худший способ организации разработки, может лучше других, которые груг считает хорошими
но опасный шаман agile! много, много блестящих камней потеряно из-за шамана agile!
agile-проект развалился, шаман agile говорит «вы неправильно делаете agile!» груг считает, это ужасно удобно для шамана agile: можно просить больше блестящих камней улучшать agile обучать молодых гругов agile, опасность!
груг хочет взять дубину когда слишком много говорят про agile, но всегда остаётся спокойный
чтобы успешно делать программы, лучше писать прототипы, инструменты и нанимать хороших гругов: agile-процесс ладно и помогает кому-то, но иногда ущерб воспринимают слишком серьёзно. никогда нет серебряной дубины, что бы ни говорил шаман agile (опасность!)
Рефакторинг
===========
рефакторинг хорошее дело и часто хорошая идея, особенно попозже, когда код уже сформировался
однако много раз в карьере груга «рефакторинг» выходил из под контроля и давал больше вреда, чем добра
груг не знает, почему один рефакторинг делается хорошо, другой проваливается, но груг заметил, чем больше рефакторинг, тем больше опасность провала
поэтому груг пытается делать относительно небольшой рефакторинг и «не отплывать слишком далеко от берега» при рефакторинге. в идеале система работает постоянно и каждый этап заканчивается до начала другого.
здесь спасают сквозные тесты, но очень сложно понять почему ломаются… такая жизнь при рефакторинге.
ещё груг заметил, что добавление слишком много абстракции приводит к провалу рефакторинга и системы. хороший пример внедрение [J2EE](https://www.webopedia.com/definitions/j2ee/), много больших мозгов сидело и придумало слишком много абстракции, ничего хорошего не вышло и навредило многим проектам
ещё хороший пример когда компания, где работает груг, внедрила [OSGi](https://www.techtarget.com/searchnetworking/definition/OSGi), чтобы управлять/ловить демона духа сложности в кодовой базе. OSGi не только не помог, но и сделал демона сложности намного сильнее! пришлось потратить много человеко-лет лучших разработчиков для переделки! больше духа сложности и теперь фичи невозможно реализовать! очень плохо!
Забор Честертона
================
мудрый шаман груг [честертон](https://en.wikipedia.org/wiki/G._K._Chesterton) однажды сказал
> Такое может происходить в случае какой-то установки или закона; давайте ради простоты представим поставленные на дороге забор или ограду. Современный реформатор беспечно подойдёт к ним и скажет: «Я не вижу в них пользы; давайте снесём их». На это более умный реформатор ответит: «Если вы не видите в них пользы, я точно не позволю их снести. Отойдите и подумайте. Когда вы вернётесь и скажете мне, что увидели, в чём их польза, то я, возможно, позволю их снести».
многие старый груг хорошо выучили этот урок не начинать ломать код не подумав, даже если он страшный
груг понимает все программисты в чём-то платонисты: хотят в коде слышать идеальную музыку сфер. но здесь опасность, часто-часто мир уродливый и некрасивый, такой и код должен быть
смирение не часто есть у большого мозга или кто считает себя большой мозг и даже у груга, но груг часто знает «гругу не нравится, груг надо исправить» приводит к много часов мучений и система может стать не лучше а хуже
в начале карьеры груг часто нападает на кодовую базу дико размахивая дубиной и ломая всё, научись это плохо
груг не говорит не улучшать системы никогда, это глупо, но советует потратить время понять систему сначала, особенно большую систему и уважать работающий сегодня код пусть не идеальный
здесь часть тесты хорошо показывают почему забор нельзя ломать!
Микросервисы
============
груг не понимает зачем большой мозг берёт самую сложную задачу, правильно факторизует систему и добавляет сетевой вызов
очень непонятно для груга
Инструменты
===========
груг любит инструмент. инструмент и управление чувствами отличает груга от динозавров! инструмент позволяет мозгу груга делать код который без него не может быть, думает за груга, всегда хороший помощник! в новом месте груг всегда тратит время на изучения окружающих инструментов для максимизации продуктивности: изучил инструменты две недели часто делает разработку дважды быстрее и часто заставляет просить других разработчиков о помощи, нет документации
дополнение кода в IDE позволяет гругу не запоминать все API очень важно!
программирование на java почти невозможно без этого для груга!
из-за этого груг начинает задумываться
хороший отладчик ценен как много блестящих камней, а на самом деле даже больше: когда нашёл баг груг часто хочет отдать все блестящие камни и может немного детей за хороший отладчик
груг всегда советует новому программисту изучать отладчик очень хорошо, фичи вроде условных контрольных точек, вычисления выражений и другое
груг говорит никогда не переставай улучшать инструменты
Системы типов
=============
груг очень любит системы типов упрощают программирование. для груга системы типов самая польза когда груг нажимает точку на клавиатуре и магией открывается список что может сделать груг. это 90% пользы от системы типов для груга
но здесь бойся больших мозгов!
некоторые большой мозг думают системами типов и говорят леммами, могут быть очень опасные!
большой мозг шаман систем типов часто говорит главное в системе типов корректность типов, но груг заметил что некоторые большой мозг шаман систем типов не часто выпускает готовый код. груг думает наверно корректный код это который никогда не выпустят, но груг понимает корректный код не совсем так
груг говорит главная польза системы типов магический инструмент показывает что можно делать и дополнение кода, корректность тоже хорошо но не так как помогательный инструмент и не так, как думает большой мозг
ещё бойся: опасная абстракция слишком высокая, а код типа большого мозга становится астральная проекция платонической обобщённой модели вычислений тьюринга в кодовой базе. груг запутан и согласный какой-то уровень очень изящный но с ним очень сложно делать реальные задачи например записать количество дубин для компании «Груг и сыновья»
дженерики здесь особенно опасные, груг старается ограничить дженерики классами-контейнерами чаще всего так самая большая польза
соблазн очень больших дженериков это ловушка! демон дух сложности любит эту ловушку! берегись!
всегда самая польза от системы типов такая: нажимай точку смотри что груг может сделать, не забывай!
Сложность выражений
===================
раньше груг любил сокращать количество строк кода. писал такой код:
```
if(contact && !contact.isActive() && (contact.inGroup(FAMILY) || contact.inGroup(FRIENDS))) {
// ...
}
```
потом груг понял это трудно отладка, научился надо писать так:
```
if(contact) {
var contactIsInactive = !contact.isActive();
var contactIsFamilyOrFriends = contact.inGroup(FAMILY) || contact.inGroup(FRIENDS);
if(contactIsInactive && contactIsFamilyOrFriends) {
// ...
}
}
```
груг слышит крики молодых гругов — ужас много строка кода дурацкая переменная, груг готов защищаться дубиной
начинается бойня дубинами другие разработчики нападают и груг кричит: «проще отладка! вижу результат каждого выражения и имя хорошее! проще понимаю условное выражение! ПРОЩЕ ОТЛАДКА!»
отладка точно проще и когда бойня дубинами закончилась успокоились и молодой груг подумал и понял груг прав
груг всё равно ловит себя пишет код как первый пример и часто жалеет, поэтому груг не осуждает молодого груга
Замыкания
=========
груг любит замыкания где полезно, а полезно обычно абстрагирование операции с коллекцией объектов
груг предупреждает замыкания как соль, системы типов и дженерики: немного хорошо, но легко портит вещи если много и даёт рано инфаркт
разработчики javascript называют особого демона духа сложности в javascript «callback hell», потому что очень много замыкание используют библиотеки javascript. очень печально но груг правда считает разработчики javascript получают что заслуживают
Логирование
===========
груг большой любитель логирования и говорит всем давай логируй, особенно в облаке. некоторые не груги говорят логирование дорогое и не очень важное. груг так не думает больше
смешная история: идол груга [роб пайк](https://en.wikipedia.org/wiki/Rob_Pike) работает в google над логированием, груг решил: «если роб пайк работает над логированием, зачем гругу это делать?!?», не стал заниматься. оказывается логирование *очень* важное для google, поэтому конечно над ним работает лучший программист, груг!
не будь таким мозгом груга, теперь гораздо меньше блестящих камней!
ладно, груг всё равно нашёл хорошую компанию, а роб пайк одевается
[всё страннее](https://www.youtube.com/watch?v=KINIAgRpkDA), так что всё удачно, но смысл не меняется: логирование очень важное!
советы груга про логирование:
* логируй все основные логические ветвления в коде (if/for)
* если «запрос» распространяется на несколько машина в облачной инфраструктуре, добавь на все ID запроса, чтобы логи можно группировать
* если можно сделай логи динамически управляемыми, чтобы груг мог включать/отключать когда нужна отладка проблем (много!)
* если можно сделай уровень логирования для каждого пользователя, чтобы можно отлаживать проблему конкретного пользователя
два последних пункта особенно удобная дубина очень часто когда охотишься на баги в продакшен-системах
жаль библиотеки логов часто очень сложные (java, [зачем так?](https://stackify.com/logging-java/)), но надо вложить усилия сделать инфраструктуру логирования правильно — опыт груга говорит очень сильно полезно потом
груг думает логирование надо больше учить в вузах
Конкурентность
==============
груг как все разработчик в своём уме, боится конкурентность
груг старается как можно больше использовать простые модели конкурентности, например, обработчики stateless-веб-запросов и простые очереди воркеров удалённых задач, где задачи не взаимозависимые и простой api
для веба подходит [оптимистичная конкурентность](https://en.wikipedia.org/wiki/Optimistic_concurrency_control)
иногда груг пользуется [локальной переменной потоков](https://en.wikipedia.org/wiki/Thread-local_storage), особенно когда пишет код фрейворков
в некоторых языках есть хорошая структура конкуретных данных, например [ConcurrentHashMap](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ConcurrentHashMap.html) в java, но всё равно чтобы сделать правильно нужна аккуратная работа груга
груг никогда не пользовался [erlang](https://en.wikipedia.org/wiki/Erlang_(programming_language)), слышал хорошие слова, но гругу язык выглядит странный, простите
API
===
груг любит хорошие api. хорошие api не требуют чтобы груг слишком много думал
жалко многие api очень плохие, заставляют груга много думать. причин много, вот две:
* создатели API думают о реализации или области применения API, а не об использовании API
* создатели API думают слишком абстрактно и как большой мозг
обычно гругу не важно подробности api: нужно записать файл или отсортировать список, просто хочет вызвать `write()` или `sort()`
но разработчики api большой мозг говорят:
«не торопись, груг! открываешь этот *файл для записи*? ты определил *Comparator* для сортировки?»
груг снова хватает свою руку которая тянется к дубине
пока ему не важно это всё, просто хочет сортировать и записывать файлы, мистер большой мозг!
груг понимает дизайнер api большой мозг в чём-то прав и *иногда* это важно, но часто нет. разработчики api большой мозг лучше если проектировать для простых случаев с простым api, делать сложные случаи возможными с более сложным api
груг называет это «многослойный» api: два или три разных api с разным уровнем сложности для разных нужд груга
ещё если объектно-ориентированный, добавь api на элемент, а не в другое место. хуже всех в этом java!
груг хочет фильтровать список на java
«Ты преобразовал его в поток?»
ладно, груг преобразовал в поток
«Хорошо, теперь можно фильтровать»
хорошо, но теперь нужно вернуть список! а есть поток!
«Ты собрал свой поток в список?»
что?
«Определи Collector super T, A, R, чтобы собрать поток в список»
груг клянётся могилой предка будет бить дубиной каждого в комнате, но считает до двух и остаётся спокойный
добавь обычную вещь типа `filter()` для списка и пусть возвращает список, слушай меня разработчик java api большой мозг!
никому не нужен «поток» и никто не слышал про «поток», не сетевой api, все груги java используют списки мистер большой мозг!
Фронтенд-разработка
===================
некоторые не груги, имея дело с веб-разработкой говорят:
«Знаю, я разобью кодовую базу на фронтенд и бэкенд и использую новую крутую SPA-библиотеку, общающуюся с бэкендом GraphQL JSON API через HTTP (это забавно, потому что я не передаю гипертекст)»
теперь у тебя есть две норы для демона духа сложности
хуже: демон дух сложности фронтенда стал ещё сильнее и управляет всей отраслью фронтенда, как видит груг
бэкенд-разработчики стараются не усложнять и могут работать хорошо, но фронтенд-разработчики делают очень сложно очень быстро и добавляют много кода, демона духа сложности
даже когда веб-сайту нужно просто положить форму в базу данных или простой сайт брошюра!
сейчас все так делают!
груг не знает зачем может так говорят facebook и google, но для груга это не очень хорошая причина
гругу не нравятся большие сложные фронтенд библиотеки, которые все используют
груг делает [htmx](https://htmx.org) и [hyperscript](https://hyperscript.org) чтобы без них
низкая сложность, простой HTML, без много javascript, это отпугивает демона сложности
может они тебе подойдут, но не для карьеры, простите
react лучше для карьеры и некоторых приложений, но ты становишься служителем демона сложности, хочешь или нет, такая жизнь фронтенда
Мода
====
груг заметил много моды в разработке, особенно сегодня в фронтенде
бэкенд лучше скучнее наверно все плохие идеи уже проверены (некоторые пытаются повторить!)
в фронтенд разработке продолжают пробовать все плохие идеи поэтому много меняется и сложно понимать
груг советует относиться ко всем революционным идеям скептик: большие мозги уже давно работают с компьютерами, большинство идей проверено хотя бы раз
груг не говорит нельзя научиться новому или нет хороших идей, но много время тратят на повторное использование плохих идей, сила демона духа сложности появляется когда без мысли вставляют новую идею в кодовую базу
Страх выглядеть глупо
=====================
помни! очень хорошо если груг сениор может сказать всем: «хммм, это слишком сложно для груга!»
многие разработчики боятся выглядеть тупой, груг раньше тоже боятся, но груг научился бороться: очень важный груг сениор говорит «это слишком сложно и запутанно для меня»
так груги джуниоры тоже могут признаться слишком сложно и плохо понимают, часто так бывает! страх выглядеть тупой главный источник силы демона сложности, особенно у молодых гругов
убрать силу страха очень хорошо для сениор груга
но помни: надо делать мыслительное лицо и казаться большим мозгом. будь готов большой мозг или чаще *думает* он большой мозг сарказм говорит про груга
сильный будь! не надо страх!
тут полезна иногда дубина, но чаще чувство юмора, особенно очень полезен последний проваленный проект большого мозга, соберись и оставайся спокойный
Синдром самозванца
==================
груг замечает много таких чувств самозванца в разработке
груг всегда одно из двух состояний: груг хозяин вся равнина, носит дубину кода как тор ИЛИ груг не понимает что происходит
больше времени груг второе состояние, но нужно его прятать
груг делает сильные программные обеспечения и [успех в open source](https://star-history.com/#bigskysoftware/htmx&bigskysoftware/_hyperscript&Date), но сам груг часто не понимает вообще что происходит! очень часто! груг всё ещё боится сделать ошибку поломать код всей команды и разочаровать других гругов, самозванец!
это может само программирование такое для большинства гругов и лучше сказать тут ладно: никто не самозванец, если все самозванец
молодой груг кто дочитал досюда наверно будет успех в карьере программ, даже если огорчения и беспокойства будут всегда, прости
Почитать
========
гругу нравятся эти:
* [Worse is Better](https://www.dreamsongs.com/WorseIsBetter.html)
* [Worse is Better is Worse](https://www.dreamsongs.com/Files/worse-is-worse.pdf)
* [Is Worse Really Better?](https://www.dreamsongs.com/Files/IsWorseReallyBetter.pdf)
* [A Philosophy of Software Design](https://www.goodreads.com/en/book/show/39996759-a-philosophy-of-software-design)
Вывод
=====
*сам* скажи: сложность *очень*, *очень* плохо | https://habr.com/ru/post/673640/ | null | ru | null |
# Как мы Select2 в хелпер заворачивали
Думаю, многие знакомы с [Select2](http://ivaynberg.github.io/select2/). Всё в нём замечательно: и элементы красивые, и кастомизации вагон, и c ajax работает и ещё много много полезного делать умеет. Только проблема одна: инициализация довольно громоздкая (js писать надо, экшн иметь для *ajax*-овой подгрузки результатов и так далее). Это было не шибко удобно и решили мы сделать свою надстройку для *Select2*, в которой и js писать не надо, да и за пределы вьюхи уходить почти не придётся. О том как мы это делали и что получилось читайте под катом.
К чему стремились?
------------------
Все знают поведение хелперов из *ActionView::Helpers::FormTagHelper*. Например *select\_tag*:
```
select_tag "people", options_from_collection_for_select(@people, "id", "name")
```
Хочется чтобы и с *Select2* работать было так же просто. Причём с любой вариацией *Select2*: будь то статическая замена обычного *select*, *ajax* вариант или мультиселект.
Что получилось? Получилось примерно следующее:
```
= select2_ajax_tag :my_select2_name,
{class_name: :my_model_name, text_column: :name, id_column: :id},
my_init_value_id,
placeholder: 'Fill me now!'
```
Это самый простой вызов хелпера. Не надо никаких дополнительных телодвижений. Как результат получим селект с динамической загрузкой вариантов из модели *MyModelName*.
Конечно же, это самый простой способ использования. Если появится желание делать сложные выборки, выдавать разные результаты в зависимости от других параметров на странице, кастомизировать отображение вариантов в селекте и тд, то не беда, всё это можно сделать, но прийдётся добавить немного *Ruby*.
Примеры в студию!
-----------------
Для тех, кто уже хочет пощупать руками, а так же тем, кто воспринимает исходники лучше, нежели неспешное словесное описание, даю [ссылку](https://github.com/Loriowar/auto_select2_tag_example) на RoR проект с примером использования.
Альтернативы
------------
В своё время мы их не нашли, поэтому и случилось неспешное изобретение сего гема. Однако, учитывая специфику ресурса и мощь комментариев, я уверен, что кто-нибудь подскажет аналог который мы не заметили. Так что буду рад, если укажете на альтернативу.
Что это вообще такое?
---------------------
Это два гема [AutoSelect2](https://github.com/Loriowar/auto_select2) и [AutoSelect2Tag](https://github.com/Loriowar/auto_select2_tag) идею которых предложил [Tab10id](http://habrahabr.ru/users/tab10id/). Оба гема основываются на [select2-rails](https://github.com/argerim/select2-rails) и позволяют создавать Select2 элементы без тяжёлых дум о js-инициализации и о прочих накладных расходах.
Как этим пользоваться?
----------------------
Подробные *Readme* есть у каждого из гемов, но они, как водится, на английском. Поэтому расскажу по-русски о том как правильно поставить гемы, что они требуют для работы и как в итоге пользоваться их функционалом.
### Установка
Перво-на-перво нужно сказать, что если у Вас отключён asset pipeline установка становится довольно нетривиальной и выходит за рамки этой статьи, так что будем считать что с pipeline у Вас всё в порядке.
Теперь по пунктам:
1. нужно установить [select2-rails](https://github.com/argerim/select2-rails#install-select2-rails-gem), прописать его скрипты в *application.js* и стили в *application.css* (или что там у Вас вместо них?)
2. установить [AutoSelect2](https://github.com/Loriowar/auto_select2#installation) и прописать его скрипты в *application.js* (или добавить [хелперы](https://github.com/Loriowar/auto_select2#javascript-include-variants) в нужные партиалы)
3. проверить, что в проекте нет контроллера с именем *Select2AutocompletesController* и роутов на подобие
```
get 'select2_autocompletes/:class_name'
```
4. подготовить папку *'app/select2\_search\_adapter'* для своих *SearchAdapter*
5. установить гем [AutoSelect2Tag](https://github.com/Loriowar/auto_select2_tag#installation)
### Использование статического Select2
После сих дейсвий можно пользоваться хелпером для статического селекта:
```
= select2_tag :select2_name,
my_options_for_select2(my_init_value),
placeholder: 'Fill me!',
include_blank: true,
select2_options: {width: 'auto'}
```
По сути, метод является обёрткой обычного [select\_tag](http://apidock.com/rails/ActionView/Helpers/FormTagHelper/select_tag). Он добавляет нужные классы для инициализации *Select2* и пробрасывает [параметры конструктора](http://ivaynberg.github.io/select2/).
### Использование ajax Select2
Прямо «из коробки» доступен самый простой вызов хелпера:
```
= select2_ajax_tag :my_select2_name,
{class_name: :my_model_name, text_column: :name, id_column: :id},
my_init_value_id,
placeholder: 'Fill me now!'
```
Здесь второй параметр хелпера должен говорить сам за себя.
Коли же хочется более сложных конструкций в селекте, то прийдётся писать свой *SearchAdapter*. Что это такое? Это класс, который постранично выдаёт хэши с опциями для селекта и отвечает за инициализирующее значение, если оно присутствует. Класс этот используется в контроллере *Select2AutocompletesController*, а его название указывается во втором параметра *select2\_ajax\_tag* (см. пример ниже). Вот набор требований для *SearchAdapter*:
* файлы с классами должны располагаться в *'app/select2\_search\_adapter'* (по аналогии с *inputs* у [formtastic](https://github.com/justinfrench/formtastic)); справедливости ради стоит сказать, что располагаться они могут и в любой другой autoload директории, но вышеописанный способ кажется самым оптимальным
* имена классов должны оканчиваться на *SearchAdapter*
* *SearchAdapter* должен наследоваться от *AutoSelect2::Select2SearchAdapter::Base*
* класс должен реализовывать метод *search\_default* (подробности см. ниже)
Чтобы долго не описывать требования к *search\_default* приведу пример минималистичного *SearchAdapter*:
```
class SystemRoleSearchAdapter < AutoSelect2::Select2SearchAdapter::Base
class << self
def search_default(term, page, options)
if options[:init].nil?
roles = default_finder(SystemRole, term, page: page)
count = default_count(SystemRole, term)
{
items: roles.map do |role|
{ text: role.name, id: role.id.to_s } # здесь ещё можно добавить 'class_name'
end,
total: count
}
else
get_init_values(SystemRole, options[:item_ids])
end
end
end
end
```
Как видно из примера, если в *options* отсутствует ключ :init, то *search\_default* должен возвращать хэш вида:
```
{ items:
[
{ text: 'first element', id: 'first_id' },
{ text: 'second element', id: 'second_id' }
],
total: count }
```
Если же :init присутствует, то функция должна вернуть:
```
{text: 'displayed text', id: 'id_of_initial_element'}
```
После определения такого класса можно использовать ajax select2 следующим образом:
```
= select2_ajax_tag :my_select2_name,
:system_role,
init_value,
additional_options
```
И всё. Синтаксис максимально приближен к *select\_tag* и использовать можно в любом месте приложения.
### Использование multi ajax Select2
Здесь всё аналогично предыдему пункту с *ajax select2* с той лишь разницей, что надо подключить скрипт *multi\_ajax\_select2\_value\_parser.js* и добавить в хэш *select2\_options: {multiple: true}*:
```
= select2_ajax_tag :multi_countries_select2,
:country,
'',
class: 'is-multiple',
select2_options: {multiple: true}
```
Где-то здесь у разработчиков, знакомых с *Select2*, должен появиться вопрос: а скрипт зачем? Отвечаю: скрипт реализует сериализацию вариантов селекта в виде массива, а не в виде строки с вариантами через запятую. Автор *Select2* обещал сделать то же самое в следующей мажорной версии, но ждать-то не охото.
Дополнительные возможности
--------------------------
Большинство из них описано в [примере](https://github.com/Loriowar/auto_select2_tag_example). Для тех, кому лень запускать проект, да и просто для полноты картины, сделаю их краткий обзор.
### Расширение search\_default
Допустим Вы создали свой *SearchAdapter* и реализовали в нём *search\_default*. Пусть этот адаптер будет для модели User. Всё хорошо, но однажды потребовалось создать аналогичный селект, но чтобы в вариантах были только активные пользователи. Дабы не создавать новый класс для той же самой сущности можно добавить метод *search\_active* в ранее созданный *UserSearchAdapter* и указать этот метод при инициализации *Select2*:
```
= select2_ajax_tag :active_user,
:user,
'',
search_method: :active # здесь указываем какой search_ метод хотим использовать
```
### Зависимые выборки
Ещё один случай: реализовать 2 (или более) селектов, варианты в которых зависят друг от друга. Например каскадный выбор страны и города (пример из [auto\_select2\_tag\_example](https://github.com/Loriowar/auto_select2_tag_example/blob/master/app/views/home/index.html.haml)). Если выбрали страну, то выбрать город можно только внутри этой страны и наоборот. Как это неудобно делается со статическими селектами и так понятно. А вот как это делается с помощью *select2\_ajax\_tag*: во-первых, нужно присвоить всем зависимым элементам какой-либо класс, например *dependent-input*; во-вторых, указать это класс в *additional\_ajax\_data*:
```
= select2_ajax_tag :country_id,
:country,
'',
placeholder: 'Select country',
class: 'dependent-input',
select2_options: {additional_ajax_data: {selector: '.dependent-input'}}
= select2_ajax_tag :city_id,
:city,
'',
placeholder: 'Select city',
class: 'dependent-input',
select2_options: {additional_ajax_data: {selector: '.dependent-input'}}
```
После этого, при отправке ajax-запроса на получение вариантов, селект будет искать все элементы с классом *dependent-input*, исключать из них самого себя, преобразовывать оставшиеся в json, где ключ — это name-атрибут элемента, а значение — value-атрибут, и отправлять полученный json вместе с запросом. Контроллер же пробросит все эти параметры в *SearchAdapter* и в методе *search\_default* (или любом другом *search\_*) в параметре *options* будут присутствовать значения с формы. Далее их можно использовать любым удобным способом и отдавать только те варианты, которые соответствуют требованиям.
### Метод to\_select2
Можно не указывать опции *text\_column* и *id\_column*, если у модели присутствует метод *to\_select2*. В этом случае он будет автоматически вызываться для получения опций при генерации *json*. Если же нужно использовать метод отличный от *to\_select2*, то можно передать параметр *hash\_method*:
```
= select2_ajax_tag :default_country_id,
{class_name: :country, hash_method: :to_select2_alternate},
Country.first.id
```
Выгода очевидна. Без создания *SearchAdapter* можно передавать более сложные опции в селект.
Несколько слов про инициализацию
--------------------------------
Элементы автоматически инициализируются после загрузки страницы (то есть в *$(document).ready()*), после *ajax*-запросов (по эвенту *ajaxSuccess*) и по событию *cocoon:after-insert* из [cocoon](https://github.com/nathanvda/cocoon). Нет нужды переживать за повторную инициализацию, дважды ничего не вызывается и проблем нет. Если же по каким-либо причинам всё-таки потребовалась ручная инициализация, то нужно вызвать *initAutoAjaxSelect2()* и/или *initAutoStaticSelect2()*.
Планы на будущее
----------------
Так как гемы вырасли из *Redmine* проекта, то хочется сделать *pluging* к нему. Конечно же тут сразу встаёт вопрос о pipeline, который в *Redmine* не работает в принципе и для запуска которого нужно основательно [постараться](https://github.com/Tab10id/redmine_plugin_asset_pipeline). Далее хочется подружиться с [formtastic](https://github.com/justinfrench/formtastic).
За сим все
----------
Спасибо что дочитали до конца. Про опечатки и неточности пишите в лс, буду рад исправить. Прочие вопросы/замечания/предложения/возмущения пишите в комментах, будет интересно. | https://habr.com/ru/post/244553/ | null | ru | null |
# Swift vs. Kotlin. Отличия важны
*Этот пост является вольным переводом статьи [Swift vs. Kotlin — the differences that matter](https://blog.indoorway.com/swift-v-kotlin-the-differences-that-matter-50b2d393f526) by [Krzysztof Turek](https://blog.indoorway.com/@kturek)*
**Вы наверняка видели это сравнение Swift и Kotlin: <http://nilhcem.com/swift-is-like-kotlin/>. Довольно интересное, правда? Я согласен, что в этих языках много схожего, но в этой статье я обращу внимание на некоторые аспекты, которые их все-таки разнят.**
Я занимаюсь Android-разработкой с 2013 и большую часть времени разрабатывал приложения на Java. Недавно же у меня появилась возможность попробовать iOS и Swift. Я был впечатлен тем, что на Swift получается писать очень клевый код. Если вы приложите усилия — ваш код будет похож на поэму.
Через семь месяцев я вернулся к Android. Но вместо Java начал кодить на Kotlin. Google объявил на Google IO 2017, что Kotlin теперь официальный язык для Android. И я решил учить его. Мне не понадобилось много времени, чтобы заметить сходство между Kotlin и Swift. Но я бы не сказал, что они очень похожи. Ниже я покажу отличия между ними. Я не буду описывать все, а только те, которые мне интересны. Рассмотрим примеры.
Структуры vs. Data-классы. Значения и ссылки
============================================
Структуры и Data-классы — упрощенные версии классов. Они похожи в использовании, выглядит это так
Kotlin:
```
data class Foo(var data: Int)
```
Swift:
```
struct Foo {
var data: Int
}
```
Но класс по прежнему остается классом. Этот тип передается по ссылке. А вот структура — по значению. "И что?" спросите вы. Я объясню на примере.
Давайте создадим наш data-класс в Kotlin и структуру в Swift, а затем сравним результаты.
Kotlin:
```
var foo1 = Foo(2)
var foo2 = foo1
foo1.data = 4
```
Swift:
```
var foo1 = Foo(data: 2)
var foo2 = foo1
foo1.data = 4
```
Чему равно **data** для **foo2** в обоих случаях? Ответ 4 для data-класса Kotlin и 2 для структуры на Swift.
Результаты отличаются, потому что *var foo2 = foo1* в Swift создает копию экземпляра структуры (детальнее [тут](https://developer.apple.com/swift/blog/?id=10)), а в Kotlin — еще одну ссылку на тот же объект ([детальнее тут](https://stackoverflow.com/questions/40480/is-java-pass-by-reference-or-pass-by-value/40523#40523))
Если вы работаете с Java, вы вероятно знакомы с паттерном *Defensive Copy*. Если нет — наверстаем упущенное. [Здесь](http://www.javapractices.com/topic/TopicAction.do?Id=15) вы найдете больше информации по теме.
В общем: существует возможность изменения состояния объекта изнутри или извне. Первый вариант — предпочтительнее и более распространен, а вот второй — нет. Особенно когда вы работаете со ссылочным типом и не ожидаете изменений его состояния. Это может осложнить поиск багов. Для предотвращения этой проблемы, вам следует создавать защищенную копию мутабельного объекта перед тем как передавать его куда-либо. Kotlin гораздо полезнее в таких ситуациях, чем Java, но по неосторожности все еще могут возникать проблемы. Рассмотрим простой пример:
```
data class Page(val title: String)
class Book {
val pages: MutableList = mutableListOf(Page(“Chapter 1”), Page(“Chapter 2”))
}
```
Я объявил *pages* как *MutableList*, потому что хочу их менять внутри этого объекта (добавлять, удалять и т.п.). *Pages* не *private*, потому что мне нужен доступ к их состоянию извне. Пока все идет нормально.
```
val book = Book()
print(“$book”) // Book(pages=[Page(title=Chapter 1), Page(title=Chapter 2)])
```
Теперь у меня есть доступ к текущему состоянию книги:
```
val bookPages = book.pages
```
Я добавляю новую страницу в *bookPages*:
```
bookPages.add(Page(“Chapter 3”))
```
К сожалению, я также изменил состояние исходной книги. А это совсем не то, чего я хотел.
```
print(“$book”) // Book(pages=[Page(title=Chapter 1), Page(title=Chapter 2), Page(title=Chapter 3)])
```
Мы можем воспользоваться защищенной копией, чтобы избежать этого. Это очень легко в Kotlin.
```
book.pages.toMutableList()
```
Теперь у нас все хорошо. :)
А что же Swift? Тут все работает из коробки. Да, массивы — это структуры. Структуры передаются по значению, как мы уже упоминали выше, поэтому когда вы пишете:
```
var bookPages = book.pages
```
вы работаете с копией списка страниц.
Таким образом мы имеем дело с передачей данных по значению. Это очень важно для понимания отличий, если вы не хотите испытывать головную боль во время отладки. :) Многие "объекты" являются структурами в Swift, например Int, CGPoint, Array и т.п.
Интерфейсы и Протоколы и Расширения
===================================
Это моя любимая тема. :D
Начнем со сравнения интерфейса и протокола. В принципе, они идентичны.
* Оба могут требовать реализации определенных методов в классе/структуре;
* Оба могут требовать объявления определенного свойства. Свойство может быть доступным на чтение/запись или только на чтение.
* Оба\* позволяют добавить реализацию метода по-умолчанию.
Кроме того, для протоколов может потребоваться определенный инициализатор (конструктор в Kotlin).
Kotlin:
```
interface MyInterface {
var myVariable: Int
val myReadOnlyProperty: Int
fun myMethod()
fun myMethodWithBody() {
// implementation goes here
}
}
```
Swift:
```
protocol MyProtocol {
init(parameter: Int)
var myVariable: Int { get set }
var myReadOnlyProperty: Int { get }
func myMethod()
func myMethodWithBody()
}
extension MyProtocol {
func myMethodWithBody() {
// implementation goes here
}
}
```
\*Обратите внимание, что вы не можете добавить реализацию метода по-умолчанию прямо внутри протокола. Вот почему я добавил звездочку к последнему пункту списка. Вам нужно добавить расширение для этого. И это хороший способ перейти к более интересной части — расширениям!
Расширения позволяют добавлять функционал к существующим классам (или структурам ;)) не наследуя их. Это так просто. Согласитесь, это крутая возможность.
Это что-то новое для Android-разработчиков, поэтому нам нравится пользоваться этим постоянно! Создавать расширения в Kotlin — не запускать ракеты в космос.
Вы можете создавать расширения для свойств:
```
val Calendar.yearAhead: Calendar
get() {
this.add(Calendar.YEAR, 1)
return this
}
```
или для функций:
```
fun Context.getDrawableCompat(@DrawableRes drawableRes: Int): Drawable {
return ContextCompat.getDrawable(this, drawableRes) ?: throw NullPointerException("Can not find drawable with id = $drawableRes")
}
```
Как видите, мы не использовали здесь никаких ключевых слов.
В Kotlin есть некоторые предопределенные расширения, которые довольно круты, например "orEmpty()" для опциональных строк:
```
var maybeNullString: String = null
titleView.setText(maybeNullString.orEmpty())
```
Это полезное расширение выглядит так:
```
public inline fun String?.orEmpty(): String = this ?: ""
```
'?:' пытается получить значение из 'this' (что является текущим значением нашей строки). Если же там будет null, взамен будет возвращена пустая строка.
Так-с, теперь посмотрим на расширения в Swift.
Определение у них то же, поэтому не буду повторяться как заезженная пластинка.
Если вы будете искать расширение подобное "orEmpty()" — у меня для вас плохие новости. Но можно его добавить, не так ли? Давайте попробуем!
```
extension String? {
func orEmpty() -> String {
return self ?? ""
}
}
```
но вот что вы увидите:
Опционал в Swift — это generic-перечисление, с заданным типом **Wrapped**. В нашем случае **Wrapped** — это строка, поэтому расширение будет выглядеть так:
```
extension Optional where Wrapped == String {
func orEmpty() -> String {
switch self {
case .some(let value):
return value
default:
return ""
}
}
}
```
и в деле:
```
let page = Page(text: maybeNilString.orEmpty())
```
Выглядит сложнее, чем Kotlin-аналог, не так ли? И, к сожалению, есть еще и недостаток. Как вы знаете опционал в Swift — generic-перечисление, поэтому ваше расширение будет доступно для всех опциональных типов. Выглядит не очень хорошо:
Однако компилятор защитит вас и не скомпилирует этот код. Но если вы добавите больше таких расширений — ваша автоподсказка будет забита мусором.
Значит Kotlin-расширения удобнее чем в Swift? Я бы сказал, что расширения в Swift предназначены для других целей ;). Android-разработчики, держитесь!
Протоколы и расширения созданы, чтоб работать вместе. Вы можете создать свой протокол и расширение для класса, чтоб соответствовать этому протоколу. Это звучит безумно, но это еще не все! Есть такая вещь, как *условное соответствие протоколу*. Это означает, что класс/структура может соответствовать протоколу при выполнении определенных условий.
Допустим у нас есть много мест, где необходимо показать всплывающий alert. Нам нравится принцип DRY и мы не хотим копипастить код. Мы можем решить эту проблему используя протокол и расширение.
Сначала создадим протокол:
```
protocol AlertPresentable {
func presentAlert(message: String)
}
```
Затем, расширение с реализацией по-умолчанию:
```
extension AlertPresentable {
func presentAlert(message: String) {
let alert = UIAlertController(title: “Alert”, message: message, preferredStyle: .alert)
alert.addAction(UIAlertAction(title: “OK”, style: .default, handler: nil))
}
}
```
Так-с, метод presentAlert только создает alert, но ничего не показывает. Нам нужна ссылка на вью-контроллер для этого. Можем ли мы передать его как параметр в этот метод? Не очень хорошая идея. Давайте воспользуемся условием Where!
```
extension AlertPresentable where Self: UIViewController {
func presentAlert(message: String) {
let alert = UIAlertController(title: “Alert”, message: message, preferredStyle: .alert)
alert.addAction(UIAlertAction(title: “OK”, style: .default, handler: nil))
self.present(alert, animated: true, completion: nil)
}
}
```
Что у нас тут? Мы добавили специфическое требование к расширению нашего протокола. Оно предназначено только для UIViewController. Благодаря этому мы можем пользоваться методами UIViewController в методе presentAlert. Это позволяет нам вывести alert на экран.
Идем дальше:
```
extension UIViewController: AlertPresentable {}
```
Теперь у всех UIViewController появилась новая возможность:
Также, комбинация протоколов и расширений очень полезна для тестирования. Ребята, сколько раз вы пытались тестировать Android final-класс в своем приложении? Это не проблема для Swift.
Приглядимся к этой ситуации и предположим, что у нас есть final-класс в Swift. Если мы знаем сигнатуру метода, то можем создать протокол с таким же методом, а затем добавить расширение, реализующее этот протокол, к нашему final-классу, и вуаля! Вместо непосредственного использования этого класса — мы можем использовать протокол и легко тестировать. Пример кода вместо тысячи слов.
```
final class FrameworkMap {
private init() { … }
func drawSomething() { … }
}
class MyClass {
…
func drawSomethingOnMap(map: FrameworkMap) {
map.drawSomething()
}
}
```
В тесте нам нужно проверить вызывается ли метод drawSomething у объекта map при отработке метода drawSomethingOnMap. Это может быть сложно даже с Mockito (хорошо известной тест-библиотекой для Android). Но с протоколом и расширением — это будет выглядеть так:
```
protocol Map {
func drawSomething()
}
extension FrameworkMap: Map {}
```
И теперь ваш метод drawSomethingOnMap использует протокол вместо класса.
```
class MyClass {
…
func drawSomethingOnMap(map: Map) {
map.drawSomething()
}
}
```
Sealed-классы — перечисления на стероидах
=========================================
Наконец, я хотел бы упомянуть перечисления.
Нет отличий между Java-перечислениями и Kotlin-перечислениями, поэтому тут мне добавить нечего. Но у нас есть кое-что новое взамен, и это "супер-перечисления" — sealed-классы. Откуда взялось понятие "супер-перечисление"? Обратимся к [документации Kotlin](https://kotlinlang.org/docs/reference/sealed-classes.html):
> *"… Они, в некотором смысле — расширения для enum-классов: набор возможных значений для перечислений также ограничен, но каждая enum-константа существует только в единственном экземпляре, в то время как наследник sealed-класса может иметь множество экземпляров, которые могут хранить состояние."*
Окей, круто, они могут хранить состояние, но как мы можем этим пользоваться?
```
sealed class OrderStatus {
object AwaitPayment : OrderStatus()
object InProgress : OrderStatus()
object Completed : OrderStatus()
data class Canceled(val reason: String) : OrderStatus()
}
```
Это sealed-класс, который является моделью статуса заказа. Очень похоже на то, как мы работаем с перечислениями, но с одной оговоркой. Значение Canceled содержит причину отмены. Причины отмены могут быть разными.
```
val orderStatus = OrderStatus.Canceled(reason = "No longer in stock")
…
val orderStatus = OrderStatus.Canceled(reason = "Not paid")
```
Мы не можем делать так с обычными перечислениями. Если значение перечисления создано — его уже не изменить.
Вы обратили внимание, на другие отличия? Я воспользовался еще одной фишкой sealed-класса. Это — связанные данные разных типов. Классическое перечисления предполагает передачу связанных данных для всех вариантов значений перечисления, и все значения должны быть одного и того же типа.
В Swift есть эквивалент sealed-класса и он называется… перечисление. Перечисление в Kotlin — это просто пережиток Java, и 90% времени вы будете пользоваться sealed-классами. Трудно отличить sealed-класс от перечисления Swift. Они отличаются только названием и, конечно же, sealed-класс передается по ссылке, а перечисление в Swift — по значению. Пожалуйста, поправьте меня, если я не прав.
Мы не прощаемся
===============
Существует еще нюансы влияния управления памятью на способ написания кода. Я знаю, что не охватил все аспекты, и это потому, что я еще учусь. Если вы, ребята, заметили какие-либо другие отличия между этими двумя языками — дайте мне знать. Я всегда открыт к новому! | https://habr.com/ru/post/350746/ | null | ru | null |
# Руководство по возможностям Java версий 8-16
Вы можете использовать это руководство, чтобы получить практическую информацию о том, как найти и установить последнюю версию Java, понять различия между дистрибутивами Java (AdoptOpenJdk, OpenJDK, OracleJDK и т. д.), а также получить обзор функций языка Java, включая версии 8-16.
> Примечание переводчика17 февраля 2020 г. был опубликован перевод [**Руководство по версиям и возможностям Java**](https://habr.com/ru/post/488144/).
>
> Вашему вниманию предлагается обновленная версия руководства от 05 апреля 2021 г.
>
>
### Практическая информация
Во-первых, давайте рассмотрим некоторые общие практические вопросы, которые возникают у людей, пытающихся выбрать правильную версию Java для своего проекта.
#### TL; DR Мне нужна только ссылка для скачивания, и я знаю обо всем остальном. Куда мне следует идти?
Перейдите на сайт [**AdoptOpenJDK**](https://adoptopenjdk.net/), [выберите](https://adoptopenjdk.net/) последнюю версию Java, загрузите и установите ее. Затем вернитесь к этому руководству, чтобы, возможно, еще кое-что узнать о версиях Java.
> **TL;DR** (англ. too long; didn't read — слишком длинно, не читал)
>
>
#### Какая последняя версия Java?
По состоянию на март 2021 года [**Java 16**](https://openjdk.java.net/projects/jdk/16/) является последней выпущенной версией Java.
#### Какую версию Java мне следует использовать?
Новые версии Java теперь выходят каждые 6 месяцев. Следовательно, Java 17 запланирован на сентябрь 2021 года, Java 18 - на мар 2022 года и так далее. В прошлом циклы выпуска Java были *намного длиннее*, до 3-5 лет. Этот график демонстрирует, это:
Поскольку выходит так много новых версий, существуют в действительности имеются следующие сценарии использования:
* Унаследованные проекты в компаниях часто застревают на Java 8 (см. раздел «**Почему компании все еще застревают на Java 8?**» ниже). Следовательно, вы также будете вынуждены использовать Java 8.
* Некоторые устаревшие проекты даже застревают на Java 1.5 (выпущен в 2004 г.) или 1.6 (выпущен в 2006 г.) - извините, друзья!
* Если вы убедитесь, что используете самые последние IDE, фреймворки и инструменты сборки и начинаете новый проект, вы можете без колебаний использовать Java 11 (LTS) или даже последнюю версию Java 16.
* Есть специальная область разработки Android, где версия Java в основном застряла на Java 7 с с доступом к [**определенному набору функций Java 8**](https://developer.android.com/studio/write/java8-support). Но вы можете переключиться на использование языка программирования Kotlin.
#### Почему компании все еще застряли на Java 8?
Есть несколько причин, по которым компании все еще придерживаются Java 8. Вот некоторые из них:
* Инструменты сборки (Maven, Gradle и т. д.) и некоторые библиотеки *изначально* содержали ошибки с версиями Java > 8 и нуждались в обновлениях. Даже сегодня, например, с Java9+, некоторые инструменты сборки выводят [**предупреждения «reflective access»**](https://issues.apache.org/jira/browse/GROOVY-8339) при сборке проектов Java, которые просто «кажутся не готовыми», даже если сборки в порядке.
* Вплоть до Java 8 вы в значительной степени использовали сборки Oracle JDK, и вам не нужно было заботиться о лицензировании. [Однако в 2019](https://www.oracle.com/technetwork/java/javase/overview/oracle-jdk-faqs.html) году Oracle изменила[**схему лицензирования**](https://www.oracle.com/technetwork/java/javase/overview/oracle-jdk-faqs.html), что привело к тому, что Интернет сошел с ума от множества статей, в которых говорилось, что «Java больше не является бесплатным», - и последовала изрядная путаница. Однако на самом деле это не проблема, о чем вы узнаете в разделе «**Дистрибутивы Java**» этого руководства.
* Некоторые компании придерживаются политики использования только LTS-версий и полагаются на поставщиков своих ОС, которые предоставят им эти сборки, что требует времени.
Подводя итог: у вас есть сочетание практических вопросов (обновление ваших инструментов, библиотек, фреймворков) и политических проблем.
#### Почему некоторые версии Java, например 8, также называются 1.8?
В версиях Java до 9 просто была другая схема именования. Итак, Java 8 также может называться *1.8*, Java 5 может называться *1.5* и т. д. Когда вы вводили команду java -version, с этими версиями вы получали следующий результат:
```
c:\Program Files\Java\jdk1.8.0_191\bin>java -version
java version "1.8.0_191" (1)
Java(TM) SE Runtime Environment (build 1.8.0_191-b12)
Java HotSpot(TM) 64-Bit Server VM (build 25.191-b12, mixed mode)
```
Это просто означает Java 8. С переходом к основанным на времени выпускам с Java 9 схема именования также изменилась, и версии Java больше не имеют префикса 1.x. Теперь номер версии выглядит так:
```
c:\Program Files\Java\jdk11\bin>java -version
openjdk version "11" 2018-09-25 (1)
OpenJDK Runtime Environment 18.9 (build 11+28)
OpenJDK 64-Bit Server VM 18.9 (build 11+28, mixed mode)
```
### В чем разница между версиями Java?
#### Должен ли я изучать конкретную?
Придя из других языков программирования с большими перерывами между выпусками, как, например, Python 2–3, вы можете спросить, применимо ли то же самое к Java.
В этом отношении Java является особенной, поскольку она имеет *полную* обратную совместимость. Это означает, что ваша программа Java 5 или 8 гарантированно будет работать с виртуальной машиной Java 8-16 - за некоторыми исключениями, о которых вам пока не нужно беспокоиться.
Очевидно, что это не работает наоборот, скажем, ваша программа полагается на функции Java 14, которые просто недоступны в JVM Java 8.
Это означает несколько вещей:
* Вы не просто «изучаете» конкретную версию Java, например 12.
* Скорее, вы получите хорошую основу для всех языковых функций вплоть до Java 8. Это послужит хорошей базой.
* И затем, из этого руководства вы можете узнать, какие дополнительные функции появились в Java 9-16, чтобы использовать их всегда, когда это возможно.
#### Каковы примеры этих новых возможностей новых версий Java?
Взгляните на раздел «**Возможности Java 8-16**» ниже.
Но, как правило: старые, более длинные циклы выпуска (3-5 лет, вплоть до Java 8) означали множество новых функций в каждом выпуске.
Шестимесячный цикл выпуска означает меньшее количество функций на выпуск, поэтому вы можете быстро освоить языковые функции Java 9-16.
#### В чем разница между JRE и JDK?
До сих пор мы говорили только о Java. Но что именно означает «Java»?
Во-первых, вам нужно провести различие между JRE (Java Runtime Environment) и JDK (Java Development Kit).
Исторически, вы загружали только JRE, если вас интересовали только программы Java. JRE включает, помимо прочего, виртуальную машину Java (JVM) и инструмент командной строки «java».
Для разработки новых программ на Java вам нужно было загрузить JDK. JDK включает в себя все, что есть в JRE, а также компилятор **javac** и несколько других инструментов, таких как **javadoc** (генератор документации Java) и **jdb** (отладчик Java).
Теперь, почему я говорю в прошедшем времени?
Вплоть до Java 8 веб-сайт Oracle предлагал JRE и JDK в качестве отдельных загрузок, хотя JDK также всегда включал JRE в отдельной папке. В Java 9 это различие практически исчезло, и вы всегда загружаете JDK. Структура каталогов JDK также изменилась, так как в ней больше не было явной папки JRE.
Таким образом, хотя некоторые дистрибутивы (см. Раздел «**Дистрибутивы Java**») по-прежнему предлагают отдельную загрузку JRE, похоже, существует тенденция предлагать только JDK. Следовательно, теперь мы будем использовать **Java** и **JDK** взаимозаменяемо.
#### Как мне установить Java или JDK?
На данный момент не обращайте внимания на образы Java-Docker, оболочки .msi или пакеты для конкретной платформы. В конце концов, Java - это просто файл .zip, ни больше, ни меньше.
Поэтому все, что вам нужно сделать, чтобы установить Java на свой компьютер, — это разархивировать файл jdk-{5-16}.zip. Вам даже не нужны права администратора для этого.
Ваш распакованный файл Java будет выглядеть так:
```
Directory C:\dev\jdk-11
12.11.2019 19:24 .
12.11.2019 19:24 ..
12.11.2019 19:23 bin
12.11.2019 19:23 conf
12.11.2019 19:24 include
12.11.2019 19:24 jmods
22.08.2018 19:18 legal
12.11.2019 19:24 lib
12.11.2019 19:23 1.238 release
```
Магия происходит в каталоге /bin, который в Windows выглядит следующим образом:
```
Directory C:\dev\jdk-11\bin
...
12.11.2019 19:23 272.736 java.exe
...
12.11.2019 19:23 20.832 javac.exe
...
```
Поэтому все, что вам нужно сделать, это разархивировать этот файл и поместить каталог /bin в переменную PATH, чтобы вы могли вызывать команду **java** из любого места.
В случае, если вам интересно, установщики с графическим интерфейсом, такие как Oracle или AdoptOpenJDK, выполняет распаковку и изменение переменной PATH вместо вас.
Чтобы убедиться, что вы правильно установили Java, вы можете просто выполнить команду **java -version**. Если вывод выглядит так, как показано ниже, вы готовы начать разработку.
```
openjdk version "11" 2018-09-25
OpenJDK Runtime Environment 18.9 (build 11+28)
OpenJDK 64-Bit Server VM 18.9 (build 11+28, mixed mode)
```
Теперь остался один вопрос: откуда вам взять этот .zip файл с Java? Что подводит нас к теме дистрибутивов.
### Дистрибутивы Java
Есть множество сайтов, предлагающих загрузки Java (читай: JDK), и неясно, «кто что предлагает и с какими лицензиями». Этот раздел прольет на это некоторый свет.
#### Проект OpenJDK
Что касается исходного кода Java (читайте: исходный код для вашего JRE / JDK), существует ***только один***, живущий на сайте [**проекта OpenJDK**](http://openjdk.java.net/projects/jdk/).
Однако это всего лишь исходный код, а не распространяемая сборка (представьте: ваш файл .zip со скомпилированной командой java для вашей конкретной операционной системы). Теоретически мы с вами могли бы создать сборку из этого исходного кода, назвать ее, скажем, *MarcoJDK* и начать ее дистрибуцию. Но нашему дистрибутиву не хватило бы сертификации, чтобы иметь возможность на законных основаниях называть этот дистрибутив **совместимым с Java SE**.
Вот почему на практике есть несколько поставщиков, которые фактически создают эти сборки, сертифицируют (см. [**TCK**](https://en.wikipedia.org/wiki/Technology_Compatibility_Kit)) и затем распространяют их.
И хотя поставщики не могут, скажем, удалить метод из класса String перед созданием новой сборки Java, они могут добавить брэндинг (вay!) или добавить некоторые другие утилиты (например, CLI), которые они считают полезными. Но в остальном исходный код одинаков для всех дистрибутивов Java.
#### Сборки OpenJDK (от Oracle) и OracleJDK
Один из поставщиков, который создает Java из исходного кода, — это Oracle. Это приводит к двум разным дистрибутивам Java, что поначалу может казаться очень запутанными.
1. [**Сборки OpenJDK**](http://jdk.java.net/) от Oracle (!). Эти сборки бесплатны и не имеют торговой марки, но Oracle не выпустит обновления для более старых версий, скажем, Java 15, как только выйдет Java 16.
2. [**OracleJDK**](https://www.oracle.com/technetwork/java/javase/downloads/index.html) — это коммерческая сборка под брендом, выпускаемая начиная с изменения лицензии в 2019 году. Это означает, что ее можно использовать бесплатно во время разработки, но вы должны платить Oracle, если используете ее в рабочей среде. При этом вы получаете более длительную поддержку, то есть все обновления дистрибутива и номер телефона, по которому можно позвонить, если с вашей JVM будут проблемы.
Исторически (до Java 8) существовали реальные исходные различия между сборками OpenJDK и сборками OracleJDK, при этом можно было сказать, что OracleJDK был «лучше». Но на сегодняшний день обе версии практически одинаковы, с [**небольшими отличиями**](https://blogs.oracle.com/java-platform-group/oracle-jdk-releases-for-java-11-and-later).
Впрочем все сводится к тому, требуется ли вам коммерческая поддержка (номер телефона) для используемой версии Java.
#### AdoptOpenJDK
В 2017 году группа участников, разработчиков и поставщиков Java User Group (Amazon, Microsoft, Pivotal, Red Hat и другие) создала сообщество под названием [**AdoptOpenJDK**](https://adoptopenjdk.net/).
Они предоставляют бесплатные надежные сборки OpenJDK с более [**длительной доступностью / обновлениями**](https://adoptopenjdk.net/support.html) и даже предлагают вам выбор из двух разных виртуальных машин Java: [**HotSpot**](https://en.wikipedia.org/wiki/HotSpot) и [**OpenJ9**](https://en.wikipedia.org/wiki/OpenJ9).
**Я очень рекомендую** ее, если вы хотите установить Java.
#### Azul Zulu, Amazon Corretto, SAPMachine
Полный список сборок OpenJDK вы найдете на сайте [**OpenJDK Wikipedia**](https://en.wikipedia.org/wiki/OpenJDK). Среди них [**Azul Zulu**](https://www.azul.com/products/zulu-community/), [**Amazon Corretto**](https://aws.amazon.com/corretto/), а также [**SapMachine**](https://sap.github.io/SapMachine/) и многие другие. Упрощенно говоря, различия сводятся к тому, что у вас есть различные варианты поддержки/ гарантии обслуживания.
Но не забудьте проверить на сайтах дистрибьюторов, чтобы узнать о преимуществах каждого отдельного дистрибутива.
#### Полный обзор дистрибутива OpenJDK
Рафаэль Винтерхальтер ([**Rafael Winterhalter**](https://twitter.com/rafaelcodes)) собрал большой список всех доступных сборок OpenJDK, включая их описания: ОС, архитектуру, окна лицензирования, поддержки и обслуживания.
Он находится здесь: [**https://rafael.codes/openjdk/**](https://rafael.codes/openjdk/).
#### Рекомендация
Повторим с еще раз, что с 2020 года, если у вас нет особых требований, найдите файл jdk.zip (.tar.gz/.msi/.pkg) по адресу [**https://adoptopenjdk.net**](https://adoptopenjdk.net/) или выберите пакет, предоставленный вашим поставщиком ОС.
### Возможности Java 8-16
Как уже упоминалось в самом начале этого руководства: в сущности *все* (если вы не будьте слишком требовательны) функции языка Java 8 работают в Java 14. То же самое касается всех других версий Java между ними.
В свою очередь, это означает, что знание всех языковых возможностей Java 8 создает хорошую базу в изучении Java, а все остальные версии (Java 9-16) в значительной степени дают дополнительные функции поверх этого базового уровня.
Вот краткий обзор того, что конкретные версии могут предложить:
#### — Java 8 -
Java 8 была массовым выпуском, и вы можете найти список всех функций на [**веб-сайте Oracle**](https://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html). Здесь я хотел бы упомянуть два основных набора функций:
**Особенности языка: лямбды и т. д.**
До Java 8 всякий раз, когда вы хотели создать экземпляр, например, нового Runnable, вы должны были написать анонимный внутренний класс, например, так:
```
Runnable runnable = new Runnable(){
@Override
public void run(){
System.out.println("Hello world !");
}
};
```
С лямбдами тот же код выглядит так:
```
Runnable runnable = () -> System.out.println("Hello world two!");
```
Вы также получили ссылки на методы, повторяющиеся аннотации, методы по умолчанию для интерфейсов и некоторые другие языковые функции.
**Коллекции и потоки**
В Java 8 вы также получили операции в функциональном стиле для коллекций, также известные как Stream API. Живой пример:
```
List list = Arrays.asList("franz", "ferdinand", "fiel", "vom", "pferd");
```
До Java 8, вам нужно было написать циклы for, чтобы что-то сделать с этим списком.
С помощью API Streams вы можете сделать следующее:
```
list.stream()
.filter(name -> name.startsWith("f"))
.map(String::toUpperCase)
.sorted()
.forEach(System.out::println);
```
**Если вы хотите больше практики на Java 8**
Очевидно, что в рамках этого руководства я могу только дать краткий обзор каждого недавно добавленного Stream, Lambda или Optional метода в Java 8.
Если вам нужен более детальный, подробный обзор, включая упражнения, вы можете ознакомиться с моим курсом по [**основным функциям Java 8**](https://www.marcobehler.com/courses/32-core-java-features-version-8-12?utm_campaign=java_features_guide&utm_medium=java_features_guide&utm_source=java_features_guide).
#### — Java 9 -
Java 9 также была довольно большой версией, с несколькими дополнениями:
**Коллекции**
Коллекции получили несколько новых вспомогательных методов для простого создания списков, наборов и карт.
```
List list = List.of("one", "two", "three");
Set set = Set.of("one", "two", "three");
Map map = Map.of("foo", "one", "bar", "two");
```
**Streams**
Потоки получили несколько дополнений в виде методов **takeWhile**, **dropWhile** и **iterate**.
```
Stream stream = Stream.iterate("", s -> s + "s")
.takeWhile(s -> s.length() < 10);
```
**Optionals**
Optionals получили метод **ifPresentOrElse**, которого очень не хватало.
```
user.ifPresentOrElse(this::displayAccount, this::displayLogin);
```
**Интерфейсы**
Интерфейсы получили private методы:
```
public interface MyInterface {
private static void myPrivateMethod(){
System.out.println("Yay, I am private!");
}
}
```
**Другие возможности языка**
И пара других улучшений, таких как улучшенный оператор try-with-resources или расширения diamond оператора.
**JShell**
Наконец, в Java появилась оболочка, в которой вы можете попробовать простые команды и получить немедленные результаты.
```
% jshell
| Welcome to JShell -- Version 9
| For an introduction type: /help intro
jshell> int x = 10
x ==> 10
```
**HTTPClient**
В Java 9 появилась первая предварительная версия нового HttpClient. До этого времени встроенная поддержка Http в Java была довольно низкоуровневой, и вам приходилось прибегать к использованию сторонних библиотек, таких как Apache HttpClient или OkHttp (кстати, отличные библиотеки!).
В Java 9 у Java появился собственный современный клиент - хотя и в режиме превью, что означает возможность его изменения в более поздних версиях Java.
**Project Jigsaw: модули Java и файлы Jar с несколькими выпусками**
В Java 9 появилась система [**модулей Jigsaw**](https://www.oracle.com/corporate/features/understanding-java-9-modules.html), которая чем-то напоминает старую [добрую **спецификацию OSGI**](https://en.wikipedia.org/wiki/OSGi). Подробное описание Jigsaw не входит в задачи данного руководства — посмотрите предыдущие ссылки, чтобы узнать больше.
Файлы Multi-Release .jar позволили создать один файл .jar, который содержит разные классы для разных версий JVM. Таким образом, ваша программа может вести себя по-разному / использовать разные классы, например, при запуске на Java 8 и Java 10.
**Если вы хотите больше практиковаться в Java 9**
Опять же, это всего лишь краткий обзор функций Java 9, и если вам нужны более подробные объяснения и упражнения, [ознакомьтесь с](https://www.marcobehler.com/courses/32-core-java-features-version-8-12?utm_campaign=java_features_guide&utm_medium=java_features_guide&utm_source=java_features_guide) курсом [**основных функций Java 9**](https://www.marcobehler.com/courses/32-core-java-features-version-8-12?utm_campaign=java_features_guide&utm_medium=java_features_guide&utm_source=java_features_guide).
#### - Java 10 -
В Java 10 было внесено несколько изменений, таких как сборка мусора и т. д. Но единственное реальное изменение, которое вы, как разработчик, вероятно, заметите, - это введение ключевого слова «**var**», также называемого выводом типа локальной переменной.
**Вывод типа локальной переменной: ключевое слово var**
```
// Pre-Java 10
String myName = "Marco";
// With Java 10
var myName = "Marco"
```
Чувствуете себя как в Javascript-е, не так ли? Однако Java все еще строго типизирован и **var** применяется только к переменным *внутри методов* (спасибо, [**dpash**](https://www.reddit.com/user/dpash), за то, что снова указали на это).
#### - Java 11 -
Java 11 также была несколько меньшей версией с точки зрения разработчика.
**Строки и файлы**
Строки и файлы получили пару новых методов (здесь перечислены не все):
```
"Marco".isBlank();
"Mar\nco".lines();
"Marco ".strip();
Path path = Files.writeString(Files.createTempFile("helloworld", ".txt"), "Hi, my name is!");
String s = Files.readString(path);
```
**Запустить исходные файлы**
Начиная с Java 10, вы можете запускать исходные файлы Java ***без*** предварительной их компиляции. Шаг к написанию сценариев.
```
ubuntu@DESKTOP-168M0IF:~$ java MyScript.java
```
**Вывод типа локальной переменной (var) для лямбда-параметров**
В заголовке сказано все:
```
(var firstName, var lastName) -> firstName + lastName
```
**HttpClient**
HttpClient из Java 9 в его последней, не предварительной версии.
**Другие вкусности**
Flight Recorder (Регистратор полетов), сборщик мусора No-Op, Nashorn-Javascript-Engine объявлен deprecated (устаревшим) и т.д.
#### - Java 12 -
В Java 12 появилось несколько [**новых функций и исправлений**](https://www.oracle.com/technetwork/java/javase/12-relnote-issues-5211422.html), но здесь стоит упомянуть только поддержку Unicode 11 и предварительный просмотр нового выражения **switch**, которое вы увидите в следующем разделе.
#### - Java 13 -
Вы можете найти полный список возможностей [**здесь**](https://www.oracle.com/technetwork/java/13-relnote-issues-5460548.html), но, по сути, вы получаете поддержку Unicode 12.1, а также две новые или улучшенные превью функции (могут быть изменены в будущем):
**Switch выражение (Preview — предварительная версия)**
Switch выражения теперь могут возвращать значение. И вы можете использовать лямбда-стиль синтаксиса для своих выражений, без проблем с ошибками:
Старые операторы switch выглядели так:
```
switch(status) {
case SUBSCRIBER:
// code block
break;
case FREE_TRIAL:
// code block
break;
default:
// code block
}
```
В то время как в Java 13 операторы switch могут выглядеть так:
```
boolean result = switch (status) {
case SUBSCRIBER -> true;
case FREE_TRIAL -> false;
default -> throw new IllegalArgumentException("something is murky!");
};
```
**Многострочные строки (предварительная версия)**
***Наконец-то****,* вы можете сделать это на Java:
```
String htmlBeforeJava13 = "\n" +
" \n" +
" Hello, world
\n" +
" \n" +
"\n";
String htmlWithJava13 = """
Hello, world
""";
```
#### Java 14 и далее
**Switch выражения (стандартное)**
Switch выражения, которые были превью функцией в версиях 12 и 13, теперь стандартизированы.
```
int numLetters = switch (day) {
case MONDAY, FRIDAY, SUNDAY -> 6;
case TUESDAY -> 7;
default -> {
String s = day.toString();
int result = s.length();
yield result;
}
};
```
**Records (Записи -** превью**)**
В настоящее время существуют классы Records (записей), которые помогают облегчить задачу написания большого количества шаблонов с использованием Java.
Взгляните на этот класс до Java 14, который содержит только данные, (потенциально) методы получения / установки, equals / hashcode, toString.
```
final class Point {
public final int x;
public final int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
// state-based implementations of equals, hashCode, toString
// nothing else
```
С записями теперь это можно записать так:
```
record Point(int x, int y) { }
```
Опять же, это предварительная версия, которая может быть изменена в будущих выпусках.
**Полезные исключения NullPointerExceptions**
Наконец, исключения NullPointerExceptions описывают*,* какая *именно* переменная имела значение NULL.
```
author.age = 35;
Exception in thread "main" java.lang.NullPointerException:
Cannot assign field "age" because "author" is null
```
**Сопоставление с образцом для InstanceOf (предварительная версия)**
Раньше вам приходилось выполнять cast ваших объектов внутри instanceof следующим образом:
```
if (obj instanceof String) {
String s = (String) obj;
// use s
}
```
Теперь вы можете сделать это, эффективно сбросив гипс.
```
if (obj instanceof String s) {
System.out.println(s.contains("hello"));
}
```
**Инструмент для упаковки (инкубатор)**
Существует инструмент jpackage (инкубатор), который позволяет упаковать ваше Java-приложение в пакеты для конкретной платформы, включая все необходимые зависимости.
* Linux: deb и rpm
* macOS: pkg и dmg
* Windows: msi и exe
**Сборщики мусора**
Сборщик мусора Concurrent Mark Sweep (CMS) был удален, и был добавлен экспериментальный сборщик мусора Z.
#### Java 15
**Текстовые блоки / многострочные строки**
Представленные в качестве экспериментальной функции в Java 13 (см. Выше), многострочные тексты теперь готовы к работе.
```
String text = """
Lorem ipsum dolor sit amet, consectetur adipiscing \
elit, sed do eiusmod tempor incididunt ut labore \
et dolore magna aliqua.\
""";
```
#### Запечатанные (sealed) классы - превью
Если вы когда-либо хотели иметь еще более четкое представление о том, кому разрешено создавать подклассы ваших классов, теперь есть такая `sealed`функция.
```
public abstract sealed class Shape
permits Circle, Rectangle, Square {...}
```
Это означает, что пока класс есть `public`, только классы, которым разрешено создавать подклассы, `Shape`это `Circle`, `Rectangle`и `Square`.
**Записи и сопоставление с образцом**
Функции `Records`и `Pattern Matching`из Java 14 (см. Выше) все еще находятся в предварительной версии и еще не доработаны.
**Движок JavaScript Rhinoceros**
После устаревания в Java 11 механизм Nashorn Javascript Engine был окончательно удален в JDK 15.
**ZGC: готово к продакшн**
[**Z Garbage Collector**](https://wiki.openjdk.java.net/display/zgc/Main) не маркирован экспериментальное больше. Теперь он готов к использованию в продакшн.
#### Java 16
**Каналы сокетов домена Unix**
Теперь вы можете подключаться к сокетам домена Unix (также поддерживаются macOS и Windows (10+).
```
socket.connect(UnixDomainSocketAddress.of(
"/var/run/postgresql/.s.PGSQL.5432"));
```
**API стороннего компоновщика - превью**
Планируемая замена JNI (Java Native Interface), позволяющая выполнять привязку к собственным библиотекам (подумайте о C).
**Записи и сопоставление с образцом**
Обе функции теперь готовы к продакшн и больше не отмечены `in preview`.
**Запечатанные классы**
Запечатанные классы (начиная с Java 15, см. Выше) все еще находятся в предварительной версии.
#### Java 17 и новее
Будет рассмотрено здесь, как только они будут выпущены. Зайдите в ближайшее время.
### Заключение
К настоящему времени у вас должен быть довольно хорошее представление о нескольких вещах:
* Как установить Java, какую версию получить и где ее получить (подсказка: [**AdoptOpenJDK**](https://adoptopenjdk.net/)).
* Что такое дистрибутив Java, какие существуют и в чем различия.
* Каковы различия между конкретными версиями Java.
Отзывы, исправления и ваш вклад всегда приветствуются! Просто оставьте комментарий внизу.
Спасибо за прочтение!
### Благодарности
Стивен Колеборн, написал [**фантастическую статью**](https://blog.joda.org/2018/09/time-to-look-beyond-oracles-jdk.html?showComment=1536303755275#c5934330550793525320) о различных доступных дистрибутивах Java. | https://habr.com/ru/post/551590/ | null | ru | null |
# Run MongoDB Atlas locally for testing
What happens to your MongoDB replica set when it comes to failures like network partitioning, restarting, reconfiguration of the existing topology, etc.? This question is especially important these days because of [the popularity gained by the multi-cloud model](https://www.mongodb.com/blog/post/introducing-multicloud-clusters-on-mongodb-atlas?utm_campaign=INT_EM_Newsletter%252520Developer_01_21_WW&utm_source=eloqua&utm_medium=email&utm_term=MongoDB%252520Developer%252520Newsletter%25253A%252520February%2525204%25252C%2525202021) where chances of these scenarios are quite realistic.
However, is there a solution, preferably a free one, for testing such cases that would obviate the need of writing manual scripts and poring over the official documentation? As software developers, we would be better off preparing our applications in advance to survive these failures.
Having a look at MongoDB Atlas and their free [Shared Clusters](https://docs.atlas.mongodb.com/reference/free-shared-limitations/#std-label-atlas-free-tier), we cannot configure a replica set given by default which is Primary with Two Secondary Members (hereinafter the P-S-S), not to mention testing some features like `restartPrimaries`. All of it is for Dedicated Clusters requiring payments at hourly rates.
While cloud solutions seem to be the de facto choice for production systems, some software developers are likely to be in need of free local alternatives, which is proven by projects like LocalStack, act, etc.
Given that, what about developing a solution for running locally some functionality that the paid version of MongoDB Atlas does? One possible way is to opt for the following:
* Docker to run MongoDB containers;
* Testcontainers to handle the containers via a programming language like Java;
* Toxiproxy to simulate network conditions.
All good, but to build a cluster of more than one node MongoDB requires that ["each member of a replica set is accessible by way of resolvable DNS or hostnames"](https://docs.mongodb.com/manual/tutorial/deploy-replica-set/). If you run Docker version 18.03+ on hosts like Mac and Win or Docker 20.04+ on Linux, you are free to use the special DNS name `host.docker.internal`. During installation Docker might add it to your OS host file. However, for those who cannot upgrade their Docker for some reason, we can employ a special container which redirects traffic to the host, for instance [Qoomon docker-host](https://github.com/qoomon/docker-host). Similarly, we can add `dockerhost` to the OS host file and also run the container with `NET_ADMIN` and `NET_RAW` kernel capabilities.
The good news is that we do not have to connect all the above-mentioned pieces together manually, but instead can take the free [MongoDBReplicaSet](https://github.com/silaev/mongodb-replica-set).
Let us get started by creating a new Gradle project with Java and adding some dependencies from Maven central:
```
testCompile("com.github.silaev:mongodb-replica-set:0.4.3")
testImplementation("org.mongodb:mongodb-driver-sync:4.2.1")
```
1) Note that it is up to you which MongoDB driver to use here, `mongodb-driver-sync` is an example.
Then we need to check and possibly change our OS host file. Regarding `host.docker.internal`, it might be already there, otherwise add `127.0.0.1 host.docker.internal`. As per `dockerhost`, add `127.0.0.1 dockerhost`. You have to pick only one of them and use it within your test execution.
Our journey begins and we are ready to write a test to simulate network partitioning in the P-S-S. Here is the description of it:
```
try (
final MongoDbReplicaSet mongoReplicaSet = MongoDbReplicaSet.builder()
.mongoDockerImageName("mongo:4.4.4")
.useHostDockerInternal(true)
.addToxiproxy(true)
.replicaSetNumber(3)
.commandLineOptions(Arrays.asList("--oplogSize", "50"))
.build()
) {
```
1) Use `mongo:4.4.4` as the latest MongoDB Docker image at the moment of writing;
2) If `useHostDockerInternal` is true, use `host.docker.internal` of Docker, otherwise take `dockerhost` of Qoomon docker-host;
3) Put a ToxiproxyContainer.ContainerProxy against each MongoDB node;
4) Set 3 (possible up to 7) members to construct the P-S-S;
5) Optionally, add some command line options, for example set 50MB as the replication operation log;
6) Auto-close all the containers via try-with-resources in case of any exception or completion.
Now we can start the replica set by `mongoReplicaSet.start()`, get its URL and make some assertions:
```
final String replicaSetUrl = mongoReplicaSet.getReplicaSetUrl();
assertThat(
mongoReplicaSet.nodeStates(mongoReplicaSet.getMongoRsStatus().getMembers())
).containsExactlyInAnyOrder(PRIMARY, SECONDARY, SECONDARY);
```
1) Internally, getMongoRsStatus() calls `rs.status()` in MongoDB shell.
Then we can, for instance, create a `MongoClient` to insert some data and subsequently assert it (see [the full example on Github](https://github.com/silaev/mongodb-replica-set-examples/blob/main/src/test/java/com/github/silaev/mongodb/replicaset/examples/FailureTest.java)).
```
try (
final MongoClient mongoSyncClient = MongoClients.create(new ConnectionString(replicaSetUrl))
) {
```
1) Note that we are also able to use the more convenient `MongoClientSettings` as the parameter of the `create` method to set timeouts, read/write concerns, turn off retries at the connection level.
The first failure comes here so let our replica set survive the disconnection of the master node:
```
// TODO: Insert a document here to assert total number at the end
final MongoNode masterNodeBeforeFailure1 = mongoReplicaSet.getMasterMongoNode(
mongoReplicaSet.getMongoRsStatus().getMembers()
);
mongoReplicaSet.disconnectNodeFromNetwork(masterNodeBeforeFailure1);
mongoReplicaSet.waitForMasterReelection(masterNodeBeforeFailure1);
assertThat(
mongoReplicaSet.nodeStates(mongoReplicaSet.getMongoRsStatus().getMembers())
).containsExactlyInAnyOrder(PRIMARY, SECONDARY, DOWN);
```
1) We need to wait for a new master node elected by providing the previous master node to the `waitForMasterReelection(...)` method.
Going further, the next accident leads to the newcomer master node getting cut off:
```
// TODO: Insert a document here to assert total number at the end
final MongoNode masterNodeBeforeFailure2 = mongoReplicaSet.getMasterMongoNode(
mongoReplicaSet.getMongoRsStatus().getMembers()
);
mongoReplicaSet.disconnectNodeFromNetwork(masterNodeBeforeFailure2);
mongoReplicaSet.waitForMongoNodesDown(2);
assertThat(
mongoReplicaSet.nodeStates(mongoReplicaSet.getMongoRsStatus().getMembers())
).containsExactlyInAnyOrder(SECONDARY, DOWN, DOWN);
```
1) We wait for a moment when our single secondary detects the other 2 nodes being down.
Our journey is drawing to a close, so let us bring all the disconnected nodes back by way of a happy end:
```
// TODO: Insert a document here to assert total number at the end
mongoReplicaSet.connectNodeToNetwork(masterNodeBeforeFailure1);
mongoReplicaSet.connectNodeToNetwork(masterNodeBeforeFailure2);
mongoReplicaSet.waitForAllMongoNodesUp();
mongoReplicaSet.waitForMaster();
assertThat(
mongoReplicaSet.nodeStates(mongoReplicaSet.getMongoRsStatus().getMembers())
).containsExactlyInAnyOrder(PRIMARY, SECONDARY, SECONDARY);
```
1) The `waitForAllMongoNodesUp(...)` method waits for all the disconnected nodes to be up and running;
2) Then the `waitForMaster()` method waits for the elections to complete.
### Conclusion
Why writing such tests? To address this question, let us set `write concern` as `majority` with `journaling` enabled and `read concern` as `majority` as well. Then we can replace `// TODO:...` in the above-mentioned code examples with the `mongoSyncClient.insertOne(…)` method handling possible exceptions to add a new document 3 times. Running this test 120 times and waiting for a while at the end, I found out that approximately half the time total number was 2 and the other half it was 3. Therefore, the idea behind these tests is to be ready for some corner cases beforehand.
### Links:
1. Find the example from this article [here](https://github.com/silaev/mongodb-replica-set-examples/blob/main/src/test/java/com/github/silaev/mongodb/replicaset/examples/FailureTest.java);
2. [MongoDBReplicaSet on Github](https://github.com/silaev/mongodb-replica-set). | https://habr.com/ru/post/544460/ | null | en | null |
# Hibernate: использование lazy initialization в разработке клиент-серверного приложения
При проектировании доменов приложения, разрабатываемого с использованием Hibernate, разработчику необходимо сделать выбор: инициализировать ли свойства домена, соответствующие коллекциям связанных доменов, сразу (FetchType=EAGER) или же делать это только при обращении к ним (FetchType=LAZY). На самом деле в случае, когда предметная область имеет сколь-либо сложную структуру связей между объектами, выбор уже сделан – загружать полбазы ради одного объекта, как это было бы при FetchType=EAGER, мягко говоря, неразумно. [Поэтому](http://docs.jboss.org/hibernate/core/3.5/reference/en/html/performance.html#performance-fetching-lazy) ленивая инициализация в случае коллекций есть наиболее предпочтительная стратегия инициализации связанных объектов.
Однако, не всё так просто. Ленивая инициализация реализуется за счёт создания прокси-объекта с помощью JDK Dynamic Proxy или библиотеки CGLIB. В обоих случаях проксирование соответствующих get-методов сводится к обращению к сессии Hibernate для получения необходимых данных. Последнее же в свою очередь означает, что обращение к ленивым свойствам объекта может быть осуществлено только при наличии сессии Hibernate. В противном случае, попытка получить свойство объекта приведёт к незабвенному исключению «LazyInitializationException: could not initialize proxy — the owning Session was closed».
Понятно, что иметь открытую сессию под рукой можно далеко не всегда, что доставляет некоторые неудобства. Так, например, для того, что бы использовать домены с ленивой инициализацией в шаблонах MVC-приложения придётся прибегнуть к методике «[OpenSessionInView](http://community.jboss.org/wiki/OpenSessioninView)», суть которой сводится к созданию фильтра, обеспечивающего открытие сессии в начале обработки запроса и её закрытие в конце.
Но, что делать, если домены с загруженными данными нужно использовать вне сессии Hibernate? Например, в случае клиент-серверной архитектуры, когда серверу необходимо передать домены клиенту? Разумеется, что об открытие сессии на стороне клиента не может идти и речи, хотя бы потому, что в общем случае о БД ему ничего не известно. Единственным выходом из ситуации, на мой взгляд, будет «депроксирование» объектов доменов и инициализация их необходимыми данными перед передачей от сервера клиенту.
Представим, что серверная часть приложения состоит из 3-х слоёв:
* слой служб (объекты, с которыми работает клиент);
* слой бизнес-логики (объекты, реализующие бизнес-логику приложения);
* слой персистенции (Hibernate, домены).
Сами классы доменов доступны как серверу, так и клиенту (что, в общем, логично).
При таком раскладе слой бизнес логики может спокойно работать с прокси-объектами доменов в рамках сессии Hibernate. Роль слоя служб при этом сводится получению необходимых данных от слоя бизнес-логики и компоновки данных для клиента: создание DTO-объектов на базе классов доменов с помощью копирования определённой глубины и детализации.
Вопрос остаётся только в том, как провести это «депроксирование». В принципе это можно [сделать с помощью самого Hibernate’a](http://stackoverflow.com/questions/2216547/converting-hibernate-proxy-to-real-object):
> `public static T initializeAndUnproxy(T entity) {
>
> if (entity == null) {
>
> throw new
>
> NullPointerException("Entity passed for initialization is null");
>
> }
>
>
>
> Hibernate.initialize(entity);
>
> if (entity instanceof HibernateProxy) {
>
> entity = (T) ((HibernateProxy) entity).getHibernateLazyInitializer()
>
> .getImplementation();
>
> }
>
> return entity;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Такой подход инициализирует все коллекции заданного объекта и «достанет» его из прокси. Однако, у него есть целый ряд недостатков: инициализируются все коллекции подряд и депроксируется только родительский объект (как минимум потому, что непонятно, на сколько глубоко нужно спуститься по графу связей объекта при депроксировании).
Решением в данной ситуации может послужить создание небольшого класса-утилиты, который будет выполнять депроксирование домена путём создания нового объекта того же класса и инициализации свойств, соответствующих [базовым классам Hibernate’a](http://docs.jboss.org/hibernate/core/3.3/reference/en/html/mapping.html#mapping-types-basictypes). Все остальные свойства объекта будут инициализироваться слоем служб по мере необходимости.
Я не берусь, утверждать, что данный подход является оптимальным и/или единственно верным. Если у вас есть предложения, как решить проблему иначе, — буду рад их услышать. | https://habr.com/ru/post/111911/ | null | ru | null |
# Фальшивомонетчики против банкиров: стравливаем adversarial networks в Theano
*Вы бы никогда не подумали, но это прогулка по пространству нейросети-фальшивомонетчика. Сделано крутейшими людьми [Anders Boesen Lindbo Larsen и Søren Kaae Sønderby](http://torch.ch/blog/2015/11/13/gan.html)*
Допустим, у нас есть задача — понять окружающий мир.
Давайте для простоты представим, что мир — это деньги.
Метафора, может быть, с некоторой моральной двусмысленностью, но в целом пример не хуже прочих — деньгам (банкнотам) определенно свойственна какая-то сложная структура, тут у них цифра, тут буква, а там хитрые водяные знаки. Предположим, нам нужно понять, как они сделаны, и узнать правило, по которым их печатают. Какой план?
Напрашивающийся шаг — это пойти в офис центрального банка и попросить их выдать спецификацию, но во-первых, вам ее не дадут, а во-вторых, если выдерживать метафору, то у вселенной нет центрального банка (хотя на этот счет есть религиозные разногласия).
Ну, раз так, давайте попробуем их подделать.
Disriminative vs generative
===========================
Вообще на тему понимания мира есть один достаточно известный подход, который заключается в том, что **понять — значит распознать**. То есть когда мы с вами занимаемся какой-то деятельностью в окружающем мире, мы учимся отличать одни объекты от других и использовать их потом соответственным образом. Вот это — стул, на нем сидят, а вот это — яблоко, и его едят. Путем последовательного наблюдения нужного количества стульев и яблок мы учимся отличать их друг от друга по указаниям учителя, и таким образом обнаруживаем в мире какую-то неоднородность и структуру.
Так работает довольно большое количество моделей, которые мы называем **дискриминативными**. Если вы немного ориентируетесь в машинном обучении, то в дискриминативную модель можно попасть, ткнув пальцем наугад куда угодно — многослойные перцептроны, решающие деревья и леса, SVM, you name it. Их задача — присваивать наблюдаемым данным правильную метку, и все они отвечают на вопрос «на что похоже то, что я вижу?»
Другой подход, слегка совершенно отличающийся, состоит в том, что **понять — значит повторить**. То есть если вы пронаблюдали за миром какое-то время, а потом оказались в состоянии реконструировать его часть (сложить бумажный самолетик, например), то вы кое-что поняли о том, как он устроен. Модели, которые так делают, обычно не нуждаются в указаниях учителя, и мы называем их **порождающими** — это всевозможные скрытые Марковские, наивные (и не наивные) Байесовские, а модный мир глубоких нейросетей с недавних пор добавил туда restricted Boltzmann machines и автоэнкодеры.
Фундаментальная разница в этих двух вещах вот в чем: для того, чтобы воссоздать вещь, ты должен знать о ней более-менее все, а для того, чтобы научиться отличать одну от другой — совершенно необязательно. Иллюстрируется лучше всего вот этой картинкой:
Слева — то, что видит порождающая модель (у синего распределения сложная бимодальная структура, а красное сильнее сужено), а справа — то, что видит дискриминативная (только граница, на которой проходит водораздел между двумя распределениями, и она понятия не имеет о прочей структуре). Дискриминативная модель видит мир хуже — она вполне может заключить, что яблоки отличаются от стульев только тем, что они красные, и для ее целей этого вполне хватит.
У обеих моделей есть свои преимущества и недостатки, но давайте пока для нашей цели согласимся, что порождающая модель просто круче. Нам нравится идея понимать вещи целиком, а не попарно-сравнительно.
How do we generate
==================
Ну ладно, а как нам настроить эту порождающую модель? Для каких-то ограниченных случаев мы можем воспользоваться просто теорией вероятности и теоремой Байеса — скажем, мы пытаемся моделировать броски монетки, и предполагаем, что они соответствуют биномиальному распределению, тогда  и так далее. Для действительно интересных объектов вроде картинок или музыки это не очень работает — проклятье размерности дает о себе знать, признаков становится слишком много (и они зависят друг от друга, поэтому приходится строить совместное распределение...).
Более абстрактная (и интересная) альтернатива — предположить, что вещь, которую мы моделируем, можно представить в виде небольшого количества скрытых переменных или «факторов». Для нашего гипотетического случая денег это предположение выглядит вроде вполне интуитивно правильным — рисунок на купюре можно разложить на компоненты в виде номинала, серийного номера, красивой картинки, надписи. Тогда можно сказать, что наши исходные данные можно сжать до размера этих факторов и восстановив обратно, не потеряв смыслового содержимого. На этом принципе работают всевозможные [автоэнкодеры](https://en.wikipedia.org/wiki/Autoencoder), пытающиеся сжать данные и потом построить их максимально точную реконструкцию — очень интересная штука, про которую мы, правда, говорить не будем.
Еще один способ [предложил](http://arxiv.org/pdf/1406.2661v1.pdf) Иэн Гудфеллоу из Google, и заключается он вот в чем:
1) Мы создаем две модели, одну — порождающую (назовем ее фальшивомонетчиком), и вторую — дискриминативную (эта пусть будет банкиром)
2) Фальшивомонетчик пытается построить на выходе подделку на настоящие деньги, а банкир — отличить подделку от оригинала (обе модели начинают с рандомных условий, и поначалу выдают в качестве результатов шум и мусор).
3) Цель фальшивомонетчика — сделать такой продукт, который банкир не мог бы отличить от настоящего. Цель банкира — максимально эффективно отличать подделки от оригиналов. Обе модели начинают игру друг против друга, ~~где останется только один~~.
Обе модели будут нейронными сетями — отсюда название adversarial networks. Статья утверждает, что игра со временем сходится к победе фальшивомонетчика и, соотвественно, поражению банкира. Хорошие новости для преступного мира порождающих моделей.
Немного формализма
==================
Назовем нашего фальшивомонетчика  (или generator), а банкира —  (или discriminator). У нас есть какое-то количество оригинальных денег  для банкира, и пусть на выходе у него будет число диапазоном от нуля до единицы, чтобы оно выражало уверенность банкира в том, что выданные ему на рассмотрение деньги настоящие. Еще — поскольку фальшивомонетчик у нас нейронная сеть, ей нужны какие-то входные данные, назовем их . На самом деле это просто случайный шум, который модель будет стараться превратить в деньги.
Тогда, очевидно, цель фальшивомонетчика — это максимизировать , то есть сделать так, чтобы банкир был уверен, что подделки — настоящие.
Цель банкира посложнее — ему нужно одновременно положительно опознавать оригиналы, и отрицательно — подделки. Запишем это как максимизацию . Умножение можно превратить в сложение, если взять логарифм, поэтому получаем:
Для банкира: максимизировать 
Для фальшивомонетчика: максимизировать 
Это чуть менее чем вся математика, которая нам здесь понадобится.
Одномерный пример
=================
(почти целиком взят из этого замечательного [поста](http://evjang.com/articles/genadv1), но там — на TensorFlow)
Давайте попробуем решить простой одномерный пример: пусть наши модели имеет дело с обычными числами, которые сгустились вокруг точки  с небольшим размахом . Вероятность каждого встреченного числа оказаться где-то на числовой прямой можно представить нормальным распределением. Вот таким:
Соответственно числа, которые соответствуют этому распределению (живут в окрестности от -2) будут считаться «правильными» и «оригинальными», а остальные — нет.
Возьмем Theano и Lasagne, и зададим наши модели — простенькие нейронные сети с двумя слоями по десять нейронов каждый. При этом из-за механизма работы Theano (он строит символьный граф вычислений и позволяет в качестве входа дискриминатора задать одну конкретную переменную, а нам надо две — оригиналы и фальшивки) сделаем две копии дискриминатора: одна будет пропускать через себя «правильные» числа, а вторая — подделки генератора.
**Код**
```
import theano
import theano.tensor as T
from lasagne.nonlinearities import rectify, sigmoid, linear, tanh
G_input = T.matrix('Gx')
G_l1 = lasagne.layers.InputLayer((None, 1), G_input)
G_l2 = lasagne.layers.DenseLayer(G_l1, 10, nonlinearity=rectify)
G_l3 = lasagne.layers.DenseLayer(G_l2, 10, nonlinearity=rectify)
G_l4 = lasagne.layers.DenseLayer(G_l3, 1, nonlinearity=linear)
G = G_l4
G_out = lasagne.layers.get_output(G)
# discriminators
D1_input = T.matrix('D1x')
D1_l1 = lasagne.layers.InputLayer((None, 1), D1_input)
D1_l2 = lasagne.layers.DenseLayer(D1_l1, 10, nonlinearity=tanh)
D1_l3 = lasagne.layers.DenseLayer(D1_l2, 10, nonlinearity=tanh)
D1_l4 = lasagne.layers.DenseLayer(D1_l3, 1, nonlinearity=sigmoid)
D1 = D1_l4
D2_l1 = lasagne.layers.InputLayer((None, 1), G_out)
D2_l2 = lasagne.layers.DenseLayer(D2_l1, 10, nonlinearity=tanh, W=D1_l2.W, b=D1_l2.b)
D2_l3 = lasagne.layers.DenseLayer(D2_l2, 10, nonlinearity=tanh, W=D1_l3.W, b=D1_l3.b)
D2_l4 = lasagne.layers.DenseLayer(D2_l3, 1, nonlinearity=sigmoid, W=D1_l4.W, b=D1_l4.b)
D2 = D2_l4
D1_out = lasagne.layers.get_output(D1)
D2_out = lasagne.layers.get_output(D2)
```
Давайте нарисуем, как ведет себя дискриминатор — то есть для каждого числа, которое есть на прямой (мы ограничимся диапазоном от -5 до 5) отметим уверенность дискриминатора в том, что это число — правильное. Получим зеленую кривую на графике ниже — как видите, поскольку дискриминатор у нас не обучен, выдает он полную околорандомную ересь. И заодно попросим генератор выплюнуть какое-то количество чисел и нарисуем их распределение с помощью красной гистограммы:
И еще немного Theano-кода, чтобы сделать функции цены и начать обучение:
**Еще код**
```
# objectives
G_obj = (T.log(D2_out)).mean()
D_obj = (T.log(D1_out) + T.log(1 - D2_out)).mean()
# parameters update and training
G_params = lasagne.layers.get_all_params(G, trainable=True)
G_lr = theano.shared(np.array(0.01, dtype=theano.config.floatX))
G_updates = lasagne.updates.nesterov_momentum(1 - G_obj, G_params, learning_rate=G_lr, momentum=0.6)
G_train = theano.function([G_input], G_obj, updates=G_updates)
D_params = lasagne.layers.get_all_params(D1, trainable=True)
D_lr = theano.shared(np.array(0.1, dtype=theano.config.floatX))
D_updates = lasagne.updates.nesterov_momentum(1 - D_obj, D_params, learning_rate=D_lr, momentum=0.6)
D_train = theano.function([G_input, D1_input], D_obj, updates=D_updates)
# training loop
epochs = 400
k = 20
M = 200 # mini-batch size
for i in range(epochs):
for j in range(k):
x = np.float32(np.random.normal(mu, sigma, M)) # sampled orginal batch
z = sample_noise(M)
D_train(z.reshape(M, 1), x.reshape(M, 1))
z = sample_noise(M)
G_train(z.reshape(M, 1))
if i % 10 == 0: # lr decay
G_lr *= 0.999
D_lr *= 0.999
```
Используем здесь learning rate decay и не очень большой momentum. Кроме того, на один шаг генератора дискриминатор тренируется несколько шагов (20 в данном случае) — несколько мутный пункт, про который есть в статье, но не очень понятно, зачем. Мое предположение — это позволяет генератору не реагировать на случайные метания дискриминатора (т.е., фальшивомонетчик сначала ждет, пока банкир не утвердит для себя стратегию поведения, а потом пытается обмануть ее).
Процесс обучения выглядит примерно вот так:
Что происходит в этой гифке? Зеленая линия старается загнать красную гистограмму в синий контур. Когда граница дискриминатора в определенном месте опускается ниже 0.5, это означает, что для соответствующих мест числовой прямой дискриминатор подозревает больше подделок, чем оригиналов, и скорее будет выдавать отрицательные заключения (тем самым он практически заталкивает выбросы красных чисел ниже — посмотрите, например, на выброс справа от центра распределения через первые несколько секунд гифки).
Там, где гистограмма совпадает с контуром, кривая дискриминатора держится на уровне 0.5 — это значит, что дискриминатор больше не может отличить подделки от оригиналов и делает лучшее, что может в такой ситуации — просто рандомно выплевывает догадки с одинаковой вероятностью.
За пределами интересующего нас участка дискриминатор ведет себя не очень адекватно — например, положительно с вероятностью ~1 классифицирует все числа большие -1 — но это не страшно, потому что в этой игре мы болеем за фальшивомонетчика, и именно его успехи нас интересуют.
За этой парочкой любопытно наблюдать, играясь с разными параметрами. Например, если поставить momentum слишком большим, оба участника игры начнут слишком резко откликаться на обучающиеся сигналы и исправляют свое поведение так сильно, что делают еще хуже. Как-то так:
Целиком на код можно посмотреть [здесь](https://gist.github.com/rocknrollnerd/06bfed6b9d1bce612fd6).
Пример поинтереснее
===================
Ладно, это было не так уж плохо, но мы способны на большее, как намекает заглавная картинка. Попробуем новообретенные скиллы фальшивомонетчика на старых добрых рукописных цифрах.
Тут для генератора придется использовать небольшой трюк, который описан в статье под кодовым названием [DCGAN](http://arxiv.org/pdf/1511.06434.pdf) (им же пользуются Ларс и Сорен в заглавном посте). Он состоит в том, что мы делаем такую своего рода сверточную сеть наоборот (разверточную сеть?), где заменяем subsampling-слои, уменьшающие картинку в N раз, на upsampling-слои, которые ее увеличивают, а сверточные слои делаем в режиме «full» — когда фильтр выскакивает за границы картинки и на выходе дает результат больше, чем исходная картинка. Если для вас это мутно и неочевидно, [вот эта](http://cs231n.github.io/convolutional-networks/) страница за пять минут все прояснит, а пока можно запомнить простое правило — в случае обычной свертки картинки  фильтром  результат будет иметь сторону , а full convolution — . Это позволит нам начать с маленького квадратика шума и «развернуть» его в полноценное изображение.
**Некоторые технические непонятности**Вообще говоря, в статье сказано, что они рекомендуют убрать subsampling/upsampling слои вообще. Можете попробовать так сделать, хотя по-моему, получается слегка громоздко… Еще одна непонятность связана с тем, что свертки, которые у них используются — strided, т.е. делаются с шагом, большим 1. Для обычной свертки, вообще говоря, результат должен получаться как раз такой же, как при subsampling + обычная свертка (если я ничего не путаю), и соответственно, я решил, что upsampling + full convolution дадут аналогичный результат для нашей разверточной сети. При этом еще и происходит ужасная путаница с терминами — одна и та же штука в гугле называется «full convolution», «fractionaly-strided convolution» и даже «deconvolution». Авторы DCGAN говорят, что deconvolution — неправильное название, но в их же [коде](https://github.com/Newmu/dcgan_code/blob/master/lib/ops.py) использовано именно такое… в общем, в какой-то момент я махнул рукой и решил, что работает — и ладно.
Код генератора для цифр MNIST выглядит примерно как под спойлером. Дискриминатором будет какая-нибудь самая простая сверточная сеть. Если честно, я один-в-один содрал ее из readme к Lasagne, и даже не буду здесь приводить.
**Больше кода**
```
G_input = T.tensor4('Gx')
G = lasagne.layers.InputLayer((None, 1, NOISE_HEIGHT, NOISE_WIDTH), G_input)
G = batch_norm(lasagne.layers.DenseLayer(G, NOISE_HEIGHT * NOISE_WIDTH * 256, nonlinearity=rectify))
G = lasagne.layers.ReshapeLayer(G, ([0], 256, NOISE_HEIGHT, NOISE_WIDTH))
G = lasagne.layers.Upscale2DLayer(G, 2) # 4 * 2 = 8
G = batch_norm(lasagne.layers.Conv2DLayer(G, 128, (3, 3), nonlinearity=rectify, pad='full')) # 8 + 3 - 1 = 10
G = lasagne.layers.Upscale2DLayer(G, 2) # 10 * 2 = 20
G = batch_norm(lasagne.layers.Conv2DLayer(G, 64, (3, 3), nonlinearity=rectify, pad='full')) # 20 + 3 - 1 = 22
G = batch_norm(lasagne.layers.Conv2DLayer(G, 64, (3, 3), nonlinearity=rectify, pad='full')) # 22 + 3 - 1 = 24
G = batch_norm(lasagne.layers.Conv2DLayer(G, 32, (3, 3), nonlinearity=rectify, pad='full')) # 24 + 3 - 1 = 26
G = batch_norm(lasagne.layers.Conv2DLayer(G, 1, (3, 3), nonlinearity=sigmoid, pad='full')) # 26 + 3 - 1 = 28
G_out = lasagne.layers.get_output(G)
```
Результат оказывается примерно такой.
Не то чтобы идеально, но что-то определенно похожее. Забавно наблюдать, как генератор *сначала* учится рисовать похожими штрихами, а потом приличное время борется с тем, чтобы составить из них правильную форму. Например, вот здесь выделенные символы не похожи на цифры, но при этом явно представляют собой какие-то символы, то есть генератор пошел правильной дорогой:
Едем дальше — берем базу лиц [LFW Crop](http://conradsanderson.id.au/lfwcrop/), для начала уменьшаем лица до размера MNIST (28x28 пикселей) и пытаемся повторить эксперимент, только в цвете. И сразу замечаем несколько закономерностей:
1) Лица тренируются хуже. Количество нейронов и слоев, которое я тут приводил для MNIST, взято слегка с запасом — его можно уполовинить, и будет получаться неплохо. Лица при этом превращаются в непонятное рандомное месиво.
2) Цветные лица тренируются еще хуже — что объяснимо, конечно, информации становится в три раза больше.
3) Приходится иногда корректировать взаимное поведение генератора и дискриминатора: случаются ситуации, когда один загоняет другого в тупик, и игра останавливается. Обычно это происходит в ситуации, когда, скажем, дискриминатор оказывается мощнее в репрезентативном смысле — он может понимать такие тонкие детали, которые генератор еще (или вообще) не в состоянии различить. В опять-таки заглавном посте описано несколько эвристик (замедлять дискриминатор, когда он получает слишком хорошие оценки и т.д.), но у меня все достаточно неплохо работало и без них — хватало один раз в начале обучения подправить настройки и число нейронов.
И результат:
Неплохо-неплохо, но я все еще хочу что-нибудь такого же качества, как на КДПВ!
Полноразмерный пример и блуждания в пространстве рецептов
=========================================================
Я нагрузил опечаленную GT 650M полноразмерным (64x64) LFW Crop и оставил на ночь. К утру прошло примерно 30 эпох (на 10000 лиц), и конечный результат выглядел вот так:
Прелесть какая. Если кому нужны портреты персонажей для зомби-апокалипсиса, дайте знать! У меня их много.
Качество получилось не очень, но произошло что-то похожее на ту ситуацию с MNIST — наш генератор научился справляться с визуальными шумами и расплывчатостью, нормально рисовать глаза, носы и рты, и теперь у него проблема под названием «как их правильно совместить».
Давайте теперь подумаем еще раз, что у нас нарисовалось. Все эти лица выплевывает одна и та же сеть, а нейронная сеть — это насквозь детерминированная штука, просто последовательность умножений и сложений (и нелинейностей, ну ладно). Я не добавлял в генератор никакой рандомизации, dropout'а и т.д. Так каким образом лица получаются разные? Очевидно, единственный источник рандома, которым сеть может руководствоваться — это тот самый входной шум, который мы раньше обозвали «бессмысленным» параметром. Теперь выясняется, что он оказывается довольно важным — в этом шуме закодированы все параметры выходного лица, а все, что делает остальная сеть — это просто читает входной «рецепт» и в соответствии с ним наносит краску.
И рецепты не дискретны (я об этом не успел сказать, но в качестве шума бралось простое равномерное распределение чисел от 0 до 1). Правда, мы все еще не знаем, какое число в рецепте что именно кодирует, хм — и даже «кодирует ли что-нибудь осмысленное какое-то одно число?». Ну ладно, и зачем нам тогда это все?
Во-первых, зная теперь, что входной шум — это рецепт, мы можем им управлять. Равномерный шум, скажем прямо, был не очень хорошей идеей — теперь каждый кусочек шума может кодировать что угодно с одинаковой вероятностью. Мы можем подать на вход, скажем, нормальный шум (распределенный по Гауссу) — тогда значения шума, близкие к центру, будут встречаться часто и кодировать что-нибудь общее (типа цвета кожи), а редкие выбросы — что-нибудь особенное и редкое (например, очки на лице). Люди, писавшие статью про DCGAN, [нашли](https://github.com/Newmu/dcgan_code) несколько семантических кусков рецепта, и использовали их для того, чтобы надевать лицам очки или заставлять их хмуриться по желанию.
Во-вторых… видели мем на тему [«image enhancing»](http://static.fjcdn.com/pictures/Csi_3c4720_195814.jpg) из сериала CSI? Вещь над которой долго смеялись все люди, сколь-либо знакомые с компьютерами: могущественный алгоритм ФБР волшебным образом повышает разрешение картинки. Так вот, возможно, нам еще придется взять свои слова обратно, потому что а почему бы нам немного не облегчить жизнь нашему генератору, и вместо того, чтобы подавать на вход шум, подать, скажем, *уменьшенный* вариант нашего оригинала? Тогда вместо того, чтобы рисовать лица из головы, генератору всего лишь надо будет их «дорисовать» — а эта задача явно выглядит проще, чем первая.
У меня, к сожалению, не дошли до этого руки, но вот тут есть отличный [пост](https://swarbrickjones.wordpress.com/2016/01/13/enhancing-images-using-deep-convolutional-generative-adversarial-networks-dcgans/), демонстрирующий, как это делается с впечатляющими иллюстрациями.
Ну и в-третьих, можно немного поразвлечься. Раз мы знаем, что рецепты не дискретны, то существуют переходные состояния между любыми двумя рецептами. Берем два вектора шума, интерполируем их и скармливаем генератору. Повторяем, пока не надоест, или пока люди в комнате серьезно не начнут беспокоиться, зачем вы так пристально разглядываете агонизирующих зомби.
Заключение
==========
1) Adversarial networks — это весело.
2) Если вы решите попробовать тренировать их сами — проще подсмотреть готовые рецепты, чем играться с параметрами.
3) Иошуа Бенджио [назвал](https://www.quora.com/What-is-the-most-exciting-machine-learning-research-paper-you-read-in-2015) DCGAN и LAPGAN (это который image enhancing) в числе самых впечатляющих штук в машинном обучении 2015 года ~~и именно после этого я полез про них читать, само собой~~
4) В еще одном блоге был на днях хороший [пост](http://www.inference.vc/deep-learning-is-easy/) на тему «deep learning is easy, try something harder» — как раз для людей ~~вроде меня~~, которые зацепились за популярную тему и не очень понимают, куда двигаться дальше. Adversarial networks — хороший вариант (и тоже упоминается в посте как одно из новых перспективных направлений), потому что тут куча всего интересного, и контроль над рецептами только одна из самых напрашивающихся вещей.
5) Как перевести «adversarial networks» на русский язык? «Враждующие сети»? «Соперничающие сети»? | https://habr.com/ru/post/275429/ | null | ru | null |
# VINTEO Server — корпоративная видеоконференцсвязь высшего класса. Установка, настройка, полное описание
В прошлой статье, [**Обучение, переговоры, консультации удалённо — Часть 2: Vinteo Server — 3 месяца бесплатной видеоконференцсвязи**](https://habr.com/ru/company/stss/blog/495216/), я немного описал особенности и функционал уникального российского решения ВКС Vinteo Server.
Эта статья является подробным руководством по установке и настройке сервера Vinteo на Вашей аппаратной платформе. Если Ваша компания в период принудительной удалёнки отчаялась в выборе оптимального корпоративного сервиса видеоконференцсвязи, то самое время протестировать российское решение ВКС премиального уровня Vinteo.
К тому же, продолжается акция «3 месяца бесплатной видеоконференцсвязи», описанная в прошлой статье.
Сервер Vinteo – это программное ядро системы видеоконференцсвязи и коммуникаций. Решение поддерживает все открытые стандарты связи, включая H.323, SIP и WebRTC, и обеспечивает протокольную и функциональную совместимость с доступным на рынке оборудованием ВКС от ведущих вендоров в данной области. Vinteo позволяет не только организовать сеть конференцсвязи с нуля, но также расширить возможности уже имеющейся в инфраструктуре системы ВКС любого вендора.
Одними из уникальных особенностей решения **Vinteo** являются **персональные раскладки** для каждого участника, а также **функция синхронного перевода**.
Функциональные возможности
--------------------------
* Трансляция сеансов ВКС с индивидуальной раскладкой
* Запись всех сеансов ВКС с индивидуальной раскладкой
* Активация по голосу в асимметричной раскладке
* Индивидуальные и общие раскладки для всех участников
* Ручное и автоматическое управление раскладками
* Обширный функционал администратора/модератора конференции
* Подключение к конференции IP-камер и видео контента
* Поддержка H.239, BFCP, второго видеопотока для WebRTC, VNC
* Множество автоматических и ручных сценариев подключения
* Расписание и автоматический сбор ВКС
* SIP Registrar и H.323 Gatekeeper
* Интеграция с любыми серверами ВКС/АТС по SIP/H.323
* Глубокая интеграция с УПАТС по SIP, H.323, ISDN PRI
* Перенос участников из конференции в конференцию «на лету»
* Функция синхронного перевода с использованием настраиваемых аудио каналов
* Каскадирование для повышения отказоустойчивости и производительности
Установка сервера ВКС Vinteo
----------------------------
Программное решение Vinteo Server разработано и оптимизировано для максимально эффективной работы на [аппаратных платформах](https://vc4u.ru/catalog/servery_vcs/servery_vinteo/) с использованием многоядерных CPU и GPU.
Ориентировочные системные требования выглядят следующим образом:
* Для реализации многоточечных конференций на 10 HD-подключений потребуется не менее 3 физических ядер совместно с видеокартой Quadro P2000, или не менее 6 ядер без использования видеоадаптеров.
* Если разрешение этих 10 подключений увеличить до Full HD, то потребуется использование графической платы уровня RTX4000 или Tesla P4 совместно с 10-ядерным центральным процессором, поколения не старше V3/V4. Без видеоадаптера потребуется использование 18-ядерного CPU.
Для инсталляции Vinteo на физический сервер потребуется программа для монтирования образа на USB-накопитель, например [Rufus](https://rufus.ie/)
#### Установка дистрибутива
Необходимо скачать загрузочный образ [Vinteo Server](https://download.vinteo.com/) и смонтировать на флешку.
**Процесс установки**
Запускается установщик
Читаем предупреждения и запоминаем IP-адрес сервера, для дальнейшей настройки через web
Принимаем условия лицензионного соглашения
Выбираем физический диск для установки
Соглашаемся потерять все данные на диске
Ждём полного развёртывания образа
Перезагружаем сервер, предварительно отключив устройство с загрузочным образом.
Идём в web-интерфейс по адресу 10.0.0.10 для дальнейшей настройки и эксплуатации.
#### Настройка и администрирование
Из консоли сервера Vinteo можно изменить настройки сетевых интерфейсов.
Для этого воспользуйтесь командой `**st defult intrfce**`
Затем Вам будет представлен поэтапный диалог для изменения настроек:
`**#intname>**` ввести имя сетевого интерфейса для изменения
`**#ipaddr>**` ввести новый IP адрес для выбранного соединения
`**#mask>**` ввести маску сети
`**#gw>**` ввести IP адрес шлюза
В системе изначально не установлен действующий сертификат, поэтому при входе в веб-интерфейс сервера Vinteo, браузер потребует подтвердить свои намерения.
**Классическое уведомление от Google Chrome**
После удачного перехода по адресу сервера отображается универсальная форма доступа, c помощью которой можно войти не только в интерфейс администрирования, но также есть возможность анонимно подключится к трансляции, или же войти в веб-клиента, а уже через интерфейс пользователя присоединиться к конференции.
В верхнем правом углу доступна языковая панель, для выбора региональной адаптации интерфейса.
По умолчанию для входа следует воспользоваться парой:
Логин: `admin`
Пароль: `123`
Главная страница интерфейса управления выглядит следующим образом:
На этой странице детально отображается информация о состоянии сервера, которая включает:
* Количество созданных конференций
* Количество зарегистрированных абонентов
Информация о центральном процессоре включает:
* Модель установленных процессоров и их номинальную частоту
* Количество вычислительных потоков (учитывая Hyper-Threading)
* Общую загрузку вычислительной подсистемы в процентах
Для жёсткого диска доступны данные:
* Производитель и модель
* Общий полезный объём накопителя
* Свободный доступный объём
По ОЗУ: Общий и свободный объём.
Информация о клиенте:
* Тип и версия браузера
* Разрешение экрана
* IP-адрес клиента
* Ширина канала
Эта информация может стать очень полезной для диагностирования каких-либо затруднений в работе системы. Например, тестирование пропускной способности канала от сервера до клиента может исключить многие причины при проблемах качества связи.
Далее идёт перечень активных веб-трансляций и конференций, которыми можно управлять.
Ниже находится окно статуса загрузки сетевых интерфейсов, а также перечень и загрузка видеоадаптеров.
#### Абоненты
Абоненты — это клиенты сервера ВКС Vinteo.
Управление абонентами включает следующие действия:
* Создание абонента
* Создание нескольких абонентов
* Добавление абонентов в конференцию
* Удаление абонентов
Существует 4 типа абонентов сервера Vinteo:
* **SIP** – программный клиент или аппаратный терминал ВКС с подключением по протоколу SIP
* **H.323** — программный клиент или аппаратный терминал ВКС с подключением по протоколу H.323
* **WS** — участник с подключением через браузер с использованием WebRTC
* **Loop** — участник-абонент удаленного сервера, с которым настроено соединение — например абонент цифровой АТС, Lync/Skype for Business, Asterisk)
**Основные настройки**
1. В поле **«Тип»** выбрать метод подключения абонентского оборудования.
2. В поле **«Номер»** ввести идентификационный номер абонента. Номер может содержать
цифры и буквы латинского алфавита, по умолчанию сервер предлагает номера по порядку от номера 100. Номер также является логином для регистрации абонентского оборудования на сервере, а также логином для доступа к личному кабинету абонента на сервере Vinteo
3. В поле **«Имя»** ввести информацию об абоненте
4. В поле **«Пароль»** ввести пароль или нажать кнопку «Сгенерировать»
5. В поле **«Конференция»** можно выбрать уже существующие комнаты конференций для автоматического добавления абонента к ним
6. В поле **«E-mail»** ввести электронный адрес абонента, данное поле используется сервером для отправки уведомлений на почту о запланированных конференциях, а также уведомления-напоминания о скором начале видеоконференции, в которой принимает участие абонент
7. В поле **«Пропускная способность канала»** предлагается выбрать ширину канала передачи данных от абонентского оборудования до сервера Vinteo. Этот параметр влияет на скорость подключения по умолчанию, при подключении к конференции. По умолчанию этот параметр имеет значение 512 Кбит/сек, что соответствует максимальному разрешению 640 х 360 точек при подключении к комнатам конференций
8. В поле **«Разрешение в режиме P2P»** необходимо выставить разрешение видео абонента с которым будет происходить соединение в режиме точка-точка
9. Переключатель **«Находится за NAT»** включает или отключает технологию трансляции сетевых адресов при подключении абонента к серверу
**Расширенные настройки**
1. Поле **«IP»** заполняется IP-адресом абонента в случае подключения абонента по протоколу SIP в режиме «без регистрации» или по протоколу «H.323» в режиме «без регистрации на gatekeeper». В режиме регистрации — это поле по умолчанию имеет значение dynamic
2. Поле **«Порт»** содержит номера портов подключаемого абонента. SIP – порт 5060, H.323 – порт 1720
3. Поле **«Транспорт»** определяет протокол передачи данных для подключения SIP-абонентов и передачи видео и аудио потоков для них. Значения: UDP или TCP
4. Поле «Insecure» определяет параметр подключения абонента по протоколу SIP. Значения данного поля:
* **Port** – разрешает проверку IP-адреса подключаемого абонента без проверки соответствия номера порта с которого пришел запрос
* **Invite** – позволяет не требовать аутентификации входящих сообщений «Invite» от абонента
* **Very** – игнорирует авторизацию (пользователь/пароль)
5. Функция **«Qualify»** позволяет включать/отключать отправку сообщений «Options» оборудованию абонентов, подключенных по протоколу SIP, для проверки что данный абонент находится в режиме подключения и доступен для совершения вызовов
6. Поле **«Кодеки»** содержит список поддерживаемых устройством абонента аудио и видео кодеков. В интерфейсе доступные для подключения абонента кодеки представлены в виде двух списков, в правом списке находятся определенные для подключения кодеки, а в левом списке доступные для добавления. Перенос кодеков осуществляется одинарным кликом по имени кодека
7. Параметр **«H.264 High Profile»** может быть включен только у абонентов, у которых выбран кодек H.264. Абонентское устройство должно поддерживать этот стандарт. По умолчанию функция отключена
8. Функция **«Проключать медиа потоки до ответа»** позволяет включать передачу медиапотоков от сервера до ответа абонента (параметр FastStart)
9. Параметр **«DTMF mode»** определяет метод передачи DTMF сигнала от абонента
10. Параметр **«Настройка видео потока»** позволяет принимать видео поток от IP-камер для того чтобы при необходимости подменить или предоставить сторонний видео поток от абонента к серверу
11. Параметр **«BFCP»** позволяет указать протокол передачи данных (UDP/TCP), который будет использовать сервер для передачи второго видео потока в протоколе SIP
12. Параметр **«Media Encryption»** позволяет включить или отключить шифрование медиа потоков SRTP в протоколе SIP
13. Переключение параметров **«Skype4B»** является обязательным для абонентов «Skype для Бизнеса»
14. Для сохранения внесенных изменений необходимо нажать кнопку **«Добавить»**
**Аватар**
Это графическое изображение участника конференции. Оно может быть назначено абоненту сервера для отображения изображения вместо видеопотока, если участник назначен на экране конференции, но не подключен или подключен в режиме «только звук».
**Создание нескольких абонентов**
Процедура создания нескольких абонентов аналогична процедуре созданию нового абонента с той лишь разницей, что модальное окно «Добавить несколько абонентов» в поле номер будет содержаться два значения с какого и по какой номер будет создана группа абонентов.
**Редактирование параметров абонента**
При редактировании параметров абонента доступны основные и расширенные настройки, идентичные настройкам создания новых абонентов, исключением составляет невозможность изменить значение поле «Тип» и «Номер», если
возникает подобная необходимость, то необходимо удалить абонентов с неверным типом или номером и пройти повторно процедуру создания абонента.
**Добавление абонентов в конференцию**
**Страница «Группы»**
В Vinteo реализована возможность группировки абонентов в виртуальные группы, что позволяет добавлять абонентов к конференции заранее определенным набором участников.
Для добавления существующих абонентов к группе следует:
1. В основном меню конфигурации из раскрывающегося списка «Абоненты», необходимо выбрать пункт меню
«Список» — откроется страница «Список абонентов»
2. Нажать на имя существующего абонента
3. Выбрать из списка «Группа», созданную ранее группу абонентов
4. Нажать кнопку «Сохранить»
#### Конференции
В Vinteo реализована возможность проведения одновременно нескольких независимых видеоконференций. Каждая видеоконференция имеет свой настраиваемый профиль.
Настройка сервиса **«Конференции»** включает выполнение следующих операций:
**Создание конференции**
Для создания новой конференции следует в основном меню выбрать пункт «Конференции». Нажать кнопку «Добавить новую конференцию» в правом верхнем углу страницы.
1. В поле **«Номер»** ввести номер конференции по которому будет осуществляться дозвон в комнату конференции
2. В поле **«Описание»** при необходимости ввести описание конференции
3. В списке **«Модераторы»** при необходимости выбрать модератора конференции, который будет осуществлять управление конференцией из личного кабинета на сервере Vinteo
4. Нажать кнопку **«Добавить»**
**Управление конференцией**
Страница визуально разделена на три части:
**Информационная часть** расположена в верхнем правом углу и отображает текущий статус конференции, нагрузку ЦПУ и время работы конференции,
а также предоставляет доступ к некоторым функциям:
* **Быстрый набор** — Позволяет вызвать абонента не из списка абонентов по IP-адресу либо SIP/H.323 URI адресу, выбрать разрешение подключаемого участника, ширину канала и количество кадров в секунду. Данный абонент будет подключен до окончания разговора с ним, и не будет сохранен в дальнейшем в списке участников конференции.
* **Добавить участника** — Позволяет создать нового, выбрать существующего или переместить абонента, а также добавить заранее созданную группу абонентов. Для создания нового абонента используется только базовые настройки абонента: «Тип», «Номер», «Имя абонента», «Пароль абонента» и «IP-адрес». После создания абонента его можно вызвать как участника после нажатия кнопки «Добавить». Для добавления существующего абонента можно воспользоваться строкой «Поиск» и выбрать необходимого абонента.
Для перемещения абонента из другой активной конференции, выбираем из списка «Конференция» конференцию, затем из списка «Участники» активного участника и нажимаем кнопку «Добавить». Участник будет вызван автоматически. Для добавления группы абонентов выберите из списка «Группа» группу абонентов и нажимаем кнопку «Добавить». Участники будут вызваны автоматически.
* **Проигрыватель** — Позволяет добавлять загруженные ранее видеоролики. Выберите из списка «Видеоролик» необходимый файл, если требуется включите функцию «Включить автоповтор» и нажмите кнопку «Добавить». Без включенной функции «Автоповтор» видеоролик будет проигрываться до завершения ролика и будет отключен от конференции.
* **Видеопоток** — Позволяет добавлять потоковое видео из различных источников по протоколам HTTP и RTSP. Для добавления введите понятное описание в поле «Описание потока», в поле «URL видеопотока» введите адрес потока и нажмите кнопку «Добавить».
Например, для подключения потокового видео с камеры CCTV Beward требуется ввести адрес такого формата:
`rtsp://XXX.XXX.XXX.XXX:YYY/user=[пользователь]&password=[пароль]&channel=1&stream=[видеопоток]`
+ **ХХХ.ХХХ.ХХХ.ХХХ** – сетевой адрес устройства
+ **YYY** – порт RTSP потока, заданный в конфигурации устройства (по умолчанию: 554)
+ **Пользователь** – администратор устройства с правом просмотра потока
+ **Пароль** – пароль администратора устройства
+ **Видеопоток** – цифровой номер потока, если Ваше устройство имеет более одного потока (0 = основной поток)
* **Сообщение** — Позволяет вывести сообщение на экран. Введите текст сообщения в поле и выберите сколько секунд показывать данное сообщение, нажмите кнопку «Отправить». Данное сообщение будет показано всем участникам конференции.
**Навигационная часть** расположена под информационной частью, позволяет выполнять переход к страницам «Настройки», «Раскладка» и «Участники», а также показывает максимальную ширину канала, количество подключенных участников и срок действия
конференции, если таковой установлен.
**Основная часть** расположена под навигационной частью и позволяет увидеть список участников, а также провести быстрые настройки таких функций как:
**Запись**
Кнопка разделена на две части, левая часть включает/выключает запись конференции, правая часть дает доступ к настройкам записи. При нажатии на кнопку «Запись» будет произведена запись конференции с настройками по умолчанию, при следующем включении конференции запись будет произведена снова.
В основных настройках записи можно изменить разрешение записи микшированного видеопотока, а также отключить запись видео.
В настройках раскладок можно изменить раскладку для записи, не затрагивая раскладку конференции, либо оставить автоматическое распределение участников.
**Лектор**
Данная кнопка управляет включением режима «Видеоселектор», при включении на кнопке появится идентификатор текущего участника, назначенного лектором.
**Мозаика**
Данная кнопка управляет видом мозаики, количеством одновременно отображаемых участников.
**Расположение**
Данная кнопка открывает окно с изображением выбранной пронумерованной раскладки и актуальным списком участников занимаемых соответствующие позиции, которая изменяется в режиме онлайн при перемещении участников в раскладке.
Это окно информационное — оно не позволяет изменять расположение, а лишь отражает текущее состояние раскладки в конференции.
Менять расположение участников «на лету» можно в настройках раскладки конференции.
**Презентация**
Кнопка разделена на две части, левая часть включает\выключает видео поток с презентацией, правая часть дает доступ к настройкам отображение презентации.
В настройках доступно два режима, как «Сервер VNC», так и режим «Клиент VNC».
Настройки при режиме подключения «Server»:
* **Источник презентации** – доступен VNC протокол
* **VNC IP** – адрес в формате IPv4
* **VNC порт** – порт, на котором удаленный сервер «слушает» входящие соединения
* **VNC пароль** – пароль от удаленного сервера VNC.
Настройки доступные при режиме подключения «Client»:
* **Порт ожидания подключения** – порт на котором требуется включить прослушивание входящих соединений
**Веб-трансляция**
Кнопка разделена на две части, левая часть включает\выключает трансляцию, правая часть даёт доступ к настройкам отображения трансляции.
Настройки веб-трансляции имеют 4 закладки:
* **HLS** (HTTP Live Streaming)
* **Multicast**
* **YouTube**
* Пользовательский режим
В закладке «Раскладка» можно выбрать индивидуальную раскладку для трансляции.
**Список участников**
Список участников имеет меню настроек списка в котором также присутствует возможность добавить участника, изменить отображаемое количество участников, фильтрация участников по их статусам, включение дополнительной информации по участникам, а также изменения режима отображения списка. Отображение информации происходит в режиме реального времени.
Также в этом списке доступно контекстное меню при нажатии на участника конференции. Из данного меню можно выполнить следующие действия:
При не активном статусе участника:
* **Вызвать** – нажатие этого пункта вызывает участника конференции
* **Удалить** – нажатие этого пункта удаляет участника конференции
При активном статусе участника:
* **Отключить** – отключает участника от текущей конференции и переводит его в статус не активных участников
* **Выключить микрофон** – отключает исходящий аудио поток от участника
* **Назначить лектором** – назначает этого участника лектором, обводит его видео желтой рамкой
* **Выключить камеру** – выключает исходящий видео поток от участника
* **Выключить звук** – выключает входящий аудио поток к участнику
* **Выключить видео** – выключает входящий видео поток к участнику
* **Показать участника** – выводит видео поток участника на предварительно
зарезервированную для него позицию на раскладке мозаики
* **Показать скриншот** – выводит скриншот видеопотока от данного участника и помещает его слева от имени участника
* **Показать, как презентацию** – выводит входящий видео поток от участника на экран как презентацию
* **Переместить** – выводит диалоговое окно с активными конференциями для перемещения участника в любую из них
* **Свойства** – выводит всплывающее окно с техническими сведениями об участнике (его разрешение, видео кодек, аудио кодек, FPS, RATE, H.239, fpsDV, rateDV, потери, JB), а также позволяет в пункте «Параметры» изменить громкость звука к и от участника
В закладке **«Аудио каналы»** можно настроить функционал **синхронного перевода**.
Для каждого участника можно задать канал входящего и исходящего аудио потока. Таким образом можно реализовать синхронный перевод на несколько языков в рамках одной видеоконференции. Для этого достаточно согласовать и применить индивидуальные настройки для каждого участника. Например: русский язык — это канал номер 1, английский — 2, японский — 3 и т.д. Мы имеем, например, русско-английского переводчика и англо-японского.
В настройках русскоязычной публики и входящим и исходящим каналом будет номер 1. Для англоязычной — 2, для японской аудитории — 3 соответственно. Русско-английский переводчик находится в конференции без видео, на вход получает 1-й аудио канал, на выход 2-й. Англо-японский синхропереводчик — на вход 2-й, на выход — 3-й. Таким образом все участники, кроме закадровых переводчиков будут слышать речь оппонентов только на своём языке!
**Отображение**
Отображение списка участников в виде строк позволяет отразить статусы, а также в этом виде доступен вывод дополнительных параметров подключения, таких как потери, количество передаваемых кадров в видеопотоках, актуальный битрейт видеопотоков и т.д.
Стандартные статусы выводят следующую информацию подключения участника:
* Статус подключенного участника — строка с подключенным участником окрашена градиентом светло-зеленого цвета
* Время подключения участника
* Текущий лектор – статус лектора выделяется светло-голубым цветом среди подключенных участников
* Видеоразрешение подключения к серверу участника конференций — стрелка перед значением указывает направление потока, если вместо значения появляется прочерк – это означает, что видеопотока нет. Аналогичным образом строятся остальные статусы
* Используемые видеокодеки подключения участника конференций
* Используемые аудиокодеки подключения участника конференции
Расширенные статусы выводят следующую информацию подключения участника:
* Количество кадров в секунду в видеопотоках участника
* Текущее значение полосы пропускания, занимаемое основным потоком видеоданных
* Статус приема/отправки потока контента по протоколам H.239, BFCP
* Количество кадров в секунду в видеопотоке контента по протоколам H.239, BFCP
* Текущее значение полосы пропускания, занимаемое дополнительным видеопотока для передачи контента по протоколам H.239 и BFCP
* Количество потерянных пакетов и общий процент потерь в настоящий момент времени в передаче видеопотоков участника
* Значение адаптивного джитер-буфера сервера для конкретного участника, значение измеряется в миллисекундах и отражает состояние канала передачи данных от участника к серверу, чем выше этот показатель, тем больше задержка видеоизображения у данного участника
* Сервер подключения участника в случае если используется каскадирование
**Настройки конференции**
Данная конфигурационная страница разделена на четыре группы настроек:
**Основные**
* **Конференция** – номер настраиваемой конференции
* **Описание** – в данном поле указывается описание конференции
* **Модераторы** – позволяет назначить модераторов конференции из списка абонентов сервера
* **ПИН-код** – задает пин-код конференции для анонимных абонентов
**Настройки вызова**
* **Длительность вызова участника** – задает временной интервал в секундах, в течении которого сервер будет осуществлять вызов участников
* **Количество попыток вызова** – задает число попыток вызова участников, если участник занят или не отвечает
* **Интервал между вызовами** – определяет интервал между попытками вызова участников
**Настройки подключений по-умолчанию для анонимов**
* **Ширина канала**
* **Разрешение**
* **FPS**
Это значения применяемые к анонимным участникам при отсутствии индивидуальных настроек.
**Свойства конференции**
* **Не выключать конференцию** – позволяет держать конференцию включенной
все время
* **Открытая конференция** – включает возможность дозваниваться анонимным пользователям без ввода ПИН-кода
* **Перезванивать самостоятельно отключившимся** – включается при необходимости серверу самостоятельно вызывать тех участников конференции, которые были отключены после обрыва соединения с участником
* **При подключении микрофон выключен** – позволяет отключать на сервере микрофон всем вызванным участникам. Включить микрофон участникам сможет только администратор/модератор конференции
* **Вызвать участников при входе модератора** – настройка автоматизирует процесс вызова участников. Если настройка включена, то сервер автоматически произведет вызов всех участников, как только модератор зайдет в эту конференцию. Если Модератор не подключен в конференцию, то сервер откажет в подключении рядовым участникам
* **Отключить участников при выходе модератора** – переключатель позволяет автоматизировать завершение конференции. При отключении последнего модератора от конференции сервер автоматически отключит всех рядовых участников
* **Показывать скриншоты после подключения участников** – включает возможность показа изображения от всех участников на экране управления конференцией
* **Включить логирование раскладки** — активирует сохранение изменений в процессе конференции
**Свойства раскладок**
* **Персональная раскладка лектора** – задает индивидуальную раскладку для участника, определяемого как «лектор», если в расположении раскладки выбрана позиция с значением лектор.
*При включении режима персональной раскладки лектора позиция «Предыдущий лектор», будет переведена в значение «Авто»*
* **Автоматические назначенные панели** – режим, который позволяет заполнять назначенные панели, до подключения участников назначенных на эти панели
* **Дублирование панелей** – включает возможность дублирования участника в панель «Лектор»
* **Не отображать собственное видео** – режим, который исключает отображение в общей раскладке собственного видео участника (не видеть себя в общей раскладке).
*Включение режима «Не отображать собственное видео» автоматически отключает режимы
«Автоматические назначенные панели» и «Дублирование панелей». Многослойные раскладки будут недоступны для использования*
* **Отображать участников без видео** – включает возможность отображать участников без видеопотока в общей раскладке
* **Приоритет режима лектора** – настройка определяет приоритет режима лектора перед персональными раскладками. Если настройка активна, то в режиме Лектор абсолютно все участники будут видеть лектора на весь экран.
*Настройка «Приоритет режима лектора» является офлайн настройкой, должна быть определена до начала конференции. Во время конференции изменения этой настройки не изменит поведение раскладок в конференции*
* **Не занимать позицию лектор назначенным панелям** – настройка, которая отменяет перемещение на позицию лектора для участников, конкретно назначенных на панелях раскладки
* **Включить титры** – включение анимированных графических подписей для участников, которые становятся лекторами.
*Логика появления титров на участнике: Титр появляется на участнике, который сервер считает лектором (назначенный администратором участник или активный по голосу, если определение лектора происходит в автоматическом режиме)*
* **Включить автоматические сообщения** – настройка, которая выводит на экран конференции поверх изображения участников текстовые сообщения о подключении или отключении участников в конференции
* **Презентация без мозаики** – настройка позволяющая передавать контент в виде мозаики с совмещением изображения общей раскладки и презентации. Данная настройка предназначена для отображения режима презентации в записи, трансляции и для участников, которым отключен дополнительный видеопоток презентации или отсутствует возможность принимать контент в дополнительном потоке
* **Отображать участников в формате 16:9** — кадрирование видео потоков от участников в формате 16:9
* **Рамки участников** — активирует для всех участников рамку
* **Индикация записи конференции** — отображает красную рамку вокруг экрана при включении записи конференции
* **Конфиденциально** — активирует всплывающую надпись с пиктограммой «Конфиденциально»
* **Отображать watermark** — настройка, которая позволяет отображать подписи для участников находящихся в раскладке конференции
**Страница Раскладка**
Данная страница позволяет произвести настройку общей мозаики конференции, выбрать нужную раскладку, расположить участников на экране, определить системные позиции для лектора или прокрутки участников и т.д.
Страница отображает в левой верхней части выбранную мозаику, ниже доступные для выбора раскладки. В правой верхней части страницы расположены элементы назначения панелей, кнопка установление всех позиций в авто и поле поиска позиции (панели).
Для определения значения панели достаточно установить курсор в поле соответствующей панели, после чего появится список доступных значений и участников, в данном списком зеленым цветом выделены и отсортированы подключенные участники для удобства выбора. Набор в поле значения панели содержит элемент поиска, который оставляет в списке доступных значений, только те значения, которые имеют частичное или полное совпадение, поиск происходит по номеру участника, по имени участника и по ip-адресу участника.
Варианты доступных значений для каждой панели в выбранной раскладке:
* **auto — Автовыбор** — добавляет в ячейку мозайки участника в автоматическом режиме
* **blank — Пустой экран** — вместо участника отображается чёрный экран
* **scroll — Прокрутка** — режим активирует автоматическую ротацию участников, не установленных в фиксированные ячейки мозайки. Замена будет происходить с интервалом, установленным в закладке «Настройки» раздела «Конференции»
* **presentation — Презентация** — вместо участника активируется показ презентации
* **lecturer — Лектор** — отображается активный докладчик (активированный по голосу)
* **lastlecturer — Предыдущий лектор** — отображается прежний докладчик (для создания эффекта диалога — оба собеседника будут в фиксированных ячейках)
После выбора раскладки или определения значения панели следует нажать кнопку «Сохранить» для вступления изменений в силу.
Для сохранения настроек в качестве Пресета (сохраненной конфигурации раскладки) следует нажать на кнопку «Сохранить как пресет». Сохраненный пресет будет доступен на вкладке Пресеты окна Мозаика на странице управления конференцией.
**Страница Участники**
Данная страница позволяет произвести настройку текущих участников, добавить новых участников в конференцию, настроить несколько участников, удалить участников из конференции, а также полностью очистить конференцию от участников.
Для добавления, либо удаления участников воспользуйтесь кнопками в верхнем правом углу с соответствующими названиями.
Для редактирования нескольких участников выделите абонентов галочками, нажмите кнопку «Редактировать выделенных участников», выберите необходимые настройки:
* **Ширина канала** – устанавливает максимальную ширину канала
* **Разрешение** – устанавливает максимальное разрешение входящего видео потока
* **FPS** – устанавливает максимальное отображение кадров входящего видео потока в секундах
По завершению настройки, нажмите кнопку «Сохранить».
Для редактирования одного участника воспользуйтесь кнопкой «Редактировать» в столбце «Действия» списка участников.
В модальном окне доступны следующие изменения:
* **Источник видео** – параметр, позволяющий назначить участнику видеопоток из другого источника, предварительно добавленного в конференцию
* **Алгоритм(rx)** – алгоритм подключения участника к серверу конференций, определяет ширину канала, разрешение, количество кадров в секунду и иные параметры
* **Канал(tx)** – устанавливает ширину канала передачи данных от участника к серверу, влияет на максимально доступное разрешение от участника к серверу
* **Канал(rx)** – устанавливает ширину канала передачи данных от сервера к участнику
* **Разрешение(tx)** – определяет максимальное разрешение видео потока от участника к серверу
* **Разрешение(rx)** – определяет максимальное разрешение видео потока от сервера к участнику
* **FPS(tx)** – устанавливает максимальное количество кадров в секунду видео потока от участника к серверу
* **FPS(rx)** – устанавливает максимальное количество кадров в секунду видео потока от сервера к участнику
* **Камера** – при отключении данного параметра участник будет подключаться с отключенным видео потоком
* **Микрофон** – при отключении данного параметра участник будет подключаться с отключенным аудио потоком
Для редактирования персональной раскладки мозаики воспользуйтесь кнопкой «Мозаика» в столбце «Действия» списка участников.
При выборе индивидуальной раскладки становится доступной третья кнопка — «Расположение», в столбце «Действия» списка участников, которая позволяет настроить отображение участников на выбранной ранее индивидуальной раскладке.
#### Расписание
В Vinteo реализована возможность планировать конференции. Запланированные конференции отображаются на странице «Расписание», доступной, как пункт основного меню конфигурации.
**Планирование конференций**
Для планирования конференции следует произвести следующие действия:
1. В основном меню необходимо выбрать пункт «Расписание»
2. Нажать кнопку «Запланировать конференцию»
3. В модальном окне требуется настроить следующие параметры:
* **Конференция** – выбрать конференцию которую следует запустить в назначенную далее дату и время
* **Автозапуск** – дата, время и длительность конференции
* **E-mail организатора** – введите электронный адрес организатора, для отправки уведомления на почту
* **Повтор** – выберите требуется ли повторять данную конференцию и с каким интервалом
* **Вызвать всех участников** – позволяет автоматически вызывать всех участников конференции в назначенную дату и время
* **Уведомить участников по e-mail** – позволяет отправить уведомление всем участникам о запланированной для них конференции.
Нажать кнопку «Запланировать»
Если необходимо запланировать новую, а не уже созданную конференцию, то диалоговое окно приобретает более расширенную форму.
#### Отчеты
Данный модуль предоставляет возможность поиска отчетов по видеозвонкам между абонентами, проводимым конференциям, а также подробный отчет о подключениях участников во время проводимых конференций и действиях, производимых в системе.
**Записи**
Здесь можно посмотреть записи всех конференций, доступных на локальном хранилище сервера. Можно скачать видеоролик в формате mp4, а также можно его удалить,
воспользовавшись кнопками в столбце «Действия» списка «Записи»
Для того чтобы сузить количество отображаемых строк, Вы можете выбрать диапазон дат и нажать кнопку «Поиск».
При клике на какую-либо запись из списка, отображается страница с параметрами выбранной записи, а также инструмент для конвертации записи в различные форматы: wmv или avi. Конвертация записи происходит за счёт ресурсов сервера с максимальным приоритетом, поэтому рекомендуется выбирать менее загруженное время для запуска этого процесса.
**Логи**
Здесь можно просмотреть отчет о каждой конференции, параметры конференции, используемые кодеки, параметры участников конференции и иную техническую информацию о ходе конференции.
Для того чтобы сузить количество отображаемых строк, вы можете выбрать диапазон дат и нажать кнопку «Поиск».
Вы также можете просмотреть лог в окне вашего браузера, либо скачать его на ПК.
**Пример лога конференции**
`2020-10-28 12:55:59 - Вызываем участника 100 -- 1920x1080/25fps at 1536Kb/s
2020-10-28 12:55:59 - Вызываем участника 101 -- 1920x1080/25fps at 1536Kb/s
2020-10-28 12:55:59 - Вызываем участника 102 -- 1280x720/25fps at 1536Kb/s
2020-10-28 12:55:59 - Вызываем участника 103 -- 1280x720/25fps at 1536Kb/s
2020-10-28 12:55:59 - Вызываем участника 104 -- 1280x720/25fps at 1536Kb/s
2020-10-28 12:55:59 - Вызываем участника 105 -- 1280x720/25fps at 1536Kb/s
2020-10-28 12:55:59 - Вызываем участника 106 -- 1280x720/25fps at 1536Kb/s
2020-10-28 12:55:59 - Вызываем участника 108 -- 1280x720/25fps at 6144Kb/s
2020-10-28 12:55:59 - Вызываем участника observer1 -- 1280x720/25fps at 1024Kb/s
2020-10-28 12:55:59 - Вызываем участника observer -- 1280x720/25fps at 1024Kb/s
2020-10-28 12:55:59 - Вызываем участника observer2 -- 1280x720/25fps at 1024Kb/s
2020-10-28 12:55:59 - Вызываем участника player1 -- 352x288/30fps at 256Kb/s
2020-10-28 12:55:59 - Вызываем участника player2 -- 352x288/30fps at 256Kb/s
2020-10-28 12:55:59 - Вызываем участника player3 -- 352x288/30fps at 256Kb/s
2020-10-28 12:55:59 - Вызываем участника player4 -- 352x288/30fps at 256Kb/s
2020-10-28 12:55:59 - Вызываем участника player5 -- 352x288/30fps at 256Kb/s
2020-10-28 12:56:01 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:10) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:01 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:9) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:01 - Участник player1 успешно подключен
2020-10-28 12:56:01 - Участник player1 успешно подключен
2020-10-28 12:56:01 - Участник player2 успешно подключен
2020-10-28 12:56:01 - Участник player2 успешно подключен
2020-10-28 12:56:01 - Участник player3 успешно подключен
2020-10-28 12:56:01 - Участник player3 успешно подключен
2020-10-28 12:56:01 - Участник player4 успешно подключен
2020-10-28 12:56:01 - Участник player5 успешно подключен
2020-10-28 12:56:01 - Участник player5 успешно подключен
2020-10-28 12:56:01 - Participant player2 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 12:56:01 - Participant player2 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 12:56:01 - Participant player3 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 12:56:01 - Participant player3 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 12:56:01 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:8) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:01 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:8) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:01 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:9) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:01 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:9) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:01 - For participant player2 change audio type - (a(rx:tx) = g7221_48_32:-)
2020-10-28 12:56:01 - For participant player2 change video mode - CIF 352x288/30 fps bitrate=256 (v(rx:tx) = H264Base:-)
2020-10-28 12:56:01 - For participant player3 change audio type - (a(rx:tx) = g7221_48_32:-)
2020-10-28 12:56:01 - For participant player3 change video mode - CIF 352x288/30 fps bitrate=256 (v(rx:tx) = H264Base:-)
2020-10-28 12:56:02 - Участник 101 не отвечает
2020-10-28 12:56:02 - Участник 102 не отвечает
2020-10-28 12:56:02 - Участник 103 не отвечает
2020-10-28 12:56:02 - Участник 104 не отвечает
2020-10-28 12:56:02 - Участник 105 не отвечает
2020-10-28 12:56:02 - Участник 106 не отвечает
2020-10-28 12:56:02 - Участник 108 не отвечает
2020-10-28 12:56:02 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:6) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:02 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:7) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:02 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:8) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:02 - Участник player1 ответил
2020-10-28 12:56:02 - Участник player2 ответил
2020-10-28 12:56:02 - Участник player3 ответил
2020-10-28 12:56:02 - Участник player4 ответил
2020-10-28 12:56:02 - Участник player5 ответил
2020-10-28 12:56:02 - Участник player4 успешно подключен
2020-10-28 12:56:02 - Participant player1 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 12:56:02 - Participant player1 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 12:56:02 - Participant player4 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 12:56:02 - Participant player4 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 12:56:02 - Participant player5 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 12:56:02 - Participant player5 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 12:56:02 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:02 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:02 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:6) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:02 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:6) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:02 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:7) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:02 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:7) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:02 - For participant player1 change audio type - (a(rx:tx) = g7221_48_32:-)
2020-10-28 12:56:02 - For participant player1 change video mode - CIF 352x288/30 fps bitrate=256 (v(rx:tx) = H264Base:-)
2020-10-28 12:56:02 - For participant player4 change audio type - (a(rx:tx) = g7221_48_32:-)
2020-10-28 12:56:02 - For participant player4 change video mode - CIF 352x288/30 fps bitrate=256 (v(rx:tx) = H264Base:-)
2020-10-28 12:56:02 - For participant player5 change audio type - (a(rx:tx) = g7221_48_32:-)
2020-10-28 12:56:02 - For participant player5 change video mode - CIF 352x288/30 fps bitrate=256 (v(rx:tx) = H264Base:-)
2020-10-28 12:56:08 - Участник 100 ответил
2020-10-28 12:56:08 - Участник 100 успешно подключен
2020-10-28 12:56:09 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:09 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:09 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:09 - Participant 100 request (audio only) license and use for now (hd(1080p maximum)) license
2020-10-28 12:56:09 - Participant 100 request (audio only) license and use for now (hd(1080p maximum)) license
2020-10-28 12:56:09 - Participant 100 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 12:56:09 - Participant 100 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 12:56:09 - Request license(audio only). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:4) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:09 - Request license(audio only). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:4) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:09 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:4) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:09 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:4) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 12:56:09 - For participant 100 change audio type - (a(rx:tx) = -:opus)
2020-10-28 12:56:09 - For participant 100 change audio type - (a(rx:tx) = -:ulaw)
2020-10-28 12:56:09 - For participant 100 change video mode - FULLHD 1920x1080/25 fps bitrate=1536 (v(rx:tx) = -:H.264Base)
2020-10-28 12:56:09 - For participant 100 change video mode - FULLHD 1920x1080/25 fps bitrate=1536 (v(rx:tx) = -:H.264Base)
2020-10-28 12:56:09 - For participant 100 change video mode - FULLHD 1920x1080/25 fps bitrate=1536 (v(rx:tx) = -:-)
2020-10-28 12:56:10 - For participant 100 change audio type - (a(rx:tx) = opus:opus)
2020-10-28 12:57:03 - Участник 101 не отвечает
2020-10-28 12:57:03 - Участник 102 не отвечает
2020-10-28 12:57:03 - Участник 103 не отвечает
2020-10-28 12:57:03 - Участник 104 не отвечает
2020-10-28 12:57:03 - Участник 105 не отвечает
2020-10-28 12:57:03 - Участник 106 не отвечает
2020-10-28 12:57:03 - Участник 108 не отвечает
2020-10-28 12:58:04 - Участник 101 не отвечает
2020-10-28 12:58:04 - Участник 102 не отвечает
2020-10-28 12:58:04 - Участник 103 не отвечает
2020-10-28 12:58:04 - Участник 104 не отвечает
2020-10-28 12:58:04 - Участник 105 не отвечает
2020-10-28 12:58:04 - Участник 106 не отвечает
2020-10-28 12:58:04 - Участник 108 не отвечает
2020-10-28 13:06:59 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 13:06:59 - Participant player4 disconnected self moveto= cause=-1
2020-10-28 13:06:59 - Participant player4 disconnect
2020-10-28 15:14:03 - Web action (admin : 10.0.0.194): Attention! An error occurred while placing participant 100 to reserved position in conference 1000.
2020-10-28 15:14:13 - Вызываем участника player4 -- 352x288/30fps at 256Kb/s
2020-10-28 15:14:13 - Web action (admin : 10.0.0.194): Participant player4 of conference 1000 was reached successfully. Awaiting connection...
2020-10-28 15:14:15 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:14:15 - Участник player4 успешно подключен
2020-10-28 15:14:15 - Участник player4 успешно подключен
2020-10-28 15:14:15 - Participant player4 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 15:14:15 - Participant player4 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 15:14:15 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:4) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:14:15 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:4) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:14:15 - For participant player4 change audio type - (a(rx:tx) = g7221_48_32:-)
2020-10-28 15:14:15 - For participant player4 change video mode - CIF 352x288/30 fps bitrate=256 (v(rx:tx) = H264Base:-)
2020-10-28 15:14:16 - Участник player4 ответил
2020-10-28 15:14:32 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:14:32 - Participant 100 disconnected self moveto= cause=200
2020-10-28 15:14:32 - Participant 100 disconnect
2020-10-28 15:14:38 - Вызываем участника 100 -- 1920x1080/25fps at 1536Kb/s
2020-10-28 15:14:38 - Web action (admin : 10.0.0.194): Participant 100 of conference 1000 was reached successfully. Awaiting connection...
2020-10-28 15:14:42 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:14:42 - Участник 100 ответил
2020-10-28 15:14:42 - Участник 100 успешно подключен
2020-10-28 15:14:42 - Participant 100 request (audio only) license and use for now (hd(1080p maximum)) license
2020-10-28 15:14:42 - Participant 100 request (audio only) license and use for now (hd(1080p maximum)) license
2020-10-28 15:14:42 - Request license(audio only). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:4) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:14:42 - Request license(audio only). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:4) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:14:42 - For participant 100 change audio type - (a(rx:tx) = -:ulaw)
2020-10-28 15:14:42 - For participant 100 change video mode - FULLHD 1920x1080/25 fps bitrate=1536 (v(rx:tx) = -:-)
2020-10-28 15:14:43 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:14:43 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:14:43 - Participant 100 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 15:14:43 - Participant 100 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 15:14:43 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:4) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:14:43 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:4) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:14:43 - For participant 100 change audio type - (a(rx:tx) = -:opus)
2020-10-28 15:14:43 - For participant 100 change video mode - FULLHD 1920x1080/25 fps bitrate=1536 (v(rx:tx) = -:H.264Base)
2020-10-28 15:14:43 - For participant 100 change video mode - FULLHD 1920x1080/25 fps bitrate=1536 (v(rx:tx) = -:H.264Base)
2020-10-28 15:14:54 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:14:54 - Participant 100 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 15:14:54 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:4) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:14:54 - For participant 100 change video mode - FULLHD 1920x1080/25 fps bitrate=1536 (v(rx:tx) = H264Base:H.264Base)
2020-10-28 15:14:55 - For participant 100 change audio type - (a(rx:tx) = opus:opus)
2020-10-28 15:15:46 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:15:46 - Participant player1 disconnected system moveto= cause=-1
2020-10-28 15:15:46 - Participant player1 disconnect
2020-10-28 15:15:46 - Web action (admin : 10.0.0.194): Participant player1 of conference 1000 will be disconnected within a few seconds.
2020-10-28 15:16:08 - Set static lecteur state for player3 to 1
2020-10-28 15:16:08 - Web action (admin : 10.0.0.194): Participant player3 is appointed as lecturer in conference #1000.
2020-10-28 15:16:12 - Set static lecteur state for player3 to 0
2020-10-28 15:16:12 - Web action (admin : 10.0.0.194): Participant player3 has lost the lecturer status in conference #1000.
2020-10-28 15:16:41 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:6) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:16:41 - Participant player3 disconnected system moveto= cause=-1
2020-10-28 15:16:41 - Participant player3 disconnect
2020-10-28 15:16:41 - Web action (admin : 10.0.0.194): Participant player3 of conference 1000 will be disconnected within a few seconds.
2020-10-28 15:16:48 - Вызываем участника player1 -- 352x288/30fps at 256Kb/s
2020-10-28 15:16:48 - Web action (admin : 10.0.0.194): Participant player1 of conference 1000 was reached successfully. Awaiting connection...
2020-10-28 15:16:50 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:6) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:16:50 - Участник player1 успешно подключен
2020-10-28 15:16:50 - Участник player1 успешно подключен
2020-10-28 15:16:50 - Participant player1 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 15:16:50 - Participant player1 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 15:16:50 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:16:50 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:16:50 - For participant player1 change audio type - (a(rx:tx) = g7221_48_32:-)
2020-10-28 15:16:50 - For participant player1 change video mode - CIF 352x288/30 fps bitrate=256 (v(rx:tx) = H264Base:-)
2020-10-28 15:16:51 - Участник player1 ответил
2020-10-28 15:17:41 - Set composition owner -global- type 38 dimension 720p
2020-10-28 15:17:41 - Web action (admin : 10.0.0.194): Layout of conference 1000 is successfully changed.
2020-10-28 15:17:57 - Set composition owner -global- type 5 dimension 720p
2020-10-28 15:17:57 - Web action (admin : 10.0.0.194): Layout of conference 1000 is successfully changed.
2020-10-28 15:19:40 - Web action (admin : 10.0.0.194): Layout settings saved successfully. Mosaic: 5, positions: auto,auto,auto,auto,auto,100,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto.
2020-10-28 15:20:09 - Web action (admin : 10.0.0.194): Layout settings saved successfully. Mosaic: 5, positions: auto,player2,player5,player1,player4,100,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto.
2020-10-28 15:20:29 - Web action (admin : 10.0.0.194): Layout settings saved successfully. Mosaic: 5, positions: lecturer,player2,player5,player1,player4,100,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto.
2020-10-28 15:25:13 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:6) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:25:13 - Participant player4 disconnected self moveto= cause=-1
2020-10-28 15:25:13 - Participant player4 disconnect
2020-10-28 15:30:55 - Вызываем участника player4 -- 352x288/30fps at 256Kb/s
2020-10-28 15:30:55 - Web action (admin : 10.0.0.194): Call of participants player4 to conference 1000 was successful.
2020-10-28 15:30:58 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:6) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:30:58 - Участник player4 ответил
2020-10-28 15:30:58 - Участник player4 успешно подключен
2020-10-28 15:30:58 - Участник player4 успешно подключен
2020-10-28 15:30:58 - Participant player4 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 15:30:58 - Participant player4 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 15:30:58 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:30:58 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:30:58 - For participant player4 change audio type - (a(rx:tx) = g7221_48_32:-)
2020-10-28 15:30:58 - For participant player4 change video mode - CIF 352x288/30 fps bitrate=256 (v(rx:tx) = H264Base:-)
2020-10-28 15:31:50 - Set audio for 100 state 0
2020-10-28 15:31:50 - Web action (admin : 10.0.0.194): Participant`s 100 microphone in conference 1000 was successfully disabled.
2020-10-28 15:31:58 - Set audio for player1 state 1
2020-10-28 15:31:58 - Web action (admin : 10.0.0.194): Participant`s player1 microphone in conference 1000 was successfully enabled.
2020-10-28 15:32:48 - Set audio for 100 state 1
2020-10-28 15:32:48 - Web action (admin : 10.0.0.194): Participant`s 100 microphone in conference 1000 was successfully enabled.
2020-10-28 15:32:58 - Set audio for player1 state 0
2020-10-28 15:32:58 - Web action (admin : 10.0.0.194): Participant`s player1 microphone in conference 1000 was successfully disabled.
2020-10-28 15:33:07 - Set audio for player1 state 2
2020-10-28 15:33:07 - Web action (admin : 10.0.0.194): Sound to participant player1 of conference 1000 is successfully disabled.
2020-10-28 15:33:12 - Set video for player1 state 0
2020-10-28 15:33:12 - Web action (admin : 10.0.0.194): Participant`s player1 camera in conference 1000 is successfully disabled.
2020-10-28 15:33:43 - Set video for player4 state 2
2020-10-28 15:33:43 - Web action (admin : 10.0.0.194): Video stream to participant player4 of conference 1000 is successfully disabled.
2020-10-28 15:34:06 - 100 start presentation.
2020-10-28 15:34:06 - Primary video for 100 as presentation state 1
2020-10-28 15:34:06 - Web action (admin : 10.0.0.194): Picture from participant`s 100 camera is shown as a presentation in conference #1000.
2020-10-28 15:41:55 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:6) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 15:41:55 - Participant player4 disconnected self moveto= cause=-1
2020-10-28 15:41:55 - Participant player4 disconnect
2020-10-28 19:03:58 - Web action (admin : 10.0.0.194): Conference settings changed
2020-10-28 19:06:07 - Web action (admin : 10.0.0.194): Layout settings saved successfully. Mosaic: 5, positions: auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto.
2020-10-28 19:06:13 - Web action (admin : 10.0.0.194): Layout settings saved successfully. Mosaic: 5, positions: auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto.
2020-10-28 19:06:21 - Web action (admin : 10.0.0.194): Layout settings saved successfully. Mosaic: 5, positions: auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto,auto.
2020-10-28 19:06:32 - Вызываем участника player4 -- 352x288/30fps at 256Kb/s
2020-10-28 19:06:32 - Web action (admin : 10.0.0.194): Participant player4 of conference 1000 was reached successfully. Awaiting connection...
2020-10-28 19:06:34 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:6) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:06:34 - Участник player4 успешно подключен
2020-10-28 19:06:34 - Участник player4 успешно подключен
2020-10-28 19:06:34 - Participant player4 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 19:06:34 - Participant player4 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 19:06:34 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:06:34 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:06:34 - For participant player4 change audio type - (a(rx:tx) = g7221_48_32:-)
2020-10-28 19:06:34 - For participant player4 change video mode - CIF 352x288/30 fps bitrate=256 (v(rx:tx) = H264Base:-)
2020-10-28 19:06:35 - Участник player4 ответил
2020-10-28 19:06:47 - Set audio for player1 state 1
2020-10-28 19:06:47 - Web action (admin : 10.0.0.194): Participant`s player1 microphone in conference 1000 was successfully enabled.
2020-10-28 19:06:49 - Set video for player1 state 1
2020-10-28 19:06:49 - Web action (admin : 10.0.0.194): Participant`s player1 camera in conference 1000 is successfully enabled.
2020-10-28 19:07:02 - Web action (admin : 10.0.0.194): Attention! An error occurred while placing participant 100 to reserved position in conference 1000.
2020-10-28 19:07:09 - 100 stop presentation.
2020-10-28 19:07:09 - Primary video for 100 as presentation state 0
2020-10-28 19:07:09 - Web action (admin : 10.0.0.194): Presentation from the participant`s 100 camera in conference #1000 was successfully disabled.
2020-10-28 19:07:13 - Set audio for player1 state 3
2020-10-28 19:07:13 - Web action (admin : 10.0.0.194): Sound for participant player1 in conference 1000 is successfully enabled.
2020-10-28 19:07:39 - Web action (admin : 10.0.0.194): Conference settings changed
2020-10-28 19:07:53 - Web action (admin : 10.0.0.194): Conference settings changed
2020-10-28 19:08:05 - Web action (admin : 10.0.0.194): Conference settings changed
2020-10-28 19:09:39 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:09:39 - Участник monitor успешно подключен
2020-10-28 19:09:39 - Участник monitor успешно подключен
2020-10-28 19:09:39 - Participant monitor request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 19:09:39 - Participant monitor request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 19:09:39 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:254) OBSERVER:(all:255 // free:255)
2020-10-28 19:09:39 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:254) OBSERVER:(all:255 // free:255)
2020-10-28 19:09:39 - For participant monitor change audio type - (a(rx:tx) = g7221_48_32:g7221_48_32)
2020-10-28 19:09:39 - For participant monitor change video mode - 3840x2160/30 fps bitrate=6144 (v(rx:tx) = -:H.264High)
2020-10-28 19:09:39 - Web action (admin : 10.0.0.194): Conference 1000 is being recorded.
2020-10-28 19:10:00 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:10:00 - Participant monitor disconnected self moveto= cause=-1
2020-10-28 19:10:00 - Participant monitor disconnect
2020-10-28 19:10:00 - Web action (admin : 10.0.0.194): Conference 1000 is no longer being recorded.
2020-10-28 19:10:01 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:10:01 - Участник monitor успешно подключен
2020-10-28 19:10:01 - Участник monitor успешно подключен
2020-10-28 19:10:01 - Participant monitor request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 19:10:01 - Participant monitor request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 19:10:01 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:254) OBSERVER:(all:255 // free:255)
2020-10-28 19:10:01 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:254) OBSERVER:(all:255 // free:255)
2020-10-28 19:10:01 - For participant monitor change audio type - (a(rx:tx) = g7221_48_32:g7221_48_32)
2020-10-28 19:10:01 - For participant monitor change video mode - 3840x2160/30 fps bitrate=6144 (v(rx:tx) = -:H.264High)
2020-10-28 19:10:01 - Web action (admin : 10.0.0.194): Conference 1000 is being recorded.
2020-10-28 19:10:14 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:10:14 - Participant monitor disconnected self moveto= cause=-1
2020-10-28 19:10:14 - Participant monitor disconnect
2020-10-28 19:10:14 - Web action (admin : 10.0.0.194): Conference 1000 is no longer being recorded.
2020-10-28 19:10:16 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:10:16 - Участник monitor успешно подключен
2020-10-28 19:10:16 - Участник monitor успешно подключен
2020-10-28 19:10:16 - Participant monitor request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 19:10:16 - Participant monitor request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 19:10:16 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:254) OBSERVER:(all:255 // free:255)
2020-10-28 19:10:16 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:254) OBSERVER:(all:255 // free:255)
2020-10-28 19:10:16 - For participant monitor change audio type - (a(rx:tx) = g7221_48_32:g7221_48_32)
2020-10-28 19:10:16 - For participant monitor change video mode - 3840x2160/30 fps bitrate=6144 (v(rx:tx) = -:H.264High)
2020-10-28 19:10:16 - Web action (admin : 10.0.0.194): Conference 1000 is being recorded.
2020-10-28 19:10:19 - Участник monitor успешно подключен
2020-10-28 19:10:19 - Web action (admin : 10.0.0.194): Conference 1000 is being recorded.
2020-10-28 19:10:27 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:10:27 - Participant monitor disconnected self moveto= cause=-1
2020-10-28 19:10:27 - Participant monitor disconnect
2020-10-28 19:10:27 - Web action (admin : 10.0.0.194): Conference 1000 is no longer being recorded.
2020-10-28 19:10:51 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:10:51 - Участник monitor успешно подключен
2020-10-28 19:10:51 - Участник monitor успешно подключен
2020-10-28 19:10:51 - Participant monitor request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 19:10:51 - Participant monitor request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 19:10:51 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:254) OBSERVER:(all:255 // free:255)
2020-10-28 19:10:51 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:254) OBSERVER:(all:255 // free:255)
2020-10-28 19:10:51 - For participant monitor change audio type - (a(rx:tx) = g7221_48_32:g7221_48_32)
2020-10-28 19:10:51 - For participant monitor change video mode - 3840x2160/30 fps bitrate=6144 (v(rx:tx) = -:H.264High)
2020-10-28 19:10:51 - Web action (admin : 10.0.0.194): Conference 1000 is being recorded.
2020-10-28 19:11:07 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:11:07 - Participant monitor disconnected self moveto= cause=-1
2020-10-28 19:11:07 - Participant monitor disconnect
2020-10-28 19:11:07 - Web action (admin : 10.0.0.194): Conference 1000 is no longer being recorded.
2020-10-28 19:11:16 - Web action (admin : 10.0.0.194): Conference settings changed
2020-10-28 19:11:21 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:11:21 - Участник monitor успешно подключен
2020-10-28 19:11:21 - Участник monitor успешно подключен
2020-10-28 19:11:21 - Participant monitor request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 19:11:21 - Participant monitor request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 19:11:21 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:254) OBSERVER:(all:255 // free:255)
2020-10-28 19:11:21 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:254) OBSERVER:(all:255 // free:255)
2020-10-28 19:11:21 - For participant monitor change audio type - (a(rx:tx) = g7221_48_32:g7221_48_32)
2020-10-28 19:11:21 - For participant monitor change video mode - 3840x2160/30 fps bitrate=6144 (v(rx:tx) = -:H.264High)
2020-10-28 19:11:21 - Web action (admin : 10.0.0.194): Conference 1000 is being recorded.
2020-10-28 19:11:28 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:11:28 - Participant monitor disconnected self moveto= cause=-1
2020-10-28 19:11:28 - Participant monitor disconnect
2020-10-28 19:11:28 - Web action (admin : 10.0.0.194): Conference 1000 is no longer being recorded.
2020-10-28 19:11:29 - Web action (admin : 10.0.0.194): Conference 1000 is no longer being recorded.
2020-10-28 19:11:34 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:11:34 - Участник monitor успешно подключен
2020-10-28 19:11:34 - Участник monitor успешно подключен
2020-10-28 19:11:34 - Participant monitor request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 19:11:34 - Participant monitor request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 19:11:34 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:254) OBSERVER:(all:255 // free:255)
2020-10-28 19:11:34 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:254) OBSERVER:(all:255 // free:255)
2020-10-28 19:11:34 - For participant monitor change audio type - (a(rx:tx) = g7221_48_32:g7221_48_32)
2020-10-28 19:11:34 - For participant monitor change video mode - 3840x2160/30 fps bitrate=6144 (v(rx:tx) = -:H.264High)
2020-10-28 19:11:34 - Web action (admin : 10.0.0.194): Conference 1000 is being recorded.
2020-10-28 19:11:45 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:11:45 - Participant monitor disconnected self moveto= cause=-1
2020-10-28 19:11:45 - Participant monitor disconnect
2020-10-28 19:11:45 - Web action (admin : 10.0.0.194): Conference 1000 is no longer being recorded.
2020-10-28 19:13:40 - Secret mode enabled
2020-10-28 19:13:40 - Web action (admin : 10.0.0.194): Conference settings changed
2020-10-28 19:14:08 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:6) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:14:08 - Participant 100 disconnected self moveto= cause=200
2020-10-28 19:14:08 - Participant 100 disconnect
2020-10-28 19:14:47 - Вызываем участника 100 -- 1920x1080/25fps at 1536Kb/s
2020-10-28 19:14:47 - Web action (admin : 10.0.0.194): Participant 100 of conference 1000 was reached successfully. Awaiting connection...
2020-10-28 19:14:53 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:6) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:14:53 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:6) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:14:53 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:6) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:14:53 - Участник 100 ответил
2020-10-28 19:14:53 - Участник 100 успешно подключен
2020-10-28 19:14:53 - Participant 100 request (audio only) license and use for now (hd(1080p maximum)) license
2020-10-28 19:14:53 - Participant 100 request (audio only) license and use for now (hd(1080p maximum)) license
2020-10-28 19:14:53 - Participant 100 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 19:14:53 - Participant 100 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 19:14:53 - Request license(audio only). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:14:53 - Request license(audio only). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:14:53 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:14:53 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:14:53 - For participant 100 change audio type - (a(rx:tx) = -:opus)
2020-10-28 19:14:53 - For participant 100 change audio type - (a(rx:tx) = -:ulaw)
2020-10-28 19:14:53 - For participant 100 change video mode - FULLHD 1920x1080/25 fps bitrate=1536 (v(rx:tx) = -:H.264Base)
2020-10-28 19:14:53 - For participant 100 change video mode - FULLHD 1920x1080/25 fps bitrate=1536 (v(rx:tx) = -:H.264Base)
2020-10-28 19:14:53 - For participant 100 change video mode - FULLHD 1920x1080/25 fps bitrate=1536 (v(rx:tx) = -:-)
2020-10-28 19:14:55 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:6) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:14:55 - Participant 100 request (hd(1080p maximum)) license and use for now (hd(1080p maximum)) license
2020-10-28 19:14:55 - Request license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:5) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:14:55 - For participant 100 change audio type - (a(rx:tx) = opus:opus)
2020-10-28 19:14:55 - For participant 100 change video mode - FULLHD 1920x1080/25 fps bitrate=1536 (v(rx:tx) = H264Base:H.264Base)
2020-10-28 19:17:31 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:6) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-28 19:17:31 - Participant player4 disconnected self moveto= cause=-1
2020-10-28 19:17:31 - Participant player4 disconnect
2020-10-29 13:26:48 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:10) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-29 13:26:48 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:7) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-29 13:26:48 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:8) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-29 13:26:48 - Free license(hd(1080p maximum)). License state STD(all:0 // free:0) PREHD(all:0 // free:0) HD(all:10 // free:9) AUDIO:(all:0 // free:0) MONITOR:(all:255 // free:255) OBSERVER:(all:255 // free:255)
2020-10-29 13:26:48 - Participant 100 disconnected system moveto= cause=200
2020-10-29 13:26:48 - Participant 100 disconnect
2020-10-29 13:26:48 - Participant player1 disconnected system moveto= cause=-1
2020-10-29 13:26:48 - Participant player1 disconnect
2020-10-29 13:26:48 - Participant player2 disconnected system moveto= cause=-1
2020-10-29 13:26:48 - Participant player2 disconnect
2020-10-29 13:26:48 - Participant player5 disconnected system moveto= cause=-1
2020-10-29 13:26:48 - Participant player5 disconnect`
В значениях столбца «Конференция» мы можем увидеть: звонки точка-точка, номера конференций, либо значение «purgatory»
**purgatory** — это временная конференция, так называемая комната ожидания, она создаётся при звонке на сервер без указания адресата или номера конференции.
**Системные**
Здесь можно просмотреть отчет о техническом состоянии системы, время перезагрузки системы, отчеты об ошибках системы, отказах и иные данные.
Для того чтобы сузить количество отображаемых строк, вы можете выбрать диапазон дат и нажать кнопку «Поиск».
Вы также можете просмотреть лог в окне вашего браузера, либо скачать его на ПК.
**Ошибки**
При нажатии пункта основного конфигурационного меню «Ошибки», производится экспорт файла данных на ваш локальный ПК. Данный файл следует передать по просьбе сотрудников технической поддержки.
#### Система
В Vinteo реализована полная настройка различных основных и вспомогательных служб. Переход к данным настройкам производится из этого раздела меню.
**Статус**
Данная страница позволяет просматривать основную информацию о сервере – объем и занятое место на жестком диске, системное время, время бесперебойной работы сервера, статус работы Gatekeeper H.323, статус резервирования, а также текущую версию прошивки.
**Шлюзы**
Данная страница позволяет просматривать все добавленные шлюзы на сервер. Здесь настраиваются транки — любые сетевые подключения по протоколам SIP или H.323 до цифровых АТС, серверов PBX, а также иных медиа серверов.
Вкладка «Основные»
* **Тип** — выбор протокола подключения к шлюзу
* **Имя** — требуется ввести имя содержащее только латинские буквы или цифры
* **IP** — сетевой адрес в формате IPv4
* **Регистрация** — Ввести имя и пароль для подключения к шлюзу, если необходимо
* **Принимать входящие** — включает/выключает возможность принимать входящие вызовы с этого шлюза
Вкладка «Расширенные»
* **Порт** — номер порта на котором шлюз «слушает» входящие сетевые пакеты;
* **Транспорт** — выбор протокола передачи данных
* **Небезопасный** — выбор уровня безопасности
1. PORT
2. INVITE
3. VERY
* **Qualify** — опция отправляет SIP сообщения типа OPTIONS для проверки доступности устройств-абонентов
* **Кодеки** — определяет список кодеков, поддерживаемых удаленным медиа серверов
* **H.264 High Profile** — включает/отключает профиль кодека видеопотока для передачи изображения высокой четкости
* **Медиапотоки** — включает/отключает возможность запуска медиа-информации (звук\видео) до установления сеанса SIP
* **DTMF mode** — определяет поддерживаемый стандарт DTMF сигналов для удаленного сервера
* **Находится за NAT** — включает/отключает режим трансляции сетевых адресов для соединения с удаленным сервером
* **Skype4B** — включает/отключает режим распознавания сервера как VIS сервера Lync\Skype for Business
* **BFCP** — протокол передачи контента вовремя SIP вызова
* **Media Encryption** — включение шифрования медиа потока во время SIP вызова
* **From domain** — строка для записи SIP URI
Вкладка «Маршруты»
* **Направление** – определяет маску создаваемого маршрута
* **Вес** – числовое значение, влияющее на рейтинг создаваемого маршрута
* **Примечание** – понятное описание маршрута
Удаление и редактирование шлюза производится при помощи кнопок в столбце «Действия» списка «Шлюзы»
**Видеоролики**
Здесь Вы можете добавить видеоролик в форматах mp4\mov\m4v\mkv\flv\wmv\avi, для отображения их дополнительным потоком в конференции.
**Настройки**
На странице настроек вы можете найти:
* Настройки брандмауэра для запрета доступа к портам SIP и H.323 из локальной сети
* Параметры сетевых интерфейсов и маршрутизацию
* Настройки подключения анонимных пользователей
* Настройки SIP и H.323
* Параметры адресной трансляции
* Диагностические утилиты
* Управление питанием сервера
**Основные**
На странице основных настроек вы можете изменить:
* Настройки брандмауэра для запрета доступа к портам SIP и H.323 из локальной сети
* Параметры H.323 — сигнальный порт, диапазон RTP портов, включение авторизации по паре Логин/Пароль
* Параметры SIP, STUN, ToS – маркировка трафика
* Настройки времени и интерфейса – язык по умолчанию, использование http вместо https протокола (не рекомендуется)
* Настройки диапазонов номеров — требуется для определения номерной базы сервера Vinteo
**Параметры сетевых интерфейсов**
Содержит параметры интерфейсов и конфигурируется типовым способом.
Первый сетевой интерфейс является «Внешним» и настраивается заполнением полей:
* **IP** – адрес в формате IPv4
* **Маска** – значение в формате XXX.XXX.XXX.XXX
* **Шлюз** – адрес пограничного шлюза сети в формате IPv4
* **MTU** – значение максимального объема данных, который может быть передан протоколом за одну итерацию
* **DNS** – адрес сервера имен в формате IPv4
* **NTP** – адрес сервера точного времени в формате IPv4
Последующие интерфейсы имеют настройки только полей «IP», «Маска» и «MTU».
**Маршруты**
Содержит таблицу с информацией о маршрутах доступных серверу, позволяет добавить статические маршруты.
Добавление новых маршрутов позволяет определять сетевые интерфейс для маршрутизации в заданные сети. Для добавления нового маршрута необходимо на вкладке «Маршруты нажать кнопку «Добавить маршрут». В модальном окне следует определить следующие параметры:
* **Сеть** – сетевое направление маршрута
* **Маска** – в формате длины префикса в битах
* **Шлюз** – адрес шлюза по которому доступно данное направление в формате IPv4
* **Интерфейс** – сетевой интерфейс к которому физически подключено сетевое устройство с выходом на данное сетевое направление
**NAT**
Содержит параметры трансляции сетевых адрес на случай, когда сервер установлен за пограничным сетевым устройством и не имеет собственного внешнего адреса. Доступ осуществляется путем настройки DMZ зоны, либо путем добавления портов сигнализации и портов RTP в таблицу NAT сетевого устройства.
Для настройки NAT и RTP требуется заполнить следующие поля:
* **Внешний IP** – сетевой адрес пограничного сетевого устройства, которое обеспечивает технологией трансляции сетевых адресов в локальную сеть
* **Локальные сети** – список сетевых адресов или подсетей, которые являются локальными по отношению к серверу
* **Пункты SIP и H.323** – протоколы, используемые при подключении удаленных абонентов
* **Параметры RTP** — требуется заполнить диапазон портов от значения в поле «Начало» до значения в поле «Конец»
**Примечание:** *Если сервер расположен за NAT и есть необходимость подключаться извне, то задайте «Внешний IP-адрес» который подставляет NAT сервер. На NAT сервере сделайте проброс портов 5060/UDP(SIP), 5060/TCP(SIP), 1719/UDP(H.323 GK), 1730/TCP(H.323 GK) и диапазон RTP портов этого сервера. Этот диапазон не может быть меньше 1000.
Для H.323 работа в таком режиме возможна только с использованием гейткипера (в этом случае, если участники также находятся за NAT и нет возможности пробросить порты, у таких клиентов будет возможность самим подключаться, но сервер их вызвать не сможет). Также, если участники H.323 расположены за NAT, то они должны поддерживать стандарт H.460.18. Если «Внешний IP-адрес» задан, то необходимо также задать «Локальные сети» (для которых не будет выполняться подстановка внешнего IP-адреса), по одной сети на строке.
Например 192.168.0.0/255.255.0.0*
**Входящие**
В чёрный список добавляются IP адреса сетевых устройств, прием входящих вызовов с которых вы хотите запретить.
Для автоматической фильтрации спам-звонков, рекомендуется указать максимальную разрешенную длину номеров — это первый рубеж обороны против автоматических звонков из открытого интернета. Спам-адреса попадают в чёрный список, при несоответствии требованиям к допустимой длине номера. Звонки прошедшие по длине номера, но зависшие в комнате ожидания из-за бездействия — также попадают в спам-список.
**P2P**
Содержит параметры записи видеозвонков «Точка-точка». Здесь производится включение и выключение записи переключателем, выбор разрешения записи, видеоприветствие для показа ролика абоненту, ожидающего ответа, а также включение\выключение автоповтора видеоролика на случай долгого ожидания и краткой длины ролика.
**Почта**
Содержит параметры настройки почтового клиента на стороне сервера и используются для рассылки уведомлений участникам о запланированных конференциях.
**Подключение анонимов**
Содержит параметры подключения анонимных участников конференции. В настройку входят:
* **Ширина канала** – скорость передачи данных
* **Разрешение** – видеоразрешение подключения
* **FPS** – количество кадров в секунду
* **Cоздавать анонимные комнаты** – автоматически создает временную комнату в случае ее отсутствия, управление данной комнатой отсутствует (не рекомендуется использовать без спам-фильтра — любой звонок на несуществующий номер конференции создаёт временную виртуальную комнату, и задействует лицензию подключения)
* **Кодеки** – разрешенные кодеки
**LDAP**
Содержит параметры подключения к серверу LDAP и позволяет автоматически добавлять абонентов используя данные пользователей из структуры каталога LDAP. Для проверки соединения, заполните параметры подключения и нажмите кнопку «Проверить соединение».
**Каскадирование**
Сервер Vinteo имеет реализацию расширения возможностей ВКС, путем наращивания емкости портов, количества каналов связи и распределения нагрузки между несколькими серверами. Для использования данного функционала требуется несколько серверов Vinteo с одинаковой версией ПО.
Текущий сервер определяется как «Сервер №1», при удалении с него будет снята роль медиа сервера.
Для добавления каскада серверов требуется нажать на кнопку «Добавить» и заполнить параметры удаленного сервера:
* **Название сервера** – название сервера для его последующего определения на латинице
* **IP** – адрес сервера в формате IPv4
* **Порт** – порт прослушивания входящих соединений удаленного сервера
* **Локальный IP** – адрес ведущего сервера в формате IPv4
* **Пароль** – пароль администратора удаленного сервера
Корректность внесения настроек и работоспособность каскада можно проверить, перейдя на основное окно конфигурации сервера, будут показаны дополнительные вкладки статистики с названием подключенных серверов.
Логика работы данной реализации:
1. Ведущий сервер выполняет роль центрального шлюза для подключения участников конференции
2. Далее участники распределяются по каскаду, надпись «localmcu» означает подключение к ведущему серверу
3. Ведущий сервер формирует раскладку, при назначении участника с второстепенного сервера – происходит автоматическое перемещение на ведущий сервер
4. Ведущий сервер осуществляет балансировку по количеству участников между серверами и их совокупной нагрузке на каждый сервер
**Диагностика**
Содержит различные стандартные сетевые инструменты для проверки и диагностики неисправности сети и проблемных звонков.
**SSL**
В Vinteo реализована возможность установки сертификата из доменного центра сертификации, самоподписанного сертификата, либо установки сертификата от хост-провайдера.
**Перезагрузка**
Для перезагрузки сервера нажмите на данный пункт и подтвердите перезагрузку в модальном окне кнопкой «Перезагрузить»
**Выключение**
Для выключения сервера нажмите на данный пункт и подтвердите выключение в модальном окне кнопкой «Выключить».
**Лицензии**
Сервер Vinteo распространяется по лицензии приобретаемой у официальных партнеров компании ООО «ВИНТЕО». Данный пункт позволяет запросить и установить лицензию на сервер, а также просмотреть ранее установленные лицензии. Запрос на тестирование можно сделать по адресу [**vinteo@prof-av.ru**](mailto:vinteo@prof-av.ru)
Существуют ограниченные по времени и неограниченные, а также четыре типа лицензии по параметрам подключений:
1. **SD** — Лицензия на подключение участников со стандартным разрешением до VGA
2. **HD** — Лицензия на подключение участников с качеством до 720p
3. **FullHD** — Лицензия на подключение участников с качеством до 1080p
4. **Audio** — Лицензия на подключение участников только с аудио потоком
**Запрос и установка лицензии**
Для запроса лицензии требуется заполнить поля значениями количества участников, а затем нажать на кнопку «Сгенерировать». Полученный файл «licrequest.lic» необходимо отправить по электронной почте на электронный адрес [**vinteo@prof-av.ru**](mailto:vinteo@prof-av.ru), для получения файла лицензии «newlic.lic».
Полученный файл требуется загрузить через клик по кнопке «Выберите файл» и «Загрузить».
Лицензия отобразится в списке лицензий вверху страницы.
**Обновление**
Данная страница позволяет загрузить обновление прошивки, экспортировать текущую конфигурацию в файл, а также вернуть сервер к заводским настройкам.
#### Веб-клиент
Вход в веб-клиента возможен как со стартовой страницы авторизации (при входе на сервер), так и с главной страницы самого интерфейса управления.
Возможно подключиться к конференции в качестве гостя, либо подключиться к мероприятию как зарегистрированный пользователь.
Интерфейс лаконичный. По клику выползает боковое меню со списком участников и чатом.
#### Программный клиент
Vinteo Desktop — программный клиент ВКС под различные операционные системы, включая Windows, macOS и Linux (даже Astra).
Также как и в веб-интерфейсе, в программном клиенте есть закладка с настройками подключения к серверу, настройка аудио/видео периферии, цифровой номеронабиратель для прямого звонка абоненту или в конференцию, адресная книга, чат и история звонков.
В полноэкранном режиме при движении мышью появляются инструменты для управления собственными микрофоном и камерой, а также собственным видео поверх основной раскладки.
Также есть кнопка для демонстрации экрана и статистика вызова (битрейт, потерянные пакеты и длительность подключения).
При наличии у пользователя прав модератора, в списке участников доступно управление видео и аудио потоками для каждого докладчика.
Тестирование, консультация, пресейл
-----------------------------------
Если у Вас есть потребность в уникальной российской системе видеоконференцсвязи премиального класса — воспользуйтесь возможностью пилотного тестирования у себя в инфраструктуре.
Мы поможем Вам развернуть систему на Вашем сервере, дадим рекомендации по [аппаратной платформе](https://prof-av.ru/product-category/catalog/servers-vks/vinteo-servers/), продемонстрируем уникальные особенности данного решения, такие как:
* Широчайшие возможности управления раскладками для каждого участника, записи и трансляции
* Возможность синхронного перевода, используя несколько входящих и исходящих аудио каналов у каждого участника
* Эргономичный интерфейс и высокое качество связи
* Плавно выезжающие подписи-титры для каждого докладчика
* Максимальная совместимость с SIP/H.323-оборудованием ведущих мировых производителей терминальных систем ВКС
Запрос на пилотное тестирование можно сделать по адресу [**vinteo@prof-av.ru**](mailto:vinteo@prof-av.ru)
В письме просьба указать:
* Информацию о Вашей компании
* Сценарий использования (ВКС, вебинары, максимальное кол-во подключений)
* Тип терминальных клиентов (аппаратные, программные, web, мобильные)
* Доступные аппаратные ресурсы для тестирования (кол-во и тип ядер, объём ОЗУ)
Спасибо за внимание, не пропустите маленький опрос! | https://habr.com/ru/post/514560/ | null | ru | null |
# Сначала фронт, а потом бэк (когда-нибудь)
Перед тем как начать реализацию новой фичи, приходится изрядно поломать голову.
Разработка сложного функционала требует тонкой координации усилий коллектива инженеров.
И одним из важнейших моментов является вопрос распараллеливания задач.
Возможно ли избавить фронтовиков от необходимости ждать реализацию бэка? Есть ли способ распараллелить разработку отдельных фрагментов UI?
Тему распараллеливания задач в веб-разработке мы и рассмотрим в этой статье.
### Проблема
Итак, давайте для начала обозначим проблему. Представьте, что у вас есть матерый продукт (интернет сервис), в котором собрано довольно много разных микросервисов. Каждый микросервис в вашей системе — это своего рода мини-приложение интегрированное в общую архитектуру и решающее какую-то конкретную проблему пользователя сервиса. Представьте, что сегодня утром (в последний день спринта) к вам обратился Product Owner по имени Василий и обявил: "В следующем спринте мы начинаем пилить Импорт Данных, который сделает пользователей сервиса еще счастливее. Он позволит пользователю в сервис залить сразу стопиццот дофигаллиардов позиций из дремучей 1С!".
Представьте что вы менеджер или тимлид и слушаете все эти восторженные описания счастливых пользователей не с позиции бизнеса. Вы оцениваете сколько трудозатрат все это потребует. Как хороший менеджер вы прикладываете все усилия, чтобы уменьшить аппетиты Василия на скоуп задач для MVP (здесь и далее, Minimum Viable Product). При этом два главных требования для MVP — способность системы импорта выдержать большую нагрузку и работа в фоне, выкинуть нельзя.
Вы понимаете, что традиционным подходом, когда все данные обрабатываются в пределах одного запроса пользователя, обойтись не удастся. Тут придется городить огород всяких фоновых воркеров. Придется завязываться на Event Bus, думать о том как работает балансировщик нагрузки, распределенная БД и т.п. В общем все прелести микросервисной архитектуры. В итоге вы делаете вывод, что разработка бэкенда под эту фичу затянется, в гадалки не ходи.
Автоматом встает вопрос: "A что будут делать фронтовики все это время пока нет никакого API?".
Кроме того, выясняется, что данные-то надо импортировать не сразу. Нужно сначала провалидировать их и дать пользователю поправить все найденные ошибки. Получается хитрый воркфлоу и на фронтенде тоже. А запилить фичу надо, как водится, "вчера". Стало быть и фронтовиков надо как-то так скоординировать, чтобы они не толкались в одной репе, не порождали конфликтов и спокойно пилили каждый свой кусок (см. КДПВ в начале статьи).
В иной ситуации мы могли бы начать пилить с бэка к фронту. Сначала реализовать бэкенд и проверить, что он держит нагрузку, а потом спокойно навешивать на него фронтэнд. Но загвоздка в том, что спеки описывают новую фичу в общих чертах, имеют пробелы и спорные моменты с точки зрения юзабилити. А что, если в конце реализации фронта выяснится, что в таком виде фича не удовлетворит пользователя? Изменения юзабилити могут потребовать изменений в модели данных. Придется переделывать и фронт и бэк, что будет очень дорого.
### Agile пытается нам помочь
Гибкие методологии дают мудрый совет. "Начните со скейта и покажите пользователю. Вдруг ему понравится. Если понравилось, продолжайте в том же духе, прикручивайте новые фишки."
Но что, если пользователю сразу нужен как минимум мотоцикл, причем уже через две-три недели? Что если для начала работы над фасадом мотоцикла нужно хотя бы определиться с габаритами мотора и размерами ходовой части?
Как сделать так, чтобы реализация фасада не откладывалась до тех пор, пока не появится определенность с остальными слоями приложения?
В нашей ситуации лучше применить другой подход. Лучше сразу начать делать фасад (фронт), чтобы убедиться в корректности изначального представления об MVP. С одной стороны, подсунуть Product Owner'у Василию декоративный фасад, за которым ничего нет, кажется читерством, надувательством. С другой стороны, мы очень быстро получаем таким образом фидбек именно о той части функционала, c которой в первую очередь столкнется пользователь. У вас может быть неимоверно крутая архитектура, но если удобства использования нет, то какульками забросают все приложение целиком, не разбираясь в деталях. Поэтому мне кажется более важным выдать максимально функциональный UI как можно быстре, вместо того, чтобы синхронизировать прогресс фронтовой части с бэкендом. Нет смысла выдавать на пробу недоделанный UI и бэк, функционал которых не удовлетворяет главным требованиям. В то же время выдача 80% требуемого функционала UI, но без работающего бэка, вполне может оказаться профитной.
### Немного технических деталей
Итак, я уже описывал вкратце какую фичу мы собираемся реализовать. Добавим немного технических деталей.
Пользователь должен иметь возможность выгрузить в сервис файл данных большого объема. Содержимое этого файла должно соответствовать определенному формату (например, CSV). В файле должна быть определенная структура данных и есть обязательные поля, которые не должны быть пустыми. Иными словам, после выгрузки в бэкенде нужно будет данные провалидировать. Валидация может длиться значительное время. Держать коннект к бэкенду открытым нельзя (отвалится по таймауту). Поэтому мы должны быстро принять файл и запустить фоновую обработку. По окончанию валидации мы должны оповестить пользователя, что он может приступить к редактированию данных. Пользователь должен исправить ошибки, обнаруженные при валидации.
После того, как все ошибки исправлены, пользователь нажимает кнопку импорта. Исправленные данные отправляются обратно в бэкенд. для завершения процедуры импорта. О ходе всех стадий импорта мы должны оповещать фронтенд.
Самый эффективный способ оповещения — WebSocket'ы. С фронта через Websocket с определенным периодом будут отправляться запросы на получения текущего статуса фоновой обработки данных. Для фоновой обработки данных нам понадобятся фоновые обработчики, распределенная очередь команд, Event Bus и т.д.
Dataflow видится следующим (для справки):
1. Через файловый API браузера просим пользователя выбрать нужный файл с диска.
2. Через AJAX отправляем файл в бэкенд.
3. Ожидаем окончания валидации и распарсивания файла с данными (опрашиваем статус фоновой операции через Websocket).
4. По окончании валидации грузим подготовленные к импорту данные и рендерим их в таблице на странице импорта.
5. Пользователь редактирует данные, исправляет ошибки. По нажатию на кнопку внизу страницы отправляем исправленные данные в бэкенд.
6. Опять на клиентской стороне запускаем периодический опрос статуса фоновой операции.
7. До окончания текущего импорта у пользователя не должно быть возможности запустить новый импорт (даже в соседнем окне браузера или на соседнем компьютере).
### План разработки
#### Мокап UI vs. Прототип UI
Давайте сразу обозначим разницу между Wireframe, Mockup, Prototype.
На рисунке выше изображен Wireframe. Это просто рисунок (в цифре или на бумаге — не суть важно). С другими двумя понятиями сложнее.
Мокап — это такая форма представления будущего интерфейса, которая используется только в качестве презентации и в последствии будет заменена полностью. Эта форма в будущем будет отложена в архив как образец. Реальный интерфейс будет делаться с помощью других инструментов. Мокап можно сделать в векторном редакторе с достаточной детализацией дизайна, но потом фронтенд-разработчики просто отложат его в сторону и будут подглядывать на него как образец. Мокап может быть сделан даже в специализированных браузерных конструкторах и снабжен ограниченной интерактивностью. Но судьба его неизменна. Он станет образцом в альбоме Design Guide.
Прототип же создается с помощью тех же инструментов, что и будущий интерфейс пользователя (например, React). Код прототипа размещается в общем репозитарии приложения. Он не будет заменен, как это происходит с мокапом. Сначала его используют для проверки концепции (Proof of Concept, PoC). Потом, если он пройдет проверку, его начнут развивать, постепенно превращая в полноценный интерфейс пользователя.
Теперь ближе к делу...
Представим, что коллеги из цеха дизайна представили нам артефакты своего творческого процесса: mockup'ы будущего интерфейса. Наша задача спланировать работу так, чтобы как можно скорее сделать параллельную работу фронтовиков возможной.
Как составление алгоритма начинается с блок-схемы, так и создание прототипа начинаем с минималистичного Wireframe'а (см. рисунок выше). На этом Wireframe мы делим будущий функционал на крупные блоки. Главный принцип тут — фокусировка ответственности. Не следует разделять один кусок функциональности на разные блоки. Мухи идут в один блок, а котлеты в другой.
Далее нужно как можно быстрее создать заготовку страницы (пустышку), настроить Routing и разместить в меню ссылку на эту страницу. Затем нужно создать заготовки базовых компонентов (по одному на каждый блок в Wireframe прототипа). И закаммитать этот своеобразный фреймворк в ветку разработки новой фичи.
Получаем такую иерархию веток в git:
```
master ---------------------- >
└ feature/import-dev ------ >
```
Ветка "import-dev" будет играть роль development бранча для всей фичи. У этой ветки желательно закрепить одного ответственного человека (мэйнтейнера), который мержит атомарные изменения от всех параллельно работающих над фичей коллег. Также желательно не делать прямых каммитов в эту ветку, чтобы уменьшить шанс конфликтов и неожиданных изменений при мерже в эту ветку атомарных пулл реквестов.
Т.к. у нас на этот момент уже созданы компоненты для основных блоков на странице, то можно уже сразу создавать отдельные ветки под каждый блок UI. Финальная иерархия может выглядеть так:
```
master ----------------------- >
└ feature/import-dev ------- >
├ feature/import-head ---- >
├ feature/import-filter -- >
├ feature/import-table --- >
├ feature/import-pager --- >
└ feature/import-footer -- >
```
**Примечание:** *неважно в какой момент создать эти атомарные бранчи и конвенция наименования, представленная выше, не единственная годная. Бранч можно создать непосредственно перед началом работы. А имена бранчей должны быть понятны всем участникам разработки. Имя должно быть как можно короче и при этом явно указывать на то, за какую часть функционала ветка отвечает.*
Подходом, описанным выше, мы обеспечиваем безконфликтную работу нескольких разработчиков UI. У каждого фрагмента UI свой каталог в иерархии проекта. В каталоге фрагмента есть основной компонент, его набор стилей и свой набор дочерних компонентов. Также у каждого фрагмента может быть свой менеджер состояния (MobX, Redux, VueX сторы). Возможно, компоненты фрагмента используют какие-то глобальные стили. Однако изменять глобальные стили при разработке фрагмента новой страницы запрещено. Изменять дефолтное поведение и стиль общего атома дизайна также не стоит.
**Примечание:** *под "атомом дизайна" подразумевается элемент из набора стандартных компонентов нашего сервиса — см. [Atomic Design](http://bradfrost.com/blog/post/atomic-web-design/); в нашем случае предполагается, что система Атомарного Дизайна уже реализована.*
Итак, мы физически отделили фронтовиков друг от друга. Теперь каждый из них может работать спокойно, не боясь конфликтов при мерже. Также каждый может в любой момент создать пулл реквест из своей ветки в **feature/import-dev**. Уже сейчас можно спокойно набрасывать статичесий контент и даже формировать интерактив в пределах одного хранилища состояния.
Но как нам обеспечить возможность взаимодействия фрагментов UI между собой?
Нам необходимо реализовать связующее звено между фрагментами. На роль связки между фрагментами подходит JS сервис, выполняющий роль шлюза для обмена данными с бэком. Через этот же сервис можно реализовать нотификацию о событиях. Подписываясь на одни события, фрагменты неявно будут включены общий жизненный цикл микросервиса. Изменения данных в одном фрагменте приведут к необходимости обновить состояние другого фрагмента. Иными словами, мы сделали интеграцию фрагментов посредством данных и событийной модели.
Для создания этого сервиса нам понадобится еще одна ветка в git:
```
master --------------------------- >
└ feature/import-dev ----------- >
├ feature/import-js-service -- >
├ feature/import-head -------- >
├ feature/import-filter ------ >
├ feature/import-table ------- >
├ feature/import-pager ------- >
└ feature/import-footer ------ >
```
**Примечание:** *не пугайтесь количества веток и не стесняйтесь плодить ветки. Git позволяет эффективно работать с большим количеством ветвлений. Когда вырабатывается привычка, ветвиться становится легко:*
```
$/> git checkout -b feature/import-service
$/> git commit .
$/> git push origin HEAD
$/> git checkout feature/import-dev
$/> git merge feature/import-service
```
*Кому-то это покажется напряжным, но профит минимизации конфликтов весомее. К тому же пока вы эксклюзивный владелец ветки, можете без опасений делать **push -f** без риска повредить чью-то локальную историю каммитов.*
#### Фэйковые данные
Итак, на предыдущем этапе мы сделали заготовку интеграционного JS-сервиса (importService), сделали заготовки фрагментов UI. Но без данных наш прототип работать не будет. Ничего не рисуется кроме статических декораций.
Теперь нам надо определиться с примерной моделью данных и создать эти данные в виде JSON или JS файлов (выбор в пользу того или другого зависит от настройки импортов в вашем проекте; настроен ли json-loader). Наш importService, а также его тесты (о них будем думать попозже) импортируют из этих файлов данные, необходимые для имитации ответов от реального бэкенда (он пока еще не реализован). Куда положить эти данные не суть важно. Главное, чтобы их можно было легко импортировать в сам importService и тесты в нашем микросервисе.
Формат данных, конвенцию именования полей желательно обговорить с разработчиками бэка сразу. Можно, например, договориться об использовании формата, соответствующего спецификации [OpenAPI Specification](https://swagger.io/specification/). Какой бы спецификации формата данных ни следовал бэк, фэйковые данные мы создаем в точном соответствии формату данных в бэке.
**Примечание:** *не бойтесь ошибиться с моделью фэйковых данных; ваша задача сделать драфтовую версию контракта данных, который потом все равно будет согласоваться с разработчиками бэкенда.*
#### Контракты
Фэйковые данные могут служить хорошим заделом для начала работы над спецификацией будущего API в бэке. И тут неважно кто и насколько качественно реализует драфт модели. Решающее значение играет совместное обсуждение и согласование с участием разработчиков фронта и бэка.
Для описания контрактов (спецификации API) можно использовать специализированные инструменты. Напр., [OpenAPI / Swagger](https://swagger.io/). По-хорошему, при описании API с таким инструментом нет нужды в присутствии всех разработчиков. Этим может заниматься один разработчик (редактор спецификации). Результатом коллективного обсуждения нового API должны были стать некие артефакты вроде MFU (Meeting Follow Up), по которым редактор спецификации и конструирует справочник для будущего API.
По окончании создания драфта спецификации не должно потребоваться много времени, чтобы проверить корректность. Каждый участник коллективного обсуждения сможет независимо от других сделать беглый осмотр для проверки, что его мнение было учтено. Если что-то покажется некорректным, то можно будет уточнить через редактора спецификации (обычные рабочие коммуникации). Если все удовлетворены спецификацией, то ее можно опубликовать и использовать как документацию на сервис.
#### Юнит-Тестирование
**Примечание:** *Лично для меня ценность юнит-тестов довольная низка. Тут я согласен с Дэвидом Хансоном ([David Heinemeier Hansson @ RailsConf](https://youtu.be/9LfmrkyP81M)). "Юнит-тесты — это отличный способ убедиться, что ваша программа ожидаемым образом делает д… мо." Но я допускаю особые кейсы, когда юнит-тесты приносят много пользы.*
Теперь, когда мы определились с фэйковыми данными, можно приступать к тестированию базового функционала. Для тестирования фронтовых компонентов можно использовать такие инструменты как karma, jest, mocha, chai, jasmine. Обычно рядом с тестируемым ресурсом JS кладется одноименный файл с постфиксом "spec" или "test":
```
importService
├ importService.js
└ importService.test.js
```
Конкретное значение постфикса зависит от настроек сборщика пакетов JS в вашем проекте.
Конечно, в ситуации, когда бэк находится в "противозачаточном" состоянии, очень трудно покрыть юнит-тестами все возможные кейсы. Но и предназначение у юнит-тестов немного другое. Они призваны протестировать работу отдельных кусочков логики.
К примеру, хорошо покрывать юнит-тестами разного рода хэлперы (helper), через которые между JS компонентами и сервисами расшариваются куски логики или неких алгоритмов. Также этими тестами можно покрыть поведение в компонентах и сторах MobX, Redux, VueX в ответ на изменение данных пользователем.
#### Интеграционное и E2E-тестирование
Под интеграционными тестами подразумеваются проверки поведения системы на соответствие спецификации. Т.е. проверяется, что пользователь увидит именно то поведение, которое описано в спеках. Это более высокий уровень тестирования в сравнении с юнит-тестами.
Например, тест, проверяющий появление ошибки под обязательным полем, когда пользователь стёр весь текст. Или тест, проверяющий, что генерируется ошибка при попытке сохранить невалидные данные.
E2E-тесты (End-to-End) работают на ещё более высоком уровне. Они проверяют, что поведение UI корректно. Например, проверка, что после отправки файла с данными в сервис, пользователю показывается крутилка, сигнализирующая о длящемся асинхронном процессе. Или проверка, что визуализация стандартных компонентов сервиса соответствует гайдам от дизайнеров.
Этот вид тестов работает при помощи некоторого фреймворка автоматизации UI. Например, это может быть [Selenium](http://www.seleniumhq.org/). Такие тесты вместе с Selenium WebDriver запускаются в некотором браузере (обычно Chrome с "headless mode"). Работают они долго, но снижают нагрузку на специалистов QA, делая за них смоук тест.
Написание этих видов тестов довольно трудоемко. Чем раньше мы начнем их писать, тем лучше. Не смотря на то, что унас нет еще полноценного бэка, мы уже можем начинать описывать интеграционные тесты. У нас уже есть спецификация.
С описанием E2E тестов препятствий еще меньше. Мы уже набросали стандартные компоненты из библиотеки атомов дизайна. Реализовали специфичные куски UI. Сделали некоторый интерактив поверх фэйковых данных и API в importService. Ничто не мешает начать автоматизацию UI как минимум для базовых кейсов.
Написанием этих тестов можно опять же озадачить отдельных разработчиков, если имеются не озадаченные люди. И также для описания тестов можно завести отдельную ветку (как описано выше). В ветки для тестов нужно будет периодически мержить обновления из ветки "**feature/import-dev**".
Общая последовательность мержей будет такой:
1. Например, девелопер из ветки "**feature/import-filter**" создал ПР. Этот ПР проревьюили и мэйнтейнер ветки "**feature/import-dev**" вливает этот ПР.
2. Мэйнтейнер обявляет, что влито обновление.
3. Девелопер в ветке "**feature/import-tests-e2e**" затягивает крайние изменения мержем из "-dev ветки.
#### CI и автоматизация тестирования
Фронтовые тесты реализуются с помощью инструментов, работающих через CLI. В package.json прописываются команды для запуска разных видов тестов. Эти команды используются не только девелоперами в локальной среде. Они нужны еще и для запуска тестов в среде CI (Continuous Integration).
Если сейчас мы запустим билд в CI и ошибок не обнаружится, то в тестовую среду будет доставлен наш долгожданный прототип (80% функционала на фронте при не реализованном еще бэке). Мы сможем показать Василию приблизительное поведение будущего микросервиса. Васлилий попинает этот прототип и, возможно, сделает кое-какие замечания (возможно даже серьезные). На данном этапе вносить коррективы не дорого. В нашем случае бэк требует серьезных архитектурных изменений, поэтому работа по нему может идти медленнее, чем по фронту. Пока бэк не финализирован, внесение изменений в план его разработки не приведет к катастрофическим последствиям. При необходимости что-то поменять на этом этапе мы попросим внести коррективы в спецификацию API (в сваггере). После этого повторяются шаги, описанные выше. Фронтовики по-прежнему не зависят от бэкендеров. Отдельные специалисты фронтенда не зависят друг от друга.
#### Бэкенда. Контроллеры-заглушки
Отправной точкой разработки API в бэке является утвержденная спецификация API ([OpenAPI / Swagger](https://swagger.io/)). При наличии спецификации работу в бэке также станет легче распараллеливать. Анализ спецификации должен навести разработчиков на мысль об основных элементах архитектуры. Какие общие компоненты / сервисы нужно создать, прежде чем приступать к реализации отдельных вызовов API. И тут опять же можно применить подход как с заготовками для UI.
Мы можем начать сверху, т.е. с наружнего слоя нашего бэка (с контроллеров). На этой стадии мы начинаем с раутинга, заготовок контроллеров и фэйковых данных. Слой сервисов (BL) и доступа к данным (DAL) мы пока не делаем. Просто переносим данные из JS в бэкенд и программируем контроллеры так, чтобы они реализовывали ожидаемые ответы для базовых кейсов, выдавая куски из фэйковых данных.
По завершению этой стадии фронтовики должны получить работающий бэкенд на статичных тестовых данных. Причем именно тех данных, на которых фронтовики пишут интеграционные тесты. По идее, в этот момент не должно составить большого труда переключить JS шлюз (importService) на использование заготовок контроллеров в бэке.
Ответная часть для запросов через Websocket концептуально не отличается от Web API контроллеров. Эту "ответку" также делаем на тестовых данных и подключаем importService к этой заготовке.
В конечном итоге весь JS должен быть переведен на работу с реальным сервером.
#### Бэкенд. Финализация контроллеров. Заглушки в DAO
Теперь настает очередь финализировать внешний слой бэка. Для контроллеров один за одним реализуются сервисы в BL. Теперь сервисы будут работать с фэйковыми данными. Добавкой на данном этапе является то, что в сервисах мы уже реализуем реальную бизнес-логику. На этой стадии желательно начать добавление новых тестов в соответствии с бизнес-логикой из спецификаций. Тут важно, чтобы не упал ни один интеграционный тест.
**Примечание:** мы по-прежнему не зависим от того, реализована ли схема данных в БД.
#### Бэкенд. Финализация DAO. Реальная БД
После того, как схема данных реализована в БД, мы можем перенести в нее тестовые данные из предыдущих этапов и переключить наш зачаточный DAL на работу с реальным сервером БД. Т.к. мы в БД переносим изначальные данные, создававшиеся для фронта, все тесты должны остаться актуальными. Если какой-то из тестов упадет, значит что-то пошло не так и нужно разбираться.
**Примечание:** *вообще с очень большой вероятностью работы со схемой данных в БД для новой фичи будет немного; возможно изменения в БД будут сделаны одновременно с реализацией сервисов в BL.*
По окончанию этой стадии мы получаем полноценный микросервис, альфа-версию. Эту версию уже можно показать внутренним пользователям (Product Owner'у, продуктологу или еще кому-то) для оценки как MVP.
Дальше уже пойдут стандартные итерации Agile по работе над исправлением багов, реализацией дополнительных фишек и финальной полировкой.
#### Заключение
Думаю не стоит использовать вышеописанное вслепую как руководство к действию. Сначала нужно примерить и адаптировать к своему проекту. Выше описан подход способный отвязать отдельных разработчиков друг от друга и позволить им работать в параллели при определенных условиях. Все телодвижения с бранчеванием и переносом данных, реализация заготовок на фэйковых данных кажутся значительным оверхэдом. Профит в этих накладных расходах появляется за счет увеличения параллелизма. Если в команде разработки состоят ~~полтора землекопа~~ два фуллстэка или один фротовик с одним бэкендером, то профита от такого подхода, наверное, будет неочень много. Хотя и в этой ситуации некоторые моменты вполне могут повысить эффективность разработки.
Профит этого подхода появляется тогда, когда мы в самом начале быстро реализуем заготовки, максимально приближенные к будущей реальной реализации и физически разделяем работы над разными частями на уровне структуры файлов в проекте и на уровне системы управления кодом (git).
Надеюсь, что вы нашли данную статью полезной.
Спасибо за внимание! | https://habr.com/ru/post/463067/ | null | ru | null |
# DFI снижает download-скорость первые 10 секунд
Недавно обратился клиент, который жаловался на низкую скорость download-загрузки на сети 802.11ac. В качестве доказательства он представил Speedtest скрин, на котором upload был равен 200mbps, а download 15-20mbps. В ходе траблшутинга с помощью iPerf мы заметили, что низкий показатель download продолжается только первые 10 секунд теста. Мы попытались разобраться почему...
Низкая скорость загрузки проявлялась только в том случае, если сервер находился за шлюзом провайдера. Если сервер находился в пределах сайта, то скорость загрузки не понижалась.
Мы проверили не происходит ли отбрасывание пакетов на одном из сетевых устройств сайта: точке доступа, коммутаторе или маршрутизаторе. На проводных интерфейсах это проверялось командой **display interface** , на беспроводном интерфейсе точки доступа командой **dis lmac radio-tx-statistics r 1** в режиме диагностики:
`system-view`
`[HUAWEI] diagnose`
`[HUAWEI-diagnose]`
`[HUAWEI-diagnose]dis lmac radio-tx-statistics r 1`
`Tx stats:`
`Received from fwd packets : 623`
`Received from fwd bytes : 99074`
`Airport successful packets : 623`
`Airport successful bytes : 116032`
`Dropped packets total : 0`
`Dropped packets by air : 0`
`Dropped packets by software : 0`
`TotolEncapFail : 0`
Потерь не было. Мы также сняли Wireshark дамп, чтобы убедиться, что в TCP потоке (stream) не происходило повторной пересылки и фрагментации пакетов. Этого не происходило: Ethernet payload (MTU) пакетов был стабильным 1500 байт.
Внимание привлек параметр **dynamic flow inspection enable** в конфигурации vap профиля (не во всех версиях прошивок DFI включен по умолчанию):
`wlan`
`vap-profile name default`
`dynamic flow inspection enable`
Dynamic Flow Inspection (DFI) идентифицирует приложения с трафиком TCP/UDP на основе поведения трафика и гарантирует, что трафик определенных приложений будет пересылаться по нисходящему направлению (downstream) с гарантированной скоростью.
DFI идентифицирует трафик с помощью программного процессаФункции DFI нужно около 10 секунд (в версии прошивки R21), чтобы идентифицировать приложение. В течение этого времемни пакеты пересылаются программным процессом, а не аппаратным процессом пересылки, что влияет на результат Speedtest, скорость тестирования которого тоже составляет около 10 секунд. После идентификации трафик начинает пересылаться аппаратным процессом, но Speedtest к тому времени уже завершен.
Для отключения DFI:
`[AC-wlan]vap-profile name testvap`
`[AC-wlan-vap-prof-testvap] dynamic flow inspection disable`
`Warning: This operation will make the game-turbo function ineffective. Continue? [Y/N]:y`
---
Известны также случаи [влияния DFI на чрезменое использование памяти AP](https://forum.huawei.com/enterprise/ru/forum.php?mod=viewthread&tid=1019734).
---
В данном кейсе нам пока не удалось разобраться почему низкая скорость загрузки проявлялась только в том случае, если сервер находился за шлюзом провайдера - если сервер, до которого произволили тест, находился в пределах сайта, то скорость загрузки не понижалась. | https://habr.com/ru/post/692398/ | null | ru | null |
# Отладка асинхронного JavaScript с помощью Chrome DevTools
#### Вступление
Возможность асинхронной работы с помощью callback-функций(далее просто возвращаемых функций) — отличительная особенность JavaScript. Использование асинхронных возвращаемых функций позволяет вам писать событийно-ориентированный код, но так же добавляет кучу проблем, ведь код перестает выполняться в линейной последовательности.
К счастью, теперь в Chrome Canary DevTools вы можете отслеживать весь стек вызовов асинхронных функций в JavaScript!
*Небольшая презентация стека асинхронных вызовов.*
Как только вы включите поддержку стека вызовов асинхронных функций в DevTools, вы сможете получить развернутую информацию о состоянии вашего веб приложения в любые моменты времени. Прогуливаться по полному стеку выполнения ваших обработчиков событий, функций setInterval, setTimeout, XMLHttpRequest, promises, requestAnimationFrame, MutationObservers и так далее.
Помимо того, что вы можете просматривать стек вызовов, вы так же можете анализировать значения любых переменных в любой момент выполнения функций. Это похоже на машину времени для наблюдения за выражениями.
Давайте включим поддержку этого функционала и пробежимся по нескольким сценариям.
#### Включение поддержки асинхронной отладки кода в Chrome Canary
Попробуйте новый функционал, включив его поддержку в Chrome Canary(build 35 и выше). Откройте страницу Sources в Chrome Canary DevTools.
Чекбокс «Async» находится на панели, следующей за панелью стека вызовов(Call Stack) с правой стороны. В зависимости от положения этого чекбокса, возможность отладки асинхронных функций будет включена или выключена(хотя, однажды его включив, скорее всего вы никогда не захотите его выключить).
#### Перехват отложенных событий и XHR ответов
Вы, возможно, уже видели подобное раньше в Gmail:
Если произойдет ошибка в отсылке запроса(возникнут проблемы на стороне сервера или проблемы с соединением с клиентской стороны), Gmail попробует переслать письмо черзе небольшой промежуток времнеи.
Чтобы продемонстрировать, как стек асинхронных вызовов сможет нам помочь проанализировать отложенные события и XHR ответы, я воосоздала описанную выше ситуацию с [примером заглушки Gmail](http://www.html5rocks.com/en/tutorials/developertools/async-call-stack/xhr/demo.html). Весь JavaScript код примера может быть найден по ссылке выше. Алгоритм его работы выглядит следующим образом:
*На схеме выше, методы, подсвеченные синим являются главными местами для применения новых возможностей DevTools, так как эти методы выполняются асинхронно.*
Если смотреть только в панель стека вызовов(Call Stack) в предыдущих версиях DevTools, точка останова(breakpoint) в функции postOnFail() даст вам лишь немного информации о том, где функция postOnFail() была вызвана. А теперь давайте взглянем на разницу со случаем, когда мы работаем со включенной возможностью отладки асинхронных вызовов:
| | |
| --- | --- |
| **До** | **После** |
| | |
| **Панель стека вызовов без поддержки асинхронных запросов**
Здесь вы можете увидеть, что вызов функции postOnFail() произошел из возвращаемой фукнции AJAX, но ничего более. | **Панель стека вызовов с поддержкой асинхронных запросов**
Здесь вы можете увидеть, что XHR был вызван из submitHandler(), который был вызван обработчиком события клика, объявленным в scripts.js. Круто! |
При использовании стека асинхронных вызовов, мы можем легко просматривать все цепочки вызовов. Например, мы можем определить, был ли вызов метода submitHandler() иницирован так же, как описано выше, или же через retrySubmit() как описано ниже:
Используя панель стека вызовов, вы так же можете сказать, привело ли к точке останова срабатывание события пользовательского интерфейса(например, клик), задержка setTimeout() или работа асинхронной возвращаемой функции.
#### Наблюдайте за выражениями асинхронно
Когда вы просматриваете ваш стек вызовов, ваши выражения, добавленные к отслеживанию, будут обновляться, чтобы отразить состояние, которое они принимали в указанный момент времени!
#### Выполняйте код из предыдущих состояний
В дополнение к простому наблюдению за выражениями, вы так же можете взаимодействовать со своим кодом из предыдущих состояний прямо в DevTools JavaScript консоли.
Представьте, будто вы Доктор Кто(Dr. Who) и вам нужна небольшая помощь в сравнении часов, которые у вас были до этого момента в Тардисе(Tardis) и «сейчас». Из консоли DevTools вы можете легко исполнять, сохранять и производить вычисления над значениями из разных точек выполнения.
*Использование JavaScript консоли для отладки асинхронного стека вызовов вашего кода.
Пример выше может быть найден [здесь](http://www.html5rocks.com/en/tutorials/developertools/async-call-stack/past-scope/demo.html)*
Оставаясь в DevTools для манипуляций с вашими выражениями, вы экономите время, которое бы у вас заняло возвращение предыдущих состояний кода, внесение изменений, и обновление страницы браузера.
#### На подходе: Отладка цепочек обещаний(promise)
Если в прошлом примере с Gmail вам было тяжело распутывать стек асинхронных вызовов без новой возможности DevTools, то вы, вероятно, можете себе представить, насколько труднее это будет проделать с более сложными асинхронными очередями, например, с цепочкой обещаний? Давайте еще раз пробежимся по последнему примеру из [обучения по обещаниям в JavaScript](http://habrahabr.ru/post/209662/) от [Джейка Арчибальда](http://jakearchibald.com/).
*Блок-схема JavaScript обещаний*
Вот небольшая анимация работы со стеком вызовов [в лучшем асинхронном примере](http://www.html5rocks.com/tutorials/es6/promises/async-best-example.html) от Джейка:
**До:**
***Панель стека вызовов без поддержки асинхронной отладки**
Обратите внимание, как мало информации предоставляет панель стека вызовов, когда мы отлаживаем обещания.*
**После:**
***Панель стека вызовов с поддержкой асинхронной отладки**
Вау, какие обещания! Огромное количество возвращаемых функций.*
*###### Примечание:
Поддержка обещаний для стека вызова будет готова очень скоро, как только реализация обещаний перерастет из версии в Blink в финальную версию в V8.
В духе возвращения назад во времени, если вы захотите сегодня посмотреть на асинхронные стеки вызовов для обещаний, вы можете воспользоваться версиями [Chrome 33 или Chrome 34](https://googledrive.com/host/0B8R1QvA3x5IbWll3M0hIYXVLZlk/). Зайдите в [chrome://flags/#enable-devtools-experiments](http://chrome://flags/#enable-devtools-experiments) и подключите поддержку эксперементальных DevTools. После перезагрузки Canary, зайдите в настройки DevTools, там появится возможность включить [поддержку асинхронных стеков вызовов](http://www.html5rocks.com/en/tutorials/developertools/async-call-stack/enable-async-experiments.gif).*
#### Погружаемся глубже в веб анимации
Давайте пойдем глубже в архивы HTML5Rocks. Помните статью Паула Левиса «Более компактные, производительные и быстрые анимации с помощью requestAnimationFrame»?
Откройте requestAnimationFrame демо и добавьте точку останова в начале метода update()(это где-то 874 строка) файла post.html. Со асинхронным стеком вызовов мы сможем «окунуться глубже» в requestAnimationFrame. И, так же, как и в примере с заглушкой Gmail, у нас появляется возможность пройтись назад к начальному событию(это событие scroll).
| | |
| --- | --- |
| **До** | **После** |
| | |
#### Отслеживаем изменения DOM с помощью MutationObserver
MutationObserver позволяет нам наблюдать за событиями в DOM. Рассмотрим простой пример: когда вы кликаете на кнопку, новый элемент DOM добавляется к блоку .
Добавим новую точку останова в функции nodeAdded() (строка 31) в файле demo.html. С помощью асинхронного стека вызовов, вы можете пройтись по истории вызовов назад через метод addNode() к начальному событию клика.
| | |
| --- | --- |
| **До** | **После** |
| | |
#### Примечания к отладке JavaScript кода с помощью асинхронного стека вызовов
##### Называйте свои функции
Если вы привыкли добавлять все ваши возвращаемые функции как анонимные функции, то, возможно, сейчас стоит пересмотреть своё решение и начать давать функциям имена, которые помогут вам сделать отладку с использованием асинхронного стека вызовов еще проще.
Например, возьмите анонимную функцию:
```
window.addEventListener('load', function(){
// do something
});
```
И дайте ей название. Скажем, windowLoaded():
```
window.addEventListener('load', function windowLoaded(){
// do something
});
```
Когда возникнет событие загрузки документа, это будет отражено при выводе стека с помощью DevTools, где вместо мистического названия "(anonymous function)" будет красоваться полное имя функции. Это заметно упростит читабельность истории вызовов, и в большинстве случаев позволит с первого взгляда понять, что там происходит.
| | |
| --- | --- |
| **До** | **После** |
| | |
#### Что дальше
Резюмируя все вышесказанное, все эти асинхронные возвращаемые функции будут отображать полный стек вызовов:
* **Таймеры**: Возвращают назад до момента инициализации setTimeout() или setInterval()
* **XHRы**: Возвращают назад до момента, где был вызван xhr.send()
* **Анимации**: Возвращают назад до момента вызова requestAnimationFrame
* **Обработчики событий**: Возвращают назад до момента установки обработчика с помощью addEventListener()
* **Наблюдатели изменений**: Возвращают назад до момента, где было вызвано события изменения
Так же полный стек изменений можно будет посмотреть в ближайшее время для следующих JavaScript API:
* **Обещания**: Возвращают назад до момента, где обещания было выполнено
* **Object.observe**: Возвращает назад до момента прикрепления возвращаемой функции
Возможность просмотра всего стека ваших возвращаемых функций должно быть ставит дыбом ваши волосы. Это возможность в DevTools будет особенно полезна, когда несколько асинхронных событий случается в зависимости друг от друга, или когда неперехваченное сообщение об ошибке возникает в одной из ваших асинхронных возвращаемых функций.
Дайте им шанс в Chrome Canary. Если у вас есть что нам сказать по этому поводу, напишите нам в группу [Chrome DevTools](https://groups.google.com/forum/#!forum/google-chrome-developer-tools) или [присылайте нам баги](http://crbug.com/new) в наш Chrome DevTools багтрекер. | https://habr.com/ru/post/218397/ | null | ru | null |
# Бэкапы своими руками для чайников
Давно известно, что сисадмины делятся на две категории: те, кто еще не делает бэкапы и те кто уже делает. В то время, когда одни ДЦ горят, а вторые внезапно исчезают, лучше всего принадлежать ко второй категории.
Итак, хочу поделиться опытом простого автоматического резервирования данных для чайников.
#### Задача
Необходимо по расписанию создавать резервные копии файлов и базы данных. Эти два процесса должны быть независимы друг от друга, потому что бэкап БД делается чаще, чем бэкап файлов (или наоборот).
##### Дано
* VPS на базе Centos 5 x86\_64.
* Панель управления ISP Manager. Стандартные средства ISP Manager не устраивают.
* Свободного места на сервере очень мало.
##### Цель
Получить архивы файлов и БД на сервере в определенной папке. Архивы должны быть доступны по http-протоколу.
##### **Решение**
Так как это первый опыт написания скриптов — код может показаться кому-то слегка корявым.
**Бэкап MySQL**
Делает дампы всех БД, доступных для указанного пользователя.
```
#!/bin/sh
# ---- Константы --------------------------------------
# Папка, куда складываем бекапы
BACKUP_DIR="/var/www/wscms/data/www/site.ru/backup/"
# Имя файла бекапа
BACKUP_FILE="sql.tar"
# Пользователь, владелец файла с бекапами
USER="wscms"
# Папка для временных дампов MySQL
MDIR="mysql/"
# Сервер БД MySQL
MHOST="localhost"
# MYSQL root пользователь
MUSER="root"
# MYSQL root пароль
MPASS="***************"
# Поставьте "-zcf" если хотите сжимать данные или "-cf" в противном случае
PARAMS="-cf"
#--- Служебные переменные --------------------------
# Путь к mysql.
MYSQL="$(which mysql)"
# Путь к mysqldump
MYSQLDUMP="$(which mysqldump)"
# Путь к tar
TAR="$(which tar)"
# Путь к chown
CHOWN="$(which chown)"
# Путь к RM
RM="$(which rm)"
# Путь к MKDIR
MKDIR="$(which mkdir)"
# ---- Получаем список баз данных
DBS="$($MYSQL -u $MUSER -h $MHOST -p$MPASS -Bse 'show databases')"
# ---- Чистим папку с дампами на случай, если она уже существовала
$RM -rf $BACKUP_DIR$MDIR
# ---- Создаем папку для дампов
$MKDIR -p $BACKUP_DIR$MDIR
# ---- Делаем дампы найденых баз. Старые дампы замещаются
for db in $DBS
do
FILE=$BACKUP_DIR$MDIR$db.sql
$MYSQLDUMP -u $MUSER -h $MHOST -p$MPASS $db > $FILE
done
# ---- Архивируем файлы
$TAR $PARAMS $BACKUP_DIR$BACKUP_FILE $BACKUP_DIR$MDIR
# ---- Удаляем уже не нужную нам папку с MySQL дампами
$RM -rf $BACKUP_DIR$MDIR
$CHOWN $USER $BACKUP_DIR
$CHOWN $USER $BACKUP_DIR$BACKUP_FILE
exit 0
```
**Бэкап файлов**
```
#!/bin/sh
# ---- Константы --------------------------------------
# Папка, куда складываем бекапы
BACKUP_DIR="/var/www/wscms/data/www/site.ru/backup/"
# Расширение файла бекапа
EXT=".tar"
# Директория, в которой лежат аккаунты
MAIN_DIR="/var/www/"
# Директория, в которой лежат сайты аккаунтов
DATA_DIR="/data/www/"
# Пользователь, владелец файла с бекапами
USER="wscms"
# Поставьте "-zcf" если хотите сжимать данные или "-cf" в противном случае
# используйте u для добавления только новых файлов
PARAMS="-cf"
#--- Служебные переменные --------------------------
# Путь к tar
TAR="$(which tar)"
# Путь к chown
CHOWN="$(which chown)"
RM="$(which rm)"
MKDIR="$(which mkdir)"
# ---- Создаем папку для дампов
$MKDIR -p $BACKUP_DIR
$CHOWN -R $USER $BACKUP_DIR
# ---- Для всех пользователей панели
for DIR in $(/usr/local/ispmgr/sbin/mgrctl -m ispmgr user | cut -d' ' -f1 | sed s/name=//)
do
# ---- Архивируем файлы
$TAR $PARAMS $BACKUP_DIR$DIR$EXT $MAIN_DIR$DIR$DATA_DIR
$CHOWN $USER $BACKUP_DIR$DIR$EXT
done
$CHOWN -R $USER $BACKUP_DIR
exit 0
```
Добавляем в CRON от root-пользователя
/bin/sh /backup/backup.sh
/bin/sh /backup/sql.sh
Ставим нужное нам расписание
После работы этих двух скриптов мы имеем бэкапы файлов каждого пользователя по отдельности и бекап MySql.
Теперь мы можем делать с ними все что угодно: либо на стороннем сервере в другом ДЦ забирать их с помощью wget, либо (как это реализовано у меня) с помощью несложного windows-приложения, загруженного в планировщик, ежедневно скачивать бэкапы на локальную машину.
В целях безопасности в папку site.ru/backup/ советую положить следующий .htaccess
Order Deny,Allow
Deny from all
Allow from Ваш.IP.Адрес, IP.Адрес.ВПС.Если.Используете.wget
Удачи Вам, и не теряйте свои данные. | https://habr.com/ru/post/132262/ | null | ru | null |
# Ботнет Trickbot облюбовал роутеры MikroTik. Сейчас Microsoft выяснила почему
Специалистам по информационной безопасности ботнет Trickbot известен с 2016 года. Его главная задача при заражении устройства — отслеживание конфиденциальной информации пользователя. Не фоточек или видео, нет, а связок пароль/логин для банковских приложений и других сервисов. В целом, ботнет заточен под корпоративный шпионаж, но страдают от него и обычные пользователи, причем «жертв» много. Со временем выяснилось, что ботнет особенно сильно «любит» роутеры MikroTik. Сейчас представители корпорации Microsoft [выяснили](https://www.bleepingcomputer.com/news/security/microsoft-creates-tool-to-scan-mikrotik-routers-for-trickbot-infections/), почему так сложилось.
### В чем опасность ботнета
С момента появления главным предназначением зловредного ПО Trickbot является кража паролей пользователей к учетным записям в разных банках. Полученные данные киберпреступники активно используют в банковских аферах.
С течением времени ботнет стал не только воровать данные пользователей. Его «научили» специальным образом модифицировать трафик пользователей и распространяться по сети. После того, как вирус попал в систему, он открывает доступ для новых зловредов. В общем, универсальный инструмент в руках киберпреступников.
Ботнет стал настолько опасным, что Microsoft и другим крупным корпорациям пришлось даже организовать совместную операцию по саботажу инфраструктуры управления и контроля (C2), используемой вредоносным ПО Trickbot. Партнерами Microsoft в этой непростой борьбе стали ESET, Lumen's Black Lotus Labs, NTT, Symantec и другие компании.
Microsoft решила найти лазейку в законодательстве для того, чтобы уничтожить инфраструктуру ботнета. Корпорация смогла использовать в суде закон США о товарных знаках для того, чтобы ликвидировать инфраструктуру ботнета. В 2020 году корпорация сообщила следующее: «Мы отключили ключевые компоненты инфраструктуры, чтобы те, кто управляет Trickbot, не смогли инициировать новые заражения или активировать вирусы-вымогатели, уже внедренные в компьютерные системы».
Правда, после этих действий ботнет не умер полностью, но все же его удалось значительно ослабить. Исследователи заметили одну вещь — зловред почему-то очень активно работал с роутерами MikroTik, атакуя их активнее прочих сетевых девайсов. Ну и сейчас корпорация Microsoft выяснила, почему так случилось.
> **Если вы читаете наш блог, вас могут заинтересовать эти тексты:**
>
>
>
> → [Как мы выбирали лучшие из новых видеокарт NVIDIA](https://slc.tl/AOd9T)
>
> → [Зачем дата-центры устанавливают динамические источники бесперебойного питания](https://slc.tl/13OR6)
>
> → [Стоит ли создавать собственный корпус для сервера](https://slc.tl/R-hbh)
### Что удалось выяснить?
В среду [корпорация Microsoft заявила](https://thehackernews.com/2022/03/trickbot-malware-abusing-hacked-iot.html), что операторы ботнета активно компрометируют роутеры MikroTik, чтобы использовать их с целью сокрытия местоположения серверов управления и контроля, которые собирают данные с зараженных компьютеров, а также отправляют команды операторам ботнета.
Схема достаточно простая и вместе с тем оригинальная. Вместо того, чтобы подключаться к управляющим серверам, инфицированные ПК и ноутбуки сначала подключаются с зараженным роутерам. А потом уже к серверам оператора ботнета. Таким образом, роутеры MikroTik являются «посредниками» в деле, организованном киберпреступниками.
Заражение роутеров — достаточно разумный ход взломщиков. Когда сотрудники отдела безопасности в компании анализируют соединения зараженных компьютеров, то видят лишь IP-адреса, которые принадлежат маршрутизаторам. То есть это почти полная иллюзия нормальной работы сети. Соответственно, расположение управляющих серверов скрыто и не может быть обнаружено без прямого доступа к прокси-маршрутизатору.
Именно таким образом злоумышленники добивались создания надежной, но сложно обнаруживаемой линии связи между зараженными ПК и сервером С2. Стандартные системы защиты просто не обнаруживали никаких подозрительных активностей. Ну а начиналось все как раз со взлома маршрутизатора MikroTik.
### Откуда такая любовь к производителю роутеров?
Дело в том, что девайсы от MikroTik работают с уникальной ОС, которая называется MikroTik RouterOS. Она дает возможность пользователям дистанционно передавать команды, которые используют протокол SSH. Достоинства роутеров — их гибкость, функциональность и возможность работы с большим количеством команд — превратились в слабое место. Операторы Trickbot при помощи всего одной команды заставляли большое количество устройств направлять трафик определенным образом. Пример команды:
`/ip firewall nat add chain=dstnat proto=tcp dst-port=449 to-port=80 action=dst-nat to-addresses= dst-address=`
Она создает новое правило, которое дает возможность получать данные от скомпрометированных компьютеров через порт 449. А потом эти данные передаются уже на командные серверы ботнета через 80-й порт.
Команда, к слову, вполне обычная, если так можно выразиться «легальная». Но в данном кейсе речь идет об использовании вполне обычных команд злоумышленниками.
### Способ взлома роутеров
Для массового взлома роутеров злоумышленники использовали несколько векторов атаки:
* Самая простая атака, направленная на роутеры с дефолтными паролями от MikroTik.
* Подбор паролей, возможно, с использованием данных, ранее собранных с других устройств MikroTik.
* Эксплуатация уязвимости CVE-2018-14847 на устройствах с версией RouterOS до 6.42. Этот способ позволяет считывать файлы вроде user.dat. К слову, именно эта уязвимость считается одной из наиболее критических для роутеров указанной компании.
Как только удавалось взломать роутер, злоумышленники меняли пароль для предотвращения перехвата управления девайсом со стороны владельца или кого-либо еще.
Для того, чтобы обезопасить пользователей, корпорация Microsoft выпустила открытый инструмент, который позволяет вести мониторинг состояния маршрутизаторов — как дома, так и в офисе. В ходе мониторинга решение от Microsoft выполняет несколько задач, включая:
* Получение версии устройства и ее сопоставление со всеми уязвимостями.
* Проверка запланированных тасков.
* Поиск подозрительных NAT-правил.
* Поиск DNS cache poisoning.
* Обнаружение изменений дефолтных портов.
* Поиск созданных пользователей, не являющихся дефолтными.
В целом, самый простой способ избежать заражения — это отключение удаленного доступа. Конечно, в том случае, если он не нужен пользователю. Ну и плюс стандартные методы вроде уникальных паролей, регулярной их смены, обновления прошивки и т.п.
Если все реализовать корректно, то проблем не будет. Не болейте.
[](https://selectel.ru/services/cloud/?utm_source=habr.com&utm_medium=referral&utm_campaign=Brand_Banner_Article_180322_Microtik) | https://habr.com/ru/post/654467/ | null | ru | null |
# A Bug Caused by the #line Directive in the Visual C++ Compiler
The #line directive is added by the preprocessor and can then be used to help the developer understand which file and line a particular code fragment in the preprocessed file refers to. The #line directive tells code-processing tools to change the compiler's internally stored line number and filename to a given line number and filename. Subsequent lines will be numbered relative to that position. Explicit preprocessing is mostly used for debugging or by various generators. In any case, a bug breaking this functionality may have a variety of negative effects. One of our users was faced with such a problem in Visual Studio 2019.
The background of the bug
-------------------------
The #line directive is an important part of preprocessed files used by PVS-Studio to issue warnings on problem code lines in users' programs. This is where the story of hunting down the bug begins.
One of our users, who had a large code base, started moving his project from Platform Toolset v141 to v142 in Visual Studio 2019. After that, he got a pile of V002 warnings and several dozens of other warnings pointing at wrong code lines (1 line ahead of the actual one).
Incorrect line numbering is exactly the type of issues that diagnostic V002 detects. Such bugs typically have to do with multiline macros or other preprocessor directives (such as #pragma). It's not a common problem, but it's mostly seen with Microsoft's compiler. We were surprised to see so many warnings issued on one project as our testing system had never revealed any serious problems like that. So we started debugging the analyzer based on the user's preprocessed file.
A few hours later, we finally found that PVS-Studio was already working with incorrect line information, and were able to write a test case:
```
#define MACRO(a, b) // line1
// line2
int main(int argc, char* argv[]) // line3
{ // line4
MACRO("Some string", // line5
42); // line6
return 0; // line7 <=
}
```
This is what we get as a preprocessed file:
```
#line 1 "D:\\_Tests\\TestApp\\Project2\\rnd_bs.cpp"
int main(int argc, char* argv[])
{
;
#line 8 "D:\\_Tests\\TestApp\\Project2\\rnd_bs.cpp"
return 0;
}
```
The *return* statement is at line **7** in the source file, while the preprocessor points at line **8** instead. This bug in the preprocessor was presumably caused by a multiline macro.
Release of a fixed version
--------------------------
As of this writing, the problem exists in the recent Visual Studio versions up to 16.4.3 (released on January 14, 2020). We submitted a bug report "[Invalid #line directive after preprocessing (VS2019, v142)](https://developercommunity.visualstudio.com/content/problem/881472/invalid-line-direcitve-after-preprocessing-vs2019.html)" and got a curious reply four days later:
*This issue has been identified as a duplicate of an earlier reported feedback linked here: [developercommunity.visualstudio.com/content/problem/738407/preprocessor-generates-incorrect-line-information.html](https://developercommunity.visualstudio.com/content/problem/738407/preprocessor-generates-incorrect-line-information.html). If you reported or voted here, your vote has been applied to the original issue. Everyone else can add their vote directly at the above linked feedback. Voting helps increase the priority of the issue by consolidating customer impact under one feedback. Thank you!*
It turns out this problem was already reported on **September 18, 2019** – almost half a year ago: "[Preprocessor generates incorrect line information](https://developercommunity.visualstudio.com/content/problem/738407/preprocessor-generates-incorrect-line-information.html)". The user included similar test cases to reproduce the bug. According to him, it goes back to at least Visual Studio 2019 16.2.
I'm not sure if this is a coincidence or not, but a few days after our activity, the bug was assigned the status **Fixed — Pending Release**.
**On May 19, 2020, a fixed Visual Studio 2019 16.6.0 was released. It is recommended that all PVS-Studio users update to that version.** | https://habr.com/ru/post/502912/ | null | en | null |
# Как вырезать ненужные инклуды css и js из Друпальных тем (6.х версии)
Здравствуйте, хабра-товарищи!
Я часто встречаю сообщения о том, что в Друпальных темах вечно мешаются лишние друпальные css инклуды (файлы вроде system.css, defaults.css, node.css), которые воздействуют на уже заготовленные стили и мешают спокойно жить верстальщикам.
Собственно о том, как грамотно от этих инклудов избавиться я сейчас и расскажу (решение не подойдет для тех, кто по какой-то причине предпочитает видеть админку в теме сайта — даже не приступайте к этим действиям!!!).
Для начала открываем файл **template.php**, который находится в нужной теме.
Затем куда душе угодно добавляем следующий код (замените YOURFUNCTIONNAME на имя вашей темы):
`function YOURFUNCTIONNAME_preprocess_page(&$vars) {
if( request_uri() != '/admin/build/block' ){
// получаем массив всех css
$css = drupal_add_css();
// Удаляем неугодные элементы
unset($css['all']['module']['modules/system/system.css']);
unset($css['all']['module']['modules/system/defaults.css']);
unset($css['all']['module']['modules/system/system-menus.css']);
unset($css['all']['module']['modules/node/node.css']);
unset($css['all']['module']['modules/views/css/views.css']);
// Возвращаем почищенный массив Друпалу
$vars['styles'] = drupal_get_css($css);
}
}`
Вот и все — лишние ненужные стили не тормозят загрузку страницы и своим стилям проще найти верный путь до глаз пользователя. Условие "*if( request\_uri() != '/admin/build/block' ){}*" здесь стоит для того, чтобы на странице редактировании блоков (которая хоть и является частью админки, все равно выводится в дизайне сайта) оставался нужный для работы функционал.
Раз уж мы порезали css, то аналогично возьмемся и за JavaScript инклуды. В ту же функцию *YOURFUNCTIONNAME\_preprocess\_page* добавляем:
`if(drupal_is_front_page()){
// Добавляем свеженький jQuery
drupal_add_js('misc/jquery_new.js');
// Получаем массив всех JS инклудов
$js = drupal_add_js();
// Вырезаем неугодный старенький jQuery
unset($js['core']['misc/jquery.js']);
// Возвращаем Друпалу почищенный массив JS
$vars['scripts'] = drupal_get_js('header', $js);
}`
~~Вот так можно легко избавиться от штатного JS вызова jQuery какой-то там бородатой 1.2.6 версии от 2008 года на главной странице (мне потребовалось на главной делать много сложного JS, который со старой версии jQuery не работал и таким образом я легко и просто устроил подмену).~~
Будьте осторожны с вырезанием JS — не загубите функционал Друпала :)
Вот и все! Надеюсь, это кому-то пригодится.
**UPDATE** По совету Anonym и Razunter, если требуется просто обновить версию jQuery, то лучше воспользоваться [патчем](http://drupal.org/files/issues/upgrade-to-jQuery-1.4_v2.patch) или модулем [jQuery Update](http://drupal.org/project/jquery_update). В случае с ручным вырезанием инклудов JavaScript могут возникнуть проблемы. | https://habr.com/ru/post/87497/ | null | ru | null |
# Nemesida WAF 2021: защита сайтов и API от хакерских атак
Активное применение WAF началось более 10 лет назад. Пытаясь решить проблему защищенности веб-приложений, администраторы WAF сталкивались с побочными последствиями - большим количеством ложных срабатываний, сложностью настроек и пропусками (хотя о последнем чаще можно было узнать после успешной атаки). Время шло, в арсенале разработчиков появлялись новые инструменты (например, возможность применения машинного обучения), недостатки устранялись, повышалось удобство пользования, но все равно многие не торопятся использовать WAF.
Несмотря на рекомендации лучших практик, есть 2 основных проблемы, по которым использование WAF затрудняется - блокирование легитимных запросов и затраты на обслуживание (установка/настройка/обновление/масштабирование). Ниже расскажу, как Nemesida WAF решает эти проблемы, ровно как и другие: пропуски атак, поиск уязвимостей и блокирование продвинутых ботов.
На старт, внимание, фолс!
-------------------------
Ложные срабатывая - главная причина, почему администраторы отказываются использовать WAF. В попытках найти компромис между ложными срабатываниями (FP) и пропусками атак (FN), разработчики WAF старались более точно описывать правила блокировок или увеличивать порог, необходимый для блокирования запроса, повышая шанс пропустить атаку. Наступило время задействовать машинное обучение для решение этой проблемы.
https://twitter.com/neeraj\_sonaniya/status/1089235277250387969В 2018, используя различные научные работы и, конечно же, эмпирический путь, нам удалось [интегрировать](https://waf.pentestit.ru/about/4578) алгоритмы машинного обучения в Nemesida WAF, которые показали высокую точность выявления атак. Вместе с тем мы столкнулись с другой проблемой - анализ запросов с использованием ML кратно повышал требования к аппаратному обеспечению и значительно уступал по времени обработки сигнатурному анализу.
Решением проблемы стал комбинированный анализ - запросы с явными признаками атаки отсекались сразу сигнатурами, а неявными - поступали на анализ в модуль машинного обучения Nemesida AI. Сегодня мы практически не имеем ложных срабатываний, при этом анализ запросов почти не увеличивает время обработки запроса и не требует больших вычислительных мощностей. Для обработки боевого трафика 1200-1500 RPS процессор типа Xeon CPU E3-1245 3.40GHz будет загружен на 30-50%.
В редких случаях возникновения ложных срабатываний их всегда можно экспортировать в один клик, после чего схожие запросы не будут блокироваться и войдут в обучающую выборку модуля машинного обучения. Кроме этого, применение классических алгоритмов машинного обучения позволило нам снизить до минимума требования к аппаратному обеспечению. Таким образом, построение моделей и анализ запросов происходит на стороне клиента, не передавая трафик за периметр его инфраструктуры.
Назойливые хитрые боты
----------------------
Помимо атак, связанных с попытками поиска и эксплуатаций уязвимостей, боты приносят не меньше проблем. Одни перегружают сервер избытком запросов, другие - сливают бюджет за счет злоупотребления функционалом авторизации или восстановления пароля по СМС. Для блокирования подобных атак в Nemesida WAF используется 3 механизма:
* выявление попыток перебора значений (подбор логина/пароля и т.д.)
* выявление попыток злоупотребления СМС-функционалом
* выявление DDoS Layer 7
Блокирование попыток подбора пароляНезависимо от того, на что направлена атака ботов, Nemesida WAF довольно точно определит ее признаки и заблокирует практически всех участников.
Интеграция с GeoIP-сервисами
----------------------------
Наличие GeoIP-данных источника запроса часто помогает правильно реагировать на сомнительные запросы, поэтому в процессе работы модули Nemesida WAF активно используют такой функционал: библиотеку `libmaxminddb0` для получения **базовой** информации по IP, и [онлайн GeoIP-базу](https://ip.pentestit.ru) для получения **расширенной** информации (является ли IP-адрес прокси-сервером/TOR, используется ли он мобильными операторами или закреплен за дата-центром, его страну, город, провайдера и т.д). Расширенная информация используется при автоматическом анализе модулями Nemesida WAF, а также при визуализации событий в Личном кабинете.
Вывод расширенных GeoIP-данных
> Демонстрационный стенд Личного кабинета: [https://demo.lk.nemesida-waf.com/](https://demo.lk.nemesida-waf.com/waf/personal/) (demo@pentestit.ru / pentestit)
>
>
Использование функционала CAPTCHA для отмены временной блокировки IP
--------------------------------------------------------------------
В Nemesida WAF есть функционал временного блокирования атакующего по IP-адресу, позволяя ограничить доступ к ресурсу. Используя функционал управления Nemesida WAF Management API в сочетании с CAPTCHA, пользователь может снять временный бан, успешно пройдя проверку.
Nemesida WAF Scanner
--------------------
Использование динамического сканера уязвимостей в составе Nemesida WAF позволяет повысить уровень защищенности веб-приложений - вы можете активировать периодический обход веб-ресурса сканером, а также выполнять проверки уязвимостей "на лету" через заблокированные запросы. В последнем случае, используя Личный кабинет, при клике на кнопке Recheck (**R**) в строке с заблокированных запросом, сканер попытается проверить наличие уязвимостей в рамках этого запроса собственным набором пейлоадов, после чего сообщит, найдена ли уязвимость или нет.
Продвинутые техники декодирования запросов
------------------------------------------
Помимо привычного многим UTF-8 Basic Latin существует множество различных кодировок и наборов символов, многие из которых применяют для обхода WAF.
Данные запроса, использующие набор символов, отличный от Basic Latin, как правило, игнорируются сигнатурным анализом, но могут успешно "собираться" на стороне конечного веб-приложения и отрабатывать: всевозможные HTTP Entity Encode, Base64, UTF-8 Halfwidth and Fullwidth Forms, множественные URL Encode и т. д.
UTF-8: Basic LatinUTF-8: Halfwidth and Fullwidth FormsКроме этого, механизмы анализа некоторых WAF могут удалять "плохую последовательность", позволяя выолнять обход. Например, если WAF удаляет последовательность `UNION`, используемую при проведении SQLi, атакующий может обойти механизм, используя последовательность uni**UNION**on.
Не стоит забывать и про особенности обработки кода браузером. Вероятно, Safari умеет обрабатывать нестандартное представление UTF-16: `\u{22}` как `"` (`\u0022`):
https://twitter.com/garethheyes/status/1412486327539490818Многие способы обхода WAF основаны на использовании кодировок, отличных от UTF-8 text. Например, последовательность `alert()` можно частично или полностью передаться в UTF-8 (`\x61\x6c\x65\x72\x74\x28\x29`), UTF-16 (`\u0061\u006c\u0065\u0072\u0074\u0028\u002`9) или UTF-32 (`u+00000061u+0000006c...`). Также встречаются и смешанные кодировки.
В качестве другого примера я люблю использовать особенность обработки данных Bash-интерпретатором. В случае, когда веб-приложение содержит OS Command Injection, мы можем прочитать содержимое файла, например, `/etc/passwd`, выполнив расщепление данных с помощью кавычки: `ca't /et'c'/pas's'wd`. Также можно использовать символ `?`, который будет преобразован до нужной буквы: `/bi?/ca? /et?/pa??wd` (/bin/cat /etc/passwd).
Перекрыть такие техники без увеличения ложных срабатываний невозможно сигнатурным методом, но модуль машинного обучения вкупе с различными механизмами нормализации выявляет очень точно такие и другие методы обхода.
Вилкой в глаз или WAF baypass?
------------------------------
В начале года команда Vulners выпустила исследование, в котором анализировала различные популярные WAF с помощью байпасера (инструмент, проверяющий устойчивость WAF к пропускам атак и ложным срабатываниям), после чего мы, используя тот же инструмент, проверили его на Nemesida WAF и получили более высокую оценку. Если интересно, со статьей можно ознакомиться по [ссылке](https://habr.com/ru/company/pentestit/blog/540188/).
На Github мы опубликовали собственный [waf-bypass](https://github.com/nemesida-waf/waf-bypass), с помощью которого можно оценить используемый WAF. Это бесплатный инструмент содержит почти 1500 полезных нагрузок для SQLi, XSS, SSI, SSTI, RCE, LFI/RFI и т.д., написан на Python3 и доступен в виде Docker-образа.
Результат работы waf-bypass от Nemesida Security TeamИспользуя waf-bypass от Nemesida Security Team, вы проверяете WAF, в том числе, на возможность его обхода, используя техники, о которых я писал в предыдущем блоке.
> **Программа обучения WebSecOps от Pentestit**
>
> Для эффективного применения WAF одних технологий недостаточно, в некоторых случаях администратору необходимо понимать архитектуру веб-приложений, угрозы и признаки атаки, поэтому мы разработали программу WebSecOps, программу, направленную на практическую подготовку в области безопасности веб-приложений.
>
> Состав программы:
> - Архитектура веб-приложений;
> - Разведка и сбор информации;
> - Уязвимости веб-приложений: SQLi; NoSQLi; XSS; XXE; RCE; OSCI; SSTI; CSRF и другие;
> - Инструменты анализа защищенности веб-приложений;
> - Атаки методом перебора; WAF и техники обхода;
> - Выявление атак и анализ инцидентов с использованием Nemesida WAF.
>
> На WebSecOps вам предстоит производить поиск и эксплуатацию веб-уязвимостей с использованием специализированного инструментария, узнать архитектуру веб-приложений, научиться предотвращать атаки и анализировать инциденты с использованием WAF, изучить техники обхода. Программа разработана для специалистов в области информационной безопасности, пентестеров, разработчиков, системных администраторов, DevOps-инженеров и всех, кто только планирует погрузиться в мир веб-безопасности. Более подробная информация доступна по [ссылке](https://www.pentestit.ru/courses/websecops/).
>
>
Формат поставки и стоимость
---------------------------
Все модули Nemesida WAF представлены в виде установочных дистрибутивов для Ubuntu/Debian/CentOS и разворачиваются в инфраструктуре клиента (on-premises software). Анализ запросов и обучение поведенческих моделей происходит также в инфраструктуре клиента, не передавая запросы за периметр.
Стоимость в 2021 г. коммерческой версии Nemesida WAF начинается от 99.000 р. в год и зависит от используемых [опций](https://waf.pentestit.ru/about/4079#pricing) - наличие модуля машинного обучения, количества используемых экземпляров и поведенческих моделей, сканера уязвимостей. Но если пока не готовы к полноценной версии - можно попробовать бесплатную [Nemesida WAF Free](https://waf.pentestit.ru/about/2511), использующую только сигнатурный анализ и содержащую некоторые ограничения.
Свыше 400 клиентов по всему миру используют Nemesida WAF. Множественные механизмы парсинга и нормализации данных позволяют выявлять атаки практически в любом HTTP-трафике: от личных кабинетов и интернет-магазинов до маркетплейсов и API. Nemesida WAF работает "из коробки", базовый запуск для опытных пользователей занимает примерно 15 минут. Заблокированные запросы хранятся в PostgreSQL, позволяя провести интеграцию с SIEM-системами, а отсутствие механизмов изменения запросов позволяет не "ломать" логику веб-приложения. Протестируйте Nemesida WAF бесплатно в течение 2-х недель и узнайте, как часто вас атакуют. Оставайтесь здоровыми и защищенными. | https://habr.com/ru/post/565770/ | null | ru | null |
# Размазываем PHP
Настанет день, и ты поймешь, что одного потока в PHP тебе мало.
Сначала ты оптимизируешь код, потом пытаешься изменить сознание на асинхронный реакт, но весь PHP мир не хочет понимать такое стремление. Смотришь на phthreads, но после java concurrency чувствуешь, что тебя где-то “обманули”. А когда ты задумаешь покинуть процесс и начнешь захлебываться в форках exec’ах и сигналах, ты поймешь, что дальше погружаться нельзя. И, наконец, всплыв из всего этого, ты поплывешь к острову MOM (message-oriented middleware).
Оооо, а каких тут продавцов кирби только нет: RabbitMQ, ActiveMQ, Kafka, Kestrel и даже Redis pub/sub’ом подбарыживает. И у всех все хорошо: все самое лучшее, быстрое, безотказное. Но есть небольшая беда — шаг в сторону и, привет, теперь ты в числе толпы нытиков на stackoverflow в поисках воркэраундов и странных схем. И это будет продолжаться пока ты не найдешь ZeroMQ.
А что это? ZeroMQ — высокопроизводительная асинхронная месседж-ориентированная библиотека направленная на использование в масштабируемых распределенных или параллельных приложениях. Но в отличии от других месседж-ориентированных мидлваре она безброкерная и работает без сервера, как такового.
И что же тут предлагают тогда? А предлагают эти ребята набор сокетов на стероидах оптимизированных под основные месседж паттерны и использовать мы их можем как хотим. С их помощью можем построить сеть с любой топологией и сложностью.
Еще у них есть своя сектанская дока <http://zguide.zeromq.org/page:all>. Хорошо вправляет мозги в нужном направлении независимо от того, будешь использовать 0mq или нет, правда, если можешь в многопоточное программирование, можно частично пролистывать.
##### **В сухом остатке:**
* Набор стероидных сокетов
* Чертовски быстрые
* Работа через IPC,TCP, multicast, inproc
* Асинхронные
* Легкий старт
* Байндинги для овер 40 языков программирования
Звучит все это очень круто! Хватит теорий идем на [www.gliffy.com](https://www.gliffy.com) и яростно архитектурим систему. А хотим мы следующее:
* **Auth + task generator**
Отвечает за авторизацию на сервере и раздает нон-стоп задачи на парсинг.
* **Parse worker**
Получает ключ авторизации и задачу для парсинга после завершение возвращает результат генератору.
* **Parsed data publisher**
Получив результат от воркера, паблишит его всем сабскрайберам.
* **Alert system subscriber**
Получает данные и рассылает алерты, если нужно.
* **Upload system subscriber**
Получает данные и заливает их на сервер.
* **Data upload worker**
Енкодит, зипует и аплодит данные на сервер.
* **System monitor**
Собирает статистику системы в рейалтайме.
Архитектура получилась несложная, все компоненты были написаны отдельно от бизнес-логики, оформлены в пакет для композера и запаблишены на гитхаб:
<https://github.com/limitium/zmq>
##### **Чтоб поковырять, нужно (на примере дебиан):**
###### **1. Установить ZeroMQ**
```
sudo apt-get update -qq
sudo apt-get install -y libzmq3-dev
```
###### **2. Установить байндинг php-zmq**
```
git clone https://github.com/mkoppanen/php-zmq.git
sh -c "cd php-zmq && phpize && ./configure && make --silent && sudo make install"
echo "extension=zmq.so" >> `php --ini | grep "Loaded Configuration" | sed -e "s|.*:\s*||"`
```
###### **3. Установить либу через composer**
```
composer require limitium/zmq
```
Дальше берем, например, psr-3 логгер и смотрим, как он работает:
Логгер
```
$logger = new ZLogger('my_service_1', 'tcp://127.0.0.1:5555');
$logger->info("core is stable");
$logger->emergency("we're all going to die!");
```
Сборщик логов
```
(new Concentrator('tcp://127.0.0.1:5555'))
->setReceiver(function ($logMsg) {
$serviceName = $logMsg[0];
$time = $logMsg[1];
$logLevel = $logMsg[2];
$logMsg = $logMsg[3];
})
->listen();
```
Все просто, при этом логгер благодаря плюшкам ZeroMQ может работать как в рамках одного процесса, так и собирать информацию со 100500 серваков.
Пример генератора задач и воркера
Generator
```
(new Ventilator('tcp://127.0.0.1:5555'))
->setGenerator(function () {
sleep(1);
return rand();
})
->setResponder(function ($msg) {
echo $msg;
})
->listen();
```
Worker
```
(new Worker('tcp://127.0.0.1:5555'))
->setExecutor(function ($msg) {
return $msg + $msg;
})
->work();
```
И под конец банальный pub/sub
Publisher
```
$pub = new Publisher('tcp://127.0.0.1:5555');
$pub->send('azaza');
```
Subscriber
```
(new Subscriber('tcp://127.0.0.1:5555'))
->setListener(function ($msg){
echo $msg;
})
->listen();
```
Единственный минус ZeroMQ, который стоит отметить — чем больше интерпрзайности хочется от системы, тем больше придется писать кода. Но кого это волнует, когда запускается все в 2 строчки кода? | https://habr.com/ru/post/257281/ | null | ru | null |
# Обзор Java App Bundlers
Итак, [в прошлый раз](http://habrahabr.ru/post/178481/) я писал об инструменте для сборки приложений JavaFXPackager. Там было 2 каких-то способа собрать приложение, но ни один из них не мог быть удобно вызван просто из кода. Но мы же труЪ Java-программисты. И вот для таких труЪ-программистов с версии 8u20 и был создан в JDK специальный API в JavaFXPackager, который позволяет просто вот так взять и собрать бандл из ваших бинарников. Одна проблема — этот API незадокументирован. Но не беда, разберёмся.
#### Источники информации
Первичным источником будет, естественно, JavaDoc, который, впрочем, тоже не доступен публично. Поэтому мы соберём его сами из [исходников](http://hg.openjdk.java.net/openjfx/8u-dev/rt). Не заставляя это делать читателей, я просто выложу его: [ginz.bitbucket.org/fxpackager-javadoc](http://ginz.bitbucket.org/fxpackager-javadoc/). Конечно, нелишним будет иметь у себя исходный код, так как документирован API плохо.
#### Введение
Какой класс заставляет в первую очередь обратить на себя внимание? Видимо, интерфейс [Bundler](http://ginz.bitbucket.org/fxpackager-javadoc/com/oracle/tools/packager/Bundler.html) с вот такой спецификацией:
```
// action methods
File execute(Map params, File outputParentDir);
boolean validate(Map params);
// information methods
Collection> getBundleParameters();
String getBundleType();
String getDescription();
String getID();
String getName();
```
Методы явно делятся на 2 вида: методы, производящие действия с уже данными параметрами и методы, дающие информацию об этом бандлере.
execute принимает Map параметров и выходную директорию в качестве параметров и создаёт в данной директории бандл в каком-то ожидаемом формате. Но ожидать правильного исполнения мы можем только если validate проходит без исключений, а их он может кинуть 2 вида: UnsupportedPlatformException и ConfigException, говорящие названия которых подсказывают, что в случае выкидывания первого вы просто используете бандлер, который не поддерживается вашей платформой. Второй же выкидывается, если у вас что-то не так с переданными параметрами.
А что вообще можно передавать в качестве параметров в эти методы? Большая часть ключей в этих методах находится во всяких статических экземплярах класса [BundlerParamInfo](http://ginz.bitbucket.org/fxpackager-javadoc/com/oracle/tools/packager/BundlerParamInfo.html), большая часть из которых (общие кроссплатформенные параметры) находятся в классе [StandardBundlerParam](http://ginz.bitbucket.org/fxpackager-javadoc/com/oracle/tools/packager/StandardBundlerParam.html), а более специфичные (платформенно-зависимые), как правило, находятся в самих классах-реализациях [Bundler](http://ginz.bitbucket.org/fxpackager-javadoc/com/oracle/tools/packager/Bundler.html)'а: [LinuxAppBundler](http://ginz.bitbucket.org/fxpackager-javadoc/com/oracle/tools/packager/linux/LinuxAppBundler.html), [WinExeBundler](http://ginz.bitbucket.org/fxpackager-javadoc/com/oracle/tools/packager/windows/WinExeBundler.html) и так далее. Хотя не совсем очевидно, каким образом этот класс вообще связан с тем, что мы кладём в params, который передаём execute. На самом деле оказывается, что id, получаемый getID(), является ключом в этом Map'е, а значение должно быть типа, которым параметризован BundlerParamInfo.
#### А как получить экземпляры бандлеров?
Самый простой метод получения всех возможных «предустановленных» [Bundler](http://ginz.bitbucket.org/fxpackager-javadoc/com/oracle/tools/packager/Bundler.html)'ов через статический метод [createBundlersInstance](http://ginz.bitbucket.org/fxpackager-javadoc/com/oracle/tools/packager/Bundlers.html#createBundlersInstance--) интерфейса [Bundlers](http://ginz.bitbucket.org/fxpackager-javadoc/com/oracle/tools/packager/Bundlers.html) (Warning, HOT: Java 8):
```
public static List getSuitableBundlers() {
return Bundlers.createBundlersInstance()
.getBundlers()
.stream()
.filter(bundler -> {
try {
bundler.validate(Collections.emptyMap());
} catch (UnsupportedPlatformException ex) {
return false;
} catch (ConfigException ignored) {
}
return true;
}).collect(Collectors.toList());
}
```
Таким образом, мы не только получили все «предустановленные» бандлеры, но и отфильтровали их по платформенному принципу: как правило, невозможно собирать пакеты для одной платформы на другой.
#### И что, никаких примеров?!
А, точно, можно попробовать перестать теоретизировать и нарисовать какой-нибудь пример.
Поскольку мне кажется, что статическая типизация всегда лучше, то мы можем обернуть создание ассоциативного массива параметров во что-то типа BunderParamsBuilder:
```
public class BundlerParamsBuilder {
private Map params = new HashMap<>();
public BundlerParamsBuilder setParam(BundlerParamInfo param, T value) {
params.put(param.getID(), value);
return this;
}
public BundlerParamsBuilder unsafeSetParam(String key, Object value) {
params.put(key, value);
return this;
}
public Map build() {
return new HashMap<>(params);
}
}
```
Таким образом, сборка проекта будет заключаться примерно в следующем (подразумевается существование запускающегося /tmp/helloWorld.jar):
```
List bundlers = getSuitableBundlers();
Path directoryWithBundles = Files.createTempDirectory("bundles");
Path jar = Paths.get("/tmp/helloWorld.jar");
RelativeFileSet mainJar = new RelativeFileSet(jar.getParent().toFile(), new HashSet(
Arrays.asList(jar.toFile())
));
Map params = new BundlerParamsBuilder()
.setParam(StandardBundlerParam.APP\_NAME, "HelloWorld")
.setParam(StandardBundlerParam.APP\_RESOURCES, mainJar)
.build();
bundlers.forEach(bundler -> bundler.execute(params, directoryWithBundles.toFile()));
System.out.println("Bundles are created in " + directoryWithBundles);
System.out.println("Parameters after bundling: " + params);
```
Выхлоп после запуска будет примерно следующий:
```
Bundles are created in /tmp/bundles5791581710818077755
Parameters after bundling: {appVersion=1.0, copyright=Copyright (C) 2015, stopOnUninstall=true, .mac-jdk.runtime.rules=[Lcom.oracle.tools.packager.JreUtils$Rule;@4c3e4790, mac.app.bundler=Mac Application Image, linux.deb.imageRoot=/tmp/fxbundler6592356981290936843/images/linux-deb.image/helloworld-1.0/opt, buildRoot=/tmp/fxbundler6592356981290936843, mac.bundle-id-signing-prefix=HelloWorld., linux.deb.licenseText=Unknown, linux.deb.maintainer=Unknown , jvmProperties={}, mac.signing-key-user-name=, licenseFile=[], identifier=HelloWorld, linux.rpm.imageDir=/tmp/fxbundler6592356981290936843/images/linux-rpm.image, runtime=RelativeFileSet{basedir:/home/dginzburg/soft/jdk1.8.0\_25/jre, files:[]}, shortcutHint=false, mainJar=RelativeFileSet{basedir:/tmp, files:[helloWorld.jar]}, jvmOptions=[], name.fs=HelloWorld, fxPackaging=false, name=HelloWorld, appResources=RelativeFileSet{basedir:/tmp, files:[helloWorld.jar]}, mac.category=Unknown, linux.deb.imageDir=/tmp/fxbundler6592356981290936843/images/linux-deb.image/helloworld-1.0, .mac.default.icns=GenericAppHiDPI.icns, runAtStartup=false, linux.app.bundler=Linux Application Image, mac.signing-key-developer-id-app=null, linux.launcher.url=jar:file:/home/dginzburg/soft/jdk1.8.0\_25/lib/ant-javafx.jar!/com/oracle/tools/packager/linux/JavaAppLauncher, description=HelloWorld, configRoot=/tmp/fxbundler6592356981290936843/macosx, preferencesID=HelloWorld, title=HelloWorld, linux.bundleName=helloworld, startOnInstall=false, mac.pkg.packagesRoot=/tmp/fxbundler6592356981290936843/packages, licenseType=Unknown, linux.deb.fullPackageName=helloworld-1.0, mac.CFBundleIdentifier=HelloWorld, serviceHint=false, vendor=Unknown, email=Unknown, applicationCategory=Unknown, mac.app.imageRoot=/tmp/fxbundler6592356981290936843/images/dmg.image, userJvmOptions={}, classpath=, linux.deb.configDir=/tmp/fxbundler6592356981290936843/images/linux-deb.image/helloworld-1.0/DEBIAN, verbose=false, imagesRoot=/tmp/fxbundler6592356981290936843/images, mac.daemon.image=/tmp/fxbundler6592356981290936843/images/pkg.daemon, applicationClass=HelloWorld, .linux.runtime.rules=[Lcom.oracle.tools.packager.JreUtils$Rule;@38cccef, menuHint=true}
```
Ой, откуда у нас всё это тут взялось? Мы вроде клали в params только 2 параметра. Чтобы разобраться в этом, надо посмотреть на сорцы метода [BunderParamInfo.fetchFrom](http://ginz.bitbucket.org/fxpackager-javadoc/com/oracle/tools/packager/BundlerParamInfo.html#fetchFrom-java.util.Map-), который используется для того, чтобы получить значение параметра из params:
```
//...
if (getDefaultValueFunction() != null) {
T result = getDefaultValueFunction().apply(params);
if (result != null) {
params.put(getID(), result);
}
return result;
}
//...
```
Ага, если параметр не был найден в params и он может быть получен через другие параметры (за это отвечает функция defaultValueFunction), то значение, полученное таким образом, запихивается в params. Например, мы не указали параметр MAIN\_JAR, но MAIN\_JAR обязателен для того, чтобы создать запускаемый файл. Посмотрим на то, как определяется MAIN\_JAR: в качестве defaultValueFunction видим:
```
params -> {
extractMainClassInfoFromAppResources(params);
return (RelativeFileSet) params.get("mainJar");
}
```
Вот и ответ, откуда там появляется значение mainJar.
#### Полный список параметров
Для того, чтобы не искать каждый раз параметры, я сделал [табличку](http://ginz.bitbucket.org/bundlerParams.html), в которую вывел информацию по всем найденным статическим экземплярам BundlerParamInfo.
#### Заключение
Описан самый минимум и самые очевидные возможности, так что не стесняйтесь читать JavaDoc и даже код.
Статья будет улучшаться и исправляться по запросу комментаторов. | https://habr.com/ru/post/257363/ | null | ru | null |
# Первый самодельный клиент, который подключается к Skype Network
Skype — [один из самых небезопасных мессенджеров](https://www.eff.org/node/82654) по объективным причинам. Одна из них — обфусцированный бинарный файл, чтобы затруднить реверс-инжиниринг. Корпорация Microsoft отказывается предоставить исходный код для аудита и проверки специалистами по безопасности, последняя проверка [проводилась в 2005 году](https://download.skype.com/share/security/2005-031%20security%20evaluation.pdf).
Несмотря на все риски, многие люди вынуждены использовать клиент Skype.
Закрытость протокола и официального клиента вынудила активистов пойти на нарушение закона DMCA и принудительно деобфусцировать бинарный код клиента.
В рамках проекта Skype Open Source в июне 2011 года был проведён обратный инжиниринг протокола Skype 3.8.
В марте 2012 года был опубликован [деобфусцированный бинарный клиент оригинального Skype 5.5](http://www.phoronix.com/scan.php?page=news_item&px=MTA3NzU) со снятой защитой от отладки.
Skype 5.5 представлял собой некий гибрид графического интерфейса, написанного на Delphi, и встроенных библиотек DLL с «ядром». Ядро программы — полностью независимая структура на уровне бинарного кода: блоки кода, блоки данных, импорт. Если судить по наличию следов библиотек VC, то для компиляции программы использовался компилятор Visual C++.
Сейчас найти тот клиент и исходные коды непросто, потому что по требованиям DMCA хостеры удалили оригинальный блог, а также [почти все копии](https://github.com/downloads/skypeopensource/skypeopensource/skype55.zip) клиента `skype55.zip`, которые разошлись по Сети.
Прошли годы, корпорация Microsoft перевела пиринговую сеть супернодов Skype в свою собственную облачную сеть Skype Network, на которую перешла в последних версиях клиента, и немного изменила протокол: изменения касались в основном добавление DH-384 обмена ключами до старта RC4 шифрования. Активистам пришлось начинать работу заново — и проводить [реверс-инжиниринг нового протокола](http://skype-open-source2.blogspot.com.by/2016/06/skype-protocol-dumps.html).
Разработчики снова добились своего. 1 сентября 2016 года в новом блоге [Skype Open Source 2](http://skype-open-source2.blogspot.com/) опубликована [радостная весть](http://skype-open-source2.blogspot.com.by/2016/09/first-in-world-skype-network-compatible.html) о выходе первого в мире самодельного свободного клиента, совместимого с сетью Skype Network. Исходный код клиента [пока не удалён с Github](https://github.com/skypeopensource/skypeopensource2). Клиент ограничен передачей только текстовых сообщений.
Клиент Epycs Messenger написан на чистом Си, снабжён простым графическим интерфейсом на .NET 4.0. Соответственно, для установки требуется наличие среды .NET 4.0. Проект загружается и компилируется в Visual Studio 2010. Программа работает только под Windows. Автор говорит, что для портирования под Linux нужно слегка пошаманить с сокетами.
**Ссылки на скачивание бинарников:**
<http://epycs.ru/files/EpycsMessenger2_20160901.zip>
<https://yadi.sk/d/xvKhmImdugThn>
<http://dfiles.ru/files/ob1kzcc1x>
**Исходный код под LGPL 3.0:**
<http://epycs.ru/files/EpycsMessenger2_20160901_src.zip>
<https://yadi.sk/d/V_IWJT-fugvND>
<http://dfiles.ru/files/ryh285mue>
*На тестовой машине не удалось завершить процедуру импорта контактов*
Автором программы является [Ефим Бушманов](https://geektimes.ru/users/efimich/). Он же написал предыдущие версии деобфусцированного клиента Skype и был автором первого блога Skype Open Source.
Несмотря на предположительное нарушение DMCA, предлагается коммерческая лицензия на Epycs Messenger. Продолжается также сбор пожертвований на развитие проекта.
Теоретически, после реверс-инжиниринга протокола Skype любые мессенджеры могут свободно подключаться к сети Microsoft и напрямую обмениваться сообщениями с пользователями Skype, в том числе мессенджеры Telegram или Viber.
После публикации исходников на Github некоторые разработчики отмечают плохую структуру кода, [повсеместные магические строки](https://github.com/skypeopensource/skypeopensource2/blob/master/skycontact4_dll/skycontact4_dll/skype_login.c), [утечки памяти](https://github.com/skypeopensource/skypeopensource2/blob/master/goodsendrelay3/goodsendrelay3/tcp_recv.c#L500) и повсеместные [переполнения буфера](https://github.com/skypeopensource/skypeopensource2/blob/master/skyauth4_dll/skyauth4_dll/skype_login.c#L260). Впрочем, это не умаляет заслуг разработчика, который проделал большую работу. Автор просит протестировать программу и высказать свои предложения и пожелания.
**UPD 05.09**. Ефим Бушманов пишет, что загрузка контактов перестала работать. Похоже, Skype отключил сервера с контакт-листами совсем. Контакты можно добавить вручную, если добавить файл contacts.txt в корневую директорию и вручную добавить контакты из Skype в таком формате:
u/skypeuser1
u/skypeuser2
u/skypeuser3
u/skypeuser4
u/skypeuser5
Остальное вроде пока работает, говорит автор. | https://habr.com/ru/post/397351/ | null | ru | null |
# Разработка микросервисов с использованием Scala, Spray, MongoDB, Docker и Ansible
Цель данной статьи — показать возможный подход для построения [микросервисов](http://technologyconversations.com/2015/01/07/monolithic-servers-vs-microservices/) с использованием [Scala](http://www.scala-lang.org/), RESTful JSON, [Spray](http://spray.io/) и [Akka](http://akka.io/). В качестве базы данных мы будем использовать [MongoDB](http://www.mongodb.org/). В результате нашей работы мы упакуем наш проект в Docker-контейнер, а [Vagrant](https://www.vagrantup.com/) и [Ansible](http://www.ansible.com/home) позволит нам управлять конфигурацией приложения.
В этой статье вы не найдете подробностей о языке Scala и других технологиях, которые будут использоваться в проекте. В ней вы не найдете руководства, которое ответит на все ваши вопросы. Цель статьи — показать технику, которую можно использовать при разработке микросервисов. На самом деле, большая часть этой статьи не завязана на конкретной технологии. Docker имеет более широкую сферу использования, нежели только микросервисы. Ansible позволяют быстро развернуть любое требуемое окружение, а Vagrant — отличный инструмент для создания виртуальных машин.
Итак, приступим к созданию «Книжного сервиса» со следующими методами:
* Получить все книги
* Получить информацию о книге
* Обновить существующую книгу
* Удалить существующую книгу
#### Окружение
Мы будем использовать Ubuntu в качестве сервера. Наиболее простой путь его создать – воспользоваться Vagrant. Если у вас он еще не установлен, пожалуйста, скачайте его и установите. Вам так же потребуется [Git](http://git-scm.com/) для клонирования репозитория с исходным кодом. Остальная часть статьи не потребует от вас ручной установки дополнительных пакетов.
Приступим к клонированию репозитория
```
git clone https://github.com/vfarcic/books-service.git
cd books-service
```
Далее необходимо создать Ubuntu-сервер используя Vagrant со следующими настройками:
```
# -*- mode: ruby -*-
# vi: set ft=ruby :
VAGRANTFILE_API_VERSION = "2"
Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
config.vm.box = "ubuntu/trusty64"
config.vm.synced_folder ".", "/vagrant"
config.vm.provision "shell", path: "bootstrap.sh"
config.vm.provider "virtualbox" do |v|
v.memory = 2048
end
config.vm.define :dev do |dev|
dev.vm.provision :shell, inline: 'ansible-playbook /vagrant/ansible/dev.yml -c local'
end
config.vm.define :prod do |prod|
prod.vm.provision :shell, inline: 'ansible-playbook /vagrant/ansible/prod.yml -c local'
end
end
```
Мы определили *box* (ОС) как Ubuntu, *synced\_folder* означает, что всё, находящееся внутри каталога ./vagrant на хост-машине будет доступно внутри виртуальной машины. Остальную работу, по установке приложений и подготовки окружения мы возложим на Ansible, который будет установлен с помощью bootstrap.sh. В Vagrantfile находится две виртуальные машины: dev и prod. Каждая из них будет использовать Ansible, поэтому убедитесь, что он установлен корректно.
Классический путь работы с Ansible — разделить конфигурацию на роли. В нашем случае мы имеем 4 роли, находящиеся в ansible/roles. Первая роль включает в себя установку Scala и SBT. Еще одна устанавливает Docker. Третья устанавливает MongoDB-контейнер. Последняя роль (books) будет использоваться для разворачивания приложения на боевую виртуальную машину.
В качестве примера, объявим mongodb роль следующим образом:
```
- name: Directory is present
file:
path=/data/db
state=directory
tags: [mongodb]
- name: Container is running
docker:
name=mongodb
image=dockerfile/mongodb
ports=27017:27017
volumes=/data/db:/data/db
tags: [mongodb]
```
Эта роль гарантирует, что папка существует и контейнер mongodb работает. Плейбук ansible/dev.yml связывает эти роли вместе:
```
- hosts: localhost
remote_user: vagrant
sudo: yes
roles:
- scala
- docker
- mongodb
```
Каждый раз когда мы запускаем плейбук, выполняются все задачи из ролей scala, docker и mongodb.
Одна из прелестей Ansible в том, что он выполняет задачи только тогда, когда это нужно. Если вы запустите его во второй раз, он проверит, что всё на месте и ничего не сделает. Однако, если вы удалите папку /data/db, Ansible заметит пропажу и создаст её снова.
Время запускать виртуальную машину! Первый запуск, будет немного долгим, так как Vagrant необходимо скачать дистрибутив Ubuntu, установить пакеты и скачать Docker-образ MongoDB. Последующие запуски будут происходит заметно быстрее.
```
vagrant up dev
vagrant ssh dev
ll /vagrant
```
Команда vagrant up создает новую виртуальную машину или запускает одну из существующих. С vagrant ssh мы заходим на недавно созданную машину. И, наконец ll /vagrant показывает список файлов и директорий как доказательство того, что наши локальные файлы доступны внутри виртуальной машины.
Это всё. Наш сервер разработки со Scala, SBT и MongoDB готов к работе. Приступим к разработке нашего сервиса.
#### «Книжный сервис»
Мне нравится Scala, это очень мощный язык, а akka мой любимый фреймворк для построения message-driven JVM-приложений. Несмотря на то, что Akka появилась из Scala, ничто не мешает использовать её в Java.
Spray — это простой, но мощный инструмент для построения REST/HTTP сервисов. Он асинхронный, благодаря использованию Akka-акторов и имеет замечательный DSL для описания HTTP маршрутов.
В моду использования [TDD](http://technologyconversations.com/2014/09/30/test-driven-development-tdd/) мы пишем тесты перед реализацией. Вот пример тестов, который проверяет маршрут, по которому отдается список книг.
```
"GET /api/v1/books" should {
"return OK" in {
Get("/api/v1/books") ~> route ~> check {
response.status must equalTo(OK)
}
}
"return all books" in {
val expected = insertBooks(3).map { book =>
BookReduced(book._id, book.title, book.author)
}
Get("/api/v1/books") ~> route ~> check {
response.entity must not equalTo None
val books = responseAs[List[BookReduced]]
books must haveSize(expected.size)
books must equalTo(expected)
}
}
}
```
Это простой тест, который, надеюсь, покажет направление, в котором нужно двигаться для разработки тестов на API построенные на Spray. Первое, что мы проверяем — сервер, по данному запросу должен возвращать код 200 (ОК). Второе, на что мы обращаем внимание, что после добавления книги в базу данных, она корректно возвращается. Полный исходный код с тестами вы можете посмотреть в ServiceSpec.scala
Как реализованы эти проверки? Код, который это позволит, представлен ниже:
```
val route = pathPrefix("api" / "v1" / "books") {
get {
complete(
collection.find().toList.map(grater[BookReduced].asObject(_))
)
}
}
```
Мы определили маршрут /api/v1/books, GET метод и ответ внутри выражения complete(). В нашем случае мы получили список всех книг из БД и преобразовали его к кейс-классу BookReduced. Весь исходный код, включающий все методы (GET, PUT, DELETE) вы можете найти в ServiceActor.scala
Оба теста и реализация приведены в качестве примера, на практике они, как правило, сложнее. Но Spray с этим справляется по-настоящему здорово.
Во время разработки вы можете запустить тесты в быстром режиме.
```
#[Внутри виртуальной машины]
cd /vagrant
sbt ~test-quick
```
Каждый раз, при изменении исходного кода, все затронутые тесты будут запущены снова. Обычно у меня открыто окно терминала с результатами тестов, это дает мне возможность получать моментальную обратную связь о качестве кода, над которым я работаю.
#### Тестирование, сборка и развертывание
Наше приложение, как и любое другое, нуждается в тестировании, сборке и развертывании.
Давайте создадим Docker-контейнер с сервисом. Необходимые настройки вы можете указать в Dockerfile.
```
#[Внутри виртуальной машины]
cd /vagrant
sbt assembly
sudo docker build -t vfarcic/books-service .
sudo docker push vfarcic/books-service
```
Мы скомпилировали JAR (прохождение тестов — это часть этапа сборки), собрали Docker-контейнер и отправили это в Docker Hub. Если вы планируете воспроизвести эти шаги снова, пожалуйста, создайте аккаунт в hub.docker.com и измените «vfarcic» на ваш логин.
Контейнер, который мы создали содержит всё, что нужно для запуска нашего сервиса. Он основан на Ubuntu, содержит JDK7 с MongoDB и собранный JAR-файл. Этот контейнер может быть запущен на любой машине, с установленным Docker. Он не требует установки дополнительных зависимостей на сервер, контейнер самодостаточен и может быть запущен где угодно.
Давайте развернем (запустим) контейнер который мы создали на другой виртуальной машине. Это очень похоже на разворачивание приложение в production-среде.
Для создания production-виртуальной машины, с нашим сервисом необходимо выполнить следующие команды:
```
#[из директории с исходным кодом]
vagrant halt dev
vagrant up prod
```
Первая команда останавливает dev-виртуальную машину. Каждая машина требует 2ГБ ОЗУ, и если вы имеете достаточно свободной ОЗУ, то можете пропустить этот шаг. Вторая команда запускает production-машину, с развернутым сервисом.
Через некоторое время ожидания, виртуальная машина создастся, Ansible установится и запустит playbook prod.yml. Он установит Docker и запустит vfarcic/books-service, собранный на предыдущем шаге и отправленный в Docker Hub. Во время работы от будет использовать порт 8080 и иметь общую, с хостовой системой, папку /data/db.
Давайте попробуем, что у нас получилось. Для начала попробуем отправить PUT-запрос, чтобы добавить тестовые данные:
```
curl -H 'Content-Type: application/json' -X PUT -d '{"_id": 1, "title": "My First Book", "author": "John Doe", "description": "Not a very good book"}' http://localhost:8080/api/v1/books
curl -H 'Content-Type: application/json' -X PUT -d '{"_id": 2, "title": "My Second Book", "author": "John Doe", "description": "Not a bad as the first book"}' http://localhost:8080/api/v1/books
curl -H 'Content-Type: application/json' -X PUT -d '{"_id": 3, "title": "My Third Book", "author": "John Doe", "description": "Failed writers club"}' http://localhost:8080/api/v1/books
```
Давайте проверим, что сервис вернул нам корректные данные:
```
curl -H 'Content-Type: application/json' http://localhost:8080/api/v1/books
```
Мы можем удалить книгу:
```
curl -H 'Content-Type: application/json' -X DELETE http://localhost:8080/api/v1/books/_id/3
```
Проверим, что удаленная книга более не существует:
```
curl -H 'Content-Type: application/json' http://localhost:8080/api/v1/books
```
В заключение попробуем извлечь конкретный экземпляр книги:
```
curl -H 'Content-Type: application/json' http://localhost:8080/api/v1/books/_id/1
```
Мы попробовали быстрый способ разработки, сборки и разворачивания микросервиса. Docker упрощает разворачивание и не требует дополнительных зависимостей. Каждый сервис, требующий JDK и MongoDB не требует установленных приложений на конечной машине. Это всё является частью контейнера, который запущен как Docker-процесс.
#### Итоги
Идея микросервисов существовала долгое время, и до недавнего времени не получала должного внимания, из-за проблем совместимости приложений, необходимых для одновременной работы сотен и тысяч различных экземпляров сервисов. Преимущества, которые возникали благодаря использованию микросервисов (разделение, уменьшение срока разработки, масштабируемость и т.д) были не столь значимыми по сравнению с проблемами, которые они несли при обеспечении нужного окружения и разворачивании. Docker и такие инструменты как Ansible помогают значительно сократить усилия. С уходом от этой проблемы, самые разнородные микросервисы становятся в моде из-за преимуществ, которые они несут.
Spray — это отличный выбор для микросервиса. Docker-контейнеры содержат всё, что нужно для работы приложения, и ничего лишнего. Использование больших веб-серверов, таких как JBoss и WebSphere может быть неоправданно для небольшого сервиса. Даже в таких небольших серверах как Tomcat обычно нет необходимости. Play! — это замечательный фреймворк для построения RESTFul API, однако он содержит много вещей которые мы не используем. Spray, c другой стороны делает всего лишь одну вещь — предоставляет асинхронную маршрутизацию для RESTFul API, и делает это великолепно.
Мы можем продолжить расширять функционал сервиса. Например, мы можем добавить модуль регистрации и аутентификации.
Тем не менее, это приблизит нас на один шаг к монолитному приложению. В мире микросервисов новые сервисы должны быть новыми приложениями, а в случае с Docker — отдельными контейнерами, каждый из которых слушает свой порт и отвечает на адресованные ему запросы.
При построении микросервисов, нужно пытаться создать их таким образом, чтобы они делали только одну, или небольшое количество работы. Сложность решается путем объединения их вместе, а не построением большого монолитного приложения. | https://habr.com/ru/post/250043/ | null | ru | null |
# Строим карту популярности дней рождения с помощью Processing и VK API
#### Вступление
Несколько дней назад в блоге The Daily Viz [была опубликована запись](http://thedailyviz.com/2012/05/12/how-common-is-your-birthday/), которая привлекла внимание широкой общественности как пример простой и эффективной визуализации данных.
Визуализация представляла собой карту популярности дней рождения, реализованную как [теплокарта (heatmap)](http://en.wikipedia.org/wiki/Heat_map) в виде календаря. По вертикали располагались числа, по горизонтали — месяцы, и, глядя в эту незамысловатую таблицу, мы могли по насыщенности оттенка судить о том, насколько популярен тот или иной день в году с точки зрения деторождения.
Через какое-то время автор визуализации опубликовал в том же блоге [второй пост](http://thedailyviz.com/2012/05/18/how-common-is-your-birthday-pt-2/), извинившись за то, что ввел сообщество в заблуждение, не прокомментировав должным образом [исходные данные](http://www.nytimes.com/2006/12/19/business/20leonhardt-table.html?_r=1), использованные в работе над изображением. Проблема была в том, что исходный сет данных не содержал информации о реальном числе родившихся в тот или иной день людей. Информация была дана в другом виде — на каком месте (rank) находится тот или иной день в «рейтинге» популярности дней рождения.
То есть, разница между первой и второй позицией в рейтинге могла быть колоссальной (скажем, в два раза), но отличались бы они все равно только на один тон. Иными словами, визуализация не отражала реальных данных из-за того, что сет содержал лишь производные данные.
Немного подумав над этой проблемой, я решил описать собственный пример создания такой визуализации от начала до конца — т. е. от сбора данных до, собственно, отрисовки изображения. Этот пример хорош тем, что он, с одной стороны, относительно прост, а с другой — является целостным завершенным проектом с определенным интересным результатом.
Для всех операций я использовал среду Processing, которая традиционно используется для подобных задач (на проблеме выбора инструмента подробно останавливаться не стоит).
Итак, процесс работы над проектом имеет устойчивую структуру и состоит из трех этапов:
сбор данных > cортировка данных > визуализация данных
Будем следовать этой структуре.
#### 1. Сбор данных
Данные будем извлекать из профилей пользователей социальной сети vk.com. К счастью для нас, некоторые методы ее API являются открытыми и не требуют авторизации приложения, что значительно упрощают задачу.
Опытным путем я установил, что данных 100 000 профилей будет достаточно для того, чтобы нивелировать случайные неоднородности в распределении дней рождения в календаре и выявить основные тенденции. Тем не менее, для экономии времени и демонстрации соберем 10 000 записей. Позже мы сможем подставить в программу любое нужное нам число профилей.
Писать программу мы будем внутри основной функции **setup()**. Функция **draw()** нам не понадобится, поскольку программа генерирует статичное изображение и не содержит анимации. Подробнее со структурой программы на Processing можно ознакомиться на сайте проекта. Там же есть описание всех встроенных функций и прекрасный справочник по синтаксису.
Кроме того, мы не будем писать программу, которая выполняет задачу от и до: собирает данные, обрабатывает их и создает визуализацию. Разделим «слона» на несколько модулей, чтобы было проще работать и тратить меньше времени на отладку и устранение ошибок. Т. е. сначала напишем программу, которая собирает данные, соберем с ее помощью данные. Затем отдельно напишем программу, которая на основе сохраненных собранных данных генерирует требуемое изображение.
Итак, пишем болванку-заготовку для программы.
````
void setup() { //наша основная функция
exit(); //выходим из программы
}
````
Теперь разберемся, как работает VK API. Мы обращаемся к серверу по специальному URL, содержащему параметры нашего запроса:
```
http://api.vk.com/method/users.get.xml/uids={здесь список id интересующих нас пользователей через запятую}&fields={здесь список названий интересующих нас полей профиля пользователя}
```
Если мы напишем имя метода без .xml, то получим ответ от сервера в виде строки в формате JSON. Это один из вариантов, но в данном примере мы будем использовать XML. Предположим, мы хотим получить информацию из аккаунта Павла Дурова, основателя vkontakte. Наш адрес:
```
http://api.vk.com/method/users.get.xml?uids=1&fields=bdate
```
Id его профиля — 1, интересующее нас поле — день рождения — называется **bdate**.
Попробуем получить информацию об этом профиле. Используем встроенную функцию **loadStrings()**, которая в качестве параметра принимает строку с адресом интересующего нас файла, а возвращает содержимое файла в виде массива строк.
````
void setup() {
String[] user = loadStrings("http://api.vk.com/method/users.get.xml?uids=1&fields=bdate"); //загружаем информацию
println(user); //выводим содержимое массива (ответ сервера) в консоль
exit(); //выходим из программы
}
````
После запуска программы в консоли появится наш ответ от сервера:
````
[0] "xml version="1.0" encoding="utf-8"?"
[1] ""
[2] " "
[3] " 1"
[4] " Павел"
[5] " Дуров"
[6] " 10.10.1984"
[7] " "
[8] ""
````
Числа в квадратных скобках означают номер записи (index) в массиве и не имеет отношения к содержимому массива. Также каждая строка заключена в кавычки. Собственно, то, что находится между кавычками, и есть наше содержимое. Нас интересует поле
(строка [6]). Оно содержит интересующую нас информацию — дату рождения пользователя №1 в понятном формате: 10 число 10 месяца (октября) 1984 года.
Мы договорились собрать 10 000 дат рождения. Что мы делаем? Перебираем id пользователей от 1 до нужного нам числа. Проблема заключается в том, что не все id имеют действующие профили и не все пользователи открывают свою дату рождения. Таким образом, нам нужно два счетчика: первый счетчик будет отсчитывать id пользователей по порядку, а второй будет считать, сколько дат мы действительно собрали, чтобы вовремя остановиться. По опыту, чтобы набрать 10 000 дат, нужно перебрать около 15 000 аккаунтов.
Пишем цикл:
````
void setup() {
int count = 0; //счетчик успешных обращений к серверу
for (int i = 1; count <= 10000; i++) { //перебираем id, не останавливаемся, пока счетчик успешных обращений меньше или равен 10000
String[] user = loadStrings("http://api.vk.com/method/users.get.xml?uids=" + str(i) + "&fields=bdate"); //загружаем информацию, подставляя счетчик на место id
for (int j = 0; j < user.length; j++) { //перебираем все строки ответа
if (user[j].indexOf("") != -1) { //если строка содержит интересующее нас поле
println(i + "\t" + count + "\t" + user[j]); //выводим данные в консоль
count++; //увеличиваем счетчик успеха на 1
}
}
}
exit(); //выходим из программы
}
````
Заметьте, что значение счетчика **i**, когда мы подставляем его в строку, «обернуто» функцией **str()**. Она нужна для перевода типа данных из числа в строку. Строго говоря, программа поймет что мы от нее хотим и без этой операции, но лучше сразу взять за привычку контролировать такие вещи, как перевод данных из одного типа в другой (в некоторых ситуациях автоматический перевод не работает).
При переборе строк ответа мы используем метод **indexOf()**, который возвращает местоположение указанной в параметре строки в строке, к которой применяется метод. Если в нашей строке строки-параметра нет, метод возвращает значение -1, чем мы и пользуемся для проверки того, является ли текущая строка нужной нам.
Когда мы выводим интересующие нас данные в консоль, добавим дополнительную информацию: состояние счетчиков, чтобы следить за прогрессом. Значения переменных в скобках функции вывода **println()** разделены строкой **"\t"**, которая означает символ табуляции.
Если сейчас запустить программу, мы увидим, что значения счетчиков быстро расходятся. В моем случае после перебора 55 id была собрана только 31 дата.
Итак, кажется, всё работает нормально, осталось только заставить программу записывать данные в файл по мере поступления. Для этого создадим объект класса **PrintWriter**. Он объявляется как обычная переменная, и ему как правило сразу присваивается значение функции **createWriter(путь к файлу)**:
````
PrintWriter p = createWriter("data/bdates.txt");
````
В данном случае мы именуем объект «p», привязывая к нему файл по адресу «папка-программы/data/bdates.txt», что позволит нам записывать в этот файл то, что нам нужно. Как мы это делаем? К нашему объекту можно применить метод **println()**, который работает так же, как одноименная функция, но выводит данные не в консоль, а в указанный файл. Выглядит это так:
````
p.println(данные);
````
После того, как мы поработали с нашим файлом, нужно корректно завершить работу с ним, иначе информация в него не запишется. Делается это с помощью такой записи:
````
p.flush();
p.close();
````
Эти две функции всегда используются для корректного завершения работы с файлом вместе. Наша программа:
````
void setup() {
PrintWriter p = createWriter("data/bdates.txt"); //объект для вывода данных в файл
int count = 0; //счетчик успешных обращений к серверу
for (int i = 1; count <= 10000; i++) { //перебираем id, не останавливаемся, пока счетчик успешных обращений меньше или равен 10000
String[] user = loadStrings("http://api.vk.com/method/users.get.xml?uids=" + str(i) + "&fields=bdate"); //загружаем информацию, подставляя счётчик на место id
for (int j = 0; j < user.length; j++) { //перебираем все строки ответа
if (user[j].indexOf("") != -1) { //если строка содержит интересующее нас поле
p.println(user[j]); //записываем результат в файл
println(count); //выводим счетчик в консоль для наблюдения за прогрессом
count++; //увеличиваем счетчик успеха на 1
}
}
}
p.flush();
p.close(); //завершаем работу с файлом
exit(); //выходим из программы
}
````
При сборе данных мы отказались от вывода значения строки и счетчика id в консоль: вывод слишком большого количества данных в консоль иногда может тормозить работу программы, поэтому лучше ограничиться только необходимым — счетчиком собранных дат.
Казалось бы, что еще нужно? Можно запускать программу! И да, и нет. При опросе удаленного сервера всегда нужно иметь в виду, что иногда сервер не отвечает. Представим, что мы отправили запрос к серверу, ждем ответа и не получаем его. Через какое-то время программа решит, что сервер «лежит» и просто продолжит выполняться дальше. Что будет? Ведь мы не получили данные о пользователе, наш массив пустой. Если программа к нему обратится, программа выдаст в консоль сообщение об ошибке и остановится. Этого может и не произойти, но может и произойти, и тогда придется снова запускать программу, ждать и молиться о том, чтобы сервер ответил на все 15 000 наших запросов.
Чтобы не полагаться на слепую судьбу, была изобретена обрабока ошибок. Ошибки обрабатываются с помощью вот такой записи:
````
try {
//здесь код, который может вызвать сбой
} catch (здесь тип ошибки) {
//здесь код, который выполняется в случае, если ошибка произошла
}
````
Программа с обработкой ошибок:
````
void setup() {
PrintWriter p = createWriter("data/bdates.txt"); //объект для вывода данных в файл
int count = 0; //счетчик успешных обращений к серверу
for (int i = 1; count <= 10000; i++) { //перебираем id, не останавливаемся, пока счетчик успешных обращений меньше или равен 10000
String[] user = loadStrings("http://api.vk.com/method/users.get.xml?uids=" + str(i) + "&fields=bdate"); //загружаем информацию, подставляя счётчик на место id
try {
for (int j = 0; j < user.length; j++) { //перебираем все строки ответа
if (user[j].indexOf("") != -1) { //если строка содержит интересующее нас поле
p.println(user[j]); //записываем результат в файл
println(count); //выводим счетчик в консоль для наблюдения за прогрессом
count++; //увеличиваем счетчик успеха на 1
}
}
} catch (Exception e) {}
}
p.flush();
p.close(); //завершаем работу с файлом
exit(); //выходим из программы
}
````
Теперь, если возникает ошибка при обращении к массиву (если массив пустой), выполнится код… никакого кода не выполнится, программа выведет сообщение об ошибке, но не остановится. Мы просто игнорируем ошибку и идем дальше — всего-то придется запросить информацию еще одного пользователя. Тип ошибки указан **Exception**, это значит, что мы «ловим» любые ошибки, которые возникнут. Запись **e** после типа ошибки требуется, потому что программе нужна какая-то переменная, в которую можно записать информацию об ошибке. Мы можем обращаться к этой переменной при обработке ошибок, однако в данном случае это не нужно.
#### 2. Сортировка данных
Через какое-то время (обычно не больше получаса) после запуска программы она завершится и мы увидим в консоли заветное число 10 000. Это значит, что данные собраны и можно начинать сортировку. Откроем файл в текстовом редакторе и посмотрим на результат наших трудов:
Что не так? Ага, мы совсем забыли, что записывали в файл данные вместе с XML-тегами. Не беда! В любом текстовом редакторе есть функция автозамена, с помощью которой можно почистить наш файл от лишней информации. Строго говоря, мы могли бы программно «отловить» лишнее уже на этапе сбора данных, но в принципе, для простоты и экономии времени не зазорно воспользоваться любым доступным инструментом.
Почистив файл, сохраняем его и закрываем. Теперь программе будет просто его читать.
#### 3. Визуализация данных
А теперь займемся отрисовкой. Сначала нам нужно открыть файл и посчитать, сколько же пользователей родилось в каждый отдельный день. Для открытия файла используем старую знакомую функцию **loadStrings()**. Для того, чтобы хранить количество пользователей, родившихся в определенный день, используем двухмерный массив натуральный чисел:
````
int[][] table = new int[12][31]
````
Мы указали размер массива 12 на 31. В году у нас 12 месяцев и максимум 31 день. По идее, 31 февраля не должно родиться ни одного человека, поэтому нас не должно волновать, что массив для некоторых месяцев слишком длинный.
Как будет работать наша программа? Мы должны взять дату, определить, какой в ней содержится день и месяц, и увеличить соответствующую ячейку массива на единицу.
Для того, чтобы разбить строку на числа дня, месяца и года, мы будем использовать метод **split()**. Он возвращает массив строк, а принимает в качестве аргумента строку-разделитель: инструкция
````
String[] s = "00010010".split("1");
````
присвоит массиву **s** значение
````
[0] "000"
[1] "00"
[2] "0"
````
Что это означает для нашей практики? Мы берем строку массива и делим ее с помощью символа точки в качестве разделителя. Есть одна техническая проблема: символ точки зарезервирован в качестве обозначения любого символа. Поэтому вместо "." в качестве аргумента мы передаем "\\." — такая запись обозначает нужный нам символ точки. Получается так:
````
void setup() {
String[] file = loadStrings("data/bdates.txt"); //загружаем файл с данными
int[][] table = new int[12][31];
for (int i = 0; i < file.length; i++) { //перебираем все строки файла
String[] date = file[i].split("\\."); //переводим строку в массив, содержащий числа даты
}
exit(); //выходим из программы
}
````
Теперь в ячейке **date[0]** содержится строка с номером дня в месяце, а в **date[1]** — номер месяца. Мы должны увеличить соответствующую ячейку массива **table** на единицу:
````
table[int(table[1])-1][int(table[0])-1]++;
````
Указывая адрес ячейки соответствующий дате, мы переводим строку в число с помощью функции **int()**, а также отнимаем единицу. Зачем отнимать единицу? Затем, что отсчет ячеек массива начинается с нуля. Мы указали длину 12, это значит, что ячейки массива имеют нумерацию от 0 до 11. В отличие от месяцев, которые нумеруются от 1 до 12. Об этом несоответствии необходимо помнить.
Правильно? Правильно, да не совсем. Если сейчас запустить программу, она выдаст ошибку. Дело в том, что наш сет данных не идеален. По какой-то неведомой причине у некоторых пользователей в поле даты рождения стоят какие-то непотребные числа вроде 666.666 или 32.13.888888888. Иногда можно даже встретить пользователя, который родился, к примеру, минус пятого декабря. Чтобы их отсортировать, нужно отбросить значения месяцев больше 12 и значения дней больше 31, а также все значения меньше или равные нулю:
````
if ((int(date[1]) <= 12) && (int(date[1]) > 0) && (int(date[0]) <= 31) && (int(date[0]) > 0)) { //если с числом все в порядке
table[int(date[1])-1][int(date[0])-1]++; //увеличиваем ячейку таблицы на 1
}
````
Программа целиком:
````
void setup() {
String[] file = loadStrings("data/bdates.txt"); //загружаем файл с данными
int[][] table = new int[12][31];
for (int i = 0; i < file.length; i++) { //перебираем все строки файла
String[] date = file[i].split("\\."); //переводим строку в массив, содержащий числа даты
if ((int(date[1]) <= 12) && (int(date[1]) > 0) && (int(date[0]) <= 31) && (int(date[0]) > 0)) { //если с числом все в порядке
table[int(date[1])-1][int(date[0])-1]++; //увеличиваем ячейку таблицы на 1
}
}
exit(); //выходим из программы
}
````
Теперь, когда данные наконец собраны и хранятся в памяти программы, можно наконец-то приступить к творчеству — рисованию. Сначала определимся с цветом, которым мы будем рисовать: я взял фирменный синий цвет VK: RGB 54, 99, 142. Объявим переменную-цвет, чтобы не писать каждый раз три заветных числа:
````
color c = color(54, 99, 142);
````
Также нам нужно (по традиции, в самом начале программы) решить, какой ширины и высоты будет наше изображение. Для этого напишем функцию:
````
size(ширина, высота);
````
Какая у нас будет ширина и высота? Предположим, каждая ячейка теплокарты будет шириной 40 пикселей плюс один пиксель для отступа между ячейками. Месяцы откладываем по ширине. Не забываем про отступ от край (10 пикселей). Получается 20+41\*12. Если не хочется считать в уме или открывать приложение-калькулятор, можно просто написать это выражение как аргумент функции **println(20+41\*12);** и получить ответ — 512. Это ширина изображения. С учетом высоты ячейки в 20 пикселей и такого же отступа от края, получаем:
````
size(512, 671);
````
Теперь временно уберем команду **exit();** в конце программы, чтобы мы не выходили из программы после завершения, и запустим выполнение кода:
````
void setup() {
size(512, 671); //устанавливаем размер
background(255); //цвет фона - белый
String[] file = loadStrings("data/bdates.txt"); //загружаем файл с данными
int[][] table = new int[12][31];
for (int i = 0; i < file.length; i++) { //перебираем все строки файла
String[] date = file[i].split("\\."); //переводим строку в массив, содержащий числа даты
if ((int(date[1]) <= 12) && (int(date[1]) > 0) && (int(date[0]) <= 31) && (int(date[0]) > 0)) { //если с числом все в порядке
table[int(date[1])-1][int(date[0])-1]++; //увеличиваем ячейку таблицы на 1
}
}
color c = color(54, 99, 142); //цвет
}
````
После указания размера кадра я добавил команду установить белый фон: если мы указываем цвет одним числом, то он распознается как оттенки серого от 0 (черный) до 255 (белый). При запуске программы должно открыться окно с белым фоном нужного нам размера.
Начнем, наконец, рисовать. Как мы рисуем? Пробегаемся по массиву **table** — по каждой строке (месяц) и в каждой строке (день этого месяца) по ячейкам. Рисуем в нужном месте и нужным цветом прямоугольник 40 на 20. Как вычисляется позиция X? 10(отступ) + 41(ширина+зазор между) \* i(счетчик месяцев). Позиция Y? 10(отступ) + 21(высота+зазор между) \* j(счетчик дней). Прямоугольник рисуется функцией **rect(x, y, ширина, высота);** —
````
rect(10+41*i, 10+21*j, 40, 20);
````
Программа:
````
void setup() {
size(512, 671); //устанавливаем размер
background(255); //цвет фона - белый
String[] file = loadStrings("data/bdates.txt"); //загружаем файл с данными
int[][] table = new int[12][31];
for (int i = 0; i < file.length; i++) { //перебираем все строки файла
String[] date = file[i].split("\\."); //переводим строку в массив, содержащий числа даты
if ((int(date[1]) <= 12) && (int(date[1]) > 0) && (int(date[0]) <= 31) && (int(date[0]) > 0)) { //если с числом все в порядке
table[int(date[1])-1][int(date[0])-1]++; //увеличиваем ячейку таблицы на 1
}
}
color c = color(54, 99, 142); //цвет
for (int i = 0; i < table.length; i++) { //пробегаемся по месяцам
for (int j = 0; j < table[i].length; j++) { //пробегаемся по дням
rect(10+41*i, 10+21*j, 40, 20); //рисуем прямоугольник в нужной позиции
}
}
}
````
Если запустить этот код, мы получим поле, странным образом расчерченное прямоугольниками с обводкой. Сначала уберем обводку, добавив перед рисованием команду **noStroke();**. Теперь установим наш цвет в качестве заливки: **fill( c );**
Прекрасно. Теперь площадь замощена красивыми синими плиточками с белыми промежутками. Дальше нам нужно каким-то образом закодировать значения таблицы в цвет заливки. Сделаем это с помощью прозрачности. Прозрачность цвета принимает значения от 0 до 255. Запись **fill(c, 10);** даст едва заметный синеватый оттенок, а запись **fill(c, 240);** даст почти что полностью насыщенный синий цвет. Итак, диапазон прозрачностей — 0..255. Диапазон значений в нашем массиве гораздо больше (или меньше). Предположим, мы знаем максимальное значение в массиве. Минимальным, понятное дело, будет ноль. Нам нужно как-то вписать значение из массива в диапазон 0..255, как бы уменьшив (увеличив) масштаб. Для этого существует функция **map(значение, начало исходного диапазона, конец исходного диапазона, начало нового диапазона, конец нового диапазона)**:
````
map(table[i][j], 0, 1000, 0, 255);
````
Здесь мы сделали предположение, что максимальное значение массива — 1000. Тогда при значении **table[i][j]** в 1000 функция вернет 255, а при значении 0 — вернет ноль.
Как же рассчитать минимальное и максимальное значение двухмерного массива? Для одномерного массива существуют функции соответственно **min()** и **max()**. Используем их. Пробежимся циклом по «месяцам» и сравним минимальное и максимальное значение каждого «месяца» (который воспринимается средой как одномерный массив) с переменными, хранящими текущее минимальное или максимальное значение в массиве. И не забудем еще одну важную вещь: иногда в сете данных встречались некорректные даты, т.е. кто-то мог указать дату рождения 31 ноября или 30 февраля. Чтобы этот факт нам не мешал, установим значение всех несуществующих дат на ноль.
````
table[1][29] = 0; //30 февраля
table[1][30] = 0; //31 февраля
table[3][30] = 0; //31 апреля
table[5][30] = 0; //31 июня
table[8][30] = 0; //31 сентября
table[10][30] = 0; //31 ноября
int mi = table[0][0]; //минимальное значение
int ma = table[0][0]; //максимальное значение
for (int i = 0; i < table.length; i++) {
if ((min(table[i]) < mi) && (min(table[i]) > 0)) { //если минимальное значение этой строки меньше текущего минимума и больше нуля
mi = min(table[i]); //сделать это значение минимумом
}
if (max(table[i]) > ma) { //если максимальное значение этой строки больше текущего максимума
ma = max(table[i]); //сделать это значение максимумом
}
}
println(mi + " " + ma); //выводим значения
````
У меня значения получились 14 и 47. В принципе, это не важно, потому что мы можем использовать значения переменных. Теперь нам надо при каждом обращении к ячейке таблицы, т.е. перед рисованием каждого прямоугольника, установить свою заливку:
````
void setup() {
size(512, 671); //устанавливаем размер
background(255); //цвет фона - белый
String[] file = loadStrings("data/bdates.txt"); //загружаем файл с данными
int[][] table = new int[12][31];
for (int i = 0; i < file.length; i++) { //перебираем все строки файла
String[] date = file[i].split("\\."); //переводим строку в массив, содержащий числа даты
if ((int(date[1]) <= 12) && (int(date[1]) > 0) && (int(date[0]) <= 31) && (int(date[0]) > 0)) { //если с числом все в порядке
table[int(date[1])-1][int(date[0])-1]++; //увеличиваем ячейку таблицы на 1
}
}
table[1][29] = 0; //30 февраля
table[1][30] = 0; //31 февраля
table[3][30] = 0; //31 апреля
table[5][30] = 0; //31 июня
table[8][30] = 0; //31 сентября
table[10][30] = 0; //31 ноября
int mi = table[0][0]; //минимальное значение
int ma = table[0][0]; //максимальное значение
for (int i = 0; i < table.length; i++) {
if ((min(table[i]) < mi) && (min(table[i]) > 0)) { //если минимальное значение этой строки меньше текущего минимума и больше нуля
mi = min(table[i]); //сделать это значение минимумом
}
if (max(table[i]) > ma) { //если максимальное значение этой строки больше текущего максимума
ma = max(table[i]); //сделать это значение максимумом
}
}
color c = color(54, 99, 142);
noStroke();
for (int i = 0; i < table.length; i++) { //пробегаемся по месяцам
for (int j = 0; j < table[i].length; j++) { //пробегаемся по дням
fill(c, map(table[i][j], 0, ma, 0, 255)); //считаем заливку
rect(10+41*i, 10+21*j, 40, 20); //рисуем прямоугольник в нужной позиции
}
}
}
````
Что мы видим после запуска программы? Плиточки стали разного цвета, в зависимости от количества родившихся в тот или иной день. Также мы видим, что 29 февраля имеет довольно отчетливый цвет. Очевидно, что количество родившихся в этот день минимально, а это значит, что мы теряем большую часть диапазона цветов, доступного для отображения (значения начинаются с 14, а у нас минимум стоит на 0 — это значит, мы не используем значения прозрачности навскидку примерно от 0 до 85. Непорядок. Поставим минимальным значением в функции **map()** не ноль, а 12, чтобы плиточка 29 февраля была едва заметна. Из-за того, что наш минимум теперь составляет 12, а не ноль, прозрачность тех плиточек, которые имеют значение 0, будет отрицательной. А поскольку при отрицательных значениях прозрачность откатывается циклически (-5 — это все равно что 250!), получится, что несуществующие дни будут не белыми, а темными. Добавим условие, при котором «нулевые» дни вообще не рисуются:
````
void setup() {
size(512, 671); //устанавливаем размер
background(255); //цвет фона - белый
String[] file = loadStrings("data/bdates.txt"); //загружаем файл с данными
int[][] table = new int[12][31];
for (int i = 0; i < file.length; i++) { //перебираем все строки файла
String[] date = file[i].split("\\."); //переводим строку в массив, содержащий числа даты
if ((int(date[1]) <= 12) && (int(date[1]) > 0) && (int(date[0]) <= 31) && (int(date[0]) > 0)) { //если с числом все в порядке
table[int(date[1])-1][int(date[0])-1]++; //увеличиваем ячейку таблицы на 1
}
}
table[1][29] = 0; //30 февраля
table[1][30] = 0; //31 февраля
table[3][30] = 0; //31 апреля
table[5][30] = 0; //31 июня
table[8][30] = 0; //31 сентября
table[10][30] = 0; //31 ноября
int mi = table[0][0]; //минимальное значение
int ma = table[0][0]; //максимальное значение
for (int i = 0; i < table.length; i++) {
if ((min(table[i]) < mi) && (min(table[i]) > 0)) { //если минимальное значение этой строки меньше текущего минимума и больше нуля
mi = min(table[i]); //сделать это значение минимумом
}
if (max(table[i]) > ma) { //если максимальное значение этой строки больше текущего максимума
ma = max(table[i]); //сделать это значение максимумом
}
}
color c = color(54, 99, 142);
noStroke();
for (int i = 0; i < table.length; i++) { //пробегаемся по месяцам
for (int j = 0; j < table[i].length; j++) { //пробегаемся по дням
if (table[i][j] > 0) {
fill(c, map(table[i][j], 12, ma, 0, 255)); //считаем заливку
rect(10+41*i, 10+21*j, 40, 20); //рисуем прямоугольник в нужной позиции
}
}
}
}
````
Но что мы видим? Среди окружающих дней как-то особенно выделяется 1 января. Та же тенденция сохраняется на гораздо больших числах пользователей. Когда я собирал данные по 300 000 аккаунтов, 1 января точно так же сияло глубоким синим, а остальные цвета были бледными. Очевидно, такое явление связано с действиями пользователей, которые, не желая публиковать свой реальный день рождения, выбирают первое число в списке. Отделить действительно родившихся в Новый год от жалких симулянтов не представляется возможным. Чтобы выровнять сет, просто удалим оттуда данные, присоив ячейке **table[0][0]** значение ноль. Чтобы сохранить картинку, используем команду **saveFrame(«frame.jpg»);** в самом конце программы. У нас появится соответствующий файл в папке с программой.
Код программы полностью:
````
void setup() {
size(512, 671); //устанавливаем размер
background(255); //цвет фона - белый
String[] file = loadStrings("data/bdates.txt"); //загружаем файл с данными
int[][] table = new int[12][31];
for (int i = 0; i < file.length; i++) { //перебираем все строки файла
String[] date = file[i].split("\\."); //переводим строку в массив, содержащий числа даты
if ((int(date[1]) <= 12) && (int(date[1]) > 0) && (int(date[0]) <= 31) && (int(date[0]) > 0)) { //если с числом все в порядке
table[int(date[1])-1][int(date[0])-1]++; //увеличиваем ячейку таблицы на 1
}
}
table[0][0] = 0; //1 января
table[1][29] = 0; //30 февраля
table[1][30] = 0; //31 февраля
table[3][30] = 0; //31 апреля
table[5][30] = 0; //31 июня
table[8][30] = 0; //31 сентября
table[10][30] = 0; //31 ноября
int mi = table[0][0]; //минимальное значение
int ma = table[0][0]; //максимальное значение
for (int i = 0; i < table.length; i++) {
if ((min(table[i]) < mi) && (min(table[i]) > 0)) { //если минимальное значение этой строки меньше текущего минимума и больше нуля
mi = min(table[i]); //сделать это значение минимумом
}
if (max(table[i]) > ma) { //если максимальное значение этой строки больше текущего максимума
ma = max(table[i]); //сделать это значение максимумом
}
}
color c = color(54, 99, 142);
noStroke();
for (int i = 0; i < table.length; i++) { //пробегаемся по месяцам
for (int j = 0; j < table[i].length; j++) { //пробегаемся по дням
if (table[i][j] > 0) {
fill(c, map(table[i][j], 12, ma, 0, 255)); //считаем заливку
rect(10+41*i, 10+21*j, 40, 20); //рисуем прямоугольник в нужной позиции
}
}
}
saveFrame("frame.jpg"); //сохраняемся
}
````
Готово! Из получившейся картинки пока что не особенно понятны, как сейчас говорят, тренды, потому что мы собрали слишком мало данных. Вот картинка для 300 000 аккаунтов (нет, я не ждал для сбора данных 100 лет, а использовал асинхронные запросы к серверу — может быть, я когда-нибудь напишу о реализации их в Processing), на которой ясно видна тенденция (хотя и не очень яркая):
А анализ полученной визуализации ложится на ваши плечи! ;] | https://habr.com/ru/post/144531/ | null | ru | null |
# Уязвимости в Linux допускают возможность атаки «в один клик»
Группа исследователей CrowdStrike Intelligence обнаружила несколько уязвимостей, влияющих на LibVNCClient в Linux. В некоторых широко используемых средах рабочего стола (например, Gnome) эти уязвимости можно эксплуатировать одним кликом мыши.
Вступление
----------
Эксплуатация уязвимостей на стороне клиента — распространённая схема работы злоумышленников. Обычно лазейкой становятся браузеры, но их разработчики постоянно усиливают средства защиты, поэтому использовать их становится всё сложнее. А вот другим компонентам рабочего стола не уделяется столько внимания, поэтому некоторые риски остаются незамеченными. В статье исследуем состояние безопасности типичной среды рабочего стола Linux.
Обработчики схем URL
--------------------
Будет ли запущено приложение, когда пользователь кликает по ссылке, зависит от того, зарегистрирован ли в системе обработчик схемы URL. На стандартном рабочем столе Ubuntu 21.04 на базе Gnome есть различные приложения, зарегистрированные как обработчики схемы URL. Полный список этих обработчиков можно получить, выполнив поиск файла через: `mimeinfo.cache`:
```
$ grep x-scheme-handler /usr/share/applications/mimeinfo.cache
x-scheme-handler/apt=apturl.desktop;
x-scheme-handler/chrome=firefox.desktop;
x-scheme-handler/ftp=firefox.desktop;
x-scheme-handler/ghelp=yelp.desktop;
x-scheme-handler/help=yelp.desktop;
x-scheme-handler/http=firefox.desktop;
x-scheme-handler/https=firefox.desktop;
x-scheme-handler/icy=org.gnome.Totem.desktop;
x-scheme-handler/icyx=org.gnome.Totem.desktop;
x-scheme-handler/info=yelp.desktop;
x-scheme-handler/magnet=transmission-gtk.desktop;
x-scheme-handler/mailto=thunderbird.desktop;
x-scheme-handler/man=yelp.desktop;
x-scheme-handler/mms=org.gnome.Totem.desktop;
x-scheme-handler/mmsh=org.gnome.Totem.desktop;
x-scheme-handler/net=org.gnome.Totem.desktop;
x-scheme-handler/pnm=org.gnome.Totem.desktop;
x-scheme-handler/rdp=org.remmina.Remmina.desktop;remmina-file.desktop;
x-scheme-handler/remmina=org.remmina.Remmina.desktop;remmina-file.desktop;
x-scheme-handler/rtmp=org.gnome.Totem.desktop;
x-scheme-handler/rtp=org.gnome.Totem.desktop;
x-scheme-handler/rtsp=org.gnome.Totem.desktop;
x-scheme-handler/snap=snap-handle-link.desktop;
x-scheme-handler/spice=org.remmina.Remmina.desktop;remmina-file.desktop;
x-scheme-handler/uvox=org.gnome.Totem.desktop;
x-scheme-handler/vnc=org.remmina.Remmina.desktop;remmina-file.desktop;
x-scheme-handler/vnd.libreoffice.cmis=libreoffice-startcenter.desktop;
```
Хотя URL-адрес, начинающийся с пользовательской схемы, может показаться подозрительным, истинная цель ссылки может быть скрыта в приложениях, которые позволяют встраивать разметку HTML. Примером является приложение для управления персональной информацией [Evolution](https://wiki.gnome.org/Apps/Evolution):
Инструмент удалённого администрирования [Remmina](https://remmina.org/) зарегистрирован для схем URL rdp, remmina, spice и vnc. Соответствующий файл .desktop, указанный как часть определения обработчика, содержит ссылку на сценарий оболочки `remmina-file-wrapper`, который получает указанный URL-адрес в качестве второго аргумента (%U плейсхолдер):
```
$ cat /usr/share/applications/remmina-file.desktop
[Desktop Entry]
[...]
Exec=remmina-file-wrapper -c %U
Icon=org.remmina.Remmina
MimeType=application/x-remmina;x-scheme-handler/remmina;x-scheme-handler/rdp;x-scheme-handler/spice;x-scheme-handler/vnc;
[...]
```
Затем этот сценарий оболочки запускает фактический двоичный файл Remmina, если указан соответствующий URL:
```
$ cat /usr/bin/remmina-file-wrapper
#!/usr/bin/env bash
[...]
REMMINA="/usr/bin/remmina"
if [[ ! -f "$REMMINA" ]] ; then
REMMINA="${USRBIN}/remmina"
else
REMMINA="remmina"
fi
export GLADE_HOME="$USRBIN/../share/remmina/ui/"
case "$@" in
*rdp:*)
"$REMMINA" "${@#rdp:\/\/}"
;;
*spice:*)
"$REMMINA" "${@#spice:\/\/}"
;;
*vnc:*)
"$REMMINA" "${@#vnc:\/\/}"
;;
*remmina:*)
"$REMMINA" "${@#remmina:\/\/}"
;;
*)
"$REMMINA" "${@}"
;;
esac
```
Таким образом, эти обработчики URL-адресов открывают большое пространство для атак, которые можно осуществить при минимальном взаимодействии с пользователем. Например, клик по URL-адресу, такому как vnc://user:pass@example.com/, автоматически запускает Remmina и мгновенно устанавливает VNC соединение с указанным удалённым хостом по заданным учётным данным. Любая уязвимость, влияющая на реализацию протокола VNC Remmina, потенциально допускает сценарии эксплуатации всего по одному клику мышки. Поэтому есть смысл внимательнее изучить [libvncclient](https://github.com/LibVNC/libvncserver), который используется Remmina для поддержки VNC.
Аудит кода
----------
[Libvncclient](https://libvnc.github.io/) реализует [протокол VNC](https://datatracker.ietf.org/doc/html/rfc6143), который основан на концепции удалённого буфера кадров. Он предлагает функциональные возможности для передачи нажатий клавиш и кликов мыши от клиента к серверу в процессе трансляции графического рабочего стола сервера, как только обновляется фреймбуфер клиента. Первоначальная спецификация протокола удалённого буфера кадра (RFB), лежащего в основе VNC, появилась в 1998 году и была относительно простой. Однако с годами она обросла дополнительными функциями для оптимизации различных аспектов протокола. Например, уменьшение объёма данных, которые необходимо передать для обновления буфера кадра. Такая оптимизация, в свою очередь, привела к дополнительному усложнению и увеличению [площади атаки](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=vnc).
Две из этих оптимизаций связаны с реализацией протоколов [UltraVNC](https://www.uvnc.com/) и [TightVNC](https://www.tightvnc.com/) и используют настраиваемые схемы кодирования. Обе эти схемы также поддерживаются LibVNCClient. Аудит кода выявил две различные уязвимости, связанные с повреждением памяти при обработке этих схем кодирования.
Переполнение буфера при кодировании Ultra
-----------------------------------------
Сообщения от VNC-сервера к клиенту обрабатываются функцией `HandleRFBServerMessage()`. Эта функция сначала считывает тип сообщения, а затем обрабатывает остальную его часть. Обновления буфера кадра передаются в сообщениях типа `rfbFramebufferUpdate`. Эти сообщения содержат информацию о количестве обновлений буфера кадра, содержащихся в сообщении, и о кодировании данных для каждого фрейма (например, `rfbEncodingUltra` для кодирования UltraVNC). Следующий кусок исходного кода из `libvncclient` показывает функцию `HandleUltraBPP()`, которая реализует обработку обновлений кадрового буфера в кодировке UltraVNC:
```
static rfbBool
HandleUltraBPP (rfbClient* client, int rx, int ry, int rw, int rh)
{
rfbZlibHeader hdr;
int toRead=0;
[...]
lzo_uint uncompressedBytes = (( rw * rh ) * ( BPP / 8 ));
if (!ReadFromRFBServer(client, (char *)&hdr, sz_rfbZlibHeader))
return FALSE;
toRead = rfbClientSwap32IfLE(hdr.nBytes);
[...]
```
Строка BPP в имени функции будет расширена препроцессором C до трёх различных функций для обработки обновлений буфера кадра с 8, 16 или 32 битами цвета на пиксель. После прочтения заголовка из сокета с помощью `ReadFromRFBServer()`, его поле `nBytes` используется для подстановки целого числа в переменную toRead. Впоследствии `toRead` берётся в качестве размера для выделения 4-байтового буфера (`ultra_buffer`), если предыдущий буфер не был выделен при прошлом вызове функции, или если он имеет недостаточный размер:
```
[...]
/* allocate enough space to store the incoming compressed packet */
if ( client->ultra_buffer_size < toRead ) { if ( client->ultra_buffer != NULL ) {
free( client->ultra_buffer );
}
client->ultra_buffer_size = toRead;
/* buffer needs to be aligned on 4-byte boundaries */
if ((client->ultra_buffer_size % 4)!=0)
client->ultra_buffer_size += (4-(client->ultra_buffer_size % 4));
client->ultra_buffer = (char*) malloc( client->ultra_buffer_size );
[...]
```
После этого код считывает из сокета количество данных, указанное в toRead:
```
[...]
/* Fill the buffer, obtaining data from the server. */
if (!ReadFromRFBServer(client, client->ultra_buffer, toRead))
return FALSE;
[...]
```
Вредоносный сервер VNC может полностью контролировать значение переменной toRead, включая отрицательные значения. Если сначала отправить обновление буфера кадра, которое приводит к выделению буфера определённого размера, а затем сделать второе обновление, которое устанавливает для toRead отрицательное значение, ultra\_buffer может переполниться. Затем буфер, который выделяется во время первого обновления буфера кадра, переполняется вторым, так как не будет выполнено условие client->ultra\_buffer\_size < toRead, что приводит к вызову функции `ReadFromRFBServer()`, где toRead – отрицательное число.
Так как `ReadFromRFBServer()` ожидал целочисленное значение без отрицательного знака, неявное преобразование типа приводит к вызову `read()` со слишком большим значением `count`. Точный объём перезаписываемых данных можно контролировать, заранее закрыв базовое соединение с сокетом.
Переполнение внутренней структуры в жёстком кодировании
-------------------------------------------------------
Если для обновления буфера кадра используется жёсткое кодирование, вызывается функция `HandleTightBPP()` (как и в кодировке Ultra, BPP является заполнителем для препроцессора). Как показано в следующем листинге, функция считывает значение `comp_ctl` из нижележащего сокета:
```
static rfbBool
HandleTightBPP(rfbClient *client, int rx, int ry, int rw, int rh)
{
CARDBPP fill_colour;
uint8_t comp_ctl;
uint8_t filter_id;
filterPtrBPP filterFn;
z_streamp zs;
int err, stream_id, compressedLen, bitsPixel;
int bufferSize, rowSize, numRows, portionLen, rowsProcessed, extraBytes;
rfbBool readUncompressed = FALSE;
if (client->frameBuffer == NULL)
return FALSE;
if (rx + rw > client->width || ry + rh > client->height)
{
rfbClientLog("Rect out of bounds: %dx%d at (%d, %d)\n", rx, ry, rw, rh);
return FALSE;
}
if (!ReadFromRFBServer(client, (char *)∁_ctl, 1))
return FALSE;
[...]
```
Это значение используется функцией, чтобы сделать ряд предположений относительно точного формата. Например, оно используется для выбора функции фильтрации, определяет тип фрейма и сообщает, используется ли сжатие. Далее функция `ReadCompactLen()` вызывается для чтения значения `compressedLen` из базового сокета:
```
[...]
/* Read the length (1..3 bytes) of compressed data following. */
compressedLen = (int)ReadCompactLen(client)
[...]
```
`ReadCompactLen()` позволяет серверу указать размер данных, который может находиться в диапазоне от 1 до 3 байтов. Наиболее значимыми являются первые один или два бита, так как они определяют последовательность остальных байтов.
Следовательно, указанный размер может достигать 22 бит (7 + 7 + 8). Таким образом, максимальное целочисленное значение, которое может быть возвращено функцией, равно 4 194 303 (2 ^ 22 - 1).
Когда клиент ожидает несжатые данные (обозначены `comp_ctl`), `compressedLen` передаётся `ReadFromRFBServer()` как количество данных, которые считываются в client->buffer:
```
[...]
if (readUncompressed)
{
if (!ReadFromRFBServer(client, (char *)client->buffer, compressedLen))
return FALSE;
[...]
```
Как показано ниже, client->buffer представляет собой массив фиксированного размера (307 200 байт), расположенный в центральной структуре `rfbClient`, которая выделяется для каждого соединения:
```
typedef struct _rfbClient {
uint8_t* frameBuffer;
[...]
int serverPort; /**< if -1, then use file recorded by vncrec */ rfbBool listenSpecified; int listenPort, flashPort; struct { int x, y, w, h; } updateRect; /** Note that the CoRRE encoding uses this buffer and assumes it is big enough to hold 255 * 255 * 32 bits -> 260100 bytes. 640*480 = 307200 bytes.
Hextile also assumes it is big enough to hold 16 * 16 * 32 bits.
Tight encoding assumes BUFFER_SIZE is at least 16384 bytes. */
#define RFB_BUFFER_SIZE (640*480)
char buffer[RFB_BUFFER_SIZE];
char *bufoutptr;
unsigned int buffered;
[...]
```
Поскольку максимальный размер compressedLen может превышать размер buffer, сервер может переполнять указанный буфер и полностью контролировать последующие элементы структуры rfbClient, а также смежную память кучи. Сюда входят указатели, с помощью которых можно произвольно записывать примитивы, а также указатели функций, которые позволяют захватить поток управления.
Фаззинг
-------
Помимо ручного аудита был использован [afl ++](https://github.com/AFLplusplus/AFLplusplus) для проведения [фаззинговых](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B7%D0%B7%D0%B8%D0%BD%D0%B3) тестов. Для этого разработали тонкую оболочку вокруг основной функции отправки сообщений `HandleRFBServerMessage()`. Аргументом для этой функции является клиентский объект, который настроен на чтение обновлений буфера кадров stdin. Путем фаззинга были обнаружены две дополнительных ошибки, которые описаны ниже.
Переполнение буфера в TRLE
--------------------------
В случае получения обновления буфера кадра с кодировкой TRLE вызывается функция `HandleTRLE()`. Как показано в следующем фрагменте исходного кода, функция содержит цикл, который получает произвольное количество 0xFF байтов из базового сокета в выделенную кучу client->raw\_buffer:
```
static rfbBool HandleTRLE(rfbClient *client, int rx, int ry, int rw, int rh) {
[...]
uint8_t *buffer;
[...]
buffer = (uint8_t*)(client->raw_buffer);
[...]
while (*buffer == 0xff) {
if (!ReadFromRFBServer(client, (char*)buffer + 1, 1))
return FALSE;
length += *buffer;
buffer++;
}
[...]
}
```
Поскольку проверка границ отсутствует, атакующий сервер может переполнить буфер.
Переполнение буфера в кодировке ZRLE
------------------------------------
В случае получения обновления буфера кадра с кодировкой ZRLE вызывается функция `HandleZRLE()`. Как показано в следующем фрагменте исходного кода, функция сначала считывает с сервера структуру типа `rfbZRLEHeader`. После этого принимаются дополнительные данные, сжатые zlib.
```
static rfbBool HandleZRLE (rfbClient* client, int rx, int ry, int rw, int rh)
{
while (( remaining > 0 ) && ( inflateResult == Z_OK )) {
[...]
/* Fill the buffer, obtaining data from the server. */
if (!ReadFromRFBServer(client, client->buffer,toRead))
return FALSE;
client->decompStream.next_in = ( Bytef * )client->buffer;
client->decompStream.avail_in = toRead;
/* Need to uncompress buffer full. */
inflateResult = inflate( &client->decompStream, Z_SYNC_FLUSH );
[...]
}
if ( inflateResult == Z_OK ) {
[...]
for(j=0; j
```
Затем распакованные данные передаются функции `HandleZRLETILE()` в качестве аргумента buf. Его первый байт определяет type:
```
static int HandleZRLETile(rfbClient* client, uint8_t* buffer,size_t buffer_length, int x,int y,int w,int h)
{
[...]
uint8_t type;
[...]
type = *buffer;
buffer++;
[...]
if( type == 0 ) /* raw *
[...]
else if( type == 1 ) /* solid */
[...]
else if( type <= 127 ) { /* packed Palette */
CARDBPP palette[16];
int i,j,shift,
[...]
/* read palette */
for(i=0; i
```
Если type не является ни 0, ни 1, но меньше или равен 127, код исполняется по ветке, которая обрабатывает `palette`. В этом случае palette объявляется выделенным массивом из 16 названных элементов. Точное значение `typethen` определяет, сколько элементов считывается в `массиве` palette внутри цикла `for`. В случае, если значение `type` превышает 16, происходит запись в стек за пределами допустимого диапазона.
Возможность эксплуатации
------------------------
Описанные уязвимости позволяют произвольно записывать примитивы и полностью контролировать указатель инструкций. Наличие рандомизации адресного пространства (ASLR) затрудняет эксплуатацию в стандартной среде рабочего стола Ubuntu x64. Это связано с тем, что сама Remmina скомпилирована как исполняемый файл, не зависимый от позиции и, следовательно, она похожа на библиотеки, загружаемые в случайном месте. Таким образом, у злоумышленника нет надёжных фиксированных адресов. Однако, если одна из уязвимостей приведёт к утечке информации или будет обнаружена отдельная ошибка, позволяющая раскрыть адреса памяти, указанные уязвимости сделают возможным удалённое выполнение кода.
Заключение
----------
Дистрибутивы Linux начали предоставлять [механизмы изоляции для конкретных приложений,](https://ubuntu.com/core/docs/security-and-sandboxing) а также интегрировать [методы песочницы в критически важные компоненты,](https://gitlab.gnome.org/GNOME/tracker-miners/-/blob/master/src/libtracker-miners-common/tracker-seccomp.c) но далеко не все части типичных настольных сред защищены аналогичным образом.
Linux — не единственная платформа, которая открывает такую обширную поверхность для атак. Недавно обнаруженная уязвимость MSHTML для удалённого выполнения кода CVE-2021-40444 в операционных системах Windows также поддерживает и автоматически добавляет пользовательские обработчики протоколов для известных типов файлов.
---
**Что ещё интересного есть в блоге Cloud4Y**
→ [Айтишный пицца-квест. Итоги](https://habr.com/ru/company/cloud4y/blog/587096/)
→ [Как я случайно заблокировал 10 000 телефонов в Южной Америке](https://habr.com/ru/company/cloud4y/blog/584578/)
→ [Клавиатуры, которые постигла неудача](https://habr.com/ru/company/cloud4y/blog/573476/)
→ [Чувствуете запах? Пахнет утечкой ваших данных](https://habr.com/ru/company/cloud4y/blog/587994/)
→ [Изучаем своё железо: сброс паролей BIOS на ноутбуках](https://habr.com/ru/company/cloud4y/blog/565074/)
Подписывайтесь на наш [Telegram](https://t.me/cloud4y)-канал, чтобы не пропустить очередную статью. Пишем не чаще двух раз в неделю и только по делу. | https://habr.com/ru/post/591849/ | null | ru | null |
# Разработка и тестирование chef кукбуков с помощью инструмента Sparrowdo v2
Здравствуйте! Об инструменте [sparrowdo](https://github.com/melezhik/sparrowdo) и его применение в разработке сценариев конфигурации [chef](https://www.chef.io/) я [писал](https://habrahabr.ru/post/313034/) уже ранее.
Что ж, за это время утекло много воды и я хотел снова немного раскрыть данную тему, собственно поэтому заголовок статьи содержит версию два.
Итак — sparrowdo — система управления конфигурациями написанная на замечательном языке [Perl6](http://perl6.org/), активно развивающимся в последнее время. В своей лично работе я нахожу sparrowdo очень удобным и органично сосуществующим с более мощной платформой управления конфигурация — [opscode chef](https://www.chef.io). На нескольких конкретных примерах я покажу как я использую chef вместе со sparrowdo. Это пост не будет очень длинным, но надеюсь даст понимание о чем идет речь.
Что мы имеем? В силу своей основной профессиональной деятельности мне приходится много писать всяческих chef [кукбуков](https://docs.chef.io/cookbooks.html). В нашем проекте активно используется [aws](https://aws.amazon.com/) сервисы, поэтому создание сервера и установка на нем chef клиента — операция достаточно дешевая и нересурсоемкая, следовательно я могу запросто отлаживать chef рецепты, запуская chef клиента на удаленном сервере по ssh, вместо того что бы использовать более традиционный для таких случаев [vagrant](https://www.vagrantup.com/)
Хорошо, таким образом процесс разработки и отладки кукбуков сводится к тому, что разрабатывая очередную версию рецептов, я обновляю кукбук на chef сервере посредством команды [knife upload](https://docs.chef.io/knife_upload.html) и запускаю тестируемый кукбук далее на удаленном сервере посредством команды `chef-client` ( с заданным ран листом ). Собственно, вылавливая при этом различные ошибки и падения возникающие при деплое ( если выражаться языком документации chef — конвергенции ноды )
При таком раскладе мне очень удобен sparrowdo — который в отличие от chef является push based инструментом управления конфигурациями или, попросту говоря, умеет выполнять свои сценарии на удаленном хосте по ssh.
Как вы уже можете начать догадываться — сценарий в этом случае будет такой — запустить chef клиента на удаленной машине.
Sparrowdo поддерживает модульность — вы можете расширять его базовую функциональность за счет модулей написанных на языке Perl6, поэтому специально для это задачи мною был написан модуль под названием [Sparrowdo::Chef::Client](https://github.com/melezhik/sparrowdo-chef-client)
Интерфейс модуля достаточно прост — он предоставляет необходимый минимум для запуска chef клиента — а именно указание [ран листа](https://docs.chef.io/run_lists.html) и опционально задание [атрибутов](https://docs.chef.io/attributes.html)
Вот как будет выглядеть сценарий по запуску кукбука [java](https://supermarket.chef.io/cookbooks/java) с установкой атрибута, задающем версию устанавливаемого jdk:
```
$ cat sparrowfile
module_run 'Chef::Client', %(
run-list => [
"recipe[java]"
],
attributes => %(
java => %(
jdk_version => 7
),
),
log-level => 'info',
force-formatter => True
);
```
В наших проектах мы используем во основном jdk версии 7, поэтому я выставляю ее через соответствующий chef атрибут, который переопределяет дефолтное значение.
Вот как будет выглядеть отчет sparrowdo при запуске на удаленном сервере:
```
$ sparrowdo --host=remote.server --ssh_user=centos --ssh_private_key=/home/melezhik/.ssh/foo.pem
running sparrow tasks on remote.server ...
target OS is - centos7
enter module ...
push task plg OK
push task plg OK
set up task box file - /tmp/sparrowdo/task-box8938.json - OK
get index updates from SparrowHub ... OK
public@file is uptodate (0.0.5)
public@bash is uptodate (0.1.4)
running task box from /tmp/sparrow-cache/task-box8938.json ...
[t] set up chef run list and attributes at 2017-04-06 13:35:14
set target content
touch target
target created
set target mode to 644
ok scenario succeeded
ok text match /target (created|deleted)/
ok text has 'set target content'
STATUS SUCCEED
[t] run chef-client
@ runs bash command
[t] run chef-client modules/bash-command/ params: envvars: at 2017-04-06 13:35:14
[2017-04-06T13:35:15+00:00] INFO: Forking chef instance to converge...
Starting Chef Client, version 12.19.36
#
# вывод опущен
#
Chef Client finished, 7/9 resources updated in 38 seconds
ok scenario succeeded
STATUS SUCCEED
```
Хорошо, это простой пример показывает как мы можем управлять настройками запускаемых сhef кукбуков, выставляя ран лист и различные атрибуты. Приведу далее еще несколько интересных случаев.
тестирование прохождения граничных условий
==========================================
Не секрет, что большо'е количество задач по управлению конфигрурациями и автоматизации связано с запуском сетевых сервисов. Например у нас есть кукбук, который настраивает и и перезапускает сервер nginx согласно какому-то нетривиальному набору правил. Я думаю, те кто писал подобного рода рецепты часто сталкивались с тем, что их сценарии могут вести себя по-разному относительно разных состояний сервиса в начале. Вот, например я хочу посмотреть что будет, и не упадет ли мой деплой если nginx не будет запущен до выполнения chef рецепта, с помощью sparrowdo, который сам по себе так же является инструментом управления конфигурациями это сделать легко:
```
$ cat sparrowfile
service-stop 'nginx'
module_run 'Chef::Client', %(
run-list => [
"recipe[nginx-app::configure]"
]
);
```
Согласитесь — что встраивать остановку nginx внутрь шеф рецептов, только для того, что бы протестировать поведение нашего основного кукбука, было бы не хорошо. А здесь с помощью sparrowdo мы делаем это легко и непринужденно, причем не меняя ничего в коде самого chef кукбука
встроенные post deployment / audit тесты
========================================
Часто требуется проверить работу шеф клиента после того, как он отработал. Есть различные варианты решения данной задачи — [test-kitchen](https://github.com/test-kitchen/test-kitchen)/ [serverspec](http://serverspec.org/), [goss](https://github.com/aelsabbahy/goss), [chef minitest-handler](https://github.com/chef/minitest-chef-handler), [inspec](https://github.com/chef/inspec) у всех у них есть свои плюсы и минусы. Но вот вам еще одна альтернатива — sparrowdo — основной смысл тот же — мы делаем проверки рядом, а точнее внутри sparrowdo сценария, вот одна из моих излюбленных проверок на то, что сервер tomcat запущен и "виден" в списке процессов — практика показывает, что иногда chef не отлавливает ситуации с падением перезапускаемого сервиса и нам необходимо делать это самим:
```
$ cat sparrowfile
service-stop 'nginx'
module_run 'Chef::Client', %(
run-list => [
"recipe[tomcat-app::configure]"
]
);
task-run 'check tomcat', 'proc-validate', %(
pid_file => '/var/run/tomcat7.pid',
footprint => 'java'
);
```
необязательные зависимости
==========================
И наконец, последний самый простой и очевидный случай ( но от этого его актуальность не теряется ) — вам нужно *временно* поставить дополнительные пакеты и утилиты на тестируемый сервер. Вы не хотите включать это в ваши chef рецепты, потому что напрямую к установке приложений данные зависимости отношения не имеют, но они нужны вам для отладки устанавливаемых приложений, что ж, просто добавим их через sparrowdo, не меняя при этом код написанных вами chef рецептов.
Вот, например специализированный пакет, который нам вряд ли понадобится в продакшене, но
будет необходим, если мы захотим заняться дебаггингом java кода:
```
package-install 'java-1.7.0-openjdk-debuginfo'
module_run 'Chef::Client', %(
run-list => [
"recipe[java]"
]
);
```
На этом я заканчиваю. В заключении хочется сказать что в моей личной работе, связанной с ежедневной разработкой десятков кукбуков для сотен различных проектов sparrowdo зарекомендовал себя как отличный инструмент-компаньон существенно ускоряющий и упрощающий разработку и тестирование сценариев chef.
Как обычно, буду рад вопросам и конструктивной критики. | https://habr.com/ru/post/325848/ | null | ru | null |
# Код как искусство: как борются с багами и повышают уровень разработки в Mail.ru Group
Есть четыре вещи, заниматься которыми можно бесконечно. И если про первые три все слышали, то четвертая — это смотреть код. Мы с вами немного погрузились в это увлекательное занятие с помощью [теста](https://habr.com/ru/article/531370/), а теперь покажем, как мы просматриваем код в собственных программах и ищем в них баги. Мы попросили наших разработчиков вспомнить истории на эту тему и рассказать, с чем они сталкивались, как работают сами над качеством кода и как оценивают его у будущих коллег.
---
Ошибки — это нормально, так как их совершают все, ненормально — когда они попадают в продакт. Чтобы этого не происходило, мы в своих командах постоянно проверяем продукты перед выходом и выстраиваем QA-процесс. В Mail.ru Group много разных команд, и у каждой есть свой опыт, подход и куча интересных историй про то, как что-то где-то пошло (или могло пойти) не так. Мы собрали пять из них, и каждая покажет свою важную составляющую работы над качеством кода.
Не только код-ревью
-------------------
Привет, Хабр! Меня зовут Марк Локшин, я старший программист [IT Territory / MY. GAMES](https://u.habr.com/mrg_post_itt). Разработкой java-серверов для компьютерных игр занимаюсь уже 8 лет и не единожды что-нибудь ломал, но ещё больше раз чинил и предотвращал поломки.
.t-review-social-links {
line-height: 0px;
}
.t-review-social-links\_\_wrapper {
display: -webkit-box;
display: -ms-flexbox;
display: flex;
-webkit-box-align: center;
-ms-flex-align: center;
align-items: center;
-ms-flex-wrap: wrap;
flex-wrap: wrap;
width: auto;
}
.t-review-social-links {
margin-top: 15px;
}
.t-review-social-links\_\_item {
padding: 0px 4px;
}
.t-review-social-links\_\_item svg {
width: 20px;
height: 20px;
}
.t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg {
width: 23px;
height: 23px;
}
.t-review-social-links\_\_item:first-child {
padding-left: 0px;
}
@media screen and (max-width: 960px) {
.t-review-social-links\_\_item {
margin-bottom: 3px;
}
}
@media screen and (max-width: 640px) {
.t-review-social-links {
margin-top: 13px;
}
.t-review-social-links\_\_item {
padding: 0px 3px;
}
.t-review-social-links\_\_item svg {
width: 17px;
height: 17px;
}
.t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg {
width: 20px;
height: 20px;
}
}
function t\_reviews\_social\_init(recid){
var rec = $('#rec' + recid);
var social = rec.find('.t-review-social-links');
if (social !== 'undefined' && social.length > 0) {
social.each(function() {
var $this = $(this);
var socialAttr = $this.attr('data-social-links');
var socialWrapper = $this.find('.t-review-social-links\_\_wrapper');
var links;
$this.removeAttr('data-social-links');
if (typeof socialAttr !== 'undefined') {
links = socialAttr.split(',');
links.forEach(function(item) {
t\_reviews\_social\_add\_item(item, socialWrapper);
});
}
});
}
}
function t\_reviews\_social\_add\_item(item, socialWrapper) {
var fill = socialWrapper.attr('data-social-color') || '#000000';
var fb = '';
fb = '<div class="t-review-social-links\_\_item">';
fb += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
fb += '<svg class="t-review-social-links\_\_svg" version="1.1" id="Layer\_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="30px" height="30px" viewBox="0 0 48 48" enable-background="new 0 0 48 48" xml:space="preserve" fill="' + fill + '"><desc>Facebook</desc><path d="M47.761,24c0,13.121-10.638,23.76-23.758,23.76C10.877,47.76,0.239,37.121,0.239,24c0-13.124,10.638-23.76,23.764-23.76C37.123,0.24,47.761,10.876,47.761,24 M20.033,38.85H26.2V24.01h4.163l0.539-5.242H26.2v-3.083c0-1.156,0.769-1.427,1.308-1.427h3.318V9.168L26.258,9.15c-5.072,0-6.225,3.796-6.225,6.224v3.394H17.1v5.242h2.933V38.85z"></path></svg>';
} else {
fb += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M21.1 7.8C22.5 6.5 24.5 6 26.4 6h6v6.3h-3.9c-.8-.1-1.6.6-1.8 1.4v4.2h5.7c-.1 2-.4 4.1-.7 6.1h-5v18h-7.4V24h-3.6v-6h3.6v-5.9c.1-1.7.7-3.3 1.8-4.3z"/></svg>';
}
fb += '</a>';
fb += '</div>';
var twi = '';
twi += '<div class="t-review-social-links\_\_item">';
twi += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.762 24c0 13.121-10.639 23.76-23.761 23.76S.24 37.121.24 24C.24 10.876 10.879.24 24.001.24S47.762 10.876 47.762 24m-9.731-11.625a12.148 12.148 0 0 1-3.87 1.481 6.08 6.08 0 0 0-4.455-1.926 6.095 6.095 0 0 0-6.093 6.095c0 .478.054.941.156 1.388a17.302 17.302 0 0 1-12.559-6.367 6.066 6.066 0 0 0-.825 3.064 6.088 6.088 0 0 0 2.711 5.07 6.075 6.075 0 0 1-2.761-.762v.077c0 2.951 2.1 5.414 4.889 5.975a6.079 6.079 0 0 1-2.752.106 6.104 6.104 0 0 0 5.692 4.232 12.226 12.226 0 0 1-7.567 2.607c-.492 0-.977-.027-1.453-.084a17.241 17.241 0 0 0 9.34 2.736c11.209 0 17.337-9.283 17.337-17.337 0-.263-.004-.527-.017-.789a12.358 12.358 0 0 0 3.039-3.152 12.138 12.138 0 0 1-3.498.958 6.089 6.089 0 0 0 2.686-3.372"/></svg>';
} else {
twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.8 12.7c-1.3.6-2.8 1-4.2 1.1 1.5-1 2.6-2.3 3.2-4-1.5.8-2.9 1.5-4.7 1.8-1.3-1.5-3.2-2.3-5.3-2.3-4 0-7.3 3.2-7.3 7.3 0 .6 0 1.1.2 1.6-6-.3-11.3-3.2-15.1-7.6-.6 1.1-1 2.3-1 3.7 0 2.6 1.3 4.7 3.2 6-1.1 0-2.3-.3-3.2-1v.2c0 3.6 2.4 6.5 5.8 7.1-.6.2-1.3.3-1.9.3-.5 0-1 0-1.3-.2 1 2.9 3.6 5 6.8 5-2.4 1.9-5.7 3.1-9.1 3.1-.6 0-1.1 0-1.8-.2 3.2 2.1 7 3.2 11.2 3.2 13.4 0 20.7-11 20.7-20.7v-1c1.7-.7 2.8-2 3.8-3.4z"/></svg>';
}
twi += '</a>';
twi += '</div>';
var vk = '';
vk += '<div class="t-review-social-links\_\_item">';
vk += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.761 24c0 13.121-10.639 23.76-23.76 23.76C10.878 47.76.239 37.121.239 24 .239 10.877 10.878.24 24.001.24c13.121 0 23.76 10.637 23.76 23.76m-12.502 4.999c-2.621-2.433-2.271-2.041.89-6.25 1.923-2.562 2.696-4.126 2.45-4.796-.227-.639-1.64-.469-1.64-.469l-4.71.029s-.351-.048-.609.106c-.249.151-.414.505-.414.505s-.742 1.982-1.734 3.669c-2.094 3.559-2.935 3.747-3.277 3.524-.796-.516-.597-2.068-.597-3.171 0-3.449.522-4.887-1.02-5.259-.511-.124-.887-.205-2.195-.219-1.678-.016-3.101.007-3.904.398-.536.263-.949.847-.697.88.31.041 1.016.192 1.388.699.484.656.464 2.131.464 2.131s.282 4.056-.646 4.561c-.632.347-1.503-.36-3.37-3.588-.958-1.652-1.68-3.481-1.68-3.481s-.14-.344-.392-.527c-.299-.222-.722-.298-.722-.298l-4.469.018s-.674-.003-.919.289c-.219.259-.018.752-.018.752s3.499 8.104 7.573 12.23c3.638 3.784 7.764 3.36 7.764 3.36h1.867s.566.113.854-.189c.265-.288.256-.646.256-.646s-.034-2.512 1.129-2.883c1.15-.36 2.624 2.429 4.188 3.497 1.182.812 2.079.633 2.079.633l4.181-.056s2.186-.136 1.149-1.858c-.197-.139-.715-1.269-3.219-3.591"/></svg>';
} else {
vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.2 22.2c.6-.8 1.1-1.5 1.5-2 2.7-3.5 3.8-5.8 3.5-6.8l-.2-.2c-.1-.1-.3-.3-.7-.4-.4-.1-.9-.1-1.5-.1h-7.2c-.2 0-.3 0-.3.1 0 0-.1 0-.1.1v.1c-.1 0-.2.1-.3.2-.1.1-.2.2-.2.4-.7 1.9-1.5 3.6-2.5 5.2-.6 1-1.1 1.8-1.6 2.5s-.9 1.2-1.2 1.5c-.3.3-.6.6-.9.8-.2.3-.4.4-.5.4-.1 0-.3-.1-.4-.1-.2-.1-.4-.3-.5-.6-.1-.2-.2-.5-.3-.9 0-.4-.1-.7-.1-.9v-4c0-.7 0-1.2.1-1.6v-1.3c0-.4 0-.8-.1-1.1-.1-.3-.1-.5-.2-.7-.1-.2-.3-.4-.5-.6-.2-.1-.5-.2-.8-.3-.8-.2-1.9-.3-3.1-.3-2.9 0-4.7.2-5.5.6-.3.2-.6.4-.9.7-.3.3-.3.5-.1.6.9.1 1.6.5 2 1l.1.3c.1.2.2.6.3 1.1.1.5.2 1.1.2 1.7.1 1.1.1 2.1 0 2.9-.1.8-.1 1.4-.2 1.9-.1.4-.2.8-.3 1.1-.1.3-.2.4-.3.5 0 .1-.1.1-.1.1-.1-.1-.4-.1-.6-.1-.2 0-.5-.1-.8-.3-.3-.2-.6-.5-1-.9-.3-.4-.7-.9-1.1-1.6-.4-.7-.8-1.5-1.3-2.4l-.4-.7c-.2-.4-.5-1.1-.9-1.9-.4-.8-.8-1.6-1.1-2.4-.1-.3-.3-.6-.6-.7l-.1-.1c-.1-.1-.2-.1-.4-.2s-.3-.1-.5-.2H3.2c-.6 0-1.1.1-1.3.4l-.1.1c0 .1-.1.2-.1.4s0 .4.1.6c.9 2.2 1.9 4.3 3 6.3s2 3.6 2.8 4.9c.8 1.2 1.6 2.4 2.4 3.5.8 1.1 1.4 1.8 1.7 2.1.3.3.5.5.6.7l.6.6c.4.4.9.8 1.6 1.3.7.5 1.5 1 2.4 1.5.9.5 1.9.9 3 1.2 1.2.3 2.3.4 3.4.4H26c.5 0 .9-.2 1.2-.5l.1-.1c.1-.1.1-.2.2-.4s.1-.4.1-.6c0-.7 0-1.3.1-1.8s.2-.9.4-1.2c.1-.3.3-.5.5-.7.2-.2.3-.3.4-.3.1 0 .1-.1.2-.1.4-.1.8 0 1.3.4s1 .8 1.4 1.3c.4.5 1 1.1 1.6 1.8.6.7 1.2 1.2 1.6 1.5l.5.3c.3.2.7.4 1.2.5.5.2.9.2 1.3.1l5.9-.1c.6 0 1-.1 1.4-.3.3-.2.5-.4.6-.6.1-.2.1-.5 0-.8-.1-.3-.1-.5-.2-.6-.1-.1-.1-.2-.2-.3-.8-1.4-2.2-3.1-4.4-5.1-1-.9-1.6-1.6-1.9-1.9-.5-.6-.6-1.2-.3-1.9.3-.5 1-1.5 2.2-3z"/></svg>';
}
vk += '</a>';
vk += '</div>';
var ok = '';
ok += '<div class="t-review-social-links\_\_item">';
ok += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15.001 29.997C6.715 29.997 0 23.28 0 14.997 0 6.714 6.715 0 15.001 0 23.282-.001 30 6.713 30 14.998c0 8.283-6.716 14.999-14.998 14.999zM15 9.163c.986 0 1.787.803 1.787 1.787 0 .987-.801 1.788-1.787 1.788a1.788 1.788 0 0 1 0-3.574zm4.317 1.787a4.322 4.322 0 0 0-4.317-4.319 4.323 4.323 0 0 0-4.319 4.32A4.322 4.322 0 0 0 15 15.266a4.32 4.32 0 0 0 4.316-4.317zm-2.57 7.84a8.126 8.126 0 0 0 2.507-1.038 1.266 1.266 0 0 0-1.347-2.143 5.482 5.482 0 0 1-5.816 0 1.265 1.265 0 0 0-1.348 2.143c.78.49 1.628.838 2.507 1.038l-2.414 2.414a1.267 1.267 0 0 0 .894 2.16c.324 0 .649-.125.895-.37l2.371-2.373 2.373 2.373a1.265 1.265 0 0 0 1.788-1.789l-2.41-2.415z"/></svg>';
} else {
ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M12.498 6.2a1.932 1.932 0 0 0-1.929 1.93 1.932 1.932 0 0 0 3.861 0 1.932 1.932 0 0 0-1.932-1.93zm0 6.592a4.668 4.668 0 0 1-4.66-4.662 4.665 4.665 0 0 1 4.66-4.663 4.666 4.666 0 0 1 4.664 4.663 4.669 4.669 0 0 1-4.664 4.662zm-1.884 3.801a8.75 8.75 0 0 1-2.708-1.12 1.367 1.367 0 1 1 1.455-2.312 5.925 5.925 0 0 0 6.276 0 1.367 1.367 0 1 1 1.456 2.311c-.832.522-1.749.9-2.707 1.12l2.606 2.608a1.367 1.367 0 0 1-1.933 1.931L12.5 18.569l-2.561 2.562a1.368 1.368 0 0 1-1.934-1.934l2.609-2.604z"/></svg>';
}
ok += '</a>';
ok += '</div>';
var behance = '';
behance += '<div class="t-review-social-links\_\_item">';
behance += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-421.541 278.608c-3.095 0-3.526 3.09-3.526 3.09h6.581c0-.001.042-3.09-3.055-3.09zM-436.472 281.697h-5.834v5.356h5.165c.088 0 .219.002.374 0 .831-.02 2.406-.261 2.406-2.604-.001-2.78-2.111-2.752-2.111-2.752z"/><path d="M-430.984 257C-444.248 257-455 267.75-455 281.014c0 13.263 10.752 24.016 24.016 24.016 13.262 0 24.014-10.752 24.014-24.016-.001-13.263-10.754-24.014-24.014-24.014zm5.054 14.756h8.267v2.467h-8.267v-2.467zm-4.179 12.943c0 6.116-6.364 5.914-6.364 5.914h-10.428v-20.038h10.428c3.168 0 5.668 1.75 5.668 5.335s-3.057 3.813-3.057 3.813c4.031 0 3.753 4.976 3.753 4.976zm15.466-.328h-10.384c0 3.722 3.526 3.487 3.526 3.487 3.329 0 3.213-2.156 3.213-2.156h3.527c0 5.722-6.859 5.33-6.859 5.33-8.227 0-7.698-7.661-7.698-7.661s-.008-7.698 7.698-7.698c8.112.001 6.977 8.698 6.977 8.698z"/><path d="M-435.055 276.221c0-2.084-1.417-2.084-1.417-2.084H-442.306v4.471h5.472c.944 0 1.779-.304 1.779-2.387z"/></svg>';
} else {
behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M22.4 7.5h-5.6V6.1h5.6v1.4zm-9.3 5.7c.4.6.5 1.2.5 2s-.2 1.6-.6 2.2c-.3.4-.6.8-1 1.1-.4.3-1 .6-1.6.7-.6.1-1.3.2-2 .2H2.3V5.6H9c1.7 0 2.9.5 3.6 1.5.4.6.6 1.3.6 2.1s-.2 1.5-.6 2c-.2.3-.6.6-1.1.8.7.2 1.2.7 1.6 1.2zM5.5 11h2.9c.6 0 1.1-.1 1.5-.3.4-.2.6-.6.6-1.2s-.2-1.1-.7-1.3C9.3 8.1 8.7 8 8.1 8H5.5v3zm5.2 4c0-.7-.3-1.2-.9-1.5-.3-.2-.8-.2-1.4-.2h-3V17h2.9c.6 0 1.1-.1 1.4-.2.7-.3 1-.9 1-1.8zm13.8-2.2c.1.5.1 1.1.1 2h-7.2c0 1 .4 1.7 1 2.1.4.3.9.4 1.4.4.6 0 1.1-.1 1.4-.5.2-.2.4-.4.5-.7h2.6c-.1.6-.4 1.2-1 1.8-.9 1-2.1 1.4-3.7 1.4-1.3 0-2.5-.4-3.5-1.2-1-.8-1.5-2.1-1.5-4 0-1.7.5-3 1.4-4 .9-.9 2.1-1.4 3.5-1.4.9 0 1.6.2 2.3.5.7.3 1.3.8 1.7 1.5.6.6.8 1.3 1 2.1zm-2.7.2c0-.7-.3-1.2-.7-1.6-.4-.4-.9-.5-1.5-.5-.7 0-1.2.2-1.5.6-.4.4-.6.9-.7 1.5h4.4z"/></svg>';
}
behance += '</a>';
behance += '</div>';
var vimeo = '';
vimeo += '<div class="t-review-social-links\_\_item">';
vimeo += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 256.971c13.267 0 24.023 10.755 24.023 24.023s-10.755 24.023-24.023 24.023-24.023-10.755-24.023-24.023 10.756-24.023 24.023-24.023zm-12.262 19.146l.996 1.306s2.054-1.619 2.739-.81c.685.81 3.299 10.584 4.171 12.387.761 1.581 2.862 3.672 5.166 2.179 2.302-1.493 9.959-8.03 11.329-15.749 1.369-7.717-9.213-6.1-10.335.623 2.802-1.682 4.297.683 2.863 3.362-1.431 2.676-2.739 4.421-3.424 4.421-.683 0-1.209-1.791-1.992-4.92-.81-3.236-.804-9.064-4.17-8.403-3.171.623-7.343 5.604-7.343 5.604z"/></svg>';
} else {
vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M2.9 16.5l1.6 2s3.2-2.5 4.3-1.3c1.1 1.3 5.2 16.5 6.5 19.3 1.2 2.5 4.5 5.7 8.1 3.4S39 27.4 41.1 15.3s-14.4-9.5-16.1 1c4.4-2.6 6.7 1.1 4.5 5.3s-4.3 6.9-5.3 6.9c-1.1 0-1.9-2.8-3.1-7.7-1.3-5.1-1.3-14.2-6.5-13.1-5.2 1-11.7 8.8-11.7 8.8z"/></svg>';
}
vimeo += '</a>';
vimeo += '</div>';
var youtube = '';
youtube += '<div class="t-review-social-links\_\_item">';
youtube += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 257.013c13.248 0 23.987 10.74 23.987 23.987s-10.74 23.987-23.987 23.987-23.987-10.74-23.987-23.987 10.739-23.987 23.987-23.987zm11.815 18.08c-.25-1.337-1.363-2.335-2.642-2.458-3.054-.196-6.119-.355-9.178-.357-3.059-.002-6.113.154-9.167.347-1.284.124-2.397 1.117-2.646 2.459a40.163 40.163 0 0 0 0 11.672c.249 1.342 1.362 2.454 2.646 2.577 3.055.193 6.107.39 9.167.39 3.058 0 6.126-.172 9.178-.37 1.279-.124 2.392-1.269 2.642-2.606a39.769 39.769 0 0 0 0-11.654zm-14.591 9.342v-7.115l6.627 3.558-6.627 3.557z"/></svg>';
} else {
youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M43.9 15.3c-.4-3.1-2.2-5-5.3-5.3-3.6-.3-11.4-.5-15-.5-7.3 0-10.6.2-14.1.5-3.3.3-4.8 1.8-5.4 4.9-.4 2.1-.6 4.1-.6 8.9 0 4.3.2 6.9.5 9.2.4 3.1 2.5 4.8 5.7 5.1 3.6.3 10.9.5 14.4.5s11.2-.2 14.7-.6c3.1-.4 4.6-2 5.1-5.1 0 0 .5-3.3.5-9.1 0-3.3-.2-6.4-.5-8.5zM19.7 29.8V18l11.2 5.8-11.2 6z"/></svg>';
}
youtube += '</a>';
youtube += '</div>';
var instagram = '';
instagram += '<div class="t-review-social-links\_\_item">';
instagram += ' <a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15 11.014a3.986 3.986 0 1 0 .001 7.971A3.986 3.986 0 0 0 15 11.014zm0 6.592A2.604 2.604 0 0 1 12.393 15 2.604 2.604 0 0 1 15 12.394 2.614 2.614 0 0 1 17.607 15 2.604 2.604 0 0 1 15 17.606zM19.385 9.556a.915.915 0 0 0-.92.921c0 .512.407.919.92.919a.914.914 0 0 0 .921-.919.916.916 0 0 0-.921-.921z"/><path d="M15.002.15C6.798.15.149 6.797.149 15c0 8.201 6.649 14.85 14.853 14.85 8.199 0 14.85-6.648 14.85-14.85 0-8.203-6.651-14.85-14.85-14.85zm7.664 18.115c0 2.423-1.979 4.401-4.416 4.401h-6.5c-2.438 0-4.417-1.979-4.417-4.386v-6.546c0-2.422 1.978-4.4 4.417-4.4h6.5c2.438 0 4.416 1.978 4.416 4.4v6.531z"/></svg>';
} else {
instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M16.396 3.312H8.604c-2.921 0-5.292 2.371-5.292 5.273v7.846c0 2.886 2.371 5.256 5.292 5.256h7.791c2.922 0 5.292-2.37 5.292-5.274V8.586c.001-2.903-2.37-5.274-5.291-5.274zM7.722 12.5a4.778 4.778 0 1 1 9.554 0 4.778 4.778 0 0 1-9.554 0zm10.034-4.318c-.615 0-1.104-.487-1.104-1.102s.488-1.103 1.104-1.103c.614 0 1.102.488 1.102 1.103s-.488 1.102-1.102 1.102z" /><path d="M12.5 9.376A3.12 3.12 0 0 0 9.376 12.5a3.12 3.12 0 0 0 3.124 3.124 3.12 3.12 0 0 0 3.124-3.124A3.133 3.133 0 0 0 12.5 9.376z"/></svg>';
}
instagram += '</a>';
instagram += '</div>';
var pinterest = '';
pinterest += '<div class="t-review-social-links\_\_item">';
pinterest += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-407 281c0 13.254-10.746 24-23.999 24-13.257 0-24.003-10.746-24.003-24 0-13.256 10.746-24 24.003-24 13.253 0 23.999 10.744 23.999 24zm-30.628 14.811c.027.205.29.254.409.1.17-.223 2.365-2.932 3.111-5.639.211-.768 1.212-4.738 1.212-4.738.599 1.145 2.349 2.148 4.21 2.148 5.539 0 9.297-5.049 9.297-11.809 0-5.111-4.329-9.873-10.909-9.873-8.186 0-12.314 5.871-12.314 10.766 0 2.963 1.122 5.6 3.527 6.582.395.162.749.006.863-.43.08-.303.268-1.065.353-1.385.114-.432.07-.582-.248-.959-.694-.818-1.138-1.879-1.138-3.381 0-4.353 3.259-8.252 8.484-8.252 4.627 0 7.169 2.828 7.169 6.603 0 4.969-2.198 9.162-5.461 9.162-1.804 0-3.153-1.49-2.722-3.32.518-2.182 1.522-4.537 1.522-6.113 0-1.41-.758-2.588-2.324-2.588-1.843 0-3.323 1.908-3.323 4.461 0 1.627.55 2.727.55 2.727l-2.217 9.391c-.657 2.787-.099 6.203-.051 6.547z"/></svg>';
} else {
pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M24.9 5.5c4.2 0 7.7 1.3 10.5 3.9s4.1 5.7 4.1 9.2c0 4.6-1.2 8.4-3.5 11.3-2.3 3-5.3 4.5-8.9 4.5-1.2 0-2.3-.3-3.4-.9s-1.8-1.3-2.2-2c-.9 3.5-1.4 5.6-1.6 6.3-.7 2.4-2 4.9-4.1 7.5-.2.2-.4.2-.5-.1-.5-3.5-.5-6.4.1-8.7l2.9-12.6c-.5-.9-.7-2.1-.7-3.6 0-1.7.4-3.1 1.3-4.2s1.9-1.7 3.2-1.7c1 0 1.8.3 2.3 1 .5.6.8 1.5.8 2.4 0 .6-.1 1.4-.3 2.3-.2.9-.5 1.9-.9 3.1s-.6 2.1-.8 2.8c-.3 1.2-.1 2.2.7 3.1.7.9 1.7 1.3 3 1.3 2.1 0 3.8-1.2 5.2-3.6 1.4-2.4 2-5.3 2-8.7 0-2.6-.8-4.7-2.5-6.3-1.7-1.6-4-2.4-7-2.4-3.4 0-6.1 1.1-8.2 3.2S13 17.4 13 20.4c0 1.8.5 3.3 1.5 4.5.3.4.4.8.3 1.2 0 .1-.1.3-.2.6-.1.4-.1.6-.2.7 0 .1-.1.4-.2.6-.1.3-.3.4-.4.4h-.6c-3.1-1.3-4.7-4.2-4.7-8.7 0-3.6 1.5-6.9 4.4-9.9s7-4.3 12-4.3z"/></svg>';
}
pinterest += '</a>';
pinterest += '</div>';
var linkedin = '';
linkedin += '<div class="t-review-social-links\_\_item">';
linkedin += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-615 1477 48 48" fill="' + fill + '"><path d="M-566.999 1501c0 13.256-10.746 24-24 24-13.256 0-24.002-10.744-24.002-24 0-13.254 10.746-24 24.002-24 13.254 0 24 10.746 24 24zm-38.507 13.975h6.22v-20.004h-6.22v20.004zm3.11-22.739a3.606 3.606 0 0 0 0-7.211 3.603 3.603 0 0 0-3.604 3.605 3.604 3.604 0 0 0 3.604 3.606zm26.396 11.766c0-5.387-1.163-9.529-7.454-9.529-3.023 0-5.054 1.658-5.884 3.231h-.085v-2.733h-5.964v20.004h6.216v-9.896c0-2.609.493-5.137 3.729-5.137 3.186 0 3.232 2.984 3.232 5.305v9.729h6.21v-10.974z"/></svg>';
} else {
linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M42.3 23.1v13.5h-7.9V24c0-3.2-1.1-5.3-4-5.3-2.2 0-3.5 1.5-4 2.9-.2.5-.3 1.2-.3 1.9v13.2h-7.9s.1-21.4 0-23.6h7.9v3.3s0 .1-.1.1h.1v-.1c1-1.6 2.9-3.9 7.1-3.9 5.2-.1 9.1 3.3 9.1 10.6zM10.1 1.6c-2.7 0-4.4 1.8-4.4 4.1S7.4 9.8 10 9.8h.1c2.7 0 4.4-1.8 4.4-4.1s-1.7-4.1-4.4-4.1zm-3.9 35H14V13H6.2v23.6z"/></svg>';
}
linkedin += '</a>';
linkedin += '</div>';
var soundcloud = '';
soundcloud += '<div class="t-review-social-links\_\_item">';
soundcloud += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><defs><path id="a" d="M0 0h48v48H0V0z"/></defs><g fill-rule="evenodd"><path d="M38.206 22.171c-.635 0-1.241.129-1.793.36-.369-4.177-3.871-7.453-8.144-7.453a8.28 8.28 0 0 0-2.965.553c-.35.136-.442.275-.446.546v14.709a.545.545 0 0 0 .5.531c.013.002 12.848 0 12.848 0 2.56 0 4.634-2.051 4.634-4.611a4.634 4.634 0 0 0-4.634-4.635zM24.17 16.237a.5.5 0 0 0-.582.043.517.517 0 0 0-.189.392v.053l-.21 10.388.107 1.92.103 1.869a.514.514 0 0 0 .51.505.515.515 0 0 0 .51-.509v.004l.228-3.79-.227-10.44a.517.517 0 0 0-.25-.435zm-1.364 14.72v-.001.001-.002.002zm-.215-13.813a.47.47 0 0 0-.264-.081.486.486 0 0 0-.478.477l-.001.09-.18 9.48.181 3.847.001.016a.48.48 0 0 0 .477.458c.246 0 .248-.054.335-.14a.486.486 0 0 0 .144-.336l.02-.38.181-3.463-.201-9.573a.487.487 0 0 0-.215-.395zm-1.853 1.479a.447.447 0 0 0-.446.444l-.2 8.044.2 3.87c.005.465.2.442.446.442.245 0 .44.023.446-.444v.003l.223-3.87-.223-8.046a.447.447 0 0 0-.446-.443zm-1.577-.273a.416.416 0 0 0-.414.412l-.219 8.349.219 3.895c.005.228.187.41.414.41a.416.416 0 0 0 .413-.412v.002l.246-3.895-.246-8.35a.416.416 0 0 0-.413-.411zm-1.184 12.693v-.002.002zm0-12.5a.385.385 0 0 0-.382-.38.384.384 0 0 0-.381.38l-.238 8.567.238 3.932c.006.21.173.377.381.377a.385.385 0 0 0 .382-.378l.268-3.931-.268-8.568zm-1.935-.069a.354.354 0 0 0-.35.347l-.256 8.288.257 3.957c.006.193.16.346.35.346a.354.354 0 0 0 .349-.347v.002l.29-3.958-.29-8.288a.355.355 0 0 0-.35-.347zm-1.564.691a.322.322 0 0 0-.318.315l-.275 7.65.276 3.998a.321.321 0 0 0 .317.313c.17 0 .31-.138.317-.315v.002l.312-3.999-.312-7.65a.323.323 0 0 0-.317-.314zM12.974 20.6a.29.29 0 0 0-.285.282l-.295 6.226.295 4.023a.29.29 0 0 0 .285.281.292.292 0 0 0 .285-.282v.001l.333-4.023-.333-6.226a.292.292 0 0 0-.285-.282zm-1.264 2.678a.258.258 0 0 0-.253-.248.257.257 0 0 0-.253.25l-.314 3.826.314 4.024c.008.142.117.25.253.25a.259.259 0 0 0 .253-.25l.356-4.024-.356-3.828zm0 7.851v.001zm-1.757-8.366a.226.226 0 0 0-.221.217l-.333 4.126.333 3.99c.009.124.104.217.22.217s.21-.093.221-.216l.4-3.991-.4-4.126c-.01-.123-.105-.217-.22-.217zm-1.493.142c-.1 0-.179.078-.189.185l-.351 4.015.351 3.868c.01.108.09.185.19.185.097 0 .176-.077.188-.184l.4-3.869-.4-4.015c-.012-.107-.091-.185-.189-.185zm-2.873 1.96c-.079 0-.14.06-.151.147l-.276 2.094.276 2.056c.01.086.072.147.15.147s.14-.06.152-.147l.326-2.056-.326-2.095c-.013-.086-.074-.145-.151-.145zM6.98 23.57c-.08 0-.146.064-.157.152l-.25 3.385.25 3.308c.011.088.077.152.157.152s.144-.062.156-.152l.422-3.308-.422-3.385c-.012-.09-.077-.152-.156-.152zM48 24c0 13.255-10.745 24-24 24C10.757 48 0 37.255 0 24 0 10.757 10.757 0 24 0c13.255 0 24 10.757 24 24z"/></g></svg>';
} else {
soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M1.6 24.3c-.2 0-.3.1-.3.3l-.5 6.2.5 6c0 .2.2.3.3.3.2 0 .3-.1.3-.3l.6-6-.6-6.2c0-.2-.1-.3-.3-.3zm3.3 12.6zm0-11.8c0-.2-.2-.4-.4-.4s-.4.2-.4.4l-.5 5.8.5 6.1c0 .2.2.4.4.4s.4-.2.4-.4l.5-6.1-.5-5.8zm2.7-6.2c-.3 0-.5.2-.5.5l-.4 11.5.4 6c0 .3.2.5.5.5s.5-.2.5-.5l.5-6-.5-11.6c-.1-.2-.3-.4-.5-.4zm3.8-1c0-.3-.3-.6-.6-.6s-.6.3-.6.6l-.4 13 .4 5.9c0 .3.3.6.6.6s.6-.3.6-.6l.4-5.9-.4-13zm2.7.1c-.4 0-.7.3-.7.7l-.3 12.2.3 5.9c0 .4.3.7.7.7.4 0 .7-.3.7-.7l.3-5.9-.3-12.2c0-.4-.3-.7-.7-.7zm3.7-3.6c-.1-.1-.3-.1-.4-.1-.2 0-.4.1-.5.2-.2.1-.3.4-.3.6v.1l-.3 15.7.2 2.9.2 2.8c0 .4.4.8.8.8s.8-.3.8-.8l.3-5.7-.3-15.8c-.1-.3-.3-.5-.5-.7zm22.4 9c-1 0-1.9.2-2.7.5-.6-6.3-5.9-11.3-12.3-11.3-1.6 0-3.1.3-4.5.8-.5.2-.7.4-.7.8v22.2c0 .4.3.8.8.8h19.4c3.9 0 7-3.1 7-7 0-3.7-3.1-6.8-7-6.8z"/></svg>';
}
soundcloud += '</a>';
soundcloud +=' </div>';
var telegram = '';
telegram += '<div class="t-review-social-links\_\_item">';
telegram += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 60 60" fill="' + fill + '"><path d="M30 0C13.4 0 0 13.4 0 30s13.4 30 30 30 30-13.4 30-30S46.6 0 30 0zm16.9 13.9l-6.7 31.5c-.1.6-.8.9-1.4.6l-10.3-6.9-5.5 5.2c-.5.4-1.2.2-1.4-.4L18 32.7l-9.5-3.9c-.7-.3-.7-1.5 0-1.8l37.1-14.1c.7-.2 1.4.3 1.3 1z"/><path d="M22.7 40.6l.6-5.8 16.8-16.3-20.2 13.3"/></svg>';
} else {
telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 60 60" fill="' + fill + '"><path d="M52.5 9L6.1 26.9c-.9.4-.9 1.8 0 2.3L18 34.1l4.4 14.1c.3.8 1.2 1 1.8.5l6.8-6.4L43.9 51c.7.4 1.6 0 1.7-.7l8.4-40c.2-.8-.7-1.6-1.5-1.3zm-28 27.7l-.7 7.3-3.6-11.2L45.5 16l-21 20.7z"/></svg>';
}
telegram += '</a>';
telegram += '</div>';
if (item.indexOf('facebook') != -1) {
socialWrapper.append(fb);
}
if (item.indexOf('twitter') != -1) {
socialWrapper.append(twi);
}
if (item.indexOf('vk.com') != -1) {
socialWrapper.append(vk);
}
if (item.indexOf('ok.ru') != -1) {
socialWrapper.append(ok);
}
if (item.indexOf('behance') != -1) {
socialWrapper.append(behance);
}
if (item.indexOf('vimeo') != -1) {
socialWrapper.append(vimeo);
}
if (item.indexOf('youtube') != -1) {
socialWrapper.append(youtube);
}
if (item.indexOf('instagram') != -1) {
socialWrapper.append(instagram);
}
if (item.indexOf('pinterest') != -1) {
socialWrapper.append(pinterest);
}
if (item.indexOf('linkedin') != -1) {
socialWrapper.append(linkedin);
}
if (item.indexOf('soundcloud') != -1) {
socialWrapper.append(soundcloud);
}
if (item.indexOf('telegram') != -1) {
socialWrapper.append(telegram);
}
}
$(document).ready(function() {
t\_reviews\_social\_init('262141601');
});
@media screen and (max-width: 640px){
.t525 .t-review-social-links\_\_wrapper {
-webkit-box-pack: center;
-ms-flex-pack: center;
justify-content: center;
}
}
### Один запрос к разным БД
Один раз во время подготовки выпуска обновления игры нужно было сконвертировать данные. Стандартно мы делали это с помощью SQL-запроса. Запросы были нужны в синтаксисе MySQL и PostgreSQL. В MySQL синтаксис позволяет указать после UPDATE несколько таблиц, которые можно использовать далее в запросе. PostgreSQL такого не позволяет, у него другой синтаксис. Упрощённо мой запрос выглядел следующим образом (для краткости я убрал связи с другими таблицами):
**update test set id = t2.id + 1 from test t2;**
Этот запрос делал совсем не то, что задумывалось. Если вставить в id числа от 1 до 3, то при выполнении запроса PostgreSQL во всех строках поставил 2 (хотя результат исполнения запроса, вообще говоря, не детерминирован: в любой строке может получиться число от 2 до 4). Подобный запрос в синтаксисе T-SQL (update test set id = id + 1 from test;) будет синтаксически верным и действительно увеличит значение столбца id на 1.
Дело в том, что синтаксис PostgreSQL не позволяет задавать одинаковые имена таблицам в секциях update и from, в то время как T-SQL позволяет указывать имя той же таблицы в from, и это будет именно таблица из update. Возможно, из-за этой особенности разработчик допустил ошибку и она не была найдена в процессе код-ревью.
В ходе проверки большая часть тестовых ситуаций была для MySQL, а исполнение запроса для PostgreSQL оказалось недетерминированным. Ошибку во время проверки конвертирования так и не обнаружили. Возможно, там случайно оказались нужные цифры либо на них не обратили внимания.
Кроме тестовых ситуаций у нас есть процедура автоматизированной проверки обновлённой базы данных: после преобразования программа подключается к новой версии и заходит в игру разными игроками. Как только её запустили, сразу заметили, что конвертирование базы стало идти дольше, чем обычно. Так мы и обнаружили проблемный запрос.
### Как мы выстраиваем процесс код-ревью
Этот баг мы поймали благодаря налаженному процессу тестирования. Если бы не нашли этот запрос, часть данных у некоторых игроков изменилась бы случайным образом. Причём, скорее всего, это бы выяснилось через определённое время после миграции базы, когда исправить ошибку было бы уже сложнее.
Чтобы избегать подобных ситуаций, мы проводим код-ревью поэтапно и отслеживаем несколько критериев качества. Во-первых, отслеживаем соответствие кода Code Conventions внутри команды. Проверяем, что в коде нет выделенного нами набора инспекций из IDEA и копипасты чужого кода (хотя это и не всегда [плохо](https://youtu.be/BAoDa2ImPpk), просто вместе с кодом нередко копипастят и ошибки). Оцениваем покрытие кода тестами. 100 %-го покрытия кода тестами, конечно, нет, но какой-то хотя бы минимальный набор на каждый функционал быть должен. Как показал данный случай, ошибка может пройти несколько стадий проверки, поэтому в работе важно использовать различные методы поиска ошибок и тестирования приложений.
У новых сотрудников мы оцениваем качество их кода и стараемся сразу подключить к процессу код-ревью. Если это не начинающий разработчик, то через непродолжительное время по мере знакомства с проектом он сам начинает проводить ревью чужого кода. Начинающему разработчику требуется больше времени, чтобы включиться в процесс с обеих сторон. Но по мере накопления опыта и уменьшения количества дефектов в коде стараемся подключать к процессу осуществления ревью как можно раньше.
Регламенты и информирование
---------------------------
Привет, Хабр! Меня зовут Анна Долгова, и я прошла путь от тестировщика до тимлида группы тестирования фронтенда в проекте «[Пульс](https://u.habr.com/mrg_post_pulse)» — рекомендательной системе, которая работает на базе технологий машинного обучения и предлагает пользователям контент и рекламу с учётом их интересов.
.t-review-social-links {
line-height: 0px;
}
.t-review-social-links\_\_wrapper {
display: -webkit-box;
display: -ms-flexbox;
display: flex;
-webkit-box-align: center;
-ms-flex-align: center;
align-items: center;
-ms-flex-wrap: wrap;
flex-wrap: wrap;
width: auto;
}
.t-review-social-links {
margin-top: 15px;
}
.t-review-social-links\_\_item {
padding: 0px 4px;
}
.t-review-social-links\_\_item svg {
width: 20px;
height: 20px;
}
.t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg {
width: 23px;
height: 23px;
}
.t-review-social-links\_\_item:first-child {
padding-left: 0px;
}
@media screen and (max-width: 960px) {
.t-review-social-links\_\_item {
margin-bottom: 3px;
}
}
@media screen and (max-width: 640px) {
.t-review-social-links {
margin-top: 13px;
}
.t-review-social-links\_\_item {
padding: 0px 3px;
}
.t-review-social-links\_\_item svg {
width: 17px;
height: 17px;
}
.t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg {
width: 20px;
height: 20px;
}
}
function t\_reviews\_social\_init(recid){
var rec = $('#rec' + recid);
var social = rec.find('.t-review-social-links');
if (social !== 'undefined' && social.length > 0) {
social.each(function() {
var $this = $(this);
var socialAttr = $this.attr('data-social-links');
var socialWrapper = $this.find('.t-review-social-links\_\_wrapper');
var links;
$this.removeAttr('data-social-links');
if (typeof socialAttr !== 'undefined') {
links = socialAttr.split(',');
links.forEach(function(item) {
t\_reviews\_social\_add\_item(item, socialWrapper);
});
}
});
}
}
function t\_reviews\_social\_add\_item(item, socialWrapper) {
var fill = socialWrapper.attr('data-social-color') || '#000000';
var fb = '';
fb = '<div class="t-review-social-links\_\_item">';
fb += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
fb += '<svg class="t-review-social-links\_\_svg" version="1.1" id="Layer\_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="30px" height="30px" viewBox="0 0 48 48" enable-background="new 0 0 48 48" xml:space="preserve" fill="' + fill + '"><desc>Facebook</desc><path d="M47.761,24c0,13.121-10.638,23.76-23.758,23.76C10.877,47.76,0.239,37.121,0.239,24c0-13.124,10.638-23.76,23.764-23.76C37.123,0.24,47.761,10.876,47.761,24 M20.033,38.85H26.2V24.01h4.163l0.539-5.242H26.2v-3.083c0-1.156,0.769-1.427,1.308-1.427h3.318V9.168L26.258,9.15c-5.072,0-6.225,3.796-6.225,6.224v3.394H17.1v5.242h2.933V38.85z"></path></svg>';
} else {
fb += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M21.1 7.8C22.5 6.5 24.5 6 26.4 6h6v6.3h-3.9c-.8-.1-1.6.6-1.8 1.4v4.2h5.7c-.1 2-.4 4.1-.7 6.1h-5v18h-7.4V24h-3.6v-6h3.6v-5.9c.1-1.7.7-3.3 1.8-4.3z"/></svg>';
}
fb += '</a>';
fb += '</div>';
var twi = '';
twi += '<div class="t-review-social-links\_\_item">';
twi += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.762 24c0 13.121-10.639 23.76-23.761 23.76S.24 37.121.24 24C.24 10.876 10.879.24 24.001.24S47.762 10.876 47.762 24m-9.731-11.625a12.148 12.148 0 0 1-3.87 1.481 6.08 6.08 0 0 0-4.455-1.926 6.095 6.095 0 0 0-6.093 6.095c0 .478.054.941.156 1.388a17.302 17.302 0 0 1-12.559-6.367 6.066 6.066 0 0 0-.825 3.064 6.088 6.088 0 0 0 2.711 5.07 6.075 6.075 0 0 1-2.761-.762v.077c0 2.951 2.1 5.414 4.889 5.975a6.079 6.079 0 0 1-2.752.106 6.104 6.104 0 0 0 5.692 4.232 12.226 12.226 0 0 1-7.567 2.607c-.492 0-.977-.027-1.453-.084a17.241 17.241 0 0 0 9.34 2.736c11.209 0 17.337-9.283 17.337-17.337 0-.263-.004-.527-.017-.789a12.358 12.358 0 0 0 3.039-3.152 12.138 12.138 0 0 1-3.498.958 6.089 6.089 0 0 0 2.686-3.372"/></svg>';
} else {
twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.8 12.7c-1.3.6-2.8 1-4.2 1.1 1.5-1 2.6-2.3 3.2-4-1.5.8-2.9 1.5-4.7 1.8-1.3-1.5-3.2-2.3-5.3-2.3-4 0-7.3 3.2-7.3 7.3 0 .6 0 1.1.2 1.6-6-.3-11.3-3.2-15.1-7.6-.6 1.1-1 2.3-1 3.7 0 2.6 1.3 4.7 3.2 6-1.1 0-2.3-.3-3.2-1v.2c0 3.6 2.4 6.5 5.8 7.1-.6.2-1.3.3-1.9.3-.5 0-1 0-1.3-.2 1 2.9 3.6 5 6.8 5-2.4 1.9-5.7 3.1-9.1 3.1-.6 0-1.1 0-1.8-.2 3.2 2.1 7 3.2 11.2 3.2 13.4 0 20.7-11 20.7-20.7v-1c1.7-.7 2.8-2 3.8-3.4z"/></svg>';
}
twi += '</a>';
twi += '</div>';
var vk = '';
vk += '<div class="t-review-social-links\_\_item">';
vk += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.761 24c0 13.121-10.639 23.76-23.76 23.76C10.878 47.76.239 37.121.239 24 .239 10.877 10.878.24 24.001.24c13.121 0 23.76 10.637 23.76 23.76m-12.502 4.999c-2.621-2.433-2.271-2.041.89-6.25 1.923-2.562 2.696-4.126 2.45-4.796-.227-.639-1.64-.469-1.64-.469l-4.71.029s-.351-.048-.609.106c-.249.151-.414.505-.414.505s-.742 1.982-1.734 3.669c-2.094 3.559-2.935 3.747-3.277 3.524-.796-.516-.597-2.068-.597-3.171 0-3.449.522-4.887-1.02-5.259-.511-.124-.887-.205-2.195-.219-1.678-.016-3.101.007-3.904.398-.536.263-.949.847-.697.88.31.041 1.016.192 1.388.699.484.656.464 2.131.464 2.131s.282 4.056-.646 4.561c-.632.347-1.503-.36-3.37-3.588-.958-1.652-1.68-3.481-1.68-3.481s-.14-.344-.392-.527c-.299-.222-.722-.298-.722-.298l-4.469.018s-.674-.003-.919.289c-.219.259-.018.752-.018.752s3.499 8.104 7.573 12.23c3.638 3.784 7.764 3.36 7.764 3.36h1.867s.566.113.854-.189c.265-.288.256-.646.256-.646s-.034-2.512 1.129-2.883c1.15-.36 2.624 2.429 4.188 3.497 1.182.812 2.079.633 2.079.633l4.181-.056s2.186-.136 1.149-1.858c-.197-.139-.715-1.269-3.219-3.591"/></svg>';
} else {
vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.2 22.2c.6-.8 1.1-1.5 1.5-2 2.7-3.5 3.8-5.8 3.5-6.8l-.2-.2c-.1-.1-.3-.3-.7-.4-.4-.1-.9-.1-1.5-.1h-7.2c-.2 0-.3 0-.3.1 0 0-.1 0-.1.1v.1c-.1 0-.2.1-.3.2-.1.1-.2.2-.2.4-.7 1.9-1.5 3.6-2.5 5.2-.6 1-1.1 1.8-1.6 2.5s-.9 1.2-1.2 1.5c-.3.3-.6.6-.9.8-.2.3-.4.4-.5.4-.1 0-.3-.1-.4-.1-.2-.1-.4-.3-.5-.6-.1-.2-.2-.5-.3-.9 0-.4-.1-.7-.1-.9v-4c0-.7 0-1.2.1-1.6v-1.3c0-.4 0-.8-.1-1.1-.1-.3-.1-.5-.2-.7-.1-.2-.3-.4-.5-.6-.2-.1-.5-.2-.8-.3-.8-.2-1.9-.3-3.1-.3-2.9 0-4.7.2-5.5.6-.3.2-.6.4-.9.7-.3.3-.3.5-.1.6.9.1 1.6.5 2 1l.1.3c.1.2.2.6.3 1.1.1.5.2 1.1.2 1.7.1 1.1.1 2.1 0 2.9-.1.8-.1 1.4-.2 1.9-.1.4-.2.8-.3 1.1-.1.3-.2.4-.3.5 0 .1-.1.1-.1.1-.1-.1-.4-.1-.6-.1-.2 0-.5-.1-.8-.3-.3-.2-.6-.5-1-.9-.3-.4-.7-.9-1.1-1.6-.4-.7-.8-1.5-1.3-2.4l-.4-.7c-.2-.4-.5-1.1-.9-1.9-.4-.8-.8-1.6-1.1-2.4-.1-.3-.3-.6-.6-.7l-.1-.1c-.1-.1-.2-.1-.4-.2s-.3-.1-.5-.2H3.2c-.6 0-1.1.1-1.3.4l-.1.1c0 .1-.1.2-.1.4s0 .4.1.6c.9 2.2 1.9 4.3 3 6.3s2 3.6 2.8 4.9c.8 1.2 1.6 2.4 2.4 3.5.8 1.1 1.4 1.8 1.7 2.1.3.3.5.5.6.7l.6.6c.4.4.9.8 1.6 1.3.7.5 1.5 1 2.4 1.5.9.5 1.9.9 3 1.2 1.2.3 2.3.4 3.4.4H26c.5 0 .9-.2 1.2-.5l.1-.1c.1-.1.1-.2.2-.4s.1-.4.1-.6c0-.7 0-1.3.1-1.8s.2-.9.4-1.2c.1-.3.3-.5.5-.7.2-.2.3-.3.4-.3.1 0 .1-.1.2-.1.4-.1.8 0 1.3.4s1 .8 1.4 1.3c.4.5 1 1.1 1.6 1.8.6.7 1.2 1.2 1.6 1.5l.5.3c.3.2.7.4 1.2.5.5.2.9.2 1.3.1l5.9-.1c.6 0 1-.1 1.4-.3.3-.2.5-.4.6-.6.1-.2.1-.5 0-.8-.1-.3-.1-.5-.2-.6-.1-.1-.1-.2-.2-.3-.8-1.4-2.2-3.1-4.4-5.1-1-.9-1.6-1.6-1.9-1.9-.5-.6-.6-1.2-.3-1.9.3-.5 1-1.5 2.2-3z"/></svg>';
}
vk += '</a>';
vk += '</div>';
var ok = '';
ok += '<div class="t-review-social-links\_\_item">';
ok += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15.001 29.997C6.715 29.997 0 23.28 0 14.997 0 6.714 6.715 0 15.001 0 23.282-.001 30 6.713 30 14.998c0 8.283-6.716 14.999-14.998 14.999zM15 9.163c.986 0 1.787.803 1.787 1.787 0 .987-.801 1.788-1.787 1.788a1.788 1.788 0 0 1 0-3.574zm4.317 1.787a4.322 4.322 0 0 0-4.317-4.319 4.323 4.323 0 0 0-4.319 4.32A4.322 4.322 0 0 0 15 15.266a4.32 4.32 0 0 0 4.316-4.317zm-2.57 7.84a8.126 8.126 0 0 0 2.507-1.038 1.266 1.266 0 0 0-1.347-2.143 5.482 5.482 0 0 1-5.816 0 1.265 1.265 0 0 0-1.348 2.143c.78.49 1.628.838 2.507 1.038l-2.414 2.414a1.267 1.267 0 0 0 .894 2.16c.324 0 .649-.125.895-.37l2.371-2.373 2.373 2.373a1.265 1.265 0 0 0 1.788-1.789l-2.41-2.415z"/></svg>';
} else {
ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M12.498 6.2a1.932 1.932 0 0 0-1.929 1.93 1.932 1.932 0 0 0 3.861 0 1.932 1.932 0 0 0-1.932-1.93zm0 6.592a4.668 4.668 0 0 1-4.66-4.662 4.665 4.665 0 0 1 4.66-4.663 4.666 4.666 0 0 1 4.664 4.663 4.669 4.669 0 0 1-4.664 4.662zm-1.884 3.801a8.75 8.75 0 0 1-2.708-1.12 1.367 1.367 0 1 1 1.455-2.312 5.925 5.925 0 0 0 6.276 0 1.367 1.367 0 1 1 1.456 2.311c-.832.522-1.749.9-2.707 1.12l2.606 2.608a1.367 1.367 0 0 1-1.933 1.931L12.5 18.569l-2.561 2.562a1.368 1.368 0 0 1-1.934-1.934l2.609-2.604z"/></svg>';
}
ok += '</a>';
ok += '</div>';
var behance = '';
behance += '<div class="t-review-social-links\_\_item">';
behance += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-421.541 278.608c-3.095 0-3.526 3.09-3.526 3.09h6.581c0-.001.042-3.09-3.055-3.09zM-436.472 281.697h-5.834v5.356h5.165c.088 0 .219.002.374 0 .831-.02 2.406-.261 2.406-2.604-.001-2.78-2.111-2.752-2.111-2.752z"/><path d="M-430.984 257C-444.248 257-455 267.75-455 281.014c0 13.263 10.752 24.016 24.016 24.016 13.262 0 24.014-10.752 24.014-24.016-.001-13.263-10.754-24.014-24.014-24.014zm5.054 14.756h8.267v2.467h-8.267v-2.467zm-4.179 12.943c0 6.116-6.364 5.914-6.364 5.914h-10.428v-20.038h10.428c3.168 0 5.668 1.75 5.668 5.335s-3.057 3.813-3.057 3.813c4.031 0 3.753 4.976 3.753 4.976zm15.466-.328h-10.384c0 3.722 3.526 3.487 3.526 3.487 3.329 0 3.213-2.156 3.213-2.156h3.527c0 5.722-6.859 5.33-6.859 5.33-8.227 0-7.698-7.661-7.698-7.661s-.008-7.698 7.698-7.698c8.112.001 6.977 8.698 6.977 8.698z"/><path d="M-435.055 276.221c0-2.084-1.417-2.084-1.417-2.084H-442.306v4.471h5.472c.944 0 1.779-.304 1.779-2.387z"/></svg>';
} else {
behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M22.4 7.5h-5.6V6.1h5.6v1.4zm-9.3 5.7c.4.6.5 1.2.5 2s-.2 1.6-.6 2.2c-.3.4-.6.8-1 1.1-.4.3-1 .6-1.6.7-.6.1-1.3.2-2 .2H2.3V5.6H9c1.7 0 2.9.5 3.6 1.5.4.6.6 1.3.6 2.1s-.2 1.5-.6 2c-.2.3-.6.6-1.1.8.7.2 1.2.7 1.6 1.2zM5.5 11h2.9c.6 0 1.1-.1 1.5-.3.4-.2.6-.6.6-1.2s-.2-1.1-.7-1.3C9.3 8.1 8.7 8 8.1 8H5.5v3zm5.2 4c0-.7-.3-1.2-.9-1.5-.3-.2-.8-.2-1.4-.2h-3V17h2.9c.6 0 1.1-.1 1.4-.2.7-.3 1-.9 1-1.8zm13.8-2.2c.1.5.1 1.1.1 2h-7.2c0 1 .4 1.7 1 2.1.4.3.9.4 1.4.4.6 0 1.1-.1 1.4-.5.2-.2.4-.4.5-.7h2.6c-.1.6-.4 1.2-1 1.8-.9 1-2.1 1.4-3.7 1.4-1.3 0-2.5-.4-3.5-1.2-1-.8-1.5-2.1-1.5-4 0-1.7.5-3 1.4-4 .9-.9 2.1-1.4 3.5-1.4.9 0 1.6.2 2.3.5.7.3 1.3.8 1.7 1.5.6.6.8 1.3 1 2.1zm-2.7.2c0-.7-.3-1.2-.7-1.6-.4-.4-.9-.5-1.5-.5-.7 0-1.2.2-1.5.6-.4.4-.6.9-.7 1.5h4.4z"/></svg>';
}
behance += '</a>';
behance += '</div>';
var vimeo = '';
vimeo += '<div class="t-review-social-links\_\_item">';
vimeo += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 256.971c13.267 0 24.023 10.755 24.023 24.023s-10.755 24.023-24.023 24.023-24.023-10.755-24.023-24.023 10.756-24.023 24.023-24.023zm-12.262 19.146l.996 1.306s2.054-1.619 2.739-.81c.685.81 3.299 10.584 4.171 12.387.761 1.581 2.862 3.672 5.166 2.179 2.302-1.493 9.959-8.03 11.329-15.749 1.369-7.717-9.213-6.1-10.335.623 2.802-1.682 4.297.683 2.863 3.362-1.431 2.676-2.739 4.421-3.424 4.421-.683 0-1.209-1.791-1.992-4.92-.81-3.236-.804-9.064-4.17-8.403-3.171.623-7.343 5.604-7.343 5.604z"/></svg>';
} else {
vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M2.9 16.5l1.6 2s3.2-2.5 4.3-1.3c1.1 1.3 5.2 16.5 6.5 19.3 1.2 2.5 4.5 5.7 8.1 3.4S39 27.4 41.1 15.3s-14.4-9.5-16.1 1c4.4-2.6 6.7 1.1 4.5 5.3s-4.3 6.9-5.3 6.9c-1.1 0-1.9-2.8-3.1-7.7-1.3-5.1-1.3-14.2-6.5-13.1-5.2 1-11.7 8.8-11.7 8.8z"/></svg>';
}
vimeo += '</a>';
vimeo += '</div>';
var youtube = '';
youtube += '<div class="t-review-social-links\_\_item">';
youtube += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 257.013c13.248 0 23.987 10.74 23.987 23.987s-10.74 23.987-23.987 23.987-23.987-10.74-23.987-23.987 10.739-23.987 23.987-23.987zm11.815 18.08c-.25-1.337-1.363-2.335-2.642-2.458-3.054-.196-6.119-.355-9.178-.357-3.059-.002-6.113.154-9.167.347-1.284.124-2.397 1.117-2.646 2.459a40.163 40.163 0 0 0 0 11.672c.249 1.342 1.362 2.454 2.646 2.577 3.055.193 6.107.39 9.167.39 3.058 0 6.126-.172 9.178-.37 1.279-.124 2.392-1.269 2.642-2.606a39.769 39.769 0 0 0 0-11.654zm-14.591 9.342v-7.115l6.627 3.558-6.627 3.557z"/></svg>';
} else {
youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M43.9 15.3c-.4-3.1-2.2-5-5.3-5.3-3.6-.3-11.4-.5-15-.5-7.3 0-10.6.2-14.1.5-3.3.3-4.8 1.8-5.4 4.9-.4 2.1-.6 4.1-.6 8.9 0 4.3.2 6.9.5 9.2.4 3.1 2.5 4.8 5.7 5.1 3.6.3 10.9.5 14.4.5s11.2-.2 14.7-.6c3.1-.4 4.6-2 5.1-5.1 0 0 .5-3.3.5-9.1 0-3.3-.2-6.4-.5-8.5zM19.7 29.8V18l11.2 5.8-11.2 6z"/></svg>';
}
youtube += '</a>';
youtube += '</div>';
var instagram = '';
instagram += '<div class="t-review-social-links\_\_item">';
instagram += ' <a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15 11.014a3.986 3.986 0 1 0 .001 7.971A3.986 3.986 0 0 0 15 11.014zm0 6.592A2.604 2.604 0 0 1 12.393 15 2.604 2.604 0 0 1 15 12.394 2.614 2.614 0 0 1 17.607 15 2.604 2.604 0 0 1 15 17.606zM19.385 9.556a.915.915 0 0 0-.92.921c0 .512.407.919.92.919a.914.914 0 0 0 .921-.919.916.916 0 0 0-.921-.921z"/><path d="M15.002.15C6.798.15.149 6.797.149 15c0 8.201 6.649 14.85 14.853 14.85 8.199 0 14.85-6.648 14.85-14.85 0-8.203-6.651-14.85-14.85-14.85zm7.664 18.115c0 2.423-1.979 4.401-4.416 4.401h-6.5c-2.438 0-4.417-1.979-4.417-4.386v-6.546c0-2.422 1.978-4.4 4.417-4.4h6.5c2.438 0 4.416 1.978 4.416 4.4v6.531z"/></svg>';
} else {
instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M16.396 3.312H8.604c-2.921 0-5.292 2.371-5.292 5.273v7.846c0 2.886 2.371 5.256 5.292 5.256h7.791c2.922 0 5.292-2.37 5.292-5.274V8.586c.001-2.903-2.37-5.274-5.291-5.274zM7.722 12.5a4.778 4.778 0 1 1 9.554 0 4.778 4.778 0 0 1-9.554 0zm10.034-4.318c-.615 0-1.104-.487-1.104-1.102s.488-1.103 1.104-1.103c.614 0 1.102.488 1.102 1.103s-.488 1.102-1.102 1.102z" /><path d="M12.5 9.376A3.12 3.12 0 0 0 9.376 12.5a3.12 3.12 0 0 0 3.124 3.124 3.12 3.12 0 0 0 3.124-3.124A3.133 3.133 0 0 0 12.5 9.376z"/></svg>';
}
instagram += '</a>';
instagram += '</div>';
var pinterest = '';
pinterest += '<div class="t-review-social-links\_\_item">';
pinterest += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-407 281c0 13.254-10.746 24-23.999 24-13.257 0-24.003-10.746-24.003-24 0-13.256 10.746-24 24.003-24 13.253 0 23.999 10.744 23.999 24zm-30.628 14.811c.027.205.29.254.409.1.17-.223 2.365-2.932 3.111-5.639.211-.768 1.212-4.738 1.212-4.738.599 1.145 2.349 2.148 4.21 2.148 5.539 0 9.297-5.049 9.297-11.809 0-5.111-4.329-9.873-10.909-9.873-8.186 0-12.314 5.871-12.314 10.766 0 2.963 1.122 5.6 3.527 6.582.395.162.749.006.863-.43.08-.303.268-1.065.353-1.385.114-.432.07-.582-.248-.959-.694-.818-1.138-1.879-1.138-3.381 0-4.353 3.259-8.252 8.484-8.252 4.627 0 7.169 2.828 7.169 6.603 0 4.969-2.198 9.162-5.461 9.162-1.804 0-3.153-1.49-2.722-3.32.518-2.182 1.522-4.537 1.522-6.113 0-1.41-.758-2.588-2.324-2.588-1.843 0-3.323 1.908-3.323 4.461 0 1.627.55 2.727.55 2.727l-2.217 9.391c-.657 2.787-.099 6.203-.051 6.547z"/></svg>';
} else {
pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M24.9 5.5c4.2 0 7.7 1.3 10.5 3.9s4.1 5.7 4.1 9.2c0 4.6-1.2 8.4-3.5 11.3-2.3 3-5.3 4.5-8.9 4.5-1.2 0-2.3-.3-3.4-.9s-1.8-1.3-2.2-2c-.9 3.5-1.4 5.6-1.6 6.3-.7 2.4-2 4.9-4.1 7.5-.2.2-.4.2-.5-.1-.5-3.5-.5-6.4.1-8.7l2.9-12.6c-.5-.9-.7-2.1-.7-3.6 0-1.7.4-3.1 1.3-4.2s1.9-1.7 3.2-1.7c1 0 1.8.3 2.3 1 .5.6.8 1.5.8 2.4 0 .6-.1 1.4-.3 2.3-.2.9-.5 1.9-.9 3.1s-.6 2.1-.8 2.8c-.3 1.2-.1 2.2.7 3.1.7.9 1.7 1.3 3 1.3 2.1 0 3.8-1.2 5.2-3.6 1.4-2.4 2-5.3 2-8.7 0-2.6-.8-4.7-2.5-6.3-1.7-1.6-4-2.4-7-2.4-3.4 0-6.1 1.1-8.2 3.2S13 17.4 13 20.4c0 1.8.5 3.3 1.5 4.5.3.4.4.8.3 1.2 0 .1-.1.3-.2.6-.1.4-.1.6-.2.7 0 .1-.1.4-.2.6-.1.3-.3.4-.4.4h-.6c-3.1-1.3-4.7-4.2-4.7-8.7 0-3.6 1.5-6.9 4.4-9.9s7-4.3 12-4.3z"/></svg>';
}
pinterest += '</a>';
pinterest += '</div>';
var linkedin = '';
linkedin += '<div class="t-review-social-links\_\_item">';
linkedin += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-615 1477 48 48" fill="' + fill + '"><path d="M-566.999 1501c0 13.256-10.746 24-24 24-13.256 0-24.002-10.744-24.002-24 0-13.254 10.746-24 24.002-24 13.254 0 24 10.746 24 24zm-38.507 13.975h6.22v-20.004h-6.22v20.004zm3.11-22.739a3.606 3.606 0 0 0 0-7.211 3.603 3.603 0 0 0-3.604 3.605 3.604 3.604 0 0 0 3.604 3.606zm26.396 11.766c0-5.387-1.163-9.529-7.454-9.529-3.023 0-5.054 1.658-5.884 3.231h-.085v-2.733h-5.964v20.004h6.216v-9.896c0-2.609.493-5.137 3.729-5.137 3.186 0 3.232 2.984 3.232 5.305v9.729h6.21v-10.974z"/></svg>';
} else {
linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M42.3 23.1v13.5h-7.9V24c0-3.2-1.1-5.3-4-5.3-2.2 0-3.5 1.5-4 2.9-.2.5-.3 1.2-.3 1.9v13.2h-7.9s.1-21.4 0-23.6h7.9v3.3s0 .1-.1.1h.1v-.1c1-1.6 2.9-3.9 7.1-3.9 5.2-.1 9.1 3.3 9.1 10.6zM10.1 1.6c-2.7 0-4.4 1.8-4.4 4.1S7.4 9.8 10 9.8h.1c2.7 0 4.4-1.8 4.4-4.1s-1.7-4.1-4.4-4.1zm-3.9 35H14V13H6.2v23.6z"/></svg>';
}
linkedin += '</a>';
linkedin += '</div>';
var soundcloud = '';
soundcloud += '<div class="t-review-social-links\_\_item">';
soundcloud += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><defs><path id="a" d="M0 0h48v48H0V0z"/></defs><g fill-rule="evenodd"><path d="M38.206 22.171c-.635 0-1.241.129-1.793.36-.369-4.177-3.871-7.453-8.144-7.453a8.28 8.28 0 0 0-2.965.553c-.35.136-.442.275-.446.546v14.709a.545.545 0 0 0 .5.531c.013.002 12.848 0 12.848 0 2.56 0 4.634-2.051 4.634-4.611a4.634 4.634 0 0 0-4.634-4.635zM24.17 16.237a.5.5 0 0 0-.582.043.517.517 0 0 0-.189.392v.053l-.21 10.388.107 1.92.103 1.869a.514.514 0 0 0 .51.505.515.515 0 0 0 .51-.509v.004l.228-3.79-.227-10.44a.517.517 0 0 0-.25-.435zm-1.364 14.72v-.001.001-.002.002zm-.215-13.813a.47.47 0 0 0-.264-.081.486.486 0 0 0-.478.477l-.001.09-.18 9.48.181 3.847.001.016a.48.48 0 0 0 .477.458c.246 0 .248-.054.335-.14a.486.486 0 0 0 .144-.336l.02-.38.181-3.463-.201-9.573a.487.487 0 0 0-.215-.395zm-1.853 1.479a.447.447 0 0 0-.446.444l-.2 8.044.2 3.87c.005.465.2.442.446.442.245 0 .44.023.446-.444v.003l.223-3.87-.223-8.046a.447.447 0 0 0-.446-.443zm-1.577-.273a.416.416 0 0 0-.414.412l-.219 8.349.219 3.895c.005.228.187.41.414.41a.416.416 0 0 0 .413-.412v.002l.246-3.895-.246-8.35a.416.416 0 0 0-.413-.411zm-1.184 12.693v-.002.002zm0-12.5a.385.385 0 0 0-.382-.38.384.384 0 0 0-.381.38l-.238 8.567.238 3.932c.006.21.173.377.381.377a.385.385 0 0 0 .382-.378l.268-3.931-.268-8.568zm-1.935-.069a.354.354 0 0 0-.35.347l-.256 8.288.257 3.957c.006.193.16.346.35.346a.354.354 0 0 0 .349-.347v.002l.29-3.958-.29-8.288a.355.355 0 0 0-.35-.347zm-1.564.691a.322.322 0 0 0-.318.315l-.275 7.65.276 3.998a.321.321 0 0 0 .317.313c.17 0 .31-.138.317-.315v.002l.312-3.999-.312-7.65a.323.323 0 0 0-.317-.314zM12.974 20.6a.29.29 0 0 0-.285.282l-.295 6.226.295 4.023a.29.29 0 0 0 .285.281.292.292 0 0 0 .285-.282v.001l.333-4.023-.333-6.226a.292.292 0 0 0-.285-.282zm-1.264 2.678a.258.258 0 0 0-.253-.248.257.257 0 0 0-.253.25l-.314 3.826.314 4.024c.008.142.117.25.253.25a.259.259 0 0 0 .253-.25l.356-4.024-.356-3.828zm0 7.851v.001zm-1.757-8.366a.226.226 0 0 0-.221.217l-.333 4.126.333 3.99c.009.124.104.217.22.217s.21-.093.221-.216l.4-3.991-.4-4.126c-.01-.123-.105-.217-.22-.217zm-1.493.142c-.1 0-.179.078-.189.185l-.351 4.015.351 3.868c.01.108.09.185.19.185.097 0 .176-.077.188-.184l.4-3.869-.4-4.015c-.012-.107-.091-.185-.189-.185zm-2.873 1.96c-.079 0-.14.06-.151.147l-.276 2.094.276 2.056c.01.086.072.147.15.147s.14-.06.152-.147l.326-2.056-.326-2.095c-.013-.086-.074-.145-.151-.145zM6.98 23.57c-.08 0-.146.064-.157.152l-.25 3.385.25 3.308c.011.088.077.152.157.152s.144-.062.156-.152l.422-3.308-.422-3.385c-.012-.09-.077-.152-.156-.152zM48 24c0 13.255-10.745 24-24 24C10.757 48 0 37.255 0 24 0 10.757 10.757 0 24 0c13.255 0 24 10.757 24 24z"/></g></svg>';
} else {
soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M1.6 24.3c-.2 0-.3.1-.3.3l-.5 6.2.5 6c0 .2.2.3.3.3.2 0 .3-.1.3-.3l.6-6-.6-6.2c0-.2-.1-.3-.3-.3zm3.3 12.6zm0-11.8c0-.2-.2-.4-.4-.4s-.4.2-.4.4l-.5 5.8.5 6.1c0 .2.2.4.4.4s.4-.2.4-.4l.5-6.1-.5-5.8zm2.7-6.2c-.3 0-.5.2-.5.5l-.4 11.5.4 6c0 .3.2.5.5.5s.5-.2.5-.5l.5-6-.5-11.6c-.1-.2-.3-.4-.5-.4zm3.8-1c0-.3-.3-.6-.6-.6s-.6.3-.6.6l-.4 13 .4 5.9c0 .3.3.6.6.6s.6-.3.6-.6l.4-5.9-.4-13zm2.7.1c-.4 0-.7.3-.7.7l-.3 12.2.3 5.9c0 .4.3.7.7.7.4 0 .7-.3.7-.7l.3-5.9-.3-12.2c0-.4-.3-.7-.7-.7zm3.7-3.6c-.1-.1-.3-.1-.4-.1-.2 0-.4.1-.5.2-.2.1-.3.4-.3.6v.1l-.3 15.7.2 2.9.2 2.8c0 .4.4.8.8.8s.8-.3.8-.8l.3-5.7-.3-15.8c-.1-.3-.3-.5-.5-.7zm22.4 9c-1 0-1.9.2-2.7.5-.6-6.3-5.9-11.3-12.3-11.3-1.6 0-3.1.3-4.5.8-.5.2-.7.4-.7.8v22.2c0 .4.3.8.8.8h19.4c3.9 0 7-3.1 7-7 0-3.7-3.1-6.8-7-6.8z"/></svg>';
}
soundcloud += '</a>';
soundcloud +=' </div>';
var telegram = '';
telegram += '<div class="t-review-social-links\_\_item">';
telegram += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 60 60" fill="' + fill + '"><path d="M30 0C13.4 0 0 13.4 0 30s13.4 30 30 30 30-13.4 30-30S46.6 0 30 0zm16.9 13.9l-6.7 31.5c-.1.6-.8.9-1.4.6l-10.3-6.9-5.5 5.2c-.5.4-1.2.2-1.4-.4L18 32.7l-9.5-3.9c-.7-.3-.7-1.5 0-1.8l37.1-14.1c.7-.2 1.4.3 1.3 1z"/><path d="M22.7 40.6l.6-5.8 16.8-16.3-20.2 13.3"/></svg>';
} else {
telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 60 60" fill="' + fill + '"><path d="M52.5 9L6.1 26.9c-.9.4-.9 1.8 0 2.3L18 34.1l4.4 14.1c.3.8 1.2 1 1.8.5l6.8-6.4L43.9 51c.7.4 1.6 0 1.7-.7l8.4-40c.2-.8-.7-1.6-1.5-1.3zm-28 27.7l-.7 7.3-3.6-11.2L45.5 16l-21 20.7z"/></svg>';
}
telegram += '</a>';
telegram += '</div>';
if (item.indexOf('facebook') != -1) {
socialWrapper.append(fb);
}
if (item.indexOf('twitter') != -1) {
socialWrapper.append(twi);
}
if (item.indexOf('vk.com') != -1) {
socialWrapper.append(vk);
}
if (item.indexOf('ok.ru') != -1) {
socialWrapper.append(ok);
}
if (item.indexOf('behance') != -1) {
socialWrapper.append(behance);
}
if (item.indexOf('vimeo') != -1) {
socialWrapper.append(vimeo);
}
if (item.indexOf('youtube') != -1) {
socialWrapper.append(youtube);
}
if (item.indexOf('instagram') != -1) {
socialWrapper.append(instagram);
}
if (item.indexOf('pinterest') != -1) {
socialWrapper.append(pinterest);
}
if (item.indexOf('linkedin') != -1) {
socialWrapper.append(linkedin);
}
if (item.indexOf('soundcloud') != -1) {
socialWrapper.append(soundcloud);
}
if (item.indexOf('telegram') != -1) {
socialWrapper.append(telegram);
}
}
$(document).ready(function() {
t\_reviews\_social\_init('262141654');
});
@media screen and (max-width: 640px){
.t525 .t-review-social-links\_\_wrapper {
-webkit-box-pack: center;
-ms-flex-pack: center;
justify-content: center;
}
}
### Что может непроверенный конфиг
На второй неделе работы мне поручили проверить релиз админки, откуда фронтенд-демон для рекомендаций забирает настройки, на основании чего система определяет, что будет показываться пользователям. Я проверила все задачи и написала в общий чат, что можно выкатываться.
Релиз выкатили, а мы все пошли на daily scrum meeting, где по алертам из Grafana узнали, что пользователям перестала показываться реклама. Мы откатились к прошлой версии админки и стали разбираться. Так как я работала недавно, то не знала, что у админки есть конфиг, который она выгружает в наш фронтенд-демон для рекомендаций. А именно в тот раз конфиг админки отгружал невалидные поля, которые не смог прочитать демон.
### Полная проверка по готовым регламентам
Чтобы такого не повторилось, мы:
* обязательно после проверки всех задач в релизе проверяем, что конфиг не поломается;
* написали регламент проверки конфигураций;
* обязательно после проверки всех задач в релизе проверяем совместимость текущей версии фронтенд-демона для рекомендаций и новой версии админки;
* написали регламент проверки совместимости текущей версии фронтенд-демона для рекомендаций и новой версии админки;
* если у нас готовится новый релиз фронтенд-демона, проверяем релиз админки сразу с двумя версиями;
* попросили разработчиков написать регламент по выгрузке полей и их содержанию;
попросили разработчиков тщательнее покрывать код unit-тестами.
Новые сотрудники в моей команде должны иметь общее представление о составных частях проекта, а также детальное представление о тех частях, которые им будет необходимо тестировать. Для этого в confluence собрана вся информация и инструкции, которые мы постоянно обновляем и дополняем. Мы регулярно проводим встречи, где делимся друг с другом опытом. В среднем новый сотрудник полностью погружается в работу за три месяца.
Растущие объёмы кода
--------------------
Привет, Хабр. Меня зовут Станислав Барбуков, и я работаю руководителем отдела тестирования в [Pixonic](https://u.habr.com/mrg_post_pix). Я сам подбираю кадры для своей команды, обучаю их и оптимизирую тестирование в нашей компании.
.t-review-social-links {
line-height: 0px;
}
.t-review-social-links\_\_wrapper {
display: -webkit-box;
display: -ms-flexbox;
display: flex;
-webkit-box-align: center;
-ms-flex-align: center;
align-items: center;
-ms-flex-wrap: wrap;
flex-wrap: wrap;
width: auto;
}
.t-review-social-links {
margin-top: 15px;
}
.t-review-social-links\_\_item {
padding: 0px 4px;
}
.t-review-social-links\_\_item svg {
width: 20px;
height: 20px;
}
.t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg {
width: 23px;
height: 23px;
}
.t-review-social-links\_\_item:first-child {
padding-left: 0px;
}
@media screen and (max-width: 960px) {
.t-review-social-links\_\_item {
margin-bottom: 3px;
}
}
@media screen and (max-width: 640px) {
.t-review-social-links {
margin-top: 13px;
}
.t-review-social-links\_\_item {
padding: 0px 3px;
}
.t-review-social-links\_\_item svg {
width: 17px;
height: 17px;
}
.t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg {
width: 20px;
height: 20px;
}
}
function t\_reviews\_social\_init(recid){
var rec = $('#rec' + recid);
var social = rec.find('.t-review-social-links');
if (social !== 'undefined' && social.length > 0) {
social.each(function() {
var $this = $(this);
var socialAttr = $this.attr('data-social-links');
var socialWrapper = $this.find('.t-review-social-links\_\_wrapper');
var links;
$this.removeAttr('data-social-links');
if (typeof socialAttr !== 'undefined') {
links = socialAttr.split(',');
links.forEach(function(item) {
t\_reviews\_social\_add\_item(item, socialWrapper);
});
}
});
}
}
function t\_reviews\_social\_add\_item(item, socialWrapper) {
var fill = socialWrapper.attr('data-social-color') || '#000000';
var fb = '';
fb = '<div class="t-review-social-links\_\_item">';
fb += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
fb += '<svg class="t-review-social-links\_\_svg" version="1.1" id="Layer\_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="30px" height="30px" viewBox="0 0 48 48" enable-background="new 0 0 48 48" xml:space="preserve" fill="' + fill + '"><desc>Facebook</desc><path d="M47.761,24c0,13.121-10.638,23.76-23.758,23.76C10.877,47.76,0.239,37.121,0.239,24c0-13.124,10.638-23.76,23.764-23.76C37.123,0.24,47.761,10.876,47.761,24 M20.033,38.85H26.2V24.01h4.163l0.539-5.242H26.2v-3.083c0-1.156,0.769-1.427,1.308-1.427h3.318V9.168L26.258,9.15c-5.072,0-6.225,3.796-6.225,6.224v3.394H17.1v5.242h2.933V38.85z"></path></svg>';
} else {
fb += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M21.1 7.8C22.5 6.5 24.5 6 26.4 6h6v6.3h-3.9c-.8-.1-1.6.6-1.8 1.4v4.2h5.7c-.1 2-.4 4.1-.7 6.1h-5v18h-7.4V24h-3.6v-6h3.6v-5.9c.1-1.7.7-3.3 1.8-4.3z"/></svg>';
}
fb += '</a>';
fb += '</div>';
var twi = '';
twi += '<div class="t-review-social-links\_\_item">';
twi += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.762 24c0 13.121-10.639 23.76-23.761 23.76S.24 37.121.24 24C.24 10.876 10.879.24 24.001.24S47.762 10.876 47.762 24m-9.731-11.625a12.148 12.148 0 0 1-3.87 1.481 6.08 6.08 0 0 0-4.455-1.926 6.095 6.095 0 0 0-6.093 6.095c0 .478.054.941.156 1.388a17.302 17.302 0 0 1-12.559-6.367 6.066 6.066 0 0 0-.825 3.064 6.088 6.088 0 0 0 2.711 5.07 6.075 6.075 0 0 1-2.761-.762v.077c0 2.951 2.1 5.414 4.889 5.975a6.079 6.079 0 0 1-2.752.106 6.104 6.104 0 0 0 5.692 4.232 12.226 12.226 0 0 1-7.567 2.607c-.492 0-.977-.027-1.453-.084a17.241 17.241 0 0 0 9.34 2.736c11.209 0 17.337-9.283 17.337-17.337 0-.263-.004-.527-.017-.789a12.358 12.358 0 0 0 3.039-3.152 12.138 12.138 0 0 1-3.498.958 6.089 6.089 0 0 0 2.686-3.372"/></svg>';
} else {
twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.8 12.7c-1.3.6-2.8 1-4.2 1.1 1.5-1 2.6-2.3 3.2-4-1.5.8-2.9 1.5-4.7 1.8-1.3-1.5-3.2-2.3-5.3-2.3-4 0-7.3 3.2-7.3 7.3 0 .6 0 1.1.2 1.6-6-.3-11.3-3.2-15.1-7.6-.6 1.1-1 2.3-1 3.7 0 2.6 1.3 4.7 3.2 6-1.1 0-2.3-.3-3.2-1v.2c0 3.6 2.4 6.5 5.8 7.1-.6.2-1.3.3-1.9.3-.5 0-1 0-1.3-.2 1 2.9 3.6 5 6.8 5-2.4 1.9-5.7 3.1-9.1 3.1-.6 0-1.1 0-1.8-.2 3.2 2.1 7 3.2 11.2 3.2 13.4 0 20.7-11 20.7-20.7v-1c1.7-.7 2.8-2 3.8-3.4z"/></svg>';
}
twi += '</a>';
twi += '</div>';
var vk = '';
vk += '<div class="t-review-social-links\_\_item">';
vk += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.761 24c0 13.121-10.639 23.76-23.76 23.76C10.878 47.76.239 37.121.239 24 .239 10.877 10.878.24 24.001.24c13.121 0 23.76 10.637 23.76 23.76m-12.502 4.999c-2.621-2.433-2.271-2.041.89-6.25 1.923-2.562 2.696-4.126 2.45-4.796-.227-.639-1.64-.469-1.64-.469l-4.71.029s-.351-.048-.609.106c-.249.151-.414.505-.414.505s-.742 1.982-1.734 3.669c-2.094 3.559-2.935 3.747-3.277 3.524-.796-.516-.597-2.068-.597-3.171 0-3.449.522-4.887-1.02-5.259-.511-.124-.887-.205-2.195-.219-1.678-.016-3.101.007-3.904.398-.536.263-.949.847-.697.88.31.041 1.016.192 1.388.699.484.656.464 2.131.464 2.131s.282 4.056-.646 4.561c-.632.347-1.503-.36-3.37-3.588-.958-1.652-1.68-3.481-1.68-3.481s-.14-.344-.392-.527c-.299-.222-.722-.298-.722-.298l-4.469.018s-.674-.003-.919.289c-.219.259-.018.752-.018.752s3.499 8.104 7.573 12.23c3.638 3.784 7.764 3.36 7.764 3.36h1.867s.566.113.854-.189c.265-.288.256-.646.256-.646s-.034-2.512 1.129-2.883c1.15-.36 2.624 2.429 4.188 3.497 1.182.812 2.079.633 2.079.633l4.181-.056s2.186-.136 1.149-1.858c-.197-.139-.715-1.269-3.219-3.591"/></svg>';
} else {
vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.2 22.2c.6-.8 1.1-1.5 1.5-2 2.7-3.5 3.8-5.8 3.5-6.8l-.2-.2c-.1-.1-.3-.3-.7-.4-.4-.1-.9-.1-1.5-.1h-7.2c-.2 0-.3 0-.3.1 0 0-.1 0-.1.1v.1c-.1 0-.2.1-.3.2-.1.1-.2.2-.2.4-.7 1.9-1.5 3.6-2.5 5.2-.6 1-1.1 1.8-1.6 2.5s-.9 1.2-1.2 1.5c-.3.3-.6.6-.9.8-.2.3-.4.4-.5.4-.1 0-.3-.1-.4-.1-.2-.1-.4-.3-.5-.6-.1-.2-.2-.5-.3-.9 0-.4-.1-.7-.1-.9v-4c0-.7 0-1.2.1-1.6v-1.3c0-.4 0-.8-.1-1.1-.1-.3-.1-.5-.2-.7-.1-.2-.3-.4-.5-.6-.2-.1-.5-.2-.8-.3-.8-.2-1.9-.3-3.1-.3-2.9 0-4.7.2-5.5.6-.3.2-.6.4-.9.7-.3.3-.3.5-.1.6.9.1 1.6.5 2 1l.1.3c.1.2.2.6.3 1.1.1.5.2 1.1.2 1.7.1 1.1.1 2.1 0 2.9-.1.8-.1 1.4-.2 1.9-.1.4-.2.8-.3 1.1-.1.3-.2.4-.3.5 0 .1-.1.1-.1.1-.1-.1-.4-.1-.6-.1-.2 0-.5-.1-.8-.3-.3-.2-.6-.5-1-.9-.3-.4-.7-.9-1.1-1.6-.4-.7-.8-1.5-1.3-2.4l-.4-.7c-.2-.4-.5-1.1-.9-1.9-.4-.8-.8-1.6-1.1-2.4-.1-.3-.3-.6-.6-.7l-.1-.1c-.1-.1-.2-.1-.4-.2s-.3-.1-.5-.2H3.2c-.6 0-1.1.1-1.3.4l-.1.1c0 .1-.1.2-.1.4s0 .4.1.6c.9 2.2 1.9 4.3 3 6.3s2 3.6 2.8 4.9c.8 1.2 1.6 2.4 2.4 3.5.8 1.1 1.4 1.8 1.7 2.1.3.3.5.5.6.7l.6.6c.4.4.9.8 1.6 1.3.7.5 1.5 1 2.4 1.5.9.5 1.9.9 3 1.2 1.2.3 2.3.4 3.4.4H26c.5 0 .9-.2 1.2-.5l.1-.1c.1-.1.1-.2.2-.4s.1-.4.1-.6c0-.7 0-1.3.1-1.8s.2-.9.4-1.2c.1-.3.3-.5.5-.7.2-.2.3-.3.4-.3.1 0 .1-.1.2-.1.4-.1.8 0 1.3.4s1 .8 1.4 1.3c.4.5 1 1.1 1.6 1.8.6.7 1.2 1.2 1.6 1.5l.5.3c.3.2.7.4 1.2.5.5.2.9.2 1.3.1l5.9-.1c.6 0 1-.1 1.4-.3.3-.2.5-.4.6-.6.1-.2.1-.5 0-.8-.1-.3-.1-.5-.2-.6-.1-.1-.1-.2-.2-.3-.8-1.4-2.2-3.1-4.4-5.1-1-.9-1.6-1.6-1.9-1.9-.5-.6-.6-1.2-.3-1.9.3-.5 1-1.5 2.2-3z"/></svg>';
}
vk += '</a>';
vk += '</div>';
var ok = '';
ok += '<div class="t-review-social-links\_\_item">';
ok += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15.001 29.997C6.715 29.997 0 23.28 0 14.997 0 6.714 6.715 0 15.001 0 23.282-.001 30 6.713 30 14.998c0 8.283-6.716 14.999-14.998 14.999zM15 9.163c.986 0 1.787.803 1.787 1.787 0 .987-.801 1.788-1.787 1.788a1.788 1.788 0 0 1 0-3.574zm4.317 1.787a4.322 4.322 0 0 0-4.317-4.319 4.323 4.323 0 0 0-4.319 4.32A4.322 4.322 0 0 0 15 15.266a4.32 4.32 0 0 0 4.316-4.317zm-2.57 7.84a8.126 8.126 0 0 0 2.507-1.038 1.266 1.266 0 0 0-1.347-2.143 5.482 5.482 0 0 1-5.816 0 1.265 1.265 0 0 0-1.348 2.143c.78.49 1.628.838 2.507 1.038l-2.414 2.414a1.267 1.267 0 0 0 .894 2.16c.324 0 .649-.125.895-.37l2.371-2.373 2.373 2.373a1.265 1.265 0 0 0 1.788-1.789l-2.41-2.415z"/></svg>';
} else {
ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M12.498 6.2a1.932 1.932 0 0 0-1.929 1.93 1.932 1.932 0 0 0 3.861 0 1.932 1.932 0 0 0-1.932-1.93zm0 6.592a4.668 4.668 0 0 1-4.66-4.662 4.665 4.665 0 0 1 4.66-4.663 4.666 4.666 0 0 1 4.664 4.663 4.669 4.669 0 0 1-4.664 4.662zm-1.884 3.801a8.75 8.75 0 0 1-2.708-1.12 1.367 1.367 0 1 1 1.455-2.312 5.925 5.925 0 0 0 6.276 0 1.367 1.367 0 1 1 1.456 2.311c-.832.522-1.749.9-2.707 1.12l2.606 2.608a1.367 1.367 0 0 1-1.933 1.931L12.5 18.569l-2.561 2.562a1.368 1.368 0 0 1-1.934-1.934l2.609-2.604z"/></svg>';
}
ok += '</a>';
ok += '</div>';
var behance = '';
behance += '<div class="t-review-social-links\_\_item">';
behance += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-421.541 278.608c-3.095 0-3.526 3.09-3.526 3.09h6.581c0-.001.042-3.09-3.055-3.09zM-436.472 281.697h-5.834v5.356h5.165c.088 0 .219.002.374 0 .831-.02 2.406-.261 2.406-2.604-.001-2.78-2.111-2.752-2.111-2.752z"/><path d="M-430.984 257C-444.248 257-455 267.75-455 281.014c0 13.263 10.752 24.016 24.016 24.016 13.262 0 24.014-10.752 24.014-24.016-.001-13.263-10.754-24.014-24.014-24.014zm5.054 14.756h8.267v2.467h-8.267v-2.467zm-4.179 12.943c0 6.116-6.364 5.914-6.364 5.914h-10.428v-20.038h10.428c3.168 0 5.668 1.75 5.668 5.335s-3.057 3.813-3.057 3.813c4.031 0 3.753 4.976 3.753 4.976zm15.466-.328h-10.384c0 3.722 3.526 3.487 3.526 3.487 3.329 0 3.213-2.156 3.213-2.156h3.527c0 5.722-6.859 5.33-6.859 5.33-8.227 0-7.698-7.661-7.698-7.661s-.008-7.698 7.698-7.698c8.112.001 6.977 8.698 6.977 8.698z"/><path d="M-435.055 276.221c0-2.084-1.417-2.084-1.417-2.084H-442.306v4.471h5.472c.944 0 1.779-.304 1.779-2.387z"/></svg>';
} else {
behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M22.4 7.5h-5.6V6.1h5.6v1.4zm-9.3 5.7c.4.6.5 1.2.5 2s-.2 1.6-.6 2.2c-.3.4-.6.8-1 1.1-.4.3-1 .6-1.6.7-.6.1-1.3.2-2 .2H2.3V5.6H9c1.7 0 2.9.5 3.6 1.5.4.6.6 1.3.6 2.1s-.2 1.5-.6 2c-.2.3-.6.6-1.1.8.7.2 1.2.7 1.6 1.2zM5.5 11h2.9c.6 0 1.1-.1 1.5-.3.4-.2.6-.6.6-1.2s-.2-1.1-.7-1.3C9.3 8.1 8.7 8 8.1 8H5.5v3zm5.2 4c0-.7-.3-1.2-.9-1.5-.3-.2-.8-.2-1.4-.2h-3V17h2.9c.6 0 1.1-.1 1.4-.2.7-.3 1-.9 1-1.8zm13.8-2.2c.1.5.1 1.1.1 2h-7.2c0 1 .4 1.7 1 2.1.4.3.9.4 1.4.4.6 0 1.1-.1 1.4-.5.2-.2.4-.4.5-.7h2.6c-.1.6-.4 1.2-1 1.8-.9 1-2.1 1.4-3.7 1.4-1.3 0-2.5-.4-3.5-1.2-1-.8-1.5-2.1-1.5-4 0-1.7.5-3 1.4-4 .9-.9 2.1-1.4 3.5-1.4.9 0 1.6.2 2.3.5.7.3 1.3.8 1.7 1.5.6.6.8 1.3 1 2.1zm-2.7.2c0-.7-.3-1.2-.7-1.6-.4-.4-.9-.5-1.5-.5-.7 0-1.2.2-1.5.6-.4.4-.6.9-.7 1.5h4.4z"/></svg>';
}
behance += '</a>';
behance += '</div>';
var vimeo = '';
vimeo += '<div class="t-review-social-links\_\_item">';
vimeo += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 256.971c13.267 0 24.023 10.755 24.023 24.023s-10.755 24.023-24.023 24.023-24.023-10.755-24.023-24.023 10.756-24.023 24.023-24.023zm-12.262 19.146l.996 1.306s2.054-1.619 2.739-.81c.685.81 3.299 10.584 4.171 12.387.761 1.581 2.862 3.672 5.166 2.179 2.302-1.493 9.959-8.03 11.329-15.749 1.369-7.717-9.213-6.1-10.335.623 2.802-1.682 4.297.683 2.863 3.362-1.431 2.676-2.739 4.421-3.424 4.421-.683 0-1.209-1.791-1.992-4.92-.81-3.236-.804-9.064-4.17-8.403-3.171.623-7.343 5.604-7.343 5.604z"/></svg>';
} else {
vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M2.9 16.5l1.6 2s3.2-2.5 4.3-1.3c1.1 1.3 5.2 16.5 6.5 19.3 1.2 2.5 4.5 5.7 8.1 3.4S39 27.4 41.1 15.3s-14.4-9.5-16.1 1c4.4-2.6 6.7 1.1 4.5 5.3s-4.3 6.9-5.3 6.9c-1.1 0-1.9-2.8-3.1-7.7-1.3-5.1-1.3-14.2-6.5-13.1-5.2 1-11.7 8.8-11.7 8.8z"/></svg>';
}
vimeo += '</a>';
vimeo += '</div>';
var youtube = '';
youtube += '<div class="t-review-social-links\_\_item">';
youtube += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 257.013c13.248 0 23.987 10.74 23.987 23.987s-10.74 23.987-23.987 23.987-23.987-10.74-23.987-23.987 10.739-23.987 23.987-23.987zm11.815 18.08c-.25-1.337-1.363-2.335-2.642-2.458-3.054-.196-6.119-.355-9.178-.357-3.059-.002-6.113.154-9.167.347-1.284.124-2.397 1.117-2.646 2.459a40.163 40.163 0 0 0 0 11.672c.249 1.342 1.362 2.454 2.646 2.577 3.055.193 6.107.39 9.167.39 3.058 0 6.126-.172 9.178-.37 1.279-.124 2.392-1.269 2.642-2.606a39.769 39.769 0 0 0 0-11.654zm-14.591 9.342v-7.115l6.627 3.558-6.627 3.557z"/></svg>';
} else {
youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M43.9 15.3c-.4-3.1-2.2-5-5.3-5.3-3.6-.3-11.4-.5-15-.5-7.3 0-10.6.2-14.1.5-3.3.3-4.8 1.8-5.4 4.9-.4 2.1-.6 4.1-.6 8.9 0 4.3.2 6.9.5 9.2.4 3.1 2.5 4.8 5.7 5.1 3.6.3 10.9.5 14.4.5s11.2-.2 14.7-.6c3.1-.4 4.6-2 5.1-5.1 0 0 .5-3.3.5-9.1 0-3.3-.2-6.4-.5-8.5zM19.7 29.8V18l11.2 5.8-11.2 6z"/></svg>';
}
youtube += '</a>';
youtube += '</div>';
var instagram = '';
instagram += '<div class="t-review-social-links\_\_item">';
instagram += ' <a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15 11.014a3.986 3.986 0 1 0 .001 7.971A3.986 3.986 0 0 0 15 11.014zm0 6.592A2.604 2.604 0 0 1 12.393 15 2.604 2.604 0 0 1 15 12.394 2.614 2.614 0 0 1 17.607 15 2.604 2.604 0 0 1 15 17.606zM19.385 9.556a.915.915 0 0 0-.92.921c0 .512.407.919.92.919a.914.914 0 0 0 .921-.919.916.916 0 0 0-.921-.921z"/><path d="M15.002.15C6.798.15.149 6.797.149 15c0 8.201 6.649 14.85 14.853 14.85 8.199 0 14.85-6.648 14.85-14.85 0-8.203-6.651-14.85-14.85-14.85zm7.664 18.115c0 2.423-1.979 4.401-4.416 4.401h-6.5c-2.438 0-4.417-1.979-4.417-4.386v-6.546c0-2.422 1.978-4.4 4.417-4.4h6.5c2.438 0 4.416 1.978 4.416 4.4v6.531z"/></svg>';
} else {
instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M16.396 3.312H8.604c-2.921 0-5.292 2.371-5.292 5.273v7.846c0 2.886 2.371 5.256 5.292 5.256h7.791c2.922 0 5.292-2.37 5.292-5.274V8.586c.001-2.903-2.37-5.274-5.291-5.274zM7.722 12.5a4.778 4.778 0 1 1 9.554 0 4.778 4.778 0 0 1-9.554 0zm10.034-4.318c-.615 0-1.104-.487-1.104-1.102s.488-1.103 1.104-1.103c.614 0 1.102.488 1.102 1.103s-.488 1.102-1.102 1.102z" /><path d="M12.5 9.376A3.12 3.12 0 0 0 9.376 12.5a3.12 3.12 0 0 0 3.124 3.124 3.12 3.12 0 0 0 3.124-3.124A3.133 3.133 0 0 0 12.5 9.376z"/></svg>';
}
instagram += '</a>';
instagram += '</div>';
var pinterest = '';
pinterest += '<div class="t-review-social-links\_\_item">';
pinterest += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-407 281c0 13.254-10.746 24-23.999 24-13.257 0-24.003-10.746-24.003-24 0-13.256 10.746-24 24.003-24 13.253 0 23.999 10.744 23.999 24zm-30.628 14.811c.027.205.29.254.409.1.17-.223 2.365-2.932 3.111-5.639.211-.768 1.212-4.738 1.212-4.738.599 1.145 2.349 2.148 4.21 2.148 5.539 0 9.297-5.049 9.297-11.809 0-5.111-4.329-9.873-10.909-9.873-8.186 0-12.314 5.871-12.314 10.766 0 2.963 1.122 5.6 3.527 6.582.395.162.749.006.863-.43.08-.303.268-1.065.353-1.385.114-.432.07-.582-.248-.959-.694-.818-1.138-1.879-1.138-3.381 0-4.353 3.259-8.252 8.484-8.252 4.627 0 7.169 2.828 7.169 6.603 0 4.969-2.198 9.162-5.461 9.162-1.804 0-3.153-1.49-2.722-3.32.518-2.182 1.522-4.537 1.522-6.113 0-1.41-.758-2.588-2.324-2.588-1.843 0-3.323 1.908-3.323 4.461 0 1.627.55 2.727.55 2.727l-2.217 9.391c-.657 2.787-.099 6.203-.051 6.547z"/></svg>';
} else {
pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M24.9 5.5c4.2 0 7.7 1.3 10.5 3.9s4.1 5.7 4.1 9.2c0 4.6-1.2 8.4-3.5 11.3-2.3 3-5.3 4.5-8.9 4.5-1.2 0-2.3-.3-3.4-.9s-1.8-1.3-2.2-2c-.9 3.5-1.4 5.6-1.6 6.3-.7 2.4-2 4.9-4.1 7.5-.2.2-.4.2-.5-.1-.5-3.5-.5-6.4.1-8.7l2.9-12.6c-.5-.9-.7-2.1-.7-3.6 0-1.7.4-3.1 1.3-4.2s1.9-1.7 3.2-1.7c1 0 1.8.3 2.3 1 .5.6.8 1.5.8 2.4 0 .6-.1 1.4-.3 2.3-.2.9-.5 1.9-.9 3.1s-.6 2.1-.8 2.8c-.3 1.2-.1 2.2.7 3.1.7.9 1.7 1.3 3 1.3 2.1 0 3.8-1.2 5.2-3.6 1.4-2.4 2-5.3 2-8.7 0-2.6-.8-4.7-2.5-6.3-1.7-1.6-4-2.4-7-2.4-3.4 0-6.1 1.1-8.2 3.2S13 17.4 13 20.4c0 1.8.5 3.3 1.5 4.5.3.4.4.8.3 1.2 0 .1-.1.3-.2.6-.1.4-.1.6-.2.7 0 .1-.1.4-.2.6-.1.3-.3.4-.4.4h-.6c-3.1-1.3-4.7-4.2-4.7-8.7 0-3.6 1.5-6.9 4.4-9.9s7-4.3 12-4.3z"/></svg>';
}
pinterest += '</a>';
pinterest += '</div>';
var linkedin = '';
linkedin += '<div class="t-review-social-links\_\_item">';
linkedin += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-615 1477 48 48" fill="' + fill + '"><path d="M-566.999 1501c0 13.256-10.746 24-24 24-13.256 0-24.002-10.744-24.002-24 0-13.254 10.746-24 24.002-24 13.254 0 24 10.746 24 24zm-38.507 13.975h6.22v-20.004h-6.22v20.004zm3.11-22.739a3.606 3.606 0 0 0 0-7.211 3.603 3.603 0 0 0-3.604 3.605 3.604 3.604 0 0 0 3.604 3.606zm26.396 11.766c0-5.387-1.163-9.529-7.454-9.529-3.023 0-5.054 1.658-5.884 3.231h-.085v-2.733h-5.964v20.004h6.216v-9.896c0-2.609.493-5.137 3.729-5.137 3.186 0 3.232 2.984 3.232 5.305v9.729h6.21v-10.974z"/></svg>';
} else {
linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M42.3 23.1v13.5h-7.9V24c0-3.2-1.1-5.3-4-5.3-2.2 0-3.5 1.5-4 2.9-.2.5-.3 1.2-.3 1.9v13.2h-7.9s.1-21.4 0-23.6h7.9v3.3s0 .1-.1.1h.1v-.1c1-1.6 2.9-3.9 7.1-3.9 5.2-.1 9.1 3.3 9.1 10.6zM10.1 1.6c-2.7 0-4.4 1.8-4.4 4.1S7.4 9.8 10 9.8h.1c2.7 0 4.4-1.8 4.4-4.1s-1.7-4.1-4.4-4.1zm-3.9 35H14V13H6.2v23.6z"/></svg>';
}
linkedin += '</a>';
linkedin += '</div>';
var soundcloud = '';
soundcloud += '<div class="t-review-social-links\_\_item">';
soundcloud += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><defs><path id="a" d="M0 0h48v48H0V0z"/></defs><g fill-rule="evenodd"><path d="M38.206 22.171c-.635 0-1.241.129-1.793.36-.369-4.177-3.871-7.453-8.144-7.453a8.28 8.28 0 0 0-2.965.553c-.35.136-.442.275-.446.546v14.709a.545.545 0 0 0 .5.531c.013.002 12.848 0 12.848 0 2.56 0 4.634-2.051 4.634-4.611a4.634 4.634 0 0 0-4.634-4.635zM24.17 16.237a.5.5 0 0 0-.582.043.517.517 0 0 0-.189.392v.053l-.21 10.388.107 1.92.103 1.869a.514.514 0 0 0 .51.505.515.515 0 0 0 .51-.509v.004l.228-3.79-.227-10.44a.517.517 0 0 0-.25-.435zm-1.364 14.72v-.001.001-.002.002zm-.215-13.813a.47.47 0 0 0-.264-.081.486.486 0 0 0-.478.477l-.001.09-.18 9.48.181 3.847.001.016a.48.48 0 0 0 .477.458c.246 0 .248-.054.335-.14a.486.486 0 0 0 .144-.336l.02-.38.181-3.463-.201-9.573a.487.487 0 0 0-.215-.395zm-1.853 1.479a.447.447 0 0 0-.446.444l-.2 8.044.2 3.87c.005.465.2.442.446.442.245 0 .44.023.446-.444v.003l.223-3.87-.223-8.046a.447.447 0 0 0-.446-.443zm-1.577-.273a.416.416 0 0 0-.414.412l-.219 8.349.219 3.895c.005.228.187.41.414.41a.416.416 0 0 0 .413-.412v.002l.246-3.895-.246-8.35a.416.416 0 0 0-.413-.411zm-1.184 12.693v-.002.002zm0-12.5a.385.385 0 0 0-.382-.38.384.384 0 0 0-.381.38l-.238 8.567.238 3.932c.006.21.173.377.381.377a.385.385 0 0 0 .382-.378l.268-3.931-.268-8.568zm-1.935-.069a.354.354 0 0 0-.35.347l-.256 8.288.257 3.957c.006.193.16.346.35.346a.354.354 0 0 0 .349-.347v.002l.29-3.958-.29-8.288a.355.355 0 0 0-.35-.347zm-1.564.691a.322.322 0 0 0-.318.315l-.275 7.65.276 3.998a.321.321 0 0 0 .317.313c.17 0 .31-.138.317-.315v.002l.312-3.999-.312-7.65a.323.323 0 0 0-.317-.314zM12.974 20.6a.29.29 0 0 0-.285.282l-.295 6.226.295 4.023a.29.29 0 0 0 .285.281.292.292 0 0 0 .285-.282v.001l.333-4.023-.333-6.226a.292.292 0 0 0-.285-.282zm-1.264 2.678a.258.258 0 0 0-.253-.248.257.257 0 0 0-.253.25l-.314 3.826.314 4.024c.008.142.117.25.253.25a.259.259 0 0 0 .253-.25l.356-4.024-.356-3.828zm0 7.851v.001zm-1.757-8.366a.226.226 0 0 0-.221.217l-.333 4.126.333 3.99c.009.124.104.217.22.217s.21-.093.221-.216l.4-3.991-.4-4.126c-.01-.123-.105-.217-.22-.217zm-1.493.142c-.1 0-.179.078-.189.185l-.351 4.015.351 3.868c.01.108.09.185.19.185.097 0 .176-.077.188-.184l.4-3.869-.4-4.015c-.012-.107-.091-.185-.189-.185zm-2.873 1.96c-.079 0-.14.06-.151.147l-.276 2.094.276 2.056c.01.086.072.147.15.147s.14-.06.152-.147l.326-2.056-.326-2.095c-.013-.086-.074-.145-.151-.145zM6.98 23.57c-.08 0-.146.064-.157.152l-.25 3.385.25 3.308c.011.088.077.152.157.152s.144-.062.156-.152l.422-3.308-.422-3.385c-.012-.09-.077-.152-.156-.152zM48 24c0 13.255-10.745 24-24 24C10.757 48 0 37.255 0 24 0 10.757 10.757 0 24 0c13.255 0 24 10.757 24 24z"/></g></svg>';
} else {
soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M1.6 24.3c-.2 0-.3.1-.3.3l-.5 6.2.5 6c0 .2.2.3.3.3.2 0 .3-.1.3-.3l.6-6-.6-6.2c0-.2-.1-.3-.3-.3zm3.3 12.6zm0-11.8c0-.2-.2-.4-.4-.4s-.4.2-.4.4l-.5 5.8.5 6.1c0 .2.2.4.4.4s.4-.2.4-.4l.5-6.1-.5-5.8zm2.7-6.2c-.3 0-.5.2-.5.5l-.4 11.5.4 6c0 .3.2.5.5.5s.5-.2.5-.5l.5-6-.5-11.6c-.1-.2-.3-.4-.5-.4zm3.8-1c0-.3-.3-.6-.6-.6s-.6.3-.6.6l-.4 13 .4 5.9c0 .3.3.6.6.6s.6-.3.6-.6l.4-5.9-.4-13zm2.7.1c-.4 0-.7.3-.7.7l-.3 12.2.3 5.9c0 .4.3.7.7.7.4 0 .7-.3.7-.7l.3-5.9-.3-12.2c0-.4-.3-.7-.7-.7zm3.7-3.6c-.1-.1-.3-.1-.4-.1-.2 0-.4.1-.5.2-.2.1-.3.4-.3.6v.1l-.3 15.7.2 2.9.2 2.8c0 .4.4.8.8.8s.8-.3.8-.8l.3-5.7-.3-15.8c-.1-.3-.3-.5-.5-.7zm22.4 9c-1 0-1.9.2-2.7.5-.6-6.3-5.9-11.3-12.3-11.3-1.6 0-3.1.3-4.5.8-.5.2-.7.4-.7.8v22.2c0 .4.3.8.8.8h19.4c3.9 0 7-3.1 7-7 0-3.7-3.1-6.8-7-6.8z"/></svg>';
}
soundcloud += '</a>';
soundcloud +=' </div>';
var telegram = '';
telegram += '<div class="t-review-social-links\_\_item">';
telegram += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 60 60" fill="' + fill + '"><path d="M30 0C13.4 0 0 13.4 0 30s13.4 30 30 30 30-13.4 30-30S46.6 0 30 0zm16.9 13.9l-6.7 31.5c-.1.6-.8.9-1.4.6l-10.3-6.9-5.5 5.2c-.5.4-1.2.2-1.4-.4L18 32.7l-9.5-3.9c-.7-.3-.7-1.5 0-1.8l37.1-14.1c.7-.2 1.4.3 1.3 1z"/><path d="M22.7 40.6l.6-5.8 16.8-16.3-20.2 13.3"/></svg>';
} else {
telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 60 60" fill="' + fill + '"><path d="M52.5 9L6.1 26.9c-.9.4-.9 1.8 0 2.3L18 34.1l4.4 14.1c.3.8 1.2 1 1.8.5l6.8-6.4L43.9 51c.7.4 1.6 0 1.7-.7l8.4-40c.2-.8-.7-1.6-1.5-1.3zm-28 27.7l-.7 7.3-3.6-11.2L45.5 16l-21 20.7z"/></svg>';
}
telegram += '</a>';
telegram += '</div>';
if (item.indexOf('facebook') != -1) {
socialWrapper.append(fb);
}
if (item.indexOf('twitter') != -1) {
socialWrapper.append(twi);
}
if (item.indexOf('vk.com') != -1) {
socialWrapper.append(vk);
}
if (item.indexOf('ok.ru') != -1) {
socialWrapper.append(ok);
}
if (item.indexOf('behance') != -1) {
socialWrapper.append(behance);
}
if (item.indexOf('vimeo') != -1) {
socialWrapper.append(vimeo);
}
if (item.indexOf('youtube') != -1) {
socialWrapper.append(youtube);
}
if (item.indexOf('instagram') != -1) {
socialWrapper.append(instagram);
}
if (item.indexOf('pinterest') != -1) {
socialWrapper.append(pinterest);
}
if (item.indexOf('linkedin') != -1) {
socialWrapper.append(linkedin);
}
if (item.indexOf('soundcloud') != -1) {
socialWrapper.append(soundcloud);
}
if (item.indexOf('telegram') != -1) {
socialWrapper.append(telegram);
}
}
$(document).ready(function() {
t\_reviews\_social\_init('262141713');
});
@media screen and (max-width: 640px){
.t525 .t-review-social-links\_\_wrapper {
-webkit-box-pack: center;
-ms-flex-pack: center;
justify-content: center;
}
}
### Как тестирование тормозит разработку
В Pixonic мы оцениваем качество кода с помощью метрики «плотность дефектов». За 2019 и 2020 годы она составляет 7−9 ошибок на 1000 строк кода. Проблема в том, что даже при стабильной плотности дефектов объёмы кода постоянно растут: так, в прошлом году команда тестирования находила от 500 до 1200 багов в основном проекте за месяц.
В итоге команду тестирования необходимо было регулярно наращивать: бюджет рос, а релизы выходили реже. Чтобы снизить нагрузку на ребят и быстрее выкатывать новые версии игры, я переработал наш подход к тестированию и внедрил новую систему работы.
### Ускорение тестирования
Я решил использовать более продвинутый подход, который сократит рутинные операции и ускорит тестирование:
* ввёл краткие чек-листы вместо объёмных тест-комплектов;
* сфокусировал команду на основных «пользовательских сценариях» использования приложения вместо большого количества избыточных «негативных сценариев»;
* отказался от классических огромных регрессионных сессий проверок версии перед релизом и автоматизировал тестирование;
* результат: меньше временных затрат на тестирование, отсутствие потребности в большем количестве сотрудников, сокращение сроков тестирования;
* использовал сильные стороны сотрудников там, где это было максимально целесообразно и эффективно.
Внутри компании у каждого проекта есть свой приоритет, по которому мы выбираем степень рисков, которую мы можем позволить себе при тестировании. Грубо говоря, чем лучше финансовые показатели у проекта, тем тщательнее мы его проверяем. Например, на проекте War Robots мы работаем по самой безопасной методологии: проверяем по чек-листам, оставили минимально необходимые негативные сценарии, регрессионные сессии составляем на основе конкретных изменений в проекте, всю рутину отдали на откуп автотестам, а на самые критичные истории назначаем только проверенных и опытных инженеров.
На ранних этапах разработки проектов цена ошибки не столь высока и такие процессуальные манипуляции помогают существенно экономить время и ресурсы. Автоматизация весьма недешевое удовольствие, а в случае с играми готовых решений на рынке очень мало и приходится использовать собственное решение. Мы разрабатывали собственный фреймворк для автоматизации 3 года, из которых полтора ушло на его полишинг и написание самих тестов. При этом тестовое покрытие проекта ещё далеко не 100%-е и находится в активной разработке.
Когда мы принимаем новых сотрудников, на этапе собеседования приблизительно оцениваем опыт соискателя и сопоставляем его схожесть с процессами внутри Pixonic. В полном объёме оценка компетенций сотрудника проходит в течение первого года сотрудничества. Мы назначаем из более опытных сотрудников ментора, планомерно поручаем всё более сложные задачи и следим за количеством дефектов после поставки. Параллельно проводим обязательную сертификацию по методологии ISTQB, внутренние обучения.
Работа с dev-контуром
---------------------
Привет, Хабр! Меня зовут Иван Решетин. Последние 1,5 года я руковожу бэкенд-платформой в сервисе объявлений [Юла](https://u.habr.com/mrg_post_ula). Помогаю внедрять микросервисы, улучшать инфраструктуру и делать Юлу быстрее, выше, сильнее. Люблю A/B-тесты и поэтапное внедрение.
.t-review-social-links {
line-height: 0px;
}
.t-review-social-links\_\_wrapper {
display: -webkit-box;
display: -ms-flexbox;
display: flex;
-webkit-box-align: center;
-ms-flex-align: center;
align-items: center;
-ms-flex-wrap: wrap;
flex-wrap: wrap;
width: auto;
}
.t-review-social-links {
margin-top: 15px;
}
.t-review-social-links\_\_item {
padding: 0px 4px;
}
.t-review-social-links\_\_item svg {
width: 20px;
height: 20px;
}
.t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg {
width: 23px;
height: 23px;
}
.t-review-social-links\_\_item:first-child {
padding-left: 0px;
}
@media screen and (max-width: 960px) {
.t-review-social-links\_\_item {
margin-bottom: 3px;
}
}
@media screen and (max-width: 640px) {
.t-review-social-links {
margin-top: 13px;
}
.t-review-social-links\_\_item {
padding: 0px 3px;
}
.t-review-social-links\_\_item svg {
width: 17px;
height: 17px;
}
.t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg {
width: 20px;
height: 20px;
}
}
function t\_reviews\_social\_init(recid){
var rec = $('#rec' + recid);
var social = rec.find('.t-review-social-links');
if (social !== 'undefined' && social.length > 0) {
social.each(function() {
var $this = $(this);
var socialAttr = $this.attr('data-social-links');
var socialWrapper = $this.find('.t-review-social-links\_\_wrapper');
var links;
$this.removeAttr('data-social-links');
if (typeof socialAttr !== 'undefined') {
links = socialAttr.split(',');
links.forEach(function(item) {
t\_reviews\_social\_add\_item(item, socialWrapper);
});
}
});
}
}
function t\_reviews\_social\_add\_item(item, socialWrapper) {
var fill = socialWrapper.attr('data-social-color') || '#000000';
var fb = '';
fb = '<div class="t-review-social-links\_\_item">';
fb += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
fb += '<svg class="t-review-social-links\_\_svg" version="1.1" id="Layer\_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="30px" height="30px" viewBox="0 0 48 48" enable-background="new 0 0 48 48" xml:space="preserve" fill="' + fill + '"><desc>Facebook</desc><path d="M47.761,24c0,13.121-10.638,23.76-23.758,23.76C10.877,47.76,0.239,37.121,0.239,24c0-13.124,10.638-23.76,23.764-23.76C37.123,0.24,47.761,10.876,47.761,24 M20.033,38.85H26.2V24.01h4.163l0.539-5.242H26.2v-3.083c0-1.156,0.769-1.427,1.308-1.427h3.318V9.168L26.258,9.15c-5.072,0-6.225,3.796-6.225,6.224v3.394H17.1v5.242h2.933V38.85z"></path></svg>';
} else {
fb += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M21.1 7.8C22.5 6.5 24.5 6 26.4 6h6v6.3h-3.9c-.8-.1-1.6.6-1.8 1.4v4.2h5.7c-.1 2-.4 4.1-.7 6.1h-5v18h-7.4V24h-3.6v-6h3.6v-5.9c.1-1.7.7-3.3 1.8-4.3z"/></svg>';
}
fb += '</a>';
fb += '</div>';
var twi = '';
twi += '<div class="t-review-social-links\_\_item">';
twi += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.762 24c0 13.121-10.639 23.76-23.761 23.76S.24 37.121.24 24C.24 10.876 10.879.24 24.001.24S47.762 10.876 47.762 24m-9.731-11.625a12.148 12.148 0 0 1-3.87 1.481 6.08 6.08 0 0 0-4.455-1.926 6.095 6.095 0 0 0-6.093 6.095c0 .478.054.941.156 1.388a17.302 17.302 0 0 1-12.559-6.367 6.066 6.066 0 0 0-.825 3.064 6.088 6.088 0 0 0 2.711 5.07 6.075 6.075 0 0 1-2.761-.762v.077c0 2.951 2.1 5.414 4.889 5.975a6.079 6.079 0 0 1-2.752.106 6.104 6.104 0 0 0 5.692 4.232 12.226 12.226 0 0 1-7.567 2.607c-.492 0-.977-.027-1.453-.084a17.241 17.241 0 0 0 9.34 2.736c11.209 0 17.337-9.283 17.337-17.337 0-.263-.004-.527-.017-.789a12.358 12.358 0 0 0 3.039-3.152 12.138 12.138 0 0 1-3.498.958 6.089 6.089 0 0 0 2.686-3.372"/></svg>';
} else {
twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.8 12.7c-1.3.6-2.8 1-4.2 1.1 1.5-1 2.6-2.3 3.2-4-1.5.8-2.9 1.5-4.7 1.8-1.3-1.5-3.2-2.3-5.3-2.3-4 0-7.3 3.2-7.3 7.3 0 .6 0 1.1.2 1.6-6-.3-11.3-3.2-15.1-7.6-.6 1.1-1 2.3-1 3.7 0 2.6 1.3 4.7 3.2 6-1.1 0-2.3-.3-3.2-1v.2c0 3.6 2.4 6.5 5.8 7.1-.6.2-1.3.3-1.9.3-.5 0-1 0-1.3-.2 1 2.9 3.6 5 6.8 5-2.4 1.9-5.7 3.1-9.1 3.1-.6 0-1.1 0-1.8-.2 3.2 2.1 7 3.2 11.2 3.2 13.4 0 20.7-11 20.7-20.7v-1c1.7-.7 2.8-2 3.8-3.4z"/></svg>';
}
twi += '</a>';
twi += '</div>';
var vk = '';
vk += '<div class="t-review-social-links\_\_item">';
vk += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.761 24c0 13.121-10.639 23.76-23.76 23.76C10.878 47.76.239 37.121.239 24 .239 10.877 10.878.24 24.001.24c13.121 0 23.76 10.637 23.76 23.76m-12.502 4.999c-2.621-2.433-2.271-2.041.89-6.25 1.923-2.562 2.696-4.126 2.45-4.796-.227-.639-1.64-.469-1.64-.469l-4.71.029s-.351-.048-.609.106c-.249.151-.414.505-.414.505s-.742 1.982-1.734 3.669c-2.094 3.559-2.935 3.747-3.277 3.524-.796-.516-.597-2.068-.597-3.171 0-3.449.522-4.887-1.02-5.259-.511-.124-.887-.205-2.195-.219-1.678-.016-3.101.007-3.904.398-.536.263-.949.847-.697.88.31.041 1.016.192 1.388.699.484.656.464 2.131.464 2.131s.282 4.056-.646 4.561c-.632.347-1.503-.36-3.37-3.588-.958-1.652-1.68-3.481-1.68-3.481s-.14-.344-.392-.527c-.299-.222-.722-.298-.722-.298l-4.469.018s-.674-.003-.919.289c-.219.259-.018.752-.018.752s3.499 8.104 7.573 12.23c3.638 3.784 7.764 3.36 7.764 3.36h1.867s.566.113.854-.189c.265-.288.256-.646.256-.646s-.034-2.512 1.129-2.883c1.15-.36 2.624 2.429 4.188 3.497 1.182.812 2.079.633 2.079.633l4.181-.056s2.186-.136 1.149-1.858c-.197-.139-.715-1.269-3.219-3.591"/></svg>';
} else {
vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.2 22.2c.6-.8 1.1-1.5 1.5-2 2.7-3.5 3.8-5.8 3.5-6.8l-.2-.2c-.1-.1-.3-.3-.7-.4-.4-.1-.9-.1-1.5-.1h-7.2c-.2 0-.3 0-.3.1 0 0-.1 0-.1.1v.1c-.1 0-.2.1-.3.2-.1.1-.2.2-.2.4-.7 1.9-1.5 3.6-2.5 5.2-.6 1-1.1 1.8-1.6 2.5s-.9 1.2-1.2 1.5c-.3.3-.6.6-.9.8-.2.3-.4.4-.5.4-.1 0-.3-.1-.4-.1-.2-.1-.4-.3-.5-.6-.1-.2-.2-.5-.3-.9 0-.4-.1-.7-.1-.9v-4c0-.7 0-1.2.1-1.6v-1.3c0-.4 0-.8-.1-1.1-.1-.3-.1-.5-.2-.7-.1-.2-.3-.4-.5-.6-.2-.1-.5-.2-.8-.3-.8-.2-1.9-.3-3.1-.3-2.9 0-4.7.2-5.5.6-.3.2-.6.4-.9.7-.3.3-.3.5-.1.6.9.1 1.6.5 2 1l.1.3c.1.2.2.6.3 1.1.1.5.2 1.1.2 1.7.1 1.1.1 2.1 0 2.9-.1.8-.1 1.4-.2 1.9-.1.4-.2.8-.3 1.1-.1.3-.2.4-.3.5 0 .1-.1.1-.1.1-.1-.1-.4-.1-.6-.1-.2 0-.5-.1-.8-.3-.3-.2-.6-.5-1-.9-.3-.4-.7-.9-1.1-1.6-.4-.7-.8-1.5-1.3-2.4l-.4-.7c-.2-.4-.5-1.1-.9-1.9-.4-.8-.8-1.6-1.1-2.4-.1-.3-.3-.6-.6-.7l-.1-.1c-.1-.1-.2-.1-.4-.2s-.3-.1-.5-.2H3.2c-.6 0-1.1.1-1.3.4l-.1.1c0 .1-.1.2-.1.4s0 .4.1.6c.9 2.2 1.9 4.3 3 6.3s2 3.6 2.8 4.9c.8 1.2 1.6 2.4 2.4 3.5.8 1.1 1.4 1.8 1.7 2.1.3.3.5.5.6.7l.6.6c.4.4.9.8 1.6 1.3.7.5 1.5 1 2.4 1.5.9.5 1.9.9 3 1.2 1.2.3 2.3.4 3.4.4H26c.5 0 .9-.2 1.2-.5l.1-.1c.1-.1.1-.2.2-.4s.1-.4.1-.6c0-.7 0-1.3.1-1.8s.2-.9.4-1.2c.1-.3.3-.5.5-.7.2-.2.3-.3.4-.3.1 0 .1-.1.2-.1.4-.1.8 0 1.3.4s1 .8 1.4 1.3c.4.5 1 1.1 1.6 1.8.6.7 1.2 1.2 1.6 1.5l.5.3c.3.2.7.4 1.2.5.5.2.9.2 1.3.1l5.9-.1c.6 0 1-.1 1.4-.3.3-.2.5-.4.6-.6.1-.2.1-.5 0-.8-.1-.3-.1-.5-.2-.6-.1-.1-.1-.2-.2-.3-.8-1.4-2.2-3.1-4.4-5.1-1-.9-1.6-1.6-1.9-1.9-.5-.6-.6-1.2-.3-1.9.3-.5 1-1.5 2.2-3z"/></svg>';
}
vk += '</a>';
vk += '</div>';
var ok = '';
ok += '<div class="t-review-social-links\_\_item">';
ok += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15.001 29.997C6.715 29.997 0 23.28 0 14.997 0 6.714 6.715 0 15.001 0 23.282-.001 30 6.713 30 14.998c0 8.283-6.716 14.999-14.998 14.999zM15 9.163c.986 0 1.787.803 1.787 1.787 0 .987-.801 1.788-1.787 1.788a1.788 1.788 0 0 1 0-3.574zm4.317 1.787a4.322 4.322 0 0 0-4.317-4.319 4.323 4.323 0 0 0-4.319 4.32A4.322 4.322 0 0 0 15 15.266a4.32 4.32 0 0 0 4.316-4.317zm-2.57 7.84a8.126 8.126 0 0 0 2.507-1.038 1.266 1.266 0 0 0-1.347-2.143 5.482 5.482 0 0 1-5.816 0 1.265 1.265 0 0 0-1.348 2.143c.78.49 1.628.838 2.507 1.038l-2.414 2.414a1.267 1.267 0 0 0 .894 2.16c.324 0 .649-.125.895-.37l2.371-2.373 2.373 2.373a1.265 1.265 0 0 0 1.788-1.789l-2.41-2.415z"/></svg>';
} else {
ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M12.498 6.2a1.932 1.932 0 0 0-1.929 1.93 1.932 1.932 0 0 0 3.861 0 1.932 1.932 0 0 0-1.932-1.93zm0 6.592a4.668 4.668 0 0 1-4.66-4.662 4.665 4.665 0 0 1 4.66-4.663 4.666 4.666 0 0 1 4.664 4.663 4.669 4.669 0 0 1-4.664 4.662zm-1.884 3.801a8.75 8.75 0 0 1-2.708-1.12 1.367 1.367 0 1 1 1.455-2.312 5.925 5.925 0 0 0 6.276 0 1.367 1.367 0 1 1 1.456 2.311c-.832.522-1.749.9-2.707 1.12l2.606 2.608a1.367 1.367 0 0 1-1.933 1.931L12.5 18.569l-2.561 2.562a1.368 1.368 0 0 1-1.934-1.934l2.609-2.604z"/></svg>';
}
ok += '</a>';
ok += '</div>';
var behance = '';
behance += '<div class="t-review-social-links\_\_item">';
behance += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-421.541 278.608c-3.095 0-3.526 3.09-3.526 3.09h6.581c0-.001.042-3.09-3.055-3.09zM-436.472 281.697h-5.834v5.356h5.165c.088 0 .219.002.374 0 .831-.02 2.406-.261 2.406-2.604-.001-2.78-2.111-2.752-2.111-2.752z"/><path d="M-430.984 257C-444.248 257-455 267.75-455 281.014c0 13.263 10.752 24.016 24.016 24.016 13.262 0 24.014-10.752 24.014-24.016-.001-13.263-10.754-24.014-24.014-24.014zm5.054 14.756h8.267v2.467h-8.267v-2.467zm-4.179 12.943c0 6.116-6.364 5.914-6.364 5.914h-10.428v-20.038h10.428c3.168 0 5.668 1.75 5.668 5.335s-3.057 3.813-3.057 3.813c4.031 0 3.753 4.976 3.753 4.976zm15.466-.328h-10.384c0 3.722 3.526 3.487 3.526 3.487 3.329 0 3.213-2.156 3.213-2.156h3.527c0 5.722-6.859 5.33-6.859 5.33-8.227 0-7.698-7.661-7.698-7.661s-.008-7.698 7.698-7.698c8.112.001 6.977 8.698 6.977 8.698z"/><path d="M-435.055 276.221c0-2.084-1.417-2.084-1.417-2.084H-442.306v4.471h5.472c.944 0 1.779-.304 1.779-2.387z"/></svg>';
} else {
behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M22.4 7.5h-5.6V6.1h5.6v1.4zm-9.3 5.7c.4.6.5 1.2.5 2s-.2 1.6-.6 2.2c-.3.4-.6.8-1 1.1-.4.3-1 .6-1.6.7-.6.1-1.3.2-2 .2H2.3V5.6H9c1.7 0 2.9.5 3.6 1.5.4.6.6 1.3.6 2.1s-.2 1.5-.6 2c-.2.3-.6.6-1.1.8.7.2 1.2.7 1.6 1.2zM5.5 11h2.9c.6 0 1.1-.1 1.5-.3.4-.2.6-.6.6-1.2s-.2-1.1-.7-1.3C9.3 8.1 8.7 8 8.1 8H5.5v3zm5.2 4c0-.7-.3-1.2-.9-1.5-.3-.2-.8-.2-1.4-.2h-3V17h2.9c.6 0 1.1-.1 1.4-.2.7-.3 1-.9 1-1.8zm13.8-2.2c.1.5.1 1.1.1 2h-7.2c0 1 .4 1.7 1 2.1.4.3.9.4 1.4.4.6 0 1.1-.1 1.4-.5.2-.2.4-.4.5-.7h2.6c-.1.6-.4 1.2-1 1.8-.9 1-2.1 1.4-3.7 1.4-1.3 0-2.5-.4-3.5-1.2-1-.8-1.5-2.1-1.5-4 0-1.7.5-3 1.4-4 .9-.9 2.1-1.4 3.5-1.4.9 0 1.6.2 2.3.5.7.3 1.3.8 1.7 1.5.6.6.8 1.3 1 2.1zm-2.7.2c0-.7-.3-1.2-.7-1.6-.4-.4-.9-.5-1.5-.5-.7 0-1.2.2-1.5.6-.4.4-.6.9-.7 1.5h4.4z"/></svg>';
}
behance += '</a>';
behance += '</div>';
var vimeo = '';
vimeo += '<div class="t-review-social-links\_\_item">';
vimeo += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 256.971c13.267 0 24.023 10.755 24.023 24.023s-10.755 24.023-24.023 24.023-24.023-10.755-24.023-24.023 10.756-24.023 24.023-24.023zm-12.262 19.146l.996 1.306s2.054-1.619 2.739-.81c.685.81 3.299 10.584 4.171 12.387.761 1.581 2.862 3.672 5.166 2.179 2.302-1.493 9.959-8.03 11.329-15.749 1.369-7.717-9.213-6.1-10.335.623 2.802-1.682 4.297.683 2.863 3.362-1.431 2.676-2.739 4.421-3.424 4.421-.683 0-1.209-1.791-1.992-4.92-.81-3.236-.804-9.064-4.17-8.403-3.171.623-7.343 5.604-7.343 5.604z"/></svg>';
} else {
vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M2.9 16.5l1.6 2s3.2-2.5 4.3-1.3c1.1 1.3 5.2 16.5 6.5 19.3 1.2 2.5 4.5 5.7 8.1 3.4S39 27.4 41.1 15.3s-14.4-9.5-16.1 1c4.4-2.6 6.7 1.1 4.5 5.3s-4.3 6.9-5.3 6.9c-1.1 0-1.9-2.8-3.1-7.7-1.3-5.1-1.3-14.2-6.5-13.1-5.2 1-11.7 8.8-11.7 8.8z"/></svg>';
}
vimeo += '</a>';
vimeo += '</div>';
var youtube = '';
youtube += '<div class="t-review-social-links\_\_item">';
youtube += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 257.013c13.248 0 23.987 10.74 23.987 23.987s-10.74 23.987-23.987 23.987-23.987-10.74-23.987-23.987 10.739-23.987 23.987-23.987zm11.815 18.08c-.25-1.337-1.363-2.335-2.642-2.458-3.054-.196-6.119-.355-9.178-.357-3.059-.002-6.113.154-9.167.347-1.284.124-2.397 1.117-2.646 2.459a40.163 40.163 0 0 0 0 11.672c.249 1.342 1.362 2.454 2.646 2.577 3.055.193 6.107.39 9.167.39 3.058 0 6.126-.172 9.178-.37 1.279-.124 2.392-1.269 2.642-2.606a39.769 39.769 0 0 0 0-11.654zm-14.591 9.342v-7.115l6.627 3.558-6.627 3.557z"/></svg>';
} else {
youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M43.9 15.3c-.4-3.1-2.2-5-5.3-5.3-3.6-.3-11.4-.5-15-.5-7.3 0-10.6.2-14.1.5-3.3.3-4.8 1.8-5.4 4.9-.4 2.1-.6 4.1-.6 8.9 0 4.3.2 6.9.5 9.2.4 3.1 2.5 4.8 5.7 5.1 3.6.3 10.9.5 14.4.5s11.2-.2 14.7-.6c3.1-.4 4.6-2 5.1-5.1 0 0 .5-3.3.5-9.1 0-3.3-.2-6.4-.5-8.5zM19.7 29.8V18l11.2 5.8-11.2 6z"/></svg>';
}
youtube += '</a>';
youtube += '</div>';
var instagram = '';
instagram += '<div class="t-review-social-links\_\_item">';
instagram += ' <a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15 11.014a3.986 3.986 0 1 0 .001 7.971A3.986 3.986 0 0 0 15 11.014zm0 6.592A2.604 2.604 0 0 1 12.393 15 2.604 2.604 0 0 1 15 12.394 2.614 2.614 0 0 1 17.607 15 2.604 2.604 0 0 1 15 17.606zM19.385 9.556a.915.915 0 0 0-.92.921c0 .512.407.919.92.919a.914.914 0 0 0 .921-.919.916.916 0 0 0-.921-.921z"/><path d="M15.002.15C6.798.15.149 6.797.149 15c0 8.201 6.649 14.85 14.853 14.85 8.199 0 14.85-6.648 14.85-14.85 0-8.203-6.651-14.85-14.85-14.85zm7.664 18.115c0 2.423-1.979 4.401-4.416 4.401h-6.5c-2.438 0-4.417-1.979-4.417-4.386v-6.546c0-2.422 1.978-4.4 4.417-4.4h6.5c2.438 0 4.416 1.978 4.416 4.4v6.531z"/></svg>';
} else {
instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M16.396 3.312H8.604c-2.921 0-5.292 2.371-5.292 5.273v7.846c0 2.886 2.371 5.256 5.292 5.256h7.791c2.922 0 5.292-2.37 5.292-5.274V8.586c.001-2.903-2.37-5.274-5.291-5.274zM7.722 12.5a4.778 4.778 0 1 1 9.554 0 4.778 4.778 0 0 1-9.554 0zm10.034-4.318c-.615 0-1.104-.487-1.104-1.102s.488-1.103 1.104-1.103c.614 0 1.102.488 1.102 1.103s-.488 1.102-1.102 1.102z" /><path d="M12.5 9.376A3.12 3.12 0 0 0 9.376 12.5a3.12 3.12 0 0 0 3.124 3.124 3.12 3.12 0 0 0 3.124-3.124A3.133 3.133 0 0 0 12.5 9.376z"/></svg>';
}
instagram += '</a>';
instagram += '</div>';
var pinterest = '';
pinterest += '<div class="t-review-social-links\_\_item">';
pinterest += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-407 281c0 13.254-10.746 24-23.999 24-13.257 0-24.003-10.746-24.003-24 0-13.256 10.746-24 24.003-24 13.253 0 23.999 10.744 23.999 24zm-30.628 14.811c.027.205.29.254.409.1.17-.223 2.365-2.932 3.111-5.639.211-.768 1.212-4.738 1.212-4.738.599 1.145 2.349 2.148 4.21 2.148 5.539 0 9.297-5.049 9.297-11.809 0-5.111-4.329-9.873-10.909-9.873-8.186 0-12.314 5.871-12.314 10.766 0 2.963 1.122 5.6 3.527 6.582.395.162.749.006.863-.43.08-.303.268-1.065.353-1.385.114-.432.07-.582-.248-.959-.694-.818-1.138-1.879-1.138-3.381 0-4.353 3.259-8.252 8.484-8.252 4.627 0 7.169 2.828 7.169 6.603 0 4.969-2.198 9.162-5.461 9.162-1.804 0-3.153-1.49-2.722-3.32.518-2.182 1.522-4.537 1.522-6.113 0-1.41-.758-2.588-2.324-2.588-1.843 0-3.323 1.908-3.323 4.461 0 1.627.55 2.727.55 2.727l-2.217 9.391c-.657 2.787-.099 6.203-.051 6.547z"/></svg>';
} else {
pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M24.9 5.5c4.2 0 7.7 1.3 10.5 3.9s4.1 5.7 4.1 9.2c0 4.6-1.2 8.4-3.5 11.3-2.3 3-5.3 4.5-8.9 4.5-1.2 0-2.3-.3-3.4-.9s-1.8-1.3-2.2-2c-.9 3.5-1.4 5.6-1.6 6.3-.7 2.4-2 4.9-4.1 7.5-.2.2-.4.2-.5-.1-.5-3.5-.5-6.4.1-8.7l2.9-12.6c-.5-.9-.7-2.1-.7-3.6 0-1.7.4-3.1 1.3-4.2s1.9-1.7 3.2-1.7c1 0 1.8.3 2.3 1 .5.6.8 1.5.8 2.4 0 .6-.1 1.4-.3 2.3-.2.9-.5 1.9-.9 3.1s-.6 2.1-.8 2.8c-.3 1.2-.1 2.2.7 3.1.7.9 1.7 1.3 3 1.3 2.1 0 3.8-1.2 5.2-3.6 1.4-2.4 2-5.3 2-8.7 0-2.6-.8-4.7-2.5-6.3-1.7-1.6-4-2.4-7-2.4-3.4 0-6.1 1.1-8.2 3.2S13 17.4 13 20.4c0 1.8.5 3.3 1.5 4.5.3.4.4.8.3 1.2 0 .1-.1.3-.2.6-.1.4-.1.6-.2.7 0 .1-.1.4-.2.6-.1.3-.3.4-.4.4h-.6c-3.1-1.3-4.7-4.2-4.7-8.7 0-3.6 1.5-6.9 4.4-9.9s7-4.3 12-4.3z"/></svg>';
}
pinterest += '</a>';
pinterest += '</div>';
var linkedin = '';
linkedin += '<div class="t-review-social-links\_\_item">';
linkedin += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-615 1477 48 48" fill="' + fill + '"><path d="M-566.999 1501c0 13.256-10.746 24-24 24-13.256 0-24.002-10.744-24.002-24 0-13.254 10.746-24 24.002-24 13.254 0 24 10.746 24 24zm-38.507 13.975h6.22v-20.004h-6.22v20.004zm3.11-22.739a3.606 3.606 0 0 0 0-7.211 3.603 3.603 0 0 0-3.604 3.605 3.604 3.604 0 0 0 3.604 3.606zm26.396 11.766c0-5.387-1.163-9.529-7.454-9.529-3.023 0-5.054 1.658-5.884 3.231h-.085v-2.733h-5.964v20.004h6.216v-9.896c0-2.609.493-5.137 3.729-5.137 3.186 0 3.232 2.984 3.232 5.305v9.729h6.21v-10.974z"/></svg>';
} else {
linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M42.3 23.1v13.5h-7.9V24c0-3.2-1.1-5.3-4-5.3-2.2 0-3.5 1.5-4 2.9-.2.5-.3 1.2-.3 1.9v13.2h-7.9s.1-21.4 0-23.6h7.9v3.3s0 .1-.1.1h.1v-.1c1-1.6 2.9-3.9 7.1-3.9 5.2-.1 9.1 3.3 9.1 10.6zM10.1 1.6c-2.7 0-4.4 1.8-4.4 4.1S7.4 9.8 10 9.8h.1c2.7 0 4.4-1.8 4.4-4.1s-1.7-4.1-4.4-4.1zm-3.9 35H14V13H6.2v23.6z"/></svg>';
}
linkedin += '</a>';
linkedin += '</div>';
var soundcloud = '';
soundcloud += '<div class="t-review-social-links\_\_item">';
soundcloud += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><defs><path id="a" d="M0 0h48v48H0V0z"/></defs><g fill-rule="evenodd"><path d="M38.206 22.171c-.635 0-1.241.129-1.793.36-.369-4.177-3.871-7.453-8.144-7.453a8.28 8.28 0 0 0-2.965.553c-.35.136-.442.275-.446.546v14.709a.545.545 0 0 0 .5.531c.013.002 12.848 0 12.848 0 2.56 0 4.634-2.051 4.634-4.611a4.634 4.634 0 0 0-4.634-4.635zM24.17 16.237a.5.5 0 0 0-.582.043.517.517 0 0 0-.189.392v.053l-.21 10.388.107 1.92.103 1.869a.514.514 0 0 0 .51.505.515.515 0 0 0 .51-.509v.004l.228-3.79-.227-10.44a.517.517 0 0 0-.25-.435zm-1.364 14.72v-.001.001-.002.002zm-.215-13.813a.47.47 0 0 0-.264-.081.486.486 0 0 0-.478.477l-.001.09-.18 9.48.181 3.847.001.016a.48.48 0 0 0 .477.458c.246 0 .248-.054.335-.14a.486.486 0 0 0 .144-.336l.02-.38.181-3.463-.201-9.573a.487.487 0 0 0-.215-.395zm-1.853 1.479a.447.447 0 0 0-.446.444l-.2 8.044.2 3.87c.005.465.2.442.446.442.245 0 .44.023.446-.444v.003l.223-3.87-.223-8.046a.447.447 0 0 0-.446-.443zm-1.577-.273a.416.416 0 0 0-.414.412l-.219 8.349.219 3.895c.005.228.187.41.414.41a.416.416 0 0 0 .413-.412v.002l.246-3.895-.246-8.35a.416.416 0 0 0-.413-.411zm-1.184 12.693v-.002.002zm0-12.5a.385.385 0 0 0-.382-.38.384.384 0 0 0-.381.38l-.238 8.567.238 3.932c.006.21.173.377.381.377a.385.385 0 0 0 .382-.378l.268-3.931-.268-8.568zm-1.935-.069a.354.354 0 0 0-.35.347l-.256 8.288.257 3.957c.006.193.16.346.35.346a.354.354 0 0 0 .349-.347v.002l.29-3.958-.29-8.288a.355.355 0 0 0-.35-.347zm-1.564.691a.322.322 0 0 0-.318.315l-.275 7.65.276 3.998a.321.321 0 0 0 .317.313c.17 0 .31-.138.317-.315v.002l.312-3.999-.312-7.65a.323.323 0 0 0-.317-.314zM12.974 20.6a.29.29 0 0 0-.285.282l-.295 6.226.295 4.023a.29.29 0 0 0 .285.281.292.292 0 0 0 .285-.282v.001l.333-4.023-.333-6.226a.292.292 0 0 0-.285-.282zm-1.264 2.678a.258.258 0 0 0-.253-.248.257.257 0 0 0-.253.25l-.314 3.826.314 4.024c.008.142.117.25.253.25a.259.259 0 0 0 .253-.25l.356-4.024-.356-3.828zm0 7.851v.001zm-1.757-8.366a.226.226 0 0 0-.221.217l-.333 4.126.333 3.99c.009.124.104.217.22.217s.21-.093.221-.216l.4-3.991-.4-4.126c-.01-.123-.105-.217-.22-.217zm-1.493.142c-.1 0-.179.078-.189.185l-.351 4.015.351 3.868c.01.108.09.185.19.185.097 0 .176-.077.188-.184l.4-3.869-.4-4.015c-.012-.107-.091-.185-.189-.185zm-2.873 1.96c-.079 0-.14.06-.151.147l-.276 2.094.276 2.056c.01.086.072.147.15.147s.14-.06.152-.147l.326-2.056-.326-2.095c-.013-.086-.074-.145-.151-.145zM6.98 23.57c-.08 0-.146.064-.157.152l-.25 3.385.25 3.308c.011.088.077.152.157.152s.144-.062.156-.152l.422-3.308-.422-3.385c-.012-.09-.077-.152-.156-.152zM48 24c0 13.255-10.745 24-24 24C10.757 48 0 37.255 0 24 0 10.757 10.757 0 24 0c13.255 0 24 10.757 24 24z"/></g></svg>';
} else {
soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M1.6 24.3c-.2 0-.3.1-.3.3l-.5 6.2.5 6c0 .2.2.3.3.3.2 0 .3-.1.3-.3l.6-6-.6-6.2c0-.2-.1-.3-.3-.3zm3.3 12.6zm0-11.8c0-.2-.2-.4-.4-.4s-.4.2-.4.4l-.5 5.8.5 6.1c0 .2.2.4.4.4s.4-.2.4-.4l.5-6.1-.5-5.8zm2.7-6.2c-.3 0-.5.2-.5.5l-.4 11.5.4 6c0 .3.2.5.5.5s.5-.2.5-.5l.5-6-.5-11.6c-.1-.2-.3-.4-.5-.4zm3.8-1c0-.3-.3-.6-.6-.6s-.6.3-.6.6l-.4 13 .4 5.9c0 .3.3.6.6.6s.6-.3.6-.6l.4-5.9-.4-13zm2.7.1c-.4 0-.7.3-.7.7l-.3 12.2.3 5.9c0 .4.3.7.7.7.4 0 .7-.3.7-.7l.3-5.9-.3-12.2c0-.4-.3-.7-.7-.7zm3.7-3.6c-.1-.1-.3-.1-.4-.1-.2 0-.4.1-.5.2-.2.1-.3.4-.3.6v.1l-.3 15.7.2 2.9.2 2.8c0 .4.4.8.8.8s.8-.3.8-.8l.3-5.7-.3-15.8c-.1-.3-.3-.5-.5-.7zm22.4 9c-1 0-1.9.2-2.7.5-.6-6.3-5.9-11.3-12.3-11.3-1.6 0-3.1.3-4.5.8-.5.2-.7.4-.7.8v22.2c0 .4.3.8.8.8h19.4c3.9 0 7-3.1 7-7 0-3.7-3.1-6.8-7-6.8z"/></svg>';
}
soundcloud += '</a>';
soundcloud +=' </div>';
var telegram = '';
telegram += '<div class="t-review-social-links\_\_item">';
telegram += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 60 60" fill="' + fill + '"><path d="M30 0C13.4 0 0 13.4 0 30s13.4 30 30 30 30-13.4 30-30S46.6 0 30 0zm16.9 13.9l-6.7 31.5c-.1.6-.8.9-1.4.6l-10.3-6.9-5.5 5.2c-.5.4-1.2.2-1.4-.4L18 32.7l-9.5-3.9c-.7-.3-.7-1.5 0-1.8l37.1-14.1c.7-.2 1.4.3 1.3 1z"/><path d="M22.7 40.6l.6-5.8 16.8-16.3-20.2 13.3"/></svg>';
} else {
telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 60 60" fill="' + fill + '"><path d="M52.5 9L6.1 26.9c-.9.4-.9 1.8 0 2.3L18 34.1l4.4 14.1c.3.8 1.2 1 1.8.5l6.8-6.4L43.9 51c.7.4 1.6 0 1.7-.7l8.4-40c.2-.8-.7-1.6-1.5-1.3zm-28 27.7l-.7 7.3-3.6-11.2L45.5 16l-21 20.7z"/></svg>';
}
telegram += '</a>';
telegram += '</div>';
if (item.indexOf('facebook') != -1) {
socialWrapper.append(fb);
}
if (item.indexOf('twitter') != -1) {
socialWrapper.append(twi);
}
if (item.indexOf('vk.com') != -1) {
socialWrapper.append(vk);
}
if (item.indexOf('ok.ru') != -1) {
socialWrapper.append(ok);
}
if (item.indexOf('behance') != -1) {
socialWrapper.append(behance);
}
if (item.indexOf('vimeo') != -1) {
socialWrapper.append(vimeo);
}
if (item.indexOf('youtube') != -1) {
socialWrapper.append(youtube);
}
if (item.indexOf('instagram') != -1) {
socialWrapper.append(instagram);
}
if (item.indexOf('pinterest') != -1) {
socialWrapper.append(pinterest);
}
if (item.indexOf('linkedin') != -1) {
socialWrapper.append(linkedin);
}
if (item.indexOf('soundcloud') != -1) {
socialWrapper.append(soundcloud);
}
if (item.indexOf('telegram') != -1) {
socialWrapper.append(telegram);
}
}
$(document).ready(function() {
t\_reviews\_social\_init('262132686');
});
@media screen and (max-width: 640px){
.t525 .t-review-social-links\_\_wrapper {
-webkit-box-pack: center;
-ms-flex-pack: center;
justify-content: center;
}
}
### Ошибка в одну строчку
Как-то раз нам нужно было реализовать небольшую задачку: добавить сохранение истории изменений в админке A/B-тестов. После выкатки в продакшен первое же изменение одного из A/B-тестов затерло всю базу, в которой было более 200 кейсов со сложными конфигурационными настройками. Начали разбираться, какая последняя задача была и как она выкатывалась. В той задаче в легаси-код была добавлена практически одна строчка нового функционала. Но вместе с этим решили поправить немного кодстайл, а также для лучшего понимания кода изменили имя у переменной, которая содержит новое значение A/B-теста. В итоге пулреквест (схематично) выглядел так:
Мы используем MongoDB как основное хранилище. А модуль A/B-тестов был очень старый и все A/B-тесты хранились в одном (!) документе. Выглядело это как-то так:
```
{
"_id" : ObjectId("5acf0c97640f499c8cd8dc09"),
"code" : "module_ab_tests",
"data" : {
"abtest_name1" : {}
"abtest\_name2" : {}
"abtest\_name3" : {}
}
}
```
$(document).ready(function(){
hljs.initHighlightingOnLoad();
});
.t264 .hljs {
background-color: ;
}
Пазл сложился. Изначально в переменной $config хранился map со всеми A/B-тестами. И так как новая переменная $configAbModule была пустая, то в результате маленькая правка меняла data, оставляя в нём только ключ с текущим A/B-тестом. На код-ревью этот момент пропустили, а автотесты проверяли только сохранение конкретного теста: изменил, сохранил, получил… всё ок… но проверки остальных значений A/B-тестов не было.
Ещё одной причиной того, что удаление данных из старой базы в dev-контуре никто не заметил, стала подготовка к запуску нового сервиса A/B-тестов на Go. Он уже имел отдельное хранилище и использовался в dev-контуре последние несколько недель. Этот сервис также был раскатан в бою, но пока без боевой нагрузки. Поэтому мы переключились на него, но на 2 дня раньше запланированной даты. Иначе нам пришлось бы экстренно раскатывать 11 шардов из бэкапов.
### Внимание к деталям
Этот случай научил нас уделять внимание даже «однострочным» правкам, а ещё мы расширили тест-кейсы и начали проверять всё, что могло зааффектить. Также мы стали делать dev- и prod-окружение более похожим и регулярно проводить учения по развертыванию бэкапов.
Чтобы все ребята в команде понимали, как устроен продукт, мы проводим внутренние митапы по архитектуре, где рассказываем, как устроены различные компоненты. Во время онбординга показываем записи со всех митапов новичкам, чтобы они лучше понимали, как устроен продукт, и проще втягивались в работу.
Внимание к задачам на этапе разработки
--------------------------------------
Привет, Хабр! Меня зовут Стас Фомин, и я отвечаю за тестирование проектов студии [NORD](https://u.habr.com/mrg_post_nord). Мы одна из старейших студий MY. GAMES: с 2007 года занимаемся разработкой и продюсированием онлайн-игр. Да, это мы сделали Jungle Heat, Iron Desert и Hustle Castle.
.t-review-social-links {
line-height: 0px;
}
.t-review-social-links\_\_wrapper {
display: -webkit-box;
display: -ms-flexbox;
display: flex;
-webkit-box-align: center;
-ms-flex-align: center;
align-items: center;
-ms-flex-wrap: wrap;
flex-wrap: wrap;
width: auto;
}
.t-review-social-links {
margin-top: 15px;
}
.t-review-social-links\_\_item {
padding: 0px 4px;
}
.t-review-social-links\_\_item svg {
width: 20px;
height: 20px;
}
.t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg {
width: 23px;
height: 23px;
}
.t-review-social-links\_\_item:first-child {
padding-left: 0px;
}
@media screen and (max-width: 960px) {
.t-review-social-links\_\_item {
margin-bottom: 3px;
}
}
@media screen and (max-width: 640px) {
.t-review-social-links {
margin-top: 13px;
}
.t-review-social-links\_\_item {
padding: 0px 3px;
}
.t-review-social-links\_\_item svg {
width: 17px;
height: 17px;
}
.t-review-social-links\_\_wrapper\_round .t-review-social-links\_\_item svg {
width: 20px;
height: 20px;
}
}
function t\_reviews\_social\_init(recid){
var rec = $('#rec' + recid);
var social = rec.find('.t-review-social-links');
if (social !== 'undefined' && social.length > 0) {
social.each(function() {
var $this = $(this);
var socialAttr = $this.attr('data-social-links');
var socialWrapper = $this.find('.t-review-social-links\_\_wrapper');
var links;
$this.removeAttr('data-social-links');
if (typeof socialAttr !== 'undefined') {
links = socialAttr.split(',');
links.forEach(function(item) {
t\_reviews\_social\_add\_item(item, socialWrapper);
});
}
});
}
}
function t\_reviews\_social\_add\_item(item, socialWrapper) {
var fill = socialWrapper.attr('data-social-color') || '#000000';
var fb = '';
fb = '<div class="t-review-social-links\_\_item">';
fb += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
fb += '<svg class="t-review-social-links\_\_svg" version="1.1" id="Layer\_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="30px" height="30px" viewBox="0 0 48 48" enable-background="new 0 0 48 48" xml:space="preserve" fill="' + fill + '"><desc>Facebook</desc><path d="M47.761,24c0,13.121-10.638,23.76-23.758,23.76C10.877,47.76,0.239,37.121,0.239,24c0-13.124,10.638-23.76,23.764-23.76C37.123,0.24,47.761,10.876,47.761,24 M20.033,38.85H26.2V24.01h4.163l0.539-5.242H26.2v-3.083c0-1.156,0.769-1.427,1.308-1.427h3.318V9.168L26.258,9.15c-5.072,0-6.225,3.796-6.225,6.224v3.394H17.1v5.242h2.933V38.85z"></path></svg>';
} else {
fb += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M21.1 7.8C22.5 6.5 24.5 6 26.4 6h6v6.3h-3.9c-.8-.1-1.6.6-1.8 1.4v4.2h5.7c-.1 2-.4 4.1-.7 6.1h-5v18h-7.4V24h-3.6v-6h3.6v-5.9c.1-1.7.7-3.3 1.8-4.3z"/></svg>';
}
fb += '</a>';
fb += '</div>';
var twi = '';
twi += '<div class="t-review-social-links\_\_item">';
twi += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.762 24c0 13.121-10.639 23.76-23.761 23.76S.24 37.121.24 24C.24 10.876 10.879.24 24.001.24S47.762 10.876 47.762 24m-9.731-11.625a12.148 12.148 0 0 1-3.87 1.481 6.08 6.08 0 0 0-4.455-1.926 6.095 6.095 0 0 0-6.093 6.095c0 .478.054.941.156 1.388a17.302 17.302 0 0 1-12.559-6.367 6.066 6.066 0 0 0-.825 3.064 6.088 6.088 0 0 0 2.711 5.07 6.075 6.075 0 0 1-2.761-.762v.077c0 2.951 2.1 5.414 4.889 5.975a6.079 6.079 0 0 1-2.752.106 6.104 6.104 0 0 0 5.692 4.232 12.226 12.226 0 0 1-7.567 2.607c-.492 0-.977-.027-1.453-.084a17.241 17.241 0 0 0 9.34 2.736c11.209 0 17.337-9.283 17.337-17.337 0-.263-.004-.527-.017-.789a12.358 12.358 0 0 0 3.039-3.152 12.138 12.138 0 0 1-3.498.958 6.089 6.089 0 0 0 2.686-3.372"/></svg>';
} else {
twi += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.8 12.7c-1.3.6-2.8 1-4.2 1.1 1.5-1 2.6-2.3 3.2-4-1.5.8-2.9 1.5-4.7 1.8-1.3-1.5-3.2-2.3-5.3-2.3-4 0-7.3 3.2-7.3 7.3 0 .6 0 1.1.2 1.6-6-.3-11.3-3.2-15.1-7.6-.6 1.1-1 2.3-1 3.7 0 2.6 1.3 4.7 3.2 6-1.1 0-2.3-.3-3.2-1v.2c0 3.6 2.4 6.5 5.8 7.1-.6.2-1.3.3-1.9.3-.5 0-1 0-1.3-.2 1 2.9 3.6 5 6.8 5-2.4 1.9-5.7 3.1-9.1 3.1-.6 0-1.1 0-1.8-.2 3.2 2.1 7 3.2 11.2 3.2 13.4 0 20.7-11 20.7-20.7v-1c1.7-.7 2.8-2 3.8-3.4z"/></svg>';
}
twi += '</a>';
twi += '</div>';
var vk = '';
vk += '<div class="t-review-social-links\_\_item">';
vk += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><path d="M47.761 24c0 13.121-10.639 23.76-23.76 23.76C10.878 47.76.239 37.121.239 24 .239 10.877 10.878.24 24.001.24c13.121 0 23.76 10.637 23.76 23.76m-12.502 4.999c-2.621-2.433-2.271-2.041.89-6.25 1.923-2.562 2.696-4.126 2.45-4.796-.227-.639-1.64-.469-1.64-.469l-4.71.029s-.351-.048-.609.106c-.249.151-.414.505-.414.505s-.742 1.982-1.734 3.669c-2.094 3.559-2.935 3.747-3.277 3.524-.796-.516-.597-2.068-.597-3.171 0-3.449.522-4.887-1.02-5.259-.511-.124-.887-.205-2.195-.219-1.678-.016-3.101.007-3.904.398-.536.263-.949.847-.697.88.31.041 1.016.192 1.388.699.484.656.464 2.131.464 2.131s.282 4.056-.646 4.561c-.632.347-1.503-.36-3.37-3.588-.958-1.652-1.68-3.481-1.68-3.481s-.14-.344-.392-.527c-.299-.222-.722-.298-.722-.298l-4.469.018s-.674-.003-.919.289c-.219.259-.018.752-.018.752s3.499 8.104 7.573 12.23c3.638 3.784 7.764 3.36 7.764 3.36h1.867s.566.113.854-.189c.265-.288.256-.646.256-.646s-.034-2.512 1.129-2.883c1.15-.36 2.624 2.429 4.188 3.497 1.182.812 2.079.633 2.079.633l4.181-.056s2.186-.136 1.149-1.858c-.197-.139-.715-1.269-3.219-3.591"/></svg>';
} else {
vk += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M41.2 22.2c.6-.8 1.1-1.5 1.5-2 2.7-3.5 3.8-5.8 3.5-6.8l-.2-.2c-.1-.1-.3-.3-.7-.4-.4-.1-.9-.1-1.5-.1h-7.2c-.2 0-.3 0-.3.1 0 0-.1 0-.1.1v.1c-.1 0-.2.1-.3.2-.1.1-.2.2-.2.4-.7 1.9-1.5 3.6-2.5 5.2-.6 1-1.1 1.8-1.6 2.5s-.9 1.2-1.2 1.5c-.3.3-.6.6-.9.8-.2.3-.4.4-.5.4-.1 0-.3-.1-.4-.1-.2-.1-.4-.3-.5-.6-.1-.2-.2-.5-.3-.9 0-.4-.1-.7-.1-.9v-4c0-.7 0-1.2.1-1.6v-1.3c0-.4 0-.8-.1-1.1-.1-.3-.1-.5-.2-.7-.1-.2-.3-.4-.5-.6-.2-.1-.5-.2-.8-.3-.8-.2-1.9-.3-3.1-.3-2.9 0-4.7.2-5.5.6-.3.2-.6.4-.9.7-.3.3-.3.5-.1.6.9.1 1.6.5 2 1l.1.3c.1.2.2.6.3 1.1.1.5.2 1.1.2 1.7.1 1.1.1 2.1 0 2.9-.1.8-.1 1.4-.2 1.9-.1.4-.2.8-.3 1.1-.1.3-.2.4-.3.5 0 .1-.1.1-.1.1-.1-.1-.4-.1-.6-.1-.2 0-.5-.1-.8-.3-.3-.2-.6-.5-1-.9-.3-.4-.7-.9-1.1-1.6-.4-.7-.8-1.5-1.3-2.4l-.4-.7c-.2-.4-.5-1.1-.9-1.9-.4-.8-.8-1.6-1.1-2.4-.1-.3-.3-.6-.6-.7l-.1-.1c-.1-.1-.2-.1-.4-.2s-.3-.1-.5-.2H3.2c-.6 0-1.1.1-1.3.4l-.1.1c0 .1-.1.2-.1.4s0 .4.1.6c.9 2.2 1.9 4.3 3 6.3s2 3.6 2.8 4.9c.8 1.2 1.6 2.4 2.4 3.5.8 1.1 1.4 1.8 1.7 2.1.3.3.5.5.6.7l.6.6c.4.4.9.8 1.6 1.3.7.5 1.5 1 2.4 1.5.9.5 1.9.9 3 1.2 1.2.3 2.3.4 3.4.4H26c.5 0 .9-.2 1.2-.5l.1-.1c.1-.1.1-.2.2-.4s.1-.4.1-.6c0-.7 0-1.3.1-1.8s.2-.9.4-1.2c.1-.3.3-.5.5-.7.2-.2.3-.3.4-.3.1 0 .1-.1.2-.1.4-.1.8 0 1.3.4s1 .8 1.4 1.3c.4.5 1 1.1 1.6 1.8.6.7 1.2 1.2 1.6 1.5l.5.3c.3.2.7.4 1.2.5.5.2.9.2 1.3.1l5.9-.1c.6 0 1-.1 1.4-.3.3-.2.5-.4.6-.6.1-.2.1-.5 0-.8-.1-.3-.1-.5-.2-.6-.1-.1-.1-.2-.2-.3-.8-1.4-2.2-3.1-4.4-5.1-1-.9-1.6-1.6-1.9-1.9-.5-.6-.6-1.2-.3-1.9.3-.5 1-1.5 2.2-3z"/></svg>';
}
vk += '</a>';
vk += '</div>';
var ok = '';
ok += '<div class="t-review-social-links\_\_item">';
ok += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15.001 29.997C6.715 29.997 0 23.28 0 14.997 0 6.714 6.715 0 15.001 0 23.282-.001 30 6.713 30 14.998c0 8.283-6.716 14.999-14.998 14.999zM15 9.163c.986 0 1.787.803 1.787 1.787 0 .987-.801 1.788-1.787 1.788a1.788 1.788 0 0 1 0-3.574zm4.317 1.787a4.322 4.322 0 0 0-4.317-4.319 4.323 4.323 0 0 0-4.319 4.32A4.322 4.322 0 0 0 15 15.266a4.32 4.32 0 0 0 4.316-4.317zm-2.57 7.84a8.126 8.126 0 0 0 2.507-1.038 1.266 1.266 0 0 0-1.347-2.143 5.482 5.482 0 0 1-5.816 0 1.265 1.265 0 0 0-1.348 2.143c.78.49 1.628.838 2.507 1.038l-2.414 2.414a1.267 1.267 0 0 0 .894 2.16c.324 0 .649-.125.895-.37l2.371-2.373 2.373 2.373a1.265 1.265 0 0 0 1.788-1.789l-2.41-2.415z"/></svg>';
} else {
ok += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M12.498 6.2a1.932 1.932 0 0 0-1.929 1.93 1.932 1.932 0 0 0 3.861 0 1.932 1.932 0 0 0-1.932-1.93zm0 6.592a4.668 4.668 0 0 1-4.66-4.662 4.665 4.665 0 0 1 4.66-4.663 4.666 4.666 0 0 1 4.664 4.663 4.669 4.669 0 0 1-4.664 4.662zm-1.884 3.801a8.75 8.75 0 0 1-2.708-1.12 1.367 1.367 0 1 1 1.455-2.312 5.925 5.925 0 0 0 6.276 0 1.367 1.367 0 1 1 1.456 2.311c-.832.522-1.749.9-2.707 1.12l2.606 2.608a1.367 1.367 0 0 1-1.933 1.931L12.5 18.569l-2.561 2.562a1.368 1.368 0 0 1-1.934-1.934l2.609-2.604z"/></svg>';
}
ok += '</a>';
ok += '</div>';
var behance = '';
behance += '<div class="t-review-social-links\_\_item">';
behance += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-421.541 278.608c-3.095 0-3.526 3.09-3.526 3.09h6.581c0-.001.042-3.09-3.055-3.09zM-436.472 281.697h-5.834v5.356h5.165c.088 0 .219.002.374 0 .831-.02 2.406-.261 2.406-2.604-.001-2.78-2.111-2.752-2.111-2.752z"/><path d="M-430.984 257C-444.248 257-455 267.75-455 281.014c0 13.263 10.752 24.016 24.016 24.016 13.262 0 24.014-10.752 24.014-24.016-.001-13.263-10.754-24.014-24.014-24.014zm5.054 14.756h8.267v2.467h-8.267v-2.467zm-4.179 12.943c0 6.116-6.364 5.914-6.364 5.914h-10.428v-20.038h10.428c3.168 0 5.668 1.75 5.668 5.335s-3.057 3.813-3.057 3.813c4.031 0 3.753 4.976 3.753 4.976zm15.466-.328h-10.384c0 3.722 3.526 3.487 3.526 3.487 3.329 0 3.213-2.156 3.213-2.156h3.527c0 5.722-6.859 5.33-6.859 5.33-8.227 0-7.698-7.661-7.698-7.661s-.008-7.698 7.698-7.698c8.112.001 6.977 8.698 6.977 8.698z"/><path d="M-435.055 276.221c0-2.084-1.417-2.084-1.417-2.084H-442.306v4.471h5.472c.944 0 1.779-.304 1.779-2.387z"/></svg>';
} else {
behance += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M22.4 7.5h-5.6V6.1h5.6v1.4zm-9.3 5.7c.4.6.5 1.2.5 2s-.2 1.6-.6 2.2c-.3.4-.6.8-1 1.1-.4.3-1 .6-1.6.7-.6.1-1.3.2-2 .2H2.3V5.6H9c1.7 0 2.9.5 3.6 1.5.4.6.6 1.3.6 2.1s-.2 1.5-.6 2c-.2.3-.6.6-1.1.8.7.2 1.2.7 1.6 1.2zM5.5 11h2.9c.6 0 1.1-.1 1.5-.3.4-.2.6-.6.6-1.2s-.2-1.1-.7-1.3C9.3 8.1 8.7 8 8.1 8H5.5v3zm5.2 4c0-.7-.3-1.2-.9-1.5-.3-.2-.8-.2-1.4-.2h-3V17h2.9c.6 0 1.1-.1 1.4-.2.7-.3 1-.9 1-1.8zm13.8-2.2c.1.5.1 1.1.1 2h-7.2c0 1 .4 1.7 1 2.1.4.3.9.4 1.4.4.6 0 1.1-.1 1.4-.5.2-.2.4-.4.5-.7h2.6c-.1.6-.4 1.2-1 1.8-.9 1-2.1 1.4-3.7 1.4-1.3 0-2.5-.4-3.5-1.2-1-.8-1.5-2.1-1.5-4 0-1.7.5-3 1.4-4 .9-.9 2.1-1.4 3.5-1.4.9 0 1.6.2 2.3.5.7.3 1.3.8 1.7 1.5.6.6.8 1.3 1 2.1zm-2.7.2c0-.7-.3-1.2-.7-1.6-.4-.4-.9-.5-1.5-.5-.7 0-1.2.2-1.5.6-.4.4-.6.9-.7 1.5h4.4z"/></svg>';
}
behance += '</a>';
behance += '</div>';
var vimeo = '';
vimeo += '<div class="t-review-social-links\_\_item">';
vimeo += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 256.971c13.267 0 24.023 10.755 24.023 24.023s-10.755 24.023-24.023 24.023-24.023-10.755-24.023-24.023 10.756-24.023 24.023-24.023zm-12.262 19.146l.996 1.306s2.054-1.619 2.739-.81c.685.81 3.299 10.584 4.171 12.387.761 1.581 2.862 3.672 5.166 2.179 2.302-1.493 9.959-8.03 11.329-15.749 1.369-7.717-9.213-6.1-10.335.623 2.802-1.682 4.297.683 2.863 3.362-1.431 2.676-2.739 4.421-3.424 4.421-.683 0-1.209-1.791-1.992-4.92-.81-3.236-.804-9.064-4.17-8.403-3.171.623-7.343 5.604-7.343 5.604z"/></svg>';
} else {
vimeo += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M2.9 16.5l1.6 2s3.2-2.5 4.3-1.3c1.1 1.3 5.2 16.5 6.5 19.3 1.2 2.5 4.5 5.7 8.1 3.4S39 27.4 41.1 15.3s-14.4-9.5-16.1 1c4.4-2.6 6.7 1.1 4.5 5.3s-4.3 6.9-5.3 6.9c-1.1 0-1.9-2.8-3.1-7.7-1.3-5.1-1.3-14.2-6.5-13.1-5.2 1-11.7 8.8-11.7 8.8z"/></svg>';
}
vimeo += '</a>';
vimeo += '</div>';
var youtube = '';
youtube += '<div class="t-review-social-links\_\_item">';
youtube += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-431 257.013c13.248 0 23.987 10.74 23.987 23.987s-10.74 23.987-23.987 23.987-23.987-10.74-23.987-23.987 10.739-23.987 23.987-23.987zm11.815 18.08c-.25-1.337-1.363-2.335-2.642-2.458-3.054-.196-6.119-.355-9.178-.357-3.059-.002-6.113.154-9.167.347-1.284.124-2.397 1.117-2.646 2.459a40.163 40.163 0 0 0 0 11.672c.249 1.342 1.362 2.454 2.646 2.577 3.055.193 6.107.39 9.167.39 3.058 0 6.126-.172 9.178-.37 1.279-.124 2.392-1.269 2.642-2.606a39.769 39.769 0 0 0 0-11.654zm-14.591 9.342v-7.115l6.627 3.558-6.627 3.557z"/></svg>';
} else {
youtube += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M43.9 15.3c-.4-3.1-2.2-5-5.3-5.3-3.6-.3-11.4-.5-15-.5-7.3 0-10.6.2-14.1.5-3.3.3-4.8 1.8-5.4 4.9-.4 2.1-.6 4.1-.6 8.9 0 4.3.2 6.9.5 9.2.4 3.1 2.5 4.8 5.7 5.1 3.6.3 10.9.5 14.4.5s11.2-.2 14.7-.6c3.1-.4 4.6-2 5.1-5.1 0 0 .5-3.3.5-9.1 0-3.3-.2-6.4-.5-8.5zM19.7 29.8V18l11.2 5.8-11.2 6z"/></svg>';
}
youtube += '</a>';
youtube += '</div>';
var instagram = '';
instagram += '<div class="t-review-social-links\_\_item">';
instagram += ' <a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 30 30" fill="' + fill + '"><path d="M15 11.014a3.986 3.986 0 1 0 .001 7.971A3.986 3.986 0 0 0 15 11.014zm0 6.592A2.604 2.604 0 0 1 12.393 15 2.604 2.604 0 0 1 15 12.394 2.614 2.614 0 0 1 17.607 15 2.604 2.604 0 0 1 15 17.606zM19.385 9.556a.915.915 0 0 0-.92.921c0 .512.407.919.92.919a.914.914 0 0 0 .921-.919.916.916 0 0 0-.921-.921z"/><path d="M15.002.15C6.798.15.149 6.797.149 15c0 8.201 6.649 14.85 14.853 14.85 8.199 0 14.85-6.648 14.85-14.85 0-8.203-6.651-14.85-14.85-14.85zm7.664 18.115c0 2.423-1.979 4.401-4.416 4.401h-6.5c-2.438 0-4.417-1.979-4.417-4.386v-6.546c0-2.422 1.978-4.4 4.417-4.4h6.5c2.438 0 4.416 1.978 4.416 4.4v6.531z"/></svg>';
} else {
instagram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 25 25" fill="' + fill + '"><path d="M16.396 3.312H8.604c-2.921 0-5.292 2.371-5.292 5.273v7.846c0 2.886 2.371 5.256 5.292 5.256h7.791c2.922 0 5.292-2.37 5.292-5.274V8.586c.001-2.903-2.37-5.274-5.291-5.274zM7.722 12.5a4.778 4.778 0 1 1 9.554 0 4.778 4.778 0 0 1-9.554 0zm10.034-4.318c-.615 0-1.104-.487-1.104-1.102s.488-1.103 1.104-1.103c.614 0 1.102.488 1.102 1.103s-.488 1.102-1.102 1.102z" /><path d="M12.5 9.376A3.12 3.12 0 0 0 9.376 12.5a3.12 3.12 0 0 0 3.124 3.124 3.12 3.12 0 0 0 3.124-3.124A3.133 3.133 0 0 0 12.5 9.376z"/></svg>';
}
instagram += '</a>';
instagram += '</div>';
var pinterest = '';
pinterest += '<div class="t-review-social-links\_\_item">';
pinterest += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-455 257 48 48" fill="' + fill + '"><path d="M-407 281c0 13.254-10.746 24-23.999 24-13.257 0-24.003-10.746-24.003-24 0-13.256 10.746-24 24.003-24 13.253 0 23.999 10.744 23.999 24zm-30.628 14.811c.027.205.29.254.409.1.17-.223 2.365-2.932 3.111-5.639.211-.768 1.212-4.738 1.212-4.738.599 1.145 2.349 2.148 4.21 2.148 5.539 0 9.297-5.049 9.297-11.809 0-5.111-4.329-9.873-10.909-9.873-8.186 0-12.314 5.871-12.314 10.766 0 2.963 1.122 5.6 3.527 6.582.395.162.749.006.863-.43.08-.303.268-1.065.353-1.385.114-.432.07-.582-.248-.959-.694-.818-1.138-1.879-1.138-3.381 0-4.353 3.259-8.252 8.484-8.252 4.627 0 7.169 2.828 7.169 6.603 0 4.969-2.198 9.162-5.461 9.162-1.804 0-3.153-1.49-2.722-3.32.518-2.182 1.522-4.537 1.522-6.113 0-1.41-.758-2.588-2.324-2.588-1.843 0-3.323 1.908-3.323 4.461 0 1.627.55 2.727.55 2.727l-2.217 9.391c-.657 2.787-.099 6.203-.051 6.547z"/></svg>';
} else {
pinterest += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M24.9 5.5c4.2 0 7.7 1.3 10.5 3.9s4.1 5.7 4.1 9.2c0 4.6-1.2 8.4-3.5 11.3-2.3 3-5.3 4.5-8.9 4.5-1.2 0-2.3-.3-3.4-.9s-1.8-1.3-2.2-2c-.9 3.5-1.4 5.6-1.6 6.3-.7 2.4-2 4.9-4.1 7.5-.2.2-.4.2-.5-.1-.5-3.5-.5-6.4.1-8.7l2.9-12.6c-.5-.9-.7-2.1-.7-3.6 0-1.7.4-3.1 1.3-4.2s1.9-1.7 3.2-1.7c1 0 1.8.3 2.3 1 .5.6.8 1.5.8 2.4 0 .6-.1 1.4-.3 2.3-.2.9-.5 1.9-.9 3.1s-.6 2.1-.8 2.8c-.3 1.2-.1 2.2.7 3.1.7.9 1.7 1.3 3 1.3 2.1 0 3.8-1.2 5.2-3.6 1.4-2.4 2-5.3 2-8.7 0-2.6-.8-4.7-2.5-6.3-1.7-1.6-4-2.4-7-2.4-3.4 0-6.1 1.1-8.2 3.2S13 17.4 13 20.4c0 1.8.5 3.3 1.5 4.5.3.4.4.8.3 1.2 0 .1-.1.3-.2.6-.1.4-.1.6-.2.7 0 .1-.1.4-.2.6-.1.3-.3.4-.4.4h-.6c-3.1-1.3-4.7-4.2-4.7-8.7 0-3.6 1.5-6.9 4.4-9.9s7-4.3 12-4.3z"/></svg>';
}
pinterest += '</a>';
pinterest += '</div>';
var linkedin = '';
linkedin += '<div class="t-review-social-links\_\_item">';
linkedin += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="-615 1477 48 48" fill="' + fill + '"><path d="M-566.999 1501c0 13.256-10.746 24-24 24-13.256 0-24.002-10.744-24.002-24 0-13.254 10.746-24 24.002-24 13.254 0 24 10.746 24 24zm-38.507 13.975h6.22v-20.004h-6.22v20.004zm3.11-22.739a3.606 3.606 0 0 0 0-7.211 3.603 3.603 0 0 0-3.604 3.605 3.604 3.604 0 0 0 3.604 3.606zm26.396 11.766c0-5.387-1.163-9.529-7.454-9.529-3.023 0-5.054 1.658-5.884 3.231h-.085v-2.733h-5.964v20.004h6.216v-9.896c0-2.609.493-5.137 3.729-5.137 3.186 0 3.232 2.984 3.232 5.305v9.729h6.21v-10.974z"/></svg>';
} else {
linkedin += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M42.3 23.1v13.5h-7.9V24c0-3.2-1.1-5.3-4-5.3-2.2 0-3.5 1.5-4 2.9-.2.5-.3 1.2-.3 1.9v13.2h-7.9s.1-21.4 0-23.6h7.9v3.3s0 .1-.1.1h.1v-.1c1-1.6 2.9-3.9 7.1-3.9 5.2-.1 9.1 3.3 9.1 10.6zM10.1 1.6c-2.7 0-4.4 1.8-4.4 4.1S7.4 9.8 10 9.8h.1c2.7 0 4.4-1.8 4.4-4.1s-1.7-4.1-4.4-4.1zm-3.9 35H14V13H6.2v23.6z"/></svg>';
}
linkedin += '</a>';
linkedin += '</div>';
var soundcloud = '';
soundcloud += '<div class="t-review-social-links\_\_item">';
soundcloud += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="30" height="30" viewBox="0 0 48 48" fill="' + fill + '"><defs><path id="a" d="M0 0h48v48H0V0z"/></defs><g fill-rule="evenodd"><path d="M38.206 22.171c-.635 0-1.241.129-1.793.36-.369-4.177-3.871-7.453-8.144-7.453a8.28 8.28 0 0 0-2.965.553c-.35.136-.442.275-.446.546v14.709a.545.545 0 0 0 .5.531c.013.002 12.848 0 12.848 0 2.56 0 4.634-2.051 4.634-4.611a4.634 4.634 0 0 0-4.634-4.635zM24.17 16.237a.5.5 0 0 0-.582.043.517.517 0 0 0-.189.392v.053l-.21 10.388.107 1.92.103 1.869a.514.514 0 0 0 .51.505.515.515 0 0 0 .51-.509v.004l.228-3.79-.227-10.44a.517.517 0 0 0-.25-.435zm-1.364 14.72v-.001.001-.002.002zm-.215-13.813a.47.47 0 0 0-.264-.081.486.486 0 0 0-.478.477l-.001.09-.18 9.48.181 3.847.001.016a.48.48 0 0 0 .477.458c.246 0 .248-.054.335-.14a.486.486 0 0 0 .144-.336l.02-.38.181-3.463-.201-9.573a.487.487 0 0 0-.215-.395zm-1.853 1.479a.447.447 0 0 0-.446.444l-.2 8.044.2 3.87c.005.465.2.442.446.442.245 0 .44.023.446-.444v.003l.223-3.87-.223-8.046a.447.447 0 0 0-.446-.443zm-1.577-.273a.416.416 0 0 0-.414.412l-.219 8.349.219 3.895c.005.228.187.41.414.41a.416.416 0 0 0 .413-.412v.002l.246-3.895-.246-8.35a.416.416 0 0 0-.413-.411zm-1.184 12.693v-.002.002zm0-12.5a.385.385 0 0 0-.382-.38.384.384 0 0 0-.381.38l-.238 8.567.238 3.932c.006.21.173.377.381.377a.385.385 0 0 0 .382-.378l.268-3.931-.268-8.568zm-1.935-.069a.354.354 0 0 0-.35.347l-.256 8.288.257 3.957c.006.193.16.346.35.346a.354.354 0 0 0 .349-.347v.002l.29-3.958-.29-8.288a.355.355 0 0 0-.35-.347zm-1.564.691a.322.322 0 0 0-.318.315l-.275 7.65.276 3.998a.321.321 0 0 0 .317.313c.17 0 .31-.138.317-.315v.002l.312-3.999-.312-7.65a.323.323 0 0 0-.317-.314zM12.974 20.6a.29.29 0 0 0-.285.282l-.295 6.226.295 4.023a.29.29 0 0 0 .285.281.292.292 0 0 0 .285-.282v.001l.333-4.023-.333-6.226a.292.292 0 0 0-.285-.282zm-1.264 2.678a.258.258 0 0 0-.253-.248.257.257 0 0 0-.253.25l-.314 3.826.314 4.024c.008.142.117.25.253.25a.259.259 0 0 0 .253-.25l.356-4.024-.356-3.828zm0 7.851v.001zm-1.757-8.366a.226.226 0 0 0-.221.217l-.333 4.126.333 3.99c.009.124.104.217.22.217s.21-.093.221-.216l.4-3.991-.4-4.126c-.01-.123-.105-.217-.22-.217zm-1.493.142c-.1 0-.179.078-.189.185l-.351 4.015.351 3.868c.01.108.09.185.19.185.097 0 .176-.077.188-.184l.4-3.869-.4-4.015c-.012-.107-.091-.185-.189-.185zm-2.873 1.96c-.079 0-.14.06-.151.147l-.276 2.094.276 2.056c.01.086.072.147.15.147s.14-.06.152-.147l.326-2.056-.326-2.095c-.013-.086-.074-.145-.151-.145zM6.98 23.57c-.08 0-.146.064-.157.152l-.25 3.385.25 3.308c.011.088.077.152.157.152s.144-.062.156-.152l.422-3.308-.422-3.385c-.012-.09-.077-.152-.156-.152zM48 24c0 13.255-10.745 24-24 24C10.757 48 0 37.255 0 24 0 10.757 10.757 0 24 0c13.255 0 24 10.757 24 24z"/></g></svg>';
} else {
soundcloud += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 48 48" fill="' + fill + '"><path d="M1.6 24.3c-.2 0-.3.1-.3.3l-.5 6.2.5 6c0 .2.2.3.3.3.2 0 .3-.1.3-.3l.6-6-.6-6.2c0-.2-.1-.3-.3-.3zm3.3 12.6zm0-11.8c0-.2-.2-.4-.4-.4s-.4.2-.4.4l-.5 5.8.5 6.1c0 .2.2.4.4.4s.4-.2.4-.4l.5-6.1-.5-5.8zm2.7-6.2c-.3 0-.5.2-.5.5l-.4 11.5.4 6c0 .3.2.5.5.5s.5-.2.5-.5l.5-6-.5-11.6c-.1-.2-.3-.4-.5-.4zm3.8-1c0-.3-.3-.6-.6-.6s-.6.3-.6.6l-.4 13 .4 5.9c0 .3.3.6.6.6s.6-.3.6-.6l.4-5.9-.4-13zm2.7.1c-.4 0-.7.3-.7.7l-.3 12.2.3 5.9c0 .4.3.7.7.7.4 0 .7-.3.7-.7l.3-5.9-.3-12.2c0-.4-.3-.7-.7-.7zm3.7-3.6c-.1-.1-.3-.1-.4-.1-.2 0-.4.1-.5.2-.2.1-.3.4-.3.6v.1l-.3 15.7.2 2.9.2 2.8c0 .4.4.8.8.8s.8-.3.8-.8l.3-5.7-.3-15.8c-.1-.3-.3-.5-.5-.7zm22.4 9c-1 0-1.9.2-2.7.5-.6-6.3-5.9-11.3-12.3-11.3-1.6 0-3.1.3-4.5.8-.5.2-.7.4-.7.8v22.2c0 .4.3.8.8.8h19.4c3.9 0 7-3.1 7-7 0-3.7-3.1-6.8-7-6.8z"/></svg>';
}
soundcloud += '</a>';
soundcloud +=' </div>';
var telegram = '';
telegram += '<div class="t-review-social-links\_\_item">';
telegram += '<a href="' + item + '" target="\_blank">';
if (socialWrapper.hasClass('t-review-social-links\_\_wrapper\_round')) {
telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="30" height="30" viewBox="0 0 60 60" fill="' + fill + '"><path d="M30 0C13.4 0 0 13.4 0 30s13.4 30 30 30 30-13.4 30-30S46.6 0 30 0zm16.9 13.9l-6.7 31.5c-.1.6-.8.9-1.4.6l-10.3-6.9-5.5 5.2c-.5.4-1.2.2-1.4-.4L18 32.7l-9.5-3.9c-.7-.3-.7-1.5 0-1.8l37.1-14.1c.7-.2 1.4.3 1.3 1z"/><path d="M22.7 40.6l.6-5.8 16.8-16.3-20.2 13.3"/></svg>';
} else {
telegram += '<svg class="t-review-social-links\_\_svg" xmlns="http://www.w3.org/2000/svg" width="25" height="25" viewBox="0 0 60 60" fill="' + fill + '"><path d="M52.5 9L6.1 26.9c-.9.4-.9 1.8 0 2.3L18 34.1l4.4 14.1c.3.8 1.2 1 1.8.5l6.8-6.4L43.9 51c.7.4 1.6 0 1.7-.7l8.4-40c.2-.8-.7-1.6-1.5-1.3zm-28 27.7l-.7 7.3-3.6-11.2L45.5 16l-21 20.7z"/></svg>';
}
telegram += '</a>';
telegram += '</div>';
if (item.indexOf('facebook') != -1) {
socialWrapper.append(fb);
}
if (item.indexOf('twitter') != -1) {
socialWrapper.append(twi);
}
if (item.indexOf('vk.com') != -1) {
socialWrapper.append(vk);
}
if (item.indexOf('ok.ru') != -1) {
socialWrapper.append(ok);
}
if (item.indexOf('behance') != -1) {
socialWrapper.append(behance);
}
if (item.indexOf('vimeo') != -1) {
socialWrapper.append(vimeo);
}
if (item.indexOf('youtube') != -1) {
socialWrapper.append(youtube);
}
if (item.indexOf('instagram') != -1) {
socialWrapper.append(instagram);
}
if (item.indexOf('pinterest') != -1) {
socialWrapper.append(pinterest);
}
if (item.indexOf('linkedin') != -1) {
socialWrapper.append(linkedin);
}
if (item.indexOf('soundcloud') != -1) {
socialWrapper.append(soundcloud);
}
if (item.indexOf('telegram') != -1) {
socialWrapper.append(telegram);
}
}
$(document).ready(function() {
t\_reviews\_social\_init('262132697');
});
@media screen and (max-width: 640px){
.t525 .t-review-social-links\_\_wrapper {
-webkit-box-pack: center;
-ms-flex-pack: center;
justify-content: center;
}
}
### К чему приводит усложнение
Представьте себе, что у юнитов в бою перестанет отображаться полоска здоровья (HP). Кому-то покажется мелочью, но для геймеров это очень важная часть игрового процесса, и её поломка грозила превратиться в огромное число тикетов от саппорта и потерю аудитории.
Проблема оказалась довольно сложной. Она возникла из-за неправильной концепции кода отображения HP в графическом интерфейсе пользователя (GUI). Мы отправляли не конкретное значение HP в текущий момент, а дельту — показатель, как изменился HP после определённого действия. Уже внутри UI из этой дельты рассчитывались значения текущего и максимального здоровья. Это совсем атас — фактически HP для боёвки и HP для UI считались в разных местах, а максимальное и текущее HP отправлялись в GUI отдельно друг от друга. В результате нам пришлось переписать визуализацию изменений HP и логику применения баффов на HP.
### Как мы боремся с узкими местами
Чтобы избежать подобных багов, мы выделили для себя критичные участки кода. Так боевая система на проектах полностью покрыта автотестами, которые мы постоянно пополняем. Также у нас есть клиентские и серверные unit-тесты, покрывающие самые критичные участки кода. Есть отдельные тестовые сценарии для проверки клиент-серверного взаимодействия, игровой логики. Все тесты крутятся в CI Jenkins и запускаются каждую ночь на регулярной основе. Код-ревью клиентской и серверной части проводят ведущие разработчики на проекте по каждой фиче.
Задачи идут с подробным описанием логики реализации и узких мест, которые продумываются заранее, ещё на этапе проработки концепции. Для валидаций нейминга и структуры статичных файлов (графика/видео/звуки) используются commit hooks, которые показали себя довольно эффективно.
Так мы добиваемся того, что большая часть задач становится очевидной даже для новых сотрудников. Период адаптации новых сотрудников у нас составляет 3 месяца: за это время они изучают наши рабочие процессы, задачи на проекте, знакомятся с командой. Для этого есть подробные гайды, FAQ, а наставник помогает вникнуть в технические детали проекта.
---
Качественный код — это искусство. У этого искусства две стороны. Одна — налаженный процесс тестирования, умелое введение в курс дела новобранцев, код-ревью, митапы по архитектуре, подробное описание задач, продумывание логики реализации и узких мест. И это далеко не все существующие способы делать код ещё лучше. Вторая — непрерывная работа команды над собственными скилами. В MRG мы сосредоточены на обоих процессах и делаем всё, чтобы мягко погрузить нового сотрудника в работу и помогать ему совершенствоваться. Хочешь стать частью нашей команды? Смотри наши [вакансии](https://u.habr.com/mrg_post_end) или заполни анкету:
Коротко о моем опыте работы\*
Ваш email
Отправить
#rec262139416 input::-webkit-input-placeholder {color:#000000; opacity: 0.5;}
#rec262139416 input::-moz-placeholder {color:#000000; opacity: 0.5;}
#rec262139416 input:-moz-placeholder {color:#000000; opacity: 0.5;}
#rec262139416 input:-ms-input-placeholder {color:#000000; opacity: 0.5;}
#rec262139416 textarea::-webkit-input-placeholder {color:#000000; opacity: 0.5;}
#rec262139416 textarea::-moz-placeholder {color:#000000; opacity: 0.5;}
#rec262139416 textarea:-moz-placeholder {color:#000000; opacity: 0.5;}
#rec262139416 textarea:-ms-input-placeholder {color:#000000; opacity: 0.5;}
#rec262139416 .t-btn[data-btneffects-first],
#rec262139416 .t-btn[data-btneffects-second],
#rec262139416 .t-submit[data-btneffects-first],
#rec262139416 .t-submit[data-btneffects-second] {
position: relative;
overflow: hidden;
-webkit-transform: translate3d(0,0,0);
transform: translate3d(0,0,0);
}
$(document).ready(function() {
});
.t525\_\_bgimg {
margin: 0;
}
.t525 .t-cell, .t525\_\_title.t-name.t-name\_xs {
text-align: left;
}
.t525 .t-cell.t-valign\_middle{
vertical-align: top;
}
.t107\_\_title {
padding-bottom: 0;
}
//Модифицируем блок с цитатой
var quote\_t525 = document.getElementsByClassName('t525');
var t525\_col = document.getElementsByClassName('t525\_\_col t-col t-col\_6')
for (var i = 0; i < quote\_t525.length; i++) {
for (var j = 0; j < quote\_t525[i].getElementsByClassName('t525\_\_col t-col t-col\_6').length; j++) {
quote\_t525[i].getElementsByClassName('t525\_\_col t-col t-col\_6')[j].classList = 't-col t-col\_8 t-prefix\_2';
}
} | https://habr.com/ru/post/533504/ | null | ru | null |
# ELFийские трюки в Go
В этой заметке мы научимся получать машинный код Go функции прямо в рантайме, распечатаем его с помощью дизассемблера и по пути узнаем несколько фокусов вроде получения адреса функции без её вызова.
**Предупреждение**: ничему полезному эта мини-статья вас не научит.
Function value в Go
===================
Для начала определимся, что такое Go функция и зачем нам нужно понятие **function value**.
Лучше всего это объясняет документ [Go 1.1 Function Calls](https://golang.org/s/go11func). Документ не новый, но большая часть информации в нём всё ещё актуальна.
На самом низком уровне это всегда указатель на исполняемый код, но когда мы используем анонимные функции/замыкания или передаём функцию как `interface{}`, этот указатель скрывается внутри некоторой структуры.
Само по себе имя функции не является выражением, поэтому, такой код не работает:
```
// https://play.golang.org/p/wXeVLU7nLPs
package main
func add1(x int) int { return 1 }
func main() {
addr := &add1
println(addr)
}
```
> `compile: cannot take the address of add1`
Но при этом мы можем получить `function value` через то же имя функции:
```
// https://play.golang.org/p/oWqv_FQq4hy
package main
func add1(x int) int { return 1 }
func main() {
f := add1 // <--------
addr := &f
println(addr)
}
```
Этот код запускается, но печатать он будет адрес локальной переменной на стеке, что не совсем то, чего мы хотели. Но, как было сказано выше, адрес функции всё ещё там, просто нужно знать, как к нему доступиться.
Пакет [`reflect`](https://golang.org/pkg/reflect/) зависит от этой детали реализации, чтобы успешно выполнять [`reflect.Value.Call()`](https://golang.org/pkg/reflect/#Value.Call). [Там же (reflect/makefunc.go)](https://github.com/golang/go/blob/dcd3b2c173b77d93be1c391e3b5f932e0779fb1f/src/reflect/makefunc.go#L56-L60) можно подсмотреть следующий шаг для получения адреса функции:
```
dummy := makeFuncStub
code := **(**uintptr)(unsafe.Pointer(&dummy))
```
Код выше демонстрирует базовую идею, которую можно доработать до функции:
```
// funcAddr returns function value fn executable code address.
func funcAddr(fn interface{}) uintptr {
// emptyInterface is the header for an interface{} value.
type emptyInterface struct {
typ uintptr
value *uintptr
}
e := (*emptyInterface)(unsafe.Pointer(&fn))
return *e.value
}
```
Получить адрес функции `add1` можно с помощью вызова `funcAddr(add1)`.
Получение блока машинного кода функции
======================================
Теперь, когда у нас есть адрес начала машинного кода функции, хотелось бы получить весь машинный код функции. Здесь требуется уметь определять, где же код текущей функции заканчивается.
Если бы архитектура x86 имела инструкции фиксированной длины, было бы не так сложно и нам могли бы помочь несколько эвристик, среди которых:
* Как правило, в конце кода функций есть отбивка из [`INT3`](https://en.wikipedia.org/wiki/INT_(x86_instruction)#INT3) инструкций. Это хороший маркер конца кода функции, но он может отсутствовать.
* У функций с ненулевым фреймом для стека есть пролог, который проверяет, нужно ли расширять этот стек. Если да, то выполняется прыжок на код сразу за кодом функции, а затем прыжок на старт функции. Интересующий нас код будет посередине.
Но вам потребуется честно декодировать инструкции, потому что побайтовый проход может найти байт `INT3` внутри другой инструкции. Сделать вычисление длины инструкции для её пропуска тоже не так легко, [потому что это x86, детка](https://stackoverflow.com/questions/45801447/x86-assembly-how-to-calculate-instruction-opcodes-length-in-bytes).
Адрес функции в контексте пакета [`runtime`](https://golang.org/pkg/runtime) иногда называют `PC`, чтобы подчеркнуть возможность использовать адрес где-то внутри функции, а не только точку входа функции. Результат `funcAddr` можно использовать как аргумент функции [`runtime.FuncForPC()`](https://golang.org/pkg/runtime/#FuncForPC), для получения [`runtime.Func`](https://golang.org/pkg/runtime/#Func) без вызова самой функции. Через небезопасные новогодние преобразования мы можем получить доступ к [`runtime._func`](https://play.golang.org/p/lQxxK36ZXru), что познавательно, но не очень полезно: там нет информации о размере блока кода функции.
Похоже, без помощи [ELFов](https://golang.org/pkg/debug/elf/) мы не справимся.
> Для платформ, где исполняемые файлы имеют иной формат, большая часть статьи останется релевантна, но вам нужно будет использовать не [`debug/elf`](https://golang.org/pkg/debug/elf/), а другой пакет из [`debug`](https://golang.org/pkg/debug/).
ELF, который прячется в вашей программе
=======================================
Информация, которая нам нужна, уже содержится в метаданных [ELF](https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#File_header) файла.
Через [`os.Args[0]`](https://golang.org/pkg/os/#pkg-variables) мы можем получить доступ к самому исполняемому файлу, а уже из него получить таблицу символов.
```
func readELF() (*elf.File, error) {
f, err := os.Open(os.Args[0])
if err != nil {
return nil, fmt.Errorf("open argv[0]: %w", err)
}
return elf.NewFile(f)
}
```
Поиск символа внутри [`elf.File`](https://golang.org/pkg/debug/elf/#File)
=========================================================================
Получить все символы можно с помощью метода [`File.Symbols()`](https://golang.org/pkg/debug/elf/#File.Symbols). Этот метод возвращает [`[]elf.Symbol`](https://golang.org/pkg/debug/elf/#Symbol), которые содержат поле `Symbol.Size` — это и есть искомый нами "размер функции". Поле `Symbol.Value` должно совпадать со значением, возвращаемым `funcAddr`.
Искать нужный символ можно либо по адресу (`Symbol.Value`), либо по имени (`Symbol.Name`). Если бы символы были сортированы по имени, можно было бы применить [`sort.Search()`](https://golang.org/pkg/sort/#Search), но это не так:
> The symbols will be listed in the order they appear in file.
Если нужно часто находить символы в таблице, то следует построить дополнительный индекс, например, через `map[string]*elf.Symbol` или `map[uintptr]*elf.Symbol`.
Поскольку мы уже умеем получать адрес функции по её значению, будем делать поиск по нему:
```
func elfLookup(f *elf.File, value uint64) *elf.Symbol {
symbols, err := f.Symbols()
if err != nil {
return nil
}
for _, sym := range symbols {
if sym.Value == value {
return &sym
}
}
return nil
}
```
> **Примечание**: для работы этого подхода, нам нужна таблица символов. Если бинарник собран с '`-ldflags "-s"`', то `elfLookup()` всегда будет возвращать `nil`. Если вы будете запускать программу через `go run` вы можете столкнуться с той же проблемой. Для примеров из статьи рекомендуется делать '`go build`' или '`go install`' для получения исполняемых файлов.
Получение машинного кода функции
================================
Зная диапазон адресов, в котором находится исполняемый код, остаётся только вытащить его в виде `[]byte` для удобной обработки.
```
func funcCode(addr uintptr) ([]byte, error) {
elffile, err := readELF()
if err != nil {
return nil, fmt.Errorf("read elf: %w", err)
}
sym := elfLookup(elffile, uint64(addr))
if sym == nil {
return nil, fmt.Errorf("can't lookup symbol for %x", addr)
}
code := *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{
Data: addr,
Len: int(sym.Size),
Cap: int(sym.Size),
}))
return code, nil
}
```
Этот код намеренно упрощен для демонстрации. Не стоит каждый раз читать `ELF` и выполнять линейный поиск по его таблице.
Результатом работы функции `funcCode()` является слайс с байтами машинного кода функции. На вход ей стоит подавать результат вызова `funcAddr()`.
```
code, err := funcCode(funcAddr(add1))
if err != nil {
log.Panicf("can't get function code: %v", err)
}
fmt.Printf("% x\n", code)
// => 48 8b 44 24 08 48 ff c0 48 89 44 24 10 c3
```
Дизассемблирование машинного кода
=================================
Для того, чтобы проще читать машинный код, мы воспользуемся дизассемблером.
Я больше всего знаком с проектами [zydis](https://github.com/zyantific/zydis) и [Intel XED](https://github.com/intelxed/xed), поэтому в первую очередь мой выбор падает на них.
Для Go можно взять биндинг [go-zydis](https://github.com/jpap/go-zydis), который достаточно хорош и прост в установке для нашей задачи.
Опишем абстракцию "обхода машинных инструкций", с помощью которой потом можно реализовать остальные операции:
```
func walkDisasm(code []byte, visit func(*zydis.DecodedInstruction) error) error {
dec := zydis.NewDecoder(zydis.MachineMode64, zydis.AddressWidth64)
buf := code
for len(buf) > 0 {
instr, err := dec.Decode(buf)
if err != nil {
return err
}
if err := visit(instr); err != nil {
return err
}
buf = buf[int(instr.Length):]
}
return nil
}
```
Эта функция принимает на вход слайс машинного кода и вызывает callback-функцию для каждой декодируемой инструкции.
На основе неё мы можем написать нужную нам `printDisasm`:
```
func printDisasm(code []byte) error {
const ZYDIS_RUNTIME_ADDRESS_NONE = math.MaxUint64
formatter, err := zydis.NewFormatter(zydis.FormatterStyleIntel)
if err != nil {
return err
}
return walkDisasm(code, func(instr *zydis.DecodedInstruction) error {
s, err := formatter.FormatInstruction(instr, ZYDIS_RUNTIME_ADDRESS_NONE)
if err != nil {
return err
}
fmt.Println(s)
return nil
})
}
```
Если мы запустим `printDisasm` на коде функции `add1`, то получим долгожданный результат:
```
mov rax, [rsp+0x08]
inc rax
mov [rsp+0x10], rax
ret
```
Валидация результата
--------------------
Теперь мы попробуем убедиться в том, что ассемблерный код, полученный в предыдущей секции, является корректным.
Поскольку у нас уже есть собранный бинарник, можно использовать поставляемый с Go `objdump`:
```
$ go tool objdump -s 'add1' exe
TEXT main.add1(SB) example.go
example.go:15 0x4bb760 488b442408 MOVQ 0x8(SP), AX
example.go:15 0x4bb765 48ffc0 INCQ AX
example.go:15 0x4bb768 4889442410 MOVQ AX, 0x10(SP)
example.go:15 0x4bb76d c3 RET
```
Всё сходится, только синтаксис немного разный, что ожидаемо.
Method expressions
==================
Если нам нужно совершить аналогичное с методами, то вместо имени функции мы будем использовать [method expression](https://golang.org/ref/spec#Method_expressions).
Допустим, наш `add1` — это на самом деле не функция, а метод типа `adder`:
```
type adder struct{}
func (adder) add1(x int) int { return x + 2 }
```
Тогда вызов получения адреса функции будет выглядеть как `funcAddr(adder.add1)`.
Заключение
==========
Пришёл я к этим вещам не случайно и, возможно, в одной из следующих статей расскажу, как планировалось использовать все эти механизмы. А пока предлагаю относиться к этой заметке как к поверхностному описанию того, как `runtime` и `reflect` смотрят на наши Go функции через function value.
Список использованных ресурсов:
* [Go 1.1 Function Calls](https://golang.org/s/go11func)
* [Analyzing Golang Executables](https://www.pnfsoftware.com/blog/analyzing-golang-executables/)
* [Go "internal ABI" design](https://go.googlesource.com/proposal/+/master/design/27539-internal-abi.md) | https://habr.com/ru/post/482392/ | null | ru | null |
# Неизменяемые объекты в PHP
В этой короткой статье мы рассмотрим, что собой представляют неизменяемые объекты и почему нам следует их использовать. Неизменяемыми называются объекты, чьё состояние остаётся постоянным с момента их создания. Обычно такие объекты очень просты. Наверняка вы уже знакомы с типами enum или примитивами наподобие `DateTimeImmutable`. Ниже мы увидим, что если делать простые объекты неизменяемыми, то это поможет избежать определённых ошибок и сэкономить немало времени.
При реализации неизменяемых объектов необходимо:
* Объявить класс как `final`, чтобы его нельзя было переопределить при добавлении методов, изменяющих внутреннее состояние.
* Объявить свойства как `private`, чтобы опять же их нельзя было изменить.
* Избегать сеттеров и использовать конструктор для задания параметров.
* Не хранить ссылки на изменяемые объекты или коллекции. Если вы внутри неизменяемого объекта храните коллекцию, то она тоже должна быть неизменяемой.
* Проверять, что, если вам нужно модифицировать неизменяемый объект, вы делали его копию, а не переиспользовали существующий.
Если в одном месте изменить объект, то в другом могут проявиться нежелательные побочные эффекты, которые с трудом поддаются отладке. Это может произойти где угодно: в сторонних библиотеках, в структурах языка и т. д. Использование неизменяемых объектов позволит избежать подобных неприятностей.
Итак, в чём заключаются преимущества правильно реализованных неизменяемых объектов:
* Состояние программы становится более предсказуемым, потому что меньшее количество объектов меняют собственные состояния.
* Благодаря тому что становятся невозможны ситуации с разделяемыми ссылками (shared references), упрощается отладка.
* Неизменяемые объекты удобно применять для создания параллельно исполняемых программ (в этой статье не рассматривается).
Примечание: неизменяемость всё же можно нарушить с помощью «отражений», сериализации/десериализации, биндинга анонимных функций или магических методов. Однако всё это довольно непросто реализовать и вряд ли будет использовано случайно.
Перейдём к примеру неизменяемого объекта:
```
php
final class Address
{
private $city;
private $house;
private $flat;
public function __construct($city, $house, $flat)
{
$this-city = (string)$city;
$this->house = (string)$house;
$this->flat = (string)$flat;
}
public function getCity()
{
return $this->city;
}
public function getHouse()
{
return $this->house;
}
public function getFlat()
{
return $this->flat;
}
}
```
После того как создан, этот объект уже не меняет состояние, поэтому его можно считать неизменяемым.
Пример
======
Давайте теперь разберём ситуацию с переводом денег на счетах, в которой отсутствие неизменяемости приводит к ошибочным результатам. У нас есть класс `Money`, который представляет собой некую сумму денег.
```
php
class Money
{
private $amount;
public function getAmount()
{
return $this-amount;
}
public function add($amount)
{
$this->amount += $amount;
return $this;
}
}
```
Используем его следующим образом:
```
php
$userAmount = Money::USD(2);
/**
* Марк собирается отправить Алексу 2 доллара. Комиссия составляет 3%,
* и мы прибавляем её к основному переводу.
*/
$processedAmount = $userAmount-add($userAmount->getAmount() * 0.03);
/**
* Получаем с карты Марка для последующего перевода 2 доллара + 3% комиссии
*/
$markCard->withdraw($processedAmount);
/**
* Отправляем Алексу 2 доллара
*/
$alexCard->deposit($userAmount);
```
Примечание: тип float здесь применён только для простоты примера. В реальной жизни для выполнения операции с необходимой точностью вам нужно будет использовать расширение bcmath или какие-то другие библиотеки вендоров.
Всё должно быть в порядке. Но в связи с тем, что класс `Money` изменяемый, вместо двух долларов Алекс получит 2 доллара и 6 центов (комиссия 3%). Причина в том, что `$userAmount` и `$processedAmount` ссылаются на один и тот же объект. В данном случае рекомендуется применить неизменяемый объект.
Вместо модифицирования существующего объекта необходимо создать новый либо сделать копию существующего объекта. Давайте изменим приведённый код, добавив в него создание другого объекта:
```
php
final class Money
{
private $amount;
public function getAmount()
{
return $this-amount;
}
}
```
```
php
$userAmount = Money::USD(2);
$commission = $userAmount-val() * 3 / 100;
$processedAmount = Money::USD($userAmount->getAmount() + $commission);
$markCard->withdraw($processedAmount);
$alexCard->deposit($userAmount);
```
Это хорошо работает для простых объектов, но в случае сложной инициализации лучше начать с копирования существующего объекта:
```
php
final class Money
{
private $amount;
public function getAmount()
{
return $this-amount;
}
public function add($amount)
{
return new self($this->amount + $amount, $this->currency);
}
}
```
Используется он точно так же:
```
php
$userAmount = Money::USD(2);
/**
* Марк собирается отправить Алексу 2 доллара. Комиссия составляет 3%,
* и мы прибавляем её к основному переводу.
*/
$processedAmount = $userAmount-add($userAmount->val() * 0.03);
/**
* Получаем с карты Марка для последующего перевода 2 доллара + 3% комиссии
*/
$markCard->withdraw($processedAmount);
/**
* Отправляем Алексу 2 доллара
*/
$alexCard->deposit($userAmount);
```
В этот раз Алекс получит свои два доллара без комиссии, а с Марка правильно спишут эту сумму и комиссию.
Случайная изменяемость
======================
При реализации изменяемых объектов программисты могут допускать ошибки, из-за которых объекты становятся изменяемыми. Очень важно это знать и понимать.
### Утечка внутренней ссылки на объект
У нас есть изменяемый класс, и мы хотим, чтобы его использовал неизменяемый объект.
```
php
class MutableX
{
protected $y;
public function setY($y)
{
$this-y = $y;
}
}
class Immutable
{
protected $x;
public function __construct($x)
{
$this->x = $x;
}
public function getX()
{
return $this->x;
}
}
```
У неизменяемого класса есть только геттеры, а единственное свойство присвоено конструктором. На первый взгляд, всё в порядке, верно? Теперь давайте используем это:
```
php
$immutable = new Immutable(new MutableX());
var_dump(md5(serialize($immutable))); // f48ac85e653586b6a972251a85dd6268
$immutable-getX();
var_dump(md5(serialize($immutable))); // f48ac85e653586b6a972251a85dd6268
```
Объект остался прежним, состояние не изменилось. Прекрасно!
Теперь немного поиграем с Х:
```
php
$immutable-getX()->setY(5);
var_dump(md5(serialize($immutable))); // 8d390a0505c85aea084c8c0026c1621e
```
Состояние неизменяемого объекта изменилось, так что он на самом деле оказался изменяемым, хотя всё говорило об обратном. Это произошло потому, что при реализации было проигнорировано правило «не хранить ссылки на изменяемые объекты», приведённое в начале этой статьи. Запомните: *неизменяемые объекты должны содержать только неизменяемые данные или объекты.*
### Коллекции
Использование коллекций — явление распространённое. А что, если вместо конструирования неизменяемого объекта с другим объектом мы сконструируем его с коллекцией объектов?
Для начала давайте реализуем коллекцию:
```
php
class Collection
{
protected $elements = [];
public function __construct(array $elements)
{
$this-elements = $elements;
}
public function add($element)
{
$this->elements[] = $element;
}
public function get($key)
{
return isset($this->elements[$key]) ? $this->elements[$key] : null ;
}
}
```
Теперь воспользуемся этим:
```
php
$immutable = new Immutable(new Collection([new XMutable(), new XMutable()]));
var_dump(md5(serialize($immutable))); // 9d095d565a96740e175ae07f1192930f
$immutable-getX();
var_dump(md5(serialize($immutable))); // 9d095d565a96740e175ae07f1192930f
$immutable->getX()->get(0)->setY(5);
var_dump(md5(serialize($immutable))); // 803b801abfa2a9882073eed4efe72fa0
```
Как мы уже знаем, лучше не держать изменяемые объекты внутри неизменяемого. Поэтому заменим изменяемые объекты скалярами.
```
php
$immutable = new Immutable(new Collection([1, 2]));
var_dump(md5(serialize($immutable))); // 24f1de7dc42cfa14ff46239b0274d54d
$immutable-getX();
var_dump(md5(serialize($immutable))); // 24f1de7dc42cfa14ff46239b0274d54d
$immutable->getX()->add(10);
var_dump(md5(serialize($immutable))); // 70c0a32d7c82a9f52f9f2b2731fdbd7f
```
Поскольку наша коллекция предоставляет метод, позволяющий добавить новые элементы, мы можем косвенно менять состояние неизменяемого объекта. Так что при работе с коллекцией внутри неизменяемого объекта удостоверьтесь, что она сама не является изменяемой. Например, убедитесь, что она содержит только неизменяемые данные. И что нет методов, которые добавляют новые элементы, убирают их или иным способом изменяют состояние коллекции.
### Наследование
Другая распространённая ситуация связана с наследованием. Мы знаем, что нужно:
* использовать только геттеры,
* создавать экземпляры через конструктор,
* внутри объектов неизменяемых объектов хранить только неизменяемые данные.
Давайте модифицируем класс `Immutable`, чтобы он принимал только `Immutable`-объекты.
```
php
class Immutable
{
protected $x;
public function __construct(Immutable $x)
{
$this-x = $x;
}
public function getX()
{
return $this->x;
}
}
```
Выглядит неплохо… пока кто-то не расширит ваш класс:
```
php
class Mutant extends Immutable
{
public function __construct()
{
}
public function getX()
{
return rand(1, 1000000);
}
public function setX($x)
{
$this-x = $x;
}
}
```
```
php
$mutant = new Mutant();
$immutable = new Immutable($mutant);
var_dump(md5(serialize($immutable-getX()->getX()))); // c52903b4f0d531b34390c281c400abad
var_dump(md5(serialize($immutable->getX()->getX()))); // 6c0538892dc1010ba9b7458622c2d21d
var_dump(md5(serialize($immutable->getX()->getX()))); // ef2c2964dbc2f378bd4802813756fa7d
var_dump(md5(serialize($immutable->getX()->getX()))); // 143ecd4d85771ee134409fd62490f295
```
Всё опять пошло не так. Вот поэтому неизменяемые объекты должны быть объявлены как `final`, чтобы их нельзя было расширить.
Заключение
==========
Мы узнали, что такое неизменяемый объект, где он может быть полезен и какие правила необходимо соблюдать при его реализации:
* Объявить класс как `final`, чтобы его нельзя было переопределить при добавлении методов, изменяющих внутреннее состояние.
* Объявить свойства как `private`, чтобы опять же их нельзя было изменить.
* Избегать сеттеров и использовать конструктор для задания параметров.
* Не хранить ссылки на изменяемые объекты или коллекции. Если вы внутри неизменяемого объекта храните коллекцию, то она тоже должна быть неизменяемой.
* Проверять, что, если вам нужно модифицировать неизменяемый объект, вы делали его копию, а не переиспользовали существующий. | https://habr.com/ru/post/301004/ | null | ru | null |
# Три бага в драйвере Go для MySQL
Так как нас не устраивала скорость и надежность исходной имплементации на Ruby, в последние несколько лет мы постепенно выводили критический функционал из нашего Rails-монолита GitHub.com и переписывали часть кода на Go. Например, на Github Satellite в прошлом году мы анонсировали — и имплементировали — возможность «более контролируемой авторизации» с использованием сервиса `authzd`.
Работа с `authzd` оказалась очень интересной и значимой для нас задачей, поскольку это был наш первый сервис на Go для работы с чтением данных из баз MySQL на продакшне в ходе веб-реквеста. У нас имелся опыт развертывания других работающих с базами MySQL-сервисов на Go, но при этом они были либо службами внутреннего контроля (наша кластерная поисковая система `manticore`), либо асинхронными пакетными заданиями (оркестратор резервного копирования Git `gitbackups`). Требования к производительности и надежности `authzd` отличаются от них повышенной строгостью, поскольку обычный реквест к Rails-монолиту вызывает этот сервис неоднократно.
Кроме того, проблемы с большими задержками при открытии TCP соединений на наших Kubernetes кластерах особенно влияли на пул соединений Go MySQL драйвера. Это добавляло работы, ведь именно на Kubernetes мы и развернули `authzd`. Одним из самых опасных самообманов программиста в этом отношении является вера в надежность сети, поскольку да, в большинстве случаев сеть *действительно* надежна… но как только она начинает тормозить или барахлить, нас настигают базовые проблемы таких же базовых библиотек, и все начинает рушиться.
Так чего нам в итоге стоила подготовка `authzd` к обработке всего нашего рабочего трафика через SQL, да еще и в соответствии с нашими целями доступности?
Падение
-------
Более двух лет назад я впервые обнаружил и зарепортил самый неуловимый из всех известных багов MySQL, `"Invalid connection (unexpected EOF)"`. Впервые мы столкнулись с ним в ходе развертывания в продакшн исходных версий нашего оркестратора резервного копирования (`gitbackups`), и мы вынуждено обошли проблему правкой кода приложения, поскольку команда сопровождающих MySQL драйвер никак не могла определиться, как поправить баг на своей стороне. Этот баг вновь проявил себя в прошлом году, как раз во время первого развертывания `authzd` в продакшн: частота ошибочных откликов `authzd` резко возросла на фоне сотен и сотен ошибок `Invalid connection` в минуту. Такое поведение системы заставило меня вновь взяться за баг, и я наконец-то разработал не требующий каких-либо изменений в коде приложения фикс этой проблемы. Давайте посмотрим на него повнимательней.
### Решение проблемы
Задача Go SQL драйвера — предоставлять «SQL соединение», обычный примитив к идущему в стандартной библиотеке Go пакету `database/sql`. Драйвер предоставляет соединения с хранением состояния, и по определению на всех крупных SQL серверах, включая MySQL и Postrgres, эти соединения не могут вестись параллельно. Пакет `database/sql` со своей стороны контролирует доступ и длительность таких соединений и является входной точкой для всех возможных проводимых над базой данных SQL операций, а его структура `DB` — это абстракция над предоставляемым драйвером пулом отдельных соединений. Таким образом, обращение к методам вида `(*DB).Query` или `(*DB).Exec` требует сложной логики: для начала необходимо выбрать из пула соединений активное, но свободное соединение, или вызвать основной драйвер для создания нового соединения при занятости всех других, а затем выполнить команду или запрос и вернуть соединения обратно в пул либо сбросить его при уже полном пуле.
Каждый раз, когда при работе с `gitbackups` и `authzd` мы забирали соединение из пула и создавали запрос, у нас проявлялась ошибка «unexpected EOF», и, по данным логов, MySQL сервер закрывал превышающие свое время ожидания соединения за слишком долгое присутствие в пуле Go `sql.(*DB)`. При этом, ак как мы хотим быть уверены в отсутствии слишком большого числа соединений в любой момент, время ожидания наших MySQL кластеров на продакшне жестко ограничено — не более 30 секунд. Тем не менее, постоянные оповещения об ошибках нас порядком озадачивали — и являлись серьезной проблемой, ведь из-за них постоянно падал наш сервис.
В прерывании TCP соединений нет ничего необычного, и с помощью специальной имплементации драйвера пакет `database/sql` умеет в любой момент времени справляться с прерыванием в любом из сотен одновременных соединений из пула `(*DB)`. Будь то закрытие, плохой пакет или что-нибудь не то с SQL соединением, драйвер должен вернуть `driver.ErrBadConn` на следующий вызов любого из методов в соединении, как только он заметит, что соединение драйвера стало нездоровым по какой-либо из множества возможных причин.
`ErrBadConn` — это такой волшебный сигнал, который указывает пакету `database/sql` на неактуальность соединения с сохранением состояния: если соединение было в пуле, его необходимо оттуда убрать, а если его уже выбрали для выполнения запроса, необходимо отбросить текущее соединение и выбрать либо создать новое. Учитывая такое поведение, мы не ожидаем от `(*DB).Query` падения из-за ошибки «invalid connection», поскольку с возвратом `driver.ErrBadConn` запрос незаметно для пользователя повторится на новом соединении.
Так что же приводит ко всем этим ошибкам «invalid connection» в `authzd`?
Между протоколом TCP и протоколом MySQL поверх него есть очень тонкое несоответствие: в полностью двустороннем TCP соединении данные свободно передаются в обоих направлениях независимо друг от друга, но стоит протоколу MySQL оказаться в командной фазе, клиентская сторона получает над ним полный контроль. Это происходит из-за передачи MySQL сервером пакета MySQL клиенту только в ответ на пакет от клиента. Когда сервер закрывает активное соединение в командной фазе, например, по времени ожидания или по вине активно подрезающих соединения процессов вида `pt-kill`, такая ситуация приводит к проблемам. Давайте посмотрим на диаграмму сети:
*Рисунок 1: Диаграмма сети демонстрирует передачу пакетов между MySQL сервером и MySQL клиентом.*
На этой визуализации бага мы можем наблюдать стандартное TCP рукопожатие и следующую за ним пару запроса и ответа на уровне MySQL. После длительного перерыва без новых запросов к MySQL серверу на стороне сервера происходит таймаут, и сервер закрывает сокет активным `close`. Когда TCP сервер закрывает сокет, его ядро отсылает клиенту пару `[FIN, ACK]`, что означает завершение передачи данных сервером. Ядро клиента подтверждает `[FIN, ACK]` ответным `[ACK]`, но еще не закрывает свою сторону соединения — под этим мы и подразумеваем «полностью двустороннее соединение». Сторона записи соединения «клиент -> сервер» независима и должна быть явно закрыта вызовом `close` со стороны клиента.
Клиент проводит `read` чтение с сервера, и как только он получает `[SYN, ACK]`, следующее чтение возвращает ошибку `EOF`, поскольку ядро в курсе, что сервер не станет больше записывать данные в это соединение, поэтому такая ситуация обычно не создает проблем в большинстве протоколов поверх TCP. Но, как мы уже отметили ранее, клиент считывает данные с сервера только *после* отправки запроса, поскольку сервер высылает данные только в ответ на запрос от клиента, ведь как только MySQL соединение оказывается в своей командной фазе, MySQL протокол управляется со стороны клиента.
Результат такого соединения хорошо виден на диаграмме. После периода ожидания мы успешно высылаем серверу `write` реквест, так как наша сторона соединения все еще открыта. В ответ сервер отправляет пакет `[RST]`, ведь сервер уже закрыт, просто мы этого еще не знаем. После чего клиент пытается прочесть ответ от MySQL сервера, получает ошибку `EOF` и слишком поздно осознает, что соединение прервано.
Теперь мы знаем причину прерывания наших MySQL соединений (они становятся неактуальны), но не причину последующих падений приложения. Почему при прерывании наш MySQL драйвер не возвращает `driver.ErrBadConn`? И почему он не позволяет `database/sql` переотправить запрос через новое соединение? К несчастью, потому что открытая переотправка запроса небезопасна.
События, как на диаграмме выше, происходят слишком уж часто, наши MySQL кластеры на продакшне фиксируют тысячи подобных случаев в минуту, чаще всего в наименее загруженные часы, когда наши сервисы простаивают и достигают таймаутов. Но соединения могут прерываться далеко не только по таймаутам.
Что будет, если в ходе здорового соединения мы проведем `UPDATE`, MySQL выполнит его, а затем наша сеть отключится до того, как сервер успеет нам ответить? После актуального запроса на запись Go MySQL драйвер тоже получит в ответ ошибку `EOF`, но если он вернет `driver.ErrBadConn`, то `database/sql` запустит `UPDATE` на новом соединении. А ведь это повреждение данных! Казалось бы, мы знаем, что в типичном случае (когда MySQL убивает наше соединение) переотправлять запросы можно без опаски.Ошибки при записи запроса в сеть не было, и мы знаем, что MySQL не получил его, не говоря уже о том, чтобы выполнить. Но в такой ситуации надо ожидать худшего и исходить из того, что запрос все же достиг сервера. И вот поэтому возвращать `driver.ErrBadConn` небезопасно. В какой же мерзкой ситуации мы оказались!
Как нам с этим справиться? Самым простым решением — мы им в свое время воспользовались для `gitbackups` — было вызвать на нашем клиенте `(*DB).SetConnMaxLifetime` и задать порог длительности для таких соединений ниже таймаута ожидания MySQL кластера. Подобный метод далек от идеала: `SetConnMaxLifetime` задает максимальную длительность *в целом*, а не максимальную длительность *ожидания*. Из-за этого `database/sql` будет прерывать соединения строго по таймеру, вне зависимости от статуса активности соединений и готовности сервера прерывать их по таймауту. Не все серверы имплементируют концепт таймаута по ожиданию, поэтому в пакете `database/sql` нет API для «максимальной длительности ожидания». О, муки абстракций… На практике же такое решение работает нормально, если не брать во внимание постоянные сетевые переподключения и случаи, когда MySQL сервер активно обрезает соединения — этот метод их не обнаруживает.
Оптимальным вариантом было бы проверять состояние здоровья соединения после того, как оно взято из пула, но до того, как на него отправят какой-либо `write` реквест. К несчастью, до появления интерфейса [`SessionResetter`](https://golang.org/pkg/database/sql/driver/#SessionResetter) в Go 1.10 узнать, когда соединение возвращается в пул, было невозможно, из-за чего баг так и висел без подобающего фикса почти два года.
Проверку состояния здоровья такого соединения можно провести двумя методами: на MySQL уровне и на TCP уровне. Проверка на MySQL уровне включается в себя отправку пакета `PING` и ожидание ответа, и так как `PING` не проводит никаких операций записи в MySQL (хотелось бы надеяться), в этом случае можно без опаски возвращать `driver.ErrBadConn`. С другой стороны, явным недостатком такого метода является добавление случайной задержки к первой операции на соединение из пула. В итоге мы выбрали проверку на закрытие MySQL сервером своего соединения на NCP уровне, поскольку в Go приложении соединения довольно часто добавляются и вынимаются из пула, и дополнительная задержка другого метода немного напрягает.
Проверка на уровне TCP очень проста и нетребовательна к ресурсам: нам нужно только провести неблокирующее чтение нашего соединения до попытки внесения какой-либо записи. Если соединение все еще открыто, мы сразу получим ошибку `EWOULDBLOCK`, поскольку данных на чтение (пока еще) нет, а если сервер закрыл свою сторону соединения, то нам тут же вернется уже знакомый ответ `EOF`. К тому же все сокеты в Go программе уже выставлены в неблокирующий режим. Но не дайте обмануть себя элегантной абстракцией Goroutines: под ее красивым фасадом Go планировщик использует асинхронный цикл событий, чтобы усыпить Goroutines и пробудить, только когда у них появятся данные для чтения. (Необычно, не правда ли?) К несчастью, мы не можем проводить неблокирующие чтения через методы вида `net.Conn.Read`, иначе планировщик нас тут же усыпит (опять же, элегантные абстракции Goroutines). Корректный интерфейс для проведения неблокирующего чтения впервые появился в Go 1.9: [`(*TCPConn).SyscallConn`](https://golang.org/pkg/net/#TCPConn.SyscallConn) дает нам доступ к основному дескриптору файла, и мы можем напрямую использовать системный вызов `read`.
Вооружившись новым API, [я сумел реализовать проверку состояния здоровья соединения, которая решала проблему «устаревших соединений»](https://github.com/go-sql-driver/mysql/pull/934) с менее чем пятью микросекундами пинга. Неблокирующие чтения действительно очень быстры, ведь в этом-то и есть их суть— не блокировать.
После ввода решения в продакшн все скачки «Invalid Connection» тут же пропали, и наш сервис впервые вышел на девять баллов по показателю доступности.
*Рисунок 2: Скачки и повторные попытки со стороны клиента после ввода `authzd` в продакшн.*
### Советы в продакшн
* Если ваш MySQL сервер использует таймауты по ожиданию или активно обрезает соединения, вашим сервисам нет нужды вызывать `(*DB).SetConnMaxLifetime`, поскольку драйвер может изящно обнаруживать и повторно пробовать устаревшие соединения. Добавление максимума длительности соединений будет постоянно удалять и создавать здоровые соединения, заставляя систему делать лишние телодвижения.
* Настройка вашего `sql.(*DB)` пула (`(*DB).SetMaxIdleConns` и `(*DB).SetMaxOpenConns)` со значениями, которые поддерживают трафик пиковых часов нагрузки на ваш сервис, станет хорошей моделью по контролю высокопроизводительного доступа к MySQL. Также стоит проверить, что в остальные часы ваш MySQL сервер активно подрезает ожидающие соединения: он будет удалять их и пересоздавать при необходимости.
Таймаут
-------
Когда мы добавляем сервисы наподобие `authzd` зависимостью в стандартный маршрут реквестов нашего монолита, его время отклика добавляется к общему времени отклика всех реквестов нашего приложения или реквестов с тем или иным методом авторизации — а их у нас очень много. Слишком долгое время обработки запросов `authzd` может привести к массовой деградации производительности, поэтому критически важно гарантировать выполнение запросов в рамках выделенного им времени.
Со стороны Rails нам необходимо быть очень осторожными с тем, как мы проводим RPC реквесты к сервису и как мы отслеживаем их по времени. С серверной стороны Go это означает лишь одно — `Context`. API `context` был доступен отдельной библиотекой уже несколько лет, но в стандартную библиотеку его ввели только в Go 1.7. Идея этого пакета проста: сделать ваш сервис осведомленным об обнулении реквестов через передачу `context.Context` всем вовлеченным в жизненный цикл реквестов вашего сервиса функциям. Каждый входящий HTTP реквест предоставляет объект `Context`, который обнуляется в случае, если клиент рано разъединился, что позволит вам использовать ранние обнуления и таймауты реквестов через единый API. Кроме того, вы можете расширить свой `Context` дедлайном.
Ответственная за разработку нового сервиса команда инженеров проделала шикарную работу по обеспечению всех методов в `authzd` передачей `Context`, включая методы, которые направляют запросы к MySQL. Так как это самая дорогостоящая в плане ресурсов часть жизненного цикла наших реквестов, фундаментально важно передавать `Context` методам запросов `database/sql`. Мы должны убедиться в получении этими методами `Context` для быстрого обнуления наших MySQL запросов на случай их слишком долгой обработки.
Тем не менее, на практике все выглядело так, будто `authzd` не брал обнуление запросов или тайматуы в расчет:
*Рисунок 3: Время внутрисервисного отклика на развертывание `authzd`. Таймаут распознавателя был установлен на 1000мс — это можно понять по красной пунктирной линии, но уж точно не по рандомным скачкам, достигающим добрых 5000мс.*
Одного взгляда на эти метрики достаточно чтобы понять: пусть мы и успешно распространяем `Context` наших реквестов через весь код приложения, в жизненном цикле некоторых из них есть места, где обнуление попросту игнорируется. Поиск таких мест через просмотр кода может оказаться очень трудоемким процессом, даже если мы небезосновательно подозреваем драйвер Go MySQL, поскольку больше никто в нашем сервисе не совершает внешние запросы. Желая обнаружить, где блокируется код, в этой ситуации я за несколько попыток поймал актуальный след стека от хоста продакшна, и все стало очевидно, как только я поймал тот, что блокировался на вызове `QueryContext`:
```
0 0x00000000007704cb in net.(*sysDialer).doDialTCP
at /usr/local/go/src/net/tcpsock_posix.go:64
1 0x000000000077041a in net.(*sysDialer).dialTCP
at /usr/local/go/src/net/tcpsock_posix.go:61
2 0x00000000007374de in net.(*sysDialer).dialSingle
at /usr/local/go/src/net/dial.go:571
3 0x0000000000736d03 in net.(*sysDialer).dialSerial
at /usr/local/go/src/net/dial.go:539
4 0x00000000007355ad in net.(*Dialer).DialContext
at /usr/local/go/src/net/dial.go:417
5 0x000000000073472c in net.(*Dialer).Dial
at /usr/local/go/src/net/dial.go:340
6 0x00000000008fe651 in github.com/github/authzd/vendor/github.com/go-sql-driver/mysql.MySQLDriver.Open
at /home/vmg/src/gopath/src/github.com/github/authzd/vendor/github.com/go-sql-driver/mysql/driver.go:77
7 0x000000000091f0ff in github.com/github/authzd/vendor/github.com/go-sql-driver/mysql.(*MySQLDriver).Open
at :1
8 0x0000000000645c60 in database/sql.dsnConnector.Connect
at /usr/local/go/src/database/sql/sql.go:636
9 0x000000000065b10d in database/sql.(\*dsnConnector).Connect
at :1
10 0x000000000064968f in database/sql.(\*DB).conn
at /usr/local/go/src/database/sql/sql.go:1176
11 0x000000000065313e in database/sql.(\*Stmt).connStmt
at /usr/local/go/src/database/sql/sql.go:2409
12 0x0000000000653a44 in database/sql.(\*Stmt).QueryContext
at /usr/local/go/src/database/sql/sql.go:2461
[...]
```
Проблема заключалась в том, что мы не распространяем `Context` наших реквестов настолько глубоко, как мы думали. Пусть при выполнении SQL запросов мы и передаем `Context` для `QueryContext`, и этот Context используется для исполнения и таймаута SQL запросов, мы упускаем крайний случай в API `database/sql/driver`. Когда мы пытаемся выполнить запрос, а в пуле нет ни одного SQL соединения, вызовом [`driver.Driver.Open()`](https://golang.org/src/database/sql/driver/driver.go?s=1594:2015#L45) мы должны создать новое, но этот метод интерфейса не берет `context.Context`!
В предыдущем следе стека явно видно, как в (8) мы перестаем распространять наш `Context` и попросту вызываем `(*MysqlDriver).Open()` в нашу базу данных через DSN. Открытие MySQL соединения — это недешевая операция: она включает в себя открытие TCP, SSL-общение (если мы пользуемся SSL), рукопожатие и аутентификацию MySQL и настройку любых базовых опций соединения. Итого нашим правилам таймаута не подчиняются, как минимум, *шесть* разных сетевых соединений, и все из-за их `Context`-неосведомленности.
Что же нам с этим делать? Нашей первой попыткой было изменение значения `timeout` на DSN нашего соединения, что, в свою очередь, влияет на таймаут используемого `(*MySQLDriver).Open` открытого TCP. Этого оказалось недостаточно, так как открытое TCP — лишь первый шаг инициализации соединения. Последующие шаги (MySQL рукопожатие, аутентификация и так далее) не подчинялись никаким таймаутам, поэтому превышающие 1000мс таймаут реквесты так никуда и не делись.
Корректное решение потребовало рефакторинга большого куска Go MySQL драйвера. Основная проблема возникла еще в Go 1.8 с имплементацией API `QueryContext` и `ExecContext`. Они формально могли обнулять SQL запросы, но несмотря на их `Context`-осведомленность, метод `driver.Open` не был обновлен для получения аргумента `context.Context`. Лишь два патча спустя, в Go 1.10, добавили новый интерфейс [`Connector`](https://golang.org/pkg/database/sql/driver/#Connector), и его необходимо было имплементировать *отдельно* от самого драйвера. В итоге команда сопровождающих Go MySQL драйвер так и не удосужилась имплементировать новый интерфейс, во многом из-за указанных выше сложностей и недостатка информации о потенциальных проблемах с доступностью старого интерфейса `Driver.Open`, поскольку поддержка и старого `driver.Driver`, и нового `driver.Connector` интерфейсов требовала значительных правок в структуре любого SQL драйвера.
К счастью, у меня нашлись и время, и терпение на подобный рефакторинг. [После выгрузки итогового драйвера с новым интерфейсом](https://github.com/go-sql-driver/mysql/pull/941) [`Connector`](https://github.com/go-sql-driver/mysql/pull/941) в `authzd`, мы на следах стеков подтвердили корректное распространение контекста `QueryContext` при новых MySQL соединениях:
```
0 0x000000000076facb in net.(*sysDialer).doDialTCP
at /usr/local/go/src/net/tcpsock_posix.go:64
1 0x000000000076fa1a in net.(*sysDialer).dialTCP
at /usr/local/go/src/net/tcpsock_posix.go:61
2 0x0000000000736ade in net.(*sysDialer).dialSingle
at /usr/local/go/src/net/dial.go:571
3 0x0000000000736303 in net.(*sysDialer).dialSerial
at /usr/local/go/src/net/dial.go:539
4 0x0000000000734bad in net.(*Dialer).DialContext
at /usr/local/go/src/net/dial.go:417
5 0x00000000008fdf3e in github.com/github/authzd/vendor/github.com/go-sql-driver/mysql.(*connector).Connect
at /home/vmg/src/gopath/src/github.com/github/authzd/vendor/github.com/go-sql-driver/mysql/connector.go:43
6 0x00000000006491ef in database/sql.(*DB).conn
at /usr/local/go/src/database/sql/sql.go:1176
7 0x0000000000652c9e in database/sql.(*Stmt).connStmt
at /usr/local/go/src/database/sql/sql.go:2409
8 0x00000000006535a4 in database/sql.(*Stmt).QueryContext
at /usr/local/go/src/database/sql/sql.go:2461
[...]
```
Обратите внимание, как `(*DB).conn` напрямую вызывает интерфейс `Connector` нашего драйвера, в обход текущего `Context`. Помимо этого, стало ясно что глобальный таймаут реквестов распространяется на все реквесты:
*Рисунок 4: Время отклика распознавателя с таймаутом в 90мс. Можно быть уверенными, что `Context` не игнорируется, поскольку 99й процентиль больше похож на штрихкод, чем на график.*
### Советы для продакшена
* Вам не нужно менять инициализацию вашего `sql.(*DB)` для использования нового API `sql.OpenDB`. Даже при вызове `sql.Open` в Go 1.10 пакет `database/sql` замечает интерфейс `Connector`, и новые соединения создаются `Context`–осведомленными.
* Тем не менее, изменение вашего приложения под использование `sql.OpenDB` вместе с `mysql.NewConnector` несет в себе несколько преимуществ, в особенности возможность настройки опций соединения для вашего MySQL кластера из структуры `mysql.Config`, без необходимости составлять DSN.
* Не назначайте на вашем MySQL драйвере `?timeout=` (или его аналог `mysql.(Config).Timeout`), это плохая идея, поскольку статичное значение таймаута исходящего соединения не учитывает расход вашего запаса ресурсов на выполнение реквестов.
* Вместо этого убедитесь в использовании интерфейсов `QueryContext` / `ExecContext` каждой SQL операцией вашего приложения. Тогда они будут обнулены на основе `Context` вашего текущего реквеста вне зависимости от причин, будь то неудачное соединение либо слишком долгое исполнение запроса.
Гонка
-----
Напоследок будет очень серьезная, коварная и неуловимая проблема безопасности, вызванная data race. Мы много говорили о том, что `sql.(*DB)` — это попросту обертка вокруг пула соединений хранения состояния, но есть одна деталь, которую мы еще не затронули. Проведение SQL запроса, одной из самых частых операций над базами данных, как через `(*DB).Query`, так и через `(*DB).QueryContext`, на самом деле *крадет* соединение из пула.
В отличие от простого вызова `(*DB).Exec`, который не возвращает никаких данных из базы, `(*DB).Query` возвращает одну или несколько строк, и мы должны взять под контроль соединение с хранением состояния, в которое сервер запишет эти строки, чтобы прочесть их из кода нашего приложения. Здесь нам помогает структура `sql.(*Rows)`, которая возвращается после каждого вызова `Query` и `QueryContext`: она оборачивает украденное из пула соединение для прочтения из него индивидуальных строк `Row`. И если по завершении обработки результатов запроса не вызывать `(*Rows).Close`, украденное соединение так и не вернется в пул.
Обмен данными между обычным SQL запросом и `databaseb/sql` не менялся с самого первого стабильного релиза Go:
```
rows, err := db.Query("SELECT a, b FROM some_table")
if err != nil {
return err
}
defer rows.Close()
for rows.Next() {
var a, b string
if err := rows.Scan(&a, &b); err != nil {
return err
}
...
}
```
На практике этот подход прямолинеен: `(*DB).Query` возвращает `sql.(*Rows)`, а он крадет из SQL пула соединение, на котором мы провели запрос. Последующие вызовы `(*Rows).Next` прочтут итоговую строку из соединения, и мы можем извлечь ее содержимое вызовом `(*Rows).Scan`, пока мы наконец не вызовем `(*Rows).Close`, после чего все последующие вызовы `Next` вернут `false`, а все вызовы `Scan` вернут ошибку.
На самом деле, имплементация с основным драйвером выглядит сложнее: драйвер возвращает свой собственный обернутый в `sql.(*Rows)` интерфейс `Rows`. Тем не менее, благодаря оптимизации у `Rows` драйвера вместо метода `Scan` имеется итератор `Next(dest []Value) error`. Итератор возвращает объекты `Value` за каждый столбец в SQL запросе, поэтому вызов `sql.(*Rows).Next` попросту вызывает подо всем этим `driver.Rows.Next`, сохраняя указатель на возвращенных драйвером значениях. Затем, когда пользователь вызывает `sql.(*Rows).Scan`, библиотека стандартов конвертирует объекты `Value` драйвера в заданные пользователем целевые типы в виде аргументов для `Scan`. А значит, драйверу не нужно проводить конвертацию аргументов (об этом заботится библиотека стандартов Go), и вместо указания новых значений `Value` драйвер может вернуть украденную память из своего итератора строк, все равно метод `Scan` и так конвертирует память.
Как вы могли сразу догадаться, наша проблема безопасности вызвана *украденной памятью*. В контракте драйвера очень рекомендуют возвращать временную память, эта важная оптимизация на практике хорошо ложится на MySQL и позволяет нам возвращать указатели в буфер соединения для считывания результатов напрямую. Как только информация строк SQL запроса доставлена, ее можно передать методу *Scan*, который распарсит строчное отображение в ожидаемые пользователем типы (`int`, `bool`, `string` и так далее). Этот безопасный метод не вызывает никаких data race, потому что без нового вызова пользователем `sql.(*Rows).Next` мы не переписываем наш буфер.
… Так все и было, по крайней мере, пока в Go 1.8 не появился API `QueryContext`. С новыми интерфейсами можно вызывать `db.QueryContext` с объектом `Context`, который прервет запрос раньше — мы уже это детально разобрали. Однако прерывание или отключение запроса по таймауту, когда мы сканируем его результаты, открывает серьезную уязвимость для безопасности. Как только SQL запрос прерывается посреди вызова `sql.(*Rows).Scan`, драйвер переписывает основной буфер MySQL соединения, и `Scan` возвращает поврежденные данные.
Подобное поведение может показаться неожиданным, но так как обнуление нашего `Context` означает обнуление SQL запроса *на клиенте*, а не на MySQL сервере, ситуация становится яснее. Сервер продолжает выдавать результаты запроса через активное MySQL соединение, поэтому если мы хотим восстановить соединение на месте обнуления запроса, мы должны сначала «опустошить» все переданные сервером пакеты результатов. Для опустошения и сброса оставшихся в запросе строк мы должны прочесть эти пакеты в наш буфер соединения, и так как обнуление запроса может произойти одновременно с запросом `Scan`, мы переписываем ответственную за значения `Value` память, в которой пользователь ведет поиск. В результате с очень высокой долей вероятности получаются поврежденные данные.
Эта data race уже звучит пугающе, но вот в чем главная загвоздка: на практике однозначно сказать случилась data race в вашем приложении или еще нет не получится. В прошлом примере использования `rows.Scan` нет какого-либо надежного способа сказать, обнулился ли наш SQL запрос из-за истекшего `Context`, даже несмотря на наши проверки на ошибки. Если обнуление `Context` случилось внутри вызова `rows.Scan` (например, в удобном для старта data race месте), то значения строк будут отсканированы с потенциально поврежденными данными и не будет возвращена ошибка, поскольку `rows.Scan` проверяет закрытие строк только единожды, *при входе в функцию*. Таким образом, при data race мы получаем поврежденные данные без возврата ошибки и не можем сказать, обнулялся запрос или нет, до тех пор, пока не совершим наш следующий вызов `rows.Scan`. Но этот вызов никогда не произойдет, потому что `rows.Next()` вернет `false`, и снова без ошибки.
Проверка возвратного значения вызова `rows.Close` — это единственный способ проверки корректного завершения сканирования строк нашего SQL запроса, но мы не совершаем этот вызов, так как строки закрыты в операторе `defer`. Кроме того, [быстрый поиск кода по](https://github.com/search?p=2&q=rows.Close%28%29&type=Code) [`rows.Close()`](https://github.com/search?p=2&q=rows.Close%28%29&type=Code) на Github демонстрирует, что практически *никто* явно не проверяет возвратное значение `rows.Close()` в своем коде. До API `QueryContext` такой подход был безопасен, но со времен Go 1.8 одного `rows.Scan` недостаточно. Без проверки обратного значения `rows.Close()` вы не узнаете, просканировали ли вы все-все строки вашего SQL запроса, даже после устранения этого data race на Go MySQL драйвере. Так что обновляйте ваши lint’ы.
Я знаю несколько способов устранения этой data race. Самый очевидный — и самый медленный — предлагает всегда клонировать память при возвращении из `driver.Rows.Next`. Так как распределение памяти отложено до вызова пользователем `sql.(*Rows).Scan`, то драйверу не нужно выделять память при вызове driver.Rows.Next, в этом заключается сама идея контракта драйвера. Если мы станем распределять в Next, мы будем распределять память по два раза для каждой строки, и это вызовет сильную регрессию производительности. Ни команда сопровождающих Go MySQL, ни я не были довольны таким положением дел. Другие похожие методы, например, [усечение основного буфера соединения при вызове](https://github.com/go-sql-driver/mysql/pull/904) sql.[`(*Rows).Close`](https://github.com/go-sql-driver/mysql/pull/904), были отвергнуты по той же причине — они потенциально распределяют память при каждом вызове `Scan`. В итоге критический баг так и провисел шесть месяцев без фикса, потому что команда не нашла устраивающего их ответа. Лично я очень опасаюсь ситуаций с долгим провисанием критически опасных багов, поэтому для исправления проблемы без вызова регрессии на наших хостах мне пришлось придумать нечто совершенно новое.
Сначала я попробовал «опустошать» MySQL соединения без использования основного буфера соединений, ведь data race не возникнет, если мы не пишем в буфер. Но так как MySQL может высылать множество необходимых для опустошения пакетов, и разные размеры этих пакетов определяются их заголовками, мои попытки вскоре превратились в кошмарный спагетти-код. Частично парсить заголовки без буфера очень неприятно.
Я размышлял над этой проблемой еще некоторое время, и в один момент меня осенило — двойная буферизация. Это решение оказалась безумно простым и достаточно быстрым, чтобы в дальнейшем замержить его вверх. Еще во времена древних стеков компьютерной графики подобный стек записывал индивидуальные пиксели прямо на буфер кадров, а монитор одновременно с этим считывал пиксели со своей кадровой частотой. Когда стек писал данные в буфер кадров одновременно с тем, как экран считывал из него, наблюдалось мерцание, старый графический глич. Фундаментально мерцание можно определить как видимую невооруженным взглядом data race, что само по себе довольно интересный концепт. Проще всего устранить мерцание можно двумя буферами кадров: из одного буфера будет считывать данные экран (передний буфер), а в другой будет записывать данные графический процессор (задний буфер). Когда графический процессор завершает визуализацию кадра, мы автоматически меняем передний и задний буфер местами, поэтому монитор никогда не считает незаконченный кадр.
*Рисунок 5: Двойная буферизация графического стека Nintendo 64. Если Марио этого достаточно, то и для MySQL драйвера сойдет.*
Наша проблема и эта ситуация очень похожи, поэтому мы можем воспользоваться приемом с двумя буферами. В нашем случае, мы *меняем местами* наш буфер соединений с задним буфером, когда структура `driver.Rows` закрывается по причине раннего обнуления запроса, и таким образом пока мы осушаем MySQL соединение в задний буфер, пользователь все еще может вызвать `sql.Rows.Scan` на передний. Когда в следующий раз SQL запрос поступит на то же самое соединение, мы продолжим чтение из заднего буфера, пока `Rows` не закроется вновь и мы не поменяем буферы обратно. Эта очень тривиальная имплементация распределяет память один раз за SQL соединение, амортизируя потери продуктивности. Мы сумели улучшить ситуацию для крайнего случая через задержку распределения в задний буфер до необходимости в первый раз опустошить в него данные, поэтому когда в обычной ситуации в MySQL соединении ни один запрос не обнуляется раньше, то не происходит и дополнительного распределения памяти.
После [аккуратной сборки нескольких тестов производительности](https://github.com/go-sql-driver/mysql/pull/945#issuecomment-479532346) регрессии двойной буферизации не было выявлено ни в одном из случаев, я наконец-то [направил фикс вверх](https://github.com/go-sql-driver/mysql/pull/943). К несчастью, особенности бага не дают посмотреть частоту чтения поврежденной памяти, однако его легко воспроизвести, поэтому таких чтений наверняка было *довольно много*.
### Советы в продакшн
* Всегда проводите явную проверку возврата ошибки в вызове `(*Rows).Close`, другого способа проверить, был ли SQL запрос потревожен в ходе сканирования, попросту нет. Тем не менее, не убирайте из вашего приложения вызов `defer rows.Close()` — только им можно закрыть строки, если случается `panic` или ранний возврат в ходе вашего сканирования. Всегда безопасно несколько раз вызвать `(*Rows).Close`.
* Никогда не используйте `(*Rows).Scan` вместе с целью `sql.RawBytes`. Даже если Go MySQL драйвер теперь намного более стойкий, при раннем обнулении доступ к `RawBytes` может и будет падать с другими SQL драйверами. Если это случится, то вы с высокой вероятностью прочтете некорректные данные. Единственная разница между сканированием `[]byte` и `sql.RawBytes` в том, что raw версия распределяет дополнительную память, и столь крохотная оптимизация не стоит потенциальной data race в Context–осведомленном приложении.
Заключение
----------
Развертывание кода на новом языке программирования в продакшн, особенно в масштабах Github, — это всегда вызов. Производительность и сложность наших моделей использования MySQL отражает нашу многолетнюю тонкую настройку MySQL клиента под Ruby, а теперь мы рады делать то же самое для Go MySQL драйвера. [Релиз 1.5.0](https://github.com/go-sql-driver/mysql/releases/tag/v1.5.0) Go MySQL драйвера содержит в себе все переданные нами вверх в ходе нашего первого развертывания Go фиксы и есть теперь в общем доступе. Мы же параллельно с ростом нашего использования Go в продакшне и дальше продолжим привносить исправления в драйвер и расширять его функционал.
Спасибо сопровождающим Go MySQL специалистам, @methane и @julienschmidt за их помощь с патчами! | https://habr.com/ru/post/503586/ | null | ru | null |
# Примеры использования customTask в Google Tag Manager
*Материал основан на статье Simo Ahava [«customTask — The Guide»](https://www.simoahava.com/analytics/customtask-the-guide/).*
Примерно год назад (в 2017) произошло обновление JS библиотеки Universal Analytics. Обновление принесло с собой такую замечательную штуку как **customTask**. Данная фича, в рамках Google Tag Manager, позволяет выполнять любые «задания» до отправки хита в Google Analytics.
В [оригинальной статье](https://www.simoahava.com/analytics/customtask-the-guide/#how-tasks-work) Simo Ahava подробно описывает механизм работы customTask и делится полезными примерами. Также можно ознакомиться с [официальным мануалом](https://developers.google.com/analytics/devguides/collection/analyticsjs/tasks) по библиотеке Universal Analytics, где дано описание всех тасков с очередностью их выполнения.
*Порядок выполнения заданий analytics.js*
Ниже представлен краткий обзор примеров использования customTask. Уверен, некоторые решения вам точно пригодятся.
### Примеры использования customTask (краткий обзор)
**1. Запись Client ID в custom dimension**
Самый надежный способ передачи Client ID на текущий момент. Мануалы по настройке:
* [От BurgerData](https://burgerdata.com/blog/kak-peredavat-clientid-cherez-customtask/)
* [От Simo Ahava](https://www.simoahava.com/gtm-tips/use-customtask-access-tracker-values-google-tag-manager/)
**2. Дублирование хита GA и отправка его в другие места**
Мануалы:
* [Отправка в несколько GA property](https://www.simoahava.com/gtm-tips/send-google-analytics-tag-multiple-properties/), автор Simo Ahava.
Хорошая идея для оптимизации тегов в GTM (не нужно создавать дополнительных тегов для отправки данных в несколько аккаунтов). Единственный минус — если в настройках тега есть междоменное отслеживание (cross-domains tracking), то дублируемый хит уйдет без этих настроек (только оригинальный хит сохранит настройки тега).
* [Отправка в Google Sheet](https://habr.com/post/353836/), автор dkomarovskiy.
Выгрузка всех данных хита (payload) в Google Sheet. Полезно при дебаге и анализе данных (если проект небольшой).
* [Отправка в Google Bigquery](http://dmitriilin.com/exporting-data-google-analytics-google-bigquery/) (**note! здесь используется таск sendHitTask т.е. одновременно использовать customTask и sendHitTask нельзя; можно переписать код из sendHitTask в customTask — тогда все ок**), автор Dmitri Ilin.
Крутой мануал если необходимо полностью избавиться от семплирования и ограничений GA.
* [Отправка в Snowplow](https://www.simoahava.com/analytics/automatically-fork-google-analytics-hits-snowplow/), автор Simo Ahava.
Snowplow — сервис позволяющий создать/организовать свой собственный пайплайн для работы с данными в т.ч. веб аналитики. В сервис включены все процессы работы с данными: от сбора/обработки до хранения/анализа/визуализации т.е. можете сами сделать свой GA с блэкджеком и сводными таблицами.
**3. Удаление персональных данных из GA payload (GDPR\*)**
[Мануал](https://www.simoahava.com/gtm-tips/remove-pii-google-analytics-hits/) от Simo Ahava.
Пригодиться в первую очередь тем, кто работает со странами Евросоюза и столкнулся с выполнением требований [GDPR](https://piwik.pro/blog/gdpr-interview-aurelie-pols/). Данное решение позволяет убрать все персональные данные из payload'a (где-бы они не находились: URL, Custom Dimension, Event Label, etc.).
Например page path:
```
/test?tel=+44012345678&email=brian@me.com&other=bclifton@DOMAIN.com&firstName=brian&password=hello
```
после модификации customTask будет таким:
```
/test?tel=[REDACTED TELEPHONE]&email=b[REDACTED EMAIL]om&other=bcli[REDACTED SELF-EMAIL]OMAIN.com&firstName=[REDACTED NAME]&password=[REDACTED PASSWORD]
```
**4. Трекинг офлайн пользователей**
[Мануал](https://www.simoahava.com/analytics/track-users-who-are-offline-in-google-analytics/) от Simo Ahava.
Решает проблему разорванного соединения т.е. например, когда конект обрывается, то отправка хита не заканчивается ошибкой (т.к. нет конекта), а закрепляется в очереди в localStorage. Когда конект возобновляется — хит отправляется. Полезно проектам с высокой долей аудитории с мобильного трафика с нестабильным конектом (часто ездят в метро например).
**5. Учет пользовательского согласия на отправку данных в GA (GDPR\*)**
[Мануал](https://www.simoahava.com/gtm-tips/respect-opt-out-from-advertising-and-analytics/) от Simo Ahava.
Пригодиться при выполнении требований [GDPR](https://piwik.pro/blog/gdpr-interview-aurelie-pols/). Например у вас на сайте есть поп-ап, в котором пользователь соглашается/не соглашается на обработку своих персональных данных 3-ми лицами. При отказе, данный customTask не отправит данные в GA и DoubleClick.
**6. Отправка ID эксперимента Google Optimize в GA**
[Мануал](https://www.simoahava.com/analytics/send-event-custom-dimension-google-optimize-experiment-running/) от Simo Ahava.
Помогает с проблемой отображения данных Google Optimize в GA. Во время эксперимента пользователю присваиваются переменные Experiment Name и Experiment ID. Привязать эти данные к конкретным сессиям/сегментам — проблема, с которой помогает справиться данный customTask. Таск проверяет Page View тег, если он содержит данные об эксперименте — записывает их в custom dimension и отправляет хит.
**7. Auto Link Domains в виде регулярного выражения**
[Мануал](https://www.simoahava.com/gtm-tips/auto-link-domains-with-regex/) от Simo Ahava.
Решает проблему невозможности использовать регулярные выражения в GTM тегах в поле **Auto Link Domains** при настройке междоменного трекинга.
**8. Автоматическая подрезка GA Payload Lenght**
[Мануал](https://www.simoahava.com/analytics/automatically-reduce-google-analytics-payload-length/) от Simo Ahava.
Красивое решение проблемы с превышением payload lenght. Одним за одним удаляет из payload'a ненужные параметры пока тот не станет меньше 8192. Что конкретно выкидывать — можно настроить.
### Объединение нескольких решений в один customTask
Если вы захотели объединить несколько решений в одном customTask, то необходимо помнить следующие правила работы с customTask:
* В GTM теге можно определить только один customTask
* В JS коде customTask'a, параметр **model** определяется один раз.
Отправка таска **sendHitTask** тоже происходит один раз (в рамках одного тега):
*model.set('sendHitTask', function(sendModel) {… });*
Если записать несколько sendHitTask в один customTask — отправиться только один (последний).
**Пример объединения нескольких решений в один customTask**
Что объединяем:
* определение Client ID в custom dimension
* удаление персональных данных (PII) из payload
* отправка хита в несколько GA property
```
function() {
var newTrackingId = 'UA-12345678-1';
return function(model) {
//Define client ID
model.set('dimension1', model.get('clientId'));
// Add the PII patterns into this array as objects
var piiRegex = [{
name: 'EMAIL',
regex: /(?<=emailAddress=|email=).+?(?=@|%40)/gi
}];
// Fetch reference to the original sendHitTask
var globalSendTaskName = '_' + model.get('trackingId') + '_sendHitTask';
var originalSendTask = window[globalSendTaskName] = window[globalSendTaskName] || model.get('sendHitTask');
var i, hitPayload, parts, val, oldTrackingId;
model.set('sendHitTask', function(sendModel) {
// Overwrite sendHitTask with PII purger
hitPayload = sendModel.get('hitPayload').split('&');
for (i = 0; i < hitPayload.length; i++) {
parts = hitPayload[i].split('=');
// Double-decode, to account for web server encode + analytics.js encode
try {
val = decodeURIComponent(decodeURIComponent(parts[1]));
}
catch (e) {
val = decodeURIComponent(parts[1]);
}
piiRegex.forEach(function(pii) {
val = val.replace(pii.regex, '[REDACTED ' + pii.name + ']');
});
parts[1] = encodeURIComponent(val);
hitPayload[i] = parts.join('=');
}
sendModel.set('hitPayload', hitPayload.join('&'), true);
originalSendTask(sendModel);
// Rewrite the tracking ID
hitPayload = sendModel.get('hitPayload');
oldTrackingId = new RegExp(sendModel.get('trackingId'), 'gi');
sendModel.set('hitPayload', hitPayload.replace(oldTrackingId, newTrackingId), true);
originalSendTask(sendModel);
});
};
}
```
Сначала определяем Client ID. Затем, через регулярные выражения, указываем какие персональные данные мы хотим искать. В данном примере задан только один параметр — email. Можно добавить больше (см. [мануал Simo Ahava](https://www.simoahava.com/gtm-tips/remove-pii-google-analytics-hits/)).
Следующий шаг — проверяем payload на наличие персональных данных и перезаписываем его. Здесь есть один нюанс — двойное декодирование. Добавлена инструкция try… catch для отлова случаев если попадается знак процента '%' (также в regex добавлено условие %40). Если данную инструкцию убрать, то хиты в которых встречается '%' доходить не будут т.к. возникает JS ошибка. Способов декодирования существует множество, в данном случае, это один из рабочих вариантов. Можете попробовать свои.
Последние шаги — отправка модифицированного payload в оригинальный GA property и дублирование/отправка в другой GA property.
Если у вас есть еще примеры использования customTask — поделитесь опытом. Буду рад дополнить статью. | https://habr.com/ru/post/359196/ | null | ru | null |
# Пишем изящный парсер на Питоне
В C++17 (нет-нет, Питон скоро будет, вы правильно зашли!) появляется новый синтаксис для оператора `if`, позволяющий объявлять переменные прямо в заголовке блока. Это довольно удобно, поскольку конструкции вида
```
Foo foo = make_foo();
if(foo.is_nice()) {
// do work with foo
}
// never use foo again
// foo gets deleted
```
довольно общеупотребительны. Код выше лёгким движением руки программиста (и тяжёлым движением руки комитета по стандартизации) превращается в:
```
if(Foo foo = make_foo(); foo.is_nice()) {
// do work with foo
} // foo gets deleted
// never use foo again (well, you can't anyway)
```
Стало чуть-чуть лучше, хотя всё ещё не выглядит идеально. В Python нет и такого, но если вы ненавидите `if` в Python-коде так же сильно, как я, и хотите научиться быстро писать простые парсеры, то добро пожаловать под кат. В этой статье мы попытаемся написать короткий и изящный парсер для JSON на Python 2 (без каких-либо дополнительных модулей, конечно же).
Что такое парсинг и с чем его едят
==================================
*Парсинг* (по-русски «синтаксический анализ») — это бессмертная задача разобрать и преобразовать в осмысленные единицы нечто, написанное на некотором фиксированном языке, будь то язык программирования, язык разметки, язык структурированных запросов или главный язык жизни, Вселенной и всего такого. Типичная последовательность этапов решения задачи выглядит примерно так:
1. **Описать язык**. Конечно, сначала надо определиться, какую именно задачу мы решаем. Обычно описание языка — это очередная вариация [формы Бэкуса-Наура](https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%80%D0%BC%D0%B0_%D0%91%D1%8D%D0%BA%D1%83%D1%81%D0%B0_%E2%80%94_%D0%9D%D0%B0%D1%83%D1%80%D0%B0). ([Вот](https://github.com/python/cpython/blob/master/Grammar/Grammar), например, описание грамматики Python, использующееся при построении его парсера.) При этом устанавливаются как правила «построения предложений» в языке, так и правила определения валидных слов.
2. **Разбить ввод на токены**. Пишется *лексический анализатор* (в народе токенайзер), который разбивает входную строку или файл на последовательность *токенов*, то есть валидных слов нашего языка (или ноет, что это нельзя сделать).
3. **Проверить синтаксис и построить синтаксическое дерево**. Проверяем, соответствует ли последовательность токенов описанию нашего языка. Здесь в ход идут алгоритмы вроде [метода рекурсивного спуска](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D1%80%D0%B5%D0%BA%D1%83%D1%80%D1%81%D0%B8%D0%B2%D0%BD%D0%BE%D0%B3%D0%BE_%D1%81%D0%BF%D1%83%D1%81%D0%BA%D0%B0). Каждое валидное предложение языка включает какое-то конечное количество валидных слов или других валидных предложений; если токены смогли сложиться в стройную картину, то на выходе мы автоматически получаем дерево, которое и называется *абстрактным синтаксическим деревом*.
4. **Сделать, наконец, работу**. У вас есть синтаксическое дерево и вы можете наконец сделать то, что хотели: посчитать значение арифметического выражения, организовать запрос в БД, скомпилировать программу, отобразить веб-страницу и так далее.
Вообще область эта изучена вдоль и поперёк и полна замечательных результатов, и по ней написаны сотни (возможно, хороших) книг. Однако, теоретическая разрешимость задачи и написание кода — не одно и то же.
Модельная задача
----------------
Написание парсера проиллюстрируем на простом, но не до конца тривиальном примере — парсинге JSON. Грамматика выглядит примерно так:
```
root ::= value
value ::= string | number | object | array | 'true' | 'false' | 'null'
array ::= '[' ']' | '[' comma-separated-values ']'
comma-separated-values ::= value | value ',' comma-separated-values
object ::= '{' '}' | '{' comma-separated-keyvalues '}'
comma-separated-keyvalues ::= keyvalue | keyvalue ',' comma-separated-keyvalues
keyvalue ::= string ':' value
```
Здесь нет правил для `string` и `number` — они, вместе со всеми строками в кавычках, будут нашими токенами.
Парсим JSON
===========
Полноценный токенайзер мы писать не станем (это скучно и не совсем тема статьи) — будем работать с целой строкой и бить её на токены по мере необходимости. Напишем две первые функции:
```
import re
# без re.DOTALL мы сломаемся на первом же переносе строки
number_regex = re.compile(r"(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)\s*(.*)", re.DOTALL)
def parse_number(src):
match = number_regex.match(src)
if match is not None:
number, src = match.groups()
return eval(number), src # использовать eval - не лучшее решение, но самое простое
string_regex = re.compile(r"('(?:[^\\']|\\['\\/bfnrt]|\\u[0-9a-fA-F]{4})*?')\s*(.*)", re.DOTALL)
def parse_string(src):
match = string_regex.match(src)
if match is not None:
string, src = match.groups()
return eval(string), src # здесь мы вообще подменили JSON'овский
# формат строк на питоновский, ну да ладно
```
(Я обещал без if'ов, но это последние, чесслово!)
Для всего остального напишем одну функцию, генерящую простенькие функции-парсеры:
```
def parse_word(word, value=None):
l = len(word)
def result(src):
# добавьте в следующую строчку вызовы .lower() для case-insensitive языка!
if src.startswith(word): # опять if! вот живучая тварь!
return value, src[l:].lstrip() # lstrip нужен для игнорирования пробелов, см. ниже
result.__name__ = "parse_%s" % word # для отладки
return result
parse_true = parse_word("true", True)
parse_false = parse_word("false", False)
parse_null = parse_word("null", None)
```
Итого, по какому принципу мы строим наши функции:
1. Они принимают строку, которую нужно парсить.
2. Они возвращают пару (результат, оставшаяся\_строка) при успехе (то есть когда требуемая конструкция нашлась в начале строки) и `None` при провале.
3. Они отправляют в небытие все пробельные символы между токенами. (Не делайте так, если пишете парсер Питона!)
Собственно, на этих трёх функциях проблемы с токенами решены, и мы можем перейти к интересной части.
### Парсим правило с ветвлением
Как должна выглядеть функция `parse_value`, соответствующая грамматике выше? Обычно как-то так:
```
def parse_value(src):
# попытайся распарсить строковый литерал
match = parse_string(src)
if match is not None:
# получилось!
return match
# не получилось; ну тогда попытайся распарсить число
match = parse_number(src)
if match is not None:
return match
# да что ж такое. ну тогда попытайся расп...
# ...
```
Ну уж нет, эти `if` достали меня!
Давайте поменяем три функции выше самым неожиданным образом: заменим `return` на `yield`! Теперь они возвращают [генераторы](https://wiki.python.org/moin/Generators) — пустые, если парсинг не удался, и ровно с одним элементом, если удался. Да-да, мы разворачиваем на 90 градусов наш принцип номер 2: все наши функции мы будем теперь писать в таком стиле:
```
number_regex = re.compile(r"(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)\s*(.*)", re.DOTALL)
def parse_number(src):
match = number_regex.match(src)
if match is not None:
number, src = match.groups()
yield eval(number), src
# если управление дошло до сюда без yield, числа обнаружить не удалось.
# ну что же, пустой генератор тоже генератор.
string_regex = re.compile(r"('(?:[^\\']|\\['\\/bfnrt]|\\u[0-9a-fA-F]{4})*?')\s*(.*)", re.DOTALL)
def parse_string(src):
match = string_regex.match(src)
if match is not None:
string, src = match.groups()
yield eval(string), src
def parse_word(word, value=None):
l = len(word)
def result(src):
if src.startswith(word):
yield value, src[l:].rstrip()
result.__name__ = "parse_%s" % word
return result # здесь возвращаем функцию-парсер, не yield'им
parse_true = parse_word("true", True)
parse_false = parse_word("false", False)
parse_null = parse_word("null", None)
```
Во что же превратится наша `parse_value`? На первый взгляд во что-то такое:
```
def parse_value(src):
for match in parse_string(src):
yield match
return
for match in parse_number(src):
yield match
return
# ...
```
Но на второй взгляд мы увидим, что каждая опция может занимать всего одну строчку!
```
# весьма полезная itertools.chain объединяет переданные ей итераторы
# в цепочку, не трогая ни один раньше времени
from itertools import chain
def parse_value(src):
for match in chain(
parse_string(src),
parse_number(src),
parse_array(src),
parse_object(src),
parse_true(src),
parse_false(src),
parse_null(src),
): # закрывающей скобке грустно, но веселье только начинается
yield match
return
```
При этом эффективность остаётся на прежнем уровне — каждая функция начнёт выполняться (а стало быть, делать работу, проверяя регулярные выражения) только тогда, когда предыдущая не даст результата. `return` гарантирует, что лишняя работа не будет выполнена, если где-то в середине списка парсинг удался.
### Парсим последовательности конструкций
Перейдём к следующему номеру нашей программы — функции `parse_array`. Выглядеть она должна как-то так:
```
parse_left_square_bracket = parse_word("[")
parse_right_square_bracket = parse_word("]")
def parse_array(src):
# здесь потребуется временная переменная tsrc, иначе даже при неудачном
# парсинге пустого массива открывающая скобка может быть "съедена"
for _, tsrc in parse_left_square_bracket(src):
for _, tsrc in parse_right_square_bracket(tsrc):
# если мы здесь, то нам удалось последовательно распарсить '[' и ']'
yield [], tsrc
return
# здесь переменную src уже не жалко -- за этим циклом только боль и пустота
for _, src in parse_left_square_bracket(src):
for items, src in parse_comma_separated_values(src):
for _, src in parse_right_square_bracket(src):
yield items, src
# если управление дошло сюда без yield, то парсинг массива не удался
```
Ни одного `if`, как и обещано, но что-то всё равно не так… Давайте напишем небольшую вспомогательную функцию, которая поможет нам соединять функции-парсеры в последовательности подобно тому, как `chain` помогла соединять их в режиме «или». Эта функция должна будет аккуратно брать все результаты и вернуть все первые элементы результатов (результаты анализа) и последний второй элемент (оставшуюся непроанализированной часть строки). Мой вариант выглядит так:
```
def sequence(*funcs):
if len(funcs) == 0: # ну простите, не могу в рекурсию без if'а
def result(src):
yield (), src
return result
def result(src):
for arg1, src in funcs[0](src):
for others, src in sequence(*funcs[1:])(src):
yield (arg1,) + others, src # конкатенируем содержательные результаты
return result
```
С этим мощным (пусть и страшноватым) инструментом наша функция перепишется в виде:
```
parse_left_square_bracket = parse_word("[")
parse_right_square_bracket = parse_word("]")
parse_empty_array = sequence(parse_left_square_bracket, parse_right_square_bracket)
def parse_array(src):
for _, src in parse_empty_array(src): # увы, эта функция недостаточно умна, чтобы вернуть []
yield [], src
return # этот return нужен, чтобы не пойти радостно парсить
# дальше в конструкции вида {} {"a": 1}
for (_, items, _), src in sequence(
parse_left_square_bracket,
parse_comma_separated_values,
parse_right_square_bracket,
)(src):
yield items, src
# если управление дошло сюда без yield, то парсинг массива не удался
```
Ну а дописать функцию `parse_comma_separated_values` — раз плюнуть:
```
parse_comma = parse_word(",")
def parse_comma_separated_values(src):
for (value, _, values), src in sequence(
parse_value,
parse_comma,
parse_comma_separated_values # я говорил, что не могу в рекурсию без if? я соврал
)(src):
yield [value] + values, src
return
for value, src in parse_value(src):
yield [value], src
```
Приведёт ли такое решение к бесконечной рекурсии? Нет! Однажды функция `parse_comma` не найдёт очередной запятой, и до последующей `parse_comma_separated_values` выполнение уже не дойдёт.
Идём дальше! Объект:
```
parse_left_curly_bracket = parse_word("{")
parse_right_curly_bracket = parse_word("}")
parse_empty_object = sequence(parse_left_curly_bracket, parse_right_curly_bracket)
def parse_object(src):
for _, src in parse_empty_object(src):
yield {}, src
return
for (_, items, _), src in sequence(
parse_left_curly_bracket,
parse_comma_separated_keyvalues,
parse_right_curly_bracket,
)(src):
yield items, src
parse_colon = parse_word(":")
def parse_keyvalue(src):
for (key, _, value), src in sequence(
parse_string,
parse_colon,
parse_value
)(src):
yield {key: value}, src
def parse_comma_separated_keyvalues(src):
for (keyvalue, _, keyvalues), src in sequence(
parse_keyvalue,
parse_comma,
parse_comma_separated_keyvalues, # тут снова рекурсия, не проглядите
)(src):
keyvalue.update(keyvalues)
yield keyvalue, src
return
for keyvalue, src in parse_keyvalue(src):
# к сожалению, питон не умеет в генераторе возвращать другой генератор
yield keyvalue, src
```
### Ну, что там дальше?
Собственно, всё! Остаётся добавить простую интерфейсную функцию:
```
def parse(s):
s = s.strip() # наш токенайзер убивает пробелы после токенов, но не терпит до
match = list(parse_value(s))
if len(match) != 1:
# где-то что-то пошло не так. про отладку расскажу в другой раз :)
raise ValueError("not a valid JSON string")
result, src = match[0]
if src.strip():
# мы распарсили, но в строке ещё что-то осталось. это ошибка.
raise ValueError("not a valid JSON string")
return result
```
Вуаля!
**Весь код вместе**
```
from itertools import chain
import re
def sequence(*funcs):
if len(funcs) == 0:
def result(src):
yield (), src
return result
def result(src):
for arg1, src in funcs[0](src):
for others, src in sequence(*funcs[1:])(src):
yield (arg1,) + others, src
return result
number_regex = re.compile(r"(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)\s*(.*)", re.DOTALL)
def parse_number(src):
match = number_regex.match(src)
if match is not None:
number, src = match.groups()
yield eval(number), src
string_regex = re.compile(r"('(?:[^\\']|\\['\\/bfnrt]|\\u[0-9a-fA-F]{4})*?')\s*(.*)", re.DOTALL)
def parse_string(src):
match = string_regex.match(src)
if match is not None:
string, src = match.groups()
yield eval(string), src
def parse_word(word, value=None):
l = len(word)
def result(src):
if src.startswith(word):
yield value, src[l:].lstrip()
result.__name__ = "parse_%s" % word
return result
parse_true = parse_word("true", True)
parse_false = parse_word("false", False)
parse_null = parse_word("null", None)
def parse_value(src):
for match in chain(
parse_string(src),
parse_number(src),
parse_array(src),
parse_object(src),
parse_true(src),
parse_false(src),
parse_null(src),
):
yield match
return
parse_left_square_bracket = parse_word("[")
parse_right_square_bracket = parse_word("]")
parse_empty_array = sequence(parse_left_square_bracket, parse_right_square_bracket)
def parse_array(src):
for _, src in parse_empty_array(src):
yield [], src
return
for (_, items, _), src in sequence(
parse_left_square_bracket,
parse_comma_separated_values,
parse_right_square_bracket,
)(src):
yield items, src
parse_comma = parse_word(",")
def parse_comma_separated_values(src):
for (value, _, values), src in sequence(
parse_value,
parse_comma,
parse_comma_separated_values
)(src):
yield [value] + values, src
return
for value, src in parse_value(src):
yield [value], src
parse_left_curly_bracket = parse_word("{")
parse_right_curly_bracket = parse_word("}")
parse_empty_object = sequence(parse_left_curly_bracket, parse_right_curly_bracket)
def parse_object(src):
for _, src in parse_empty_object(src):
yield {}, src
return
for (_, items, _), src in sequence(
parse_left_curly_bracket,
parse_comma_separated_keyvalues,
parse_right_curly_bracket,
)(src):
yield items, src
parse_colon = parse_word(":")
def parse_keyvalue(src):
for (key, _, value), src in sequence(
parse_string,
parse_colon,
parse_value
)(src):
yield {key: value}, src
def parse_comma_separated_keyvalues(src):
for (keyvalue, _, keyvalues), src in sequence(
parse_keyvalue,
parse_comma,
parse_comma_separated_keyvalues,
)(src):
keyvalue.update(keyvalues)
yield keyvalue, src
return
for keyvalue, src in parse_keyvalue(src):
yield keyvalue, src
def parse(s):
s = s.strip()
match = list(parse_value(s))
if len(match) != 1:
raise ValueError("not a valid JSON string")
result, src = match[0]
if src.strip():
raise ValueError("not a valid JSON string")
return result
```
130 строк. Попробуем запустить:
```
>>> import my_json
>>> my_json.parse("null")
>>> my_json.parse("true")
True
>>> my_json.parse("false")
False
>>> my_json.parse("0.31415926E1")
3.1415926
>>> my_json.parse("[1, true, '1']")
[1, True, '1']
>>> my_json.parse("{}")
{}
>>> my_json.parse("{'a': 1, 'b': null}")
{'a': 1, 'b': None}
```
Успех!
### Заключение
Конечно, я рассмотрел далеко не все ситуации, которые могут возникнуть при написании парсеров. Иногда программисту может потребоваться ручное управление выполнением, а не запуск последовательности `chain`ов и `sequence`ов. К счастью, это не так неудобно в рассмотренном подходе, как может показаться. Так, если нужно попытаться распарсить необязательную конструкцию и сделать действие в зависимости от её наличия, можно написать:
```
for stuff, src in parse_optional_stuff(src):
# опциональная конструкция на месте -- работаем
break # предотвращает выполнение else
else:
# опциональная конструкция отсутствует -- грустим
pass
```
Здесь мы пользуемся малопопулярной фишкой Питона — блоком `else` у циклов, который выполняется, если цикл дошёл до конца без `break`. Это выглядит не так привлекательно, как наш код в статье, но точно не хуже, чем те `if`, от которых мы столь изящно избавились.
Несмотря на неполноту и неакадемичность изложения, я надеюсь, что эта статья будет полезна начинающим программистам, а может, даже удивит новизной подхода программистов продвинутых. При этом я прекрасно отдаю себе отчёт, что это просто новая форма для старого доброго рекурсивного спуска; но если программирование — это искусство, разве не важна в нём форма если не наравне, то хотя бы в степени, близкой к содержанию?..
Как обычно, не откладывая пишите в личку обо всех обнаруженных неточностях, орфографических, грамматических и фактических ошибках — иначе я сгорю от стыда! | https://habr.com/ru/post/309242/ | null | ru | null |
# Установка Carbonio Community Edition на Ubuntu 20.04
Не так давно почтовый сервер Carbonio CE от компании Zextras получил поддержку Ubuntu 20.04 LTS. В данной статье мы пошагово произведем установку Carbonio CE на Ubuntu 20.04 и расскажем о том, как начать работу с почтовым сервером.
Скачать дистрибутив Ubuntu 20.04 можно [с сайта проекта](https://releases.ubuntu.com/20.04/). Для установки Carbonio CE подойдет как десктопная, так и серверная версия Ubuntu 20.04.
Рекомендуемая конфигурация, на которую будет устанавливаться Carbonio CE включает в себя:
* Физический или виртуальный 4-ядерный 64-битный x86-совместимый процессор с частотой 1,5 ГГц
* 8 Гб оперативной памяти
* 40 Гб места на жестком диске (рекомендуется использовать SSD)
Помимо требований к серверному “железу”, предъявляются требования к сети. В частности, для корректной работы Carbonio CE нужны:
* Корректно настроенное FQDN сервера
* Корректно настроенные A и MX записи в DNS
Данная инструкция подразумевает, что у вас уже настроены необходимые записи DNS.
В качестве доменного имени для сервера мы будем использовать carbonio.example.ru. Доменное имя сервера можно задать как на этапе установки, так и после ее завершения при помощи команды **sudo hostnamectl set-hostname carbonio.example.ru**.
После того как сервер с Ubuntu будет подготовлен, необходимо добавить FQDN сервера в файл /etc/hosts. Для этого откройте данный файл в текстовом редакторе с правами суперпользователя sudo nano /etc/hosts и добавьте в него строку с именем и ip-адресом вашего сервера.
Для установки Carbonio CE требуется [заполнить форму на сайте Zextras](https://www.zextras.com/carbonio-community-edition/). После ее заполнения на указанный вами почтовый ящик придет письмо с необходимыми для установки Carbonio CE данными. Эти данные представляют из себя ссылки на репозитории, которые потребуется добавить в вашу систему. Делается это при помощи следующих команд:
`sudo su
echo 'deb ******************* focal main' >>/etc/apt/sources.list.d/zextras.list
apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys *****************`
Вместо звездочек потребуется подставить ссылку и приватный ключ, которые вы получили в электронном письме от Zextras.
После этого выполните обновление кэша пакетного менеджера и обновите все установленные пакеты:
`sudo su
apt update
apt upgrade`
Когда все пакеты в системе будут обновлены, можно приступать к установке Carbonio CE. Делается это при помощи команды apt install carbonio-ce, запущенной с правами суперпользователя. После окончания установки Carbonio CE и всех его зависимостей, выполните в терминале с правами суперпользователя команду carbonio-bootstrap для первоначальной настройки почтового сервера.
При появлении диалога о настройке сервера вводим Y и нажимаем Enter, чтобы принять настройки по умолчанию.
В ходе выполнения carbonio-bootstrap будет создан домен по умолчанию, который будет на один уровень меньше FQDN сервера. То есть, при установке на сервер carbonio.example.ru почтовым доменом по умолчанию будет example.ru, а учетная запись администратора будет иметь вид zextras@example.ru. Также в системе будет создана учетная запись zextras, от которой будет осуществляться управление Carbonio CE.
Изначально для учетной записи администратора задан случайный пароль, который неизвестен пользователю и его необходимо сменить. Делается это следующим образом:
`sudo su - zextras
carbonio prov setPassword zextras@example.ru Pa$$w0rD`
где Pa$$w0rD - желаемый пароль администраторской учетной записи.
Получить доступ к веб-клиенту Carbonio CE можно в браузере введя ссылку <https://carbonio.example.ru>. Для входа введите имя учетной записи и пароль.
Для входа в консоль администратора используйте адрес https://carbonio.example.ru:6071/login. Для входа также введите имя учетной записи и пароль.
Помимо администраторской учетной записи при установке Carbonio CE на сервере создается ряд других системных учетных записей. Среди них два ящика для обучения антиспама (spam и ham), карантинный ящик для антивируса (virus-quarantine) и учетная запись GAL (galsync).
По умолчанию в веб-клиенте и в консоли администратора используется английский язык интерфейса. Сменить его на русский можно в настройках веб-клиента
После выбора языка нажмите “Сохранить” и утвердительно ответьте на предложение перезапустить веб-клиент. После этого язык в веб-клиенте и в консоли администратора сменится на русский.
Эксклюзивный дистрибьютор Zextras [SVZcloud](https://svzcloud.ru/). По вопросам тестирования и приобретения Zextras Carbonio обращайтесь на электронную почту: [sales@svzcloud.ru](mailto:sales@svzcloud.ru) | https://habr.com/ru/post/651439/ | null | ru | null |
# Как правильно проверять сложность пароля пользователя при регистрации
За десятилетия айтишки сложилась практика ограничивать пользователей в сложности их паролей. Сейчас пароль пользователя должен:
* быть не меньше N символов;
* && быть не больше M символов (чуть реже встречается такое правило);
* Содержать хотя бы одну большую букву;
* Содержать хотя бы одну маленькую букву;
* Содержать хотя бы одну цифру;
* Содержать хотя бы один спецсимвол;
* Иногда можно наткнуться на шедевры, вроде ограничения по количеству символов одинакового типа подряд, из чего рождается бессмертный анекдот про [одну грёбаную розовую розу](https://pikabu.ru/story/parol_2658600)...
Уж где мы только не подстелили соломы для наших нерадивых пользователей, лишь бы они были в безопасности. Ведь и мы, и матанализ, и различные софтинки – все наперебой говорят, что пароль `qwerty` и пароль `W0wS3qur3P/-\$$` имеют кардинально разную подбороустойчивость...
Алгоритм везде один и тот же. К слову, обычно проверка на спецсимволы производится *"хотя бы однин символ из заранее захардкоженного словаря"*. Обычно, словарь вида *"не буквы и не цифры с обычной клавиатуры английской раскладки"*. Просто курсор в кавычки константы, глазки на клавиатуру – и погнали составлять наш шикарнейший словарь.
Данный алгоритм настолько распространён, что встречается почти что в каждой первой статье. Примеров подобных статей – тысячи. Есть даже [на хабре](https://habr.com/ru/post/584020/) (в примере кода можно заметить ту самую регулярку).
Однако, всё ли у нас в порядке с нашим алгоритмом?
Что есть спецсимвол?
--------------------
> *Дисклеймер: примеры кода будут на пыхе, для простоты забудем про ограничения длины пароля*
>
>
Типовой шаблон для поиска спецсимволов выглядит в лучшем случае вот так:
```
$password = 'fF6:';
var_dump(preg_match('/[\.:,;\?!@#\$%\^&\*_\-\+=]/', $password));
//true
```
А что если скобка?
```
php
$password = 'fF6:(';
var_dump(preg_match('/[\.:,;\?!@#\$%\^&\*_\-\+=]/', $password));
//false</code
```
Ок, не проблема, добавим в словарь ещё и все скобки
```
php
$password = 'fF6:(';
var_dump(preg_match('/[\.:,;\?!@#$%^&\*_\-\+=\(\)<{}\[\]]/', $password));
//true
```
А как же слэш?
```
php
$password = 'fF6:(/';
var_dump(preg_match('/[\.:,;\?!@#\$%\^&*_\-\+=\(\)<{}\[\]]/', $password));
//false
```
Ок, ладно, сейчас мы сотрём регулярку и заново внимательно перенесём каждый чёртов символ с клавиатуры...
```
php
$password = 'fF6:(/';
var_dump(preg_match('/[\.:,;\?!@#\$%\^&\*_\-\+=\(\)<{}\[\]\'"`\/_~|\\]/', $password));
//true
```
И вроде мы собой довольны, однако... "*•√π÷׶∆£¢€¥°©®™✓*". Вот лишь некоторые символы, которые я слишком легко могу ввести со стандартной GBoard клавиатуры на своём телефоне. Буквально два нажатия: открыть клавиатуру символов и перейти на вторую страницу. Это уже не говоря о различных альтернативах вроде длинного и очень длинного тире (также известные как `–` (–) и `—` (—)). Что, опять словарь дополнять? Кстати, если переключить перед этим раскладку клавиатуры – то гборд даже поменяет некоторые символы. То есть мы уже видим проблему множества раскладок. А теперь ещё можно вспомнить про то, что есть другие клавиатуры, и даже другие операционые системы, у которых свои клавиатуры. Ну и на сладенькое...
😏 Эмоджи
😐 тоже
🙁 символы
☹️ .
🤯 БЭЭЭЭМ!
Наш словарь скоро начнёт требовать отдельное распределённое хранилище.
К какому же выводу мы приходим? Константный словарь спецсимволов – это *пло* что? павильно, *хо*. Плохо это... Поэтому наш герой-бэкендер достаёт из инвентаря ~~пузырёк витаминов C++~~ зиплок с регулярками и пишет `'/[^\w\d]/i'`, что в переводе с драугрского означает *"Что угодно, кроме букв и цифр. Регистронезависимо."*
Удивительно, но с этим даже эмоджи находятся
*Не обращайте внимания, что матчей 3. Эмоджи – двухбайтовые символы, поэтому регулярка их воспринимает как "первая половина" и "вторая половина".*
Итак, со спецсимволами разобрались. Но всё ли теперь в порядке с нашим алгоритмом?
Отдельный котёл для проверяющих регистр букв
--------------------------------------------
Казалось бы, всё нормально:
```
php
$password = 'Bye, World!';
if (!preg_match('/[A-Z]/', $password)) {
$errors[] = 'В пароле должна быть хотя бы одна большая буква';
}
if (!preg_match('/[a-z]/', $password)) {
$errors[] = 'В пароле должна быть хотя бы одна маленькая буква');
}</code
```
Однако... Стоит сделать всего лишь вот так
```
php
$password = 'АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ'
. 'абвгдеёжзийклмнопрстуфхцчшщъыьэюя';</code
```
И наш пароль не пройдёт ни одну проверку на регистры букв. То есть, мы только что напали на проблему: наш алгоритм ищет только буквы англиского алфавита. Это значит, что пароли на французском (é, è, ê), испанском (ñ), немецком (ä, ö, ü), норвежском(ø, Æ) и я могу продолжать ещё очень долго – могут не пройти проверку, если там не будет ни одной буквы английского алфавита.
То есть мы приходим к выводу, что нам нужно проверять как-то иначе. На этом моменте наш герой-бэкендер складывает регулярки обратно в зиплок, кладёт рядом с витаминками, и достаёт старые добрые методы работы со строками:
```
php
$password = 'АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ'
. 'абвгдеёжзийклмнопрстуфхцчшщъыьэюя';
if ($password === mb_strtolower($password)) {
$errors[] = 'В пароле должна быть хотя бы одна большая буква';
}
if ($password === mb_strtoupper($password)) {
$errors[] = 'В пароле должна быть хотя бы одна маленькая буква');
}</code
```
Вот так нужно проверять строки на наличие букв конкретного регистра.
Неожиданное заключение
----------------------
Всё это хорошо, однако...
Существуют языки, в которых просто нет деления на большие и маленькие буквы. Моё исследование под названием *"Спроси у ChatGPT"* показало, что в мире чуть больше 7000 языков, из них около половины (3500) имеют уникальные алфавиты, и около 20-30% всех языков (1400-2100) не имеют разделения на маленькие и большие буквы. Например, китайский, японский, корейский, иврит, арабский (ChatGPT говорит, что в арабском всего несколько букв имеют разделение на маленькие и большие) и индоевропейские языки. А также почему-то латынь и греческий, с чем я в корне не согласен, ибо тексты на обоих этих языках я видел в большом количестве, и больших букв там ровно каждой маленькой по паре...
ОТРЕДАКТИРОВАНО:
Ранее тут был пассаж про существование букв, у которых нет формы "большая" или "маленькая". В пример я приводил букву эсцет (ß) из немецкого алфавита. И даже проводил некоторые тесты, а потом обнаружил, что я забыл использовать `mb_*`.
В чём проблема: если проверять буквы юникода и не использовать mb-аналоги обычных методов работы со строками, то результат будет странным. Например, в случае эсцет – буква просто не меняла свой шифт, и выглядела как в квантовой суперпозиции:
```
php
$eszett = 'ß';
var_dump(strtoupper($eszett) === strtolower($eszett)); //true</code
```
Однако потом меня поправили в комментариях, что у сей буквы в 2017-ом появился её аналог со шифтом. Промариновавшись в фоне где-то часочек эта мысль навела меня на то, что я дурак и забыл про `mb`. И тут вскрылось такое...
ẞ – большая, ß – маленькая. Как можно заметить, большая эсцет (ẞ) при её понижении спокойно превращается в маленькую (ß), но вот маленькая эсцет при вознесении её шифтом животворящим внезапно превращается в "*SS*". То есть применяется её написание до 2017 года.
И при том, каждая из этих "S" – это отдельный символ. То есть если потом опять понизить регистр – вы не получите исходный вариант:
Вот такие вот могут быть подводные камни при работе с регистрами.
/ОТРЕДАКТИРОВАНО
Не будем забывать, что навязанные обязательства на пароль, порой, могут зафейлить просто безупречно подбороустойчивый экземпляр:
Поэтому, на самом деле правильным будет никак не ограничивать пользователя в его паролях. В конце концов, безопасность пользователя – это дело пользователя. Наша же задача как бэкендеров лишь обеспечить безопасность системы (в плане утечек) и хранения (хотя бы захэшировать с солью). Ну и защититься от брутфорса какой-нибудь рекапчей после трёх попыток.
А пароль пользователя должен просто... быть?..
```
php
//...
if ($password1 === '')) {
throw new ValidationError('Придумайте пароль');
}
if ($password1 !== $password2)) {
throw new ValidationError('Пароли не совпадают. Проверьте внимательно и попробуйте ещё раз');
}
//encrypt password and do things</code
``` | https://habr.com/ru/post/714478/ | null | ru | null |
# Пример создания среды виртуализации в Gentoo
«Скажи мне, Рождённый Женщиной,
— вопросил Кришна,
Куда движутся эти миры,
Зачем злой Парвана по ночам охотится
за своей второй сущностью,
И почему у ласточки Бшакти две ноги,
а у Меня двадцать четыре?»
— Элементарно, — сказал Арджуна, — берём вектор Пойнтинга…
БХАГАВАД-ГИТА (мл. тибетская)
Запев 30 тома
### Предыстория
Когда-то давно для создания виртуальных машин (далее ВМ) в Gentoo Linux я использовал libvirt, всё бы ничего, но однажды свет увидела версия Qemu с поддержкой чипсета Q35, libvirt же ещё долгое (как мне казалось) время предлагал пользоваться только одним старым добрым i440FX. Хотелось попробовать новомодную функцию, не потеряв при этом в удобстве создания ВМ. После череды проб и ошибок получилась среда виртуализации на чистом Qemu, удобная и простая (по крайней мере, на мой взгляд), пригодная для быстрого создания похожих ВМ, как правило, недолгоживущих, так как специфика моей работы заключается именно в установке операционных систем (далее ОС) и программного обеспечения (далее ПО) на голые сервера. ОС — это обычно CentOS, Astra Linux, Windows Server. Выходит, новая версия ОС или ПО — создаются новые пустые ВМ для отработки установки всей совокупности ПО.
### Дано
| | |
| --- | --- |
| ОС хоста | Gentoo Linux
Профиль default/linux/amd64/17.1/no-multilib |
| Ядро | sys-kernel/gentoo-sources-5.13.0-r1
USE=«experimental symlink»
Здесь и далее снятые USE-флаги не показаны.
**Внимание:** версия ядра 5.13.0 содержала ошибку в коде сервера NFS (см., например, [elrepo.org/bugs/view.php?id=1116](https://elrepo.org/bugs/view.php?id=1116)), поэтому под ним не работала сетевая установка CentOS с помощью NFS |
| Менеджер служб | sys-apps/systemd-248.3-r1
USE=«gcrypt hwdb kmod lz4 pam pcre policykit seccomp split-usr sysv-utils zstd» |
| Управление логическими томами | sys-fs/lvm2-2.02.188
USE=«systemd thin udev» |
| Пользовательские инструменты виртуализации | app-emulation/qemu-6.0.0-r50
USE=«caps io-uring usb vhost-net vnc»
QEMU\_SOFTMMU\_TARGETS=«x86\_64»
QEMU\_USER\_TARGETS="" |
| Просмотрщик VNC | net-libs/gtk-vnc-1.2.0
USE=«introspection vala»
К сожалению, по непонятным причинам этот ebuild с некоторых пор не устанавливает собственно клиент VNC, его приходится собирать отдельно такими командами:
ebuild /путь/до/дерева/портежей/net-libs/gtk-vnc/gtk-vnc-1.2.0.ebuild unpack
ebuild /путь/до/дерева/портежей/net-libs/gtk-vnc/gtk-vnc-1.2.0.ebuild compile
После этого шага собранный gvncviewer копируется из временного каталога сборки в /usr/local/bin, например |
| Управление сетью | net-misc/connman-1.40
USE=«ethernet nftables wifi» |
| Сетевой экран | net-firewall/nftables-0.9.9
USE=«gmp modern-kernel» |
| Сервер DNS, DHCP и TFTP | net-dns/dnsmasq-2.85
USE=«dhcp idn inotify libidn2 tftp» |
| Сервер HTTP и FTP | sys-apps/busybox-1.33.1
USE=«savedconfig systemd»
Вполне хватает для сетевой установки гостевых ОС |
| Сервер CIFS | net-fs/samba-4.14.5-r1
USE=«system-mitkrb5 systemd»
Нужен для сетевой установки гостевого Windows Server |
| Средство для подключения к сокетам Unix | net-misc/socat-1.7.4.1
USE="" |
| Оконный менеджер | gui-wm/sway-1.6.1
USE=«X man swaybar swaybg swayidle swaylock swaymsg swaynag tray»
Указываю здесь на всякий случай, так как следующий пункт с этим связан |
| Средство автоматизации | gui-apps/ydotool-0.1.9
Этот ebuild отсутствует в официальном дереве портежей, его нужно взять из оверлея pg\_overlay, оттуда же берутся две зависимости:
dev-libs/libevdevplus-0.1.1
dev-libs/libuinputplus-0.1.4 |
### Настройка ядра
```
General setup --->
[*] Configure standard kernel features (expert users) --->
```
*# Выберем такой тип AIO (Asynchronous Input/Output) для ВМ, опять же, ужасно новомодный*
```
[*] Enable IO uring support
[*] Virtualization --->
```
*# Без KVM, полагаю, ВМ будут о-о-очень медленными*
```
<*> Kernel-based Virtual Machine (KVM) support
```
*# Следующие две настройки зависят от производителя центрального процессора (далее ЦП) хоста (мне достался Intel)*
```
<*> KVM for Intel (and compatible) processors support
< > KVM for AMD processors support
[*] Networking support --->
Networking options --->
```
*# Полезно для сетевого взаимодействия с ВМ*
```
<*> 802.1d Ethernet Bridging
Device Drivers --->
[*] Block devices --->
```
*# Для монтирования ISO-образов, понадобится при сетевой установке гостевых ОС*
```
<*> Loopback device support
[*] Multiple devices driver support (RAID and LVM) --->
<*> Device mapper support
```
*# Для создания снапшотов ВМ*
```
<*> Snapshot target
```
*# Для бережного использования диска хоста*
```
<*> Thin provisioning target
[*] Network device support --->
[*] Network core driver support
```
*# Полезно для сетевого взаимодействия с ВМ*
```
<*> Universal TUN/TAP device driver support
Input device support --->
[*] Miscellaneous devices --->
```
*# Это совсем не обязательно, но пригодится для автоматизации некоторых операций с ВМ*
```
User level driver support
```
*# Для ускорения работы сети в ВМ*
```
[*] VHOST drivers --->
<*> Host kernel accelerator for virtio net
File systems --->
CD-ROM/DVD Filesystems --->
```
*# Для монтирования ISO-образов, понадобится при сетевой установке гостевых ОС*
```
ISO 9660 CDROM file system support
[\*] Microsoft Joliet CDROM extensions
```
*# Для монтирования ISO-образов, понадобится при сетевой установке гостевой Windows Server*
```
UDF file system support
Pseudo filesystems --->
```
# Очень рекомендуется использовать огромные страницы для ВМ
```
[*] HugeTLB file system support
[*] Network File Systems --->
```
*# Понадобится при сетевой установке гостевой CentOS*
```
NFS server support
[\*] NFS server support for NFS version 4
```
**Для справки привожу выдержку из /usr/src/linux/.config:**
`CONFIG_IO_URING=y
CONFIG_VIRTUALIZATION=y
CONFIG_KVM=y
CONFIG_KVM_INTEL=y
CONFIG_BRIDGE=y
CONFIG_BLK_DEV_LOOP=y
CONFIG_DM_SNAPSHOT=y
CONFIG_DM_THIN_PROVISIONING=y
CONFIG_TUN=y
CONFIG_INPUT_UINPUT=m
CONFIG_VHOST_NET=y
CONFIG_ISO9660_FS=m
CONFIG_JOLIET=y
CONFIG_UDF_FS=m
CONFIG_HUGETLBFS=y
CONFIG_NFSD=m
CONFIG_NFSD_V4=y`
Настройки, нужные для сетевого экрана, не привожу, чтобы не повторяться, они имеются в другой статье, под названием: «[Прозрачный Squid с SSL-Bump для Gentoo с nft](https://habr.com/ru/company/infowatch/blog/492260/)».
### Настройка дискового хранилища
Допустим, у нас имеется 500 ГБ свободного пространства в группе томов «vg», создадим в нём так называемый «тонкий пул» с именем «thin»:
```
lvm lvcreate -c 64M -I 64M -L 500G -Zn --type thin-pool --thinpool thin vg
```
Ключ -Zn отключает обнуление первого блока создаваемых в этом пуле логических томов.
### Настройка оперативной памяти
Мой ЦП поддерживает только двухмегабайтные огромные страницы, для гигабайтных нужны дополнительные настройки загрузчика. Количество огромных страниц зададим в /etc/sysctl.conf:
```
vm.nr_hugepages = 5000
```
Hugetlbs автоматически монтируется менеджером служб Systemd в /dev/hugepages.
### Настройка сети
До перехода с OpenRC на Systemd никаких сложностей с настройкой сети не было. Так как Systemd может настроить только предельно простую сеть (по крайней мере, пока), после перехода потребовалась установка службы настройки сети, в этом качестве был выбран connman. Однако он не подходит для создания сетевого моста. Systemd мог бы создать своими средствами мост, но он не назначает пустому мосту IP-адрес.
В итоге пришлось создать отдельную службу /etc/systemd/system/create-br0.service:
```
[Unit]
Description=Bridge creation.
Before=network-pre.target
Before=nftables-restore.service
[Service]
Type=simple
ExecStart=/bin/bash /usr/local/sbin/create-br0.sh
RemainAfterExit=yes
[Install]
WantedBy=nftables-restore.service
WantedBy=dnsmasq.service
```
Сценарий /usr/local/sbin/create-br0.sh у меня выглядит так:
```
#!/bin/sh
ip link add br0 type bridge
ip link set br0 address 8e:fb:65:16:72:38
ip link set br0 up
ip addr add 192.168.120.1/24 dev br0
```
Чтобы connman не мешал, исключим в его настройках мост и сетевые стыки ВМ, в итоге /etc/connman/main.conf выглядит так:
```
[General]
AllowDomainnameUpdates=false
AllowHostnameUpdates=false
NetworkInterfaceBlacklist=lo,vnet,br
```
Настройка nft, за вычетом всего, никак не касающегося ВМ, выглядит так:
*#!/sbin/nft -f*
```
define icmp_types = { destination-unreachable, time-exceeded, parameter-problem, timestamp-request, echo-request, echo-reply }
define br = br0
define host = 192.168.120.1
define virtual_machines = 192.168.120.0/24
define br_bcast = 192.168.120.255
define eth = enp0s25
define wifi = wlp2s0
define dhcp_client = 192.168.120.224/27
```
*# ВМ с выходом в Интернет*
```
define privileged_vm = { 192.168.120.22, 192.168.120.127, 192.168.120.129 }
define nat_if = { $eth, $wifi }
define squid = 3128
flush ruleset
table ip filter {
chain input {
type filter hook input priority 0; policy drop;
iif lo accept comment "allow loopback"
icmp type $icmp_types accept comment "allow important ICMP types"
ct state invalid counter drop comment "drop invalid packets"
tcp flags syn tcp option maxseg size < 999 counter drop comment "TCP SACK Panic workaround"
tcp flags & (syn | ack) == syn ct state untracked counter drop comment "drop initial packets from untracked ports"
iif $br ip daddr $host ip saddr $virtual_machines tcp dport { domain, http, https, microsoft-ds, nfs, $squid, ftp } accept comment "allow services for virtual machines"
ct state { established, related } accept comment "allow all related connections"
iif $br udp dport { domain, bootps, tftp, 4011 } counter accept comment "allow DNS, DHCP, TFTP, proxyDHCP"
counter comment "count dropped packets"
}
chain output {
type filter hook output priority 100; policy drop;
oif lo accept comment "allow loopback"
icmp type $icmp_types counter accept comment "allow important ICMP types"
oif { $eth, $wifi } udp dport . udp sport { bootps . bootpc } counter accept comment "allow exchange with DHCP servers"
oif $br ip saddr $host ip daddr { $dhcp_client, 255.255.255.255 } udp sport . udp dport { bootps . bootpc } counter accept comment "allow DHCP of dnsmasq"
oif $br ip saddr $host ip daddr $virtual_machines udp sport { domain, tftp } counter accept comment "allow DNS, TFTP"
oif $br ip saddr $host ip daddr $virtual_machines tcp sport { domain, http, https, microsoft-ds, ftp } accept comment "allow DNS, HTTP, Samba, FTP"
meta l4proto { tcp, udp } th sport >= 1025 accept comment "allow unprivileged ports"
counter comment "count dropped packets"
}
chain forward {
type filter hook forward priority 0; policy drop;
tcp flags syn tcp option maxseg size set rt mtu counter comment "clamp TCP MSS to path MTU"
iif $br ip daddr != $host meta l4proto { tcp, udp } th dport domain drop comment "deny DNS to external servers"
iif $br ip saddr { $privileged_vm, $dhcp_client } accept comment "allow privileged virtual machine & DHCP clients"
oif $br ip daddr { $privileged_vm, $dhcp_client } accept comment "allow privileged virtual machine & DHCP clients"
counter comment "count dropped packets"
}
}
table ip nat {
chain postrouting {
type nat hook postrouting priority 100; policy accept;
oif $nat_if ip saddr { $privileged_vm, $dhcp_client } counter masquerade comment "masquerade virtual machine"
}
}
```
### Сценарий запуска ВМ
Для запуска по запросу отдельных ВМ нам понадобится следующий простой сценарий, назовём его /usr/local/sbin/qemu:
```
#!/bin/bash
VM=$2
if [[ "$1" != status && -z "$VM" ]]; then
echo "No VM name was supplied"
exit 4
fi
WAIT=60
CFGDIR=/etc/qemu
CHROOT=/var/tmp/qemu/empty
export LVM_SUPPRESS_FD_WARNINGS=1
[ -f /etc/conf.d/qemu.$VM ] && . /etc/conf.d/qemu.$VM
CFG=$CFGDIR/$VM.cfg
case $1 in
start)
if [[ -r $CFG ]]; then
CPU=`sed -ne '/#CPU/{s/.*=\(.*\)/\1/p;q}' $CFG`
X[0]=`sed -ne '/#MEM/{s/.*=\(.*\)/\1/p;q}' $CFG`
if grep '^#kernel=' $CFG &> /dev/null; then
X[1]='-kernel'
X[2]=`sed -ne '/#kernel/{s/[^=]*=\(.*\)/\1/p;q}' $CFG`
X[3]='-append'
X[4]=`sed -ne '/#append/{s/[^=]*=\(.*\)/\1/p;q}' $CFG`
X[5]='-initrd'
X[7]=`sed -ne '/#initrd/{s/[^=]*=\(.*\)/\1/p;q}' $CFG`
fi
N=`sed -ne '/= "vnet[0-9]/{s/.*"vnet\([0-9]\+\).*/\1/p;q}' $CFG`
echo "Starting $VM"
taskset -c $CPU qemu-system-x86_64 -name $VM -nodefaults -daemonize -runas qemu -cpu host -machine q35 -readconfig $CFG -m "${X[@]}" \
-mem-prealloc -mem-path /dev/hugepages -rtc base=utc -chroot $CHROOT -vga virtio -audiodev id=none,driver=none \
-object rng-random,filename=/dev/urandom,id=rng0 -device virtio-rng-pci,rng=rng0,id=vrng0,max-bytes=1024,period=200 -vnc 127.0.0.1:$N || exit 1
else
echo "Unrecognized VM: $VM"
exit 3
fi
;;
stop)
if [[ -r $CFG ]]; then
PID=`pgrep -f "qemu-system-x86_64 -name $VM "`
if [[ -n $PID ]]; then
echo "Stopping $VM"
MON=`sed -ne 's/^\s*path\s*=\s*"\(.*\)"/\1/p' $CFG`
echo '{ "execute": "qmp_capabilities" } { "execute": "system_powerdown" }' | socat - $MON > /dev/null
while ps -p $PID >/dev/null 2>&1; do
[[ $((i++)) -ge $WAIT ]] && break || sleep 1
done
[[ $i -gt $WAIT ]] && kill $PID
fi
[[ $i -gt $WAIT ]] && sleep 2
pgrep -f "qemu-system-x86_64 -name $VM " && exit 1
else
echo "Unrecognized VM: $VM"
exit 3
fi
;;
status)
ps -eo args | sed -ne 's/.*[q]emu-system-x86_64 -name \([^ ]\+\) .* -vnc \([^ ]\+\)/\1\t\2/p'
;;
*)
echo "Unrecognized command: $1"
exit 2
;;
esac
```
Как видно из строки запуска qemu-system-x86\_64:
1. Процесс привязывается к определённому набору логических процессоров (командой taskset). Набор процессоров определяется в настроечном файле ВМ.
2. Процесс работает с правами пользователя qemu (-runas qemu). Если он не создан, то его нужно создать с домашним каталогом /dev/null и оболочкой /sbin/nologin. Данный пользователь должен входить в группу kvm.
3. Процессор для ВМ используется хостовый, без изменений (-cpu host). Чипсет — Q35 (-machine q35), из-за чего всё и начиналось.
4. Большая часть оборудования берётся из настроечного файла ВМ (-readconfig $CFG).
5. Память ВМ выделяется полностью (-mem-prealloc), для чего используются огромные страницы (-mem-path /dev/hugepages). Размер памяти берётся из настроечного файла ВМ (-m "${X[@]}"). Как вы можете заметить, в массиве $X передаётся не только размер памяти, но и некоторые другие настройки.
6. Время БИОСа в ВМ будет в часовом поясе UTC (-rtc base=utc), это рекомендуется для Unix-подобных систем. Для Windows это не вызовет сложностей, так как с помощью редактирования реестра можно научить её понимать такое время.
7. Процесс запирает себя в каталоге /var/tmp/qemu/empty с помощью вызова chroot (-chroot $CHROOT). В этот каталог мы позже поместим образ виртуального съёмного устройства хранения («флешки»).
8. Audio-устройства ВМ не предоставляются (-audiodev id=none,driver=none). Обычно хватает перенаправления аудио с помощью RDP в случае ВМ на Windows.
9. Каждой ВМ предоставляется устройство Virtio-RNG — паравиртуальный генератор случайных чисел (-object rng-random,filename=/dev/urandom,id=rng0 -device virtio-rng-pci,rng=rng0,id=vrng0,max-bytes=1024,period=200).
10. Для доступа к консоли ВМ предоставляется VNC на адресе 127.0.0.1, номер экрана задаётся в настроечном файле (-vnc 127.0.0.1:$N).
Кроме этого сценария есть ещё один вспомогательный, /etc/qemu/ifup.sh:
```
#!/bin/bash
ip link set $1 master br0
ip link set $1 up
```
### Создание ВМ
**Выделение места в дисковом хранилище**
Место выделяется в тонком пуле следующей командой:
```
lvm lvcreate -T vg/thin -V 10G -n ubuntu
```
Будет создан логический том размером 10 ГБ, путь к блочному устройству /dev/mapper/vg-ubuntu. Пока гостевая ОС не установлена, этот том места на диске не занимает.
**Создание настроечного файла ВМ**
Для каждой ВМ создаётся отдельный настроечный файл /etc/qemu/Имя\_ВМ.cfg. Пример для линуксовой ВМ:
# qemu config file
# Эта директива используется сценарием запуска ВМ
# определяет, к каким процессорам привязывается процесс qemu
#CPU=0,1,2,3
# Эта директива используется сценарием запуска ВМ
# определяет размер памяти ВМ в МБ
#MEM=4096
# Следующие три директивы используются сценарием запуска ВМ
# используются для непосредственного запуска ядра самим qemu
#kernel=/var/tmp/qemu/vmlinuz-3.10.0-957.el7.x86\_64
#initrd=/var/tmp/qemu/initramfs-3.10.0-957.el7.x86\_64.img
#append=ro root=/dev/vda1 elevator=noop numa=off transparent\_hugepage=never nosoftlockup mce=ignore\_ce audit=0
# Следующие два блока настраивают первый виртуальный привод DVD
# используются при установке ОС с виртуального привода DVD
```
[drive "cd0"]
file = "/opt/dist/ks-CentOS_2009-tm_7.2.0.155.iso"
if = "none"
readonly = "on"
format = "raw"
[device]
driver = "ide-cd"
drive = "cd0"
bus = "ide.0"
unit = "0"
```
# Следующие два блока настраивают первый виртуальный жёсткий диск ВМ
```
[drive "vhd0"]
file = "/dev/mapper/vg-centos"
if = "none"
format = "raw"
```
# Кеш в небезопасном режиме для скорости, надёжность хранения не важна в моём случае.
# Либо же, например, можно использовать такой режим при установке гостевой ОС,
# а затем переключиться в режим «none»
```
cache = "unsafe"
cache.direct = "on"
aio = "io_uring"
[device "virtio0"]
driver = "virtio-blk-pci"
scsi = "off"
bus = "pcie.0"
drive = "vhd0"
```
# Настройка сокета для взаимодействия с qemu с помощью команд QMP (QEMU Machine Protocol)
```
[chardev "charmonitor"]
backend = "socket"
path = "/var/tmp/qemu/centos.monitor"
server = "on"
wait = "off"
```
# Следующие два блока настраивают первый сетевой стык ВМ
```
[device "net0"]
driver = "virtio-net-pci"
netdev = "hostnet0"
mac = "52:54:00:07:00:08"
bus = "pcie.0"
```
# Настройка многоочерёдного (mutliqueue) сетевого стыка ВМ
# требуется поддержка и настройка в гостевой ОС (см. далее)
# число должно быть равно 2 \* M + 2, где M — число логических процессоров ВМ
```
vectors = "10"
mq = "on"
[netdev "hostnet0"]
type = "tap"
```
# Число после «vnet» определяет номер экрана VNC
```
ifname = "vnet6"
vhost = "on"
script = "/etc/qemu/ifup.sh"
downscript = "no"
```
# Настройка многоочерёдного (multiqueue) сетевого стыка ВМ
# в гостевой ОС включается командой: ethtool -L eth0 combined 4
# число должно быть равно М, где M — число логических процессоров ВМ
```
queues = "4"
[mon]
chardev = "charmonitor"
mode = "control"
[machine]
type = "q35"
accel = "kvm"
usb = "on"
```
# Конфигурация процессора с точки зрения ВМ
```
[smp-opts]
sockets = "1"
cores = "2"
threads = "2"
```
# Следующие два блока переводят ВМ в режим UEFI
```
[drive]
file = "/usr/share/edk2-ovmf/OVMF_CODE.fd"
if = "pflash"
format = "raw"
unit = "0"
readonly = "on"
[drive]
file = "/var/tmp/qemu/OVMF_VARS_tm72p.fd"
if = "pflash"
format = "raw"
unit = "1"
```
**Пример для ВМ c Windows:**
# qemu config file
#MEM=3072
#CPU=2,3
# Следующие четыре блока настраивают два виртуальных привода DVD
# используются при установке ОС с виртуального привода DVD
```
[drive "cd0"]
file = "/opt/distr/windows_server.iso"
if = "none"
readonly = "on"
format = "raw"
[device]
driver = "ide-cd"
drive = "cd0"
bus = "ide.0"
unit = "0"
[drive "cd1"]
```
# Второй привод DVD нужен для предоставления установщику Windows драйверов устройств Virtio
```
file = "/opt/distr/virtio-win-0.1.190.iso"
if = "none"
readonly = "on"
format = "raw"
[device]
driver = "ide-cd"
drive = "cd1"
bus = "ide.1"
unit = "0"
[drive "vhd0"]
file = "/dev/mapper/vg-windoze"
if = "none"
format = "raw"
cache = "unsafe"
cache.direct = "on"
aio = "io_uring"
[device "virtio0"]
driver = "virtio-blk-pci"
scsi = "off"
bus = "pcie.0"
drive = "vhd0"
[chardev "charmonitor"]
backend = "socket"
path = "/var/tmp/qemu/windoze.monitor"
server = "on"
wait = "off"
[device "net0"]
driver = "virtio-net-pci"
netdev = "hostnet0"
mac = "52:54:00:20:12:04"
bus = "pcie.0"
[netdev "hostnet0"]
type = "tap"
ifname = "vnet8"
vhost = "on"
script = "/etc/qemu/ifup.sh"
downscript = "no"
```
# Нужно для комфортной работы через VNC
```
[device "tablet"]
driver = "usb-tablet"
[mon]
chardev = "charmonitor"
mode = "control"
[machine]
type = "q35"
accel = "kvm"
usb = "on"
[smp-opts]
cpus = "2"
```
**Подготовка вспомогательных файлов**
При работе ВМ в режиме UEFI для каждой ВМ нужно скопировать /usr/share/edk2-ovmf/OVMF\_VARS.fd в отдельный файл в каталоге Qemu, в моём примере /var/tmp/qemu.
Для дополнительных настроек запуска ВМ предусмотрен ещё один конфигурационный файл: /etc/conf.d/qemu.Имя\_ВМ (как наследство OpenRC). Содержит одну строку с переменной QEMU\_OPTS. Пример для загрузки по сети:
```
QEMU_OPTS="-boot order=n"
```
Замечание, касающееся Systemd: до перехода с OpenRC я широко использовал каталог /var/tmp (в моём случае это отдельный раздел) для хранения разнородных данных, например, данных qemu. После перехода на Systemd выяснилось, что в нём имеется служба systemd-tmpfiles-clean, которая удалила, к моему сожалению, из /var/tmp много нужных файлов. Чтобы защитить файлы qemu, был создан настроечный файл /usr/lib/tmpfiles.d/qemu.conf:
```
d /var/tmp/qemu 0755 qemu qemu -
```
### Запуск и остановка ВМ
Запуск ВМ по требованию выглядит так:
```
/usr/local/sbin/qemu start Имя_ВМ
```
Остановка соответственно:
```
/usr/local/sbin/qemu stop Имя_ВМ
```
Получение перечня запущенных ВМ:
```
/usr/local/sbin/qemu status
```
### Подключение к ВМ хостовых устройств USB на постоянной основе
В настроечный файл достаточно добавить блок с указанием VID и PID устройства, например:
```
[device "usbaudio"]
driver = "usb-host"
vendorid = "0x041e"
productid = "0x30e0"
```
Поскольку эти настройки, как я заметил, производятся программой qemu до сброса администраторских привилегий, менять владельца устройства на qemu:qemu необязательно.
### Подключение к работающей ВМ виртуального съёмного устройства хранения («флешки»)
Предварительно должен быть создан образ виртуального съёмного устройства, например, размером в 1 ГБ, в каталоге $CHROOT (в моём случае это /var/tmp/qemu/empty):
```
truncate -s 1G /var/tmp/qemu/empty/usb.img
chown qemu:qemu /var/tmp/qemu/empty/usb.img
```
Поскольку в нашей установке графика у ВМ предоставляется только посредством VNC, то командная строка Qemu Monitor недоступна. Поэтому будем пользоваться протоколом QMP, подключаясь к сокету, указанному в настроечном файле:
```
socat - /var/tmp/qemu/windoze.monitor
```
После успешного подключения к сокету в первую очередь даём команду:
```
{ "execute": "qmp_capabilities" }
```
Затем следуют команды подключения устройства (отформатировано для удобства просмотра):
```
{
"execute": "human-monitor-command",
"arguments": {
"command-line": "drive_add auto if=none,id=hd1,file=/usb.img,cache=writeback,cache.direct=on,aio=io_uring,format=raw"
}
}
{
"execute": "device_add",
"arguments": {
"driver": "usb-storage",
"drive": "hd1",
"id": "usb1"
}
}
```
Команды отключения устройства будут, соответственно, такими:
```
{ "execute": "device_del", "arguments": { "id": "usb1" } }
{ "execute": "human-monitor-command", "arguments": { "command-line": "drive_del hd1" } }
```
### Создание снимка (снапшота) выключенной ВМ
Создание снимка делается средствами LVM:
```
lvm lvcreate -s vg/centos -n centos_bak
```
Обратите внимание, что снимок помечается как не подлежащий автоматической активации LVM.
### Перенос диска ВМ из одного пула в другой
На определённом этапе мне потребовалось создать новый тонкий пул и перенести на него логические тома нескольких использовавшихся тогда ВМ. Это делается предельно просто командой dd, предварительно необходимо создать в новом тонком пуле соответствующие логические тома:
```
dd if=/dev/vg/some_vm of=/dev/other_vg/some_vm bs=64M conv=sparse
```
Здесь ключевым является «conv=sparse», нужный для того, чтобы логический том занимал только фактически использованное ВМ место.
### Автозапуск ВМ при запуске хоста
Иногда требуется, чтобы ВМ запускалась одновременно с остальными службами хоста. Для таких случаев подготовим другой сценарий, назовём его /usr/local/bin/guests:
```
#!/bin/bash
export LVM_SUPPRESS_FD_WARNINGS=1
CFGDIR=/etc/qemu
case $1 in
start)
CHROOT=/var/tmp/qemu/empty
for CFG in $CFGDIR/*.cfg; do
VM=${CFG##*/}
VM=${VM%.cfg}
[ -f /etc/conf.d/qemu.$VM ] && . /etc/conf.d/qemu.$VM
CPU=`sed -ne '/#CPU/{s/.*=\(.*\)/\1/p;q}' $CFG`
X[0]=`sed -ne '/#MEM/{s/.*=\(.*\)/\1/p;q}' $CFG`
if grep '^#kernel=' $CFG &> /dev/null; then
X[1]='-kernel'
X[2]=`sed -ne '/#kernel/{s/[^=]*=\(.*\)/\1/p;q}' $CFG`
X[3]='-append'
X[4]=`sed -ne '/#append/{s/[^=]*=\(.*\)/\1/p;q}' $CFG`
X[5]='-initrd'
X[7]=`sed -ne '/#initrd/{s/[^=]*=\(.*\)/\1/p;q}' $CFG`
fi
N=`sed -ne '/= "vnet[0-9]/{s/.*"vnet\([0-9]\+\).*/\1/p;q}' $CFG`
echo "Starting $VM"
taskset -c $CPU qemu-system-x86_64 -name $VM -nodefaults -daemonize -runas qemu -cpu host -machine q35 -readconfig $CFG -m "${X[@]}" \
-mem-prealloc -mem-path /dev/hugepages -rtc base=utc -chroot $CHROOT -vga virtio -audiodev id=none,driver=none \
-object rng-random,filename=/dev/urandom,id=rng0 -device virtio-rng-pci,rng=rng0,id=vrng0,max-bytes=1024,period=200 -vnc 127.0.0.1:$N
done
;;
stop)
WAIT=60
for CFG in $CFGDIR/*.cfg; do
VM=${CFG##*/}
VM=${VM%.cfg}
PID=`pgrep -f "qemu-system-x86_64 -name $VM "`
if [[ -n $PID ]]; then
echo "Stopping $VM"
MON=`sed -ne 's/^\s*path\s*=\s*"\(.*\)"/\1/p' $CFG`
echo '{ "execute": "qmp_capabilities" } { "execute": "system_powerdown" }' | socat - $MON > /dev/null
while ps -p $PID >/dev/null 2>&1; do
[[ $((i++)) -ge $WAIT ]] && break || sleep 1
done
[[ $i -gt $WAIT ]] && kill $PID
fi
[[ $i -gt $WAIT ]] && sleep 2
pgrep -f "qemu-system-x86_64 -name $VM " && exit 1
done
;;
status)
ps -eo args | sed -ne 's/.*[q]emu-system-x86_64 -name \([^ ]\+\) .* -vnc \([^ ]\+\)/\1\t\2/p'
;;
*)
echo "Unrecognized command: $1"
exit 2
;;
esac
```
Собственно для запуска создаётся служба /usr/lib/systemd/system/guests.service:
```
[Unit]
Description=Qemu-KVM guests service.
After=network.target
[Service]
Type=forking
ExecStart=/bin/bash /usr/local/bin/guests start
ExecStop=/bin/bash /usr/local/bin/guests stop
[Install]
WantedBy=multi-user.target
```
### Настройка сетевой установки гостевых ОС
Все файлы, нужные для сетевой установки, поместим в разделе /netboot.
**DHCP и TFTP**
В качестве основного приложения, обеспечивающего сетевую установку, будем использовать dnsmasq. Привожу часть его конфигурации, касающуюся DHCP и TFTP:
`dhcp-range=192.168.120.225,192.168.120.252,3h
dhcp-option=option:netmask,255.255.255.0
dhcp-option=option:router,192.168.120.1
dhcp-option=option:dns-server,192.168.120.1
dhcp-option=option:domain-name,shadow.amn
dhcp-option-force=209,pxelinux.cfg/default
dhcp-authoritative
dhcp-vendorclass=set:uefi,"PXEClient:Arch:00007"
dhcp-match=set:uefi,option:client-arch,7
enable-tftp
tftp-root=/netboot/tftp
dhcp-boot=pxelinux.0,host.shadow.amn,192.168.120.1
dhcp-boot=tag:uefi,grubx64.efi,host.shadow.amn,192.168.120.1
pxe-prompt="Press F8 for PXE Network boot.",10
pxe-service=x86PC,"Boot from local disk"
pxe-service=x86PC,"Install OS via PXE",pxelinux`
Корнем TFTP указан каталог /netboot/tftp. Поместим в него следующие файлы:
1. Для PXE в режиме BIOS:
* pxelinux.0, ldlinux.c32, libcom32.c32, libutil.c32, vesamenu.c32 и memdisk из sys-boot/syslinux.
* Каталог pxelinux.cfg с файлом default, представляющим собой меню загрузчика pxelinux.
2. Для PXE в режиме UEFI:
* grubx64.efi с установочного DVD CentOS 7.9 (находится в EFI/BOOT).
* grub.cfg, представляющим собой меню загрузчика Grub.
* Символьную ссылку grub.cfg-00000000-0000-0000-0000-000000000000 на файл grub.cfg.
3. Для ВМ на CentOS: каталог centos, содержащий файлы initrd.img и vmlinuz с установочного DVD CentOS 7.9 (находятся в images/pxeboot).
4. Для ВМ на Astra Linux: каталог astra, содержащий файлы initrd.gz и linux с установочного DVD Astra Linux.
5. Для ВМ на Windows:
* каталог windows, содержащий файлы BCD, bootmgr.exe, boot.sdi, pxeboot.0 и winpe.wim, подготовленные с помощью Windows Assessment and Deployment Kit (Windows ADK), пустые файлы boot.ini и hiberfil.sys, каталог Fonts с файлом wgl4\_boot.ttf.
* Символьную ссылку Boot на каталог windows.
* Символьную ссылку boot.ini на windows/boot.ini.
* Символьную ссылку bootmgr.exe на windows/bootmgr.exe.
* Символьную ссылку hiberfil.sys на windows/hiberfil.sys.
Пример файла grub.cfg:
```
set timeout=60
menuentry 'Rescue installed system (CentOS)' {
linuxefi centos/vmlinuz inst.stage2=nfs:nfsvers=4:192.168.120.1:/netboot/nfs rescue selinux=0
initrdefi centos/initrd.img
}
menuentry 'Install CentOS' {
linuxefi centos/vmlinuz rd.net.timeout.carrier=15 inst.repo=nfs:nfsvers=4:192.168.120.1:/netboot/nfs inst.ks=http://192.168.120.1/ks.cfg inst.sshd
initrdefi centos/initrd.img
}
menuentry 'Install Astra Linux' {
linuxefi astra/linux auto=true priority=critical debian-installer/locale=ru_RU console-keymaps-at/keymap=ru url=ftp://192.168.120.1/preseed.cfg interface=auto netcfg/dhcp_timeout=60
initrdefi astra/initrd.gz
}
```
Пример файла pxelinux.cfg/default:
```
default vesamenu.c32
label CentOS
kernel centos/vmlinuz
append initrd=centos/initrd.img rd.net.timeout.carrier=15 inst.repo=nfs:nfsvers=4:192.168.120.1:/netboot/nfs inst.ks=http://192.168.120.1/ks.cfg inst.sshd
label Astra
menu label Astra Linux
kernel astra/linux
append initrd=astra/initrd.gz auto=true priority=critical debian-installer/locale=ru_RU console-keymaps-at/keymap=ru url=ftp://192.168.120.1/preseed.cfg interface=auto netcfg/dhcp_timeout=60
label Windows
menu label Windows Server
kernel windows/pxeboot.0
```
**NFS**
Каталог /netboot/nfs будет точкой монтирования ISO-образа установочного DVD CentOS.
Настроечный файл /etc/exports.d/netboot.exports для сетевой установки CentOS через NFS выглядит так:
```
/netboot/nfs -sec=sys,mp,async,no_root_squash,no_subtree_check 192.168.120.0/24
```
**HTTP и FTP**
В каталогe /netboot/http будет размещаться ks.cfg — кикстарт для CentOS, в каталоге /netboot/ftp будет размещаться preseed.cfg — аналог кикстарта для Astra Linux и пустой каталог astra — точка монтирования ISO-образа установочного DVD Astra Linux.
Я решил не усложнять задачу установкой полновесных веб- и FTP-серверов, воспользовался апплетами busybox’а. Для запуска их как служб очень хорошо подошёл Systemd.
Создадим службу /etc/systemd/system/httpd@.service:
```
[Unit]
Description=Busybox HTTPd
Requires=httpd.socket
[Service]
Type=simple
ExecStart=/sbin/httpd -h /netboot/http/ -vvfi
StandardInput=socket
StandardError=journal
TimeoutStopSec=60
[Install]
WantedBy=multi-user.target
```
И соответствующий ей сокет /etc/systemd/system/httpd.socket:
```
[Unit]
Description=Busybox HTTPd
[Socket]
ListenStream=192.168.120.1:80
Accept=yes
[Install]
WantedBy=sockets.target
```
Создадим службу /etc/systemd/system/ftpd@.service:
```
[Unit]
Description=Busybox FTPd
Requires=ftpd.socket
[Service]
Type=simple
ExecStart=/sbin/ftpd /netboot/ftp
StandardInput=socket
StandardError=journal
TimeoutStopSec=60
[Install]
WantedBy=multi-user.target
```
И соответствующий ей сокет /etc/systemd/system/ftpd.socket:
```
[Unit]
Description=Busybox FTPd
[Socket]
ListenStream=192.168.120.1:21
Accept=yes
[Install]
WantedBy=sockets.target
```
Теперь запуск httpd и ftpd становится просто запуском сокета Systemd:
```
systemctl start httpd.socket
systemctl start ftpd.socket
```
**CIFS**
В каталоге /netboot/smb создадим два пустых каталога (например, 2k16 и virtio), которые будут точками монтирования ISO-образов установочного DVD Windows Server и ISO-образа с драйверами Virtio для Windows. Правда, с установкой сетевых драйверов при сетевой установке Windows Server были сложности, решение, видимо, состоит в том, чтобы включить эти драйвера заранее в ISO-образ установочного DVD Windows Server.
Также в /netboot/smb может находиться файл autounattend.xml для автоматической установки Windows Server.
Часть настроечного файла /etc/samba/smb.conf, касающаяся сетевой установки Windows Server, выглядит так:
```
[global]
workgroup = AMN
netbios name = HOST
interfaces = 192.168.120.1/255.255.255.0
bind interfaces only = yes
load printers = no
show add printer wizard = no
server string = My notebook
disable netbios = yes
[public]
comment = Public
hosts allow = 192.168.120.0/255.255.255.0
path = /netboot/smb
force user = nobody
force group = nobody
create mask = 0644
directory mask = 0755
read only = yes
guest ok = yes
oplocks = no
level2 oplocks = no
locking = no
acl allow execute always = yes
```
Как уже было указано, файл winpe.wim был подготовлен с помощью ADK, в него были включены драйвера Virtio (обязательно viostor и netkvm), а также сценарий startnet.cmd:
`@echo off
chcp 65001
echo.
echo Запускаю wpeinit.
echo.
wpeinit
echo На выбор доступно три режима работы WinPE:
echo 1) Монтирование сетевого ресурса и возврат в оболочку.
echo.
echo 2) Монтирование сетевого ресурса и запуск установки
echo Windows Server 2016 Standard.
echo.
echo 3) Монтирование сетевого ресурса и запуск автоматической
echo установки Windows Server 2016 Standard
echo.
echo Для выбора пункта меню введите соответствующую ему цифру,
echo а затем нажмите клавишу Enter (ошибочный ввод = 1 пункт).
set /p ID=
echo.
if %ID%==1 goto :first
if %ID%==2 goto :second
if %ID%==3 goto :third
if %ID% GTR 3 goto :failure
if %ID% LSS 3 goto :failure
exit /b
:second
echo Выбран пункт меню под номером 2
echo.
echo Монтирую сетевой ресурс.
net use S: \\192.168.120.1\public
echo Запускаю S:\2k16\setup.exe
S:\2k16\setup.exe
exit /b
:third
echo Выбран пункт меню под номером 3
echo.
echo Монтирую сетевой ресурс.
net use S: \\192.168.120.1\public
echo Запускаю автоматическую установку: S:\2k16\setup.exe /unattend:S:\autounattend.xml
S:\2k16\setup.exe /unattend:S:\autounattend.xml
exit /b
:first
echo Выбран пункт меню под номером 1
echo.
:failure
echo.
echo Монтирую сетевой ресурс.
net use S: \\192.168.120.1\public
exit /b`
### Небольшая автоматизация
При установке Windows Server некоторую часть настроек приходится выполнять через VNC. Хотелось бы автоматизировать ввод длинных строк или паролей в окне просмотра VNC, чтобы сократить вероятность опечатки. Для Wayland’а имеется утилита ydotool, которая, правда, давно не обновлялась. Ею особенно, на мой взгляд, удобно пользоваться в плиточном оконном менеджере sway, так как запущенное из командной строки приложение gvncviewer всегда оказывается в одном и том же месте экрана.
Ydotool требует модуль uinput, загрузим его и дадим права на чтение и запись группе wheel, в которую входит обычная учётная запись (далее УЗ):
```
modprobe uinput
chgrp wheel /dev/uinput
chmod g+rw /dev/uinput
```
Затем, уже от имени обычной УЗ запустим демон ydotoold:
```
ydotoold &
```
Готово. Теперь запускаем gvncviewer с указанием адреса и номера экрана нашей ВМ. Возвращаемся обратно в командную строку и даём одной строкой череду команд (добавлены переводы строк для удобства чтения):
```
ydotool mousemove 350 15;
ydotool click 1;
ydotool key Alt+s;
ydotool type d;
sleep 5;
ydotool type P@ssw0rd;
ydotool key Enter
```
Данные команды произведут следующие действия:
1. переключение на окно gvncviewer,
2. выбор пункта меню «Send Key → Ctrl+Alt+Del»,
3. пятисекундное ожидание появления окна ввода пароля администратора,
4. ввод пароля,
5. нажатие клавиши Enter.
### Ссылки
1. [pavsh.ru/official/non-koncerts/stemsite-frolov/public/prosp/legendy.htm](http://pavsh.ru/official/non-koncerts/stemsite-frolov/public/prosp/legendy.htm) — эпиграф.
2. [gpo.zugaina.org](http://gpo.zugaina.org) — поиск по оверлеям Gentoo, Funtoo и Zentoo.
3. [gitlab.com/Perfect\_Gentleman/PG\_Overlay](https://gitlab.com/Perfect_Gentleman/PG_Overlay) — домашняя страница оверлея pg\_overlay.
4. [qemu-project.gitlab.io/qemu](https://qemu-project.gitlab.io/qemu/) — документация Qemu.
5. [habr.com/ru/company/infowatch/blog/492260](https://habr.com/ru/company/infowatch/blog/492260/) — описание настройки nft, уже немного устаревшее, так как создавалось до перехода на Systemd.
6. [fedorapeople.org/groups/virt/virtio-win/direct-downloads/latest-virtio](https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/latest-virtio/) — драйвера Virtio для Windows.
7. [docs.microsoft.com/ru-ru/windows-hardware/get-started/adk-install](https://docs.microsoft.com/ru-ru/windows-hardware/get-started/adk-install) — средства для развёртывания и оценки Windows (Windows ADK).
**Автор статьи:** Шамиль Саитов [Nikodim\_Tychoblin](https://habr.com/ru/users/nikodim_tychoblin/)
*«В лето 7529»* | https://habr.com/ru/post/575018/ | null | ru | null |
# Как превратить свою аватарку в Telegram в часы
Недавно сидел я в одном сообществе программистов в [Telegram](http://telegram.org) и заметил один очень любопытный профиль. Любопытным было следующее — на главном фото у него было изображено нынешнее время. Мне стало жутко интересно как он этого добился, и я решил во что бы то ни стало написать такую же программу.
До этого я часто работал с Telegram-ботами при помощи библиотеки [PyTelegramBotAPI](https://habr.com/ru/post/442800/), поэтому предположил, что такая функция есть в API ботов. Наверняка, это было глупейшее предположение в моей жизни, т.к. фото было на аватарке профиля именно **пользователя**, а не бота — и вскоре я в этом убедился, не найдя ни одной предпосылки к возможности изменить фото профиля.
Я начал сёрфить интернет и наткнулся на довольно удобный инструмент — [telethon](https://habr.com/ru/post/425151/). Он как раз и позволял мне заходить в Telegram как **юзер**, а не как бот. Что ж, полагаю это был самый первый и самый большой шаг к цели. Далее давайте разберем как же именно воссоздать «часы» на нашей аватарке.
### Шаг первый. Получить доступ к входу в Telegram из кода
Переходим по [ссылке](https://my.telegram.org), вводим номер телефона, после чего получаем код подтверждения. Подробнее об этом написано [тут](https://core.telegram.org/api/obtaining_api_id). Итак, мы получаем оттуда две важные для нас вещи — это api\_id и api\_hash. Создаем файл *config.py* и вводим туда следующий код:
```
api_id = <ВАШ API_ID>
api_hash = <ВАШ API_HASH>
```
Теперь создаем файл *main.py* в котором пишем:
```
from telethon import TelegramClient, sync
from .config import *
```
Важно, чтобы *main.py* и *config.py* были на одном файловом уровне, т.е. в одной папке иначе строка **from .config import \*** даст ошибку. Класс **TelegramClient** — это именно то, что позволит нам войти в Telegram в качестве обычного пользователя. Далее в этом же файле пишем следующее:
```
client = TelegramClient(<ИМЯ СЕССИИ>, api_id, api_hash)
client.start()
```
Таким образом, можно считать, мы залогинились в Telegram. **ИМЯ СЕССИИ** можете выбрать любое, на свое усмотрение (например, *«ананас»*). Итак, мы подключились к телеграму. Теперь пора думать о фотографиях…
### Шаг второй. Создаем источник фотографий с указанием времени
Пожалуй, этот шаг явился самым легким для меня, т.к. я уже долгое время разрабатывал различное ПО, использующее [компьютерное зрение](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D1%8C%D1%8E%D1%82%D0%B5%D1%80%D0%BD%D0%BE%D0%B5_%D0%B7%D1%80%D0%B5%D0%BD%D0%B8%D0%B5), а следовательно, работа с изображениями стала чем-то обыденным. Тут все просто — устанавливаем библиотеку [opencv](https://pypi.org/project/opencv-python/), позволяющую творить чудеса с фотографиями. Создаем файл *utils.py* и пишем в ней:
```
def convert_time_to_string(dt):
return f"{dt.hour}:{dt.minute:02}"
```
Данная функция нам нужна, чтобы на фотографии было указано время в формате **Ч: ММ**(были и другие способы сделать это, но я предпочел именно этот).
Итак, приступаем к созданию самих фотографий. Создаем файл *generate\_time\_images.py* и пишем в нем:
```
from .utils import *
import cv2
import numpy as np
from datetime import datetime, timedelta
```
Этих библиотек должно хватить нам для создания фотографий с указанием времени. Далее пишем функцию для получения черного фона, на котором мы будем писать время:
```
def get_black_background():
return np.zeros((500, 500))
```
Теперь нужно будет пройтись циклом по каждой минуте в сутках и сгенерировать фотографию с указанием времени. Заранее создайте папку **time\_images/** куда будете сохранять фотографии. Итак, пишем:
```
start_time = datetime.strptime("2019-01-01", "%Y-%m-%d") # Можете выбрать любую дату
end_time = start_time + timedelta(days=1)
def generate_image_with_text(text):
image = get_black_background()
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(image, text, (int(image.shape[0]*0.35), int(image.shape[1]*0.5)), font, 1.5, (255, 255, 0), 2, cv2.LINE_AA)
return image
while start_time < end_time:
text = convert_time_to_string(start_time)
image = generate_image_with_text(text)
cv2.imwrite(f"time_images/{text}.jpg", image)
start_time += timedelta(minutes=1)
```
Для создания колеекции фотографий осталось сделать только одно — запустить *generate\_time\_images.py*. После запуска мы видим, что в папке **time\_images/** появилось множество фотографий. Должны получиться примерно такие фотографии:
### Шаг третий. Обновляем фото каждую минуту
У **telethon** есть очень удобная штука — называется **UploadProfilePhotoRequest**. Импортируем ее в наш ранее написанный *main.py*:
```
from telethon.tl.functions.photos import UploadProfilePhotoRequest, DeletePhotosRequest
from datetime import datetime
from .utils import *
```
Разумеется, мы не должны обновлять аватарку в каждый момент времени — достаточно делать это раз в минуту. Для этого мы должны знать момент, когда заканчивается старая минута и начинается новая — именно в этот момент мы и поменяем фотку. Пишем еще одну небольшую функцию в *utils.py*:
```
def time_has_changed(prev_time):
return convert_time_to_string(datetime.now()) != prev_time
```
Да, да, мы передаем в нее строку со временем предыдущего обновления аватарки. Конечно, и тут были другие способы реализации, но писал я это все «на скорую руку», поэтому сильно об оптимизации не задумывался. Продолжаем заполнять наш *main.py*:
```
prev_update_time = ""
while True:
if time_has_changed(prev_update_time):
prev_update_time = convert_time_to_string(datetime.now())
client(DeletePhotosRequest(client.get_profile_photos('me')))
file = client.upload_file(f"time_images/{prev_update_time}.jpg")
client(UploadProfilePhotoRequest(file))
```
**DeletePhotosRequest** нам нужен для того, чтобы удалить предыдущие аватарки, чтобы создавался эффект, что мы не добавляем новое фото — оно меняется само собой. Для того, чтобы не перегружать процессор, можно добавить **time.sleep(1)** в конец цикла(разумеется, импортировав сперва **time.py**).
Готово! Запустите *main.py* и ваша аватарка превратится в часы. Как более оригинальный вариант, можете попробовать изменить текст на фотках, например, на такой:
**UPDATE!**
-----------
С момента написания данной статьи библиотека telethon стала полностью [*асинхронной*](https://ru.wikipedia.org/wiki/%D0%90%D1%81%D0%B8%D0%BD%D1%85%D1%80%D0%BE%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D1%8C), что вызвало необходимость полностью пересмотреть методы вызова функций в исходниках. В итоге я сел за код и кроме того, что переписал все через async-await на основе [*asyncio*](https://docs.python.org/3/library/asyncio.html) еще и оптимизировал пару вещей. К примеру, теперь не нужно создавать кучу файлов на жестком диске для их отправления — это было огромной и бесполезной тратой ресурсов, больше не буду так делать..
Вот [ссылка на репозиторий](https://github.com/mumtozvalijonov/telegram-avatar-time). Необходимые инструкции по установке уже там. | https://habr.com/ru/post/457078/ | null | ru | null |
# WebRTC in Docker. Struggling for resources
A few weeks ago we wrote an [article about Docker and WebRTC servers](https://habr.com/ru/company/flashphoner/blog/562244/) and talked about the intricacies of launching containers. Our readers (rightly) questioned whether Docker was a suitable tool for production, for the following reasons:
* Docker does not optimally use and synchronize CPU resources between containers, which can cause RTP stream timings to shift.
* Using several containers will require mapping the ports of each of them to the ports of the host, thus creating a NAT behind a NAT, which is not always a convenient and stable construct.
When running tests for the article we didn't run into such issues. However if the issues are outlined, it means someone has encountered them. We decided to look into this situation and find solutions.
### Dividing the network
We will begin with the second task --- configuring a network for Docker. Before containers can be created, we need to set up a Docker network.
For the purposes of this article, we used public IP addresses. If the containers are operated via NAT, it will complicate the process, for you will also need to configure rules for port forwarding in the border gateway.
With the ipvlan driver each container becomes a full network member, so we can create rules for port forwarding through NAT, just as if WCS were deployed on real hardware. So, keep in mind that, apart from the main NAT, no NATs are created for containers.
We requested a network of 8 public elastic IPs from our ISP.
```
1st address - network address: 147.75.76.160/29
2nd address - address of the default gateway: 147.75.76.161
3rd address - host address: 147.75.76.162
4th address - range address for Docker 147.75.76.163/30
5th address - address of the first container 147.75.76.164
6th address - address of the second container 147.75.76.165
7th and 8th - backup addresses.
```
The first step is to create a ipvlan-based Docker network named "new-testnet"
```
docker network create -d ipvlan -o parent=enp0s3 \
--subnet 147.75.76.160/29 \
--gateway 147.75.76.161 \
--ip-range 147.75.76.163/30 \
new-testnet
```
where:
* **ipvlan** — network driver type;
* **parent=enp0s3** — physical network interface (enp0s3), through which container traffic will go;
* **--subnet** — subnet;
* **--gateway** — default gateway for the subnet;
* **--ip-range** — address range for the subnet, containing addresses that Docker will assign to containers.
### Preparing the load for the testing
Containers will be put under load using a WebRTC load test. Let's prepare the settings:
On the host, in the directory
```
/opt/wcs/conf/
```
create the following files: [flashphoner.properties](https://flashphoner.com/wp-content/uploads/2021/07/flashphoner.properties) and [wcs-core.properties](https://flashphoner.com/wp-content/uploads/2021/07/wcs-core.properties), containing the lines:
for [flashphoner.properties](https://flashphoner.com/wp-content/uploads/2021/07/flashphoner.properties):
```
#server ip
ip =
ip_local =
#webrtc ports range
media_port_from =31001
media_port_to =40000
#codecs
codecs =opus,alaw,ulaw,g729,speex16,g722,mpeg4-generic,telephone-event,h264,vp8,flv,mpv
codecs_exclude_sip =mpeg4-generic,flv,mpv
codecs_exclude_streaming =flv,telephone-event
codecs_exclude_sip_rtmp =opus,g729,g722,mpeg4-generic,vp8,mpv
#websocket ports
ws.port =8080
wss.port =8443
wcs_activity_timer_timeout=86400000
wcs_agent_port_from=44001
wcs_agent_port_to=55000
global_bandwidth_check_enabled=true
zgc_log_parser_enable=true
zgc_log_time_format=yyyy-MM-dd'T'HH:mm:ss.SSSZ
```
This file will replace the original flashphoner.properties upon container launch. The **ip** and **ip\_local** variables will be filled with values specified during container creation by the **EXTERNAL\_IP** and **LOCAL\_IP** variables respectively.
Next, we use special settings to broaden the address range:
```
media_port_from=31001
media_port_to=40000
wcs_agent_port_from=44001
wcs_agent_port_to=55000
```
lengthen the test duration:
```
wcs_activity_timer_timeout=86400000
```
and make it so the data on the speed of the network adapter and ZGC operation data are displayed on the statistics page:
```
zgc_log_parser_enable=true
zgc_log_time_format=yyyy-MM-dd'T'HH:mm:ss.SSSZ
```
In the [wcs-core.properties file](https://flashphoner.com/wp-content/uploads/2021/07/wcs-core.properties), configure ZGC usage and specify the heap size:
```
### SERVER OPTIONS ###
# Set this property to false to disable session debug
-DsessionDebugEnabled=false
# Disable SSLv3
-Djdk.tls.client.protocols="TLSv1,TLSv1.1,TLSv1.2"
### JVM OPTIONS ###
-Xmx16g
-Xms16g
#-Xcheck:jni
# Can be a better GC setting to avoid long pauses
# Uncomment to fix multicast crosstalk problem when streams share multicast port
-Djava.net.preferIPv4Stack=true
# Default monitoring port is 50999. Make sure the port is closed on firewall. Use ssh tunel for the monitoring.
-Dcom.sun.management.jmxremote=true
-Dcom.sun.management.jmxremote.local.only=false
-Dcom.sun.management.jmxremote.ssl=false
-Dcom.sun.management.jmxremote.authenticate=false
-Dcom.sun.management.jmxremote.port=50999
-Dcom.sun.management.jmxremote.host=localhost
-Djava.rmi.server.hostname=localhost
#-XX:ErrorFile=/usr/local/FlashphonerWebCallServer/logs/error%p.log
-Xlog:gc*:/usr/local/FlashphonerWebCallServer/logs/gc-core-:time
# ZGC
-XX:+UnlockExperimentalVMOptions -XX:+UseZGC
# Use System.gc() concurrently in CMS
-XX:+ExplicitGCInvokesConcurrent
# Disable System.gc() for RMI, for 10000 hours
-Dsun.rmi.dgc.client.gcInterval=36000000000
-Dsun.rmi.dgc.server.gcInterval=36000000000
```
This file will also replace the [wcs-core.properties](https://flashphoner.com/wp-content/uploads/2021/07/wcs-core.properties) file, which is in the container by default.
We generally recommend to set the heap to take up 50% of the available RAM, but, in this case, the launch of two containers would take up the whole server RAM and it could result in unstable operation. This is why we will try a different approach. We shall allocate 25% of the available RAM to each container:
```
### JVM OPTIONS ###
-Xmx16g
-Xms16g
```
Now, the set-up is finished, and we're ready to launch. (You can download the sample [wcs-core.properties](https://flashphoner.com/wp-content/uploads/2021/07/wcs-core.properties) and [flashphoner.properties](https://flashphoner.com/wp-content/uploads/2021/07/flashphoner.properties) files in the "Useful files" section at the end of the article).
### Allocating the resources and launching containers
Now we come back to the primary issue - that of the resource allocation to containers and of timing shifts.
It is true that, when allocating CPU resources between containers via cgroups, the software within the containers may select the quota set by the scheduler, which results in jitters (unwanted deviations of the transmitted signal), which negatively affects RTP stream playback.
Allocation of CPU resources and jitters are an issue not only for Docker, but for both "classic" hypervisor-based virtual machines and real hardware, which is why it is not really Docker-specific. When it comes to WebRTC, jitters are handled by an adaptive jitter buffer, which runs on the client and supports a fairly wide range (up to 1000 ms).
In our case, timings are not really an issue, since the RTP stream is not linked to the server clock. RTP do not necessarily follow the encoder clock exactly, because the network is never flawless. All the discrepancies are handled with buffers in WebRTC. Once again, this is not a Docker-specific matter.
In order to minimize the struggle for resources between containers we shall manually allocate processor cores to them. This way, there will be no conflicts or quotas of processor time. The way to do it is to use the following key when creating a container:
```
--cpuset-cpus=
```
You can specify a list of cores (divided with commas) or a range of cores (separated by a hyphen). The first core is named "0".
Now let's launch the first container:
```
docker run --cpuset-cpus=0-15 \
-v /opt/wcs/conf:/conf \
-e PASSWORD=123Qwe \
-e LICENSE=xxxx-xxxx-xxxx-xxxx-xxxx \
-e LOCAL_IP=147.75.76.164 \
-e EXTERNAL_IP=147.75.76.164 \
--net new-testnet \
--ip 147.75.76.164 \
--name wcs-docker-test-1 \
-d flashphoner/webcallserver:latest
```
the keys are as follows:
* **--cpuset-cpus=0-15** - specifies that the container must use host cores 0 through 15 to run;
* **-v /opt/wcs/conf:/conf** - attaches the directory with config files to the container;
* **PASSWORD** — password to access the inner workings of the container via SSH. If this variable is not defined, it will not be possible to get into the container via SSH;
* **LICENSE** — WCS license number. If this variable is not defined, the license can be activated through the web interface;
* **LOCAL\_IP** — IP address of the container in the Docker network, which will be logged into the ip\_local parameter in the flashphoner.properties config file;
* **EXTERNAL\_IP** — IP address of the external network interface. It is entered into the IP parameter in the flashphoner.properties config file;
* **--net** specifies the network within which the container will operate. Our container is launched in the testnet network;
* **--ip 147.75.76.164** - address of the container in the Docker network;
* **--name wcs-docker-test-1** - container name;
* **-d flashphoner/webcallserver:latest** - image for the container deployment
For the second container, we use a very similar command:
```
docker run --cpuset-cpus=15-31 \
-v /opt/wcs/conf:/conf \
-e PASSWORD=123Qwe \
-e LICENSE=xxxx-xxxx-xxxx-xxxx-xxxx \
-e LOCAL_IP=147.75.76.165 \
-e EXTERNAL_IP=147.75.76.165 \
--net new-testnet \
--ip 147.75.76.165 \
--name wcs-docker-test-2 \
-d flashphoner/webcallserver:latest
```
Here, we specify a different core range and a different IP address for the container. You can also set a different password for the SSH, but it is not required.
### Testing and evaluating the results
In the web interface of the first container we launch a console for WebRTC testing with stream capture <http://147.75.76.164:9091/client2/examples/demo/streaming/console/console.html>:
In the web interface of the second container we select "Two-way Streaming":
and then start the load test:
Container performance is evaluated using graphs produced by the [Prometheus + Grafana](https://flashphoner.com/10-important-webrtc-streaming-metrics-and-configuring-prometheus-grafana-monitoring/) monitoring systems. To receive data on the CPU load we have installed Prometheus Node Exporter on the host. Information on the container load and streams status is collected from the WCS server statistics page in the containers:
```
http://147.75.76.164:8081/?action=stat
http://147.75.76.165:8081/?action=stat
```
You can find the [panel for Grafana](https://flashphoner.com/wp-content/uploads/2021/07/Docker_WebRTC_test.json) in the "Useful files" section.
The results of the test with container separation by core:
As we can see, the load on the test container that was receiving streams was slightly higher (singular peaks up to 20-25 units), compared to the container that was sending the streams. At the same time, no stream degradation was detected and the control stream's quality (see the screenshot below) was acceptable: there were no artifacts and sound stutters. All in all, it is fair to say that the containers handled the load well.
The output from the htop application, produced during the test, shows that the 32 cores used by the containers were active, while the rest of the cores were not:
Now, let's relaunch the containers with no settings for container separation by core.
The first container:
```
docker run \
-v /opt/wcs/conf:/conf \
-e PASSWORD=123Qwe \
-e LICENSE=xxxx-xxxx-xxxx-xxxx-xxxx \
-e LOCAL_IP=147.75.76.164 \
-e EXTERNAL_IP=147.75.76.164 \
--net new-testnet \
--ip 147.75.76.164 \
--name wcs-docker-test-1 \
-d flashphoner/webcallserver:latest
```
The second container:
```
docker run \
-v /opt/wcs/conf:/conf \
-e PASSWORD=123Qwe \
-e LICENSE=xxxx-xxxx-xxxx-xxxx-xxxx \
-e LOCAL_IP=147.75.76.165 \
-e EXTERNAL_IP=147.75.76.165 \
--net new-testnet \
--ip 147.75.76.165 \
--name wcs-docker-test-2 \
-d flashphoner/webcallserver:latest
```
Let's start the load test again, using the same conditions, and look at the graphs:
This time, the containers appeared to be "more powerful" – the cores were not manually limited, and each container had access to all the 40 cores of the host. That's why they managed to capture more streams, but closer to the end of the test 1% of them became degraded. This means that with container separation by core containers run more smoothly.
And thus, the testing has shown that containers can be configured to be full members of either the local or the global network. We also managed to configure resource allocation between containers in a way that makes it so they do not interfere with each other. Keep in mind that the quantitative results of your testing may be different, because they depend on the specific task you aim to perform, the technical specifications of the system used, and its environment.
Good streaming to you!
### Useful files
[flashphoner.properties](https://flashphoner.com/wp-content/uploads/2021/07/flashphoner.properties)
[wcs-core.properties](https://flashphoner.com/wp-content/uploads/2021/07/wcs-core.properties)
[Docker\_WebRTC\_test.json](https://flashphoner.com/wp-content/uploads/2021/07/Docker_WebRTC_test.json)
### Links
[WCS in Docker](https://flashphoner.com/support-web-call-server-in-docker)
[Deployment WCS in Docker](https://docs.flashphoner.com/display/WCS52EN/WCS+in+Docker)
[WCS in DockerHub](https://hub.docker.com/r/flashphoner/webcallserver)
[10 Important WebRTC Streaming Metrics and Configuring Prometheus + Grafana Monitoring](https://flashphoner.com/10-important-webrtc-streaming-metrics-and-configuring-prometheus-grafana-monitoring/)
[What kind of server do you need to run a thousand WebRTC streams?](https://flashphoner.com/what-kind-of-server-do-you-need-to-run-a-thousand-webrtc-streams/) | https://habr.com/ru/post/565610/ | null | en | null |
# DevBoy: делаем генератор сигналов
**Привет, друзья!**
В прошлых статьях я [рассказывал про свой проект](https://habr.com/post/423499/) и про [его программную часть](https://habr.com/post/424309/). В этой статье я расскажу как сделать простенький генератор сигналов на 4 канала — два аналоговых канала и два PWM канала.
Аналоговые каналы
-----------------
Микроконтроллер **STM32F415RG** имеет в своем составе 12-тибитный **DAC** (digital-to-analog) преобразователь на два независимых канала, что позволяет генерировать разные сигналы. Можно напрямую загружать данные в регистры преобразователя, но для генерации сигналов это не очень подходит. Лучшее решение — использовать массив, в который генерировать одну волну сигнала, а затем запускать DAC с триггером от таймера и DMA. Изменяя частоту таймера можно изменять частоту генерируемого сигнала.
"*[Классические](https://en.wikipedia.org/wiki/Waveform)*" формы волны включают: синусоидальная, меандр, треугольная и пилообразная волны.
**Функция генерации данных волн в буфере имеет следующий вид**
```
// *****************************************************************************
// *** GenerateWave ********************************************************
// *****************************************************************************
Result Application::GenerateWave(uint16_t* dac_data, uint32_t dac_data_cnt, uint8_t duty, WaveformType waveform)
{
Result result;
uint32_t max_val = (DAC_MAX_VAL * duty) / 100U;
uint32_t shift = (DAC_MAX_VAL - max_val) / 2U;
switch(waveform)
{
case WAVEFORM_SINE:
for(uint32_t i = 0U; i < dac_data_cnt; i++)
{
dac_data[i] = (uint16_t)((sin((2.0F * i * PI) / (dac_data_cnt + 1)) + 1.0F) * max_val) >> 1U;
dac_data[i] += shift;
}
break;
case WAVEFORM_TRIANGLE:
for(uint32_t i = 0U; i < dac_data_cnt; i++)
{
if(i <= dac_data_cnt / 2U)
{
dac_data[i] = (max_val * i) / (dac_data_cnt / 2U);
}
else
{
dac_data[i] = (max_val * (dac_data_cnt - i)) / (dac_data_cnt / 2U);
}
dac_data[i] += shift;
}
break;
case WAVEFORM_SAWTOOTH:
for(uint32_t i = 0U; i < dac_data_cnt; i++)
{
dac_data[i] = (max_val * i) / (dac_data_cnt - 1U);
dac_data[i] += shift;
}
break;
case WAVEFORM_SQUARE:
for(uint32_t i = 0U; i < dac_data_cnt; i++)
{
dac_data[i] = (i < dac_data_cnt / 2U) ? max_val : 0x000;
dac_data[i] += shift;
}
break;
default:
result = Result::ERR_BAD_PARAMETER;
break;
}
return result;
}
```
В функцию нужно передать указатель на начала массива, размер массива, максимальное значение и требуемую форму волны. После вызова массив будет заполнен сэмплами для одной волны требуемой формы и можно запускать таймер для периодической загрузки нового значения в DAC.
DAC в данном микроконтроллере имеет ограничение: типичное settling time (*время от загрузки нового значения в DAC и появлением его на выходе*) составляет 3 ms. Но не все так однозначно — данное время является максимальным, т.е. изменение от минимума до максимума и наоборот. При попытке вывести меандр эти заваленные фронты очень хорошо видно:
Если же вывести синусоидальную волну то завал фронтов уже не так заметен из-за формы сигнала. Однако если увеличивать частоту синусоидальный сигнал превращается в треугольный, а при дальнейшем увеличении уменьшается амплитуда сигнала.
**Генерация на 1 KHz (*90% амплитуда*):**
**Генерация на 10 KHz (*90% амплитуда*):**
**Генерация на 100 KHz (*90% амплитуда*):**
Уже видны ступеньки — потому что загрузку новых данных в DAC осуществляется с частотой в 4 МГц.
Кроме того, задний фронт пилообразного сигнала завален и снизу сигнал не доходит до того значения до которого должен. Это происходит потому, что сигнал не успевает достич заданного низкого уровня, а ПО загружает уже новые значения
**Генерация на 200 KHz (*90% амплитуда*):**
Тут уже видно как все волны превратились в треугольник.
Цифровые каналы
---------------
С цифровыми каналами все намного проще — практически в любом микроконтроллере есть таймеры позволяющие вывести PWM сигнал на выводы микроконтроллера. Использовать лучше всего 32-х битный таймер — в таком случае не нужно пересчитывать преддетилель таймера, достаточно в один регистр загружать период, а в другой регистр загружать требуемую скважность.
User Interface
--------------
Организовать пользовательский интерфейс было решено в четыре прямоугольника, каждый имеет картинку выводимого сигнала, частоту и амплитуду/скважность. Для текущего выбранного канала текстовые данные выведены белым шрифтом, для остальных — серым.
Управление было решено делать на энкодерах: левый отвечает за частоту и текущий выбранный канал (*изменяется при нажатии на кнопку*), правый отвечает за амплитуду/скважность и форму волны (*изменяется при нажатии на кнопку*).
Кроме того, реализована поддержка сенсорного экрана — при нажатии на неактивный канал он становится активным, при нажатии на активный канал меняется форма волны.
Конечно же используется DevCore для осуществления всего этого. Код инициализации пользовательского интерфейса и обновления данных на экране выглядит так:
**Структура содержащая все объекты UI**
```
// *************************************************************************
// *** Structure for describes all visual elements for the channel *****
// *************************************************************************
struct ChannelDescriptionType
{
// UI data
UiButton box;
Image img;
String freq_str;
String duty_str;
char freq_str_data[64] = {0};
char duty_str_data[64] = {0};
// Generator data
...
};
// Visual channel descriptions
ChannelDescriptionType ch_dsc[CHANNEL_CNT];
```
**Код инициализации пользовательского интерфейса**
```
// Create and show UI
int32_t half_scr_w = display_drv.GetScreenW() / 2;
int32_t half_scr_h = display_drv.GetScreenH() / 2;
for(uint32_t i = 0U; i < CHANNEL_CNT; i++)
{
// Generator data
...
// UI data
int32_t start_pos_x = half_scr_w * (i%2);
int32_t start_pos_y = half_scr_h * (i/2);
ch_dsc[i].box.SetParams(nullptr, start_pos_x, start_pos_y, half_scr_w, half_scr_h, true);
ch_dsc[i].box.SetCallback(&Callback, this, nullptr, i);
ch_dsc[i].freq_str.SetParams(ch_dsc[i].freq_str_data, start_pos_x + 4, start_pos_y + 64, COLOR_LIGHTGREY, String::FONT_8x12);
ch_dsc[i].duty_str.SetParams(ch_dsc[i].duty_str_data, start_pos_x + 4, start_pos_y + 64 + 12, COLOR_LIGHTGREY, String::FONT_8x12);
ch_dsc[i].img.SetImage(waveforms[ch_dsc[i].waveform]);
ch_dsc[i].img.Move(start_pos_x + 4, start_pos_y + 4);
ch_dsc[i].box.Show(1);
ch_dsc[i].img.Show(2);
ch_dsc[i].freq_str.Show(3);
ch_dsc[i].duty_str.Show(3);
}
```
**Код обновления данных на экране**
```
for(uint32_t i = 0U; i < CHANNEL_CNT; i++)
{
ch_dsc[i].img.SetImage(waveforms[ch_dsc[i].waveform]);
snprintf(ch_dsc[i].freq_str_data, NumberOf(ch_dsc[i].freq_str_data), "Freq: %7lu Hz", ch_dsc[i].frequency);
if(IsAnalogChannel(i)) snprintf(ch_dsc[i].duty_str_data, NumberOf(ch_dsc[i].duty_str_data), "Ampl: %7d %%", ch_dsc[i].duty);
else snprintf(ch_dsc[i].duty_str_data, NumberOf(ch_dsc[i].duty_str_data), "Duty: %7d %%", ch_dsc[i].duty);
// Set gray color to all channels
ch_dsc[i].freq_str.SetColor(COLOR_LIGHTGREY);
ch_dsc[i].duty_str.SetColor(COLOR_LIGHTGREY);
}
// Set white color to selected channel
ch_dsc[channel].freq_str.SetColor(COLOR_WHITE);
ch_dsc[channel].duty_str.SetColor(COLOR_WHITE);
// Update display
display_drv.UpdateDisplay();
```
Интересно реализована обработка нажатия кнопки (*представляет собой прямоугольник поверх которого рисуются остальные элементы*). Если вы смотрели код, то должны были заметить такую штуку: **ch\_dsc[i].box.SetCallback (&Callback, this, nullptr, i);** вызываемую в цикле. Это задание функции обратного вызова, которая будет вызываться при нажатии на кнопку. В функцию передаются: адрес статической функции статической функции класса, указатель this, и два пользовательских параметра, которые будут переданы в функцию обратного вызова — указатель (*не используется в данном случае — передается nullptr*) и число (*передается номер канала*).
Еще с университетской скамьи я помню постулат: "*Статические функции **не имеют доступа** к не статическим членам класса*". Так вот это **не соответствует действительности**. Поскольку статическая функция является членом класса, то она **имеет доступ ко всем членам класса**, если имеет ссылку/указатель на этот класс. Теперь взглянем на функцию обратного вызова:
```
// *****************************************************************************
// *** Callback for the buttons *********************************************
// *****************************************************************************
void Application::Callback(void* ptr, void* param_ptr, uint32_t param)
{
Application& app = *((Application*)ptr);
ChannelType channel = app.channel;
if(channel == param)
{
// Second click - change wave type
...
}
else
{
app.channel = (ChannelType)param;
}
app.update = true;
}
```
В первой же строчке этой функции происходит "*магия*" после чего можно обращаться к любым членам класса, включая приватные.
Кстати, вызов этой функции происходит в другой задаче (*отрисовки экрана*), так что внутри этой функции надо позаботится о синхронизации. В этом простеньком проекте "*пары вечеров*" я этого не сделал, потому что в данном конкретном случае это не существенно.
Исходный код генератора загружен на GitHub: <https://github.com/nickshl/WaveformGenerator>
**DevCore** теперь выделена в отдельный репозиторий и включена как субмодуль.
Ну а зачем мне нужен генератор сигналов, будет уже в следующей (*или одной из следующих*) статье. | https://habr.com/ru/post/425409/ | null | ru | null |
# django-pkgconf
*Rick and Morty ©. Чувак презентует батарейку, я тоже.*
Не так давно я опубликовал небольшое [приложение](/post/278743/) для формирования «панелей управления» django-проектов. В процессе разработки столкнулся с банальной ситуацией хранения дефолтных настроек модуля. Скорый поиск по гитхабу дал понять, что каждый разработчик использует свою реализацию. Существуют также готовые решения, однако, мне они показались избыточными в таком простом вопросе, поэтому я поступил мудро и запилил свой велосипед.
Может показаться, что данная батарейка будет полезна только OSP-шникам, но штука в том, что эту же самую идею можно использовать в повседневной жизни.
«Банальная ситуация»
--------------------
Допустим, вы написали свое приложение, которое что-то там делает. При этом, есть возможность в `settings.py` проекта выставить какие-то значения, которые перепишут те, что идут из коробки. Итого вся задача сводится к двум вещам: хранить значения по-умолчанию и дать разработчику-потребителю их переписать в своем файле настроек.
Типа так:
```
# Дефолтное значение в app/my_settings.py
FOO = True
# Вы ставите в settings.py
FOO = False
# В итоге, переписалось
from django.conf import settings
settings.FOO
False
```
Используем у себя в проекте
---------------------------
Сейчас уже привычно разрабатывать проект модульно разбивая его на "приложения". Практически все вынесено в индивидуальные файлы аппы: models, views, urls… кроме settings. Например, вы пишете адаптер к сервису рассылок и следующий код в каком-нибудь `newsletters/adapter.py`:
```
adapter = Adapter(username='user', password='pass')
```
Вы будете правы, если скажете, что хардкодить логин и пароль глупо и их надо вынести в константы:
```
USERNAME = 'user'
PASSWORD = 'password'
adapter = Adapter(username=USERNAME, password=PASSWORD)
```
Вроде бы близко, но все равно не то. Еще подход:
```
# settings.py
NEWSLETTERS_USERNAME = 'user'
NEWSLETTERS_PASSWORD = 'password'
# newsletters/adapter.py
from django.conf import settings
adapter = Adapter(username=settings.NEWSLETTERS_USERNAME, password=settings.NEWSLETTERS_PASSWORD)
```
Похоже на правду. Однако есть несколько "но":
* вот это `NEWSLETTERS_` не очень удобно. Во-первых, просто больше повторяющихся букв в коде; во-вторых, значения могут быть более универсальным и использоваться чаще, от чего эта причина становится все печальнее
* эти настройки не относятся *к проекту*, но нужны для отдельного *приложения* и, вероятно, за его пределами не используются — так зачем их держать в основном файле?
* если аппа разрабатывается одним человеком в комманде, его коммит ограничивается директорией приложения
django-pkgconf
--------------
Попробуем сделать так:
```
# newsletters/conf.py
from pkgconf import Conf
class NewsLetters(Conf):
USERNAME = 'username'
PASSWORD = 'password'
# newsletters/adapter.py
from . import conf
adapter = Adapter(username=conf.USERNAME, password=conf.PASSWORD)
```
Условия выполнены: нет префикса, нет захламления файла настроек *проекта*.
Переопределим значения в Dev настройках\*:
```
# local_settings.py
NEWSLETTERS_USERNAME = 'test_user'
```
Готово. Это перепишет значение `USERNAME` для конфигурации приложения `newsletters`, а значение `PASSWORD` останется прежним, потому что мы его не меняли. В результате получаем аккуратный и стройный `settings.py`, где лежат всякие там `DATABASES`, `TEMPLATES` и т.д., только то, что относится к *проекту*.
Совместимость
-------------
Тесты проводились на python 2.7.9, 3.4.3, 3.5.0 и django 1.8, 1.9.
```
Name Stmts Miss Cover
-----------------------------------------
pkgconf/__init__.py 22 0 100%
```
Проект на [гитхабе](https://github.com/byashimov/django-pkgconf).
\* Пожалуйста, не делайте так, используйте [django-configurations](https://github.com/jazzband/django-configurations). | https://habr.com/ru/post/283378/ | null | ru | null |
# Пишем API на Rust с помощью процедурных макросов
Процедурные макросы в Rust — это очень мощный инструмент кодогенерации, позволяющий обходиться без написания тонны шаблонного кода, или выражать какие-то новые концепции, как сделали, к примеру, разработчики крейта [`async_trait`](https://docs.rs/async-trait/0.1.22/async_trait/).
Тем не менее, многие вполне обоснованно побаиваются пользоваться этим инструментом, в основном из-за того, что разбор синтаксического дерева и атрибутов макроса зачастую превращается в "закат солнца вручную", так как задачу приходится решать на очень низком уровне.
В данной статье я хочу поделиться некоторыми, на мой взгляд, удачными подходами к написанию процедурных макросов, и показать, что на сегодняшний день процедурные макросы можно создавать относительно просто и удобно.
Предисловие
-----------
Прежде всего давайте определим задачу, которую мы будем решать с помощью макросов: мы попробуем определить некоторый абстрактный [RPC](https://en.wikipedia.org/wiki/Remote_procedure_call) API в виде трейта, который потом реализует как серверная часть, так и клиентская; а процедурные макросы, в свою очередь, помогут обойтись нам без кучи шаблонного кода. Несмотря на то, что реализовывать мы будем несколько абстрактный API, задача на самом деле довольно жизненная, и, помимо прочего, идеально подходит для демонстрации возможностей процедурных макросов.
Сам API у нас будет выполнен по очень простому принципу: есть 4 типа запросов:
* GET запросы без параметров, например: `/ping`.
* GET запросы с параметрами, параметры к которым будут передаваться в виде URL query, например: `/status?name=foo&count=15`.
* POST запросы без параметров.
* POST запросы с параметрами, которые передаются в виде JSON объектов.
Во всех случаях сервер будет отвечать валидным JSON объектом.
В качестве серверного бэкенда мы будем использовать крейт [`warp`](https://docs.rs/warp/0.2.1/warp/).
В идеале хочется получить нечто подобное:
```
// Определяем интерфейс:
/// Структура, определяющая вид запроса. Она может десериализовываться как из URL query, так и из JSON.
#[derive(Debug, FromUrlQuery, Deserialize, Serialize)]
struct Query {
first: String,
second: u64,
}
/// Сам интерфейс, для которого макросом будет автоматически реализовываться
/// монтирование API поверх warp'а.
#[http_api(warp = "serve_ping_interface")]
trait PingInterface {
#[http_api_endpoint(method = "get")]
fn get(&self) -> Result;
#[http\_api\_endpoint(method = "get")]
fn check(&self, query: Query) -> Result;
#[http\_api\_endpoint(method = "post")]
fn set\_value(&self, param: Query) -> Result<(), Error>;
#[http\_api\_endpoint(method = "post")]
fn increment(&self) -> Result<(), Error>;
}
// Теперь определяем обработчик запросов:
/// Внутренняя структура, которая будет хранить данные сервиса.
#[derive(Debug, Default)]
struct ServiceInner {
first: String,
second: u64,
}
/// Сам сервис, для которого мы будем реализовывать интерфейс.
#[derive(Clone, Default)]
struct ServiceImpl(Arc>);
impl ServiceImpl {
fn new() -> Self {
Self::default()
}
fn read(&self) -> RwLockReadGuard {
self.0.read().unwrap()
}
fn write(&self) -> RwLockWriteGuard {
self.0.write().unwrap()
}
}
// Реализуем интерфейс для обработчика:
impl PingInterface for ServiceImpl {
fn get(&self) -> Result {
let inner = self.read();
Ok(Query {
first: inner.first.clone(),
second: inner.second,
})
}
fn check(&self, query: Query) -> Result {
let inner = self.read();
Ok(inner.first == query.first && inner.second == query.second)
}
fn set\_value(&self, param: Query) -> Result<(), Error> {
let mut inner = self.write();
inner.first = param.first;
inner.second = param.second;
Ok(())
}
fn increment(&self) -> Result<(), Error> {
self.write().second += 1;
Ok(())
}
}
#[tokio::main]
async fn main() {
let addr: SocketAddr = "127.0.0.1:8080".parse().unwrap();
// А теперь просто вызываем сгенерированный код и наслаждаемся работающим API
serve\_ping\_interface(ServiceImpl::new(), addr).await
}
```
Для начала напомню, что процедурными макросами в Rust'е называются специальные плагины к компилятору, которые получают на вход некоторое синтаксическое дерево, с которым производят некоторые манипуляции, а затем возвращают модифицированное дерево для последующей компиляции.
В рамках этой статьи мы будем рассматривать два вида таких макросов: derive-макросы, позволяющие автоматически реализовать трейт для какой-то структуры (многим они уже знакомы по [`serde`](https://serde.rs/)), и атрибутные макросы, которые можно использовать для большего спектра задач.
Так как библиотеки с процедурными макросами являются по сути отдельной разновидностью крейтов, то мы разделим нашу функциональность на два крейта: `http_api`, в котором будут содержаться необходимые трейты и вспомогательные методы, и `http_api_derive` с процедурными макросами.
Создаем макрос FromUrlQuery
---------------------------
Как мне кажется, самый идиоматичный подход к написанию процедурных макросов — это объявление некоторого трейта, а потом создание макроса, который будет его выводить для пользовательских типов данных. Конечно, мы можем в дерайв-макросах генерировать любой код, но использование их для других целей неизбежно приведет к недопониманию.
Итак, приступим. Для начала объявим наш трейт по разбору URL query. Данный трейт позволит нам получать из произвольной строки структуру данных, для которой этот трейт реализован. Выглядеть он будет так:
```
pub trait FromUrlQuery: Sized {
fn from_query_str(query: &str) -> Result;
}
```
Чтобы иметь возможность автоматически реализовывать этот трейт, нам потребуется процедурный макрос. Данный макрос относится к типу макросов derive макросов и должен объявляться следующим образом:
```
/// В данном случае макрос будет вызываться через `#[derive(FromUrlQuery)]`, а также будет иметь доступ
/// к атрибутам типа #[from_url_query(rename = "bar", skip, etc)]
#[proc_macro_derive(FromUrlQuery, attributes(from_url_query))]
pub fn from_url_query(input: TokenStream) -> TokenStream {
from_url_query::impl_from_url_query(input)
}
```
Обычный джентльменский набор писателя процедурных макросов — это библиотеки [`syn`](https://docs.rs/syn/1.0.14/syn/), [`quote`](https://docs.rs/quote/1.0.2/quote/). Первый крейт является парсером `Rust` синтаксиса, он содержит в себе все типы токенов, встречающиеся в синтаксическом дереве.
Во втором крейте содержится очень важный макрос [`quote!`](https://docs.rs/quote/1.0.2/quote/macro.quote.html), который по сути является шаблонизатором и позволяет просто писать некоторый шаблонный Rust код, который будет потом преобразован в выходной набор токенов.
Помимо этих двух обязательных зависимостей есть еще много вспомогательных крейтов, одним из самых полезных, на мой взгяд, является [`darling`](https://docs.rs/darling/0.10.2/darling/). Этот крейт содержит набор процедурных макросов и трейтов для облегчения типовых задач по разбору структур или атрибутов макросов (то есть, входных данных для нашего процедурного макроса).
**Под спойлером находится страшный код, писать который мы \*\*не будем\*\*. Просто посмотрите и проникнетесь экзистенциальным ужасом:**Обычно код разбора AST и атрибутов макроса превращается в кошмар, выглядящий как куча вложенных условий, понять которые крайне сложно.
```
fn get_field_names(input: &DeriveInput) -> Option> {
let data = match &input.data {
Data::Struct(x) => Some(x),
Data::Enum(..) => None,
\_ => panic!("Protobuf convert can be derived for structs and enums only."),
};
data.map(|data| {
data.fields
.iter()
.map(|f| {
let mut action = Action::Convert;
for attr in &f.attrs {
match attr.parse\_meta() {
Ok(syn::Meta::List(ref meta)) if meta.ident == "protobuf\_convert" => {
for nested in &meta.nested {
match nested {
syn::NestedMeta::Meta(syn::Meta::Word(ident))
if ident == "skip" =>
{
action = Action::Skip;
}
\_ => {
panic!("Unknown attribute");
}
}
}
}
\_ => {
// Other attributes are ignored
}
}
}
(f.ident.clone().unwrap(), action)
})
.collect()
})
}
fn get\_field\_names\_enum(input: &DeriveInput) -> Option> {
let data = match &input.data {
Data::Struct(..) => None,
Data::Enum(x) => Some(x),
\_ => panic!("Protobuf convert can be derived for structs and enums only."),
};
data.map(|data| data.variants.iter().map(|f| f.ident.clone()).collect())
}
fn implement\_protobuf\_convert\_from\_pb(field\_names: &[(Ident, Action)]) -> impl quote::ToTokens {
let mut to\_convert = vec![];
let mut to\_skip = vec![];
for (x, a) in field\_names {
match a {
Action::Convert => to\_convert.push(x),
Action::Skip => to\_skip.push(x),
}
}
let getters = to\_convert
.iter()
.map(|i| Ident::new(&format!("get\_{}", i), Span::call\_site()));
let our\_struct\_names = to\_convert.clone();
let our\_struct\_names\_skip = to\_skip;
quote! {
fn from\_pb(pb: Self::ProtoStruct) -> std::result::Result {
Ok(Self {
#( #our\_struct\_names: ProtobufConvert::from\_pb(pb.#getters().to\_owned())?, )\*
#( #our\_struct\_names\_skip: Default::default(), )\*
})
}
}
}
```
Мы же будем использовать крейт `darling`, благодаря чему наш код будет намного короче и проще в поддержке.
Искомая структура, для которой мы выводим `FromUrlQuery`, не должна быть пустой, она не должна быть кортежем и для простоты эксперимента она не будет содержать шаблонных параметров и лайфтаймов. То есть, это всегда что-то такого вида:
```
#[derive(FromUrlQuery)]
struct OptionalQuery {
first: String,
opt_value: Option,
}
```
В `darling`'е есть много вспомогательных макросов, но нас сейчас интересует только несколько из них.
Первый макрос — это [`FromField`](https://docs.rs/darling/0.10.2/darling/trait.FromField.html), который выводит десериализацию интересующих нас свойств поля структуры из синтаксического дерева:
```
#[derive(Clone, Debug, FromField)]
struct QueryField {
ident: Option,
ty: syn::Type,
}
```
Хочу отметить, что при этом если бы мы хотели знать, публичное это поле или нет, то могли бы изменить сигнатуру на следующую:
```
#[derive(Clone, Debug, FromField)]
struct QueryField {
ident: Option,
ty: syn::Type,
vis: syn::Visibility,
}
```
Второй интересующий нас макрос — это [`FromDeriveInput`](https://docs.rs/darling/0.10.2/darling/trait.FromDeriveInput.html), который выводит десериализацию уже для целой структуры или перечисления:
```
#[derive(Debug, FromDeriveInput)]
// При помощи этого атрибута мы ограничиваемся поддержкой только именованных
// структур, если мы попробуем использовать наш макрос на других типах структур
// или перечислениях, то получим ошибку.
#[darling(supports(struct_named))]
struct FromUrlQuery {
ident: syn::Ident,
// В таком вот незамысловатом виде мы получаем список полей в уже
// разобранном виде.
// В darling::ast::Data два шаблонных параметра: первый это поля
// перечисления, а второй это поля структуры.
// Так как в данный момент перечисления нас не интересуют, то мы можем
// просто указать ().
data: darling::ast::Data<(), QueryField>,
}
```
И все, на этом наш парсер готов.
```
let input: DeriveInput = syn::parse(input).unwrap();
let from_url_query = match FromUrlQuery::from_derive_input(&input) {
Ok(parsed) => parsed,
Err(e) => return e.write_errors().into(),
};
```
Можно приступать к написанию кодогенератора.
Чтобы не перегружать статью сверх меры, мы просто будем делегировать десериализацию URL query в `serde`. При этом мы спрячем `serde` максимально глубоко, чтобы он не просочился в обязательные зависимости. Мы будем создавать точную копию нашей структуры и выводить для нее `Deserialize`, а для реального парсинга запросов будем использовать крейт [`serde_urlencoded`](https://docs.rs/serde_urlencoded/0.6.1/serde_urlencoded/). Но чтобы пользователям не приходилось самим добавлять `serde` в зависимости, мы в основном крейте сделаем реэкспорты.
```
#[doc(hidden)]
pub mod export {
pub use serde;
pub use serde_derive;
pub use serde_urlencoded;
}
```
А теперь посмотрим, как же будет в реальности выглядеть процесс кодогенерации `FromUrlQuery`:
```
impl FromUrlQuery {
// Чтобы не было конфликта имен, мы будем объявлять локальную структуру с
// постфиксом "Serde".
fn serde_wrapper_ident(&self) -> syn::Ident {
let ident_str = format!("{}Serde", self.ident);
syn::Ident::new(&ident_str, proc_macro2::Span::call_site())
}
/// Именно этот метод будет генерировать копию исходной структуры.
fn impl_serde_wrapper(&self) -> impl ToTokens {
// Мы на уровне самого атрибута ограничили себя структурами с именованными
// полями, поэтому в данном случае `unwrap` совершенно безопасен.
let fields = self.data.clone().take_struct().unwrap();
// Тут мы для каждого из полей генерируем код присваивания, как в случае
// преобразования из Query в SerdeQuery, так и наоборот.
let wrapped_fields = fields.iter().map(|field| {
let ident = &field.ident
let ty = &field.ty
quote! { #ident: #ty }
});
let from_fields = fields.iter().map(|field| {
let ident = &field.ident
quote! { #ident: v.#ident }
});
let wrapped_ident = self.serde_wrapper_ident();
let ident = &self.ident
// В общем и целом, написание генерации кода с использованием `quote!`
// очень похоже на написание правых частей в декларативных макросах, за
// исключением того, что тут используется "#" вместо "$".
quote! {
// Используем serde из экспортов нашего крейта.
use http_api::export::serde_derive::Deserialize;
#[derive(Deserialize)]
// А чтобы сам serde использовал этот реэкспорт, в нем есть
// прекрасный атрибут.
#[serde(crate = "http_api::export::serde")]
struct #wrapped_ident {
#( #wrapped_fields, )*
}
impl From<#wrapped_ident> for #ident {
fn from(v: #wrapped_ident) -> Self {
Self {
#( #from_fields, )*
}
}
}
}
}
}
```
Да, это все уже не выглядит слишком сложным или очень рутинным, по сути мы просто пишем то, что хотим получить, с одной стороны не сталкиваясь с большими когнитивными трудностями, а с другой получая весьма лаконичный и понятный код. Но, к сожалению, не всегда жизнь бывает такой простой; все становится гораздо ~~интереснее~~ сложнее, если есть необходимость написать не дерайв макрос, а атрибутный.
Пишем макрос http\_api
----------------------
Вот тут нам уже не поможет `FromDeriveInput`, нет в `darling`'е готового набора инструментов для разбора трейтов, так что придется нам немного повозиться с AST. Но не так черт страшен, как его малюют, поэтому давайте приступим:
Код объявления атрибутных макросов несколько отличается и выглядит вот так:
```
#[proc_macro_attribute]
pub fn http_api(attr: TokenStream, item: TokenStream) -> TokenStream {
// У нас уже два аргумента: отдельно синтаксическое дерево элемента, на который
// навешивается макрос и отдельно AST самого атрибута.
http_api::impl_http_api(attr, item)
}
```
Есть еще один крайне важный нюанс, над которым мне в свое время пришлось поломать голову: если мы просто решим, что раз уж нам дали целиком синтаксическое дерево трейта со всеми внутренними атрибутами (например, интересующий нас `http_api_endpoint`), то мы будем лишь частично правы. Да, они будут видны при разборе `TokenStream`, но при этом же компилятор будет нам выдавать ошибку "cannot find attribute `http_api_endpoint` in this scope", что несколько сбивает с толку. Ошибка эта возникает потому, что компилятор не знает о существовании такого атрибута, поэтому не знает, как с ним работать. О том, что этот атрибут нужен для наших внутренних нужд, компилятор не знает, поэтому и реагирует соответственно.
Чтобы решить эту проблему, нужно объявить пустой атрибутный макрос `http_api_endpoint`, который не будет ничего делать, а вместо этого просто будет возращать исходное синтаксическое дерево.
```
#[proc_macro_attribute]
#[doc(hidden)]
pub fn http_api_endpoint(_attr: TokenStream, item: TokenStream) -> TokenStream {
// Мы не изменяем входной поток токенов, потому что `http_api_endpoint`
// лишь предоставляет доступ к метаданным для `http_api` атрибута.
// Однако все равно `http_api_endpoint` должен являться
// полноценным атрибутным макросом, потому, что rustc не понимает
// неизвестных ему атрибутов.
item
}
```
Теперь компилятор знает, что такой атрибут существует, и не будет ругаться на неизвестное имя.
Разбираем методы интерфейсного трейта
-------------------------------------
Для начала напишем код, который будет разбирать отдельный метод трейта с интерфейсом, который в общем случае будет выглядеть примерно так:
```
// Вариант для простых запросов:
#[http_api_endpoint(method = "#method_type")]
fn #method_name(&self) -> Result<$ResponseType, Error>;
// Вариант для запросов с параметрами:
#[http_api_endpoint(method = "#method_type")]
fn #method_name(&self, query: $QueryType) -> Result<$ResponseType, Error>;
```
Объявим типы HTTP запросов, которые мы умеем обрабатывать:
```
#[derive(Debug)]
enum SupportedHttpMethod {
Get,
Post,
}
impl FromMeta for SupportedHttpMethod {
fn from_string(value: &str) -> Result {
match value {
"get" => Ok(SupportedHttpMethod::Get),
"post" => Ok(SupportedHttpMethod::Post),
other => Err(darling::Error::unknown\_value(other)),
}
}
}
```
И объявим набор атрибутов для метода, которые мы можем указывать:
```
#[derive(Debug, FromMeta)]
struct EndpointAttrs {
// Данный атрибут является обязательным, мы в любом случае должны указать
// тип запроса.
method: SupportedHttpMethod,
// Этот же атрибут является вспомогательным, по умолчанию он будет принимать
// значение None, если пользователь не укажет его значение явно:
// #[http_api_endpoint(method = "get", rename = "foo")]
#[darling(default)]
rename: Option,
}
```
Парсить мы будем сигнатуру функции, которая имеет тип [`syn::Signature`](https://docs.rs/syn/1.0.14/syn/struct.Signature.html), и в этом случае полностью положиться на помощь darling'а мы уже не сможем: большую часть разбора синтаксического дерева придется писать самим, но вот атрибуты методов легко можно получить с помощью знакомого нам уже `FromMeta`.
А чтобы среди атрибутов метода отыскать нужный нам `http_api_endpoint` мы напишем небольшую вспомогательную функцию. Мы будем преобразовывать тип нашего атрибута в [`syn::NestedMeta`](https://docs.rs/syn/1.0.14/syn/enum.NestedMeta.html) для того, чтобы была возможность обрабатывать вложенные метаданные вида `(foo = "bar", boo(first, second))`.
```
fn find_meta_attrs(name: &str, args: &[syn::Attribute]) -> Option {
args.as\_ref()
.iter()
.filter\_map(|a| a.parse\_meta().ok())
.find(|m| m.path().is\_ident(name))
.map(syn::NestedMeta::from)
}
```
Теперь можно переходить к разбору сигнатуры. Как я уже упоминал выше, нам нужно рассмотреть
два варианта — с дополнительным аргументом и без оного:
```
/// Вспомогательный метод для удобного создания ошибок.
fn invalid_method(span: &impl syn::spanned::Spanned) -> darling::Error {
darling::Error::custom(
"API method should have one of `fn foo(&self) -> Result` or \
`fn foo(&self, arg: Foo) -> Result` form",
)
.with\_span(span)
}
impl ParsedEndpoint {
fn parse(sig: &syn::Signature, attrs: &[syn::Attribute]) -> Result {
/// Создаем итератор с перечислением агрументов метода.
let mut args = sig.inputs.iter();
// Проверяем, что первый аргумент метода - это всегда &self и только он,
// никакие варианты в &mut self, или с &self: Arc мы поддерживать
// не будем.
if let Some(arg) = args.next() {
match arg {
// `self` в `syn` обозначается как Receiver.
syn::FnArg::Receiver(syn::Receiver {
// Наличие `reference` говорит нам, что тип на самом деле
// `&self`.
reference: Some(\_),
// Отсутствие `mutability` говорит о том, что в типе
// не содержится никаких `mut`.
mutability: None,
// Остальные поля нам не особо интересны.
..
}) => {
// Проверка пройдена, ничего делать не нужно.
}
\_ => {
// С сигнатурой что-то не так, прекращаем разбор
// и генерируем ошибку.
return Err(invalid\_method(&arg));
}
}
} else {
return Err(invalid\_method(&sig));
}
// Извлекаем опциональный тип параметра.
let arg = args
.next()
.map(|arg| match arg {
// `FnArg` может быть или `Typed`, или `Receiver`, но `Receiver`
// мы уже проверили на предыдущем шаге, поэтому достаточно просто
// извлечь тип аргумента.
syn::FnArg::Typed(arg) => Ok(arg.ty.clone()),
// Только первый аргумент может быть `self`.
\_ => unreachable!("Only first argument can be receiver."),
})
// Transpose очень удобная штука, которая превращает
// `Option>` в `Result>`, чем очень улучшает
// читабельность кода.
.transpose()?;
// Извлекаем тип возвращаемого значения, он тоже должен быть `Typed`,
// а не `Receiver`.
let ret = match &sig.output {
syn::ReturnType::Type(\_, ty) => Ok(ty.clone()),
\_ => Err(invalid\_method(&sig)),
}?;
// Функцией, которую мы писали выше, мы находим атрибуты, относящиеся
// к нашему макросу.
// С помощью `FromMeta::from\_nested\_meta` мы можем извлечь метаданные.
let attrs = find\_meta\_attrs("http\_api\_endpoint", attrs)
.map(|meta| EndpointAttrs::from\_nested\_meta(&meta))
.unwrap\_or\_else(|| Err(darling::Error::custom("todo")))?;
/// Все, парсинг сигнатуры метода готов, можно возращать значение.
Ok(Self {
ident: sig.ident.clone(),
arg,
ret,
attrs,
})
}
}
```
Разбираем интерфейсный трейт целиком
------------------------------------
Теперь можно приступить к разбору трейта с интерфейсом в целом. Интерфейсный трейт всегда состоит исключительно из методов, разбор которых мы описали выше, а также дополнительных атрибутов.
Таким образом, мы можем разобрать его без особых сложностей:
```
/// Структура содержит исходный трейт, набор его атрибутов и список
/// интерфейсных методов.
#[derive(Debug)]
struct ParsedApiDefinition {
/// Исходный трейт, который мы не трогаем. Мы передадим его дальше в
/// исходящий поток токенов без изменений.
item_trait: syn::ItemTrait,
/// Список интерфейсных методов.
endpoints: Vec,
/// Атрибуты интерфейсного трейта.
attrs: ApiAttrs,
}
#[derive(Debug, FromMeta)]
struct ApiAttrs {
/// Данный атрибут определяет имя функции, которая будет монтировать
/// реализацию интерфейса к warp'у.
warp: syn::Ident,
}
impl ParsedApiDefinition {
fn parse(
item\_trait: syn::ItemTrait,
attrs: &[syn::NestedMeta],
) -> Result {
// С парсингом в данном случае все тривиально, среди итемов трейта мы
// отфильтровываем методы, а затем разбираем их с помощью кода, который
// мы написали выше.
let endpoints = item\_trait
.items
.iter()
.filter\_map(|item| {
if let syn::TraitItem::Method(method) = item {
Some(method)
} else {
None
}
})
.map(|method| ParsedEndpoint::parse(&method.sig, method.attrs.as\_ref()))
.collect::, darling::Error>>()?;
// Парсим атрибуты трейта.
let attrs = ApiAttrs::from\_list(attrs)?;
// И возвращаем полностью разобранное описание HTTP API.
Ok(Self {
item\_trait,
endpoints,
attrs,
})
}
}
```
Переходим к кодогенерации
-------------------------
Как было указано в начале статьи, для работы с запросами мы будем использовать крейт [`warp`](https://docs.rs/warp/0.2.1/warp/).
Поэтому, прежде чем приступать к кодогенерации, необходимо разобраться с тем, как устроен `warp` и каким образом к нему подключаются обработчики запросов. Все в warp'е крутится вокруг концепции, которая называется `Filter`. Фильтры можно комбинировать в цепочки при помощи комбинаторов `and`, `map`, `and_then`, где каждый наложенный фильтр конкретизирует то, как будет обрабатываться запрос.
Например, если мы хотим просто написать обработчик запросов, который на GET запрос будет просто возвращать некоторый JSON, то мы просто пишем что-то в таком стиле:
```
/// Мы оборачиваем некоторый обработчик, который просто отдает результат
/// в фильтр warp'а
pub fn simple_get(name: &'static str, handler: F) -> JsonReply
where
F: Fn() -> Result + Clone + Send + Sync + 'static,
R: ser::Serialize,
E: Reject,
{
// Создаем некоторый фильтр запросов, который принимает только GET запросы,
// а остальные игнорирует.
warp::get()
// Накладываем на него дополнительную фильтрацию, чтобы он принимал
// только запросы с путем {name}
.and(warp::path(name))
// А в последнем комбинаторе and\_then мы вызываем обработчик и
// получившийся результат возращаем в виде JSON объекта
.and\_then(move || {
let handler = handler.clone();
// Обработчик запросов в реальности всегда асинхронный, поэтому
// нам нужно обернуть наш синхронный вызов в async блок.
async move {
match handler() {
Ok(value) => Ok(warp::reply::json(&value)),
// В warp'е достаточно своеобразная система обработки ошибок,
// но чтобы не перегружать статью, мы не будем касаться
// этого вопроса подробно и просто передадим какой-то
// тип ошибки наверх.
Err(e) => Err(warp::reject::custom(e)),
}
}
})
.boxed()
}
```
Для случая с GET запросами с параметрами мы лишь немного изменим обертку, которую мы написали выше, добавив еще один фильтр в цепочку:
```
pub fn query_get(name: &'static str, handler: F) -> JsonReply
where
F: Fn(Q) -> Result + Clone + Send + Sync + 'static,
Q: FromUrlQuery,
R: ser::Serialize,
E: Reject,
{
warp::get()
.and(warp::path(name))
// Добавляем в цепочку фильтров фильтрацию по URL query, который вернет нам
// строчку с необработанным query.
.and(warp::filters::query::raw())
.and\_then(move |raw\_query: String| {
let handler = handler.clone();
async move {
// Применим к строчке с запросом написанный нами ранее трейт
// FromUrlQuery и получим переменную с нужным обработчику
// запросов типом.
let query = Q::from\_query\_str(&raw\_query)
.map\_err(|\_| warp::reject::custom(IncorrectQuery))?;
match handler(query) {
Ok(value) => Ok(warp::reply::json(&value)),
Err(e) => Err(warp::reject::custom(e)),
}
}
})
.boxed()
}
```
Обработчики остальных двух типов запросов пишутся схожим образом.
Собираем обработчики воедино
----------------------------
Помимо комбинаторов `and`, которое объединяет фильтры в цепочку, существует еще комбинатор
`or`, которое позволяет выбирать из двух фильтров подходящий по ситуации, фактически, таким
образом мы организовываем роутинг запросов, причем правила могут быть очень сложными.
Давайте просто взглянем на пример из документации:
```
use std::net::SocketAddr;
use warp::Filter;
// В данном примере warp будет обрабатывать запросы вида `/:u32` или
// `/:socketaddr`
warp::path::param::()
.or(warp::path::param::());
```
И вот теперь мы можем приступить к генерации тела искомой функции `serve_ping_interface`. Для начала реализуем генерацию соответствующих warp фильтров для соответствующих методов трейта, где service это объект, реализующий бизнес-логику.
```
impl ParsedEndpoint {
fn impl_endpoint_handler(&self) -> impl ToTokens {
// Имя метода используется в качестве пути.
let path = self.endpoint_path();
let ident = &self.ident
// Перебираем все четыре варианта и с помощью оберток, описанных выше
// создаем соответствующие warp фильтры.
match (&self.attrs.method, &self.arg) {
(SupportedHttpMethod::Get, None) => {
quote! {
let #ident = http_api::warp_backend::simple_get(#path, {
let out = service.clone();
move || out.#ident()
});
}
}
(SupportedHttpMethod::Get, Some(_arg)) => {
quote! {
let #ident = http_api::warp_backend::query_get(#path, {
let out = service.clone();
move |query| out.#ident(query)
});
}
}
(SupportedHttpMethod::Post, None) => {
quote! {
let #ident = http_api::warp_backend::simple_post(#path, {
let out = service.clone();
move || out.#ident()
});
}
}
(SupportedHttpMethod::Post, Some(_arg)) => {
quote! {
let #ident = http_api::warp_backend::params_post(#path, {
let out = service.clone();
move |params| out.#ident(params)
});
}
}
}
}
}
```
А теперь с помощью комбинатора `or` собираем все фильтры воедино.
```
impl ToTokens for ParsedApiDefinition {
fn to_tokens(&self, out: &mut proc_macro2::TokenStream) {
let fn_name = &self.attrs.warp
let interface = &self.item_trait.ident;
// В первом массиве содержатся фильтры, а во втором массиве
// соответствующие им идентификаторы, в данном случае это
// имена методов интерфейсного типажа.
let (filters, idents): (Vec<_>, Vec<_>) = self
.endpoints
.iter()
.map(|endpoint| {
let ident = &endpoint.ident
let handler = endpoint.impl_endpoint_handler();
(handler, ident)
})
.unzip();
let mut tail = idents.into_iter();
// Нам нужно собрать все фильтры в конструкцию вида
// `a.or(b).or(c).or(d)`, а для этого головной элемент
// следует обрабатывать отдельно, поэтому извлекаем его.
let head = tail.next().unwrap();
let serve_impl = quote! {
#head #( .or(#tail) )*
};
// Финальный аккорд: создаем искомую функцию.
let tokens = quote! {
fn #fn_name(
service: T,
addr: impl Into,
) -> impl std::future::Future
where
T: #interface + Clone + Send + Sync + 'static,
{
use warp::Filter;
// Создаем фильтры для всех методов трейта.
#( #filters )\*
// Комбинируем все фильтры в конечное API и запускаем
// warp сервер.
warp::serve(#serve\_impl).run(addr.into())
}
};
out.extend(tokens)
}
}
```
Заключение
----------
С помощью этой статьи я хотел показать, что derive макросы не всегда так сложны в написании,
если использовать дополнительные библиотеки и следовать определенным практикам.
На мой взгляд, подобный подход к использованию трейтов наиболее удобен, если нужно описать
некоторый RPC, связывающий различные приложения, которые написаны на Rust'е.
Нетрудно заметить, что можно легко написать генератор реализации типажа-интерфейса для HTTP
клиентов типа `reqwest` и тем самым исключить возможность ошибиться в сопряжении клиента и сервера на корню.
Никто не мешает при помощи макросов пойти дальше и выводить еще и [openapi](https://en.wikipedia.org/wiki/Open_API) или [swagger](https://en.wikipedia.org/wiki/Swagger_(software))
спецификацию для типажей-интерфейсов. Но мне кажется, в этом случае лучше пойти другим путем и по спецификации написать генератор Rust кода, это даст больший простор для маневров.
Если писать этот генератор в виде build зависимости, то можно воспользоваться библиотеками
`syn` и `quote`, таким образом, написание генератора будет очень комфортным и простым. Впрочем, это уже вдаль идущие размышления :)
Полностью рабочий код, примеры которого приводились в данной статье можно найти по этой
[ссылке](https://github.com/alekseysidorov/playground/blob/master/http_api_trait).
Спасибо за внимание! | https://habr.com/ru/post/486740/ | null | ru | null |
# Давненько не брал я в руки шашки. Знаем, знаем, как Вы играете
Ситуация в appStore для casual разработчиков быстро меняется.
2 года назад можно было заработать, выпуская платное приложение одновременно с бесплатным аналогом.
После появления в магазине более 100 000 программ этот трюк стал неэффективен.
Год назад шустрые парни стали выкладывать только бесплатные приложения, но с покупками внутри.
Одновременно число программ в appStore перевалило за 500 000.
В ближайшее время ( судя по финансовым отчетам 2012 года) только реклама внутри приложения принесет быстрые деньги.
До прошлого года я использовал фирменную рекламу от Apple.
Однако родная iAd реклама работает исключительно на территории врага.
Чтобы добрать деньги с игроков, живущих не в США (а это минимум 25%), следует прикрутить рекламу от, скажем, Google, которая будет мелькать там, где не работает iAd.
Под *habracut* я опишу механизм AdWhirl, реализующий показ баннеров от разных производителей.
Пример кода взят из бессмертной игры нашего прекрасного детства.
#### 10 шагов разработчика
##### Шаг раз
Регистрируем новое приложение [в тунце](https://itunesconnect.apple.com/).
Не забываем нажать кнопку *Set Up iAd Network*.
На выходе мы получим *Apple ID приложения* и ссылку на программу в тунце.
##### Шаг два
Идем на сайт [AdMob от Google](http://www.admob.com/).
Нажимаем кнопку *Add site/app*, заводим рекламную компанию, для этого используем название приложения, ссылку на приложение в тунце, например [как эту](http://itunes.apple.com/app/id496192518) и *Apple ID приложения* из первого шага. В итоге получаем *ID рекламной компании adMob* и ссылку на скачивание adMob SDK для iPhone/iPad.
##### Шаг три
Идем на сайт [AdWhirl](https://www.adwhirl.com/). Нажимаем кнопку **Add Application**, вносим в поля название приложения и ссылку. Включаем рекламные компании iAd и adMob, для чего используем *Apple ID приложения* для iAd и *ID рекламной компании* для adMob. Выставляем время обновления рекламы (минимум 15 секунд) и получаем на выходе *ID adWhirl компании* и ссылку на adWhirl SDK для iPhone.
##### Шаг четыре
Скачиваем adMob SDK, распаковываем и добавляем директорию в проект нашего приложения. Мышкой.
##### Шаг пять
Скачиваем adWhirl SDK, распаковываем и добавляем директорию в проект нашего приложения. Снова мышкой. Заходим в директорию adWhirl SDK, идем до C-файлов и выбрасываем все, кроме содержащих в своем названии буквы iAd и adMob. Иначе проект перестанет собираться.
##### Шаг шесть
Добавляем в приложении нужные для показа рекламы библиотеки — frameworks. Их около 7, полный список содержится в файле readme, скачанном вместе с SDK. Среди библиотек будут iAd.framework, sqlite3.lib, MessageUI.framework и прочие.
##### Шаг семь
Добавляем в header нашего главного класса ViewController текст
```
// ViewController.h
// chapay
//
// Created by vadim bashurov on 22.01.12
//
#import
#import "AdWhirlDelegateProtocol.h"
//
@class AdWhirlView;
//
@interface ViewController : UIViewController {
AdWhirlView \*adView;
}
//
@property (nonatomic,retain) AdWhirlView \*adView;
- (void)adjustAdSize;
@end
```
~~Текст простой, единственная засада — не могу угловую скобку поставить, Хабр ее съедает.~~
*AdWhirlView* — это элемент, где будут крутить рекламу.
Наша задача только поместить *AdWhirlView* в такое место экрана, чтоб на него почаще нажимали. Р-р-раз, и цент на нашем счету. Миллион нажатий — миллион центов. Хорошо, нет?
##### Шаг восемь
Добавляем в тело нашего главного класса ViewController другой текст
```
// ViewController.m
// chapay
//
// Created by vadim bashurov on 22.01.12.
//
#import "ViewController.h"
#import "AdWhirlView.h"
//#import
@implementation ViewController
@synthesize adView;
//
- (void)viewDidLoad
{
[super viewDidLoad];
self.adView = [AdWhirlView requestAdWhirlViewWithDelegate:self];
self.adView.autoresizingMask =
UIViewAutoresizingFlexibleLeftMargin|UIViewAutoresizingFlexibleRightMargin;
[self.view addSubview:self.adView];
}
//
#pragma mark AdWhirl
- (NSString \*)adWhirlApplicationKey {
return @"6492f291f2214227a0af9983658704dd";
}
//
- (BOOL)adWhirlTestMode {
return NO;
}
//
- (void)adWhirlDidDismissFullScreenModal
{
NSLog(@"adWhirlDidDismissFullScreenModal");
}
//
- (UIViewController \*)viewControllerForPresentingModalView {
return self;
}
//
- (void)adWhirlDidReceiveAd:(AdWhirlView \*)adWhirlView {
[self adjustAdSize];
}
//
- (void)adjustAdSize {
[UIView beginAnimations:@"AdResize" context:nil];
[UIView setAnimationDuration:0.7];
CGSize adSize = [adView actualAdSize];
CGRect newFrame = adView.frame;
newFrame.size.height = adSize.height;
newFrame.size.width = adSize.width;
newFrame.origin.x = (self.view.bounds.size.width - adSize.width)/2;
newFrame.origin.y = self.view.bounds.size.height - adSize.height;
adView.frame = newFrame;
[UIView commitAnimations];
}
@end
```
Комментарии не требуются — все прозрачно.
##### Шаг девять
Компилируем приложение, убираем ошибки, проверяем работу рекламы на живом устройстве. Ждем сутки, ибо adMob заработает не сразу, идет проверка наших ID и ссылок на приложение, которые мы внесли в поля регистрации.
##### Шаг десять
Выкладываем binary код на проверку в appStore и божьей милостью через пару недель начинаем ежедневно получать финансовые отчеты на сайте adWhirl или [appfigures](https://www.appfigures.com/).
Весь процесс занимает около 60-ти минут.
##### По итогам продаж могу сказать
1) реклама на iPhone приносит в 2 раза больше денег, чем покупки из приложения;
2) реклама на iPad приносит в 5 раз больше денег, чем покупка из приложения.
Всех с днем сурка, перцы! | https://habr.com/ru/post/137425/ | null | ru | null |
# Reactor, WebFlux, Kotlin Coroutines, или Асинхронность на простом примере
Многие сервисы в современном мире, по большей части, «ничего не делают». Их задачи сводятся к запросам к другим базам/сервисам/кешам и агрегации всех этих данных по различным правилам и разнообразной бизнес-логике. Поэтому неудивительно, что появляются такие языки, как Golang, с удобной встроенной конкурентной системой, позволяющей легко организовывать неблокирующий код.
В JVM-мире всё немного сложнее. Есть огромное количество фреймворков и библиотек, блокирующих потоки при использовании. Так и сама stdlib может делать то же самое порой. Да и в Java нет аналогичного механизма, похожего на горутины в Golang.
Тем не менее, JVM активно развивается и появляются новые интересные возможности. Есть Kotlin с корутинами, которые по своему использованию очень похожи на горутины из Golang (хоть и реализованы совершенно по-другому). Есть JEP Loom, который в будущем привнесёт fibers в JVM. Один из самых популярных веб-фреймворков — Spring — не так давно добавил возможность создавать полностью неблокирующие сервисы на Webflux. А с недавним релизом Spring boot 2.2 интеграция с Kotlin стала ещё лучше.
Предлагаю на примере небольшого сервиса по переводу денег с одной карты на другую самим написать приложение на Spring boot 2.2 и Kotlin для интеграции с несколькими внешними сервисами.
Хорошо, если вы уже знакомы с Java, Kotlin, Gradle, Spring, Spring boot 2, Reactor, Web~~flux, Tomcat, Netty, Kotlin Сoroutines, Gradle Kotlin DSL или даже имеете степень доктора наук~~. Но если нет — не беда. Код будет максимально упрощён, и даже если вы не из мира JVM, надеюсь, вам будет всё понятно.
Если вы планируете сами написать сервис, убедитесь, что всё необходимое установлено:
* Java 8+;
* Docker и Docker Compose;
* cURL и желательно [jq](https://stedolan.github.io/jq/download/);
* Git;
* желательно IDE для Kotlin (Intellij Idea, Eclipse, VS, ~~vim~~ и т.п.). Но можно и в блокноте.
Примеры будут содержать как заготовки под реализацию в сервисе, так и уже написанную реализацию. Сначала запустим установку и сборку и подробнее рассмотрим сервисы и их API.
> Сам пример сервисов и API сделан лишь для наглядности, не стоит переносить к себе в прод всё `AS IS`!
Сперва клонируем к себе репозиторий с сервисами, интеграцию с которыми будем делать, и переходим в директорию:
```
git clone https://github.com/evgzakharov/spring-demo-services && cd spring-demo-services
```
В отдельном терминале собираем все приложения с помощью `gradle`, где после успешной сборки все сервисы запустятся с помощью `docker-compose`.
```
./gradlew build && docker-compose up
```
Пока всё скачивается и устанавливается, рассмотрим проект с сервисами.
На вход сервиса (Demo service) будет поступать запрос с токеном, номерами карт для перевода и суммой, которую будем переводить между картами:
```
{
"authToken": "auth-token1",
"cardFrom": "55593478",
"cardTo": "55592020",
"amount": "10.1"
}
```
По токену `authToken` необходимо сходить в сервис `AUTH` и получить `userId`, с которым потом можно сделать запрос к `USER` и вытянуть всю дополнительную информацию по пользователю. `AUTH` также будет возвращать нам информацию о том, к каким из трёх сервисов мы можем получить доступ. Пример ответа от `AUTH`:
```
{
"userId": 158,
"cardAccess": true,
"paymentAccess": true,
"userAccess": true
}
```
Для перевода между картами сначала идём с каждым номером карты в `CARD`. В ответ на запросы мы получим `cardId`, дальше с ними отправляем запрос в `PAYMENT` и делаем перевод. И последнее — ещё раз отправляем запрос в `PAYMENT` с `fromCardId` и узнаём текущий баланс.
Чтобы эмулировать небольшую задержку в сервисах, во всех контейнерах пробрасывается значение переменной окружения TIMEOUT, в которой в миллисекундах задаётся задержка на ответ. И чтобы разнообразить ответы от `AUTH`, есть возможность варьировать значение `SUCCESS_RATE`, которое управляет вероятностью ответа `true` для сервиса.
Файл docker-compose.yaml:
```
version: '3'
services:
service-auth:
build: service-auth
image: service-auth:1.0.0
environment:
- SUCCESS_RATE=1.0
- TIMEOUT=100
ports:
- "8081:8080"
service-card:
build: service-card
image: service-card:1.0.0
environment:
- TIMEOUT=100
ports:
- "8082:8080"
service-payment:
build: service-payment
image: service-payment:1.0.0
environment:
- TIMEOUT=100
ports:
- "8083:8080"
service-user:
build: service-user
image: service-user:1.0.0
environment:
- TIMEOUT=100
ports:
- "8084:8080"
```
Для всех сервисов делается проброс портов с 8081 по 8084, чтобы легко достучаться до них напрямую.
Перейдём к написанию `Demo service`. Сперва попробуем написать реализацию максимально «топорно», без асинхронности и параллелизма. Для этого возьмём Spring boot 2.2.1, Kotlin и заготовку для сервиса. Клонируем репозиторий и переходим в ветку `spring-mvc-start`:
```
git clone https://github.com/evgzakharov/demo-service && cd demo-service && git checkout spring-mvc-start
```
Переходим в файл `demo.Controller`. В нём есть единственный пустой метод `processRequest`, реализацию для которого необходимо написать.
```
@PostMapping
fun processRequest(@RequestBody serviceRequest: ServiceRequest): Response { .. }
```
На вход в метод будет поступать запрос на перевод между картами.
```
data class ServiceRequest(
val authToken: String,
val cardFrom: String,
val cardTo: String,
val amount: BigDecimal
)
```
**Для тех, кто не близко знаком с Spring**
В Spring есть встроенный DI, который работает на основе аннотаций. DemoController помечен специальной аннотацией `RestController`: она, помимо регистрации бина в DI, добавляет также его обработку как контроллера. PostProcessor находит все методы, помеченные аннотацией `PostMapping`, и добавляет их в качестве endpoint у сервиса с методом `POST`.
Обработчик также создаёт proxy-класс для DemoController, в котором в метод `processRequest` передаются все необходимые аргументы. В нашем случае это всего один аргумент, помеченный аннотацией `@RequestBody`. Поэтому в proxy данный метод будет вызываться с содержимым JSON, десериализованым в класс `ServiceRequest`.
Чтобы было проще, все методы по интеграции с другими сервисами уже сделаны, нужно только их правильно соединить. Методов всего пять, по одному под каждое действие. Сами вызовы других сервисов реализованы на **блокирующем** вызове `RestTemplate` из Spring.
Пример метода для вызова `AUTH`:
```
private fun getAuthInfo(token: String): AuthInfo {
log.info("getAuthInfo")
return restTemplate.getForEntity("${demoConfig.auth}/{token}", AuthInfo::class.java, token)
.body ?: throw RuntimeException("couldn't find user by token='$token'")
}
```
Перейдём к реализации метода. В комментариях отмечен порядок действий и какой ответ ожидается на выходе:
```
@PostMapping
fun processRequest(@RequestBody serviceRequest: ServiceRequest): Response {
//1) get auth info from service by token -> userId
//2) find user info by userId from 1.
//3) 4) find cards info for each card in serviceRequest
// 5) make transaction for known cards by calling sendMoney(id1, id2, amount)
// 6) after payment get payment info by fromCardId
TODO("return SuccessResponse")
// SuccessResponse(
// amount = ,
// userName = ,
// userSurname = ,
// userAge =
// )
}
```
Сначала реализуем метод максимально просто, без учёта, что `AUTH` может нам запретить доступ к другим сервисам. Попробуйте это сделать самостоятельно. Когда получится (или после перехода в ветку `spring-mvc`), вы можете проверить работу сервиса следующим образом:
**реализация из ветки spring-mvc**
```
fun processRequest(@RequestBody serviceRequest: ServiceRequest): Response {
val authInfo = getAuthInfo(serviceRequest.authToken)
val userInfo = findUser(authInfo.userId)
val cardFromInfo = findCardInfo(serviceRequest.cardFrom)
val cardToInfo = findCardInfo(serviceRequest.cardTo)
sendMoney(cardFromInfo.cardId, cardToInfo.cardId, serviceRequest.amount)
val paymentInfo = getPaymentInfo(cardFromInfo.cardId)
return SuccessResponse(
amount = paymentInfo.currentAmount,
userName = userInfo.name,
userSurname = userInfo.surname,
userAge = userInfo.age
)
}
```
Запускаем сервис (из папки demo-service):
```
./gradlew bootRun
```
Отправляем запрос на endpoint:
```
./demo-request.sh
```
В ответ получаем что-то подобное:
```
➜ demo-service git:(spring-mvc) ✗ ./demo-request.sh
+ curl -XPOST http://localhost:8080/ -d @demo-payment-request.json -H 'Content-Type: application/json; charset=UTF-8'
+ jq .
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 182 0 85 100 97 20 23 0:00:04 0:00:04 --:--:-- 23
{
"amount": 989.9,
"userName": "Vasia",
"userSurname": "Pupkin",
"userAge": 18,
"status": true
}
```
В общей сумме нужно сделать 6 запросов, чтобы реализовать работу сервиса. И учитывая, что каждый из них отвечает с задержкой в 100 мс, общее время не может быть меньше 600 мс. В реальности получается примерно 700 мс с учётом всех накладных расходов. Пока код совсем простой, и если мы сейчас захотим добавить проверку ответа `AUTH` для доступа к другим сервисам, то это будет несложно сделать (как и любой другой рефакторинг).
Но давайте подумаем, как можно ускорить выполнение запросов. Если не учитывать проверки ответа от `AUTH`, то у нас есть 2 независимые задачи:
* получение `userId` и запрос данных из `USER`;
* получение `cardId` для каждой из карт, проведение платежа и получение итоговой суммы.
Эти задачи могут выполняться независимо друг от друга. Тогда суммарное время выполнения будет зависеть от наиболее длинной цепочки вызовов (в данном случае второй) и будет суммарно выполняться за время 300 мс + X мс на накладные расходы.
Учитывая, что сами вызовы у нас блокирующие, то единственный способ выполнить параллельные запросы — запускать их на отдельных потоках. Можно под каждый вызов создать отдельный Thread, но это будет очень накладно. Другой способ — запуск задач на ThreadPool. С первого взгляда такое решение выглядит подходящим, и время действительно уменьшится. Например, мы можем выполнять запросы на CompletableFuture. Он позволяет запускать фоновые задачи, вызывая методы с постфиксом `async`. И если при вызове методов не указывать конкретный ThreadPool, задачи будут запускаться на `ForkJoinPool.commonPool()`. Попробуйте сами написать реализацию или перейдите в ветку `spring-mvc-async`.
**Реализация из ветки spring-mvc-async**
```
fun processRequest(@RequestBody serviceRequest: ServiceRequest): Response {
val authInfoFuture = CompletableFuture.supplyAsync { getAuthInfo(serviceRequest.authToken) }
val userInfoFuture = authInfoFuture.thenApplyAsync { findUser(it.userId) }
val cardFromInfo = CompletableFuture.supplyAsync { findCardInfo(serviceRequest.cardFrom) }
val cardToInfo = CompletableFuture.supplyAsync { findCardInfo(serviceRequest.cardTo) }
val waitAll = CompletableFuture.allOf(cardFromInfo, cardToInfo)
val paymentInfoFuture = waitAll
.thenApplyAsync {
sendMoney(cardFromInfo.get().cardId, cardToInfo.get().cardId, serviceRequest.amount)
}
.thenApplyAsync {
getPaymentInfo(cardFromInfo.get().cardId)
}
val paymentInfo = paymentInfoFuture.get()
val userInfo = userInfoFuture.get()
log.info("result")
return SuccessResponse(
amount = paymentInfo.currentAmount,
userName = userInfo.name,
userSurname = userInfo.surname,
userAge = userInfo.age
)
}
```
Если сейчас измерить время запроса, оно будет в районе 360 мс. По сравнению с первоначальным вариантом, суммарное время уменьшилось почти в 2 раза. Сам код немного усложнился, но пока его всё так же несложно видоизменять. И если мы тут захотим добавить проверку ответа от `AUTH`, то и это сделать несложно.
Но что если у нас большое количество входящих запросов на сам сервис? Скажем, около 1000 одновременных запросов? При таком подходе довольно быстро получится, что все потоки ThreadPool заняты выполнением блокирующих вызовов. И мы приходим к тому, что текущий вариант тоже не устраивает.
Остаётся только что-то сделать с самими вызовами сервисов. Можно изменить запросы и сделать их неблокирующими. Тогда методы по вызову сервисов будут возвращать CompletableFuture, Flux, Observable, Deferred, Promise или аналогичный объект, на котором можно построить цепочку ожиданий. При таком подходе нам не нужно делать вызовы на отдельных потоках — достаточно будет одного (или по крайней мере маленького отдельного пула потоков), который мы уже заняли под обработку запросов.
Сможем ли мы теперь выдерживать на сервисе большую нагрузку? Чтобы ответить на этот вопрос, внимательно посмотрим на Tomcat, который используется в Spring boot 2.2.1 в стартере `org.springframework.boot:spring-boot-starter-web`. Он построен так, что под каждый входящий запрос выделяется поток из ThreadPool на его обработку. И при отсутствии свободных потоков новые запросы будут становиться «в очередь» ожидания. Но сам наш сервис только лишь рассылает запросы в другие сервисы. Выделять под это целый поток и блокировать его, пока не придут ответы от всех, выглядит, мягко говоря, излишним.
К счастью, недавно в Spring появилась возможность использовать неблокирующий веб-сервер на базе Netty или Undertow. Для этого потребуется только сменить стартер `spring-boot-starter-web` на `spring-boot-starter-webflux` и немного изменить метод для обработки запросов, в котором запрос и ответ будут «обёрнуты» в Mono. Это связано с тем, что Webflux построен на основе Reactor, и поэтому теперь в методе нужно построить цепочку из преобразований Mono.
Попробуйте написать самостоятельно неблокирующую реализацию метода. Для этого перейдите в ветку `spring-webflux-start`. Обратите внимание, что изменился стартер для Spring Boot, где теперь используется версия с Webflux, и также изменилась реализация запросов к другим сервисам, которые переписаны на использование неблокирующего `WebClient`.
Пример метода для вызова AUTH:
```
private fun getAuthInfo(token: String): Mono {
log.info("getAuthInfo")
return WebClient.create().get()
.uri("${demoConfig.auth}/$token")
.retrieve()
.bodyToMono(AuthInfo::class.java)
}
```
В содержимое метода `processRequest` в комментарии вставлена реализация из первого примера. Попробуйте её самостоятельно переписать на Reactor. Как и в прошлый раз, вначале сделайте версию без учёта проверок от `AUTH`, а потом посмотрите, насколько сложно их добавить:
```
fun processRequest(@RequestBody serviceRequest: Mono): Mono {
// val authInfo = getAuthInfo(serviceRequest.authToken)
//
// val userInfo = findUser(authInfo.userId)
//
// val cardFromInfo = findCardInfo(serviceRequest.cardFrom)
// val cardToInfo = findCardInfo(serviceRequest.cardTo)
//
// sendMoney(cardFromInfo.cardId, cardToInfo.cardId, serviceRequest.amount)
//
// val paymentInfo = getPaymentInfo(cardFromInfo.cardId)
//
// log.info("result")
//
// return SuccessResponse(
// amount = paymentInfo.currentAmount,
// userName = userInfo.name,
// userSurname = userInfo.surname,
// userAge = userInfo.age
// )
TODO()
}
```
После того как справились с этим, можете сравнить с моей реализацией из ветки `spring-webflux`:
**Реализация из ветки spring-webflux**
```
fun processRequest(@RequestBody serviceRequest: Mono): Mono {
val cacheRequest = serviceRequest.cache()
val userInfoMono = cacheRequest.flatMap {
getAuthInfo(it.authToken)
}.flatMap {
findUser(it.userId)
}
val cardFromInfoMono = cacheRequest.flatMap { findCardInfo(it.cardFrom) }
val cardToInfoMono = cacheRequest.flatMap { findCardInfo(it.cardTo) }
val paymentInfoMono = cardFromInfoMono.zipWith(cardToInfoMono)
.flatMap { (cardFromInfo, cardToInfo) ->
cacheRequest.flatMap { request ->
sendMoney(cardFromInfo.cardId, cardToInfo.cardId, request.amount).map { cardFromInfo }
}
}.flatMap {
getPaymentInfo(it.cardId)
}
return userInfoMono.zipWith(paymentInfoMono)
.map { (userInfo, paymentInfo) ->
log.info("result")
SuccessResponse(
amount = paymentInfo.currentAmount,
userName = userInfo.name,
userSurname = userInfo.surname,
userAge = userInfo.age
)
}
}
```
Согласитесь, что теперь написать реализацию (по сравнению с предыдущим блокирующим подходом) стало сложней. И если мы захотим добавить «забытые» проверки от `AUTH`, то это будет не так просто сделать.
В этом вся суть реактивного подхода. Он прекрасно подходит для построения неразветвлённых цепочек обработок. Но если появляется ветвление, то код становится уже не таким простым.
Помочь тут могут корутины из Kotlin, которые прекрасно дружат с любым асинхронным/реактивным кодом. К тому же существует большое количество написанных обёрток для [Reactor](https://github.com/Kotlin/kotlinx.coroutines/blob/master/reactive/README.md), [CompletableFuture](https://github.com/Kotlin/kotlinx.coroutines/tree/master/integration/kotlinx-coroutines-jdk8) и т.п. Но даже если вы не найдёте нужную, её всегда можно написать самостоятельно, используя специальные [билдеры](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/suspend-cancellable-coroutine.html).
Давайте самостоятельно перепишем реализацию на корутины. Для этого перейдём в ветку `spring-webflux-coroutines-start`. В ней в build.gradle.kts добавляются нужные зависимости:
```
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlinCoroutinesVersion")
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactive:$kotlinCoroutinesVersion")
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactor:$kotlinCoroutinesVersion")
```
И немного меняется метод `processRequest`:
```
suspend fun processRequest(@RequestBody serviceRequest: ServiceRequest): Response = coroutineScope {
//TODO()
}
```
Он больше не нуждается в Mono и преобразуется просто в suspend-функцию (спасибо интеграции Spring и Kotlin). Учитывая, что в методе мы будем создавать дополнительные корутины, нам потребуется создать дочерний скоуп `coroutineScope` (для понимания причин создания дополнительного скоупа посмотрите пост Романа Елизарова о [Structured concurrency](https://medium.com/@elizarov/structured-concurrency-722d765aa952)). Обратите внимание, что другие вызовы сервисов совсем не изменились. Они возвращают всё тот же Mono, на котором можно вызвать `suspend`-метод `awaitFirst`, чтобы «дождаться» результата выполнения запроса.
Если корутины для вас ещё новая концепция, то есть замечательный [гайд](https://github.com/Kotlin/kotlinx.coroutines/blob/master/coroutines-guide.md) c подробным описанием. Попробуйте самостоятельно написать реализацию метода `processRequest` или перейдите в ветку `spring-webflux-coroutines`:
**реализация из ветки spring-webflux-coroutines**
```
suspend fun processRequest(@RequestBody serviceRequest: ServiceRequest): Response = coroutineScope {
log.info("start")
val userInfoDeferred = async {
val authInfo = getAuthInfo(serviceRequest.authToken).awaitFirst()
findUser(authInfo.userId).awaitFirst()
}
val paymentInfoDeferred = async {
val cardFromInfoDeferred = async { findCardInfo(serviceRequest.cardFrom).awaitFirst() }
val cardToInfoDeferred = async { findCardInfo(serviceRequest.cardTo).awaitFirst() }
val cardFromInfo = cardFromInfoDeferred.await()
sendMoney(cardFromInfo.cardId, cardToInfoDeferred.await().cardId, serviceRequest.amount).awaitFirst()
getPaymentInfo(cardFromInfo.cardId).awaitFirst()
}
val userInfo = userInfoDeferred.await()
val paymentInfo = paymentInfoDeferred.await()
log.info("result")
SuccessResponse(
amount = paymentInfo.currentAmount,
userName = userInfo.name,
userSurname = userInfo.surname,
userAge = userInfo.age
)
}
```
Можно сравнить код с реактивным подходом. С корутинами не придётся заранее продумывать все точки ветвлений. Мы можем просто в нужных местах вызывать методы `await` и «ответвлять» выполнение асинхронных задач в `async`. Код остаётся максимально похожим на первоначальный прямолинейный вариант, который совсем не сложно изменять. И немаловажным фактором является то, что корутины просто встраиваются в реактивный код.
Возможно, даже для этой задачи реактивный подход вам нравится больше, но многие из опрошенных людей находят его более сложным. В целом оба подхода решают свою задачу и можно использовать тот, что по душе. Кстати, с недавних пор в Kotlin появилась ещё и возможность создавать «холодные» корутины с Flow, которые во многом похожи на Reactor. Правда, они ещё находятся в экспериментальной стадии, но уже сейчас можно посмотреть на текущую реализацию и попробовать у себя в коде.
На этом хочу закончить и напоследок оставить полезные ссылки:
* [Гайд по корутинам](https://github.com/Kotlin/kotlinx.coroutines/blob/master/coroutines-guide.md)
* [Coroutines Reactor](https://github.com/Kotlin/kotlinx.coroutines/blob/master/reactive/README.md)
* [Coroutines CompletableFuture](https://github.com/Kotlin/kotlinx.coroutines/tree/master/integration/kotlinx-coroutines-jdk8)
* [Роман Елизаров про корутины](https://www.youtube.com/results?search_query=%D0%B5%D0%BB%D0%B8%D0%B7%D0%B0%D1%80%D0%BE%D0%B2+%D1%80%D0%BE%D0%BC%D0%B0%D0%BD+%D0%BA%D0%BE%D1%80%D1%83%D1%82%D0%B8%D0%BD%D1%8B)
* [Kotlin Flows and Coroutines](https://medium.com/@elizarov/kotlin-flows-and-coroutines-256260fb3bdb)
* [Structured concurrency](https://medium.com/@elizarov/structured-concurrency-722d765aa952)
* [Spring boot loves Kotlin](https://blog.karumi.com/spring-boot-loves-kotlin/)
Надеюсь, вам было интересно и у вас получилось самостоятельно написать реализацию метода для всех способов. И, конечно, хочется верить, что вариант с корутинами вам нравится больше =)
Спасибо всем, кто дочитал до конца! | https://habr.com/ru/post/477052/ | null | ru | null |
# Хабраподсветка или эксперименты в изолированном окружении Python
Протестировать свежую версию любимого фреймоврка. Запустить приложение со специфичным набором библиотек. Установить необходимые библиотеки по списку зависимостей. Как решить все эти задачи не затронув системные файлы? В этой статье речь пойдет об утилитах virutalenv и pip.
Утилита vitrualenv предназначена для создания изолированных окружений Python. Под окружением понимается собственно интерпретатор и набор библиотек к нему. Утилита pip органично дополняет easy\_install, делая установку пакетов еще проще. Подробную информацию о всех полезностях, которые virutalenv и pip дают разработчику, вы сможете узнать, посетив странички [pypi.python.org/pypi/virtualenv](http://pypi.python.org/pypi/virtualenv) и [pypi.python.org/pypi/pip](http://pypi.python.org/pypi/pip). Я же покажу на примере как все это можно использовать для экспериментов с проектами на языке Python.
Суть данного проекта предельно проста. Эта небольшая консольная программулька с именем hl.py будет раскрашивать исходный код скриптов для вставки в хабратопик. Через командую строку она принимает путь к файлу с исходником и язык, а в ответ печатает нужный html код. Например, вот так она раскрашивает сама себя:
````
$ ./ht.py ./hl.py python
Traceback (most recent call last):
File "./hl.py", line 3, in
pkg\_resources.require('lxml==2.2.2')
File "/usr/lib/python2.6/dist-packages/pkg\_resources.py", line 626, in require
needed = self.resolve(parse\_requirements(requirements))
File "/usr/lib/python2.6/dist-packages/pkg\_resources.py", line 524, in resolve
raise DistributionNotFound(req) # XXX put more info here
pkg\_resources.DistributionNotFound: lxml==2.2.2
````
Упс, не работает. Сообщение говорит о том, что не установлен дистрибутив lxml версии 2.2.2. Посмотрим, что есть в Ubuntu:
`$ apt-cache show python-lxml | grep -E ^Version
Version: 2.1.5-1ubuntu2`
Действительно есть что-то похожее, но, определенно, не той версии которая требует эта программулька. А как узнать, что такое lxml? Воспользуемся утилитой yolk (http://pypi.python.org/pypi/yolk).
`$ yolk -f summary -M lxml
bash: yolk: команда не найдена
$ apt-cache search yolk
$`
Почему разработчики Ubuntu не сделали пакет для такой полезной утилитки?…
Однако, это не проблема. У нас есть возможность сделать собственное окружение Python, не зависящее от причуд создателей дистрибутива операционной системы. Сохраните на диск следующий скрипт под именем vipsetup и сделайте его исполняемым:
````
#!/bin/sh
# Setup virtual environment for python and pip
# Usage:
# vipsetup [directory]
ENV_DIR="$1"
VIRTUALENV_BIN='virtualenv'
VIRTUALENV_ARGS='--no-site-packages'
if [ ! -f $ENV_DIR/bin/activate ]; then
if ! type "$VIRTUALENV_BIN"; then
if ! type "easy_install"; then
echo "Error: easy_install executable not found."
echo "To install easy_install type:"
echo " sudo apt-get install python-setuptools"
exit 1
fi
TMPDIR=`mktemp -d -t ve.XXXXXXXXXX` || exit 1
PYTHONPATH=$TMPDIR easy_install --install-dir=$TMPDIR virtualenv || exit 1
PYTHONPATH=$TMPDIR $TMPDIR/virtualenv "$@" $VIRTUALENV_ARGS || exit 1
rm -rf $TMPDIR
else
$VIRTUALENV_BIN "$@" $VIRTUALENV_ARGS || exit 1
fi
fi
if [ ! -e $ENV_DIR/bin/pip ]; then
$ENV_DIR/bin/easy_install pip || exit 1
fi
echo ""
echo "Installation complete"
echo "* To activate virtual environment type:"
echo " . $ENV_DIR/bin/activate"
echo "* To install python package type:"
echo " $ENV_DIR/bin/pip install "
if [ -z "$PIP\_DOWNLOAD\_CACHE" ]; then
echo "\* To enable cache for downloads"
echo " set environment variable PIP\_DOWNLOAD\_CACHE with a path"
fi
````
Создайте новое изолированное окружение, при помощи команд:
`$ mkdir -p /tmp/testenv
$ cd /tmp/testenv
$ vipsetup .
$ . /bin/activate
(testenv) $`
А теперь установите yolk, используя команду pip:
`(testenv) $ pip install yolk
...
(testenv) $ yolk -f summary -M lxml
summary: Powerful and Pythonic XML processing library combining libxml2/libxslt with the ElementTree API.`
Вот и описание. Установите lxml требуемой версии:
`(testenv) $ pip install lxml==2.2.2`
Теперь, все готово для запуска нашей программульки:
`(testenv) $ ./hl.py ./hl.py python
#!/usr/bin/env python
import pkg_resources` | https://habr.com/ru/post/70353/ | null | ru | null |
# Автовход с паролем и управление по ssh «в гостях» при помощи expect
В очередной раз используя этот скрипт в одном из учебных классов, я поискал материалы и обнаружил, что здесь давно не вспоминали об expect. Это замечательный альтернативный интерпретатор для командной строки Linux, который может общаться с ней вместо живого человека, и я добавлю сюда лишь ещё один пример его применения.
Картинок на эту тему особо нет, а в статье и вообще не будет, поэтому привлечём ваше внимание обложкой замечательной книги
#### Немного истории и оффтопика
В начале 2013го я вернулся в дополнительное образование детей, получил 24 часа еженедельной нагрузки для четырёх групп «юных программистов» и «юных системных администраторов», и приступил к набору учеников на двух площадках: моём собственном кабинете и кабинете информатики находящейся неподалёку гимназии. Силами групп «юных системных администраторов» мы привели свой кабинет в порядок, развернув AltLinux 6 и парочку альтернативных дистрибутивов. А в гимназии очень опытный «инженер компьютерного класса» давно вёл эксперименты с source-based, закончившиеся приходом Calculate Linux на все машины учителей и учебных классов. Респект ему)
#### Задача
Через пару месяцев занятий я увидел проблему. Дети отказывались уходить с занятий, любым способом стараясь задержаться подольше. Т.к. педагогические технологии — это не моё, а кружок у нас всё-таки технический, я убивал сторонние процессы и выключал машины по ssh. Это повысило интерес учеников к изучению возможностей командной строки. Однако скоро они нашли баг: выключение «руками» занимает слишком много времени, и даже в небольшом кабинете они успеют перезапустить половину машин до того, как я завершу карательный процесс, и это затянет дело. Чтобы продемонстрировать ~~кто здесь главный~~ лучшие возможности программирования для командной строки, я задумался об автоматизации.
#### Варианты решения
Нулевой мыслью было использование [italc](http://italc.sourceforge.net/), и мы даже уделили несколько недель его настройке и экспериментам. Но он оказался слишком глючен и примитивен, поэтому был благополучно забыт.
Первой же мыслью было настроить доступ через ssh по отпечатку. Это сократило бы задачу до одного цикла, но для применения «на коленке» этот способ оказался не совсем пригоден (хотя почему нет? ЕМНИП, отпечаток для пользователя также можно создать без рута). Но при доступной авторизации по паролю (кстати, большой ущерб безопасности для учебных классов, где логин-пароли одинаковы) меня заинтересовал вариант с автоматической авторизацией по паролю. Уделив час поиску, я нашёл несколько примеров для expect.
#### Решение через expect
##### Перед началом
Но, во первых, он должен быть установлен. В моём классе мы без труда сделали это, а вот в классе гимназии ВНЕЗАПНО оказалось, что и expect, и nmap, и некоторые другие интересные системные утилиты не только установлены, но и доступны ученику. Это очень помогло нам, когда в очередной раз «упал» прикрученный по NFS сетевой диск, и мы нашли способ распространения заданий через быстро найденный бухгалтерский компьютер с расшаренными дисками.
Во вторых, кроме самого expect, нам понадобится использовать 2 типа цикла: с предусловием и с параметром. Первый необходим для «зацикливания» процесса, чтобы можно было повесить выполнение скрипта фоном на всё занятие. Второй же необходим для перебора необходимых адресов, на которые мы будем заходить по ssh при помощи собственно expect.
Также необходимо помнить, что стандартно скрипт выпадает при возникновении первой же ошибки, например неответе компьютера клиента, и наверное стоит поискать способ обработки таких исключений.
##### Скрипт
Сообщаем, что для выполнения нам необходимо использовать нестандартный интерпретатор
```
#!/usr/bin/expect -f
```
Задаём паузу для ожидания ответа с клиента, имя пользователя и пароль (это скорее по инерции из имеющихся в сети примеров):
```
set timeout 2
set USER "u1"
set PASS "1"
```
Начало сценария:
```
while 1 { // применение цикла с предусловием
foreach HOST {58 60 61} { // применение цикла с параметром для списка окончаний адресов. Да, их можно генерировать и автоматически, но пост не об этом
spawn ssh $USER@192.168.0.$HOST // подключаемся
expect {
"(yes/no)?*" {
send "yes\r" // не забывайте про \r в конце строки, перед кавычками. Иначе волшебства не получится
}
}
expect "word:"
send "$PASS\r"
expect "$*"
send "killall -r teew*\r"
expect "$*"
send "killall firefox\r"
expect "$*"
send "killall chrome\r"
expect "$*"
send "exit\r"
expect eof
}
```
Это был простой скрипт автоубивания ненужных процессов для гимназии. В своём же кабинете я модифицировал скрипт и для автовыключения машин:
```
guest@0-315-gymn2 ~ $ cat scripty
#!/usr/bin/expect -f
set timeout 2
set USER "user"
set HOST "2"
set PASS "2357"
# Начало сценария
while 1 {
foreach HOST {2 3 5 7} {
spawn ssh $USER@192.168.0.$HOST
expect {
"(yes/no)?*" {
send "yes\r"
}
}
expect "word:"
send "$PASS\r"
expect "$*"
send "su\r"
expect "word:*"
send "supassword\r"
expect "#*"
send "/sbin/shutdown 0 -hP\r"
expect "#*"
send "exit\r"
expect "$*"
send "exit\r"
expect eof
}
}
```
#### Заключение
Надеюсь, упоминание замечательного интерпретатора expect и пара живых примеров по работе с ним будут полезны сообществу и породят немало статей о более тонких его применениях.
#### P.S.:
Скрипт автопоиска активных компьютеров и создания списка адресов для обработки чуть позже написал один мой ученик (не делать же всё интересное самому). Чуть позже, когда заслужит инвайт, он сможет сам написать об этом в применении к более интересной задаче. | https://habr.com/ru/post/222857/ | null | ru | null |
# Домашний сервер «всё-в-одном» — success story
Жил да был у меня роутер одной хорошей фирмы на букву «Dead». Ну, это с ним, собственно, и случилось.
Посмотрел я на цены новых, на кучу компьютерного хлама в углу, на список подключений на домашнем компе… И понял, что не нужен мне роутер. Соберу свой, с нормальной маршрутизацией, DNS, WINS, i2p, ~~блекджеком~~ и так далее.
#### Как это было?
После недолгих раскопок в залежах железа, на свет были извлечены:
• Процессор Intel Core 2 Duo E8400 @ 3GHz
• При нём же – материнка Asus P5Q
• 2 планки DDR2 по 2Gb
• PCI-e сетевая карта TP-Link TG-3468
• Неопознанная сетевая карта WiFi (b/g/n) на базе Ralink RT3060
• Жёсткий диск Seagate 250Gb
Вывод lshw можно посмотреть [тут](http://pastebin.com/7K1kw2X7).
Всё это было отчищено от пыли, вмонтировано в корпус с блоком питания, запущено и проверено в memtest и mhdd. Не обнаружив дефектов, я начал установку всего мне необходимого.
#### Основы основ
За основу я взял дистрибутив Debian Testing, раскатанный через Debootstrap. Сверху сразу были поставлены openssh-server, firmware-ralink и pppoe/pppoeconf.
Ребутнувшись в свежепоставленную систему, я сразу перенёс SSH на 192.168.1.1 и отключил авторизацию по паролю (установив предварительно свой ключ).
#### Да будет сеть!
Для начала был запущен pppoeconf. К DOCSIS-модему оказалась подключена сетевая карта с именем eth1, в итоге был получен следующий конфиг /etc/ppp/peers/rt:
```
noipdefault
defaultroute
replacedefaultroute
hide-password
noauth
persist
plugin rp-pppoe.so eth1
user "ptn"
usepeerdns
```
Но это не всё – необходимо ещё настроить /etc/network/interfaces следующим образом:
```
auto rt
iface rt inet ppp
pre-up /sbin/ifconfig eth1 up
provider rt
```
#### Превращаем роутер в WiFi-AP
Изначальная задумка была в том, что бы сделать 2 WiFi-сети: одну для своих компьютеров и ноутбуков, с надёжным паролем и присоединением ко всем необходимым ресурсам, а вторую – для гостей, которым захотелось выйти в интернет, но не надо знать о том, что творится в моей сети.
В итоге на сервер был установлен hostapd с конфигом следующего вида (все названия сетей и пароли были изменены):
```
interface=wlan0
driver=nl80211
country_code=RU
ieee80211d=1
hw_mode=g
channel=9
ssid=Private
bridge=br0
preamble=1
ignore_broadcast_ssid=0
wpa=3
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP CCMP
rsn_pairwise=CCMP
wpa_passphrase=MyVeryStrongPassword
wmm_enabled=1
ieee80211n=1
ht_capab=[HT40-][SHORT-GI-20][SHORT-GI-40]
internet=1
bss=wlan0_0
ssid=Guest
preamble=1
ignore_broadcast_ssid=0
wpa=3
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP CCMP
rsn_pairwise=CCMP
wpa_passphrase=passw0rd
wmm_enabled=1
ieee80211n=1
ht_capab=[HT40-][SHORT-GI-20][SHORT-GI-40]
internet=1
```
Тут мы ставим ещё и bridge для eth0 и wlan0 – это позволит подключившимся к нашей сети видеть её целиком, а не беспроводной сегмент. Модифицируем networks:
```
auto eth0 wlan0 wlan0_0 br0
iface eth0 inet manual
allow-hotplug wlan0
allow-hotplug wlan0_0
iface wlan0 inet manual
pre-up ifconfig wlan0 hw ether f2:7d:68:6d:51:30
iface br0 inet static
bridge_ports eth0 wlan0
address 192.168.1.1
netmask 24
iface wlan0_0 inet static
address 192.168.254.1
netmask 24
```
Немного о магии в pre-up для wlan0: для работы с несколькими AP нам надо использовать больше, чем один MAC-адрес. Hostapd назначает MAC для виртуальных интерфейсов (wlan0\_0 в нашем случае) автоматически, но для этого адрес первой точки доступа должен иметь несколько «пустых» битов в конце. Я не стал мелочиться и освободил сразу 4 штуки. Задача на дом – посчитайте, сколько максимум AP теперь можно запустить на одной карте.
#### Налетай – IP всем и каждому, бесплатно!
Всем компьютерам в сети, как это ни прискорбно, надо выдать IP-адреса. Да-да, этим мы и будем заниматься.
Недолго думая, на сервере был запущен DHCP-сервер следующей конфигурации:
```
update-static-leases on;
authoritative;
allow unknown-clients;
use-host-decl-names on;
log-facility local7;
subnet 192.168.1.0 netmask 255.255.255.0 {
interface br0;
authoritative;
range 192.168.1.2 192.168.1.254;
option subnet-mask 255.255.255.0;
option ntp-servers 192.168.1.1;
option domain-name-servers 192.168.1.1;
option netbios-name-servers 192.168.1.1;
option routers 192.168.1.1;
option domain-name "local";
}
subnet 192.168.254.0 netmask 255.255.255.0 {
interface wlan0_0;
authoritative;
range 192.168.254.2 192.168.254.254;
option subnet-mask 255.255.255.0;
option domain-name-servers 8.8.8.8, 8.8.4.4;
option routers 192.168.254.1;
}
local-address 192.168.1.1;
```
Видно, что для 192.168.1.1/24 так же выдаются DNS, WINS, NTP и шлюз 192.168.1.1 – самое время их настроить.
Со шлюзом всё просто, думаю, эти команды не знает только ленивый:
```
sysctl net.ipv4.ip_forward=1
iptables –t nat -A POSTROUTING -o ppp0 -j MASQUERADE
```
Разумеется, ставим iptables-persistent для сохранения наших настроек, а так же прописываем соответствующие параметры в /etc/sysctl.conf.
Теперь наш сервер является полноценным китайским роутером за 10$. Что? Вам кажется слабовато? Мне тоже. Едем дальше.
#### Как пройти в библиотеку?
Думаю, никто не забыл, что нам нужен DNS? Простейший forwarding настраивается до нелепости просто, но ведь мы делаем полноценный сервер с резолвингом и реверс-зонами… Ставим bind9, и настраиваем:
```
options {
directory "/var/cache/bind";
forwarders {
8.8.8.8;
8.8.4.4;
};
dnssec-validation auto;
auth-nxdomain no;
listen-on { 127.0.0.1; 192.168.1.1; };
allow-transfer { none; };
version none;
};
zone "local" IN {
type master;
file "/var/lib/bind/db.localnet";
};
zone "1.168.192.in-addr.arpa" IN {
type master;
file "/var/lib/bind/db.localnet-rev";
};
```
Теперь нам нужны файлы прямой и обратной зоны:
**/var/lib/bind/db.localnet**
```
$ORIGIN .
$TTL 86400 ; 1 day
local IN SOA ns.local. router.local. (
200216990 ; serial
28800 ; refresh (8 hours)
7200 ; retry (2 hours)
604800 ; expire (1 week)
86400 ; minimum (1 day)
)
NS ns.local.
$ORIGIN local.
$TTL 86400 ; 1 day
ns A 192.168.1.1
server A 192.168.1.1
router A 192.168.1.1
```
**/var/lib/bind/db.localnet-rev**
```
$ORIGIN .
$TTL 86400 ; 1 day
1.168.192.in-addr.arpa IN SOA ns.local. router.local. (
2001105214 ; serial
28800 ; refresh (8 hours)
14400 ; retry (4 hours)
3600000 ; expire (5 weeks 6 days 16 hours)
86400 ; minimum (1 day)
)
NS ns.local.
$ORIGIN 1.168.192.in-addr.arpa.
$TTL 3600 ; 1 hour
1 PTR router.local.
```
Просто? А теперь сделаем так, что бы каждый компьютер в сети можно было видеть не по IP, а по DNS-имени.
Для этого нам нужно настроить DDNS. Эта технология позволяет связать DHCP-сервер, выдающий адреса, и DNS-сервер.
Для начала создадим ключ для нашего DDNS:
```
dnssec-keygen -a HMAC-MD5 -b 128 -r /dev/urandom -n USER DDNS_UPDATE
```
Эта команда создаст нам 2 файлика с DDNS-ключом. Нам нужно содержимое ключа:
```
cat Kddns_update.+157+36693.key
DDNS_UPDATE. IN KEY 0 3 157 HEyb0FU9+aOXnYFQiXfiVA==
```
«HEyb0FU9+aOXnYFQiXfiVA==» и есть наш ключ.
Немного отредактируем наш конфиг DHCP, добавив в него следующие опции:
```
ddns-updates on;
ddns-update-style interim;
key rndc-key { algorithm HMAC-MD5; secret HEyb0FU9+aOXnYFQiXfiVA==; }
zone local. { primary 192.168.1.1; key rndc-key; }
zone 1.168.192.in-addr.arpa. { primary 192.168.1.1; key rndc-key; }
subnet 192.168.1.0 netmask 255.255.255.0 {
…
ddns-domainname "local.";
ddns-rev-domainname "in-addr.arpa.";
}
```
Так же поступим с DNS:
```
key "rndc-key" {
algorithm hmac-md5;
secret "HEyb0FU9+aOXnYFQiXfiVA==";
};
zone "local" IN {
…
allow-update { key rndc-key; };
};
zone "1.168.192.in-addr.arpa" IN {
…
allow-update { key rndc-key; };
};
```
Вуаля – и эта киллер-фича работает.
#### Будущее всё-таки здесь. Шестая версия
Так исторически сложилось ©, что мой провайдер (презрительный взгляд в сторону Ростелекома) не выдаёт IPv6 (хотя [обещал](http://www.comnews.ru/node/66310)).
> В настоящее время на всей протяженности сети «Ростелеком» обеспечил возможность работы по протоколу IPv6, — парирует пресс-служба оператора.
Что ж, пофиксим это недоразумение. В качестве брокера я выбрал [sixxs.net](http://sixxs.net) – у них есть туннельные серверы в России, и их туннель прост в настройке для случая с динамическим IP.
Процесс регистрации и получения настроек туннеля/подсети я опущу – там всё довольно просто. Остановлюсь на настройке.
Настройка IPv6 на самом сервере производится в 2 этапа. Во-первых, поставим пакет aiccu – это и есть туннелирующая программа. При установке у нас будет запрошен логин и пароль от sixxs, и некоторые другие данные. После запуска у нас появится новый интерфейс:
```
sixxs Link encap:IPv6-in-IPv4
inet6 addr: 2a02:578:5002:xxx::2/64 Scope:Global
UP POINTOPOINT RUNNING NOARP MTU:1280 Metric:1
…
```
Сервер теперь имеет доступ в v6-сеть – почему бы не поделиться ей с другими?
Для начала, разрешим IPv6-forwarding (не забудьте прописать в /etc/sysctl.conf):
```
sysctl net.ipv6.conf.all.forwarding=1
```
Настроек с iptables производить не надо – привет, 21 век!
Далее на сайте sixxs получаем подсеть. Её адрес будет очень похож на адрес нашего туннеля – будьте внимательны, они отличаются!
После получения адреса вида 2a02:578:5002:xxxx::/64, приступим к его настройке. Во-первых, зададим нашему серверу адрес 2a02:578:5002:xxxx::1, добавив в interfaces следующие строки:
```
iface br0 inet6 static
address 2a02:578:5002:xxxx::1
netmask 64
```
Во-вторых, разрешим выдачу IPv6 компьютерам в сети. Поставим пакет radvd, и настроим его следующим образом:
```
interface br0
{
AdvSendAdvert on;
prefix 2a02:578:5002:xxxx::/64
{
AdvOnLink on;
AdvAutonomous on;
AdvRouterAddr on;
};
RDNSS 2a02:578:5002:xxxx::1 { };
};
```
Добавим IPv6 DNS в настройки нашего bind – для полного фен-шуя:
```
options {
forwarders {
…
2001:4860:4860::8888;
2001:4860:4860::8844;
};
listen-on-v6 { ::1/128; 2a02:578:5002:xxxx::/64; };
…
};
```
Это всё – теперь мы имеем доступ, например, к [ipv6.google.com](http://ipv6.google.com), или, что гораздо ценнее – к [ipv6.nnm-club.me](http://ipv6.nnm-club.me) ;)
#### Пингвин, смотрящий в окно
Я люблю, когда у меня в сети всё красиво. А это возможно только в случае полной гармонии. Например, когда все компьютеры видят друг друга. Для рабочих станций Windows справедливо вспомнить про WINS (помните, мы даже выдавали эту настройку в DHCP).
Его настройка крайне проста: устанавливаем пакет samba. Конфиг по умолчанию надо немного изменить:
```
workgroup = WORKGROUP
wins support = yes
dns proxy = yes
interfaces = lo br0
bind interfaces only = yes
server role = standalone server
```
Проверяем результаты… О, да тут всё хорошо!
Кстати, так как у нас есть samba, можно сразу настроить файлопомойку. Но это уже настолько избитая тема, что я оставляю её на плечах гугла. По сути, всё и так должно работать из коробки – разве что read only для homes выключить да **smbpasswd -a user**…
#### Который час?
Настроим раздачу времени на сервере: установим ntp. С конфигами всё до нелепости просто:
```
server 0.ru.pool.ntp.org
server 1.ru.pool.ntp.org
server 2.ru.pool.ntp.org
server 3.ru.pool.ntp.org
…
broadcast 192.168.1.1
```
А вот и результат:
Мы уже вплотную приблизились к роутерам уровня microtik за $150-$200. Но это же не всё? Конечно нет.
#### Killer-feature #1: I2P
А почему бы не иметь доступа в эту сеть без каких-либо настроек, без прокси-серверов и так далее? Вот и я думаю, «почему». Для начала установим вменяемую версию Java:
```
echo "deb http://ppa.launchpad.net/webupd8team/java/ubuntu precise main" >> /etc/apt/sources.list
apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys EEA14886
apt-get update
apt-get install oracle-java7-installer
```
И установим сам роутер:
```
echo "deb http://deb.i2p2.no/ unstable main" >> /etc/apt/sources.list
wget "http://www.i2p2.de/_static/debian-repo.pub" -O- -q | apt-key add -
apt-get update
apt-get install i2p i2p-keyring
```
Теперь создадим зону, направляющую все запросы к \*.i2p на наш сервер. В конфиг bind:
```
zone "i2p" IN {
type master;
file "/etc/bind/db.i2p";
};
```
Сама зона:
```
$ORIGIN i2p
$TTL 7200
i2p. IN SOA ns.i2p. hostmaster.i2p. (
2010020701 ; serial
7200 ; refresh
1800 ; retry
7200 ; expire
7200 ; minimum
)
i2p. IN NS ns.i2p.
ns.i2p. IN A 192.168.1.1
*.i2p. IN A 192.168.1.1
*.i2p. IN AAAA 2a02:578:5002:xxxx::1
```
Отлично, но как теперь это обработать? Банально завернуть весь трафик на порт роутера у меня не получилось – прокси ругался на то, что не может так работать. Пришлось настраивать связку nginx+php5-fpm и писать небольшой скрипт. Как сделать первую часть – искать долго не надо, благо мануалов в сети полно. Вторая часть:
**/etc/nginx/sites-enabled/i2p**
```
server {
listen [2a02:578:5002:xxxx::1]:80;
listen 192.168.1.1:80;
# по этому адресу можно будет получить доступ к конфигам роутера
server_name localhost.i2p;
location / {
proxy_pass http://127.0.0.1:7657;
}
}
server {
listen [2a02:578:5002:xxxx::1]:80;
listen 192.168.1.1:80;
server_name *.i2p;
location / {
fastcgi_pass unix:/var/run/php5-fpm;
include fastcgi_params;
# принудительно задаём адрес скрипта
fastcgi_param SCRIPT_FILENAME /etc/nginx/proxy.php;
# передаём скрипту параметр с адресом HTTP proxy от i2p
fastcgi_param PROXY_PASS 127.0.0.1:4444;
}
}
```
Сам скрипт можно увидеть [тут](http://pastebin.com/v8fxgj6b).
Это всё! Теперь мы имеем доступ в i2p даже с телефона – никаких проблем.
#### Killer-feature #2: делаем рабочее место рабочей сетью
Так исторически сложилось ©, что я являюсь системным администратором по удалёнке сразу в нескольких фирмах. И очень полезно иметь к ним доступ с любого компьютера в сети. Настройку OpenVPN (или любого другого) для сервера осуществляем как для любого другого клиента. Например, после этих действий у нас появился интерфейс tap0 с IP 10.0.0.7/24. Но если мы обратимся из локальной сети по адресу 10.0.0.1, то трафик уйдёт в default gateway провайдера. Исправим этот недостаток:
```
iptables -t nat -A POSTROUTING -d 10.0.0.0/24 -o tap0 -j MASQUERADE
iptables-save > /etc/iptables/rules.v4
```
Аналогичным образом поступаем для всех сетей на сервере.
#### Вместо заключения
У нас есть полноценный сервер, который мы можем использовать по своему усмотрению. DNS, nginx, IPv6, i2p… Можно так же установить зону для локальной разработки, например, \*.dev, и тестировать свои сайты с любого устройства в локальной сети. Так как каждый компьютер в сети имеет свой постоянный IPv6-адрес, можно иметь к нему доступ из любой точки мира (Security warning! Настраивайте файрволы правильно!).
И это всё – лишь вершина айсберга. То, что будет его подводной частью – решать вам.
Буду рад услышать комментарии, предложения, здравую критику и прочее. Спасибо. | https://habr.com/ru/post/203376/ | null | ru | null |
# Вышел JQuery 1.9
Сегодня наконец был выпущен новый релиз JQuery версии 1.9. Давайте глянем какие нововведения и изменения мы тут увидим.
Jquery 1.9 и находящийся в бете Jquery 2.0 имеют схожий API.
Удалены некоторые устаревшие функции, такие как $.browser.
JQuery 1,9 пока еще работает на устаревших версиях Internet Explorer 6, 7 и 8. Но в версии JQuery 2.0 поддержка будет прекращена. Благодаря этому работать он будет быстрее и весить, соответственно, меньше.
Версия 1.9 уже доступна на CDN jquery и в ближайшем времени будет доступна на CDN Google и Microsoft
Для тех кто хочет проверить свои скрипты на JQuery 2.0 Beta 1 можно использовать JQuery CDN:
Для проверки вы можете подключить плагин jquery-migrate. Чтобы увидеть какие изменения могут вызвать проблемы с вашим кодом. Независимо от того какую версию Jquery вы используете, не забудьте открыть консоль, чтобы увидеть предупреждения или ошибки которые генерирует jquery-migrate. Предупреждения начинаются со слова «JQMIGRATE» и перечислены в документации плагина. Это поможет вам понять, что сломалось и как это можно исправить.
##### ЧТО НОВОГО В 1.9
**Упрощенный API:** многие устаревшие и сомнительные функции были удалены, как описано в обновлении руководства.
**Обновлена функция .css():** Теперь Вы можете получить все значения css, запросив массив с ключами:
`var dims = $("#box").css([ "width", "height", "backgroundColor" ]);
// { width: "10px", height: "20px", backgroundColor: "#D00DAD" }`
**Расширениная кросс-браузерная поддержка CSS3:** JQuery 1,9 теперь поддерживает следующие CSS3 селекторы во всех браузерах: :nth-last-child, :nth-of-type, :nth-last-of-type, :first-of-type, :last-of-type, :only-of-type, :target, :root, и :lang.
**Новый метод .finish:** Этот метод может быть использован, чтобы немедленно завершить все анимации в очереди на элемент.
##### Другие исправления
**AJAX**
# 12004: Добавлен метод ajax.method как псевдоним для ajax.type
# 12550: Исправлен JQuery Ajax cache=false не всегда работал
**ATTRIBUTES**
# 9905:. RemoveAttr («ID») теперь не даёт сбои в IE7
# 12048: [IE6/7/8] XML набор атрибутов
# 12584: JQuery неправильно сериализует с одной сломанной # 12600: jQuery(‘select’).is(‘[value=«value»]‘) работает непоследовательно в зависимости от числа возвращаемых элементов.
# 12945: Attr бросает исключение в IE9 на Flash object
# 13011: Установка атрибута type на входе не работает как положено
**BUILD**
# 12254: Reflected XSS
# 12725: Не локализованные UTF-8 символы в intro.js
# 12741: несовместимый конц строки в официальном JQuery-1.8.2.js
**CORE**
# 11737: Удалён jQuery.sub
# 12134. Реализации HTML5 compilant data form в $ fn.serialzeArray
# 12519: Public методы API не должны иметь privat аргументы
# 12840: Удалён (privat) параметр «pass» в jQuery.attr и jQuery.access
# 13021: each() не может хорошо работать с большими объектами
# 13075. Оптимизация производительности $.type
# 13076: Оптимизация производительности (10-30%) для $(“some-selector”)
**CSS**
# 11938: jQuery.css должны принять массив, чтобы получить несколько свойств
# 12990: «px» автоматически добавляется в колонке количество в CSS
# 13088. Под IE8, $(selector).attr(‘style’) всегда возвращает строку
##### Ссылки
[Официальный сайт](http://jquery.com)
[Весь список изменений](http://blog.jquery.com/2013/01/15/jquery-1-9-final-jquery-2-0-beta-migrate-final-released/)
[Руководство по миграции](http://jquery.com/upgrade-guide/1.9/) | https://habr.com/ru/post/165987/ | null | ru | null |
# Сетевое обращение к библиотекам и рантайм-формирование вызовов функций
Хочу поделиться историей из профессиональной деятельности, которую можно заслуженно поместить в блог с именем **crazydev** :) Это рассказ о необычных решениях (тех, что я попытался описать в двух словах в заголовке), к которым меня вынудили прийти еще более необычные ограничения и требования.
*И вот как-то так, через хитро закрученную \*\*\*у, оно и работает ©*
#### Постановка проблемы
Несколько лет назад работали над системой, предназначенной для [платформы наших доблестных ВС](http://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%B1%D0%B8%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D0%92%D0%BE%D0%BE%D1%80%D1%83%D0%B6%D1%91%D0%BD%D0%BD%D1%8B%D1%85_%D0%A1%D0%B8%D0%BB). Существенная часть работы протекала в портировании (с windows) уже имеющегося софта. И тут оказывается: важный компонент системы (назовем его [библиотекой сепуления](http://ru.wikipedia.org/wiki/%D0%A1%D0%B5%D0%BF%D1%83%D0%BB%D1%8C%D0%BA%D0%B8)), предоставленный партнером, попросту не имеет версии под linux, и его разработчик в общем-то не спешит с портом, т.к. нет таких договоренностей. Ругаться со своим начальством, допустившим этот промах при планированний работ бессмысленно — если в итоге сепулькарии будут стоять, то это незакрытый ТЗ, и виноваты в первую очередь будем мы, как исполнители.
#### Поиск решений
*Вначале здесь была стена текста о перебираемых вариантах решений, которые включали в себя и портирование исходников своими силами, и использований виртуальной машины с [Реактивной Осью](http://www.reactos.org/) (дабы не задействовать проприетарный софт **вероятного противника**), и включение в локальную сеть системника в форм-факторе Mini-ITX с той же ReactOS на борту. И напряженный поиск более-менее стабильной версии wine (системные библиотеки довольно старые, а обновлять нельзя — грозит **потерей сертификации** ОС).*
На варианте эмуляции с помощью Wine (который, как вы знаете, вовсе не эмулятор) мы и остановились. Оставалось продумать, как сепулькарии запускаемые внутри процесса серверного софта будут получать доступ к алгоритмам сепуления, вынуждено находящимся под юрисдикцией wine-процесса. Тут мне приходит в голову идея — организовать *сетевой транслятор обращения к библиотекам*.
#### Транслятор
В общем виде это выглядит так:
(кстати, похоже, получается одна из вариаций модели «Программа как услуга» ([Soft as a service](http://en.wikipedia.org/wiki/Software_as_a_service)), но это уже тема другого рассказа)
Что мне кажется интересным в такой схеме, так это то, что клиенты могут работать как в разных инстанциях выбранной библиотеки, так и *в одной и той же*.
Для реализации есть два пути:
1) Обучить транслятор работе с набором необходимых сейчас библиотек и и потом в случае пополнения этого набора каждый раз дописывать его код (или подключать через адаптеры, не суть важно), обеспечивая сопряжение с каждой новой библиотекой.
2) Обеспечить универсальность транслятора, сделав его по-настоящему просто *транслятором* запросов, перекладывая функцию формирования нужных запросов к новым библиотекам на клиентскую часть.
Очевидно, если бы я пошел по первому пути, писать в **crazydev** мне было бы нечего :)
#### Универсальность повсюду
Простой пример подключения библиотеки и вызова из неё функции.
```
typedef double (*myfunc_type)(long, long);
...
void *mylib;
myfunc_type myfunc;
double res;
...
mylib = dlopen("mylib.dll", RTLD_LAZY);
myfunc = dlsym(mylib, "my_func_name");
res = (*myfunc)(2, 4);
```
Как мы видим, для того чтобы обратиться к какой либо функции, мы должны предварительно описать её тип:
`typedef double (*myfunc_type)(long, long);`
А что делать когда типы функций, к которым мы будем обращаться, **неизвестны на этапе разработки**?
Всё правильно, нам приходит на помощь старый добрый ассемблер. Что, по сути, вызов функции? Помещение аргументов в стек, передача управления адресу, дальше получение результата, и, в зависимости от соглашения вызова, очистка стека.
Вот кусок кода (на Delphi), как раз выполнявший в моем трансляторе подобные операции (Внес дополнительные комментарии чтобы исключить непонятные моменты):
```
//Метод осуществляет непосредственный вызов функции,
//которую обслуживает объект класса TDLL_Function
//Возвращает байтовый массив, содержащий результат функции (если он предусмотрен)
function TDLL_Function.Execute(): TByteAr;
var
i: Integer; //Итератор для цикла
len : Integer; //Длина байтового массива со значениями параметров
B1 : Byte; //Буфер для однобайтового параметра
B2 : Word; //Буфер для двубайтового параметра
B4 : Cardinal; //Буфер для 4-байтового параметра
B8 : Double; // Буфер для 8-байтового параметра
StackPos : Integer; //Переменная для хранения позиции стека
begin
//ParamBytes это поле класса, байтовый массив содержащий все значения параметров,
//которые должны быть переданы в функцию
len:=Length(ParamBytes);
asm //Запоминаем начальное значение стека (из регистра esp)
mov StackPos, esp
end;
//ParamType это поле класса, массив значений следующего перечисляемого типа:
//TParamType = (ptOne=1, ptTwo=2, ptFour=4, ptEight=8, ptVoid=0, ptPointer=-1);
//Содержит типы параметров, которые должны быть переданы в функцию
//Перебираем массив с конца, т.к. помещать параметры в стек нужно в обратном порядке
for i := Length(ParamType)-1 downto 0 do
begin
case ParamType[i] of //В зависимости от типа текущего элемента
ptOne:begin
dec(len,1);
//Извлекаем из ParamBytes нужное число байт (с конца), кладем в буфер
Move(ParamBytes[len],B1,1);
asm //Буфер в регистр, а оттуда в стек
MOVSX EAX,B1
PUSH EAX
end;
end;
ptTwo:begin //Тоже самое для двух байт
dec(len,2);
Move(ParamBytes[len],B2,2);
asm
MOVSX EAX,B2
PUSH EAX
end;
end;
ptFour:begin //Тоже самое для четырех байт
dec(len,4);
Move(ParamBytes[len],B4,4);
asm
MOV EAX,B4
PUSH EAX
end;
end;
//Для указателей пока тоже самое что для четырех байт, но ведь поддержка
//64-битных систем (8 байт на указатель) есть в перспективе
ptPointer:begin
dec(len,4);
Move(ParamBytes[len],B4,4);
asm
MOV EAX,B4
PUSH EAX
end;
end;
ptEight:begin
dec(len,8);
Move(ParamBytes[len],B8,8);
asm //Немного другой вид инструкций для помещения восьми байт
PUSH DWORD PTR [B8]+$04
PUSH DWORD PTR B8
end;
end;
ptVoid: begin
end;
end;
end;
//Теперь B4 используется как буфер для чтения результата
case fCallingConv of //Дальше в зависимости от типа соглашения вызова
ccStdcall:
begin
TStdCall(Proc)(); //Proc - указатель на функцию библиотеки
asm //Считали результат из регистра
MOV B4,EAX
end;
end;
ccCdecl:begin
TCdeclCall(Proc)();
//В случае с Cdecl вызовом мы еще и возвращаем стек в начальное положение
asm
MOV B4,EAX
mov esp, StackPos;
end;
end;
end;
//Если результат не предусмотрен, то мы считали мусор
case ResultType of //В зависимости от типа результата
ptOne:begin //Помещаем в массив Result нужное нам число байт из B4
SetLength(Result,1);
Move(Byte(B4),Result[0],1);
end;
ptTwo:begin
SetLength(Result,2);
Move(Word(B4),Result[0],2);
end;
ptFour:begin
SetLength(Result,4);
Move(B4,Result[0],4);
end;
ptPointer:begin
SetLength(Result,4);
Move(B4,Result[0],4);
end;
ptEight:begin //Отдельный случай для восьми байт, используем B8 в роли буфера
asm
FSTP B8
end;
SetLength(Result,8);
Move(B8,Result[0],8);
end;
ptVoid:begin
SetLength(Result,0);
end;
end;
end;
```
*Прошу не бить ногами за код, он определенно требует оптимизации.*
Про особенности реализации:
1) Доступными сделал только stdcall и cdecl соглашения
2) Нет никаких гарантий в том, что ассемблерные вставки будут так же работать на архитектурах, отличных от тех, под которые это делалось.
1) Нет поддержки 64-битного кода, хотя в целом, кое-какие пути для обеспечения я закладывал
2) Если в функцию передается указатель, например, на массив, то клиент должен был переправить массив целиком, чтобы транслятор развернул его у себя и отправил в функцию указатель на него. Если этот массив нужно было вернуть обратно, то подобным образом организовывалось и его возвращение.
Вообще протокол для общения клиента и транслятора получился достаточно сложным и запутанным, и не знаю, имеет ли смысл его описывать. Скажу только, что он был [бинарный](http://habrahabr.ru/blogs/programming/138533/) :)
Общая последовательность действий для вызова выглядела так:
1) Клиент подключается к транслятору
2) Клиент отправляет имя библиотеки, к которой хочет подключиться
3) Клиент отправляет описание функции библиотеки, которую хочет вызвать
4) Клиент пакует и отправляет параметры для вызова функции библиотеки
5) Транслятор разворачивает параметры в соответствии с полученным описанием функции
6) Транслятор вызывает вышеупомянутый Execute()
7) Транслятор пакует нужные итоги работы (согласно описанию функцию) и отправляет их клиенту.
Вот такой **crazydev** :) В защиту своей поделки скажу, что в таком виде она безотказно проработала год, и, воспользовавшись этой универсальностью, удалось сократить время на портирование и некоторых других библиотек. А через год, во время планового обновления, уже поспела портированная версия сепулических библиотек, и всё закончилось хорошо.
**UPD.** Добавил тег «костыли», чтобы не было непоняток с самоидентификацией описанных решений. | https://habr.com/ru/post/138633/ | null | ru | null |
# Крадущийся в тени или поиски того света
> Assembler – мой любимый язык, … но жизнь так коротка.
Продолжаю цикл изысканий по вопросу подходящих теней для некоторого рогалика. После публикаций [раз](https://habr.com/ru/post/430438/) и [два](https://habr.com/ru/post/431304/) несколько поостыл к данной теме, но эффект незавершенного действия побуждает меня возвращаться к маранию пикселей, и завершить [гештальт](https://ru.wikipedia.org/wiki/%D0%93%D0%B5%D1%88%D1%82%D0%B0%D0%BB%D1%8C%D1%82-%D1%82%D0%B5%D1%80%D0%B0%D0%BF%D0%B8%D1%8F).
Зная себя, я уверен, что игра едва получит своё воплощение, но возможно кого-то из общественности заинтересуют мои наработки на этом тернистом пути. И так приступим.
Уже в конце прошлого цикла подходил к пониманию, что расчёт графики на CPU это уже прошлый век, но природное упрямство твердило: ещё не все возможности использованы, есть ещё варианты интересных решений.
Не воплощённой оставалась обратная трассировка лучей. Точнее её разновидность, где для каждого пикселя изображения (блока пикселей) пробрасывается луч и определяется уровень освещения текущей точки. Сам алгоритм описан в прошлой статье и возвращаться к нему нет смысла. Для обратной трассировки лучей код был ещё более упрощен, убрана полностью вся тригонометрия, что в перспективе могло дать приемлемый результат.
**Pascal**
```
const tile_size = 32; // размер тайла
tile_size1 : single = 0.03125; // 1/32 - обратный размер тайла
block_size = 4; // Ширина/высота блока в пикселях
Size_X:Byte = 32; // Количесво тайлов по X
Size_Y:Byte = 24; // Количесво тайлов по Y
//---------------------------------
function is_no_empty(x,y:Integer):Integer;
begin
if (x>=0) AND (x=0) AND (y0 then
inc(transp\_key);
if (xi=i0) and (yj=j0) then
begin
crossing := min(255,transp\_key\*64+ l \* r\_view);
exit;
end;
dx0 := (temp\_x-x)/l+0.0000001;
dy0 := (temp\_y-y)/l+0.0000001;
key := False;
last\_k :=0;
// Инициализация направления
if dx0<0 then
begin di :=-1; ddi:= 0; end
else
begin di := 1; ddi:= 1; end;
if dy0<0 then
begin dj :=-1; ddj:= 0; end
else
begin dj := 1; ddj:= 1; end;
sum\_lenX := 0;
sum\_lenY := 0;
sec1 := 1/dx0;
cosec1 := 1/dy0;
// Длина начального плеча по Х и Y
temp\_x := x-(xi+ddi) \* tile\_size ;
temp\_y := y-(yj+ddj) \* tile\_size ;
Dx := sqrt(sqr(temp\_x) + sqr(temp\_x \* sec1 \* dy0));
DY := sqrt(sqr(temp\_y) + sqr(temp\_y \* cosec1 \* dx0));
// Длина плеча по Х и Y
Dx1 := abs(tile\_size \* sec1);
Dy1 := abs(tile\_size \* cosec1);
repeat
if sum\_lenX+DX < sum\_lenY+DY then
begin
xi += di;
k := is\_no\_empty(xi,yj);
sum\_lenX += DX;
if DX<>Dx1 then DX := Dx1;
end
else
begin
yj += dj;
k := is\_no\_empty(xi,yj);
sum\_lenY += DY;
if DY<>Dy1 then DY := Dy1;
end;
if key Then
begin
if (xi<>i2) Or (yj<>j2) then
begin
// стена (дальше не расчитываем)
if last\_k=1 then
begin
crossing := 255;
exit;
end;
// множество препятствий (дальше не расчитываем)
if transp\_key>2 then
begin
crossing := 255;
exit;
end;
inc(transp\_key);
key:= false;
end;
end;
if k>0 then
begin
i2:=xi;
j2:=yj;
key:=true;
last\_k:=k;
end;
// Обнаружили искомый тайл
if (xi=i0) and (yj=j0) then
begin
crossing := min(255, transp\_key\*64+ l \* r\_view);
exit;
end;
until k=-1; // Вышли за границу карты
end;
//---------------------------------
..................
x0:= mouse\_x;
y0:= mouse\_y;
// Деление выносим за функцию для оптимизиции
x1 := x0 div tile\_size;
y1 := y0 div tile\_size;
koef := tile\_size div block\_size;
// Для каджого пикселя вызываем трасировку (в данном случае для блока пикселей)
for j:=0 to Size\_Y \* koef do
for i:=0 to Size\_X \* koef do
picture\_mask.SetPixel(i, j, BGRA(0,0,0,crossing(x0, y0, x1, y1, i, j)));
..................
```
Увы, результат оказался много хуже ожиданий, стоило картинку развернуть на полный экран, FPS стремился к единицам.
Группировка пикселей в макроблоки для уменьшения расчётов и применение последующего сглаживания, ненамного, улучшали производительность. Эффект откровенно не нравился от слова совсем.
Алгоритм отлично параллелился, но задействовать множество потоков не имело смыла, эффект казался много хуже, чем в прошлой статье, даже при лучшем качестве картинки.
Это оказался тупик. Нужно было признать, CPU в расчёте графики в моих глазах себя исчерпал. Занавес.
**Отступление 1**За последние десяток лет практически отсутствует прогресс в развитии процессоров общего назначения. Если подходить со стороны пользователя, то максимальный замеченный прирост производительности составляет не более 30% на ядро. Прогресс, мягко говоря, незначительный. Если опустить расширение длины векторных инструкций, и некоторого ускорения конвейерных блоков, то это увеличение числа рабочих ядер. Безопасная работа с потоками, то ещё удовольствие, а далеко не все задачи можно успешно параллелить. Хотелось бы иметь рабочее ядро, пусть одно, но раз так в 5-10 быстрее, но как говориться, увы и ах.
Здесь на Хабре есть отличный цикл статей [«Жизнь в эпоху «тёмного» кремния»](https://habr.com/ru/company/intel/blog/158223/), который объясняет некоторые предпосылки к текущему состоянию дел, но и возвращает с небес на землю. В ближайшее десятилетие можно не ожидать сколько-нибудь значительного роста вычислений в расчёте на одно ядро. Зато можно ожидать дальнейшее развитие количества ядер GPU и их общее ускорение. Даже на моём стареньком ноутбуке ориентировочная суммарная производительность GPU в 20 раз выше чем одного потока CPU. Даже если эффективно загрузить все 4 ядра процессора, это много меньше чем хотелось бы.
Отдаю дань разработчикам графики прошлого, которые делали свои шедевры не имея аппаратных ускорителей, настоящие мастера.
Итак, разбираемся с GPU. Для меня оказалось несколько неожиданно, что в настоящей практике мало кто просто разбрасывается полигонами по форме. Все мало-мальски интересные вещи создаются с использованием [шейдеров](https://ru.wikipedia.org/wiki/%D0%A8%D0%B5%D0%B9%D0%B4%D0%B5%D1%80). Отбросив готовые 3D движки, попробовал изучить потроха технологии как они есть на глубинном уровне. Те же процессоры тот же ассемблер, только несколько урезанный набор команд и своя специфика работы. Для пробы остановился на [GLSL](https://ru.wikipedia.org/wiki/OpenGL_Shading_Language), С- подобный синтаксис, простота, множество обучающих уроков и примеров, в том числе и на хабре.
Поскольку я в основном привык писать на [Pascal](https://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D1%81%D0%BA%D0%B0%D0%BB%D1%8C_(%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)), встала задача как подключать OpenGL
к проекту. Мне удалось найти два способа подключения: библиотека [GLFW](https://ru.wikipedia.org/wiki/GLFW) и заголовочный файл [dglOpenGL](https://wiki.delphigl.com/index.php/dglOpenGL.pas/en). Единственное в первом я не смог подключить шейдеры, но видимо это от кривизны моих рук.
**Отступление 2**Многие знакомые спрашивают меня почему я пишу на Pascal? Очевидно, это вымирающий язык, его сообщество неуклонно падает, развития почти нет. Низкоуровневые системщики предпочитают С, а прикладники Java, Python, Ruby или что там сейчас на пике.
Для меня Pascal сродни первой любви. Два десятка лет назад ещё во времена [Turbo Pascal 5.5](https://ru.wikipedia.org/wiki/Turbo_Pascal), он запал мне в душу и с тех пор шагает со мной по жизни, будь это Delphi или в последние годы [Lazarus](https://ru.wikipedia.org/wiki/Lazarus). Мне нравится предсказуемость языка, относительная низкоуровневость (ассемблерные вставки и просмотр инструкция процессора), совместимость с С. Главное что код собирается и выполняется без проблем, а то что не модный, устарел, и нет некоторых фич, это ерунда. Поговаривают, есть люди, что всё ещё на [LISP](https://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D1%81%D0%BF) пишут, а ему вообще за пол века.
Итак, окунёмся в разработку. Для пробного шага не будем брать точные реалистичные модели затенения, а попробуем реализовать то что уже пробовали ранее, но уже с производительностью GPU, так сказать для наглядного сравнения.
Изначально думал получить тень примерно такой формы, для объекта используя треугольники.
Для создания эффекта гладкой окружности нужна масса полигонов. Но что, если использовать треугольники по минимуму, использовав пиксельный шейдер для создания отверстия в фигуре. Идея ко мне пришла после прочтения [статьи](https://habr.com/ru/post/253791/) уважаемого мастера, в которой открылась возможность создавать сферы шейдером.
Если продлить треугольник за границы экрана, то в итоге получается такое:
Границы тени получились очень жёсткими и к тому же ступенчатыми. Но есть способ как получить приемлемый результат не используя [суперсэмплинг](https://ru.wikipedia.org/wiki/%D0%98%D0%B7%D0%B1%D1%8B%D1%82%D0%BE%D1%87%D0%BD%D0%B0%D1%8F_%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%D0%BA%D0%B0_%D1%81%D0%B3%D0%BB%D0%B0%D0%B6%D0%B8%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F), это использование сглаженных границ. Для этого немного изменим схему. Углы полигонов в местах пересечения касательной к окружности сделаем прозрачными.
Результат, лучше, но всё ещё выглядит неестественно.
Добавим небольшое сглаживание окружности для придания мягкости, а также изменим вид градиента с линейного на степенной.
Вполне приемлемый результат.
И в итоге добавим на форму объекты имитирующие препятствия.
**Код шейдера**`// Вершинный шейдер
#version 330 core
layout (location = 0) in vec2 aVertexPosition;
void main(void) {
gl_Position = vec4(aVertexPosition.xy, 0, 1.0);
}
// Шейдер геометрии
#version 330 core
layout (points) in;
layout (triangle_strip, max_vertices = 5) out;
uniform mat4 uModelViewMatrix;
uniform float uRadius;
uniform vec2 uHeroPoint;
out float fTransparency;
out vec2 vCenter;
void main(){
vCenter = gl_in[0].gl_Position.xy;
vec2 d = uHeroPoint - vCenter;
float l = length(d);
float i = uRadius / l;
float ii = i*i;
float ij = i * sqrt(1 - ii);
vec2 p1 = vec2(vCenter.x + d.x*ii - d.y*ij , vCenter.y + d.x*ij + d.y*ii);
vec2 p2 = vec2(vCenter.x + d.x*ii + d.y*ij , vCenter.y - d.x*ij + d.y*ii);
d = uHeroPoint - p1;
vec2 p3 = vec2(p1 - d/length(d)*1000000);
d = uHeroPoint - p2;
vec2 p4 = vec2(p2 - d/length(d)*1000000);
fTransparency = 0;
gl_Position = uModelViewMatrix * vec4(p1, 0, 1);
EmitVertex();
fTransparency = 1;
gl_Position = uModelViewMatrix * vec4(p3, 0, 1);
EmitVertex();
gl_Position = uModelViewMatrix * vec4(vCenter, 0, 1);
EmitVertex();
gl_Position = uModelViewMatrix * vec4(p4, 0, 1);
EmitVertex();
fTransparency = 0;
gl_Position = uModelViewMatrix * vec4(p2, 0, 1);
EmitVertex();
EndPrimitive();
}
// Фрагментный шейдер
#version 330 core
precision mediump float;
varying float fTransparency;
varying vec2 vCenter;
uniform float uRadius;
uniform vec2 uScreenHalfSize;
uniform float uShadowTransparency;
uniform float uShadowSmoothness;
out vec4 FragColor;
void main(){
float l = distance(vec2((gl_FragCoord.xy - uScreenHalfSize.xy)/uScreenHalfSize.y), vCenter.xy);
if (l
else {FragColor = vec4(0, 0, 0, min(pow(fTransparency, uShadowSmoothness), (l-uRadius)/uRadius*10)*uShadowTransparency);}
}`
Надеюсь было познавательно,
Ваш покорный слуга, терзатель пикселей, Rebuilder.
Прилагаю небольшое [демо](https://yadi.sk/d/FOuhpGDQ4opH7A). (EXE Виндовс)
P.S. Заголовок статьи содержит [пасхалку](https://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D1%81%D1%85%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D1%8F%D0%B9%D1%86%D0%BE_(%D0%B2%D0%B8%D1%80%D1%82%D1%83%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5)), отсылка к трилогии [Хроники Сиалы](https://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B0%D0%B4%D1%83%D1%89%D0%B8%D0%B9%D1%81%D1%8F_%D0%B2_%D1%82%D0%B5%D0%BD%D0%B8). Отличное произведение в стили фентези, о злоключениях роги, от Алексея Пехова. | https://habr.com/ru/post/446986/ | null | ru | null |
# Hibernate и битовые операции
Как оказалось Hibernate не приемлит битовых операций в условиях hql запроса. Например, «from Events where type & mask <> 0» генерирует исключение парсера, так же [битовых операций нет в документации](http://www.hibernate.org/hib_docs/v3/reference/en/html/queryhql-expressions.html). Однако не стоит отчаиваться.
* Во-первых, сравнение с маской можно заменить, пойдя математическим путём. `field & mask != 0` эквивалентно `(field / mask) % 2 = 1`
* Во-вторых, реализовать свою [SQL функцию и зарегистрировать её в диалекте.](http://javabeans.asia/2008/05/06/bitwise_operation_in_hibernate_3.html)
> `public class BitwiseAndFunction extends StandardSQLFunction
>
> implements SQLFunction {
>
>
>
> public BitwiseAndFunction(String name) {
>
> super(name);
>
> }
>
>
>
> public BitwiseAndFunction(String name, Type type) {
>
> super(name, type);
>
> }
>
>
>
> public String render(List args, SessionFactoryImplementor factory)
>
> throws QueryException {
>
>
>
> if (args.size() != 2) {
>
> throw new IllegalArgumentException("the function must be passed 2 arguments");
>
> }
>
>
>
> StringBuffer buffer = new StringBuffer(args.get(0).toString());
>
> buffer.append(" & ").append(args.get(1));
>
> return buffer.toString();
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Далле необходимо создать диалект, пронаследовав от текущего:
> `public class MySQLDialectFixed extends MySQL5Dialect {
>
>
>
> public MySQLDialectFixed() {
>
> super();
>
> registerFunction("bitwise\_and", new BitwiseAndFunction("bitwise\_and", Hibernate.INTEGER));
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
К сожалению использовать `type & mask <> 0` всё равно не выйдет, только `bitwise_and(type, mask) <> 0`. Однако SQL запрос будет выглядеть как надо. | https://habr.com/ru/post/50260/ | null | ru | null |
# Освобождение ресурсов в GO
Go - это язык с автоматическим управлением памятью: сборщик мусора без участия программиста позаботится о том, чтобы освободить память, занимаемую объектами, более не используемыми программой. Но памятью вся автоматика в целом и ограничивается - об остальных используемых программой ресурсах нам по-прежнему нужно заботиться самостоятельно.
Источник изображения: http://kenimation.net/doctor-who%E2%80%AC-dalek/Единственное, что может предложить сборщик мусора для автоматизации этого процесса - это при сборке объекта вызвать его финализатор, установленный с помощью функции [runtime.SetFinalizer](https://golang.org/pkg/runtime/#SetFinalizer). Но этот механизм не гарантирует ни порядка вызова финализаторов, ни даже того, что финализатор вообще будет вызван. Это поведение не специфично для Go - подобным образом ведут себя все языки со сборкой мусора, поддерживающие финализацию, и, как следствие, полагаться на неё обычно не рекомендуется.
Явное же освобождение ресурсов без специальных средств может быть утомительным и, что хуже - подверженным ошибкам. Собственно говоря, [утечка памяти](https://en.wikipedia.org/wiki/Memory_leak), являющаяся одной из разновидностей [утечки ресурса](https://en.wikipedia.org/wiki/Resource_leak) - это одна из основных проблем, решаемых сборкой мусора. В коде типа
```
res1, err := NewResource1()
if err != nil {
return nil, err
}
res2, err := NewResource2(res1)
if err != nil {
res1.Close()
return nil, err
}
res3, err := NewResource3(res2)
if err != nil {
res2.Close()
res1.Close()
return nil, err
}
v, err := res3.DoSomething()
if err != nil {
res3.Close()
res2.Close()
res1.Close()
return nil, err
}
res3.Close()
res2.Close()
res1.Close()
return v, nil
```
очевидно слишком много мест, в которых можно допустить ошибку просто по невнимательности. И даже если ошибок допущено не будет, паника в любой из вызываемых функций сведёт все усилия на нет (в других языках аналогичную проблему создают исключения). А если функции Close ещё и возвращают ошибки, то дело становится совсем плохо - зачастую эти ошибки вообще [игнорируются](https://en.wikipedia.org/wiki/Error_hiding).
Разные языки предлагают разные инструменты для упрощения освобождения ресурсов. Например, C# и Java предлагают [using statement](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/using-statement) и [try-with-resources statement](https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html) соответственно. В Go же есть, как мне кажется, намного более гибкий [defer statement](https://blog.golang.org/defer-panic-and-recover). Код выше с его использованием становится на порядок удобнее и писать, и сопровождать:
```
res1, err := NewResource1()
if err != nil {
return nil, err
}
defer res1.Close()
res2, err := NewResource2(res1)
if err != nil {
return nil, err
}
defer res2.Close()
res3, err := NewResource3(res2)
if err != nil {
return nil, err
}
defer res3.Close()
return res3.DoSomething()
```
В этом коде уже есть *гарантия* вызова Close даже в случае паники. Хотя с обработкой ошибок Close дело по-прежнему обстоит плохо.
Казалось бы, этого достаточно практически в любой ситуации. Но есть одно но - defer работает в пределах одной функции. Вы не сможете использовать код выше, например, в конструкторе - при выходе из него все созданные ресурсы будут освобождены, хотя они всё ещё требуются для работы программы. Конечно, можно возразить, что лучше бы в такой ситуации использовать [внедрение зависимости](https://en.wikipedia.org/wiki/Dependency_injection). Однако, даже не считая того, что какие-то ресурсы всё ещё могут быть инкапсулированы, зависимости всё равно нужно где-то создать - а значит, мы должны либо объединить инициализацию с основной логикой в одной функции (увы, но нередко таковой является main), либо использовать [инверсию управления](https://en.wikipedia.org/wiki/Inversion_of_control), например, в форме колбэка, что в любом случае [связывает](https://en.wikipedia.org/wiki/Coupling_(computer_programming)) инициализацию и основную логику сильнее, чем того хотелось бы.
Наглядной демонстрацией описываемой проблемы является код, генерируемый [Wire](https://github.com/google/wire). Конструктор (провайдер в терминологии Wire) может вернуть т. н. [cleanup function](https://github.com/google/wire/blob/main/docs/guide.md#cleanup-functions), которая будет использована для освобождения созданного им ресурса. Но код сгенерированного конструктора будет похож на первый сниппет в этой статье и в случае паники процесс освобождения ресурсов сломается.
Dedicated finalization
----------------------
Тем не менее, cама по себе идея возврата cleanup function, предложенная Wire, на мой взгляд выглядит перспективной. Дело в том, что у *метода* Close (или аналогичного финализатора) есть сразу два недостатка:
* метод можно просто забыть вызвать;
* метод может быть по ошибке вызван зависимой от ресурса функцией.
Если же финализатор возвращается не как часть ресурса, а как отдельная связанная с ним сущность, то второй недостаток нивелируется автоматически, поскольку у зависимой функции просто нет интерфейса для ошибочного вызова. Первый же недостаток нивелируется благодаря тому, что неиспользование объявленной переменной в Go является ошибкой времени компиляции:
```
res, cleanup, err := NewResource()
if err != nil {
return err
}
// Если не вызвать cleanup, то программа просто не скомпилируется.
if err := res.DoSomething(); err != nil {
return err
}
```
Итак, использование трёх выходных параметров (ресурс, финализатор и ошибка) вместо обычных двух (ресурс и ошибка) в типовой сигнатуре конструктора выглядит хорошим решением. В качестве бонуса, оно позволяет ввести концепцию "владения ресурсом", при которой ресурс принадлежит той сущности, которой известен его финализатор, а все остальные "заимствуют" или "арендуют" этот ресурс, не взаимодействуя с интерфейсом управления его жизненным циклом.
Composite finalization
----------------------
Чтобы получить возможность использовать в конструкторе defer (вернее, максимально близкий к нему механизм), можно сделать следующее:
```
func Finalize(finalizers ...func()) {
// Вызываем финализаторы в обратном порядке.
for i := len(finalizers) - 1; i >= 0; i-- {
func() {
defer func() {
// Для примера проигнорируем панику так же, как любые ошибки финализации.
// В реальном коде нужно использовать любую реализацию multierror и:
// 1) возвращать ошибку из финализатора;
// 2) превращать панику в ошибки.
recover()
}()
finalizers[i]()
}()
}
}
func NewResource3() (*Resource3, func(), error) {
var (
finalizers []func() // Массив финализаторов внутренних ресурсов
successful bool // Флаг успешного создания ресурса
)
defer func() {
// Если флаг успешного создания ресурса не поднят,
// освобождаем все созданные в процессе внутренние ресурсы -
// работа конструктора завершилась ошибкой и больше некому.
if !successfull {
Finalize(finalizers...)
}
}()
res1, fin1, err := NewResource1()
if err != nil {
return nil, nil, err
}
finalizers = append(finalizers, fin1)
res2, fin2, err := NewResource2(res1)
if err != nil {
return nil, nil, err
}
finalizers = append(finalizers, fin2)
res3 := &Resource3{
resource2: res2,
}
fin3 := func() {
Finalize(finalizers...)
}
// Поднимаем флаг успешного создания ресурса и возвращаем результат.
// С этого момента внутренние ресурсы будут освобождены только
// при вызове финализатора внешним кодом.
successful = true
return res3, fin3, nil
}
```
Функция Finalize и типовая часть конструктора - отличные кандидаты для выноса в библиотеку и последующего переиспользования.
Помимо возможности использовать привычный шаблон new - error - defer предложенный подход, при некоторой доработке, также предоставляет механизм для удобной обработки ошибок финализации, которые нередко игнорируются даже в примерах из официальной документации, поскольку их обработка оказывается весьма запутанной.
KDone в качестве заключения
---------------------------
Я опубликовал библиотеку [KDone](https://github.com/go-kata/kdone), предоставляющую описанный выше набор инструментов. Она является частью проекта [Kata](https://github.com/go-kata), о котором в следующий раз. Можно считать, что в данный момент её API стабилен и если и будет изменяться, то незначительно - тем не менее, библиотека пока свежая и я всё ещё использую нулевую мажорную версию на случай непредвиденных изменений.
Типичный конструктор с использованием этой библиотеки выглядит так:
```
func NewResource(...) (res Resource, dtor kdone.Destructor, err error) {
defer kerror.Catch(&err) // Превращаем панику в ошибку
// с помощью KError.
// Можно опустить этот обработчик.
reaper := kdone.NewReaper() // Создаём reaper.
defer reaper.MustFinalize() // Финализируем внутренние ресурсы
// в случае ошибки.
// ... reaper.MustAssume(dtor) ... // Возлагаем на reaper ответственность
// за вызов деструктора внутреннего
// ресурса.
return res, reaper.MustRelease(), nil // Освобождаем reaper от ответственности
// за вызов деструкторов и передаём её
// вышестоящему коду.
}
```
Что думаете? Концепция достаточно простая, но возможно я всё же что-то упустил в своих рассуждениях? Или у вас есть предложения улучшений? Буду рад дискуссиям в комментариях. | https://habr.com/ru/post/539386/ | null | ru | null |
# Как статический анализ кода помогает в сфере GameDev
Игровая индустрия не стоит на месте и с каждым днём развивается всё быстрее и быстрее. Вместе с ростом индустрии растёт и сложность разработки: кода становится больше и багов в нём тоже становится больше. Поэтому современные игровые проекты нуждаются в особом внимании к качеству кода. Сегодня мы расскажем об одном из способов сделать ваш код лучше – статическом анализе, а также о том, как PVS-Studio на практике помогает в разработке крупных (и не только) игровых проектов.
"*The most important thing I have done as a programmer in recent years is to aggressively pursue static code analysis. Even more valuable than the hundreds of serious bugs I have prevented with it is the change in mindset about the way I view software reliability and code quality.*" – [Джон Кармак](https://www.gamasutra.com/view/news/128836/InDepth_Static_Code_Analysis.php)
Мы работаем с крупными игровыми разработчиками уже много лет и за это время успели сделать много интересного и полезного для игровой индустрии. Это совсем не удивительно, учитывая [список наших клиентов](https://viva64.com/ru/customers/) из игровой индустрии. Мы ведём активную поддержку наших клиентов: помогаем им интегрировать PVS-Studio в их собственный процесс разработки, исправляем найденные анализатором ошибки и даже делаем специальные фичи на заказ.
Помимо этого, мы много занимаемся и самостоятельным развитием анализатора в GameDev-направлении, а также популяризируем PVS-Studio, рассказывая людям об интересных ошибках, которые он нашел в различных видеоиграх.
Естественно, не обошлось и без интересных историй. О нескольких таких историях и пойдёт речь в этой статье.
PVS-Studio и Unity
------------------
Одним из способов, с помощью которых мы продвигаем наш продукт, является написание статей о проверке открытых проектов. От этих статей получают пользу все: читатель может посмотреть на интересные ошибки в знакомом проекте и узнать для себя что-то новое, мы получаем возможность показать работу PVS-Studio на реальном коде, а разработчики проектов могут узнать об ошибках и заблаговременно их исправить.
Наше первое серьезное знакомство с Unity началось в 2016 году, когда разработчики этого игрового движка выложили в свой официальный репозиторий исходный код нескольких компонентов, библиотек и демок. Естественно, что мимо такого "вкусного" случая мы пройти не смогли и захотели написать статью о проверке выложенного кода.
Тогда мы обнаружили, что код Unity3D (в то время движок назывался именно так) имеет весьма высокое качество, однако и в нём нам удалось найти достаточно много серьёзных ошибок для написания [статьи](https://www.viva64.com/ru/b/0423/).
Спустя два года случилось еще одно событие – на этот раз разработчики Unity выложили в открытый доступ код самого движка и редактора. И так же, как и в предыдущий раз, мы не смогли пройти мимо и проверили исходный код движка. И не зря: интересных ошибок мы так же нашли целую [горсть](https://www.viva64.com/ru/b/0568/).
Однако написание статей – это далеко не всё. Мы продолжаем работать над PVS-Studio, и GameDev является для нас одним из важнейших направлений для развития. Поэтому мы хотим, чтобы разработчики игр на Unity могли получить как можно более качественный анализ своих проектов.
Одним из шагов по улучшению качества анализа Unity-проектов для нас стало написание аннотаций для методов, определённых в Unity Scripting API.
Аннотации методов – это особый механизм, использующийся в PVS-Studio. Он позволяет предоставить анализатору всю необходимую информацию о каком-нибудь конкретном методе. Она прописывается в специальном коде самими разработчиками анализатора (то есть, нами же).
Эта информация может быть совершенно различного рода. Например: как метод может повлиять на переданные ему параметры, может ли он выделить память и возвращает ли он значение, которое обязательно нужно обработать. Таким образом, аннотирование позволяет анализатору лучше понимать логику работы методов, тем самым позволяя обнаруживать новые и более сложные ошибки.
Нами уже написано огромное множество различных аннотаций (например, для методов из пространства имён System), и мы были рады пополнить их аннотациями методов из Unity Scripting API.
Мы начали пополнение списка аннотаций с оценки. Сколько всего существует методов? Какие именно стоит проаннотировать первыми? Всего методов оказалось очень много, и мы решили для начала проаннотировать наиболее часто используемые методы.
Поиск популярных методов производился следующим образом: сначала мы собрали пул проектов с GitHub, использующих возможности Unity, после чего с помощью самописной утилиты (основанной на Roslyn) подсчитали вызовы интересующих нас методов. В итоге мы получили список классов, методы которых используются наиболее часто:
* UnityEngine.Vector3
* UnityEngine.Mathf
* UnityEngine.Debug
* UnityEngine.GameObject
* UnityEngine.Material
* UnityEditor.EditorGUILayout
* UnityEngine.Component
* UnityEngine.Object
* UnityEngine.GUILayout
* UnityEngine.Quaternion
* ...
Далее осталось проаннотировать методы этих классов. Мы создали тестовый проект и "закопались" в документацию, чтобы получить как можно больше информации об этих методах. Например, мы пробовали передавать *null* в качестве различных аргументов, чтобы посмотреть, как поведёт себя программа.
Во время таких проверок периодически обнаруживалась интересная незадокументированная информация – и мы даже нашли парочку интересных багов в движке. Так, при запуске подобного кода:
```
MeshRenderer renderer = cube.GetComponent();
Material m = renderer.material;
List outNames = null;
m.GetTexturePropertyNameIDs(outNames);
```
крашится непосредственно сам редактор Unity (по крайней мере, в версии 2019.3.10f1). Вряд ли, конечно, кто-то станет писать подобный код, но интересен сам факт того, что редактор Unity можно "повалить" запуском подобного скрипта.
Итак, аннотации написаны. После запуска анализа мы сразу обнаружили новые срабатывания. Например, анализатор обнаружил странный вызов метода *GetComponent*:
```
void OnEnable()
{
GameObject uiManager = GameObject.Find("UIRoot");
if (uiManager)
{
uiManager.GetComponent();
}
}
```
**Предупреждение анализатора:** [V3010](https://www.viva64.com/ru/w/v3010/) The return value of function 'GetComponent' is required to be utilized. — ADDITIONAL IN CURRENT UIEditorWindow.cs 22
Метод *[GetComponent](https://docs.unity3d.com/ScriptReference/GameObject.GetComponent.html)* даже своим названием подразумевает возвращение определённого значения. Логично предположить, что это самое значение должно быть как-то использовано. Теперь (благодаря новой аннотации) анализатор знает, что подобный "бесхозный" вызов этого метода может свидетельствовать о логической ошибке, и предупреждает вас об этом.
Это далеко не единственное срабатывание, появившееся в наборе наших тестовых проектов после добавления новых аннотаций – я не буду приводить остальные, чтобы не делать эту статью слишком большой. Главное, что теперь разработка Unity-проектов с использованием PVS-Studio позволяет писать гораздо более безопасный и чистый код без багов.
Если вам хочется подробнее прочитать про нашу работу с аннотациями для Unity-методов, вы можете сделать это в нашей статье: [Как анализатор PVS-Studio стал находить ещё больше ошибок в проектах на Unity](https://www.viva64.com/ru/b/0744/).
Unreal Engine 4
---------------
Когда в далёком 2014-м году разработчики Unreal Engine 4 выложили исходный код движка в открытый доступ, мы просто не смогли обойти этот проект стороной и также написали о нём [статью](https://www.viva64.com/ru/b/0249/). Разработчикам движка понравилась статья и они исправили найденные нами ошибки. Но нам было этого мало, и мы решили попробовать продать компании Epic Games лицензию на наш анализатор.
Компания Epic Games была заинтересована в улучшении своего движка с помощью PVS-Studio, поэтому мы сошлись на соглашении: мы своими силами исправляем код Unreal Engine так, чтобы анализатор не выдавал на него ни одного предупреждения, а ребята из Epic Games покупают нашу лицензию и дополнительно вознаграждают нас за проделанную работу.
Зачем было нужно исправлять все предупреждения? Дело в том, что максимальную пользу от статического анализа можно получить, исправляя ошибки *в момент их появления*. А когда вы впервые проверяете свой проект, то, как правило, вы получаете несколько сотен (а иногда и тысяч) предупреждений. Среди всех этих срабатываний анализатора легко могут затеряться предупреждения, выданные на свеженаписанный код.
На первый взгляд эта проблема решается достаточно легко: нужно всего лишь сесть и полноценно обойти весь отчёт, постепенно исправляя ошибки. Однако этот способ хоть и более интуитивен, он может потребовать времени. Куда более удобным и быстрым является метод использования suppress-файлов.
Suppress-файлы – это [специальная функция PVS-Studio](https://www.viva64.com/ru/m/0032/), позволяющая "спрятать" срабатывания анализатора в специальный файл. При этом спрятанные предупреждения не будут появляться в последующих логах: их можно будет посмотреть отдельно.
Получив большое количество срабатываний после первой проверки, вы можете в пару кликов добавить все обнаруженные срабатывания в suppress-файл, и тогда при следующей проверке анализатором вы получите чистый лог без единого срабатывания.
Теперь, когда старые предупреждения больше не попадают в лог, вы сможете легко обнаружить новое предупреждение сразу в момент его появления. Написали код –> проверили анализатором –> увидели новое предупреждение –> исправили ошибку. Именно так вы получите максимальную пользу от использования анализатора.
При этом не стоит забывать про срабатывания, которые находятся в suppress-файле: в них всё так же, как и раньше, могут находиться предупреждения о серьёзных ошибках и уязвимостях. Поэтому стоит периодически возвращаться к этим предупреждениям и уменьшать их количество.
Этот сценарий, конечно, удобен, но разработчики из Epic Games хотели, чтобы их код был исправлен сразу, и передали это дело нам.
И мы приступили к работе. Проверив код проекта, мы обнаружили 1821 одно предупреждение уровней Level\_1 и Level\_2. Разбор такого объёма предупреждений требует серьезной работы, и, чтобы облегчить весь этот процесс, мы настроили непрерывный анализ кода на нашем CI-сервере.
Выглядело это так: каждую ночь на нашем сервере собиралась актуальная версия Unreal Engine 4, и сразу после сборки автоматически запускался анализ. Таким образом, когда наши ребята приходили утром на работу, у них всегда был на руках свежий отчёт анализатора, позволяющий отследить прогресс по исправлению предупреждений. Плюс такая система позволяла в любой момент проверить стабильность сборки, запустив её на сервере вручную.
Весь процесс занял у нас 17 рабочих дней. График исправления предупреждений получился следующий:
На самом деле, этот график не полностью отражает нашу работу. После того, как мы исправили все предупреждения, мы еще в течение двух дней ждали, когда они примут наши последние пулл-реквесты. Все это время у нас продолжала работать автоматическая проверка последней версии Unreal Engine, который, в свою очередь, продолжал пополняться новым кодом. И что бы вы думали? За эти два дня PVS-Studio обнаружил в коде еще целых четыре ошибки! Одна из них была особенно серьезной и потенциально могла привести к неопределённому поведению.
Конечно, и эти ошибки мы тоже исправили. Теперь разработчикам Unreal Engine осталось только одно: настроить у себя автоматический анализ так же, как это сделали мы. С этого момента они стали каждый день видеть предупреждения, которые были выданы на только что написанный код. Это позволило им исправлять ошибки в коде еще в момент их появления – *на самых ранних этапах разработки*.
Подробнее о том, как мы работали над кодом Unreal Engine, вы можете прочитать [в официальном блоге](https://www.unrealengine.com/en-US/blog/how-pvs-studio-team-improved-unreal-engines-code) Unreal Engine или [на нашем сайте](https://www.viva64.com/ru/b/0330/).
Анализ различных игр
--------------------
Я уже говорил, что мы проверяем различные открытые проекты и пишем о них статьи? Так вот, подобных статей про игровые проекты у нас накопилась просто целая уйма! Мы писали про такие игры, как [VVVVVV](https://www.viva64.com/ru/b/0707/), [Space Engineers](https://www.viva64.com/ru/b/0376/), [Command & Conquer](https://www.viva64.com/ru/b/0741/), [osu!](https://www.viva64.com/ru/b/0704/) и даже (очень древняя статья) [Doom 3](https://www.viva64.com/ru/b/0120/). А еще мы составили [топ 10](https://www.viva64.com/ru/b/0570/) самых интересных программных ошибок из видеоигровой индустрии.
Мы также проверили, пожалуй, большинство известных движков с открытым исходным кодом. Помимо Unity и Unreal Engine 4, под наш прицел попали такие проекты, как [Godot](https://www.viva64.com/ru/b/0321/), [Bullet](https://www.viva64.com/ru/b/0647/), [Amazon Lumberyard](https://www.viva64.com/ru/b/0574/), [Cry Engine V](https://www.viva64.com/ru/b/0495/) и многие другие.
Самое приятное из всего этого – это то, что многие из описанных нами багов впоследствии были исправлены самими разработчиками проектов. Приятно чувствовать, что инструмент, который ты разрабатываешь, приносит миру настоящую, видимую и ощутимую пользу.
Вы можете посмотреть список всех наших статей, так или иначе связанных с разработкой видеоигр на специальной [странице](https://www.viva64.com/ru/tags/?q=GameDev) нашего блога.
Заключение
----------
На этом моя небольшая статья подходит к концу. Желаю вам чистого и корректно работающего кода без багов и ошибок!
Заинтересовала тема статического анализа? Хочется проверить свой проект на наличие ошибок? Попробуйте [PVS-Studio](https://www.viva64.com/ru/pvs-studio-download/).
[](https://viva64.com/ru/pvs-studio-download/?utm_source=habr&utm_medium=banner&utm_campaign=0778_GameDev)
[](https://www.viva64.com/en/b/0778/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: George Gribkov. [How static code analysis helps in the GameDev industry](https://www.viva64.com/en/b/0778/). | https://habr.com/ru/post/530536/ | null | ru | null |
# Парсим X12 «на коленке»
При создании приложения, активно взаимодействующего со сторонними сервисами и системами, часто требуется обеспечить обмен информацией с ними, односторонний или двусторонний
При этом зачастую сторонний сервис предоставляет единственный формат и структуры данных для такого взаимодействия.
Одним из таких форматов электронного документооборота является [EDI ANSI ASC X12](http://citforum.ru/consulting/docflow/edi/), достаточно подробное описание которого приведено по ссылке.
КДПВ была взята с [этого сайта](https://boldvan.com/blog/x12-protocol/)
Под катом приведен простой алгоритм парсера X12 и код на Clojure, реализующий парсер и пример обработки распарсенных данных.
### Немного про формат
Цитируя вышеприведенную ссылку:
> Стандарт электронного обмена документами ANSI ASC X12 (American National Standards Institute Accredited Standards Committee X12) был разработан в 70-х годах, когда был важен малый размер электронного документа (для модемов со скоростями 300-1200 бит в секунду) и каждый байт должен был нести максимум информации. Таким образом, от «читаемости» электронного документа отказались в пользу «плотности информации».
Поэтому вы не увидите в нем никаких человекочитаемых красот, как в XML. И хотя стандарт позволяет создавать документы достаточно сложной иерархической структуры, с наличием блоков и так называемых loop-ов, тем не менее даже закрывающие теги для всех блоков (кроме ISA/GS/ST) не предусмотрены. По ссылке до ката желающие могут в деталях ознакомиться со структурой и описанием формата, далее мы будем касаться только необходимых вещей.
Каждый тип документа имеет свою структуру шаблона, в котором указывается смысл и назначение отдельных полей и сегментов, их типы и возможные значения, а также перечень обязательных и опциональных сегментов и блоков. Поддерживается версионирование шаблонов, информация о типе и номере версии передается в соответствующих полях документа. Предполагается, что именно с использованием шаблона конкретного типа документа должен производиться его разбор и валидация.
Ниже представлен пример документа, содержащего несколько транзакций типа 835 (документ типа claim response), на котором будет продемонстрирован парсинг и последующая обработка данных.
**Пример X12**
```
ISA*00* *00* *ZZ*EMEDNYBAT *ZZ*ETIN *140305*0929*^*00501*111111123*0*P*:~
GS*HP*EMED*ETIN*20140301*09304100*111111123*X*005010X221A1~
ST*835*35681~
BPR*I*810.8*C*CHK************20140331~
TRN*1*12345*1512345678~
REF*EV*XYZ CLEARINGHOUSE~
N1*PR*DENTAL OF ABC~
N3*225 MAIN STREET~
N4*CENTERVILLE*PA*17111~
PER*BL*JANE DOE*TE*9005555555~
N1*PE*BAN DDS LLC*FI*999994703~
LX*1~
CLP*7722337*1*226*132**12*119932404007801~
NM1*QC*1*DOE*SANDY****MI*SJD11112~
NM1*82*1*BAN*ERIN****XX*1811901945~
AMT*AU*132~
SVC*AD:D0120*46*25~
DTM*472*20140324~
CAS*CO*131*21~
AMT*B6*25~
SVC*AD:D0220*25*14~
DTM*472*20140324~
CAS*CO*131*11~
AMT*B6*14~
SVC*AD:D0230*22*10~
DTM*472*20140324~
CAS*CO*131*12~
AMT*B6*10~
SVC*AD:D0274*60*34~
DTM*472*20140324~
CAS*CO*131*26~
AMT*B6*34~
SVC*AD:D1110*73*49~
DTM*472*20140324~
CAS*CO*131*24~
AMT*B6*49~
LX*2~
CLP*7722337*1*119*74**12*119932404007801~
NM1*QC*1*DOE*SALLY****MI*SJD11111~
NM1*IL*1*DOE*JOHN****MI*123456~
NM1*82*1*BAN*ERIN****XX*1811901945~
AMT*AU*74~
SVC*AD:D0120*46*25~
DTM*472*20140324~
CAS*CO*131*21~
AMT*B6*25~
SVC*AD:D1110*73*49~
DTM*472*20140324~
CAS*CO*131*24~
AMT*B6*49~
LX*3~
CLP*7722337*1*226*108*24*12*119932404007801~
NM1*QC*1*SMITH*SALLY****MI*SJD11113~
NM1*82*1*BAN*ERIN****XX*1811901945~
AMT*AU*132~
SVC*AD:D0120*46*25~
DTM*472*20140324~
CAS*CO*131*21~
AMT*B6*25~
SVC*AD:D0220*25*0~
DTM*472*20140324~
CAS*PR*3*14~
CAS*CO*131*11~
AMT*B6*14~
SVC*AD:D0230*22*0~
DTM*472*20140324~
CAS*PR*3*10~
CAS*CO*131*12~
AMT*B6*10~
SVC*AD:D0274*60*34~
DTM*472*20140324~
CAS*CO*131*26~
AMT*B6*34~
SVC*AD:D1110*73*49~
DTM*472*20140324~
CAS*CO*131*24~
AMT*B6*49~
LX*4~
CLP*7722337*1*1145*14*902*12*119932404007801~
NM1*QC*1*SMITH*SAM****MI*SJD11116~
NM1*82*1*BAN*ERIN****XX*1811901945~
AMT*AU*14~
SVC*AD:D0220*25*14~
DTM*472*20140324~
CAS*CO*131*11~
AMT*B6*14~
SVC*AD:D2790*940*0~
DTM*472*20140324~
CAS*PR*3*756~
CAS*CO*131*184~
SVC*AD:D2950*180*0~
DTM*472*20140324~
CAS*PR*3*146~
CAS*CO*131*34~
LX*5~
CLP*7722337*1*348*16.8*44.2*12*119932404007801~
NM1*QC*1*JONES*SAM****MI*SJD11122~
NM1*82*1*BAN*ERIN****XX*1811901945~
AMT*AU*28~
SVC*AD:D4342*125*0~
DTM*472*20140313~
CAS*CO*131*125~
SVC*AD:D4381*43*0~
DTM*472*20140313~
CAS*PR*3*33~
CAS*CO*131*10~
SVC*AD:D2950*180*16.8~
DTM*472*20140313~
CAS*PR*3*11.2~
CAS*CO*131*152~
AMT*B6*28~
LX*6~
CLP*7722337*1*226*132**12*119932404007801~
NM1*QC*1*JONES*SALLY****MI*SJD11133~
NM1*82*1*BAN*ERIN****XX*1811901945~
AMT*AU*132~
SVC*AD:D0120*46*25~
DTM*472*20140321~
CAS*CO*131*21~
AMT*B6*25~
SVC*AD:D0220*25*14~
DTM*472*20140321~
CAS*CO*131*11~
AMT*B6*14~
SVC*AD:D0230*22*10~
DTM*472*20140321~
CAS*CO*131*12~
AMT*B6*10~
SVC*AD:D0274*60*34~
DTM*472*20140321~
CAS*CO*131*26~
AMT*B6*34~
SVC*AD:D1110*73*49~
DTM*472*20140321~
CAS*CO*131*24~
AMT*B6*49~
LX*7~
CLP*7722337*1*179*108**12*119932404007801~
NM1*QC*1*DOE*SAM****MI*SJD99999~
NM1*82*1*BAN*ERIN****XX*1811901945~
AMT*AU*108~
SVC*AD:D0120*46*25~
DTM*472*20140324~
CAS*CO*131*21~
AMT*B6*25~
SVC*AD:D0274*60*34~
DTM*472*20140324~
CAS*CO*131*26~
AMT*B6*34~
SVC*AD:D1110*73*49~
DTM*472*20140324~
CAS*CO*131*24~
AMT*B6*49~
LX*8~
CLP*7722337*1*129*82**12*119932404007801~
NM1*QC*1*DOE*SUE****MI*SJD88888~
NM1*82*1*BAN*ERIN****XX*1811901945~
AMT*AU*82~
SVC*AD:D0120*46*25~
DTM*472*20140324~
CAS*CO*131*21~
AMT*B6*25~
SVC*AD:D1120*54*37~
DTM*472*20140324~
CAS*CO*131*17~
AMT*B6*37~
SVC*AD:D1208*29*20~
DTM*472*20140324~
CAS*CO*131*9~
AMT*B6*20~
LX*9~
CLP*7722337*1*221*144**12*119932404007801~
NM1*QC*1*DOE*DONNA****MI*SJD77777~
NM1*82*1*BAN*ERIN****XX*1811901945~
AMT*AU*144~
SVC*AD:D0120*46*25~
DTM*472*20140324~
CAS*CO*131*21~
AMT*B6*25~
SVC*AD:D0330*92*62~
DTM*472*20140324~
CAS*CO*131*30~
AMT*B6*62~
SVC*AD:D1120*54*37~
DTM*472*20140324~
CAS*CO*131*17~
AMT*B6*37~
SVC*AD:D1208*29*20~
DTM*472*20140324~
CAS*CO*131*9~
AMT*B6*20~
SE*190*35681~
GE*1*111111123~
IEA*1*111111123~
```
Детальное описание назначения каждого блока и сегмента можно узнать при анализе общей структуры 12 и структуры шаблона данного типа документа. Но базовая концепция общая для всех типов — содержимое посылки состоит из сегментов, разделенных символом **~** (в тексте примера каждый сегмент выведен с новой строки, для удобочитаемости). В свою очередь, каждый сегмент может содержать произвольное число полей, разделенных символом **\***.
Такие соглашения позволяют нам легко получить линейную структуру документа как списка сегментов с перечнем их полей. Однако, это недостаточно для восстановления иерархической структуры блоков документа. Для этого, как я уже упоминал, предполагается использовать схему, которая для большинства типов документов представляет собой достаточно объемный файл. Но, поскольку мы не будем рассматривать задачу валидации документа, а ограничимся только парсингом, то для наших целей вполне подойдет следующий алгоритм — для каждого сегмента, встретившегося при последовательном разборе линейного списка сегментов документа, нам необходимо получить ответ на единственный вопрос: формирует ли данный сегмент новый вложенный блок, является ли окончанием текущего блока (и одновременно началом следующего), или же (в остальных случаях) является внутренним сегментом текущего блока.
### Парсер
Ниже продемонстрирован код на Clojure, осуществляющий парсинг линейной структуры сегментов в иерархическую структуру блоков. Для задания структуры иерархии используется декларативный подход — простейшая структура данных loops, в которой для перечисленных сегментов отдельно задаются перечни сегментов, образующих вложенные блоки, и заканчивающих текущий блок. Разумеется, эта структура зависит от типа документа, она, собственно, и задает его иерархию. Но приведенная ниже функция парсинга является универсальной, и будет работать на любых корректно заданных таким образом шаблонах структур, конечно при условии соответствия типа разбираемого документа выбранному шаблону.
```
;; Parse 835 x12 string to hierarchical structure
(def loops
{"835" {:nested #{"ISA"}}
"ISA" {:nested #{"GS"}}
"GS" {:nested #{"ST"} :end #{"IEA"}}
"ST" {:nested #{"N1" "LX"} :end #{"GE" "ST"}}
"N1" {:end #{"SE" "LX" "N1"}}
"LX" {:nested #{"CLP"} :end #{"SE" "LX"}}
"CLP" {:nested #{"SVC"} :end #{"SE" "LX" "CLP"}}
"SVC" {:end #{"SE" "LX" "CLP" "SVC"}}})
(defn parser-core [id ss acc]
(let [seg-id (first (first ss))
{:keys [nested end]} (loops id)]
(if (or (empty? ss) (and (contains? end seg-id) (not (empty? acc))))
[acc ss]
(let [[v ss-] (if (contains? nested seg-id)
(parser-core seg-id ss [])
[(first ss) (rest ss)])]
(recur id ss- (conj acc v))))))
(defn segments [s] (str/split (str/trim s) #"~"))
(defn elements [s] (str/split (str/trim s) #"\*"))
(defn x12 [s] (first (parser-core "835" (mapv elements (segments (or s ""))) [])))
```
Под спойлером представлен
**Результат парсинга**
```
[[["ISA"
"00"
" "
"00"
" "
"ZZ"
"EMEDNYBAT "
"ZZ"
"ETIN "
"140305"
"0929"
"^"
"00501"
"111111123"
"0"
"P"
":"]
[["GS" "HP" "EMED" "ETIN" "20140301" "09304100" "111111123" "X" "005010X221A1"]
[["ST" "835" "35681"]
["BPR" "I" "810.8" "C" "CHK" "" "" "" "" "" "" "" "" "" "" "" "20140331"]
["TRN" "1" "12345" "1512345678"]
["REF" "EV" "XYZ CLEARINGHOUSE"]
[["N1" "PR" "DENTAL OF ABC"]
["N3" "225 MAIN STREET"]
["N4" "CENTERVILLE" "PA" "17111"]
["PER" "BL" "JANE DOE" "TE" "9005555555"]]
[["N1" "PE" "BAN DDS LLC" "FI" "999994703"]]
[["LX" "1"]
[["CLP" "7722337" "1" "226" "132" "" "12" "119932404007801"]
["NM1" "QC" "1" "DOE" "SANDY" "" "" "" "MI" "SJD11112"]
["NM1" "82" "1" "BAN" "ERIN" "" "" "" "XX" "1811901945"]
["AMT" "AU" "132"]
[["SVC" "AD:D0120" "46" "25"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "21"]
["AMT" "B6" "25"]]
[["SVC" "AD:D0220" "25" "14"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "11"]
["AMT" "B6" "14"]]
[["SVC" "AD:D0230" "22" "10"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "12"]
["AMT" "B6" "10"]]
[["SVC" "AD:D0274" "60" "34"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "26"]
["AMT" "B6" "34"]]
[["SVC" "AD:D1110" "73" "49"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "24"]
["AMT" "B6" "49"]]]]
[["LX" "2"]
[["CLP" "7722337" "1" "119" "74" "" "12" "119932404007801"]
["NM1" "QC" "1" "DOE" "SALLY" "" "" "" "MI" "SJD11111"]
["NM1" "IL" "1" "DOE" "JOHN" "" "" "" "MI" "123456"]
["NM1" "82" "1" "BAN" "ERIN" "" "" "" "XX" "1811901945"]
["AMT" "AU" "74"]
[["SVC" "AD:D0120" "46" "25"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "21"]
["AMT" "B6" "25"]]
[["SVC" "AD:D1110" "73" "49"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "24"]
["AMT" "B6" "49"]]]]
[["LX" "3"]
[["CLP" "7722337" "1" "226" "108" "24" "12" "119932404007801"]
["NM1" "QC" "1" "SMITH" "SALLY" "" "" "" "MI" "SJD11113"]
["NM1" "82" "1" "BAN" "ERIN" "" "" "" "XX" "1811901945"]
["AMT" "AU" "132"]
[["SVC" "AD:D0120" "46" "25"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "21"]
["AMT" "B6" "25"]]
[["SVC" "AD:D0220" "25" "0"]
["DTM" "472" "20140324"]
["CAS" "PR" "3" "14"]
["CAS" "CO" "131" "11"]
["AMT" "B6" "14"]]
[["SVC" "AD:D0230" "22" "0"]
["DTM" "472" "20140324"]
["CAS" "PR" "3" "10"]
["CAS" "CO" "131" "12"]
["AMT" "B6" "10"]]
[["SVC" "AD:D0274" "60" "34"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "26"]
["AMT" "B6" "34"]]
[["SVC" "AD:D1110" "73" "49"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "24"]
["AMT" "B6" "49"]]]]
[["LX" "4"]
[["CLP" "7722337" "1" "1145" "14" "902" "12" "119932404007801"]
["NM1" "QC" "1" "SMITH" "SAM" "" "" "" "MI" "SJD11116"]
["NM1" "82" "1" "BAN" "ERIN" "" "" "" "XX" "1811901945"]
["AMT" "AU" "14"]
[["SVC" "AD:D0220" "25" "14"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "11"]
["AMT" "B6" "14"]]
[["SVC" "AD:D2790" "940" "0"]
["DTM" "472" "20140324"]
["CAS" "PR" "3" "756"]
["CAS" "CO" "131" "184"]]
[["SVC" "AD:D2950" "180" "0"]
["DTM" "472" "20140324"]
["CAS" "PR" "3" "146"]
["CAS" "CO" "131" "34"]]]]
[["LX" "5"]
[["CLP" "7722337" "1" "348" "16.8" "44.2" "12" "119932404007801"]
["NM1" "QC" "1" "JONES" "SAM" "" "" "" "MI" "SJD11122"]
["NM1" "82" "1" "BAN" "ERIN" "" "" "" "XX" "1811901945"]
["AMT" "AU" "28"]
[["SVC" "AD:D4342" "125" "0"]
["DTM" "472" "20140313"]
["CAS" "CO" "131" "125"]]
[["SVC" "AD:D4381" "43" "0"]
["DTM" "472" "20140313"]
["CAS" "PR" "3" "33"]
["CAS" "CO" "131" "10"]]
[["SVC" "AD:D2950" "180" "16.8"]
["DTM" "472" "20140313"]
["CAS" "PR" "3" "11.2"]
["CAS" "CO" "131" "152"]
["AMT" "B6" "28"]]]]
[["LX" "6"]
[["CLP" "7722337" "1" "226" "132" "" "12" "119932404007801"]
["NM1" "QC" "1" "JONES" "SALLY" "" "" "" "MI" "SJD11133"]
["NM1" "82" "1" "BAN" "ERIN" "" "" "" "XX" "1811901945"]
["AMT" "AU" "132"]
[["SVC" "AD:D0120" "46" "25"]
["DTM" "472" "20140321"]
["CAS" "CO" "131" "21"]
["AMT" "B6" "25"]]
[["SVC" "AD:D0220" "25" "14"]
["DTM" "472" "20140321"]
["CAS" "CO" "131" "11"]
["AMT" "B6" "14"]]
[["SVC" "AD:D0230" "22" "10"]
["DTM" "472" "20140321"]
["CAS" "CO" "131" "12"]
["AMT" "B6" "10"]]
[["SVC" "AD:D0274" "60" "34"]
["DTM" "472" "20140321"]
["CAS" "CO" "131" "26"]
["AMT" "B6" "34"]]
[["SVC" "AD:D1110" "73" "49"]
["DTM" "472" "20140321"]
["CAS" "CO" "131" "24"]
["AMT" "B6" "49"]]]]
[["LX" "7"]
[["CLP" "7722337" "1" "179" "108" "" "12" "119932404007801"]
["NM1" "QC" "1" "DOE" "SAM" "" "" "" "MI" "SJD99999"]
["NM1" "82" "1" "BAN" "ERIN" "" "" "" "XX" "1811901945"]
["AMT" "AU" "108"]
[["SVC" "AD:D0120" "46" "25"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "21"]
["AMT" "B6" "25"]]
[["SVC" "AD:D0274" "60" "34"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "26"]
["AMT" "B6" "34"]]
[["SVC" "AD:D1110" "73" "49"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "24"]
["AMT" "B6" "49"]]]]
[["LX" "8"]
[["CLP" "7722337" "1" "129" "82" "" "12" "119932404007801"]
["NM1" "QC" "1" "DOE" "SUE" "" "" "" "MI" "SJD88888"]
["NM1" "82" "1" "BAN" "ERIN" "" "" "" "XX" "1811901945"]
["AMT" "AU" "82"]
[["SVC" "AD:D0120" "46" "25"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "21"]
["AMT" "B6" "25"]]
[["SVC" "AD:D1120" "54" "37"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "17"]
["AMT" "B6" "37"]]
[["SVC" "AD:D1208" "29" "20"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "9"]
["AMT" "B6" "20"]]]]
[["LX" "9"]
[["CLP" "7722337" "1" "221" "144" "" "12" "119932404007801"]
["NM1" "QC" "1" "DOE" "DONNA" "" "" "" "MI" "SJD77777"]
["NM1" "82" "1" "BAN" "ERIN" "" "" "" "XX" "1811901945"]
["AMT" "AU" "144"]
[["SVC" "AD:D0120" "46" "25"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "21"]
["AMT" "B6" "25"]]
[["SVC" "AD:D0330" "92" "62"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "30"]
["AMT" "B6" "62"]]
[["SVC" "AD:D1120" "54" "37"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "17"]
["AMT" "B6" "37"]]
[["SVC" "AD:D1208" "29" "20"]
["DTM" "472" "20140324"]
["CAS" "CO" "131" "9"]
["AMT" "B6" "20"]]]]
["SE" "190" "35681"]]
["GE" "1" "111111123"]]
["IEA" "1" "111111123"]]]
```
нашего исходного примера — иерархическая структура сегментов.
Собственно, на этом задачу уже можно считать решенной. Десяток строк Clojure-кода обеспечивают нам полнофункциональный парсер любых X12 документов в иерархическое AST. Но для полноты картины можно показать пример обхода данного AST для выполнения какой-нибудь полезной задачи — например, конструирования структур требуемого формата и записи этой информации в базу данных. Ниже представлен пример кода, который обходит распарсенную структуру, и создает на ее основе список объектов. Пара универсальных функций-хэлперов для удобного доступа к данным, как они представлены в AST, и обходчик дерева, формирующий объект с возможностью обращения при этом к исходным данным на любом уровне иерархии.
```
;; util helpers for extracting information
(defn v-prefix? [v p]
(and
(vector? v)
(= p (if (vector? p) (subvec v 0 (min (count v) (count p))) (get v 0)))))
(defn items [v p & path] (filter #(v-prefix? (get-in % (vec path)) p) v))
(defn item [v p & path] (first (apply items v p path)))
;; test function for extracting human-readable structure
(defn tst [x12-string]
(for [isa (items (x12 x12-string) "ISA" 0)
gs (items isa "GS" 0)
st (items gs "ST" 0)
lx (items st "LX" 0)
clp (items lx "CLP" 0)]
(let [bpr (item st "BPR")]
{:message {:received (get-in isa [0 9])
:created (get-in gs [0 4])}
:transaction {:check (get (item st "TRN") 2)
:payed (get bpr 16)
:total (read-string (get bpr 2))}
:insurer (get-in (item st ["N1" "PR"] 0) [0 2])
:organization (get-in (item st ["N1" "PE"] 0) [0 2])
:claim {:patient (if-let [x (item clp ["NM1" "QC"])]
(str (get x 3) " " (get x 4)))
:total (read-string (get-in clp [0 4]))}
:services (mapv
(fn [svc]
{:code (get-in svc [0 1])
:amount (read-string (get-in svc [0 3]))
:date (get (item svc ["DTM" "472"]) 2)})
(items clp "SVC" 0))})))
```
Под спойлером представлен
**Результат работы функции**
```
({:message {:received "140305", :created "20140301"},
:transaction {:check "12345", :payed "20140331", :total 810.8},
:insurer "DENTAL OF ABC",
:organization "BAN DDS LLC",
:claim {:patient "DOE SANDY", :total 132},
:services
[{:code "AD:D0120", :amount 25, :date "20140324"}
{:code "AD:D0220", :amount 14, :date "20140324"}
{:code "AD:D0230", :amount 10, :date "20140324"}
{:code "AD:D0274", :amount 34, :date "20140324"}
{:code "AD:D1110", :amount 49, :date "20140324"}]}
{:message {:received "140305", :created "20140301"},
:transaction {:check "12345", :payed "20140331", :total 810.8},
:insurer "DENTAL OF ABC",
:organization "BAN DDS LLC",
:claim {:patient "DOE SALLY", :total 74},
:services
[{:code "AD:D0120", :amount 25, :date "20140324"}
{:code "AD:D1110", :amount 49, :date "20140324"}]}
{:message {:received "140305", :created "20140301"},
:transaction {:check "12345", :payed "20140331", :total 810.8},
:insurer "DENTAL OF ABC",
:organization "BAN DDS LLC",
:claim {:patient "SMITH SALLY", :total 108},
:services
[{:code "AD:D0120", :amount 25, :date "20140324"}
{:code "AD:D0220", :amount 0, :date "20140324"}
{:code "AD:D0230", :amount 0, :date "20140324"}
{:code "AD:D0274", :amount 34, :date "20140324"}
{:code "AD:D1110", :amount 49, :date "20140324"}]}
{:message {:received "140305", :created "20140301"},
:transaction {:check "12345", :payed "20140331", :total 810.8},
:insurer "DENTAL OF ABC",
:organization "BAN DDS LLC",
:claim {:patient "SMITH SAM", :total 14},
:services
[{:code "AD:D0220", :amount 14, :date "20140324"}
{:code "AD:D2790", :amount 0, :date "20140324"}
{:code "AD:D2950", :amount 0, :date "20140324"}]}
{:message {:received "140305", :created "20140301"},
:transaction {:check "12345", :payed "20140331", :total 810.8},
:insurer "DENTAL OF ABC",
:organization "BAN DDS LLC",
:claim {:patient "JONES SAM", :total 16.8},
:services
[{:code "AD:D4342", :amount 0, :date "20140313"}
{:code "AD:D4381", :amount 0, :date "20140313"}
{:code "AD:D2950", :amount 16.8, :date "20140313"}]}
{:message {:received "140305", :created "20140301"},
:transaction {:check "12345", :payed "20140331", :total 810.8},
:insurer "DENTAL OF ABC",
:organization "BAN DDS LLC",
:claim {:patient "JONES SALLY", :total 132},
:services
[{:code "AD:D0120", :amount 25, :date "20140321"}
{:code "AD:D0220", :amount 14, :date "20140321"}
{:code "AD:D0230", :amount 10, :date "20140321"}
{:code "AD:D0274", :amount 34, :date "20140321"}
{:code "AD:D1110", :amount 49, :date "20140321"}]}
{:message {:received "140305", :created "20140301"},
:transaction {:check "12345", :payed "20140331", :total 810.8},
:insurer "DENTAL OF ABC",
:organization "BAN DDS LLC",
:claim {:patient "DOE SAM", :total 108},
:services
[{:code "AD:D0120", :amount 25, :date "20140324"}
{:code "AD:D0274", :amount 34, :date "20140324"}
{:code "AD:D1110", :amount 49, :date "20140324"}]}
{:message {:received "140305", :created "20140301"},
:transaction {:check "12345", :payed "20140331", :total 810.8},
:insurer "DENTAL OF ABC",
:organization "BAN DDS LLC",
:claim {:patient "DOE SUE", :total 82},
:services
[{:code "AD:D0120", :amount 25, :date "20140324"}
{:code "AD:D1120", :amount 37, :date "20140324"}
{:code "AD:D1208", :amount 20, :date "20140324"}]}
{:message {:received "140305", :created "20140301"},
:transaction {:check "12345", :payed "20140331", :total 810.8},
:insurer "DENTAL OF ABC",
:organization "BAN DDS LLC",
:claim {:patient "DOE DONNA", :total 144},
:services
[{:code "AD:D0120", :amount 25, :date "20140324"}
{:code "AD:D0330", :amount 62, :date "20140324"}
{:code "AD:D1120", :amount 37, :date "20140324"}
{:code "AD:D1208", :amount 20, :date "20140324"}]})
```
— можно ~~подавать к столу~~ писать в базу, визуализировать на UI или использовать как-либо еще
Подобный код и алгоритм парсинга X12 документов используется в моем рабочем проекте — разумеется, с кучей дополнительной функциональности. Примеры кода в статье — это минимальный рабочий прототип для демонстрации алгоритма и подхода. Сорри, что без абстрактных фабрик фабрик, комбинаторных парсеров, рекурсивных грамматик и прочих серьезных вещей — всего 3 десятка строк кода )
Желающие могут поиграться с данным парсером в любом онлайн-репле, поддерживающем Clojure — ideone/replit/etc. Из зависимостей требуется подключить только нэймспейс *clojure.string*, ну и возможно *clojure.pprint* для красивой печати результатов. Можно попробовать изменять код тестовой функции создания объекта, получать другие поля из распарсенной структуры и т.п. Примеры X12 документов типа 835 (claim response) можно найти в сети. | https://habr.com/ru/post/427107/ | null | ru | null |
# Конкурс Игр Interactive fiction Competition 2009
##### Об играх
В связи с проведением конкурса Interactve fiction Competition 2009 представляю интересный жанр компьютерных игр — текстовых приключений в традициях «Infocom». Эти игры отличаются от интерактивной литературы, тем что в своем большинстве не используют меню. То есть для определения что в данный момент необходимо делать игроку надо написать строкой на английском языке. При этом уровень английского — средний-выше среднего. В этом состоит второй эффект (первый отдохнуть) — поддержать на уровне свой английский.
##### Пример игры
Я сделал выделение там где игрок вводит текст.
Комментарий. Игрок находится в лаборатории. Среди других вещей он видит гардероб. Оказывается гардероб может использоваться как лифт. Поднимается в квартиру…
##### Поиграть
[Здесь](http://ifwiki.org/index.php?title=15th_Annual_Interactive_Fiction_Competition/Parchment) можно поиграть в игры прямо в баузере. Есть варианты на JavaScript и JavaApplet. Интересно решен вопрос сохранений на команду SAVE выдается следующее:
`>save
Your game has been saved to the URL. You may want to bookmark this page now; just reload it at any time to restore your game from this point.
Ok.
>_`
это значит что сохранятся реально можно.
##### Обзоры игр
<http://emshort.wordpress.com/2009/10/03/if-comp-reviews/>
<http://gamesjournal.wordpress.com/>
<http://minimumsafedistance.org/> | https://habr.com/ru/post/71536/ | null | ru | null |
# Популяционный алгоритм, основанный на поведении косяка рыб
В рамках данного сообщества неоднократно обсуждались генетические алгоритмы и их применение на практике. В этой статье я хотел бы поделиться относительно новым методом оптимизации функций, основанным на поведении косяка рыб в условиях поиска пищи.
#### Введение
С середины прошлого века велись исследования по симуляции биологических механизмов природы, в частности, связанные с процессом эволюции. Лишь только к 80-м годам начались практические испытания этих методов в связи с возникшей необходимостью в эффективных способах оптимизации n-арных функций, имеющих высокую вычислительную сложность, многоэкстремальность и т.д. Говоря о терминологии, стоит упомянуть, что данные алгоритмы относятся к классу стохастических поисковых. Во многих источниках также можно встретить такие определения, как поведенческий, интеллектуальный, метаэвристический или **популяционный**. Будем и мы последний термин использовать для классификации нашего алгоритма. Вообще говоря, данный алгоритм можно определить более точно, используя следующую схему.
Популяционные алгоритмы разделяются на следующие категории:
* Эволюционные алгоритмы, включая те самые генетические.
* **Алгоритмы, вдохновленные живой природой** (например, алгоритм оптимизации роем светлячков, кукушкин поиск и т.п.).
* Алгоритмы, вдохновленные неживой природой (например, алгоритм гравитационного поиска).
* Алгоритмы, основанные на поведении человеческого общества (например, алгоритм эволюции разума).
* Прочие алгоритмы.
Разобравшись с терминологией, перейдем непосредственно к изучению популяционного алгоритма оптимизации, основанного на поведении косяка рыб.
#### Разбор алгоритма
Данный алгоритм предложили в 2008 году Фило (B. Filho) и Нето (L. Neto).
Как и во всех популяционных алгоритмах, в качестве входных параметров задаются: функция приспособленности (функция, для которой необходимо найти экстремумы), область исследования этой функции и параметры работы алгоритма (о них чуть позже). В текущем алгоритме FSS (**F**ish **S**chool **S**earch) область поиска представляет собой аквариум, в котором плавают агенты (рыбы). Как известно, в условиях поиска пищи рыбы плавают косяком, поэтому в нашем случае конечной целью является смещение всех агентов в область экстремума функции. В общем случае схема работы алгоритма следующая:
1. Инициализация популяции (равномерное распределение рыб в аквариуме)
2. Миграция агентов к источнику пищи (аналогия: чем больший шаг агенты совершили в направлении области экстремума функции, тем больше еды они получили)
3. Завершение поиска
##### Нужно больше подробностей
Стадия «Миграция агентов» выполняется поитерационно, и в каждой из итераций выполняются операторы двух групп:
1. Операторы плавания, обеспечивающие миграцию агентов в пределах аквариума.
2. Операторы кормления, фиксирующие успех исследования тех или иных областей аквариума.
Настало время поговорить о параметрах, которые имеет аквариум, и его обитатели.
Итак, введем следующие переменные, характерные для всего аквариума в целом:
`populationSize` — размер популяции (количество рыб в косяке).
`iterationCount` — количество итераций в стадии «Миграция агентов»
`lowerBoundPoint, higherBoundPoint` — верхняя и нижняя границы поиска
`individStepStart, individStepFinal` — задает начальный и конечный радиус поиска пищи вокруг агентов
`weightScale` — максимальный вес агента.
Это как раз те самые параметры, которые вводит пользователь. С помощью них регулируется соотношение *точность/время работы* алгоритма.
Сами агенты характеризуются только двумя величинами:
`swimStatePos` — позиция агента в разных стадиях плавания
`weight` — текущий вес агента
*Безусловно, при программной реализации алгоритма таким количеством переменных явно не обойтись, но пока не будем усложнять себе жизнь*.
Осознавая то, что программистам важнее код, чем пустая болтовня, будем углубляться в алгоритм, используя следующий псевдокод:
```
initialize_randomly_all_fish;
while (stop_criterion is not met)
{
for (each_fish)
{
individual_movement;
evaluate_fitness_function;
}
feeding_operator;
for (each_fish)
instinctive_movement;
calculate_barycentre;
for (each_fish) do
{
volitive_movement;
evaluate_fitness_function;
}
update_individidual_step;
}
```
*Замечание: все нижеследующие пояснения работы алгоритма рассчитаны на то, что решается задача условной максимизации функции, однако это не должно вызывать сомнений по поводу неработоспособности данного метода при поиске минимальных значений функции.*
1. Итак, как уже было сказано, первым делом проводится инициализация всей популяции: случайный выбор позиции агента в пределах аквариума (`swimStatePos[0]`) и установка веса, равного половине от максимального (`weight=weightScale/2`) для всех рыб.
2. Далее начинается основной цикл алгоритма, который характеризует стадию «Миграция агентов к источнику пищи». В качестве критерия остановки в нашем случае используется величина «Количество итераций» (`iterationCount`).
3. Затем наступает индивидуальная стадия плавания агентов. Она характеризуется тем, что все рыбы в некоторой области вокруг себя (`individStep`) пытаются найти лучшее значение функции. 
Если им это удается, то этот шаг фиксируется. В противном случае
считаем, что этого перемещения не было.
4. Теперь необходимо закрепить успех в индивидуальной стадии плавания. Для этого используется характеристика «Вес». Она равняется изменению функции приспособленности для данного агента до и после индивидуальной стадии, нормированного максимальным изменением функции среди популяции: . Вообще говоря, это является отличительной особенностью данного алгоритма, так как нам не надо запоминать лучших агентов на предыдущих итерациях.
5. После этого рыбы совершают следующую стадию плавания — инстинктивно-коллективную. Для всего косяка рыб высчитывается величина «Общий шаг миграции»: .
Смысл ее следующий: на каждого агента влияет вся популяция в целом, при этом влияние отдельного агента пропорционально его успехам в индивидуальной стадии плавания. Затем вся популяция смещается на подсчитанную величину m:
6. Перед следующей операцией плавания необходимо выполнить промежуточные действия, а именно: подсчитать центр тяжести всего косяка: .
7. Мы, а точнее, рыбы, перешли к последней стадии плавания: коллективно-волевой. Здесь необходимо узнать, как изменился вес популяции по сравнению с предыдущей итерацией. Если он увеличился, значит популяция приблизилась к области максимума функции, поэтому необходимо сузить круг его поиска, тем самым проявляются *интенсификационные* свойства. И наоборот: если вес косяка уменьшился, значит агенты ищут максимум не в том месте, поэтому необходимо изменить направление траектории и проявить *диверсификационные* свойства.
Величина `collStep` в следующей формуле отвечает за шаг волевого смещения. Рекомендуется использовать значение, в 2 раза большее индивидуального шага поиска. Оператор `dist` высчитывает расстояние между двумя точками в евклидовом пространстве.
(*Величины, отвечающие за положение агентов, являются структурными типами n-мерной точки, для которых определены следующие операции: сложение/вычитание двух точек, сложение/вычитание точки и числа, умножение/деление точки и числа, а также операции сравнения точек. Чтобы избежать этой геометрической бессмыслицы, принято считать данные величины за векторные типы данных, доопределив некоторые операции*)
8. Последним оператором в итерации является линейное уменьшение шага индивидуального поиска для следующей итерации. На самом деле, это является уже модификацией стандартного алгоритма FSS для повышения эффективности поиска, которая выполняется по такой формуле: 
#### Реализация и тестирование
##### Реализация
Данный алгоритм лег в основу моей курсовой работы («Программа оптимизации, инспирированная поведением косяка рыб»), которая была представлена на защите 26 апреля. Возможно, кто-то заинтересуется, почему так рано сдавали курсовые. Не мудрствуя лукаво, скажу лишь, что это все часть плана по отчислению студентов с 1-го курса факультета БИ (отделение ПИ) НИУ ВШЭ, которые оказались в лапах учебной части, грозящей весь год 30%-ным отчислением (на обратной стороне монеты гордо красуется агитационный лозунг: «Мы примем всех, и если надо будет, оплатим места за свой счет»). В рамках регламента курсовых работ, реализация велась на языке C# 4.0, в качестве графической составляющей была выбрана библиотека OpenTK (представляет обертку OpenGL для .NET), заданные пользователем функции парсились с помощью библиотеки, [реализованной на хабре ранее](http://habrahabr.ru/post/50158/). К сожалению, исходники выложить не могу (код далеко не совершенен, сам много раз это осознавал), а вот саму программу предоставлю на всеобщее усмотрение (ссылки в конце статьи). А пока просто скриншотик главного окна:
##### Тестирование
Для популяционных алгоритмов тестирование представляет собой увлекательную вещь, потому что результат его работы в значительной степени зависит от входных параметров. В рамках этой статьи рассмотрим следующие 2 графика.
1. 
* Область поиска: от (-100;-100) до (100; 100)
* Количество итераций: 100
* Размер популяции: 50
* Начальный индивидуальный шаг: 10
* Конечный индивидуальный шаг: 0.1
* Максимальный вес рыбы: 50
Итак, к концу работы алгоритма максимальное значение функции равнялось 9,999978..., а среднее значение 9,999148… График изменения среднего значения выглядит следующим образом:
То есть уже на 15-й итерации косяк рыб находился в положительной полуплоскости по оси OY. А начиная с 48-й итерации среднее значение функции не опускалось ниже 9-ти. А вот и полная картина происходящего (вид с верхушки айсберга):
2. 
* Область поиска: от (-100;-100) до (100; 100)
* Количество итераций: 100
* Размер популяции: 50
* Начальный индивидуальный шаг: 10
* Конечный индивидуальный шаг: 0.1
* Максимальный вес рыбы: 50
К концу работы алгоритма максимальное значение функции равнялось 19,999996..., а среднее 19,9994… Динамика среднего значения такова:
Уже с 42 итерации среднее значение функции держалось на отметке не ниже 19-ти. Анимация того, как алгоритм справляется с многоэкстремальными функциями (для Habrastorage файл слишком велик, так что возможны проблемы с отображением картинки):
#### Источники
* Скачать программу можно [тут](https://docs.google.com/file/d/0B7dfKdiXkh9yeThNZFA4a19NYkk/edit?usp=sharing) (в комплект входят: программа для исследования функций от двух переменных с отчетами по функциям из данной статьи, консольная версия программы со встроенными функциями от N переменных, описание языка задания фитнесс-функций (по ГОСТу, между прочим))
* Пожалуй, единственная русскоязычная статья, в которой описан данный алгоритм: Карпенко А. П. «Популяционные алгоритмы глобальной поисковой оптимизации. Обзор новых и малоизвестных алгоритмов». [Скачать](http://is.ifmo.ru/works/2012/karpenko-population-algorithms.pdf).
* [Веб-сайт](http://www.fbln.pro.br/FSS/), целиком посвященный Fish School Search
* И [еще одна](http://cs.fit.edu/~rmenezes/Teaching/Entries/2011/8/22_OLD__CSE5801__Swarm_Intelligence_files/01930261.pdf) полезная статья на английском
* [Исходники](https://bitbucket.org/ankulikov/fishschoolsearch/src/master) консольной версии программы (можно форкать)
##### P.S.
Спасибо за прочтение статьи! С радостью отвечу на ваши вопросы в комментариях.
UPD: Добавил исходные коды. | https://habr.com/ru/post/178309/ | null | ru | null |
# Еще одна стажировка, или сказ про реверс IP-камеры
Вступление
----------
Итак, меня взяли на [стажировку](https://raccoonsecurity.ru/internship/). Стажировка рассчитана на 2–3 месяца неспешной работы по 20 часов в неделю.
Что обещали научить делать (забегая вперед – обещание выполнили):
* анализ открытых источников;
* анализ аппаратных интерфейсов устройства;
* схемотехнический анализ устройства;
* работу с программаторами;
* пайку;
* анализ технологических интерфейсов микроконтроллеров;
* анализ программного обеспечения (как статический, так и динамический);
* поиск недекларированных возможностей;
* разработку консольного приложения.
С отдельными пунктами я уже был знаком: кое-что было на занятиях в вузе, что-то попадалось на CTF, про другие я только слышал (например, пайка и прочие "железячные" штуки).
Теперь о задании. **Объектом исследования** была типичная IP-камера, которая умеет записывать видео на MicroSD и стримить через Интернет на мобильное приложение (настраивается тоже через приложение). Еще камера может *обнаруживать движение в кадре и отправлять владельцу фотографию происходящего*. **Целью исследования** было проведение анализа защищенности *модифицированной* камеры и разработка PoC, позволяющего отключить функционал обнаружения движения в кадре, находясь в одной локальной сети с устройством.
Стоит отметить, что функционал камеры, благодаря которому в результате удалось разработать PoC, изначально в ней отсутствовал и был добавлен в прошивку специально, чтобы было, что искать (возможно, какие-нибудь уязвимости можно было бы найти и в оригинальной прошивке, но сколько времени это заняло бы у неопытного исследователя?). Но протокол, на основе которого данный функционал реализован, реально существовал.
Этап 1
------
Этот этап скорее обзорный, нужно было:
* узнать возможности камеры;
* найти внешние аппаратные интерфейсы камеры и определить протоколы, которые используются камерой на данных интерфейсах;
* попробовать найти в открытых источниках прошивки для камеры или какую-либо информацию о них.
Интерфейсы у камеры следующие:
* слот для MicroSD. Карточка должна быть отформатирована в FAT32, иначе это с ней сделают принудительно при первой попытке использования. Записывается видео в своеобразном формате, подробнее чуть ниже под спойлером;
* Wi-Fi-модуль;
* MicroUSB-порт. Изначально возникли сомнения в том, что он способен передавать данные, в дальнейшем они подтвердились: от разъема к плате идут два провода – только питание.
Для передачи как видео на сервер, так и управляющих команд на камеру используется UDP. Wireshark не распарсил протоколы, скорее всего что-то самописное и/или шифрованное.
При запуске камера шлет информацию о себе широковещательно (сначала четыре пакета подряд, потом еще шесть с интервалом 5 секунд) на 6666-й UDP-порт. Структура пакета:
* 00 00 55 AA;
* 16 байт нулей;
* {"ip":"192.168.0.102","gwId":"bf2a13eff2a4a35f67bo4w","active":2,"ablilty":0,"encrypt":true,"productKey":"endfc4sm1iaczb4l","version":"3.2"};
* CRC32 от всех пунктов, приведенных выше;
* 00 00 AA 55.
Бесполезный бонус: как сохраняется видео на microSDПосле записи видео на флешке появляются такие файлы:
1. Для воспроизведения .avs можно использовать специальный плеер с официального сайта производителя.
2. session.log – в начале короткий заголовок из ASCII-символов, потом много нулей (ровно 16 Мбайт).
3. С photo.bin то же самое, только еще есть несколько неведомых байтов. Эти файлы фактически пустые, и у них нет времени создания и изменения. По ходу работы камеры они не меняются.
4. index00.bin, index01.bin:
* размер точно по 8 Мбайт (01 – предыдущая версия файла 00, при каждом запуске старый 01 заменяется);
* первые 112(=16\*7) байт заголовок, дальше блоки данных, описывающие avs-файлы:
* байт 0B на скрине – скорее всего что-то вроде указателя на следующий файл для записи;
* размер блока 452 байта. Судя по размеру, всего возможно 18 558 видеофайлов до конца этого индекса. Блоки данных состоят из 32 байт, разделяемых промежутками по 420 нулей:
− желтое – порядковый номер блока и часть имени avs-файла;
− фиолетовое – было одинаковым в нескольких блоках;
− красное и синее – unixtime начала и конца записи;
− зеленое – размер файла.
Все числа в little endian.
Запись в файл производится маленькими порциями с одновременным обновлением index файла. Файлы режутся по ~20 минут, скорее всего отсечка по размеру (по времени слишком "некрасивые" числа выходят).
При сканировании были найдены открытые TCP-порты:
* 21 (BusyBox ftpd, якобы D-Link DCS-932L IP-Cam camera);
* 23 (BusyBox telnetd);
* 6668 (?).
NetBIOS имя камеры – *dgiot*, что является отсылкой к китайскому производителю облачных сервисов для IoT-устройств ([сайт,](https://www.iotn2n.com/) [гитхаб](https://github.com/dgiot)). При попытке подключиться по telnet становится известным имя хоста – *anyka*, что является названием SoC для IP-камер, на базе которого, как потом выяснилось, устройство и сделано.
На загадочном турецком [сайте](https://support.halabtech.com/) была найдена прошивка – образ SquashFS (это внушало надежду, что в дальнейшем можно будет увидеть не просто прошивку, но какую-то Unix-систему). Анализировать не стал, т.к. в дальнейшем предполагалось извлечь прошивку из самого устройства.
Этап 2
------
На данном этапе я наконец-то вскрываю корпус и заглядываю внутрь устройства, чтобы на плате поискать ключевые компоненты, определить их взаимосвязи, найти те, что отвечают за обработку внешних интерфейсов (тех самых, что на предыдущем этапе искали). Еще я искал отладочные интерфейсы (UART, JTAG) и должен был найти компонент, содержащий основную прошивку.
На фотографиях ниже цифрами обозначены элементы, которые мне показались потенциально полезными.
Сторона АСторона БРеально полезными оказались два:
* А1 – ANYKA / AK3918EN080 / V200 / CASJ09K17 (SoC для IP-камер);
* Б4 – WINBOND / 25Q64JVSIQ / 1920 (флеш-память 8 Mбайт).
Зеленым обведен потенциальный отладочный интерфейс (характерные подписи контактов, см. спойлер "Сторона А").
Спасибо производителям, маркирующим свои творения, гуглу и зуму в камере телефона, т.к. мое вроде бы нормальное зрение не справлялось с распознаванием символов невооруженным глазом (микроскоп или хотя бы лупа очень пригодились бы).
К слову, найти документацию на конкретно этот SoC так и не удалось, но это не сильно помешало.
На этом этапе я задавал кучу вопросов из разряда "а что это за точки?", на которые руководитель стажировки терпеливо отвечал.
Те самые точкиВзаимодействие всех внешних интерфейсов происходит через ANYKA. Для понимания взаимосвязей компонентов бывает полезно изобразить их на функциональной схеме:
Тут я предположил, что прошивка находится во флеш-памяти.
Этап 3
------
На этом этапе нужно было попробовать добыть прошивку: прочитать программатором из флеш-памяти или разобраться с отладочными контактами и прочитать прошивку через них (в образовательных целях я попробовал оба варианта).
Этот этап выполнялся в лаборатории. С использованием программатора ChipProg-48 были успешно считаны все 8192 Кбайт памяти. Тут же я впервые взял в руки паяльник и попытался подпаяться к контактам UART. Что-то даже получилось.
Термоклей нужен для того, чтобы с трудом припаянные провода не оторвались от неосторожного движения.
Кстати, для новичков с дрожащими руками: закон Мерфи работает. Капля припоя, сорвавшаяся с жала, не могла найти другого места для падения, кроме как сразу на три ножки драйвера мотора, напрочь лишив камеру возможности поворачиваться по одной из осей. Так что будьте внимательнее с тем, где держите паяльник.
При подключении к UART возникает вопрос выбора скорости передачи данных (baudrate). Говорят, ее можно определить с помощью логического анализатора, но быстрее оказалось найти нужное значение методом перебора – 115200.
Об автоматизации перебораПоявлялась мысль автоматизировать процесс программного подбора скорости: простенький скрипт, который пытается получить и вывести в консоль пару сотен символов с serial-порта для всех возможных значений скорости, чтобы потом глазами найти адекватные строки. Для этого устройства идея, в принципе, рабочая, но с другими могут быть проблемы: нет никаких гарантий, что с serial будут прочитаны именно ASCII-строки и что глазами можно будет отличить их от мусора.
Подключившись по UART к уже включенной камере, получили в терминал кучу строк, похожих на логи приложения. Если сначала подключиться к интерфейсу, а потом уже включать устройство, то можно увидеть интересную строку: `Hit any key to stop autoboot:` и таймер на 3 секунды. Нажатие любой клавиши действительно прерывает автозагрузку, и в результате был получен доступ к оболочке U-Boot.
Как подсказали help и гугл, в оболочке U-Boot есть команда *md* – *memory display*, выводящая содержимое ОЗУ. Ее аргументами являются адрес и количество объектов (по умолчанию объект – это dword). Я попробовал найти место, чтобы туда загрузить 8 Мбайт из флеш-памяти, но получал постоянно один и тот же набор байтов при попытках прочитать что-либо:
Это меня отпугнуло, и я не стал дальше копать в данном направлении.
Наличие U-Boot и его переменные среды окончательно подтвердили теорию, что в устройстве есть ОС Linux (характерные параметры загрузки ядра – четвертая строка в выводе ниже).
Вывод env print (еще одна команда U-Boot)
```
backuppage=ffffffff
baudrate=115200
boot_normal=readcfg; run read_kernel; bootm ${loadaddr}
bootargs=console=ttySAK0,115200n8 root=/dev/mtdblock4 rootfstype=squashfs init=/sbin/init mem=64M flash=SF device_id=00000000000 ethaddr=00:55:7b:b5:7d:f7 devinfo=jcoxxx memsize=64M
bootcmd=run boot_normal
bootdelay=3
console=ttySAK0,115200n8
erase_env=sf probe 0:0 ${sf_hz} 0; sf erase 0x20000 0x2000
ethact=AKEthernet-0
ethaddr=00:55:7b:b5:7d:f7
fs_addr=0x230000
init=/sbin/init
ipaddr=192.168.1.99
kernel_addr=31000
kernel_size=154590
loadaddr=81808000
memsize=64M
mtd_root=/dev/mtdblock4
netmask=255.255.255.0
read_kernel=sf probe 0:0 ${sf_hz} 0; sf read ${loadaddr} ${kernel_addr} ${kernel_size}
rootfstype=squashfs
serverip=192.168.1.1
setcmd=setenv bootargs console=${console} root=${mtd_root} rootfstype=${rootfstype} init=${init} mem=${memsize}
sf_hz=20000000
stderr=serial
stdin=serial
stdout=serial
ver=U-Boot 2013.10.0-AK_V2.0.03 (Sep 21 2017 - 17:00:25)
vram=12M
```
Путем модификации параметров загрузки ОС Linux возможно изменить стандартный порядок загрузки (запуск */sbin/init* на запуск */bin/sh*), что дает шелл в запущенной Linux-системе (основной функционал камеры в этот момент еще не начал работать). Последовательность команд в оболочке U-Boot, позволяющая сделать это:
```
setenv init /bin/sh # задать новое значение переменной
run setcmd # собрать заново переменную bootargs с уже внесенными изменениями
run boot_normal # запустить ОС
```
В результате ОС запустилась и дала возможность выполнять любые Linux-команды. Путем чтения устройства */dev/mtd0* можно считать содержимое флеш-памяти. Самый простой способ – записать с помощью *dd* содержимое флеш-памяти на microSD-карточку – почему-то в голову не пришел. Я пытался выводить содержимое ПЗУ в консоль и потом вырезать его из логов PuTTY, который использовал для подключения к serial-порту. Но в этом клиенте есть такая настройка, как Answerback to ^E, содержащая строку, которая будет [автоматически отправляться](https://documentation.help/PuTTY/config-answerback.html) серверу в случае получения от него ^E (что может произойти при выводе бинарного файла в консоль). И ладно бы проблема была только в этом – можно просто задать пустой answerback – еще PuTTY заменяет \n на \r\n, а \r\n оставляет без изменений. В итоге нереально понять, что нужно заменять обратно, а что нет. (Ну или по еще каким-то неведомым причинам размер дампа увеличивался на несколько байт.)
В итоге я использовал магию вида `dd if=/dev/mtd0 2>/dev/null | base64`, а потом локально декодировал вывод, достав его из логов.
В конце концов полученный через UART дамп совпал с тем, что был вытащен с использованием программатора.
Этап 4
------
На этом этапе нужно было:
* разобраться со структурой полученного ранее дампа и привести его к виду, доступному для анализа;
* узнать, что именно запускается в прошивке и в какой последовательности.
Среди логов, выводящихся во время загрузки ОС, попался такой фрагмент:
Разделы
```
mtd_part[0]:
name = KERNEL
size = 0x200000
offset = 0x31000
mask_flags = 0x1
mtd_part[1]:
name = MAC
size = 0x1000
offset = 0x231000
mask_flags = 0x1
mtd_part[2]:
name = ENV
size = 0x1000
offset = 0x232000
mask_flags = 0x1
mtd_part[3]:
name = A
size = 0x100000
offset = 0x233000
mask_flags = 0x1
mtd_part[4]:
name = B
size = 0x400000
offset = 0x333000
mask_flags = 0x1
mtd_part[5]:
name = C
size = 0xaf000
offset = 0x733000
mask_flags = 0x1
Creating 6 MTD partitions on "spi0.0":
0x000000031000-0x000000231000 : "KERNEL"
0x000000231000-0x000000232000 : "MAC"
0x000000232000-0x000000233000 : "ENV"
0x000000233000-0x000000333000 : "A"
0x000000333000-0x000000733000 : "B"
0x000000733000-0x0000007e2000 : "C"
```
Собственно, на прошлом этапе можно было извлекать дамп целиком из */dev/mtd0*, а можно уже разбитым на разделы из */dev/mtd[1-6]*. Оставалось только разобраться, что это за разделы с говорящими и не очень названиями (*binwalk* с этим отлично справился):
1. KERNEL – заголовок U-Boot и zImage ядро Linux.
2. MAC – помимо MAC-адреса в ASCII со странным значением (FF:FF:FF:00:00:00), тут были только 00 и FF в большом количестве.
3. ENV – переменные окружения для U-Boot.
4. A – образ SquashFS с более-менее стандартным линуксовым набором директорий и файлов.
5. B – образ SquashFS, содержащий творчество разработчиков устройства: приложения, библиотеки, модули ядра.
6. C – образ JFFS2, содержащий в основном конфиги: сетевые настройки (в т.ч. данные для подключения к Wi-Fi-сети), файл passwd.
О файле passwdВ этом файле содержался хеш пароля для пользователя root. Но, увы, гугл о нем не знал, брут по каким-то словарям для IoT с гитхаба не помог, а полный перебор занял бы на моем процессоре около года, так что пришлось отказаться от идеи подключаться к камере по telnet и творить все, что вздумается.
Порядок запуска внутри ОС описан в файле */etc/init.d/rc.local*:
Содержимое
```
#!/bin/sh
#print kernel error default
echo 4 > /proc/sys/kernel/printk
# mount usr file-system.
/bin/mount -t squashfs /dev/mtdblock5 /usr
# mount jffs2 file-system.
/bin/mount -t jffs2 /dev/mtdblock6 /etc/jffs2
# note: can't recommend running other app before `mount` command.
#start ftp server, dir=root r/w, -t 600s(timeout)
/usr/bin/tcpsvd 0 21 ftpd -w / -t 600 &
#start syslogd & klogd, log rotated 3 files(200KB) to /var/log/messages
syslogd -D -n -O /var/log/messages -s 200 -b 3 & # -l prio
klogd -n & # -c prio
#create ramdisk
dd if=/dev/zero of=/tmp/zero bs=512 count=200
losetup /dev/loop0 /tmp/zero
mkfs.vfat /dev/loop0
mkdir /tmp/ramdisk
mount /dev/loop0 /tmp/ramdisk
ifconfig lo 127.0.0.1
#load camera module
/usr/sbin/camera.sh setup
dmesg > /tmp/start_message
#start system service
#/usr/sbin/service.sh start &
## set min free reserve bytes
echo 2048 > /proc/sys/vm/min_free_kbytes
#install usb wifi driver(default)
insmod /usr/modules/sdio_wifi.ko
sleep 1 #### 等待电源稳定后再加载其他驱动
insmod /usr/modules/otg-hs.ko
sleep 2 #### 等待otg 向usb host 核心层完成一些注册工作后再加在驱动
insmod /usr/modules/rtl8188fu.ko
#ifconfig eth0 up
#检查是否有恢复usr分区的升级包
echo "start revocer_app..."
/bin/revocer_app
#start ipc
read -t 1 -n 1 char
if [ "$char" == "n" ];then
echo "stop"
else
echo "start dgiot..."
/usr/dgiot/bin/dgiot &
echo "start ota_upgrade..."
/bin/ota_upgrade &
fi
echo "start telnet......"
telnetd &
```
Вот схема запуска:
Основная жизнедеятельность камеры реализована в приложении dgiot, дальше предстоит работать именно с ним. Это обычный ELF-файл для ARM, никаких проблем с его загрузкой в IDA Pro, как у [предыдущего](https://habr.com/ru/company/ntc-vulkan/blog/485966) стажера, не возникло.
Этап 5
------
На этом этапе нужно было разобраться с потоками и основными циклами в приложении, но перед этим стоило попробовать облегчить себе задачу: попытаться найти какую-либо информацию об использованных библиотеках/SDK, чтобы в первую очередь смотреть именно в тот код, который написан разработчиками устройства.
Пробежавшись глазами по строкам из ELF-файла, нашел используемые компиляторы:
* GCC: (GNU) 3.3.2 20031005 (Debian prerelease);
* GCC: (anyka (gcc-4.8.5 + binutils-2.24 + ulcibc-0.9.33.2)(20170223)) 4.8.5;
* GCC: (Hisilicon\_v100(gcc4.4-290+uclibc\_0.9.32.1+eabi+linuxpthread)) 4.4.1.
Судя по всему, разработчики не стали возиться со сборкой сторонних библиотек, а просто использовали уже готовые бинари, поэтому тут встретились разные компиляторы.
Используемые SDK:
* [TUYA IPC SDK](https://github.com/TuyaInc/TUYA_IPC_SDK/) v4.2.4;
* [TUTK SDK](https://github.com/cnping/TUTK);
* Anyka SDK (вот тут накладка. Логично, что такое должно быть, но найти в Интернете ничего подобного не удалось).
Чтобы сопоставить найденные библиотеки и имеющееся приложение, мне посоветовали плагин [Diaphora](https://github.com/joxeankoret/diaphora) для IDA Pro. Из его функционала мне приглянулась возможность найти одинаковые функции в SDK (собранном с отладочными символами) и приложении, после чего автоматически перенести имена функций.
Мне не удалось точно угадать версию TUTK SDK, поэтому здесь Diaphora был очень кстати: ему не нужно полное совпадение функций, он по ряду собственных метрик показывает, насколько функции похожи. А для TUYA IPC SDK удобнее оказалось использовать FLAIR из состава IDA Pro. В этой [статье](https://habr.com/ru/post/509148/) подробно описано, как такое сделать.
И еще один способ получить исходные имена функций. Разработчиками используются функции для вывода в логи сообщений об ошибках с использованием макросов `__LINE__`, `__FUNCTION__`, `__FILE__` (чтобы проще было понять, что произошло):
Я нашел две разные функции такого вида, но идея одна и та же: *n*-й аргумент этой функции будет именем внешней функции (той, где вызывается вывод в лог). Переименовав вручную по этому принципу несколько десятков функций, я понял, что надо это как-то автоматизировать – наконец-то настало время попробовать IDAPython. Но мне не первому в голову пришла такая идея, даже есть [статья](https://habr.com/ru/company/inforion/blog/499382/), в разделе 0x04 которой подобный скрипт описан.
После всего вышеописанного разбираться с логикой приложения гораздо комфортнее. Среди всех запускаемых потоков можно выделить следующие:
1. Поток обнаружения движения (md\_judge\_thread @0x123890):
2. Поток обработки данных, получаемых по сети (lpc\_task\_cb@0x1E9B4C). Здесь, если пакет валидный, данные передаются в lan\_protocol\_process@0x2290E8:
Этап 6
------
На заключительном этапе нужно было выяснить:
* какие порты слушает устройство;
* каким образом обрабатывает поступающие данные;
* какие команды выполняет.
Параллельно с этим понять, как отправляются уведомления владельцу (те самые, которые нужно отключить в соответствии с целью исследования). И, наконец, разработать PoC, который будет выполнять эту задачу.
В приложении вызывается функция *listen* для сокетов на следующих портах:
* 8554 – RTCP-сервер;
* 6668 – свой протокол (в коде его называют lpc).
Были надежды, что последние две буквы в названии второго протокола означали procedure call, так что он выглядел более многообещающим, и изучать в первую очередь я стал именно его.
Данные, поступающие на порт 6668, обрабатываются в ранее упомянутой функции lan\_protocol\_process@0x2290E8. Структура пакета:
```
0x00 00 00 55 AA header
0x04 xx xx xx xx session id
0x08 00 00 00 xx command type
0x0C xx xx xx xx length (all packet)
0x10 xx xx xx xx data (e.g. json)
...
-0x08 xx xx xx xx crc32 (no check)
-0x04 00 00 AA 55 footer
```
Интересно, что контрольная сумма поступающих в приложение пакетов вычисляется, но нигде не проверяется. Хотя в пакетах, получаемых от камеры в ответ, контрольная сумма присутствует и посчитана нормально.
О Kaitai StructДавно хотел попробовать эту интересную [штуку](https://kaitai.io/). К сожалению, здесь от нее пользы было немного, потому что парсить мне в итоге так ничего и не пришлось. В виде .ksy-файла структура пакета выглядит так:
```
meta:
id: lpc_send
endian: be
seq:
- id: header
contents: [0x0, 0x0, 0x55, 0xaa]
- id: session_id
type: u4
- id: command
type: u4
enum: command_types
- id: lenght
type: u4
- id: data
size: lenght-8
- id: crc32
type: u4
- id: footer
contents: [0x0, 0x0, 0xaa, 0x55]
enums:
command_types:
7: type1
13: type1_
8: write
11: read
10: type2
16: type2_
12: token
14: typetime
15: wifi
```
На этом месте я завис, пытаясь разобраться, казалось бы, с небольшим набором команд. Полезной оказалась одна команда – 8 (должна быть в пакете по смещению 0x08) – позволяет записать произвольные 4 байта ("v") по произвольному адресу ("a"):
А теперь вернемся к функции md\_judge\_thread @0x123890 (листинг был на скрине на этапе 5). При обнаружении движения в логи пишется строка "…>>>movtion detect!!" (sic!), даже если реально уведомления никуда не отправляются (т.е. выключены пользователем). Цикл, в котором это происходит, выполняется, пока переменная по адресу 0x004975F8 равна нулю, т.е. для остановки цикла и выхода из потока необходимо записать любое отличное от нуля значение по этому адресу. А как записывать что-то в память уже известно.
Для остановки потока обнаружения движения был написан скрипт на python, отправляющий правильный пакет:
```
command = COMMAND_WRITE # 8
data = b'{"a":4814328, "v":1}'
b = bytes([0, 0, 0x55, 0xaa]) # header
b += bytes([1, 2, 3, 4]) # session id
b += struct.pack('>L', command) # command
b += struct.pack('>L', len(data)+8) # length
b += data # data
b += bytes([0, 0, 0, 0]) # crc32, not checked
b += bytes([0, 0, 0xaa, 0x55]) # footer
```
После отправки этого набора байтов на порт 6668 камера переставала отправлять владельцу уведомления о появлении движения в кадре.
Отыскать в локальной сети камеру можно с помощью *nmap*. Необходимо найти устройства с открытым требуемым портом и именем dgiot.
Заключение
----------
На этом стажировку можно было считать оконченной.
Так, в конечном счете должна выглядеть последовательность действий для отключения функционала обнаружения движения:
1. Подключиться к локальной сети, в которой находится камера.
2. С помощью *nmap* просканировать сеть на наличие камеры, получив ее IP-адрес.
3. Отправить на найденный адрес сформированный пакет, что остановит поток обнаружения движения, и, как следствие, владельцу не будут приходить уведомления о движении в кадре.
Для автоматизации этих действий я использовал скрипты на bash и python.
Помимо описанного во вступлении, также я выполнил ряд пунктов из своего собственного чек-листа "когда-нибудь попробовать":
* исследование многопоточного приложения;
* поковырять какой-то самописный протокол;
* использовать Kaitai Struct;
* попробовать написать скрипт на IDAPython.
Еще я убедился, что хочу в дальнейшем связать свою профессиональную деятельность именно с этим направлением ИБ.
Что показалось наиболее сложным:
* работа с паяльником (с ним я все еще на "вы");
* понимание, когда нужно копать глубже, а когда – взглянуть на ситуацию шире.
Следует заметить, что ряд шагов, предпринятых в исследовании, можно было бы и не совершать. Но в ходе стажировки было важно не просто достигнуть цели ("слегка" надуманной), а провести полноценное исследование, "потренироваться на кошках". Примененный здесь подход с успехом может быть использован и для более реальных задач.
По окончании стажировки мне вручили сертификат об успешном ее прохождении. Но, внезапно, не из бумаги/картона, а из текстолита размера А5. Изготовлен, видимо, так же, как печатные платы. Интересный формат, люди подошли с фантазией, казалось бы, к тривиальной вещи.
Фото сертификатаИ после двух с лишним месяцев приключений в мире исследователей защищенности хотелось бы сказать спасибо НТЦ "Вулкан" в целом за предоставленную возможность получить опыт реверс-инжиниринга IoT-устройства и руководителю стажировки в частности, который в любое время дня и ночи приходил на помощь и своими ценными советами направлял меня в этом нелегком деле.
[*Raccoon Security*](https://raccoonsecurity.ru/) *– специальная команда экспертов НТЦ "Вулкан" в области практической информационной безопасности, криптографии, схемотехники, обратной разработки и создания низкоуровневого программного обеспечения.*
*Мы постоянно проводим такие индивидуальные стажировки и будем благодарны, если вы поделитесь ссылкой на эту статью с теми, кому это может быть интересно.*
**Оставить заявку на прохождение стажировки можно** [**тут**](https://raccoonsecurity.ru/internship/)**.** | https://habr.com/ru/post/567852/ | null | ru | null |
# Избавляемся от PGP в почтовом ящике mutt
На мой параноидальный взгляд по возможности всё общение по почте и IM должно быть зашифровано. (Не потому, что мне есть что скрывать, а просто потому, что я не вижу причин показывать свои сообщения соседу Пете, вне зависимости от того, где он работает — нигде, у провайдера, или в спецслужбе.) Для почты это PGP/GPG, для IM это OTR. Но это шифрование призвано защищать сообщения в процессе передачи по сети, а не на винте в почтовом ящике/логах IM. На винте от него толку нет, одни неприятности — медленный поиск в сообщениях (если в вашем MUA поиск вообще работает в зашифрованных письмах), невозможность обрабатывать почтовый ящик простыми скриптами, etc. Если есть необходимость шифровать данные у себя на винте, то для этого есть другие, более подходящие и универсальные средства, чем PGP для части писем.
Поскольку PGP требуется только во время передачи по сети, то было бы идеальным решением шифровать/дешифровать письма в момент приёма/передачи, т.е. используя локальный POP3/SMTP relay сервер. В этом случае все почтовые клиенты (MUA) автоматически получили бы «поддержку PGP», и при этом ничего о PGP сами не знали, и работали с не зашифрованными письмами. Под Windows такой сервер есть — [GPGrelay](http://sites.inka.de/tesla/gpgrelay.html). Под \*NIX я аналога найти не смог. Есть утилитка [kuvert](http://www.snafu.priv.at/mystuff/kuvert/), которая может автоматически шифровать исходящую почту, но утилитки для дешифровки входящей я не нашёл.
Но девиз mutt не зря «All mail clients suck. This one just sucks less.» — мне удалось с помощью его гибкости, небольшого вспомогательного скрипта для qmail, и такой-то матери решить эту, на первый взгляд банальную, задачку.
#### Отправка писем
С этим всё просто. За шифрование отправляемых писем отвечает, как обычно, mutt. Таким образом я вижу/контролирую какие сообщения шифруются, а какие нет. А чтобы в моём почтовом ящике оставалась не зашифрованная версия отправленного сообщения, достаточно добавить в ~/.muttrc:
`set fcc_clear=yes`
#### Получение писем
А вот здесь возникли сложности. В mutt есть функция decrypt-save, которая корректно дешифрует письмо (в т.ч. с аттачами), сохраняет дешифрованное письмо в указанный почтовый ящик, а зашифрованный оригинал удаляет. (Кстати, не перепутайте её с decode-save, которая делает почти то же самое, только хуже — вроде аттачи как минимум не поддерживает. Что интересно, по умолчанию в mutt именно decode-save повешена на Esc+s, а лучшая decrypt-save не назначена ни на какую комбинацию кнопок.) С её помощью можно создать hook, который автоматически будет дешифровать сообщение в момент открытия, заменяя в текущем ящике шифрованную версию нешифрованной — дописываем в ~/.muttrc:
`message-hook '~h"Content-Type: multipart/encrypted"' 'push \cu^'`У этого подхода есть несколько особенностей/недостатков:
* Удалить только одно зашифрованное письмо нельзя, так что в момент открытия зашифрованного письма удаляются все помеченные к удалению письма в этом ящике, что может оказаться неприятным сюрпризом в некоторых ситуациях.
* Как обычно в mutt, в момент пометки текущего письма к удалению, он переходит к следующему письму в этом ящике. Если это зашифрованное письмо было единственным новым письмом, то всё сработает идеально — следующим письмом окажется именно его не зашифрованная копия, так что входя в это письмо вы именно его и увидите. Если в ящике было несколько новых писем, и все зашифрованные, то открывая первое из них вы вызовете лавину автоматических переходов в следующие письма с их автоматическим дешифрованием, но внешне всё сработает как ожидается — в результате откроется именно то письмо, которое вы открывали. Но вот если среди новых писем встречаются зашифрованные и не зашифрованные вперемешку, то входя в первое зашифрованное письмо у вас неожиданно вместо него откроется первое не зашифрованное.
* В отличие от виндового GPGrelay (который при расшифровке может опционально добавить в письмо информацию о том, что оно было зашифровано/подписано), функция decrypt-save никак не модифицирует письмо. Таким образом, после автоматической расшифровки и удаления оригинала письма мы никак не сможем узнать, было ли оно зашифровано и корректно подписано.
Для решения последней проблемы я написал небольшой скрипт [addgpginfo](http://powerman.name/download/addgpginfo/). Он получает на STDIN письмо, если оно было зашифровано или зашифровано и подписано то он добавляет к письму нестандартные заголовки GPG: с полной информацией о шифровании/подписи, после чего запускает указанную ему параметрами программу, предоставляя ей на STDIN модифицированное письмо. Я его разрабатывал для использования в ~/.qmail, но в теории этот подход должен работать с любыми аналогичными программами вроде procmail. Например, если у вас в ~/.qmail:
`./Maildir/`
то вы вместо этого пишете:
`|addgpginfo qmail-local "$USER" "$HOME" "$LOCAL" "" "nodeliver" "$HOST" "$SENDER" ./Maildir/`
Из соображений паранойи в него надо бы ещё добавить удаление возможных GPG: заголовков из входящих писем (чтобы никто не смог прислать вам не подписанное письмо от чужого имени, в заголовках которого прописав что оно, якобы, было корректно подписано). И из соображений совместимости переименовать заголовок GPG: в X-GPG:. Но это уже мелочи. Для работы addgpginfo необходимо, чтобы у вас был запущен gpg-agent с опцией --write-env-file, и запущенные X-ы ($DISPLAY ему можно передать параметром, если он у вас не ":0").
Результат выглядит примерно вот так:
 | https://habr.com/ru/post/135800/ | null | ru | null |
# Портирование Qt на STM32
Добрый день! Мы в проекте [Embox](https://github.com/embox/embox) запустили Qt на STM32F7-Discovery и хотели бы об этом рассказать. Ранее, мы уже рассказывали как нам удалось запустить [OpenCV](https://habr.com/ru/company/embox/blog/457724/).
Qt — это кроссплатформенный фреймворк, который включает в себя не только графические компоненты, но и такие вещи как QtNetwork, набор классов для работы с базами данных, Qt for Automation (в том числе, для реализации IoT) и многое другое. Разработчики команды Qt заранее предусмотрели использование Qt во встроенных системах, поэтому библиотеки довольно хорошо конфигурируются. Однако до недавних пор, мало кто задумывался о портировании Qt на микроконтроллеры, вероятно потому, что такая задача выглядит сложной — Qt большое, MCU маленькие.
С другой стороны, на данный момент существуют микроконтроллеры, предназначенные для работы с мультимедиа и превосходящие первые Pentium-ы. Около года назад в блоге Qt появился [пост](https://blog.qt.io/blog/2018/05/03/qt-microncontrollers-mcu/). Разработчики сделали порт Qt под ОС RTEMS, и запустили примеры с виджетами на нескольких платах под управлением stm32f7. Нас это заинтересовало. Было заметно, и сами разработчики об этом пишут, что Qt тормозит на STM32F7-Discovery. Нам стало интересно, сможем ли мы запустить Qt под Embox, при этом не просто нарисовать виджет, а запустить анимацию.
В Embox уже давно портировано Qt 4.8, поэтому решили попробовать на нем. Выбрали приложение moveblocks — пример пружинистой анимации.
**Qt moveblocks на QEMU**
Для начала конфигурируем Qt по возможности с минимальным набором компонент, требуемым для поддержки анимации. Для этого существует опция “-qconfig minimal,small,medium ...”. Она подключает конфигурационный файл из состава Qt c множеством макросов — что включить / что отключить. После этой опции добавляем в конфигурацию другие флаги, если хотим еще что-то отключить дополнительно. Вот пример нашей [конфигурации](https://github.com/embox/embox/blob/master/third-party/qt/Makefile).
Для того, чтобы Qt заработало, нужно добавить слой совместимости с ОС. Один из способов — реализовать QPA (Qt Platform Abstraction). За основу взяли уже готовый плагин fb\_base в составе Qt, на базе которого работает QPA для Линукс. В итоге получился небольшой плагин emboxfb, который предоставляет Qt фреймбуфер Embox’a, а дальше оно рисует туда уже без посторонней помощи.
**Вот так выглядит создание плагина**
```
QEmboxFbIntegration::QEmboxFbIntegration()
: fontDb(new QGenericUnixFontDatabase())
{
struct fb_var_screeninfo vinfo;
struct fb_fix_screeninfo finfo;
const char *fbPath = "/dev/fb0";
fbFd = open(fbPath, O_RDWR);
if (fbPath < 0) {
qFatal("QEmboxFbIntegration: Error open framebuffer %s", fbPath);
}
if (ioctl(fbFd, FBIOGET_FSCREENINFO, &finfo) == -1) {
qFatal("QEmboxFbIntegration: Error ioctl framebuffer %s", fbPath);
}
if (ioctl(fbFd, FBIOGET_VSCREENINFO, &vinfo) == -1) {
qFatal("QEmboxFbIntegration: Error ioctl framebuffer %s", fbPath);
}
fbWidth = vinfo.xres;
fbHeight = vinfo.yres;
fbBytesPerLine = finfo.line_length;
fbSize = fbBytesPerLine * fbHeight;
fbFormat = vinfo.fmt;
fbData = (uint8_t *)mmap(0, fbSize, PROT_READ | PROT_WRITE,
MAP_SHARED, fbFd, 0);
if (fbData == MAP_FAILED) {
qFatal("QEmboxFbIntegration: Error mmap framebuffer %s", fbPath);
}
if (!fbData || !fbSize) {
qFatal("QEmboxFbIntegration: Wrong framebuffer: base = %p,"
"size=%d", fbData, fbSize);
}
mPrimaryScreen = new QEmboxFbScreen(fbData, fbWidth,
fbHeight, fbBytesPerLine,
emboxFbFormatToQImageFormat(fbFormat));
mPrimaryScreen->setPhysicalSize(QSize(fbWidth, fbHeight));
mScreens.append(mPrimaryScreen);
this->printFbInfo();
}
```
**А вот так вот будет выглядеть перерисовка**
```
QRegion QEmboxFbScreen::doRedraw()
{
QVector rects;
QRegion touched = QFbScreen::doRedraw();
DPRINTF("QEmboxFbScreen::doRedraw\n");
if (!compositePainter) {
compositePainter = new QPainter(mFbScreenImage);
}
rects = touched.rects();
for (int i = 0; i < rects.size(); i++) {
compositePainter->drawImage(rects[i], \*mScreenImage, rects[i]);
}
return touched;
}
```
В итоге с включенной оптимизацией компилятора по размеру памяти -Os образ библиотеки получился 3.5 Мб, что конечно не влезает в основную память STM32F746. Как мы уже писали в нашей другой статье про OpenCV, на этой плате имеется:
* 1 Мб ROM
* 320 Кб RAM
* 8 Мб SDRAM
* 16 Мб QSPI
Так как для OpenCV уже была добавлена поддержка исполнения кода из QSPI, мы решили начать с того, что загрузили образ Embox c Qt в QSPI целиком. И ура, все почти сразу же запустилось из QSPI! Но как и в случае с OpenCV оказалось, что работает слишком медленно.
Поэтому решили делать так — сначала копируем образ в QSPI, затем загружаем его в SDRAM и выполняемся оттуда. Из SDRAM стало немного быстрей, но все равно далеко от QEMU.
Далее была идея включить плавающую точку — ведь Qt делает некоторые вычисления координат квадратов в анимации. Попробовали, но здесь не получили видимого ускорения, хотя в [статье](https://blog.qt.io/blog/2018/05/03/qt-microncontrollers-mcu/) разработчики Qt утверждали, что FPU дает значительный прирост в скорости для “dragging animation” на touchscreen’e. Возможно, в moveblocks существенно меньше вычислений с плавающей точкой, и это зависит от конкретного примера.
Самым же эффективным оказалась идея перенести фреймбуфер из SDRAM во внутреннюю память. Для этого мы сделали размеры экрана не 480x272, а 272x272. Еще понизили глубину цвета с A8R8G8B8 до R5G6B5, таким образом сократив размер одного пикселя с 4 до 2 байт. Получили размер фреймбуфера 272 \* 272 \* 2 = 147968 байт. Это дало значительное ускорение, пожалуй, самое заметное, анимация стала почти плавной.
Последней оптимизацией стало выполнение кода Embox из RAM, а Qt из SDRAM. Для этого мы сначала как обычно линкуем статически Embox вместе с Qt, но сегменты text, rodata, data и bss библиотеки размещаем в QSPI, с тем чтобы потом скопировать в SDRAM.
```
section (qt_text, SDRAM, QSPI)
phdr (qt_text, PT_LOAD, FLAGS(5))
section (qt_rodata, SDRAM, QSPI)
phdr (qt_rodata, PT_LOAD, FLAGS(5))
section (qt_data, SDRAM, QSPI)
phdr (qt_data, PT_LOAD, FLAGS(6))
section (qt_bss, SDRAM, QSPI)
phdr (qt_bss, PT_LOAD, FLAGS(6))
```
За счет выполнения кода Embox из ROM тоже получили ощутимое ускорение. В итоге анимация получилось достаточно плавной:
Уже в самом конце, подготавливая статью и пробуя разные конфигурации Embox’a, выяснилось, что Qt moveblocks замечательно работает и из QSPI с фреймбуфером в SDRAM, а узким местом был именно размер фреймбуфера! По-видимому, чтобы преодолеть начальное “слайдшоу” хватало ускорения в 2 раза за счет банального уменьшения размера фреймбуфера. А добиться такого результата переносом только лишь кода Embox в различные быстрые памяти не удалось (ускорение получалось не в 2, а примерно в 1.5 раза).
### Как попробовать самому
Если у Вас имеется STM32F7-Discovery, Вы можете запустить Qt под Embox сами. Прочитать как это делается можно на нашем [вики](https://github.com/embox/embox/wiki/Qt-on-STM32).
### Заключение
В итоге нам удалось запустить Qt! Сложность задачи, на наш взгляд, несколько преувеличена. Естественно нужно учитывать специфику микроконтроллеров и вообще понимать архитектуру вычислительных систем. Результаты оптимизации указывают на известный факт, что самое узкое место в вычислительной системе, это не процессор, а память.
В этом году мы будем участвовать на фестивале [TechTrain](https://techtrain.ru/). Там мы подробней расскажем и покажем Qt, OpenCV на микроконтроллерах и прочие наши достижения. | https://habr.com/ru/post/459730/ | null | ru | null |
# Анализ покрытия кода тестами в Ruby
Для начала я приведу небольшой тестовый проект из трёх классов, проанализирую его покрытие с помощью [гема SimpleCov](https://github.com/colszowka/simplecov), а напоследок немного поразмышляю о том, как анализ покрытия может приносить пользу проекту, и какие есть недостатки у Coverage в Ruby.
[](https://habrahabr.ru/post/317326/)
Подопытный проект
-----------------
В качестве проекта для тестирования взята небольшая история о мальчике, который может спрашивать разрешения погулять у матери и у отца.
```
# Мама очень заботится о своём сыне, и не разрешает ему гулять,
# если он не надел шарф. А ещё она заботится о его успеваемости, поэтому если
# сын не сделал домашнюю работу, гулять ему она тоже не разрешит.
class Mother
def permit_walk?(child)
child.scarf_put_on && child.homework_done
end
end
```
```
# Отец тоже следит за тем, чтобы шарф был надет, но не так трепетно относится к учёбе.
class Father
def permit_walk?(child)
child.scarf_put_on
end
end
```
```
# Сын любит и уважает родителей, поэтому никогда не уходит гулять,
# не спросив разрешения. Спрашивать он может и у мамы, и у папы.
# Ну и, конечно, он может одеваться и делать ДЗ.
class Child
attr_reader :homework_done, :scarf_put_on
def initialize(mother, father)
@mother = mother
@father = father
@homework_done = false
@scarf_put_on = false
end
def do_homework!
@homework_done = true
end
def put_on_scarf!
@scarf_put_on = true
end
def walk_permitted?(whom_to_ask)
parent =
if whom_to_ask == :mother
@mother
else
@father
end
parent.permit_walk?(self)
end
end
```
Покрываем тестами и смотрим покрытие
------------------------------------
Тесты намеренно покрывают не все сценарии:
```
require "simplecov"
SimpleCov.start
require "rspec"
require_relative "../lib/mother"
require_relative "../lib/father"
require_relative "../lib/child"
RSpec.describe Child do
let(:child) { Child.new(Mother.new, Father.new) }
context "when asking mother without scarf and without homework" do
it "isn't permitted to walk" do
expect(
child.walk_permitted?(:mother)
).to be false
end
end
context "when asking mother with scarf and with homework" do
it "is permitted to walk" do
child.put_on_scarf!
child.do_homework!
expect(
child.walk_permitted?(:mother)
).to be true
end
end
end
```
SimpleCov — фактически монополист в области анализа покрытия в мире Ruby 1.9.3+. Он является удобной обёрткой над [модулем Coverage](https://ruby-doc.org/stdlib-2.2.3/libdoc/coverage/rdoc/Coverage.html) из стандартной библиотеки.
Подключение сводится к двум строкам в начале файла с тестами, при этом важно, чтобы инициализация SimpleCov проводилась до подключения файлов проекта. Запускаем тесты:
```
rspec
```
Voilà! Сгенерировался файл отчёт coverage/index.html. Посмотреть его можно [по ссылке](https://hedgesky.github.io/coverage_demo/coverage/index.html), а здесь я оставлю пару скриншотов, чтобы далеко не ходить (общий отчёт используется в качестве заглавной картинки).
*father.rb*
*Выдержка из child.rb*
Бонусы от анализа coverage
--------------------------
Из отчёта сразу видно, что не протестирован путь, в котором разрешение спрашивается у отца. Отсюда очевидная польза от анализа покрытия: в условиях неприменения TDD отчёт может показать, что мы забыли что-то протестировать. Если же проект достался в наследство и нелёгкий путь тестирования только начинается, отчёт поможет решить, куда эффективнее всего направить силы.
Второе возможное применение — автоматическое обеспечение "качества" коммитов. CI-сервер может отбраковывать коммиты, которые приводят к снижению total coverage, резко снижая вероятность появления в репозитории непротестированного кода.
Что анализ покрытия не даёт
---------------------------
Во-первых, стопроцентное покрытие не обеспечивает отсутствие багов. Простой пример: если изменить класс Mother таким образом:
```
class Mother
def permit_walk?(child)
# child.scarf_put_on && child.homework_done
child.homework_done
end
end
```
покрытие класса останется 100%-ым, тесты будут по-прежнему зелёными, но логика будет очевидно неверной. Для автоматического определения "отсутствующих, но нужных" тестов можно использовать [гем mutant](https://github.com/mbj/mutant). Я ещё не пробовал его в деле, но, судя по Readme и количеству звёзд на гитхабе, библиотека действительно полезна. Впрочем, это тема для отдельного поста, до которого я как-нибудь доберусь.
Во-вторых, в Ruby на данный момент возможен анализ покрытия только по строкам, branch- и condition-coverage не поддерживается. Имеется в виду, что в однострочниках вида
```
some_condition ? 1 : 2
some_condition || another_condition
return 1 if some_condition
```
есть точки ветвления, но даже если тесты пройдут только по одной возможной ветви исполнения, coverage покажет 100%. Был [pull request в Ruby](https://github.com/ruby/ruby/pull/511) на эту тему, но от мейнтейнеров уже два года [ничего не слышно](https://bugs.ruby-lang.org/issues/9508). А жаль.
Послесловие
-----------
Я предпочитаю писать тесты сразу же после написания кода, и coverage служит мне напоминалкой о ещё не протестированных методах (частенько забываю потестить обработчики исключений). В общем, анализ покрытия вполне может приносить определённую пользу, но 100%-е покрытие не обязательно говорит о том, что тестов достаточно.
Материалы, используемые в статье:
* [Тестовый проект на гитхабе](https://github.com/hedgesky/coverage_demo)
* [Отчёт по анализу SimpleCov](https://hedgesky.github.io/coverage_demo/coverage/index.html)
* [SimpleCov](https://github.com/colszowka/simplecov)
* [mutant](https://github.com/mbj/mutant) | https://habr.com/ru/post/317326/ | null | ru | null |
# Entity Framework и производительность
В процессе работы над проектом веб-портала, я исследовал возможности улучшить производительность, и наткнулся на небольшую статью про микро-ORM Dapper, который был написан авторами проекта StackOverflow.com. Изначально их проект был написан на Linq2Sql, а теперь все критичные к производительности места переписаны с использованием означенного решения.
Недостаток этого, а также других подобных решений, которые я успел посмотреть, в том, что они уж очень незначительно помогают облегчить процесс разработки, предоставляя по большому счету лишь материализацию, скрывая работу с непосредственно ADO.Net. SQL запросы же нужно писать руками.
Linq2Entities синтаксис же располагает к более «чистому коду», позволяя как тестирование кода, так и его переиспользование. Кроме того, при изменении в базе данных, сразу после обновления контекста, компилятор сгенерирует ошибки, во всех местах где используется удаленное или переименованное поле, изменившаяся структура связей между таблицами подсветит те места, где используются соответсвующие navigation properties.
Но статья не о том, насколько EF ускоряет разработку, и не о том, что не очень хорошо иметь часть запросов написанных на linq, а часть сразу на sql. Здесь я приведу решение, позволяющее совместить EF-сущности и Linq2Entities запросы с одной стороны и «чистую производительность» ADO.Net с другой. Но сначала немного предыстории. Все, кто с такими проектами работал, как я полагаю, сталкивались с тем, что per-row вызовы работают весьма медленно. И многие, вероятно, пытались оптимизировать это, написав огромный запрос и втиснув в него все, что только можно. Это работает, но выглядит очень страшно — код метода огромен, его трудно поддерживать и невозможно тестировать. Первый этап решения, который я опробовал, это материализация всех нужных сущностей, каждой отдельным запросом. А соединение/преобразование их в доменную структуру происходит раздельно с материализацией.
Поясню на примере. Нужно отобразить список страховых полисов, первичный запрос, выглядит примерно так:
```
int clientId = 42;
var policies = context.Set().Where(x => x.active\_indicator).Where(x => x.client\_id == clientId);
```
Далее, для отображения необходимой информации, нам нужны зависимые, или как их еще можно назвать, «дочерние» сущности.
```
var coverages = policies.SelectMany(x => x.coverages);
var premiums = coverages.Select(x => x.premium).Where(x => x.premium_type == SomeIntConstant);
```
Сущности, связанные посредством NavProps, также можно подгрузить посредством Include, но с этим возникают свои трудности, проще(и производительнее, об этом далее) оказалось сделать как в означенном примере.
Эта переделка сама по себе не дала такого уж прироста производительности, относительно исходного всеобъемлющего запроса, но упростила код, позволила разбить на более мелкие методы, сделать код более притным и привычным взгляду.
Производительность пришла следующим шагом, когда запустив профайлер SQL сервера, я обнаружил, что два запроса из 30 выполняются в 10-15 раз дольше остальных. Первый из этих запросов был таким
```
var tasks = workflows.SelectMany(x => x.task)
.Where(x => types.Contains(x.task_type))
.GroupBy(x => new { x.workflow_id, x.task_type})
.Select(x => x.OrderByDescending(y => y.task_id).FirstOrDefault());
```
Как выяснилось, EF генерирует очень неудачный запрос, и всего лишь передвинув GroupBy с последнего места на первое, я приблизил скорость выполнения этих запросов к остальным, получив около 30-35% уменьшения итогового времени исполнения.
```
var tasks = context.Set
.GroupBy(x => new { x.workflow\_id, x.task\_type})
.Select(x => x.OrderByDescending(y => y.task\_id).FirstOrDefault())
.Join(workflows, task => task.workflow\_id, workflow => workflow.workflow\_id, (task, workflow) => task)
.Where(x => types.Contains(x.task\_type));
```
На всякий случай скажу, что Join в этом запросе эквивалентен SelectMany в предыдущем.
Найти и устранить подобную огреху в недрах огромного запроса проблематично, на грани невозможного. И через Include такое тоже не реализовать.
Возвращаясь в начало статьи, к микро-ORM, хочу сразу сказать, что подобный подход возможно оправдан не во всех сценариях. В нашем нужно было загрузить порцию данных из БД, сделать некоторые преобразования и подсчеты и отправить клиенту в браузер, посредством JSON.
В качестве прототипа решения, я попробовал реализовать материализацию через PetaPoco, и был сильно впечатлен тестовым результатом, разница в во времени материализации целевой группы запросов составила 4.6х (756ms против 3493ms). Хотя правиьнее было бы сказать, что я был разочарован производительностью EF.
По причинам строгих настроек в StyleCop, использовать PetaPoco в проекте не вышло, да и чтобы приспособить его под задачу пришлось влезать в него и вносить изменения, поэтому созрела идея написать свое такое решение.
Решение полагается на то, что при генерации запросов, EF в запросе укажет имена полей для датасета, соответсвующие именам свойств объектов, которые он сгенерировал для контекста. Альтернативно, можно полагаться на порядок следования этих полей, что также работает. Чтобы извлечь запрос и параметры из запроса, используется метод ToObjectQuery, а уже на результирующем объекте используются метод ToTraceString и свойство Parameters. Далее следует простой цикл чтения, взятый из MSDN, «Изюминкой» решения являются материализаторы. PetaPoco эмитирует код материализатора в runtime, я же решил сгенерировать код для них с помощью T4 Templates. За основу взял файл, который генерирует сущности для контекста, считывая при этом .edmx, использовал из него все вспомогательные классы, и заменил непосредственно генерирующий код.
Пример сгенерированного класса:
```
public class currencyMaterialize : IMaterialize, IEqualityComparer
{
public currency Materialize(IDataRecord input)
{
var output = new currency();
output.currency\_id = (int)input["currency\_id"];
output.currency\_code = input["currency\_code"] as string;
output.currency\_name = input["currency\_name"] as string;
return output;
}
public bool Equals(currency x, currency y)
{
return x.currency\_id == y.currency\_id;
}
public int GetHashCode(currency obj)
{
return obj.currency\_id.GetHashCode();
}
}
```
Код, который эмитирует PetaPoco, условно идентичен этому, что в том числе подтвержаются одинаковым временем исполнения.
Как видно, класс также реализует интерфейс IEqualityComparer, из чего уже должно быть понятно, что на объектах, материализованных таким образом, обычное сравнение ReferenceEquals уже не работает, в отличие от объектов, которые материализует EF, и для того, чтобы сделать в памяти Distinct, и нужно было такое дополнение.
Результат изысканий я оформил в виде Item Template и опубликовал в [галерее Visual Studio](http://visualstudiogallery.msdn.microsoft.com/8b217146-6bf1-4406-bef3-84a7366602e7). Краткое описание, как использовать, там присутствует. Буду рад, если кого то заинтересует решение. | https://habr.com/ru/post/227637/ | null | ru | null |
# Живые обои на Android без нативного кода или история написания Two Hearts Live Wallpaper
Более полу года проработав разработчиком для Android я решил попробовать написать живые обои с использованием OpenGL. Пробежав по сети было обнаружено несколько движков общего назначения и множество любительских поделок. Два достаточно взрослых движка предлагали быстрый нативный код и хорошую документацию:
— [Andengine](http://www.andengine.org/);
— [LibGDX](http://code.google.com/p/libgdx/).
К несчастью, первый не умеет загружать модели и ограничивается двумя измерениями, во втором же работа с моделями выполнена в расширениях и написана на Java, что приводит к перерасходу памяти и медленной работе.
Unity3D не рассматривался из-за его платности, да и не заточен он для живых обоев.
Linderdaum выполнен полностью в нативном коде, но не содержит обертки для живых обоев и страшно медлителен, на Desire в простой сцене количество кадров в секунду колебалось от 3 до 8.
Просмотр маленьких проектов обнаружил [min3d](http://code.google.com/p/min3d/) и [Rajawali](https://github.com/MasDennis/Rajawali), причем первый написан для OpenGL 1.1 и уже год не поддерживается, а второй, хотя и работает с более продвинутой версией API, не содержит многих полезных функций из первого. Кроме того первый не умеет работать с живыми обоями.
Просмотрев примеры, я все же остановился на min3d. Использование шейдеров не столь актуально для простой сцены, а примеры написаны просто и доступно. Осталось добавить в него поддержку живых обоев и внести все исправления собранные сообществом со времени его последнего обновления.
В принципе, надстроек над OpenGL для живых обоев написано достаточно много, я использовал код от Robert Green с именем пакета [net.rbgrn.opengl](http://www.rbgrn.net/content/354-glsurfaceview-adapted-3d-live-wallpapers), которые реализует сервис и все необходимые классы. Для работе с живыми обоями, из min3d пришлось убрать жесткую привязку к активити, после чего стало возможно собрать примеры.
Так как автор давно бросил свое детище, а попытки с ним связаться окончились ничем, на Google Code был создан проект [min3d-live-wallpaper-fork](https://code.google.com/p/min3d-live-wallpaper-fork/), куда и были сохранены результаты проделанной работы.
Хотелось бы сказать несколько слов о модели функционирования живых обоев в Android. Живые обои это сервис выполняемый системой в основном потоке лаунчера, поэтому если они тормозят – интерфейс будет тормозить вместе с ним. При активных жывых обоя, когда пользователь заходит в окно предварительного просмотра создается еще один экземпляр сервиса. Поэтому, если разработчик наставил статических переменных и очень плотно работал с памятью, его ожидают интересные сюрпризы. Избежать их можно тщательно следя за завершением активных потоков, очисткой растровых изображений использования менеджера ресурсов без их статической инициализации.
Так как min3d изначально затачивался для работы с активити, пришлось дописать текстурный менеджер так, чтобы отмена загрузки текстуры в предварительном просмотре не удалял текстуру из фона рабочего стола. Кроме того изначально текстуры можно было добавлять только в блоке инициализации сцены, для динамической загрузки был добавлен не слишком изящный код ожидающий команду загрузки и загружащий ее в цикле перерисовки экрана.
Собственно на этом подготовительные работы заканчиваются, ставим задачу и пытаемся ее решить. Базовый концепт прост до примитивности – вывести на экран две смоделированных сердца, заставить их биться, добавить симпатичный фон и возможно простенькие частицы.
Модель я рисовал в [Blender](http://www.blender.org/), так как сердце симметрично, была смоделирована его четверть и при помощи модификатора зеркало получена готовая модель. Так как, что пользователь будет видеть только одну сторону сердца, оборотная сторона была отрезана, сцена освещается цветными источниками света, поэтому сердце не текстурировалось. Результирующий файл составил 17 килобайт, что отлично подходит для медлительного Java парсера моделей.
Не долго думая на фон была установлена текстура с рендером из того же Blender. Из-за ограниченности авторской фантазии было решено вывести на фон изящные бокалы. Нарисовав в Inkspace огибающую для бокала я импортировал в Blender файл svg формата, преобразовал кривую в ломаную и применив модификатор Screw получил весьма симпатичный бокал. Клонировав объект и настроив материалы был получен простенький фон:
Пришло время реализовывать все это в коде. Как уже было сказано в начале, все функции связанные с живыми обоями были вынесены в отдельные классы. Нам осталось только расширить уже готовую модель. Пишем класс описывающий сервис живых обоев.
`public class TwoHeartsWallpaper extends WallpaperTemplate {
@Override
public Engine onCreateEngine() {
TwoHeartsRenderer mRenderer = new TwoHeartsRenderer(this);
return new WallpaperEngine(getBaseContext(), mRenderer.renderer);
}
public void onDestroy() {
super.onDestroy();
}
}`
Здесь мы наследуемся от класса WallpaperTemplate и инициализируем класс рендера TwoHeartsRenderer. Именнно в этом классе мы будем рисовать сцену. Заготовка этого класса наследуется от CommonRender и содержит два основных перегруженных метода
initScene() – инициализация сцена
updateScene() – обновление сцены
Эти два метода аналогичны методам из min3d, поэтому уже сейчас можно собрать один из готовых примеров и получить свои живые обои. Я же решу поставленную задачу с двумя сердцами.
Первое что нам понадобится это выгруженные в понятный min3d формат модели. Движек поддерживает md2, obj, 3ds. Из этих форматов я остановился на obj, так как он полностью текстовый – разобраться в нем проще всего. Кроме того, Blender содержит готовый экспортер, работающий с материалами. Выгрузив модель, ее необходимо скопировать в папку ресурсов raw приложения для Android. Точку в имени файла необходимо заменить на знак подчеркивания, чтобы соответствовать стандартам именования ресурсов. Теперь загрузим ее в код. Для хранения данных о объектах в min3d существует формат Object3dContainer, а для загрузки моделей парсер Iparser. Загрузка модели заняла всего несколько строк.
`IParser parser = Parser.createParser(Parser.Type.OBJ, mContext.getResources(), "com.two_hearts:raw/heart_cut_obj", false);
parser.parse();
Object3dContainer mModelHeartHe = parser.getParsedObject();
mModelHeartHe.scale().x = mModelHeartHe.scale().y = mModelHeartHe.scale().z = mModelHeartHeScaleCurrent;
mModelHeartHe.position().z = 4;
mModelHeartHe.lightingEnabled(true);`
Первые две строки инициализируют парсер и устанавливают формат модели, путь в ресурсах и параметр, определяющий необходимость генрирования MipMap карт для текстур. Далее мы загружаем модель в переменную mModelHeartHe и задаем ее размер и позицию. Последняя строка включает работу с освещением.
Модель загружена, для ее добавления в сцену достаточно выполнить команду
`_scene.addChild(mModelHeartHe);`
Аналогичным образом в сцену добавляются все объекты, при использовании прозрачных текстур необходимо соблюдать очередность добавления от дальнего к ближнему объекту. Дописывать сортировку Z-буффера я не стал, так это сильно ударило бы по производительности.
Как я уже говорил, все операции по модификации сцены выполняются в методе updateScene(). Для вращения модели по оси Z достаточно просто вставить строку
`mModelHeartHe.rotation().z++;`
После того, как были реализованы два бьющихся сердца с фоном сцена все еще выглядила примитивно, поэтому было принято решение поизобретать велосипед и написать простейшую систему частиц. Из больших сердец должны были разлетаться много маленьких. Класс Particle, получился несколько безобразным, поэтому здесь я его не привожу. Параметры для частицы задаются в виде скорости, приращения, гравитации, трения и цветового сдвига. Более сложные модели увеличили бы нагрузку на процессор при их обновлении, а более простые не позволили бы реализовать поставленную задачу. Для теста в состав min3d были включены классы ParticleBox.java, ParticleCommon.java, ParticleCube.java и ParticleSprite.java, позволяющие использовать в качестве частицы куб, модель или спрайт. Естественно, самые быстрые частицы состоят из спрайтов.
Спрайт частицы частицы был получен из того же сердца, сглаженного и отрендеренного в Blender с бликом. Получилось вот так 
Было создано два эмиттера частиц с центрами внутри сердец. Так как сортировки Z-буффера нет, используется простейший способ избежать проблем с прозрачностью. Каждаю последующая частица выводится чуть выше предыдущей. Это конечно не академическое решение, но зато работает быстро.
После запуска эмиттеров сцена выглядит примерно так
 
Осталось добавить интерактивнось. Для живых обоев доступно сообщение о нажатии, делим экран на 4 зоны, по клику в зонах сердец запускаем поток, ускоряющий биение на одну секунду.
Для полноценной программы осталось стилизовать меню настроек. В нем пользователь может настроить количество вылетающих частиц или выключить их полностью, а также, указать насколько сильно ускорять биение сердец. Ведь у каждого оно бьется по-разному. Результирующий экран настроек показан ниже. Применен настраиваемые элемент управления RatingBar в форме сердца.
Видео работы приложения доступно по [ссылке](http://www.youtube.com/watch?v=EAqJfK7OLWQ). Приложение абсолютно бесплатное и не требует от пользователя ни одного разрешения. Доступно с [Android Market](https://market.android.com/details?id=com.shadowbox.wallpaper.two_hearts.free).
Надеюсь выложенные исходные тексты шаблона живых обоев на min3d помогут начинающим ознакомиться с 3D графикой на Андроиде и применить полученные знания для написания впечатляющих обоев с низким энергопотреблением. | https://habr.com/ru/post/139008/ | null | ru | null |
# Используем Ansible вместе с Terraform
Недавно я начал применять Terraform для создания облачной лабы для тестов, и это довольно круто. Буквально за несколько дней я поднялся с «никогда не использовал AWS» до «я умею декларативно создавать изолированную инфраструктуру в облаке». Я поставил парочку серверов в выделенной сети в VPC с security group и отдельными ключами SSH, все это заняло у меня несколько сотен строк кода.
Все приятно и прельстиво, но после создания сервера из некоторого базового AMI мне надо его развернуть. Мой типовой инструмент для этого — Ansible, но, к сожалению, у Terraform нет встроенного модуля для Ansible (*есть обратный, начиная с Ansible 2.5*, прим. переводчика), в отличие от Chef и Salt. Это не похоже на Packer, имеющий `ansible` (удаленный) и `ansible-local`, который я использовал для сборки образов Docker.
Так что я потратил немножко времени и нашел несколько способов подружить Terraform и Ansible, о чем расскажу в этой статье. Но сначала — поговорим о развертывании.
Нужно ли развертывание в облаке?
--------------------------------
Вы, конечно же, можете сделать свой собственный AMI вместо использования типовых пустых, и, следовательно, пропустить полностью развертывание, но у этого способа есть фатальный недостаток. Каждое минимальнейшее изменение потребует пересоздания всего сервера. Если надо что-то поправить на базовом уровне, придется перезаливать все сервера. Это быстро надоедает в случае развертывания, установки обновлений безопасности, добавления или удаления пользователей, изменения настроек и прочих простых вещей.
Далее — если делаете свои AMI, вам все равно нужно как-то запускать развертывание, так что опять появляются такие вещи, как Ansible. Ну и опять же, я рекомендую использовать Packer вместе с Ansible.
Получается, что в большинстве случаев развертывание нужно, потому что оно — неизбежно.
Как использовать Ansible вместе с Terraform
-------------------------------------------
Возвращаемся к задаче развертывания: я нашел три способа использовать Ansible совместно с Terraform после прочтения [этого](https://github.com/hashicorp/terraform/issues/2661) обсуждения. Читайте дальше, чтобы выбрать подходящий вам.
### Встроенный inventory с IP сервера
Наиболее очевидное и хакерское решение — запускать Ansible с помощью `local-exec`, например так:
```
provisioner "local-exec" {
command = "ansible-playbook -i '${self.public_ip},' --private-key ${var.ssh_key_private} provision.yml"
}
```
Просто и приятно, но тут сразу же есть нюанс. `local-exec` запускается без ожидания запуска сервера, так что в большинстве случаев это не сработает, потому что на момент подключения еще некуда подключаться.
В качестве изящного обходного способа вы можете предварительно использовать `remote-exec`, который будет ожидать соединения с сервером, а затем запускать `local-exec`.
В результате у меня получилась следующая вещь, запускающая роль «Ansible provisioner»:
```
provisioner "remote-exec" {
inline = ["sudo dnf -y install python"]
connection {
type = "ssh"
user = "fedora"
private_key = "${file(var.ssh_key_private)}"
}
}
provisioner "local-exec" {
command = "ansible-playbook -u fedora -i '${self.public_ip},' --private-key ${var.ssh_key_private} provision.yml"
}
```
Чтобы `ansible-playbook` работал, вам надо иметь код для Ansible рядом с кодом для Terraform:
```
$ ll infra
drwxrwxr-x. 3 avd avd 4.0K Mar 5 15:54 roles/
-rw-rw-r--. 1 avd avd 367 Mar 5 15:19 ansible.cfg
-rw-rw-r--. 1 avd avd 2.5K Mar 7 18:54 main.tf
-rw-rw-r--. 1 avd avd 454 Mar 5 15:27 variables.tf
-rw-rw-r--. 1 avd avd 38 Mar 5 15:54 provision.yml
```
Встроенный inventory будет работать в большинстве случаев, кроме тех, когда необходимо иметь несколько серверов в inventory. Например, если вы устанавливаете агент Consul, вам нужен список серверов для создания файла настроек, это как правило можно найти в обычном репозитории. Но в приведенном выше способе это не сработает, поскольку у нас всего один сервер в inventory.
В любом случае, я использую такую возможность для базовых вещей, например, добавления пользователей или установки некоторых базовых пакетов.
### Динамический inventory после работы Terraform
Еще одно простое решение для раскатки инфраструктуры, созданной Terraform — не связывать вместе Terraform и Ansible. Создаем инфраструктуру с помощью Terraform, а затем используем Ansible с динамическим inventory без привязки к тому, как сервера были созданы.
Так что вы сначала создаете инфраструктуру с помощью `terraform apply`, затем запускаете `ansible-playbook -i inventory site.yml`, где `inventory` — каталог, содержащий скрипты динамического inventory.
Это все будет шикарно работать, но есть небольшая ложка дегтя — если вам надо увеличить число серверов, не забывайте запускать Ansible после Terraform.
А это то, что я использую в дополнение к предыдущему способу.
### Inventory, создаваемая из состояния Terraform
Есть еще одна интересная штука, которая, возможно, будет у вас работать — создание статического inventory из состояния Terraform.
Terraform при работе поддерживает состояние инфраструктуры, содержащее все, включая ваши сервера. При использовании [local backend](https://www.terraform.io/docs/backends/index.html) это состояние сохраняется в файле JSON, который можно потом легко разобрать и сконвертировать в inventory для Ansible.
Я нашел два проекта с примерами, так что вы можете их использовать, если будете работать с этим способом.
[Первый](https://github.com/adammck/terraform-inventory)
```
[all]
52.51.215.84
[all:vars]
[server]
52.51.215.84
[server.0]
52.51.215.84
[type_aws_instance]
52.51.215.84
[name_c10k server]
52.51.215.84
[%_1]
52.51.215.84
```
[Второй](https://github.com/express42/terraform-ansible-example/blob/master/ansible/terraform.py)
```
$ ~/soft/terraform.py --root . --hostfile
## begin hosts generated by terraform.py ##
52.51.215.84 C10K Server
## end hosts generated by terraform.py ##
```
Дополнение Ansible для Terraform, которое у меня не заработало
--------------------------------------------------------------
Наконец, есть несколько проектов, которые пытаются внедрить поддержку Ansible в Terraform, как это уже, например, сделано для Chef.
[Первая](https://github.com/jonmorehouse/terraform-provisioner-ansible) попытка сделать дополнение, но, к сожалению, он уже не поддерживается автором и даже больше — не поддерживается актуальной системой дополнений Terraform.
[Вторая](https://github.com/radekg/terraform-provisioner-ansible), более свежая и поддерживаемая, позволяет такой вариант развертывания:
```
...
provisioner "ansible" {
plays {
playbook = "./provision.yml"
hosts = ["${self.public_ip}"]
}
become = "yes"
local = "yes"
}
...
```
К сожалению, у меня не получилось заставить это работать, так что я тупо забил, поскольку первые два способа работают во всех моих случаях.
Заключение
----------
Terraform и Ansible — мощная связка, которую я использую для развертывания облачной инфраструктуры. Для типовых облачных серверов я запускаю Ansible через `local-exec`, позднее я запускаю Ansible отдельно с динамическим inventory.
Примеры можно найти [здесь](https://github.com/dzeban/c10k/tree/master/infrastructure).
Благодарю за внимание и до новых встреч! | https://habr.com/ru/post/525810/ | null | ru | null |
# HTML5 CANVAS шаг за шагом: Изображения
**CANVAS шаг за шагом:**
1. [Основы](http://habrahabr.ru/post/111308/)
2. [Изображения](http://habrahabr.ru/post/111385/)
3. [Понг](http://habrahabr.ru/post/116860/)
4. [Пятнашки](http://habrahabr.ru/post/118356/)
Продолжение [статьи про рисование на холсте](http://habrahabr.ru/blogs/html5/111308/), в которой мы научимся использовать изображения. Естественно рисовать на холсте примитивами очень не удобно и требует определённых трудозатрат, и результат иногода явно хромает качеством. Поэтому естественно в canvas api предусмотрено взаимодействие с изображениями. Добавление изображения условно можно разделить на два шага: создание JavaScript объекта Image, а второй и заключительный шаг это отрисовка изображения на холсте при помощи функции drawImage. Рассмотрим оба шага подробнее.
Создание нового графического объекта:
```
var img = new Image(); // Создание нового объекта изображения
img.src = 'image.png'; // Путь к изображению которое необходимо нанести на холст
```
Кстати в качестве источника изображения, можно указать вот такую строку в которой изображение и описанно:
```
img.src = 'data:image/gif;base64,R0lGODlhDAAMAOYAANPe5Pz//4KkutDb4szY3/b+/5u5z/3//3KWrfn//8rk8naasYGkuszY4Mbg8qG+0dzv9tXg5sTg8t/o7vP8/4iqv9ft9NPe5qfD1Mfc56O/0YKlu+Lr8M3Z4JCwxuj2/Of0+eDz9+rw9Z68z8/n8sHe8sbT3Ju6zuDv96nE1Onw9Nbh6cvX39Hq89Hq8u77/srW3tbh54Kku8ba56TD1u37/vL8/vL8/9ft9ebu8+Ps8bzM1Ymsw7XR4Nnj6Yanvsnj8qrI2Or2/NTf5tvl68vY3+r3/HqdtNji6OXt8eDz+dLc477c7bDO3t7n7d7v9s3Z4dbs9N/y98Pd6PX+/8/b4f7//+Hp7tDo8vv//+fu84GjunKWro6uxHqctOfu9P///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAAAAAAALAAAAAAMAAwAAAeEgCJfg4RfWlo5KlpgjI2OOklWBwcBAVmXCQlXHAUFVBkGBjMUNzZOEy81IF2sXUZCH0QrDyhPGzICAkohUj4XHhoQKQsLGDgWUTFIJxUjUy0uWNIkQxE9W9gMDD9BCgpLAEBNXl5H5F40DlUDEkxc71wICDwlDQBQHQ0EBEUsJjswBgQCADs=';
```
### 1. drawImage
Теперь мы перейдём к рисованию изображения на холсте. Для этого существует функция drawImage.
```
drawImage(image, x, y) // Где x и y это координаты левого верхнего угла изображения, а первый параметр это изображение
```
Стоит отметить что загрузка изображения происходит сразу после присвоения объекту источника изображения, и если оно не загрузится полностью к моменту вызова функции отрисовки, то оно попросту не будет нарисовано на холсте. Для избежания этой ситуации используется такая конструкция:
```
var img = new Image(); // Новый объект
img.onload = function() { // Событие которое будет исполнено в момент когда изображение будет загружено
/*
Какие-либо действия
*/
}
img.src = 'myImage.png'; // Путь к изображению
```
Вот мы наверное и дошли до момента когда можно рассмотреть элементарный пример:
```
imgExample
Обновите браузер
var example = document.getElementById("example"),
ctx = example.getContext('2d'), // Контекст
pic = new Image(); // "Создаём" изображение
pic.src = 'http://habrahabr.ru/i/nocopypast.png'; // Источник изображения, позаимствовано на хабре
pic.onload = function() { // Событие onLoad, ждём момента пока загрузится изображение
ctx.drawImage(pic, 0, 0); // Рисуем изображение от точки с координатами 0, 0
}
```
Ссылка на [фидл с примерами](http://jsfiddle.net/shpaker/uwCFS/) для этой стать.
### 2. Тянем-потянем
Но если бы всё ограничивалось простым рисованием изображением, то отдельную статью можно было бы не писать, а ограничиться подпунктом «Изображения» в предыдущем посте. Итак теперь мы попытаемся масштабировать изображение и для этого существует ещё один способ вызова функции drawImage:
```
drawImage(image, x, y, width, height) // параметры width, height меняют ширину и высоту изображения
```
Возьмём предыдущий пример и внесём в drawImage некоторые изменения:
```
ctx.drawImage(pic, 0, 0, 300, 150);
```
Ссылка на [фидл с примерами](http://jsfiddle.net/shpaker/uwCFS/) для этой стать.
### 3. Рисуем фрагмент изображения
Третий вызов drawImage с восемью параметрами, выглядит приблизительно так:
```
drawImage(image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight);
// Первый параметр указывает на изображение
// sx, sy, sWidth, sHeight указывают параметры фрагмента на изображение-источнике
// dx, dy, dWidth, dHeight ответственны за координаты отрисовки фрагмента на холсте
```
Возьмём всё тот же пример и подкорректируем функцию drawImage в третий раз:
```
ctx.drawImage(pic, 25, 42, 85, 55, 0, 0, 170, 110);
```
Ссылка на [фидл с примерами](http://jsfiddle.net/shpaker/uwCFS/) для этой стать.
### 4. Задача
Теперь осталось закрепить всё пройденное на практическом примере. Как и в том примере это будет небольшая карта, только не из какой-то существовавшей игры, а придуманной нами. Для того что бы он нормально работал нам необходимо будет создать в любом графическом редакторе изображение составленное из фрагментов которые нам будут нужны что бы нарисовать дорожку, домик и полянку. Вообще фрагменты карты называются тайлами, а файл в котором они все собраны в одно изображение называется тайлсетом. Вот это изображение я нарисовал собственноручно в программе Pinta под Ubuntu.
Итак, размерность будет 8 на 8 квадратных блоков шириной 32 пиксела. На карте нам необходимо будет изобразить домик и дорожку. Элементы домика нарисованы ручками, можно сказать каждый кирпичик. Траву и песок делалось путём заливки облости соответствующим цветом и добавки шума. Всё конечно представленно очень примитивно, но показательно.
Рассмотрим с пинцетом такой кусок кода как var map = [[{x:1, y: 4}… значения x и y указывают какой элемент из картинки брать. Т.е. если исходный рисунок разбить на квадрат 32×32 то станет понятней.
И **форэкзампл**:
```
imgExample
Обновите браузер
var example = document.getElementById('example'), // Задаём контекст
ctx = example.getContext('2d'), // Контекст холста
cellSize = 32, // Размер одной ячейки на карте
pic = new Image(), // "Создаём" изображение
map = // Карта уровня двумерным массивом
[
[{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4}], // 1ый ряд
[{x:1,y:4},{x:1,y:1},{x:2,y:1},{x:3,y:1},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4}], // 2ый ряд
[{x:1,y:4},{x:1,y:2},{x:2,y:2},{x:3,y:2},{x:1,y:4},{x:1,y:3},{x:1,y:3},{x:1,y:3}], // 3ый ряд
[{x:1,y:4},{x:3,y:4},{x:2,y:3},{x:3,y:4},{x:1,y:4},{x:1,y:3},{x:1,y:4},{x:1,y:4}], // 4ый ряд
[{x:1,y:4},{x:3,y:4},{x:2,y:4},{x:3,y:4},{x:1,y:4},{x:1,y:3},{x:1,y:4},{x:1,y:4}], // 5ый ряд
[{x:1,y:4},{x:1,y:4},{x:1,y:3},{x:1,y:4},{x:1,y:4},{x:1,y:3},{x:1,y:4},{x:1,y:4}], // 6ый ряд
[{x:1,y:4},{x:1,y:4},{x:1,y:3},{x:1,y:3},{x:1,y:3},{x:1,y:3},{x:1,y:4},{x:1,y:4}], // 7ый ряд
[{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4}] // 8ый ряд
]; // Первая и вторая координата (x и y соответственно) задают фрагмент в исходном изображении
// Размер холста равный 8х8 клеток
example.width = 8 \* cellSize;
example.height = 8 \* cellSize;
pic.src = 'https://habrastorage.org/getpro/habr/post\_images/e85/727/cb1/e85727cb1a88099325eaf5b243d4c41f.png';
pic.onload = function() { // Событие onLoad, ждём момента пока загрузится изображение
for (var j = 0 ; j < 8; j ++)
for (var i = 0; i < 8; i ++)
// перебираем все значения массива 'карта' и в зависимости от координат вырисовываем нужный нам фрагмент
ctx.drawImage(pic, (map[i][j].x-1)\*cellSize, (map[i][j].y-1)\*cellSize, 32, 32, j\*cellSize, i\*cellSize, 32, 32);
}
```
[Посмотреть пример](http://jsfiddle.net/shpaker/shGCG/) | https://habr.com/ru/post/111385/ | null | ru | null |
# Золотое сечение в Web
К сожалению, в наше время перенасыщенное рекламой, у многих сложился стереотип, что дизайн – это просто симпатичная и яркая картинка.
Многие начинающие дизайнеры не задумываются, что прежде всего, дизайн должен быть эффективным, т.е. доносить до конечного пользователя конкретную цель.
Сделав сногсшибательную картинку, иногда видишь, что все-таки в ней что-то не так. И это отражается на потребителе, когда продажи товара просто не идут. В отличие от конкурента, у которого совершенно пустая белая картинка, с парой выражений и логотипом.
На тему эффективного дизайна можно привести несколько ссылок:
[10 принципов эффективного веб-дизайна](http://habrahabr.ru/blog/ui_design_and_usability/35242.html)
[Пять дизайнерских правил применяемых в Web](http://forma.uz/web/5-elements-of-design-applied-to-the-we/#start)
Это из того что вспомнилось. Рекомендуется почитать блог [Дизайн пользовательских интерфейсов и юзабилити](http://habrahabr.ru/blog/ui_design_and_usability/).
Это, скажем так преамбула, которую можно отнести к любому направлению дизайна. В этой статье мы поговорим **о Web-дизайне и о применении Золотого Сечения и Правила Третей**.
Одной из главных задач эффективного дизайна в Web – это ясность и интуитивность. А также концентрация внимания пользователя на нужных местах страницы. Как этого добиваются?
Существует множество путей, например, использовать сетки, можно предпочесть самые элементарные решения или сосредоточится на простоте и удобстве.
Но в любом случае, Вы должны быть уверены, что у пользователей присутствует ощущение баланса, порядка, гармонии и комфорта. Как раз в этом случае, применение золотого сечения становится важным этапом при разработке дизайна web-страницы.
Золотое сечение
---------------
Прежде всего, что такое Золотое сечение?
По материалам [Википедии](http://ru.wikipedia.org/wiki/Золотое_сечение):
**Золото́е сече́ние** (золотая пропорция, деление в крайнем и среднем отношении, гармоническое деление, число Фидия, φ) — деление отрезка на части в таком соотношении, при котором большая часть относится к меньшей, как сумма к большей. Например, деление отрезка АС на две части таким образом, что большая его часть АВ относится к меньшей ВС так, как весь отрезок АС относится к АВ (т. е. |АВ| / |ВС| = |АС| / |АВ|).
Эту пропорцию принято обозначать греческой буквой φ (встречается также обозначение τ) и она равна 1.618… (число бесконечное)
В дошедшей до нас античной литературе золотое сечение впервые встречается в «Началах» Евклида (3 в. до н.э.). Термин «золотое сечение» был введён гораздо позднее Леонардо да Винчи, который использовал золотое сечение как пропорции «идеального человеческого тела». Золотое сечение имеет множество замечательных свойств, но ещё больше свойств вымышленных, следуя Леонардо да Винчи, многие люди «стремятся найти» золотое сечение во всём что между полутора и двумя.
На тему Золотого сечения, написано масса литературы, поэтому не буду расписывать в деталях, что это такое. Для тех, кто в первый раз слышит это понятие, настоятельно рекомендую почитать, по ниже приведенным ссылкам:
Самый простой вариант — [запрос по слову «Золотое сечение» в Google](http://www.google.ru/search?q=%D0%97%D0%BE%D0%BB%D0%BE%D1%82%D0%BE%D0%B5+%D0%A1%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D0%B5&sourceid=navclient-ff&ie=UTF-8&rlz=1B3GGGL_enUZ250UZ250)
Но, могу выделить наиболее интересные ссылки:
[Божественные пропорции золотого сечения](http://arbuz.narod.ru/zol.htm)
[Золотое сечение](http://n-t.ru/tp/iz/zs.htm)
[Музей гормонии и Золотого сечения](http://goldenmuseum.com/index_rus.html)
Золотое сечение в Web
---------------------
Рис. 1: Золотое сечение на практике в Web
На Рис. 1 демонстрируется принцип Золотого сечения. Допустим, Ваш макет фиксированной ширины – 960px и содержит два основных блока, контент и сайдбар. Как бы вы вычислили ширину колнок, не зная волшебной цифры 1.618?
Конечно, web-дизайн не должен быть строго привязан к Золотому сечению. Но в некоторых случаях, эта пропорция помогла бы улучшить визуальную взаимосвязь всего макета.
Для примера, рассмотрим дизайн блога [The 404 Blog](http://404uxd.com/).
Рис. 2: [The 404 Blog](http://404uxd.com/)
Приятная композиция, спокойные цвета. Никакого визуального напряжения и никакой **агрессивной концентрации** на нужных местах блога (хотя сейчас это в моде, что делается с помощью ярких деталей).
Но дизайн блога не придерживается принципов Золотого сечения. И что интересно, чаще всего пользователи этого просто не чувствуют, так они интуитивно разделают макет на два отдельных блока (шириной 583px `(630px - 31px - 31px)` и 299px `(330px - 31px)`).
Дело в том, что свободное пространство на блоге является пассивным. Отношение между двумя основными блоками – `630px : 330px ≈ 1.91 ≠ 1.62`.
Причина, из-за которой макет выглядит почти идеально сбалансированным, хоть и не придерживается Золотого сечения, в том, что отношения между блоками равны.
Кстати, вот несколько удобных приложений, которые помогут с вычислениями Золотого сечения без калькулятора.
1. [Phiculator](http://www.thismanslife.co.uk/phiculator) – маленькое и удобное приложение, которое из любого введенного числа, автоматически вычислит, соответствующее Золотому сечению, значение.
2. [Golden Section Ratio Design Tool](http://www.atrise.com/golden-section/) – мощный инструмент, который поможет избежать рутинных операций при работе с компоновкой объектов и форм. Результат Вы можете видеть на лету.
Правило Третей
--------------
Это принцип построения композиции, основанный на упрощенном правиле золотого сечения. Правило третей в основном используется фотографами.
При определении зрительных центров кадр, как правило, делится линиями, параллельными его сторонам, в пропорциях 3:5, 2:3 или 1:2 (берутся последовательно идущие числа Фибоначчи). Последний вариант дает деление кадра на три равные части (трети) вдоль каждой из сторон.
Несмотря на заметное отличие положения центров внимания, полученных по правилу третей, от золотого сечения, технологическая простота и наглядность сделали эту схему композиции популярной.
Рис. 4: Фотография демонстрирует использование Правила Третей
Чаще всего, невозможно, да и просто бесполезно использовать все четыре точки, для выделения на первый план самых важных деталей макета сайта. Но, не менее успешно использовать одну или две точки, как кстати обычно и делают.
Левый верхний угол обычно самый «сильный», так как пользователи просматривают сайт по принципу формы буквы «F».
Рассмотрим Правило Третей на примере. Допустим, у нас есть макет ширина которого 960px. Высота варьируется между 750 и 950px.
Как разделить макет на 9 равных частей? Несколько несложных шагов:
1. Разделите ширину вашего макета на 3. 960px / 3 = 320px.
2. Разделите высоту вашего макета на 3. ((750px + 950px) / 2) / 3 ≈ 285px.
3. Размер прямоугольника должен быть примерно 320pх на 285px.
4. Постройте сетку прямоугольников, рисуя линии, проходящие через концы прямоугольников.
5. Разместите самые важные элементы на точках пересечения горизонтальных и вертикальных линий.
В качестве примера из жизни, можно привести проект [demandware.com](http://demandware.com).
Хоть цветовая гамма сайта и является яркой и красочной, тем не менее, на нем все кажется предельно простым и понятным.
Рис. 5: [Demandware](http://demandware.com)
Если рассматривать эффективность дизайна этого проекта, то сразу можно увидеть прекрасный баланс, за счет совершенного использования Правила Третей.
Обратите внимание, на двух из четырех пересечениях, выделяется самая важная информация, имена та, на которой компания хочет сделать акцент (отмеченно розовыми квадратами).
Также замечательно расположен навигационный блок, на втором пересечении линий. Это является действительно действенным (или эффективным) дизайном.
Заключение
----------
В некоторых случаях, применение Золотого сечения и Правила Третей может значительно улучшить взаимосвязь вашего проекта с посетителями.
При пропорции 1:1.62, ваш сайт становится более удобным и более структурированным для просмотра.
И это работает не только в Web-дизайне. | https://habr.com/ru/post/27465/ | null | ru | null |
# TypeScript на сервере
TypeScript на сервере
=====================
TypeScript последнее время быстро набирает популярность, в особенности благодаря распространению Angular2. При этом на сервере TypeScript пока не особенно популярен. Многие хотели бы попробовать TypeScript, но не имеют возможности / желания долго разбираться с его настройкой. В этой статье я расскажу как можно с минимальными сложностями начать использовать TS на сервере, так что он почти не будет отличаться от ES6/Next кода, а так же зачем это нужно.
TypeScript это несколько аспектов использования — транспайлер ES кода (как Babel), опциональная типизация кода (как Flow), дополнительные правила валидации (часть функций линтера), языковые конструкции, которых нет в JS (как CoffeeScript), типизация внешних библиотек.
При этом эти аспекты во многом независимы и их использование опционально. Когда я начинал с TS мне было важно быстро настроить окружение поэтому я использовал ограниченный набор возможностей, в дальнейшем мне понравился этот режим использования и сейчас я использую его в большинстве проектов. Это дает достаточно много преимуществ, при этом код почти идентичен последней версии JS ES6/Next (легко интегрировать примеры на JS, легко преобразовать в JS код). В дальнейшем при необходимости в проекте можно использовать больше продвинутых возможностей. Рассмотрим подробнее различные аспекты TS.
TypeScript как транспайлер
--------------------------
Транспалировать или нет? Большинство новых проектов использует ES6, это очень большое дополнение JS языка, которое действительно имеет значение для комфорта и эффективности разработки. В последней LTS версии нода ES6 почти полностью поддерживается и может использоваться без дополнительной транспаляции. Если вы еще не знакомы с ES6 существует огромное количество вводных статей, например об этом можно почитать [тут](https://learn.javascript.ru/es-modern).
Кроме ES6 одной из основных новых фич языка является async/await, которая поддерживается в TS. Это новый подход к работе с асинхронным кодом, следующий шаг после колбэков и промисов. Подробнее о преимуществах [здесь](https://habrahabr.ru/company/ruvds/blog/326074/). Поддержка async/await уже есть в ноде, но пока не в LTS версии. При написании нового проекта имеет смысл сразу использовать async/awiat. Во-первых, это гораздо удобнее, во-вторых, для преобразования кода из промисов в async/awiat в дальнейшем потребуются дополнительные усилия и лучше это сделать сразу.
Помимо этого TS поддерживает импортирование в ES6 стиле (import… from вместо require), поддержка в ноде для этого будет еще не скоро, т.к. есть ряд особенностей подробнее [здесь](https://medium.com/the-node-js-collection/an-update-on-es6-modules-in-node-js-42c958b890c). Но в TS это можно использовать уже сейчас и хотя это не будет 100% реализацией спецификации, в подавляющем количестве случаев это не важно.
Для того чтобы легко отлаживать код локально рекомендуется на машине разработчика компилировать код в ES6, т.е. локально вам нужна версия нода 6.x, при этом в продакшине может использоваться нод более старых версий, тогда при компиляции для продакшина надо дополнительно компилировать из ES6 в ES5, сразу через TS или с использованием Babel.
Типизация кода
--------------
Зачем это нужно? Строгая типизация имеет несколько преимуществ: описав сигнатуры через типы, можно отловить много ошибок на момент компиляции, например если вы описали что метод принимает число, а передаете строку, то TS компилятор вам сразу об этом скажет. Кроме этого описание типов позволяет IDE давать более точные подсказки и помогает писать код быстрее. Кроме того для других языков программирования строгая типизация улучшает производительность, но для TS это не актуально, так как в результате компиляции генерируется JS код в котором аннотации типов отсутствуют.
Строгая типизация имеет также и свои недостатки: больше времени надо на описание типов, типы иногда ухудшают читабельность кода, иногда есть проблемы с преобразованием одного типа в другой.
Хорошие новости — в TS типизация опциональна. На уровне компилятора у каждой переменной/параметра есть тип, при этом если в TS коде не указан, то предполагается тип any, что значит переменная может принимать значение любого типа и TS это допускает.
Вы можете использовать столько типизации, сколько посчитаете нужным. Для простых проектов я почти не использую дополнительную типизацию, мне достаточно базовых проверок TS. Но при написании библиотеки или работе с большим сложным проектом, типизация имеет смысл и оправдывает дополнительное время необходимое на ее внедрение.
Если вы только начинаете работу с TS или мигрируете JS код, стоит начать без типизации и добавлять ее постепенно. Тогда вы сможете оценить реальную пользу ее применения.
Типизация внешних библиотек
---------------------------
TS позволяет описывать JS библиотеки с помощью файлов деклараций (declaration files \*.d.ts). При этом TS достаточно гибок и поддерживает различные типы библиотек и режимы их использования (глобальные библиотеки, модули, UMP и пр). Почти сразу после появления TS, появился oupensource репозиторий [DefinitelyTyped](https://github.com/DefinitelyTyped/DefinitelyTyped), в котором средствами энтузиастов добавлялись и обновлялись файлы деклараций для множества различных JS библиотек.
Изначально разработчики TS не занимались вопросом менеджмента файлов деклараций и появились проекты tsd и typings, которые позволяли устанавливать эти файлы похожим образом на установку npm пакетов. Начиная с TypeScript 2.0 можно использовать npm для загрузки файлов деклараций. Подробнее [здесь](https://www.typescriptlang.org/docs/handbook/declaration-files/consumption.html).
Для разработки на ноде с TS вам как минимум понадобится файл деклараций для нода
```
npm install -D @types/node
```
Это установит декларации Node API такие, как глобальные require/process/globals, стандартных модули fs/path/stream и прочее. В этом пакете описаны node API последней версии 7.x, что должно подойти и для более старых версий нода.
В более ранних версиях TS, каждый нод модуль должен был быть объявлен. Либо с помощью декларативного файла, либо через заглушку any.
```
declare module "my-module";
```
Начиная с версии TS 2.1, описание модуля не является обязательным, если его нет, то предполагается, что модуль имеет тип any (можно вызывать произвольный метод/свойство). Тем не менее TS проверяет то что модуль установлен (загружен), т.е. вы не сможете сбилдить проект пока не установите его npm пакеты.
Следует использовать файлы деклараций с осторожностью, особенно начинающим. Несмотря на преимущества проверки использования сигнатур и лучшее авто дополнение, файлы деклараций имеют так же ряд проблем.
Чаще всего файлы деклараций и сами библиотеки пишут разные люди и они не полностью синхронизированы. И бывает в документации описывается валидная сигнатура, которой нет в файле декларации. Кроме того при использовании файлов деклараций, скорее всего придется использовать больше типов в вашем коде и он уже будет сильно отличаться от чистого JS кода.
В своих проектах я часто ограничиваюсь декларациями для node и опционально для lodash.
Языковые конструкции, специфичные для TS
----------------------------------------
Есть несколько языковых конструкций в TS, которые отсутствуют в JS стандарте. Например Enum. Он существует в 2х вариантах — enum и const enum.
Const enum позволяет задать типизированные имена для числовых значений, например:
```
const enum Size {
Small = 1,
Medium,
Large
}
let size = Size.Large; //будет заменено на "let size = 3" после компиляции
```
Стандартный enum дает больше возможностей:
```
enum Size {
Small = 1,
Medium,
Large
}
let size = Size.Large; //size = 3 после присвоения
let sizeName = Size[Size.Large] // sizeName = 'Large' после присвоения
```
Это достигается тем, что стандартный TS enum компилируется в конструкцию вида:
```
var Size;
(function (Size) {
Size[Size["Small"] = 1] = "Small";
Size[Size["Medium"] = 2] = "Medium";
Size[Size["Large"] = 3] = "Large";
})(Size || (Size = {}));
```
С одной стороны это может быть удобно, но при этом ваш код становится не совместимым с JS, разработчику без знания TS будет сложнее с этим разобраться, могут быть проблемы с отладкой.
Лучше избегать таких конструкций при минималистическом использовании TS.
Практические особенности использования TS
-----------------------------------------
В TS есть ряд особенностей, которые полезно знать начинающему разработчику.
#### Импорт модулей
Импортировать внешние модули нужно так:
```
import * as fs from 'fs';
//в JS можно
import fs from 'fs';
//или
import * fs from 'fs';
```
Свои модули можно писать c использованием export default
```
//файл модуля greeter.ts
export default {
hi,
hey
}
function hi() {console.log('hi');}
function hey() {console.log('hey');}
//другой модуль
import greeter from './greeter';
greeter.hi();
```
Можно так же использовать именные экспорты согласно стандарту ES6. Подробнее [здесь](https://learn.javascript.ru/modules).
#### Приведение к типу any
Иногда бывает, что TS не дает использовать переменную как вам необходимо указывая на ее неправильный тип. В этом случае всегда можно привести ее к типу any.
```
let sayHello = (name: string) => {
console.log(`Hello, ${name}!`);
};
let x = 20;
sayHello(x); //ошибка компиляции, у переменной x числовой, а не строковый тип
sayHello(x as any); //ок
sayHello(x); //тоже ок
```
Это не очень хорошо, и следует этого избегать, но иногда удобно быстро решить проблему таким образом.
В случае если у объекта есть свойства, которые изначально отсутствуют, лучше сразу задать их пустыми иначе TS будет жаловаться на неправильный тип.
```
let myObj = {
name: 'my_obj',
value: 24,
tag: null
}
if (myObj.value > 20) {
myObj.tag = 'xyz';
}
```
#### Опциональные параметры в методах
Если вы объявляете метод с определенным количеством аргументов, то TS будет требовать точного соответствия. Для того чтобы это работало как в JS, нужно использовать опциональные параметры.
```
function doAction(action, title = null) {
if (title) {
console.log(`Doing action ${title}...`);
}
action();
}
...
doAction(() => {console.log('Files were removed!')}, 'Delete');
doAction(() => {console.log('Project was created!')});
```
#### Точечная типизация и nullable типы
Вы можете точечно добавлять типизацию, там где это имеет наибольший смысл, например, в методах, которые принимают параметры в виде объекта или строковые параметры из определенного допустимого набора
```
interface CommandOptions {
path: string,
params: string[],
title?: string // параметр опционалный
}
function executeCommand(command, options: CommandOptions) {
//...
}
type Color = 'red' | 'black' | 'white';
function log(message, color: Color) {
///...
}
logger.log('hey', 'black'); //ок, одно из валидных значений
logger.log('ho', 'yellow'); //ошибка компиляции
```
Настройка окружения
-------------------
Для работы с TS необходимо немного больше времени на настройку окружения. TS поддерживается в большинстве IDE/редакторах для JS. Наилучшая поддержка авто дополнения, рефакторинга и, главное, отладки в WebStorm и VS Code.
Разработчики VS Code тесно сотрудничают с разработчиками TS, поэтому тут поддержка TS самая лучшая.
Подробнее о настройке компиляции и отладки: для WebStorm [здесь](https://blog.jetbrains.com/webstorm/2016/03/how-to-compile-typescript-in-webstorm/) и для VS Code [здесь](https://code.visualstudio.com/docs/languages/typescript) и [здесь](https://code.visualstudio.com/docs/nodejs/nodejs-debugging).
После установки typescript npm пакета глобально компилятор доступен как глобальная команда tsc. Можно передавать различные параметры компиляции через командную строку или через файл настроек. По умолчанию компилятор пытается использовать *tsconfig.json*. Здесь можно указать параметры компиляции, а также какие файлы должны быть включены/исключены. Подробнее о настройках на сайте документации [здесь](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html).
Базовый tsconfig для node проекта с кодом в папке src может выглядеть так:
```
{
"compilerOptions": {
"target": "es6", //компилируем в es6, можно использовать es5 для старых версий нода
"module": "commonjs", //импорт модулей преобразуется в commonjs (node require)
"sourceMap": true, //генерировать sourceMaps, нужно для отладки
"outDir": "build/src", //проект билдится из папки /src в папку /build/src
"rootDir": "src"
},
//указывает что включаться должны только файлы из папки /src
"include": [
"src/**/*"
]
}
```
TS берет на себя много функций линтера. Например использование необъявленных глобальных переменных в TS не допустимо и будет давать ошибку на момент компиляции. Тем не менее TS не накладывает никаких ограничений на стиль написания кода. Этот вопрос во многом дело вкуса и нет общепринятого правильного подхода, но все сходятся во мнении, что в проекте должен быть использован единый стиль. В этом помогает использование TSLint — линтера для TS.
Для его использования установите tslint глобально:
```
npm install -g tslint
```
Добавьте файл tslint.config с необходимыми правилами.
```
{
"rules": {
//использовать одинарные кавычки для строковых констант
"quotemark": [true, "single"],
//обязательное использование точки с запятой (как в C# или Java)
"semicolon": [true]
//другие правила...
}
}
```
Можно выполнить tslint проверку через командную строку
```
tslint -p tsconfig.json //нужно указать файл конфигурации TS проекта
```
или настроить TSLint в IDE. Подробности настройки для [WebStorm](https://www.jetbrains.com/help/webstorm/2017.1/tslint.html) и [VS Code](https://marketplace.visualstudio.com/items?itemName=eg2.tslint).
Build App
---------
Я разрабатываю CLI билд систему [build-app](https://github.com/build-js-app/build-app), которая заточена под разработку full-stack JS приложений с back-end на ноде и SPA клиенте на одном из современных клиентских фреймворков (React/Vue/Angular2). Помимо самой билд системы в комплекте идет набор темплейтов от простого "Hello World" приложения, до реализации базовой функциональности простого веб сайта, с сохранением данных (SQL/NoSql), авторизацией, логированием отправкой имейлов и т.д.
Большинство темплейтов используют TS для серверной части и могут использоваться как пример описанного в статье подхода.
Кроме того в build-app помогает с настройкой окружения для TS: при создании нового проекта можно сгенерировать настройки для IDE (VS Code или WebStorm), есть опция запуска проекта в режиме watch — при изменении кода проект перезапускаться и есть встроенный скрипт сборки проекта для продакшина.
Подробнее об самой билд системе в ридми проекта.
Исходники кода темпелйтов можно посмотреть без использования build-app непосредственно в их репозиториях: [Simple Template](https://github.com/build-js-app/template-simple-server/tree/ts) и [Full template (mongo)](https://github.com/build-js-app/template-full-server/tree/mongo).
Буду рад вашим замечаниям. | https://habr.com/ru/post/328466/ | null | ru | null |
# Использование flex-config.xml
Всем привет!
Коротенький пост для новичков, о том как использовать конфигурационный файл для установки параметров компилятора.
Что такое конфигурационный файл и для чего он нужен? Данный файл это ни что иное как xml файл, содержащий параметры компилятора. И нужен он собственно для того чтобы управлять компилятором. Указать путь к конфигурационному файлу можно используя параметр компилятора -load-config.
По умолчанию Flex SDK включает в себя конфигурационный файл с именем flex-config.xml.
Этот файл содержит параметры компилятора по умолчанию для приложения и компонентов компилятора. Файл flex-config.xml располагается в директории flex\_install\_dir/frameworks вашего Flex SDK. Т.е при осуществлении сборки из командной строки, по умолчанию используется именно он.
Flash Builder не использует файл flex-config.xml из Flex SDK, и во время сборки он генерирует свой конфигурационный файл, на основании настроек проекта. Увидеть содержимое с генерированного файла конфигурации, можно использовав параметр компилятора -dump-config myapp-config.xml. Тогда при компиляции проекта, будет создан в файл myapp-config.xml который будет содержать текущую конфигурацию компилятора.
Для примера, создадим свой конфигурационный файл с именем my-flex-config.xml в котором определим пару констант для условной компиляции:
В созданном файле, опишем базовую структуру файла:
```
xml version="1.0"?
CONFIG::debug
true
CONFIG::console
true
```
[Описание синтаксиса конфигурационного файла](http://habrahabr.ru/post/155207/)
Ровно тоже самое можно сделать указав из командной строки параметр компилятора
-define=CONFIG::debug,true -define=CONFIG::console,true.
По сути конфигурационный файл позволяет указать все параметры компилятора в одном файле.
Для того чтобы добавить параметр компилятора -load-config во Flash Builder'е, нажмите правой кнопкой мыши на проекте, выберите пункт Properties (Свойства), далее пункт Action Script Compiler и в текстовой области Additional Compiler Argumets, добавьте -load-config+=my-flex-config.xml
В данном случае" += " означает что мы дополняем основной конфигурационный файл своим конфиг. файлом. Если нужно полностью заменить файл конфигурации, то указываем его через " = ". | https://habr.com/ru/post/155177/ | null | ru | null |
# Внедрение подхода «Self-Service» для самостоятельного анализа данных
Инструменты Business Intelligence (BI) за последние несколько лет проникли почти во все виды бизнеса, а изучению данных уделяется все больше внимания и выделяется больше ресурсов. Если говорить об IT-компаниях, то здесь, наверное, большинству понятно предназначение Business Intelligence и то, какую ценность для компании представляет анализ внутренних данных.
[](https://habr.com/ru/company/playrix/blog/551470/)
В Playrix на подготовку и анализ данных выделяется значительное количество ресурсов, мы стараемся использовать передовые технологии и серьёзно подходим к обучению сотрудников. Компания входит в топ-3 разработчиков мобильных игр в мире, поэтому мы стараемся держать соответствующий уровень в анализе данных и конкретно в Business Intelligence. Ежедневно в наши игры играют более 27 млн пользователей, и эта цифра может дать примерное представление об объемах данных, генерируемых мобильными устройствами каждый день. Кроме этого, данные забираются из десятков сервисов в различных форматах, после чего они агрегируются и загружаются в наши хранилища. В качестве Data Lake мы работаем с AWS S3, а Data Warehouse на AWS Redshift и PostgreSQL применяется ограниченно. Эти базы данных мы используем для аналитики. Redshift быстрее, но дороже, поэтому там мы храним самые востребованные данные. PostgreSQL дешевле и медленнее, там хранятся либо небольшие объемы данных, либо данные, скорость чтения которых некритична. Для предагрегированных данных используем Hadoop кластер и Impala.
Основным инструментом BI в Playrix является Tableau. Этот продукт достаточно хорошо известен в мире, имеет широкие возможности для анализа и визуализации данных, работы с различными источниками. Кроме того, для простых задач анализа не приходится писать код, поэтому можно обучить пользователей разных отделов самостоятельно анализировать свои бизнес-данные. Сам вендор инструмента Tableau Software также позиционирует свой продукт как инструмент для самостоятельного анализа данных, то есть для Self-Service.
Есть два основных подхода анализа данных в BI:
1. **Reporting Factory**. В этом подходе есть отдел и/или люди, разрабатывающие отчеты для бизнес-пользователей.
2. **Self-Service.** В этом подходе бизнес-пользователи делают отчеты и строят аналитику своих процессов самостоятельно.
Первый подход традиционный, и в большинстве компаний работает такая фабрика производства отчетов в масштабах всего предприятия. Второй подход относительно новый, особенно для России. Хорош он тем, что данные исследуют сами бизнес-пользователи – они намного лучше знают свои локальные процессы. Это помогает разгружать разработчиков, избавлять их от необходимости каждый раз погружаться в особенности процессов команд и заниматься созданием самых простых отчетов. Это помогает решить, наверное, самую большую проблему — проблему преодоления пропасти между бизнес-пользователями и разработчиками. Ведь основная проблема подхода Reporting Factory как раз в том, что большая часть отчетов может остаться невостребованной только из-за того, что программисты-разработчики неверно понимают проблемы бизнес-пользователей и, соответственно, создают ненужные отчеты, которые либо переделываются потом, либо просто не используются.
В Playrix изначально разработкой отчетов в компании занимались программисты и аналитики, то есть специалисты, ежедневно работающие с данными. Но компания развивается очень стремительно, и по мере роста потребностей пользователей в отчетах разработчики отчетов перестали успевать в срок решать все задачи по их созданию и поддержке. Тогда и встал вопрос либо о расширении группы разработки BI, либо о передаче компетенций в другие отделы. Направление **Self Service** нам казалось перспективным, поэтому мы решили научить бизнес-пользователей самостоятельно создавать свои проекты и анализировать данные.
В Playrix подразделение Business Intelligence (BI Team) работает над задачами:
1. Сбора, подготовки и хранения данных.
2. Разработки внутренних сервисов аналитики.
3. Интеграции с внешними сервисами.
4. Разработки web-интерфейсов.
5. Разработки отчетности в Tableau.
Мы занимаемся автоматизацией внутренних процессов и аналитики. Упрощенно нашу структуру можно представить при помощи схемы:
*Мини-команды BI Team*
Прямоугольниками здесь обозначены мини-команды. Слева — команды бэка, справа — команды фронта. Каждая из них обладает достаточными компетенциями для работы с задачами смежных команд и берут их на себя при перегруженности остальных команд.
В BI Team построен полный цикл разработки: от сбора требований до разворачивания на продуктовом окружении и последующей поддержки. В каждой мини-команде есть свой системный аналитик, разработчики и инженеры по тестированию. Они выполняют функцию **Reporting Factory**, подготавливая данные и отчеты для внутреннего использования.
Здесь важно отметить, что в большинстве проектов Tableau мы разрабатываем не простые отчеты, которые обычно показывают на демонстрациях, а инструменты с богатым функционалом, большим набором контролов, широкими возможностями и подключением внешних модулей. Эти инструменты постоянно перерабатываются, добавляются новые фичи.
Однако приходят и простые локальные задачи, которые может решить сам заказчик.
Передача компетенций и запуск пилотного проекта
-----------------------------------------------
По нашему опыту работы и общения с другими компаниями основными проблемами при передаче data-компентенций бизнес-пользователям становятся:
1. Нежелание самих пользователей изучать новые инструменты и работать с данными.
2. Отсутствие поддержки со стороны менеджмента (инвестиции в обучение, лицензии и т.п.).
Поддержка со стороны менеджмента у нас колоссальная, более того, менеджмент и предложил внедрять Self-Service. Желание у пользователей изучать работу с данными и Tableau тоже есть — это ребятам интересно, плюс анализ данных сейчас — очень существенный скилл, который большинству точно пригодится в будущем.
Внедрение новой идеологии сразу во всей компании обычно требует много ресурсов и нервов, поэтому мы начали с пилота. Пилотный проект Self-Service запустили в отделе User Acquisition полтора года назад и в процессе пилота копили ошибки и опыт, чтобы передать их другим отделам в будущем.
Направление User Acquisition работает над задачами увеличения аудитории наших продуктов, анализирует пути закупки трафика и выбирает, в какие направления привлечения пользователей стоит инвестировать средства компании. Раньше для этого направления готовились отчеты командой BI, либо ребята сами обрабатывали выгрузки из базы при помощи Excel или Google Sheets. Но в динамичной среде развития такой анализ влечет задержки, а число анализируемых данных лимитировано возможностями этих инструментов.
На старте пилота мы провели базовое обучение сотрудников работе с Tableau, сделали первый общий источник данных — таблицу в базе Redshift, в которой было более 500 млн строк и необходимые метрики. Следует отметить что Redshift — это столбчатая (или колоночная) база данных, и эта база отдает данные намного быстрее реляционных БД. Пилотная таблица в Redshift была действительно большой для людей, которые никогда больше чем с 1 млн строк одновременно не работали. Но это был вызов для ребят, чтобы научиться работать с данными таких объемов.
Мы понимали, что проблемы с производительностью начнутся по мере усложнения этих отчетов. Доступа к самой БД пользователям мы не давали, но был реализован источник на сервере Tableau, подключенный в режиме live к таблице в Redshift. У пользователей были лицензии Creator, и они могли подключаться к этому источнику либо с сервера Tableau, разрабатывая отчеты там, либо с Tableau Desktop. Надо сказать, что при разработке отчетов в вебе (у Tableau есть режим web edit) на сервере есть некоторые ограничения. На Tableau Desktop же таких ограничений нет, поэтому мы преимущественно разрабатываем на Desktop. Кроме того, если анализ нужен только одному бизнес-пользователю, не обязательно такие проекты публиковать на сервере — можно работать локально.
Обучение
--------
У нас в компании принято проводить вебинары и knowledgе sharing, в которых каждый сотрудник может рассказать о новых продуктах, фичах или возможностях инструментов, с которыми он работает или которые исследует. Все такие активности записываются и хранятся в нашей базе знаний. Этот процесс работает и в нашей команде, поэтому мы периодически тоже делимся знаниями или готовим фундаментальные обучающие вебинары.
Для всех пользователей, у которых есть лицензии Tableau, мы провели и записали получасовой вебинар по работе с сервером и дашбордами. В нем рассказали о проектах на сервере, работе с нативными контролами всех дашбордов — это верхняя панель (refresh, pause, …). Об этом обязательно надо рассказывать всем пользователям Tableau, чтобы они полноценно могли работать с нативными возможностями и не делали запросы на разработку фич, которые повторяют работу нативных контролов.
Основным препятствием для освоения какого-то инструмента (да и вообще чего-то нового) обычно является страх того, что не получится разобраться и работать с этим функционалом. Поэтому обучение, пожалуй, является самым важным этапом внедрения подхода self-service BI. От него будет сильно зависеть результат внедрения этой модели — приживется ли она в компании вообще и если да, то насколько быстро. На стартовых вебинарах как раз и надо снять барьеры использования Tableau.
Можно выделить две группы вебинаров, которые мы проводили для людей, не знакомых с работами баз данных:
1. Стартовый набор знаний новичка:
* Подключение к данным, типы соединений, типы данных, базовые преобразования данных, нормализация данных (1 час).
* Базовые визуализации, агрегация данных, базовые вычисления (1 час).
2. Сложные вычисления и базовые трюки/элементы, принятые в компании (2 часа).
В первом стартовом вебинаре мы рассматриваем все, что касается подключения к данным и преобразования данных в Tableau. Поскольку у людей обычно есть базовый уровень владения MS Excel, то здеcь важно объяснить, чем принципиально отличается работа в Excel от работы в Tableau. Это очень важный пункт, поскольку нужно переключить человека с логики таблиц с раскрашенными ячейками на логику нормализованных данных БД. На этом же вебинаре мы объясняем работу JOIN, UNION, PIVOT, также затрагиваем Blending. На первом вебинаре мы практически не затрагиваем визуализацию данных, его цель — объяснить, как работать и преобразовывать свои данные для Tableau. Важно, чтобы люди понимали, что данные первичны и большинство проблем возникает на уровне данных, а не на уровне визуализаций.
Второй вебинар по Self-Service имеет целью рассказать о логике построения визуализаций в Tableau. Tableau сильно отличается от других BI инструментов именно тем, что имеет свой движок и свою логику. В других системах, например, в PowerBI, есть набор готовых визуалов (можно скачать дополнительные модули в магазине), но эти модули не кастомизируются. В Tableau же у вас есть фактически чистый лист, на котором можно строить все что угодно. Конечно же, в Tableau есть ShowMe — меню базовых визуализаций, но все эти графики и диаграммы можно и нужно строить по логике работы Tableau. По нашему мнению, если хотите научить кого-то работать с Tableau, то не нужно использовать ShowMe для построения графиков — большая их часть людям не пригодится на старте, а нужно учить именно логике построения визуализаций. Для бизнес-дашбордов достаточно знать, как построить:
1. Time Series. Line/Area Charts (линейные графики),
2. Bar Charts (столбчатые диаграммы),
3. Scatter Plots (диаграммы разброса),
4. Tables (таблицы).
Этого набора визуализаций вполне достаточно для самостоятельного анализа данных.
Time Series: в бизнесе применяются очень часто, поскольку интересно сравнивать метрики в различные периоды времени. У нас в динамике результаты бизнеса смотрят, наверное, все сотрудники компании. Bar Charts используем для сравнения метрик по категориям. Scatter Plots (диаграмма разброса) используются редко, обычно для нахождения корреляций между метриками. Таблицы: то, от чего в бизнес-дашбордах полностью избавиться не удается, но по возможности стараемся минимизировать их число. В таблицах собираем числовые значения метрик по категориям.
То есть мы отправляем людей в свободное плавание после 1 часа обучения работы с данными и 1 часа обучения базовым вычислениям и визуализациям. Далее ребята сами работают со своими данными некоторое время, сталкиваются с проблемами, накапливают опыт, просто набивают руку. Этот этап в среднем занимает 2-4 недели. Естественно, в этот период есть возможность проконсультироваться с командой BI Team, если что-то не получается.
После первого этапа у коллег возникает необходимость совершенствования навыков и изучения новых возможностей. Для этого мы подготовили вебинары углубленного обучения. В них мы показываем, как работать с функциями LOD, табличными функциями, скриптами Python для TabPy. Мы работаем с живыми данными компании, это всегда интереснее фейковых или данных базового датасета Tableau — Superstore. В этих же вебинарах мы рассказываем об основных фичах и трюках Tableau, которые используются на продовых дашбордах, например:
1. Sheet Swapping (замена листов),
2. Агрегация графиков при помощи параметров,
3. Форматы дат и метрик,
4. Отбрасывание неполных периодов при недельных/месячных агрегациях.
Все эти трюки и фичи было принято использовать пару лет назад, поэтому в компании все к ним привыкли, и мы приняли их в стандартах разработки дашбордов. Скрипты Python мы используем для расчета некоторых внутренних метрик, все скрипты уже готовы, и для Self-Service надо понимать, как их вставлять в свои вычисления.
Таким образом, мы проводим только 4 часа вебинаров для старта Self-Service, и этого обычно достаточно, чтобы мотивированный человек начал работать с Tableau и самостоятельно анализировать данные. Кроме того, для дата-аналитиков у нас есть свои вебинары, они находятся в открытом доступе, можно знакомиться и с ними.
Разработка источников данных для Self-Service
---------------------------------------------
После проведения пилотного проекта мы посчитали его успешным и расширили количество пользователей Self-Service. Одной из больших задач была подготовка источников данных для разных команд. Ребята в Self-Service могут работать с 200+ млн строк, поэтому команда Data Engineering должна была придумать, как реализовать такие источники данных. Для большинства аналитических задач мы используем Redshift из-за скорости чтения данных и удобства работы. Но выдавать доступ к базе каждому человеку из Self-Service было рискованно с точки зрения информационной безопасности.
Первой идеей было создание источников с живым подключением к БД, то есть на Tableau Server было опубликовано несколько источников, которые смотрели либо в таблицы, либо в подготовленные view Redshift. В этом случае мы не хранили данные на сервере Tableau, а пользователи через эти источники сами ходили со своих Tableau Desktop (клиентов) в базу. Это работает, когда таблицы небольшие (единицы миллионов) или запросы Tableau не слишком сложные. По мере развития ребята начали усложнять в Tableau свои дашборды, использовать LODы, кастомные сортировки, скрипты Python. Естественно, это привело к замедлению работы некоторых Self-Service дашбордов. Поэтому через несколько месяцев после старта Self-Service мы пересмотрели подход к работе с источниками.
В новом подходе, который мы применяем до сих пор, были реализованы опубликованные на Tableau Server экстракты. Надо сказать, что у Self-Service постоянно возникают новые задачи, и от них поступают запросы на добавление новых полей в источник, естественно, источники данных постоянно модифицируются. Мы выработали следующую стратегию работы с источниками:
1. По ТЗ на источник со стороны Self-Service собираются данные в таблицах баз данных.
2. Создается нематериализованное представление (view) в тестовой схеме БД Redshift.
3. Представление тестируется на корректность данных командой QA.
4. В случае положительного результата проверки представление поднимается на продовой схеме Redshift.
5. Команда Data Engineering берет view на поддержку — подключаются скрипты анализа валидности данных, сигналы алармирования ETL, выдаются права на чтение команде Self-Service.
6. На Tableau Server публикуется источник (экстракт), подключенный к этому представлению.
7. Заводятся сигналы ETL на запуск экстракта.
8. Источник описывается в базе знаний.
9. Описание источника, вся информация для подключения и работы передается команде Self-Service.
Немного про пункт 7. Нативно Tableau позволяет создавать экстракты по расписанию с минимальной разницей в 5 минут. Если вы точно знаете, что ваши таблицы в БД обновляются всегда в 4 часа утра, то вам можно просто поставить экстракт на 5 часов утра, чтобы ваши данные собрались. Это покрывает ряд задач. В нашем случае таблицы собираются по данным от различных провайдеров в том числе. Соответственно, если один провайдер либо наш внутренний сервис не успели обновить свою часть данных, то вся таблица считается невалидной. То есть нельзя просто установить расписание на фиксированное время. Поэтому мы используем API Tableau для запуска экстрактов по готовности таблиц. Сигналы запусков экстрактов формирует наш сервис ETL после того, как убедится в том, что все новые данные пришли и они валидны.
Такой подход позволяет иметь в экстракте свежие валидные данные с минимальной задержкой.
Публикация дашбордов Self-Service на Tableau Server
---------------------------------------------------
Мы сознательно не ограничиваем людей в экспериментах со своими данными и позволяем публиковать свои воркбуки, делиться ими. Внутри каждой команды, если человек посчитает, что его дашборд полезен другим, либо дашборд нужен этому сотруднику на сервере, он может его опубликовать. Команда BI не вмешивается во внутренние эксперименты команд, соответственно, всю логику работы дашбордов и вычисления они прорабатывают сами. Есть cлучаи, когда из Self-Service вырастает интересный проект, который потом полностью передается на поддержку команды BI и переходит на прод. Это как раз и есть тот самый эффект Self-Service, когда люди, хорошо разбираясь в своих бизнеc-задачах, начинают работать со своими данными и формируют новую стратегию своей работы. Исходя из этого мы сделали следующую схему проектов на сервере:
*Схема проектов на Tableau Server*
Каждый пользователь с лицензией Creator может публиковать свои воркбуки на сервер либо делать анализ локально. Для Self-Service мы сделали свою песочницу (Sandbox) со своими группами проектов.
Сайты в Tableau идеологически разделены так, чтобы пользователи одного сайта не видели контент другого, поэтому мы разделили сервер на сайты по направлениям, которые не пересекаются: например, игровая аналитика и финансы. Мы используем групповой доступ. В каждом сайте есть проекты, в которых права на их воркбуки и источники наследуются. То есть группa пользователей Group 1 видит только свои воркбуки и источники данных. Исключением из этого правила является сайт Sandbox, который имеет еще и подпроекты. Sandbox мы используем для прототипирования, разработки новых дашбордов, их тестирования и для нужд Self-Service. Все, у кого есть доступ на публикацию в своем проекте Sandbox, могут публиковать свои прототипы.
Мониторинг источников и дашбордов на Tableau Server
---------------------------------------------------
Поскольку мы перенесли нагрузку запросов Self-Service дашбордов с базы на Tableau Server, работаем с большими источниками данных и не ограничиваем людей по запросам к опубликованным источникам, то появилась другая проблема — мониторинг быстродействия таких дашбордов и мониторинг созданных источников.
Мониторинг быстродействия дашбордов и быстродействия серверов Tableau — задача, с которой сталкиваются средние и большие компании, поэтому про быстродействие дашбордов и его тюнинг написано достаточно много статей. Мы пионерами в этой области не стали, наш мониторинг — это несколько дашбордов на базе внутренней БД PostgreSQL Tableau Server. Этот мониторинг работает со всем контентом, но можно выделить дашборды Self-Service и посмотреть их быстродействие.
Проблемы оптимизации дашбордов команда BI Team решает периодически. Пользователи иногда приходят с вопросом «Почему медленно работает дашборд?», и нам нужно понимать, что такое «медленно» с точки зрения пользователя и какие числовые критерии могут характеризовать это «медленно». Чтобы не интервьюировать пользователя и не отнимать его рабочее время для подробного пересказа проблем, мы мониторим и анализируем http-запросы, находим самые медленные и выясняем причины. После чего оптимизируем дашборды, если это может привести к увеличению производительности. Понятно что при живом подключении к источникам будут задержки, связанные с формированием view в базе задержки получения данных. Есть еще сетевые задержки, которые исследуем с нашей командой поддержки всей IT инфраструктуры, но в этой статье на них мы останавливаться не будем.
Немного о http requests
-----------------------
Каждое взаимодействие пользователя с дашбордом в браузере инициирует свой http request, передаваемый на Tableau Server. Вся история таких запросов хранится во внутренней БД PostgreSQL Tableau Server, срок хранения по умолчанию — 7 дней. Этот срок можно увеличить изменениями настроек Tableau Server, но мы не хотели увеличивать таблицу http-запросов, поэтому просто собираем инкрементальный экстракт, в который укладываются только свежие данные каждый день, старые при этом не затираются. Это хороший способ с минимумом ресурсов держать в экстракте на сервере исторические данные, которых уже нет в базе.
Каждый http request имеет свой тип (action\_type). Например, \_bootstrap — первоначальная загрузка view, relative-date-filter — фильтр дат (слайдер). По названию можно определить большинство типов, поэтому понятно, что каждый пользователь делает с дашбордом: кто-то больше смотрит тултипы, кто-то меняет параметры, кто-то делает свои custom\_view, а кто-то выгружает данные.
Ниже показан наш сервисный дашборд, который позволяет определять медленные дашборды, медленные типы запросов и пользователей, которым приходится ждать.
*Дашборд мониторинга http-запросов*
Мониторинг VizQL-сессий
-----------------------
Когда открывается какой-то дашборд в браузере, на сервере Tableau запускается VizQL сессия, в рамках которой происходит отрисовка визуализаций, также выделяются ресурсы на поддержание сессии. Такие сессии отбрасываются через 30 минут простоя по умолчанию.
По мере увеличения пользователей на сервере и внедрения Self-Service мы получили несколько пожеланий для увеличения лимитов сессий VizQL. Проблема пользователей была в том, что они открывали дашборды, устанавливали фильтры, что-то смотрели и переходили к другим своим задачам вне Tableau Server, после какого-то времени они возвращались к открытым дашбордам, но они сбрасывались на дефолтный вид, и приходилось заново их настраивать. Наша задача была сделать работу пользователей более комфортной и убедиться, что нагрузка на сервер не возрастает критически.
Следующие два параметра на сервере можно менять, но при этом надо понимать, что нагрузка на сервер может вырасти.
```
vizqlserver.session.expiry.minimum 5
```
Number of minutes of idle time after which a VizQL session is eligible to be discarded if the VizQL process starts to run out of memory.
**vizqlserver.session.expiry.timeout 30** Number of minutes of idle time after which a VizQL session is discarded.
Поэтому мы решили сделать мониторинг VizQL сессий и отслеживать:
1. Количество сессий,
2. Количество сессий на пользователя,
3. Среднюю длительность сессий,
4. Максимальную длительность сессий.
Кроме того, нам нужно было понимать, в какие дни и какие часы открывается самое большое количество сессий.
Получился такой дашборд:
*Дашборд мониторинга VizQL сессий*
C начала января этого года мы стали постепенно увеличивать лимиты и мониторить длительность сессий и нагрузку. Средняя длина сессии увеличилась с 13 до 35 минут — это видно на графиках средней длительности сессии. Конечные настройки такие:
```
vizqlserver.session.expiry.minimum 120
vizqlserver.session.expiry.timeout 240
```
После этого от пользователей мы получили положительный фидбэк, что работать стало намного приятнее — сессии перестали протухать.
Тепловые карты этого дашборда также позволяют нам планировать сервисные работы в часы минимальной востребованности сервера.
Изменение нагрузки на кластер — CPU и RAM — мы мониторим в Zabbix и AWS console. Значительных изменений нагрузки в процессе увеличения таймаутов мы не зафиксировали.
Если говорить о том, что может сильно нагнуть ваш Tableau сервер, то это может быть, например, неоптимизированный дашборд. Постройте, к примеру, в Tableau таблицу в десяток тысяч строк по категориям и id каких-нибудь событий, а в Measure используйте LOD вычисления на уровне id. С высокой вероятностью отображение таблицы на сервере не отработает, и вы получите вылет с Unexpected Error, поскольку все LODы в минимальной грануляции будут очень сильно потреблять память, и очень скоро процесс упрется в 100% потребления памяти.
Этот пример здесь приведен для того, чтобы было понятно, что один неоптимальный дашборд может съедать все ресурсы сервера, а даже 100 VizQL сессий оптимальных дашбордов не будут потреблять столько ресурсов.
Мониторинг источников данных сервера
------------------------------------
Выше мы отмечали, что для Self-Service мы подготовили и опубликовали на сервере несколько источников данных. Все источники — экстракты данных. Опубликованные источники сохраняются на сервере, и к ним предоставляется доступ ребятам, которые работают с Tableau Desktop.
В Tableau есть возможность помечать источники как сертифицированные. Так делает команда BI, когда готовит источники данных для Self-Service. Это гарантирует, что сам источник был протестирован.
Опубликованные источники могут достигать 200 млн строк и 100 полей. Для Self-Service это очень большой объем, поскольку не так много компаний имеет источники таких объемов для самостоятельной аналитики.
Естественно, при сборе требований для формирования источника мы смотрим, как можно сократить объем данных в источнике, группируя категории, разбивая источники по проектам или ограничивая периоды времени. Но все равно, как правило, источники получаются от 10 млн строк.
Поскольку источники большие, занимают место на сервере, используют ресурсы сервера для обновления экстрактов, то все их нужно мониторить, смотреть, насколько часто они используются и как быстро растут в объеме., Для этого мы сделали мониторинг опубликованных источников данных. Он показывает пользователей, подключающихся к источникам, воркбуки, которые используют эти источники. Это позволяет находить неактуальные источники или проблемные источники, которые не могут собрать экстракт.
*Дашборд мониторинга источников*
Итог
----
Мы используем подход Self-Service 1,5 года. За это время 50 пользователей стали самостоятельно работать с данными. Это снизило нагрузку на BI Team и позволило ребятам не ждать, пока BI Team дойдет до конкретно их задачи по разработке дашборда. Примерно 5 месяцев назад мы стали подключать другие направления к самостоятельной аналитике.
В наших планах проведение обучения по data literacy и лучшим практикам визуализаций.
Важно понимать, что процесс Self-Service не может быть внедрен быстро во всей компании, это займет некоторое время. Если процесс перехода будет органичным, не шокируя сотрудников, то через пару лет внедрения можно получить принципиально другие процессы работы с данными в разных отделах и направлениях компании. | https://habr.com/ru/post/551470/ | null | ru | null |
# Тонкости (странности?) работы с интефейсами
Знаешь ли ты что такое интерфейс %username%?
Если да, то я думаю этот код не вызовет у вас вопросов. PHP тонкости (странности?) работы с интефейсами
```
interface someInterface{
public function someMethod();
}
interface anotherInterface{
public function someMethod();
}
class Foo implements someInterface,anotherInterface {
public function someMethod(){
echo 'someMethod() was called'.PHP_EOL;
}
}
$foo = new Foo();
$foo->someMethod();
```
Итак что выведет на экран скрипт в результате своей работы.
Ответ под кaтом.
Правильный ответ: «Fatal error: Can't inherit abstract function …» Но почему? — совершенно справедливо спросите вы. Тем же вопросом задался и я когда впервые столкнулся с этим. Как показал поиск это — причуда, достоинство, недостаток, глупость, преимущество (нужное подчеркнуть) PHP. Если мы заглянем в учебник [php.net/manual/en/language.oop5.interfaces.php](http://php.net/manual/en/language.oop5.interfaces.php) в котором пишут такие страшные вещи «Note: A class cannot implement two interfaces that share function names, since it would cause ambiguity.» Иными словами в PHP класс не может имплементировать несколько интерфейсов содержащих одинаковые методы, так как это порождает неоднозначность. Стоп, стоп, стоп… Давайте разберёмся. Давайте вспомним множественное наследование в С++.
```
class someClass {
public:
void someMethod(){
};
}
class anotherClass {
public:
void someMethod(){
};
}
class fooClass: someClass,anotherClass{
}
int main () {
fooClass foo;
foo.someMethod();
return 0;
}
```
Тут то, как раз, и присутствует неопределённость, так как неясно какой из методов будет унаследован (ну-у почти). Интерфейсы были придуманы как раз для того, что бы разрешить коллизию возникающую при множественном наследовании классов. Ведь если говорить грубо, то интерфейс это только «набор инструкций», который говорит, что класс имплементирующий его должен реализовать такие то методы. Интерфейс не содержит реализацию метода, по этому, классу «всё равно» если ему приходится имплементировать множество интерфейсов с одинаковыми методами. Повторюсь, это всего лишь «инструкция» говорящая классу о том, что тот должен реализовать данный метод, просто этих инструкций несколько. Не совсем ясна логика разработчиков PHP, почему мы опять получили штуку, которая работает не так как везде? Почему класс не может имплементировать интерфейсы с одинаковыми методами? Почему это приводит к неоднозначности?
**UPD1:** почему то уже второй человек в комметариях говорит о перегрузке методов [en.wikipedia.org/wiki/Method\_overloading](http://en.wikipedia.org/wiki/Method_overloading) (одинаковое имя метода, но различные сигнатуры вызова: разные типы параметров передаваемых в метод, их число и прочее ...). Наверное я что то не так разъяснил, но в статье не идёт речь о оverloadin. Действительно PHP не поддерживает данный механизм. Но в данном случае к множественному имплементирования интерфейсов, этот механизм отношения не имеет.
Ещё раз в PHP класс не может имплементировать несколько интрефейсов содержащих одинаковые методы, в Java/C#/e.t.c это возможно:
```
public interface someInterface {
public void someMethod();
}
public interface anotherInterface {
public void someMethod();
}
public class fooClass implements anotherInterface,someInterface {
/**
* @param args
*/
public static void main(String[] args) {
fooClass fooClass = new fooClass();
fooClass.someMethod();
}
@Override
public void someMethod() {
System.out.println("someMethod() was called");
}
}
```
**UPD:2** решение той же задачи на C# [habrahabr.ru/blogs/php/116916/#comment\_3808966](http://habrahabr.ru/blogs/php/116916/#comment_3808966)
**UPD:3** проверил тот же код в D [en.wikipedia.org/wiki/D\_%28programming\_language%29](http://en.wikipedia.org/wiki/D_%28programming_language%29) вроде как новенький ооп язык, работает исправно файл e.d:
```
import std.stdio;
import std.stream;
interface D{
void foo();
}
interface A{
void foo();
}
class E : D, A{
void foo(){
writefln("foo() was called");
}
}
void main (string[] args){
E e = new E();
e.foo();
}
alagar@home:~/d$ dmd -run e.d
foo() was called
``` | https://habr.com/ru/post/116916/ | null | ru | null |
# Настройка OpenVPN в связке Mikrotik/Ubuntu
В любой компании, где существует более одного офиса, рано или поздно возникает необходимость в объединении этих самых офисов. Многие провайдеры предлагают такие услуги, но попросят за это денег, да и кто знает, что там творится на стороне провайдера? Поэтому сделаем все сами, и рассмотрим вариант объединения с помощью Mikrotik RB750, Ubuntu и OpenVPN.
##### Почему Mikrotik?
Дело в нативной поддержке, простоте настройки, более стабильном поведении, низких (в сравнении) пингах и множестве других приятных фич, которые предоставляет RB750. Сторонние прошивки вроде tomato или dd-wrt были исключены из рассмотрения, т.к. были (и остаются) сомнения в их стабильности. Тестировался также Asus WL-520GU, но пинги были на 20-30 мс выше.
##### Итак, поехали.
На сервере в центральном офисе, стоит Ubuntu. Установка openvpn на нем выглядит следующим образом.
```
$ sudo su
# apt-get update
# apt-get upgrade
# apt-get install openvpn
# cp -R /usr/share/doc/openvpn/examples/easy-rsa/ /etc/openvpn
# cd /etc/openvpn/easy-rsa/2.0
# ln -s openssl-1.0.0.cnf openssl.cnf
# source vars
# ./clean-all
Создаем пару корневой сертификат ca.crt и ключ ca.key
# ./build-ca
Создаем пару сертификат сервера server.crt и ключ server.key
# ./build-key-server server
Создаем пару сертификат клиента client1.crt и ключ client1.key
# ./build-key client1
Ключи Диффи Хелмана
# ./build-dh
# cd keys
# mkdir /etc/openvpn/.keys && /etc/openvpn/.ccd
# cp ca.crt ca.key dh1024.pem server.crt server.key /etc/openvpn/keys
# cp /usr/share/doc/openvpn/examples/sample-config-files/server.conf.gz /etc/openvpn/
# cd /etc/openvpn
# gunzip -d /etc/openvpn/server.conf.gz
# nano /etc/sysctl.conf
Находим строку и снимаем с нее комментарий:
# Enable packet forwarding
net.ipv4.ip_forward=1
```
Все нюансы настройки заключались в файле конфигурации openvpn на сервере, по итогу он получился таким (комментировал лишь существенные моменты, описание остальных параметров конфига есть в манах, инете, example конфигах и проч.):
```
port 1194
# Mikrotik не умеет работать с UDP
proto tcp
dev tun
ca .keys/ca.crt
cert .keys/server.crt
key .keys/server.key # This file should be kept secret
dh .keys/dh1024.pem
server 10.0.141.0 255.255.255.0
client-config-dir .ccd
client-to-client
keepalive 10 120
tun-mtu 1500
mssfix 1450
cipher AES-256-CBC # AES
auth sha1
# Компрессия микротиком так же не поддерживается
;comp-lzo
user nobody
group nogroup
#Сохраняем туннель при обрыве на время keepalive
persist-key
#Не пересчитываем ключи при обрыве связи
persist-tun
status /var/log/openvpn-status.log
log /var/log/openvpn.log
verb 3
mute 10
```
###### /etc/openvpn/.ccd/client1
```
# Клиентская подсеть за mikrotik (192) и адрес openvpn у роутера (10)
iroute 192.168.141.0 255.255.255.0 10.0.141.2
# Добавим шлюз по умолчанию для машин за микротиком
ifconfig-push 10.0.141.2 10.0.141.1
```
##### Теперь Mikrotik
Настройку опишу с самого начала, в том числе организацию свича, настройку адресов, маршрутов, DHCP и проч.
Заходим в веб-интерфейс роутера, качаем winbox.
Запускаем winbox(возможно подключение как по IP, так и по MAC), открываем new terminal, и пишем следующее(achtung, сброс конфигурации роутера): `system reset-configuration`
Подключаемся ко второму порту микротика, запускаем все тот же winbox, и на появившийся запрос клацаем `remove config`
Организуем свич на портах 2-5, порт 1 будет выступать в роли WAN порта.
Для этого у всех интерфейсов 3-5 указываем мастер порт ether2:
В меню IP->Adresses назначаем ip lan интерфейса
Добавим гейт для выхода в инет в меню IP->Routes (гейтом в данном конкретном случае выступает DSL модем с адресом 10.100.0.1)
Обратим внимание, что 10.100.0.0 — адресация между роутером и модемом DSL, через который он ходит в инет, а 10.0.141.0 — сеть VPN.
Настроить DNS можно тут IP->DNS, а DHCP в меню IP->DHCP Server->DHCP setup, указав параметры пула.
Всю нашу внутреннюю подсеть задвинем за NAT, для этого настроим маскарадинг.
Переходим IP->Firewall->NAT и добавляем правило по аналогии:
###### Счастье близко
Осталось скопировать корневой сертификат(ca.crt) и клиентские сертификат и ключ(client1.crt, client1.key), которые мы сгенерировали в процессе установки/настройки сервера. На микротике выбираем меню Files, и видим окно с файловой системой роутера. Именно сюда нужно положить наши ключи, работает drag-n-drop.
Чтобы роутер знал о наличии у него сертификатов, их нужно импортировать через System->Certifates добавляем ca.crt, client1.crt, client1.key, клиентский ключ автоматом станет «Decrypted».
Непосредственно соединение OpenVPN создается в меню Interfaces, при нажатии на красный плюс увидим OVPN Client в выпадающем списке.
На вкладке Dial Out укажем адрес нашего сервера, порт, клиентский сертификат и типы шифрования.
##### Итог.
В итоге имеем вполне себе безопасный VPN, с минимальными затратами на оборудование и услуги связи, организовать который можно в течение пары минут. | https://habr.com/ru/post/227767/ | null | ru | null |
# Ревью кода: успешный опыт
[](https://habrahabr.ru/company/alconost/blog/413589/)
В Интернете найдется масса информации по ревью кода:
* как ревью чужого кода влияет на культуру компании
* о регламентированных проверках безопасности
* сокращенные руководства
* длинные списки рекомендаций
* ревью кода с межличностной точки зрения
* зачем вообще нужен ревью кода
* проверенные методы
* еще про проверенные методы
* статистика: насколько ревью кода помогает вылавливать баги
* примеры ошибок, допускаемых при ревью кода
Да, конечно же, есть и [книги](https://books.google.com/books/about/Peer_Reviews_in_Software.html?id=d7BQAAAAMAAJ) на эту тему. Словом, в этой статье изложено, как ревью кода организован в компании Palantir. В тех организациях, чья культура не приемлет подобной коллегиальной оценки, возможно, полезно будет сначала ознакомиться с блестящим эссе Карла Уиджерса (Karl E. Wiegers) «[Ревью кода с человеческим лицом»,](http://www.processimpact.com/articles/humanizing_reviews.html) а затем попытаться следовать этому руководству.
Этот текст взят из [рекомендаций по повышению качества,](https://github.com/palantir/gradle-baseline/tree/develop/docs) составленным на основе работы с [Baseline](https://github.com/palantir/gradle-baseline), нашим инструментом для контроля качества кода на Java. В нем рассмотрены следующие темы:
* Зачем, что и когда мы пытаемся достичь при ревью кода
* Подготовка кода к ревью
* Выполнение ревью кода
* Примеры ревью кода
**Переведено в [Alconost](https://alconost.com?utm_source=habrahabr&utm_medium=article&utm_campaign=translation&utm_content=code)**
*Комикс [XKCD ‘Качество кода’, скопировано по лицензии CC BY-NC 2.5](https://xkcd.com/1513/)*
Мотивация
---------
Мы занимаемся ревью кода (РК) для повышения качества кода и хотим таким образом [положительно повлиять на командную и корпоративную культуру.](https://blog.fullstory.com/what-we-learned-from-google-code-reviews-arent-just-for-catching-bugs) Например:
* **Авторы кода мотивированы,** поскольку знают, что их запрос на внесение изменений будет рассматривать коллектив рецензентов: автор старается подчистить шероховатости, следовать плану действий и вообще улучшить весь коммит. Когда коллеги признают твой профессионализм по части написания кода – для многих программистов это повод собой гордиться.
* **Обмен знаниями** помогает команде разработчиков сразу в нескольких отношениях:
— При РК явно сообщается, какая часть функционала была добавлена/изменена/удалена, чтобы в дальнейшем члены команды могли опираться на уже выполненную работу.
— Автор кода может использовать прием или алгоритм, на котором рецензенты сами чему-то научатся. В целом ревью кода помогает [повысить планку качества в рамках всей организации](https://blog.fullstory.com/what-we-learned-from-google-code-reviews-arent-just-for-catching-bugs/).
— Рецензенты могут знать о приемах программирования или о самой базе кода нечто такое, что поможет улучшить или консолидировать внесенные изменения; например, кто-нибудь может в то же самое время разрабатывать или дорабатывать точно такую же возможность.
— Положительный контакт и коммуникация усиливают социальные связи между членами команды.
* **Благодаря согласованности** в базе кода сам код гораздо проще читать и понимать. Так легче предотвращать баги и способствовать сотрудничеству между оседлыми и кочевыми программистами.
* Автору кода сложно судить об **удобочитаемости** собственного творения, а рецензенту – как раз легко, ведь он не видит, в каком контексте этот код находится. Удобочитаемый код проще многократно использовать, в нем меньше багов, и он долговечнее.
* **Случайные ошибки** (напр., опечатки), а также **структурные ошибки** (напр., неисполняемый код, ошибки в логике или алгоритмах, проблемы с производительностью и архитектурой) зачастую гораздо проще выловить придирчивому рецензенту, который смотрит на код со стороны. По данным исследований, даже краткое и неофициальное ревью кода значительно [влияет на качество кода и встречаемость багов](https://blog.codinghorror.com/code-reviews-just-do-it/).
* **Требования соответствия** и нормативные базы зачастую требуют обязательных проверок. Ревью кода – отличный способ избежать распространенных проблем с безопасностью. Если требования к безопасности в данной среде или применительно к данной возможности повышены, то ревью будет рекомендован (или даже затребован) сатрапами из регулирующих органов (хороший пример — руководство [OWASP](https://www.owasp.org/index.php/Code_Review_Introduction)).
На что обращать внимание
------------------------
Однозначно верного ответа на этот вопрос не существует, и в каждой команде разработчиков требуется согласовать собственный подход. В некоторых коллективах предпочитают проверять любое изменение, вносимое в основную ветку разработки, а в других учитывается «порог тривиальности», по превышении которого проверка является обязательной. В данном случае приходится выдерживать баланс между эффективным использованием времени программиста (как автора, так и рецензента кода) и поддержанием качества кода. В некоторых строгих контекстах порой требуется проверять в коде все, даже самые тривиальные изменения.
Правила ревью кода одинаковы для всех: даже если вы самый старший разработчик в команде, это еще не означает, что ваш код не требует ревью. Даже если (бывает и так) код безупречен, ревью открывает возможности для менторства и сотрудничества, и, как минимум, помогает взглянуть на базу кода с разных точек зрения.
Когда проверять
---------------
Ревью кода должно происходить после успешного прохождения автоматических проверок (тесты, оформление, другие этапы непрерывной интеграции), но до слияния нового кода с главной веткой репозитория. Обычно мы не прибегаем к формальной проверке суммарных изменений, внесенных в код с момента последнего релиза.
При сложных изменениях, которые должны добавляться в главную ветку кода единым блоком, но настолько обширных, что их фактически нельзя охватить за одну проверку, попробуйте поэтапное ревью. Создаем первичную ветку feature/big-feature и ряд вторичных (напр., feature/big-feature-api, feature/big-feature-testing, т.д.), в каждой из которых инкапсулировано подмножество общего функционала, и каждая такая ветка сверяется с основной веткой feature/big-feature. После того как все вторичные ветки будут слиты в feature/big-feature, создаем ревью кода для вливания последней в главную ветку.
Подготовка кода к ревью
-----------------------
Автор кода обязан предоставлять код на ревью в удобоваримом виде, чтобы не отбирать у рецензентов лишнего времени и не демотивировать их:
* **Область применения и размер**. Изменения должны относиться к узкой, четко определенной, самодостаточной области применения, полностью покрываемой при ревью. Например, изменения могут быть связаны с реализацией некоторой возможности или с исправлением ошибки. Краткие изменения предпочтительнее длинных. Если на ревью подается материал, включающий изменения в более чем ~5 файлах, либо требует более 1–2 дней на запись, либо на само ревью может уйти более 20 минут, попробуйте разбить материал на несколько самодостаточных фрагментов и проверить каждый отдельно. Например, разработчик может отправить изменение, определяющее API для новой возможности в терминах интерфейсов и документации, а затем добавить и второе изменение, в котором описаны реализации для этих интерфейсов.
* Присылать нужно только **полные, самостоятельно проверенные** (воспользуйтесь diff) и **самостоятельно протестированные** материалы. Чтобы сэкономить время рецензента, тестируйте отправляемые изменения (т.е. запускайте тестовый набор) и убедитесь, что код проходит все сборки, а также все тесты и все этапы проверки качества, как локально, так и на серверах непрерывной интеграции, *и только потом подбирайте рецензентов*.
* **Рефакторинг изменений** не должен сказываться на поведении и наоборот; изменения, влияющие на поведение, не должны быть сопряжены с рефакторингом или переформатированием кода. На то есть ряд веских причин:
— Изменения, связанные с рефакторингом, обычно затрагивают множество строк кода во многих файлах – следовательно, этот код будет [проверяться не так внимательно](https://smartbear.com/learn/code-review/best-practices-for-peer-code-review/). Незапланированные изменения в поведении могут просочиться в базу кода, и никто этого даже не заметит.
— Крупные изменения, связанные с рефакторингом, нарушают механизмы перемещения, отбора и другую «магию», связанную с контролем исходников. Очень сложно отменить такое изменение поведения, которое было внесено после завершения рефакторинга, охватившего весь репозиторий.
— Дорогое рабочее время, которое человек тратит на рецензирование кода, должно уходить на проверку программной логики, а не на споры о стиле, синтаксисе или форматировании кода. Такие вопросы мы предпочитаем решать при помощи автоматических инструментов, в частности, [Checkstyle](http://checkstyle.sourceforge.net/), [TSLint](https://github.com/palantir/tslint), [Baseline](https://github.com/palantir/gradle-baseline), [Prettier](https://github.com/prettier/prettier) и т.д.
Коммит-сообщения
----------------
Далее приведен пример грамотного коммит-сообщения, которое выдержано в соответствии с широко применяемым стандартом:
```
Краткое (до 80 символов) описание изменений
Более детальный, поясняющий текст, если он требуется. Ограничьтесь
примерно 72 символами. В некоторых контекстах первая строка
рассматривается как тема электронного письма, а остальной
текст — как тело письма. Важна пустая строка, отделяющая краткое
описание от тела письма (если тело письма присутствует);
в противном случае такие инструменты, как rebase, могут воспринять
написанное некорректно.
Пишите коммит-сообщение в повелительном наклонении: «Исправить ошибку», а не «Исправление ошибки» и не «исправляет ошибку». Такое соглашение соблюдается и в коммит-сообщениях, генерируемых автоматически, например, командами git merge и git revert.
Дальнейшие абзацы идут после пустых строк.
Также допустимы маркированные списки.
```
Старайтесь описать и изменения, вносимые при коммите, и как именно эти изменения делаются:
```
> ПЛОХО. Не делать так.
Еще раз запустить компиляцию.
> Хорошо.
Добавить jcsv-зависимость для исправления компиляции в IntelliJ
```
Поиск рецензентов
-----------------
Обычно автор коммита подыскивает одного-двух рецензентов, знакомых с базой кода. Зачастую в таком качестве выступают руководитель проекта или старший инженер. Владельцу проекта целесообразно подписываться на собственный проект, чтобы получать уведомления о новых ревью кода. При участии троих и более рецензентов ревью кода зачастую получается непродуктивным или контрпродуктивным, поскольку разные рецензенты могут предлагать взаимно противоречивые изменения. Это может свидетельствовать о фундаментальных разногласиях по поводу верной реализации, и такие проблемы должны решаться не во время ревью кода, а на расширенном собрании, в котором лично или в режиме видеоконференции участвуют все заинтересованные стороны.
Выполнение ревью кода
---------------------
Ревью кода – это точка синхронизации между разными членами команды, поэтому потенциально она может стопорить работу. Поэтому ревью кода должно быть оперативным (занимать порядка нескольких часов, а не дней), а члены и руководители команды должны осознавать, сколько времени потребуется на проверку, и соответствующим образом приоритезировать выделяемое на нее время. Если вам кажется, что вы не успеете закончить ревью вовремя, сразу скажите об этом автору коммита, чтобы он успел найти вам замену.
Ревью должно быть довольно основательным, чтобы рецензент мог объяснить изменение другому разработчику с достаточной детализацией. Так мы добьемся того, чтобы подробности о базе кода были известны хотя бы двоим, а не одному.
Вы как рецензент должны настойчиво придерживаться стандартов качества кода и держать его на высоком уровне. Ревью кода – скорее искусство, чем наука. Научиться этому можно только на практике. Опытный рецензент должен попробовать сначала подпустить к изменениям менее опытных коллег и позволить им сделать ревью первыми. Если автор следовал вышеизложенным правилам (особенно тем, что касаются самопроверки и предварительного запуска кода), то вот на что должен обратить внимание рецензент при ревью:
### Цель
* **Позволяет ли код достичь цели, поставленной автором?** У любого изменения должна быть конкретная причина (новая возможность, рефакторинг, исправление ошибки, т.д). В самом ли деле предложенный код приводит нас к этой цели?
* **Задавать вопросы.** Функции и классы должны быть обоснованы. Если их назначение рецензенту непонятно, возможно, это означает, что код следует переписать либо подкрепить комментариями или тестами.
### Реализация
* **Подумайте, как бы решили эту задачу вы.** Если иначе – то почему? Обрабатывает ли ваш код больше (пограничных) случаев? Может быть, он короче/проще/чище/быстрее/безопаснее, а функционально не хуже? Может быть, вы уловили какую-то глубинную закономерность, не охватываемую имеющимся кодом?
* **Видите ли вы потенциал для создания полезных абстракций?** Если код частично дублируется, это зачастую означает, что из него можно извлечь более абстрактный или общий элемент функционала, который затем получится переиспользовать в иных контекстах.
* **Мыслите как оппонент, однако, оставайтесь любезны.** Старайтесь «подловить» авторов, срезающих углы или упускающих конкретные случаи, подбрасывая им проблемные конфигурации/вводимые данные, которые ломают их код.
* **Подумайте о библиотеках или о готовом рабочем коде.** Если кто-то заново реализует уже имеющуюся функциональность – это бывает не только потому, что он не знает о существовании уже готового решения. Иногда код или функциональность переизобретается намеренно – напр., чтобы избежать зависимостей. В таком случае это нужно четко прокомментировать в коде. Предоставляется ли уже данная функциональность в какой-нибудь существующей библиотеке?
* **Соответствует ли вносимое изменение стандартным паттернам?** В сложившихся базах кода часто прослеживаются закономерности, связанные с соглашениями об именовании, декомпозиции программной логики, определениями типов данных и т.д. Обычно желательно, чтобы все изменения реализовывались в соответствии с существующими закономерностями.
* **Добавляются ли при изменении зависимости, возникающие во время компиляции или во время исполнения (особенно между подпроектами)?** Мы стремимся к слабой связанности кода наших продуктов, то есть, стараемся допускать минимум зависимостей. Изменения, связанные с зависимостями и системой сборки, должны проверяться особенно тщательно.
### Удобочитаемость и стиль
* **Подумайте, каково вам читать этот код.** Удается ли достаточно быстро схватывать его концепции? Разумно ли он уложен, легко ли следить за названиями переменных и методов? Удается ли прослеживать код на протяжении нескольких файлов или функций? Покоробило ли вас где-нибудь непоследовательное именование?
* **Соответствует ли код известным рекомендациям по программированию и стилю?** Не выбивается ли код из всего проекта по стилю, соглашениям об именованиях API, т.д.? Как было указано выше, мы стараемся улаживать стилистические споры при помощи автоматических инструментов.
* **Есть ли в коде списки задач (TODO)?** Списки задач просто накапливаются в коде и со временем превращаются в балласт. Обяжите автора отправлять тикет на GitHub Issues или JIRA и прикреплять к TODO номер задачи. В предлагаемом изменении не должно быть закомментированного кода.
### Удобство поддержки
* **Читайте тесты.** Если тестов в коде нет, а они там должны быть – попросите автора написать несколько. По-настоящему не тестируемые возможности встречаются редко, а не протестированные реализации возможностей – к сожалению, часто. Сами проверяйте тесты: покрывают ли они интересные случаи? Удобно ли их читать? Снижается ли после этой проверки общее покрытие тестами? Подумайте, каким образом может сбоить этот код. Стандарты оформления тестов и основного кода зачастую отличаются, но и стандарты тестов тоже важны.
* **Возникает ли при ревью этого фрагмента риск нарушить тестовый код, обкаточный код или интеграционные тесты?** Зачастую такое ревью не делается перед коммитом/слиянием, но, если такие случаи окажутся запущенными, то пострадают все. Обращайте внимание на следующие вещи: удаление тестовых утилит или режимов, изменение конфигурации, изменения в компоновке/структуре артефакта.
* **Нарушает ли это изменение обратную совместимость?** Если так, то можно ли вносить это изменение в релиз на данном этапе, либо следует отложить его на более поздний релиз? К нарушениям могут относиться изменения базы данных или ее схемы, изменения публичных API, изменения потока задач на уровне пользователя и т.д.
* **Требуются ли в этом коде интеграционные тесты?** Иногда код не удается как следует проверить при помощи одних лишь модульных тестов, особенно если он взаимодействует со внешними системами или конфигурацией.
* **Оставляйте отзывы к документации по этому коду, к комментариям и коммит-сообщениям.** Пространные комментарии засоряют код, а скупые коммит-сообщения запутывают тех, кому впоследствии придется работать с кодом. Так бывает не всегда, но качественные комментарии и коммит-сообщения со временем обязательно сослужат вам хорошую службу. (Вспомните, когда вам доводилось видеть великолепный или просто ужасный комментарий или коммит-сообщение.)
* **Обновлялась ли внешняя документация?** Если по вашему проекту ведутся файлы README, CHANGELOG или другая документация – то обновлена ли она с учетом внесенных изменений? Устаревшая документация может быть пагубнее, чем вообще никакой, и дороже выйдет исправить ошибки в будущем, чем внести изменения сейчас.
Не забывайте похвалить лаконичный/удобочитаемый/эффективный/красивый код. Напротив, забраковать или отклонить код, предложенный на ревью — не грубость. Если изменение избыточно или несущественно – отклоните его, пояснив причину. Если изменение кажется вам неприемлемым из-за одной или нескольких фатальных ошибок – забракуйте его, опять же, аргументированно. Иногда наилучший исход ревью кода формулируется «давайте сделаем это совершенно иначе» или «давайте вообще не будем этого делать».
Уважайте рецензируемого. Хотя, позиция оппонента здравая, не вы реализовали эту возможность, и не можете все за него решать. Если не удается прийти с рецензируемым к общему мнению по поводу кода, устройте консультацию в реальном времени и выслушайте мнение третьего человека.
### Безопасность
Убедитесь, что на всех конечных точках API выполняется адекватная авторизация и аутентификация, соответствующая правилам, принятым в остальной базе кода. Ищите другие распространенные изъяны, например: слабую конфигурацию, вредоносный пользовательский ввод, недостающие записи в логах, т.д. Если сомневаетесь – покажите рецензируемый код специалисту по безопасности.
### Комментарии: краткие, вежливые, побудительные
Рецензия должна быть краткой, выдержанной в нейтральном стиле. Критикуйте код, а не автора. Если что-то непонятно – попросите пояснить, а не считайте, что все дело в невежестве автора. Избегайте притяжательных местоимений, особенно в оценочных суждениях: «*мой* код работал до *ваших* изменений», «в *вашем* методе есть баг» и т.д. Не рубите сплеча: «это *вообще не будет* работать», «результат *всегда* неверен».
Старайтесь разграничивать рекомендации (напр., «Рекомендация: извлеките метод, так код станет понятнее»), необходимые изменения (напр., «Добавить [Override](https://habr.com/users/override/)») и мнения, требующие разъяснения или обсуждения (напр., «В самом ли деле это поведение верное? Если так — пожалуйста, добавьте комментарий, поясняющий логику»). Попробуйте поставить ссылки или указатели на подробное описание проблемы.
Закончив ревью кода, укажите, насколько подробной реакции на ваши комментарии вы ожидаете от автора, хотели бы вы повторить ревью после того, как изменения будут внесены, например: «Можете смело заливать код в главную ветку после этих небольших исправлений» или «Пожалуйста, учтите мои замечания и дайте мне знать, когда я смогу снова посмотреть код».
Реакция на рецензию
-------------------
Ревью кода, в частности, призвано улучшить предложенный автором запрос на изменения; поэтому не принимайте в штыки рекомендации рецензента, отнеситесь к ним серьезно, даже если не согласны с ними. Отвечайте на любой комментарий, даже на обычные «ACK» (одобрено) или «done» (готово). Объясните, почему приняли то или иное решение, зачем у вас в коде те или иные функции, т.д. Если не можете прийти к общему мнению с рецензентом, устройте консультацию в реальном времени и выслушайте мнение стороннего специалиста.
Исправления должны фиксироваться в той же ветке, но в отдельном коммите. Если склеивать коммиты на этапе рецензирования, то рецензенту будет сложнее отслеживать изменения.
Политика слияния кода в разных командах отличается. В некоторых компаниях слияние кода доверяют только владельцу проекта, в других это может делать и участник после того, как его код будет просмотрен и одобрен.
### Ревью кода тет-а-тет
Как правило, для ревью кода отлично подходят асинхронные diff-подобные инструменты, например, Reviewable, Gerrit или GitHub. Если речь идет о сложном ревью или о ревью, участники которого сильно отличаются по уровню опыта или профессионализма, ревью бывает эффективнее проводить лично — либо сидя вдвоем перед одним монитором или проектором, либо удаленно, через видеоконференцию или инструменты для совместного просмотра экрана.
Примеры
-------
В следующих примерах комментарии рецензента в листингах вводятся при помощи
```
//R: ...
```
### Противоречивое именование
```
class MyClass {
private int countTotalPageVisits; //R: называйте переменные единообразно
private int uniqueUsersCount;
}
```
### Несогласованные сигнатуры методов
```
interface MyInterface {
/** Возвращает {@link Optional#empty}, если s не удается извлечь. */
public Optional extractString(String s);
/\*\* Возвращает null, если {@code s} не удается переписать. \*/
//R: следует гармонизировать возвращаемые значения: также применяйте здесь // Optional<>
public String rewriteString(String s);
}
```
### Использование библиотеки
```
//R: удалите и замените на MapJoiner из библиотеки Guava
String joinAndConcatenate(Map map, String keyValueSeparator, String keySeparator);
```
### Личные предпочтения
```
int dayCount; //R: нет: я предпочитаю numFoo а не fooCount; на ваш вкус, но это название должно быть единообразным во всем проекте
```
### Баги
```
//R: Количество итераций здесь numIterations+1 – так и должно быть?
// Если нет – давайте попробуем изменить семантику numIterations?
for (int i = 0; i <= numIterations; ++i) {
...
}
```
### Архитектурные соображения
```
otherService.call(); //R: Думаю, нужно обойтись без зависимости от OtherService. Можем обсудить это лично?
```
**О переводчике**
Перевод статьи выполнен в Alconost.
Alconost занимается [локализацией игр](https://alconost.com/services/game-localization?utm_source=habrahabr&utm_medium=article&utm_campaign=translation&utm_content=code), [приложений и сайтов](https://alconost.com/services/software-localization?utm_source=habrahabr&utm_medium=article&utm_campaign=translation&utm_content=code) на 70 языков. Переводчики-носители языка, лингвистическое тестирование, облачная платформа с API, непрерывная локализация, менеджеры проектов 24/7, любые форматы строковых ресурсов.
Мы также делаем [рекламные и обучающие видеоролики](https://alconost.com/services/video-production?utm_source=habrahabr&utm_medium=article&utm_campaign=translation&utm_content=code) — для сайтов, продающие, имиджевые, рекламные, обучающие, тизеры, эксплейнеры, трейлеры для Google Play и App Store.
[Подробнее](https://alconost.com?utm_source=habrahabr&utm_medium=article&utm_campaign=translation&utm_content=code) | https://habr.com/ru/post/413589/ | null | ru | null |
# Познаем промисы на основе Ecmascript спецификации. Знакомство
Здравствуйте. Изучая JavaScript (да и в принципе любую другую технологию), всегда возникают разнообразные вопросы, главный из которых: «А почему это работает таким образом и не иначе?» И очень важно в этот момент не просто найти ответ на вопрос, но и полученное объяснение встроить в единую систему уже полученных знаний. Иначе осиротевшую информацию придется зазубрить или забыть.
Совместное изучение чего-либо очень помогает искать ответы. Когда ученик / напарник задает вопрос про то, как понимать фразу — «… в следующий по цепочке промис „проваливается“ результат предыдущего… » — невольно задумываешься… Вот ведь какое странное дело. А ведь лучше уже не скажешь, неужели и это не понятно? Смотришь в чистые, немного наивные, глаза товарища и понимаешь — необходимо сказать как-то еще. Желательно так, чтобы даже запоминать не пришлось. Чтобы просто новая информация органично вписалась в уже существующие мысли человека.
Не буду описывать, что мы пробовали, читали, смотрели. В итоге заинтересовались спецификацией ECMAScript. Как её читать и понимать — это отдельный разговор (может даже отдельный пост). Но то, как там описаны промисы и их поведение, впервые дало нам целостностное и логически связное понимание данной темы. Чем и хочется поделиться с вами.
Данная статья ориентирована на новичков. Здесь будут обсуждаться промисы с точки зрения спецификации ECMAScript. Знаю, звучит странно, но как есть.
Объект promise: его философия, техническое представление, возможные состояния
-----------------------------------------------------------------------------
Уже не раз было мною замечено, что качественное обучение программированию должно состоять из 2 частей. Это — философское осмысление идеи, а уже затем её техническая реализация. То есть обычная человеческая логика, которой ученик руководствуется при принятии каких-либо решений, сильно облегчает понимание технической реализации этого решения. Поэтому начнем мы с того, что такое обещание в жизни, и как мы к нему относимся? А затем посмотрим: как примеры обещаний будут реализованы в коде. Рассмотрим следующие рисунки (рис. 1, 2, 3).
*рис 1. ( [[PromiseState]] — как результат обещания )*
*рис 2. ( [[PromiseResult]] — как информация, связанная с результатом выполненного или невыполненного обещания )*
*рис 3. ( [[PromiseFulfillReactions]], [[PromiseRejectReactions]] — как последствия, которые наступают после выполнения или невыполнения обещания )*
Мы видим, что само понятие обещания стоит на 3-х китах. 1) Было ли выполнено обещание вообще? 2) Какую дополнительную информацию мы можем извлечь после выполнения или отказа обещания? 3) Какие последствия наступят в случае положительного или отрицательного исхода нашего обещания?
Технически же обещание — это обыкновенная сущность, выраженная через такой тип данных, как объект. У этой сущности есть имя / класс Promise. Объекты, рожденные от этого класса, имеют в цепочке своих прототипов Promise.prototype. И данная сущность должна быть как-то связана со всей той «информацией из жизни», которую мы рассмотрели выше. Спецификация ECMAScript эту информацию закладывает в промис еще на уровне, который ниже по абстракции, чем сам JavaScript. Например, на уровень С++. Соответственно в объекте промиса есть место и под статус, и под результат, и под последствия обещания. Взгляните на то, из чего состоит обещание по [по версии ECMAScript](https://www.ecma-international.org/ecma-262/7.0/#sec-properties-of-promise-instances) (рис. 4).
*рис 4. ( Внутренние поля promise объекта по версии ECMAScript спецификации )*
Какими новыми красками заиграла фраза «обещать — не значит жениться» с точки зрения программиста? 1) [[PromiseState]]. Кто-то не женился. 2) [[PromiseResult]]. Потому что ему не хватило денег на свадьбу. 3) [[PromiseRejectReactions]]. Как следствие — у него появилось куча свободного времени, которое он потратил на саморазвитие 4) [[PromiseFulfillReactions]]. А зачем человеку план B, когда он уже выбрал план A?
Да, есть и пятое поле [[PromiseIsHandled]]. Оно не очень для нас, людей, важное, и оперировать им в дальнейшем уже не будем. Вкратце: там хранится сигнал интерпретатору о том, был ли обработан отказ / reject обещания программистом или нет. Если нет, то необработанный reject обещания интерпретируется движком JS как ошибка. Для нетерпеливых: если программист не повесил вторым аргументом через Promise.prototype.then() функцию-callback-обработчик reject-а состояния промиса — то возникшее состояние «rejected» promise объекта покажет вам красную ошибку в консоли разработчика.
Обратили внимание, что поля объекта promise заключены в «[[» и «]]»? Этим подчеркивается, что доступ к данной информации у программиста JS напрямую не имеется. Только через специальные средства / команды / API, как, например, команду Promise.prototype.then(). Если же у вас есть непреодолимое желание управлять «этой кухней» напрямую, то добро пожаловать в клуб разработчиков стандартов спецификации EcmaScript.
Небольшое замечание в конце данной подглавы. Если в жизни у нас могут быть обещания выполнены частично, то в EcmaScript — нет. То есть, если человек обещал отдать миллион, а отдал 950 тысяч, то в жизни, может, он и надежный партнер, но для для JavaScript такой должник будет занесен в черный список через [[PromiseState]] === «rejected». Promise объект меняет свое состояние однозначно и всего лишь один раз. Как это технически реализуется — немного позже.
Конструктор Promise, его философия. Callback функция executor — как «выполнитель» обещания. Схема взаимодействия: Promise ( конструктор ) — executor ( callback ) — promise ( объект )
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Итак, мы выяснили, что promise — это сущность, которая технически представляет собой JS объект с особыми скрытыми внутренними полями, которые в свою очередь обеспечивают философское наполнение смыслом слова «обещание».
Когда новичок первый раз создает объект promise, то его ожидает следующая картина (рис. 5).
*рис 5. ( Самый первый раз интуитивно создаем promise объект )*
Что пошло не так, и почему ошибка — стандартный вопрос. При ответе на него лучше снова привести какую-то аналогию из жизни. Например, мало кто любит «пустозвонов» вокруг нас: которые только обещают, но ничего не делают по выполнению своих заявлений (политика не в счет). Мы намного лучше относимся к тем людям, которые после своего обещания имеют план и предпринимают сразу же какие-то действия для достижения обещанного результата.
Так и философия ECMAScript подразумевает, что если вы создаете обещание, то сразу же укажите, как вы его будете выполнять. Свой план действий программисту необходимо оформить в виде параметра-функции, которую передадите в конструктор Promise. Следующий эксперимент выглядит так (рис. 6).
*рис 6. ( Создаем promise объект, передавая в конструктор Promise функцию executor )*
Из подписи к рисунку мы видим, что функция (параметр конструктора Promise) имеет собственное название — executor. Её задача — начать выполнение обещания и, желательно, привести его к какому-то логическому завершению. И если программист может писать какой угодно код в executor-е, то как программисту просигнализировать JS-у, что все — работа сделана — можно идти и смотреть результаты обещания?
Маркеры или сигналы, которые помогут программисту сообщить, что обещание завершено, передаются автоматически в параметры executor-a в виде аргументов, специально сформированных JavaScript-ом. Эти параметры можно называть как угодно, но чаще всего вы встретите их под такими именами, как res и rej. В спецификации ECMAScript их полное название — resolve function и reject function. Эти маркеры-функции имеют свои особенности, которые рассмотрим чуть ниже.
Для осознания новой информации новичку предлагается самостоятельно закодировать следующее утверждение: «Обещаю, что смогу разделить одно число на другое и выдать ответ, если только делитель не ноль». Вот как будет выглядеть приблизительно такой код (рис. 7).
*рис 7. ( Решение задачи на деление 2-х чисел через промисы )*
Теперь можно проанализировать полученный результат. Мы видим, что уже второй раз консоль браузера показывает объект промис в интересном виде. А именно: указаны 2 дополнительных поля в двойных квадратных скобках. Можно спокойно провести аналогию между [[PromiseState]] и [[PromiseStatus]], fulfilled и resolved, [[PromiseValue]] и [[PromiseResult]]. Да, браузер сам пытается подсказать программисту о наличии и значении внутренних полей promise объекта. Также мы видим воедино связанную систему объекта promise, функции executor, специальных функций-callback-маркеров res и rej.
Чтобы ученик / напарник раскрепостился еще больше в этом материале, ему предлагается следующий код (рис. 8). Необходимо его проанализировать и ответить на следующие вопросы.
*рис 8. ( Вариация решения задачи на деление 2-х чисел через промисы )*
Отработает ли код? Где здесь функция executor и какое она имеет имя? Подходящее ли в этом коде название «wantToDivide»? Что возвращает после себя функция bind? Почему в функцию bind аргументы передаются только на втором и третьем месте? Куда исчезли специальные функции resolve function и reject function? Каким образом необходимые вводные данные number1 и number2 попали в «план выполнения обещания»? Сколько элементов в псевдомассиве «arguments»? Можно ли по памяти восстановить то, как будет выглядеть ответ в консоли браузера?
Читателю предлагается самому подумать над ответами на вопросы. А также
поэкспериментировать в коде. Благо код небольшой и сама идея задачи — простая. Да, тут есть вопросы как на промисы, так и на общие знания JavaScript. Что поделать, везде нас поджидают неожиданности, которые не дают нам расслабиться. Как только вам станет все понятно — можно двигаться дальше.
**Посмотреть / скопировать код**
```
let number1 = Number(prompt("input number 1"));
let number2 = Number(prompt("input number 2"));
let wantToDivide = function() {
if (arguments[1] === 0) {
arguments[3]("it is forbidden to divide by zero");
return;
}
let result = arguments[0] / arguments[1];
arguments[2](result);
};
let myPromise = new Promise(wantToDivide.bind(null, number1, number2));
console.log(myPromise);
```
Рассматриваем аргументы executor-a: функции resolve и reject
------------------------------------------------------------
Итак, попили кофейку — двигаемся дальше. Рассмотрим поподробнее специальные функции resolve function и reject function, автоматически формируемые JavaScript-ом для перевода promise объекта в состояние fulfilled или rejected, символизирующее окончание выполнения обещания.
Попробуем для начала взглянуть на них просто в консоли разработчика (рис 9).
*рис 9. ( Исследование функции resolve function — res )*
Мы видим, что resolve function представляет собой функцию, которая принимает один аргумент (свойство length === 1). А её прототипом является Function.prototype.
Хорошо, продолжим эксперименты. А что будет, если ссылку на resolve / reject function вынесем из executor-а во внешнюю область видимости? Не поломается ли чего (рис. 10)?
*рис 10. ( Переводим промис myPromise в состояние fulfilled снаружи промиса )*
Ничего необычного. Функции как подвид объекта в JavaScript передаются по ссылке. Все отработало так, как мы и ожидали. В переменную из замыкания outerRes попала ссылка на нашу resolving function res. И мы воспользовались её функциональностью, чтобы перевести промис в состояние fulfilled снаружи самого executor-а. Следующий слегка модифицированный пример показывает ту же самую мысль, поэтому посмотрите на код и подумайте, в каком состоянии и с каким значением будут находиться myPromise1 и myPromise2 (рис.11). Потом можете проверить ваши предположения под спойлером.
*рис 11. ( Задачка на размышление. В каком состоянии и с каким значением будут находиться промисы myPromise1 и myPromise2 в консоли разработчика? )*
**Ответ к задаче на рисунке 11 (рис. 12).**
*рис 12. ( Ответ к задаче на рисунке 11 )*
А теперь можно задуматься над одним интересным вопросом. А как resolve / reject function всегда точно знает какой promise объект переводить в необходимое состояние? Обратимся к [алгоритму в спецификации](https://www.ecma-international.org/ecma-262/7.0/#sec-createresolvingfunctions), где описано, как эти функции создаются (рис. 13).
*рис 13. ( Особенности создания resolving functions для одного конкретного promise объекта )*
Важные моменты, на которые надо обратить внимание:
* в момент создания функций resolve / reject они жестко привязываются к единственному соответствующему ему объекту promise
* у функций resolve / reject как объектного типа данных существуют свои скрытые поля [[Promise]] и [[AlreadyResolved]], которые обеспечивают всем так знакомую интуитивную логику того, что а) — resolving functions сами собой переводят promise объект в необходимое состояние; и факт того, что б) — промис нельзя перевести в другое состояние, если хоть раз над ним вызывалась resolve или reject function. Данный алгоритм можно представить следующим рисунком (рис. 14).
*рис 14. ( Скрытые поля функций resolve function и reject function )*
Алгоритмы, которые используют данную информацию из скрытых полей, сейчас не будем рассматривать, так как они многословные и более сложные. К ним еще надо подготовиться как в теоретическом, так и в моральном плане. Пока что просто могу подтвердить вашу мысль: «Ух, как просто, оказывается. Наверное, при каждом разрешении / резолвинге promise объекта будет проверяться „объектный“ флаг { [[Value]]: false }. И если он установлен в true, останавливаем процесс перевода promise в другое состояние простым return-ом». Да — это происходит именно так. Думается, правильно ответить на следующий вопрос вы сможете без проблем. Какой будет результат в консоли разработчика (рис. 15)?
*рис 15. ( Эксперимент, показывающий связь resolve и reject functions c одним конкретным promise объектом )*
Алгоритм создания promise объекта по спецификации ECMAScript
------------------------------------------------------------
Рассмотрим тот завораживающий момент, когда на свет рождается он — полноценный [promise объект](https://www.ecma-international.org/ecma-262/7.0/#sec-promise-executor) (рис. 16).
*рис 16. ( Алгоритм создания promise объекта из EcmaScript спецификации )*
Никаких сложных вопросов при его просмотре возникать уже не должно:
+ конструктор Promise должен быть вызван обязательно в режиме конструктора, а не обычного вызова функции
+ конструктор Promise требует наличия executor функции
+ создаем JavaScript объект со специфическими скрытыми полями
+ инициализируем скрытые поля какими-то начальными значениями
+ создаем связанные с promise объектом функции resolve и reject
+ вызываем на исполнение executor функцию, передавая туда в качестве аргументов уже сформированные маркеры resolve function и reject function
+ если в процессе выполнения executor-a что-то пошло не так, переводим наш promise объект в состояние rejected
+ возвращаем в переменную родившийся на свет promise объект.
Не знаю, стало ли для вас открытием, что алгоритм executor функции выполняется здесь и сейчас, в обычном синхронном режиме, еще до того, как что-то будет записано в переменную слева от конструктора Promise. Но в свое время для меня это стало откровением.
Раз уж затронули тему синхронности и асинхронности, то вот вам следующий код «на подумать» или для экспериментов. Вопрос: просмотрев некое творение программиста Димы, сможете ли вы ответить, какой смысл игры закодирован ниже?
```
function randomInteger(min, max) {
return Math.floor(min + Math.random() * (max + 1 - min));
}
function game() {
let guessCubeNumber = Number(prompt("Throw dice? Guess number?", 3));
console.log("throwing dice ... wait until it stop");
let gameState = new Promise(function(res, rej) {
setTimeout(function() {
let gottenNumberDice = randomInteger(1, 6);
gottenNumberDice === guessCubeNumber
? res("you win!")
: rej(`you loose. ${gottenNumberDice} points dropped on dice`);
}, 3000);
});
return gameState;
}
console.log(game());
```
Конечно же, это эмуляция броска игрального кубика. Сможет пользователь угадать выпавшее число или нет? Посмотрите как органично асинхронный setTimeout встраивается в синхронный executor — в наш план бросить кубик и узнать выпавшее число. Как можно уже по-особому интерпретировать результаты в консоли разработчика (рис. 17)?
Если мы попробуем посмотреть промис до того времени, как кубик остановится (3000 мс указано в коде), то мы увидим, что промис до сих пор находится в состоянии ожидания: игра не завершилась, кубик еще не остановился, выпавшего числа нет. Если же мы попробуем посмотреть promise объект после остановки кубика, то мы увидим вполне конкретную информацию: выиграл ли пользователь (угадав число), или проиграл и почему (какое число выпало на самом деле).
*рис 17. ( Состояние promise объекта при наличие асинхронной операции в executor функции )*
Если вас заинтересовал данный пример, или вы хотите угадать выпавшее число подброшенного кубика — можете скопировать код и провести свои эксперименты. Смелей!
Promise reaction как последствие исполненного обещания
------------------------------------------------------
Как вы могли заметить на рисунке 14, последствия разрешения / резолвинга promise объекта подписаны как «+реакция» и «-реакция». Официальный термин для этих слов из ECMAScript спецификации — promise reaction. Предполагается, что в следующих статьях эта тема будет рассмотрена подробно. Пока что ограничимся общим представлением того, что такое promise reaction, чтобы можно было правильно ассоциировать этот термин с философским смыслом этого слова и его техническим исполнением.
Как мы помним, у обещания могут быть последствия, а могут и не быть. Что же такое последствие? Это действие, которое произойдет некоторым временем позже: после того как обещание исполнится. А раз это действие, то последствие может быть выражено обычной JavaScript функцией. Одни функции исполнятся в случае успешного резолвинга промиса (+реакция); другие функции — в случае, когда промис перейдет в состояние rejected (-реакция). Технически эти функции (последствия) передаются аргументами при вызове метода Promise.prototype.then().
Таким образом важной частью promise reaction является асинхронное действие, выполняемое когда-то в будущем. Есть и вторая важная составляющая часть promise reaction — это новосозданный промис, возвращаемый после выполнения команды Promise.prototype.then(). Это связано с тем, что последствия влияют на другие обещания. Например, есть обещание купить машину, но только после того, как будет выполнено обещание по зарабатыванию определенной суммы денег. Выполнили одно обещание — отработало последствие — теперь можно выполнить второе.
По факту promise reaction связывает обещания между собой в каком-то временном интервале. Важно помнить тот момент, что реакции обрабатываются в автоматическом режиме. Вызовы функций — последствий разрешения промиса — осуществляются движком JS, не программистом (рис. 18). И, так как реакции тесно связаны с самими promise объектами (обещаниями), логично предположить, что алгоритмы promise reaction используют их внутренние поля в своей логике. И лучше знать о всех этих нюансах, чтобы уметь осознанно контролировать асинхронную логику, построенную на обещаниях.
*рис 18. ( Последствия разрешения обещания записываются callback функциями в методе then(). Callback будет вызван асинхронно автоматически движком JS )*
Подводим итоги
--------------
1) Мы познакомились с обещаниями в JavaScript, их философией и техническим исполнением. Реализовано все это с помощью специальных внутренний полей promise объекта: [[PromiseState]], [[PromiseValue]], [[PromiseFulFillReactions]], [[PromiseRejectReactions]].
2) Программисту дается возможность выполнить заявленное им обещание через функцию executor, передаваемую аргументом в конструктор Promise.
3) Границы выполненного или невыполненного обещания определяются специальными маркерами-функциями resolve function и reject function, часто в коде именуемыми res и rej. Данные функции создаются автоматически JavaScript-ом и передаются аргументами в executor.
4) resolve function и reject function всегда имеют связанный с ними promise объект, а также общее специальное поле { [[Value]]: false }, которое обеспечивает разрешение обещания только один раз.
5) [[PromiseFulFillReactions]] и [[PromiseRejectReactions]] являются внутренними полями promise объекта, которые хранят последствия разрешения обещания, важной частью которых являются пользовательские асинхронные функции, задаваемые через метод Promise.prototype.then() promise объекта.
P. S.
-----
Данная статья подготовлена как конспект видеозанятия группы [InSimpleWords](https://youtu.be/2qL2IxD2pUI?list=PLF5GvE7BxzVFDjOL1IZCr0okJqbhJcjGp&t=1). Там достаточно подобных «видеозанятий» и есть еще материал для конспектирования. Другой вопрос — интересно ли будет участникам сообщества читать уже какую по счету статью про промисы? Ждем ваших комментариев. | https://habr.com/ru/post/478938/ | null | ru | null |
# 8 советов для более эффективной работы с Git
*Привет, мне показалось хорошей идеей начать переводить не только релизные посты из [блога ГитЛаба](https://about.gitlab.com/blog/). Для разминки я взял этот пост почти наугад, так что не судите строго. Буду рад, если поможете определиться с выбором статьи для перевода, выбрав один из вариантов в опроснике*
---
Git – это система контроля версий с огромным количеством возможностей. Пытаться изучить их все довольно утомительно, поэтому большинство пользователей ограничивается использованием лишь базового набора команд. В этой статье представлены несколько советов по работе с Git, о которых вы, возможно, не знали. Эти советы помогут вам оптимизировать ваш процесс разработки.
Алиасы
------
Одним из лучших способов упрощения работы с Git является использование алиасов для часто используемых команд. Это поможет сохранить время при наборе команд в терминале.
Например, алиасы для команд `checkout`, `commit` и `branch` можно создать следующим образом:
```
git config --global alias.co checkout
git config --global alias.ci commit
git config --global alias.br branch
```
Теперь вместо `git checkout master` достаточно ввести `git co master`.
Также можно изменять и добавлять алиасы напрямую редактируя файл `~/.gitconfig`:
```
[alias]
co = checkout
ci = commit
br = branch
```
Скрытие (stashing) изменений до коммита
---------------------------------------
Представим, что в процессе работы над новой фичей возникла срочная необходимость внести изменения в проект. Коммитить незавершенную функциональность — не лучшее решение, но терять все наработки по ней тоже не хочется.
При помощи команды `git stash` можно временно отменить внесенные изменения, не удалив их окончательно:
```
$ git stash
```
Эта команда временно скрывает внесенные изменения и оставляет чистую рабочую копию. Теперь можно переключиться на другую ветку для внесения срочных изменений, не оформляя уже сделанные изменения как коммиты.
Чтобы вернуть скрытую функциональность, достаточно ввести:
```
$ git stash pop
```
Если же скрытая функциональность больше не нужна, ее можно удалить с помощью:
```
$ git stash drop
```
Сравнение коммитов из командной строки
--------------------------------------
Быстрым и легким способом сравнения изменений между коммитами или версиями одного и того же файла является использование команды `git diff`.
Для сравнения состояний одного и того же файла между коммитами нужно ввести:
```
$ git diff $start_commit..$end_commit -- path/to/file
```
Для сравнения изменений между двумя коммитами:
```
$ git diff $start_commit..$end_commit
```
Эти команды выведут результат в текстовом виде прямо в окно терминала. Для более наглядного результата можно использовать `git difftool`. Данная команда запускает специальную программу для сравнения изменений. Одной из таких программ является Meld.
Для настройки Meld введите:
```
$ git config --global diff.tool git-meld
```
Теперь ее можно использовать:
```
$ git difftool $start_commit..$end_commit -- path/to/file
# или
$ git difftool $start_commit..$end_commit
```
Откат изменений
---------------
Иногда при работе над кодом становится понятно, что внесенные изменения оказались ненужными/неверными и их необходимо откатить. Вместо того, чтобы делать undo по каждому изменению, достаточно сделать reset файлов на HEAD-коммит ветки:
```
$ git reset --hard HEAD
```
Или, для одного конкретного файла:
```
$ git checkout HEAD -- path/to/file
```
Далее, если ненужные изменения уже были закоммичены, для их отката нужно ввести:
```
$ git reset --soft HEAD~1
```
Более эффективное использование Git blame
-----------------------------------------
Git blame используется для того, чтобы узнать, кто внес изменения в определенную строку файла. Существует набор флагов, которые можно передавать данной команде, в зависимости от того, что вы хотите вывести:
```
$ git blame -w # игнорировать знаки табуляции
$ git blame -M # игнорировать перемещения текста
$ git blame -C # игнорировать перемещения текста в другие файлы
```
---
Помимо описанных выше советов по работе с командами, существует несколько общих советов по работе с Git.
Делайте пулл часто
------------------
Если вы используете [GitLab Workflow](https://about.gitlab.com/2014/09/29/gitlab-flow/), значит вы работаете в ветках для выделенной функциональности (feature branches). Пока вы работаете над фичей в отдельной ветке, в мастер-ветке может произойти множество изменений, некоторые из которых могут конфликтовать с добавленными фичами.
Для того, чтобы избежать подобных конфликтов, нужно как можно чаще пуллить изменения из мастер-ветки в вашу. Это позволит разрешать возможные конфликты по мере их появления и сделает последующий мерж вашей ветки гораздо более легким.
Частые коммиты, редкие пуши
---------------------------
Частые коммиты логически разделяют добавленную функциональность и позволяют откатывать отдельные ее части при необходимости. Однако нет никакой необходимости пушить каждый коммит на сервер: единственное, к чему это приведет – засорение истории изменений. Пушьте только тогда, когда ваша фича готова.
Пуш только после тестирования изменений
---------------------------------------
Хорошим знаком того, что изменения готовы к пушу, является успешное прохождение тестов. Также это как правило значит, что данный блок реализуемой функциональности завершен, и можно переключить свои усилия на следующий. Делайте пуш изменений только после прохождения всех тестов, с последующим повторным их прохождением на стороне CI-сервера. | https://habr.com/ru/post/307526/ | null | ru | null |
# Прощай, Grails. Привет, Micronaut. Продолжение
Это вторая статья из цикла о миграции из Grails в Micronaut. *Обратите внимание:* ваше приложение должно быть создано в Grails 4.x или более поздней версии*.*
Всего в цикле публикаций о миграции из Grails в Micronaut 10 частей:
Многомодульный проект
Конфигурация
Статическая компиляция
Датасеты
Маршалинг
Классы предметной области
Сервисы
Контроллеры
Приложение Micronaut
Micronaut Data
В этой статье поговорим о датасетах, маршалинге и классах предметной области.
Первую статью (о многомодульных проектах, конфигурации и статической компиляции) можно прочитать [**здесь.**](https://habr.com/ru/company/otus/blog/593895/)
Часть 4. Датасеты
-----------------
Для критически важных компонентов приложения стоит написать тесты, на случай если миграция пойдет не по плану (а такое вполне может произойти). А чтобы тесты были эффективными, нужны имеющие смысл данные. В этой статье мы расскажем, как создать датасеты с помощью фреймфорка Dru: он уже поддерживает Grails, GORM и к тому же Micronaut Data.
Dru - Data Reconstruction Utility[agorapulse.github.io](https://agorapulse.github.io/dru/)Dru отлично справляется с созданием отношений между различными сущностями, но мы не будем вдаваться в подробности. Если вы хотите узнать больше об этом фреймворке, лучше обратитесь к документации.
Допустим, в нашей кодовой базе есть простой класс предметной области:
```
class Vehicle {
String name
String make
String model
static constraints = {
name maxSize: 255
make inList: ['Ford', 'Chevrolet', 'Nissan', 'Citroen']
model nullable: true
}
}
```
Чтобы определить набор данных для сущности, мы обычно берем файл в формате JSON или SQL. Посредством JSON можно получать данные из тестовой или рабочей среды, а с помощью SQL можно использовать упрощенные дампы базы данных. Чтобы включить Dru в параметр classpath, обновите Gradle-файл приложения, используя следующие зависимости:
```
dependencies {
// other dependencies
testCompile "com.agorapulse:dru:0.8.1"
testCompile "com.agorapulse:dru-client-gorm:0.8.1"
testCompile "com.agorapulse:dru-parser-json:0.8.1"
}
```
В этом фрагменте показано, как применять JSON-фикстуры для загрузки тестовых данных:
```
import com.agorapulse.dru.Dru
import com.agorapulse.dru.PreparedDataSet
import groovy.transform.CompileStatic
@CompileStatic
class HelloDataSets {
public static final PreparedDataSet VEHICLES = Dru.prepare {
from 'vehicles.json', {
map { to Vehicle }
}
}
}
```
Если класс `HelloDataSet` объявлен внутри `hello`, то JSON-файл с тестовыми данными для нашего класса `Vehicle` будет здесь: `src/test/resources/hello/HelloDataSet/vehicles.json`.
```
[
{
"name": "The Box",
"make": "Citroen",
"model": "Berlingo"
}
]
```
Наш датасет заслуживает отдельной спецификации, поскольку многие другие тесты будут зависеть от правильной загрузки данных:
```
import com.agorapulse.dru.Dru
import grails.testing.gorm.DataTest
import spock.lang.AutoCleanup
import spock.lang.Specification
class HelloDataSetsSpec extends Specification implements DataTest {
@AutoCleanup Dru dru = Dru.create(this)
void 'vehicles are loaded'() {
given:
dru.load(HelloDataSets.VEHICLES)
when:
Vehicle box = Vehicle.findByName('The Box')
then:
box
box.name == 'The Box'
box.make == 'Citroen'
box.model == 'Berlingo'
}
}
```
Созданные датасеты в будущем помогут нам в написании тестов для контроллеров, а также в миграции из GORM в Micronaut Data.
Теперь давайте перейдем к [отделению веб-уровня от уровня предметной области](https://medium.com/p/7b69d9a132bc) путем передачи объектов переноса данных (DTO) в контроллеры.
---
Часть 5. Маршалинг
------------------
Контроллеры ответственны за связь с другими уровнями приложения, включая фронтенд. Нужно убедиться, что API не изменится и приложение будет потреблять и выдавать те же данные, что и до миграции. Для этого отлично подойдет тестовый фреймворк Gru, поддерживающий Grails и Micronaut. Gru может оценивать ответы от контроллеров.
Gru - Groovy HTTP Testing Framework[agorapulse.github.io](https://agorapulse.github.io/gru/)Вы можете добавить Gru в свой проект, указав следующую зависимость в файле Gradle подпроекта вашего приложения:
```
testCompile 'com.agorapulse:gru-grails:0.9.2'
```
Допустим, у нас есть простейший контроллер, который рендерит только одну сущность.
Напишем простой тест, который будет проверять JSON-вывод контроллера.
```
class VehicleController {
VehicleDataService vehicleDataService
Object show(Long id) {
Vehicle vehicle = vehicleDataService.findById(id)
if (!vehicle) {
render status: 404
return
}
render vehicle as JSON
}
}
```
Возьмем датасет, созданный на предыдущем этапе, чтобы загрузить тестовые данные для рендеринга. Файл vehicle.json создается автоматически при первом запуске. Однако нам нужно повторно проверить его на предмет таких значений переменных, как временные метки. В [справочной документации](https://agorapulse.github.io/gru/#json-payload) описаны дополнительные операции, такие как игнорирование меток времени.
Мы написали тесты для текущего вывода. Теперь пришло время переключить внутреннюю часть на `ObjectMapper`.
В нашем случае класс `VehicleResponse` выглядит как простая сущность `Vehicle`:
```
import com.agorapulse.dru.Dru
import com.agorapulse.gru.Gru
import com.agorapulse.gru.grails.Grails
import grails.testing.gorm.DataTest
import grails.testing.web.controllers.ControllerUnitTest
import spock.lang.AutoCleanup
import spock.lang.Specification
class VehicleControllerSpec extends Specification implements ControllerUnitTest, DataTest {
@AutoCleanup Dru dru = Dru.create {
include HelloDataSets.VEHICLES
}
@AutoCleanup Gru gru = Gru.create(Grails.create(this)).prepare {
include UrlMappings
}
void 'render with gru'() {
given:
dru.load()
controller.vehicleDataService = Mock(VehicleDataService) {
findById(1) >> dru.findByType(Vehicle)
}
expect:
gru.test {
get '/vehicle/1'
expect {
json 'vehicle.json'
}
}
}
}
```
Мы хотим убедиться, что под капотом не запускается маршалинг, связанный с Grails. В дальнейшем это поможет нам перейти на контроллеры Micronaut, а также на Micronaut Data.
Текущие тесты не сработают из-за отсутствия бина `ObjectMapper`. К счастью, это легко исправить с помощью метода doWithSpring: просто объявите бин `ObjectMapper`.
На следующем этапе мы извлечем [классы предметной области](https://medium.com/p/ad2d2782059f) в отдельную библиотеку.
---
Часть 6. Классы предметной области
----------------------------------
Как правило, классы предметной области выступают важными компонентами любого приложения Grails, поэтому их сложнее всего переносить. Для начала нам нужно перенести все вызовы, связанные с базой данных, чтобы во всех случаях использовать сервисы данных вместо *«магических»* методов и свойств (включая статические методы/свойства и методы/свойства экземпляра).
GORM for Hibernate[gorm.grails.org](http://gorm.grails.org/7.0.x/hibernate/manual/index.html)Мы можем с легкостью создать сервис данных для класса предметной области `Vehicle`, с которым мы начали работать ранее:
```
import grails.gorm.services.Service
import groovy.transform.CompileStatic
@Service(Vehicle)
@CompileStatic
interface VehicleDataService {
Vehicle findById(Long id)
}
```
Мы уже пользовались таким сервисом в контроллере на предыдущем этапе.
### Поиск метода GORM с помощью системы контроля версий
Самая сложная задача — найти все случаи использования экземпляра GORM и статического API.
Для начала найдем все случаи использования сущности. Самый простой способ — зафиксировать всю работу в системе контроля версий: так ваша IDE выполнит всю сложную работу по поиску ссылок. Выберите одну из сущностей и перенесите ее в другой пакет. Можно, например, добавить `.legacy` к имени вашего пакета: так класс `Vehicle` из `hello` переместится в `hello.legacy`.
Не забудьте переместить сервис данных!
Взглянем на список измененных файлов в системе контроля версий: он должен содержать все классы, относящиеся к определенному классу предметной области.
Теперь заменим все вызовы статических методов и методов экземпляра GORM в этих файлах. Например, поменяем `Vehicle.get(id)` на `vehicleDataService.findById(id)`. Мы можем имитировать в тестах работу `vehicleDataService` или реализовать настоящее тестирование с тестовым хранилищем данных. Последняя процедура подробно описана в этой статье:
How to Use GORM Data Services in Test[medium.com](https://medium.com/agorapulse-stories/how-to-use-gorm-data-services-in-test-cf1839aca530)Давайте еще раз перечислим действия, которые нужно выполнить для каждого класса предметной области:
1. Зафиксировать все изменения в системе контроля версий.
2. Переместить класс предметной области в отдельный пакет (например, `original.legacy`).
3. Создать новый сервис данных для предметной области или переместить существующий в тот же пакет.
4. Проверить все измененные файлы в системе контроля версий.
5. Заменить методы GORM вызовами сервиса данных.
6. Повторяйте эти шаги для каждого класса предметной области, пока не перенесете их все.
Поиск методов GORM во время компиляции
--------------------------------------
После выполнения описанных выше шагов могут остаться некоторые хорошо скрытые вызовы статических методов и методов экземпляра GORM. Чтобы найти их, воспользуемся проверкой кода Groovy для GORM (Groovy Code Check for GORM):
```
compileOnly 'com.agorapulse:groovy-code-checks-gorm:0.9.0'
```
Groovy Code Checks[agorapulse.github.io](https://agorapulse.github.io/groovy-code-checks/)Это строгая библиотека: она будет выдавать ошибки компиляции каждый раз, когда находит метод, связанный с GORM. Это очень полезно для поиска случаев непрямого использования (например, `user.vehicle.save()`), когда методы GORM вызываются не напрямую из объекта сущности, а по ссылке.
Ошибки компиляции также могут возникнуть из-за изменения конфигурационного файла Enterprise Groovy `convention.groovy`.
```
Map conventions = [
disable : false,
whiteListScripts : true,
disableDynamicCompile : false,
dynamicCompileWhiteList : [
'UrlMappings',
'Application',
'BootStrap',
'resources',
'org.grails.cli'
],
limitCompileStaticExtensions: false,
defAllowed : false, // For controllers you can use Object in place of def, and in Domains add Closure to constraints/mappings closure fields.
skipDefaultPackage : true, // For GSP files
compileStaticExtensions : [
'org.grails.compiler.ValidateableTypeCheckingExtension',
'org.grails.compiler.NamedQueryTypeCheckingExtension',
'org.grails.compiler.HttpServletRequestTypeCheckingExtension',
// 'org.grails.compiler.WhereQueryTypeCheckingExtension',
// 'org.grails.compiler.DynamicFinderTypeCheckingExtension',
// 'org.grails.compiler.DomainMappingTypeCheckingExtension',
// 'org.grails.compiler.RelationshipManagementMethodTypeCheckingExtension'
],
]
System.setProperty(
'enterprise.groovy.conventions',
"conventions=${conventions.inspect()}"
)
```
Если мы закомментируем или удалим проверяющие расширения, связанные с GORM, то получим ошибки компиляции везде, где применяется «магия» библиотеки.
### Перенос классов предметной области в библиотеку
Давайте извлечем классы предметной области в отдельный подпроект, чтобы затем создать модульную структуру для других компонентов приложения. Об этом подробно написано в отдельной статье:
How to Share GORM Domain Classes between Grails and Micronaut[medium.com](https://medium.com/agorapulse-stories/how-to-share-gorm-domain-classes-between-grails-and-micronaut-a1b938e5adc4)Если вы применяли структуру Kordamp, просто создайте новую папку в разделе `libs` (например, `hello-data`), где будет файл сборки `hello-data.gradle`.
```
sourceSets {
main {
groovy {
// the source folder for the GORM domain classes
srcDir 'grails-app/domain'
// if you also want to include some services
srcDir 'grails-app/services'
}
}
}
dependencies {
// GORM
compile "org.grails:grails-datastore-gorm-hibernate5:${project['gorm.hibernate.version']}"
// required for Grails Plugin generation
compileOnly "org.grails:grails-core:$grailsVersion"
// required for Micronaut service generation, if present
compileOnly "io.micronaut:micronaut-inject-groovy:$micronautVersion"
// required for jackson ignores generation for Micronaut
compileOnly 'com.fasterxml.jackson.core:jackson-databind:2.8.11.3'
}
```
Также стоит объявить основной репозиторий Grails (Grails Central) в корневом файле `build.gradle` для всех проектов:
```
allprojects {
repositories {
mavenCentral()
maven { url 'https://repo.grails.org/grails/core/' }
}
}
```
Добавляем два новых свойства в файл `gradle.properties`:
```
gorm.hibernate.version = 7.0.5
micronautVersion = 1.3.7
```
Нам также понадобится поддельный дескриптор плагина Grails в папке `src/main/groovy`:
```
@CompileStatic
class HelloDataGrailsPlugin {
String grailsVersion = '3.3.0 > *'
String title = 'GORM Hello Data'
String author = 'Vladimir Orany'
String authorEmail = 'vlad@agorapulse.com'
String description = 'Mimicking Grails Plugin'
}
```
Далее создаем папки `grails-app/domains` и `grails-app/services` в новой библиотеке данных.
Теперь добавляем новую библиотеку в качестве зависимости в приложение Grails в файле `hello.gradle`:
```
implementation project(':hello-data')
```
В IntelliJ IDEA можно легко переместить пакеты с сущностями предметной области в новую библиотеку. Выбираем исходный пакет, затем в меню сверху нажимаем *Refactor -> Move Package or Directory…* (горячая клавиша по умолчанию — *F6*).
Выбираем *Move directory… to another source root*.
Выбираем папку `grails-app/domain` в качестве целевого расположения:
Проверим все предметные области в новой библиотеке данных и добавим аннотацию `grails.gorm.annotation.Entity`.
```
@Entity
class Vehicle {
String name
String make
String model
static constraints = {
name maxSize: 255
make inList: ['Ford', 'Chevrolet', 'Nissan']
model nullable: true
}
}
```
Наконец переносим связанные сервисы данных GORM в папку `grails-app/services`: теперь весь код, относящийся к классам предметной области, должен быть в отдельной библиотеке.
### Перенос тестовых данных в библиотеку
Переходим к следующему шагу: создадим еще одну библиотеку, где будут тестовые данные, чтобы в будущем обращаться к ним откуда угодно.
Создадим новую папку `hello-data-test-data` с новым файлом сборки `hello-data-test-data.gradle.`
```
dependencies {
api project(':hello-data')
api 'com.agorapulse:dru-client-gorm:0.8.1'
api 'com.agorapulse:dru-parser-json:0.8.1'
testImplementation("org.spockframework:spock-core") {
exclude group: "org.codehaus.groovy", module: "groovy-all"
}
}
```
Переносим классы тестовых данных вроде `HelloDataSets` в папку `src/main/groovy`.
Переносим тестовые данные вроде `vehicle.json` в папку `src/main/resources.`
Переносим тесты для датасетов вроде `HelloDataSetsSpec` в папку `src/test/groovy`, чтобы данные проходили необходимые проверки.
Не забудьте добавить зависимость для новой библиотеки тестовых данных в файл сборки приложения — `hello.gradle`.
```
testCompile project(':hello-data-test-data')
```
После извлечения классов предметной области мы также можем [извлечь сервисы в отдельную библиотеку](https://medium.com/p/f7d1ba4025f2) — об этом читайте в следующей статье.
Оригиналы публикаций: [часть 4](https://medium.com/agorapulse-stories/goodbye-grails-hello-micronaut-4-datasets-440c8b50fb56), [часть 5](https://medium.com/agorapulse-stories/goodbye-grails-hello-micronaut-5-marshalling-7b69d9a132bc), [часть 6](https://medium.com/agorapulse-stories/goodbye-grails-hello-micronaut-6-domain-classes-ad2d2782059f).
---
> Материал подготовлен в рамках [курса «Groovy Developer».](https://otus.ru/lessons/groovy-developer/?utm_source=habr&utm_medium=affilate&utm_campaign=groovy&utm_term=11.12.21)
>
> Groovy имеет множество замечательных функций для написания DSL.
> Они позволяют создавать удобные библиотеки для разработки, декларативные конфигурации в виде кода, а также инструменты, которые позволяют описывать сценарии без навыков программирования.
>
> Всех желающих приглашаем на бесплатное demo-занятие **«Groovy DSL. Создание инструментов для разработки»**. На занятии рассмотрим такие функции, как: Chains, Script Engine, Operator Overloading, Categories, Closures, AST-трансформации, и другие.
> [**>> РЕГИСТРАЦИЯ НА ЗАНЯТИЕ**](https://otus.pw/865B/)
>
> | https://habr.com/ru/post/593965/ | null | ru | null |
# Celesta и Flute: Создание бизнес-логики в Java-экосистеме
Привет, Хабр! Проект, о котором мы расскажем, с самого начала создавался нами как open-source, но до недавних пор мы использовали его только лишь для своих нужд, не говорили о нём широко и не создавали коммьюнити. Cейчас, спустя несколько лет разработки, мы почувствовали уверенность в том, что настала пора рассказать про него, и надеемся, что он начнёт приносить пользу не только нам.
Celesta ([челеста](https://ru.wikipedia.org/wiki/%D0%A7%D0%B5%D0%BB%D0%B5%D1%81%D1%82%D0%B0)) — «движок» бизнес-логики на языке Jython, встраиваемый в Java-приложения. Flute (флейта) — компонент, который позволяет работать челесте как сервису. Сначала мы расскажем о том, зачем такое вообще бывает нужно, но если вы хотите пропустить вступление и перейти сразу к технической части, то вам — в Часть II.
Часть I, вводная
----------------
### Для чего нужна Celesta?
Решаемая проблема такова: как встроить бизнес-логику в Java-приложение или, шире, в приложение, работающее в Java-экосистеме.
Казалось бы, зачем тут изобретать очередной «велосипед»? Ведь мы знаем, что есть специальные системы для работы с бизнес-логикой и написания бизнес-приложений. Самая распространённая в России — «1C», есть Microsoft Dynamics, SAP и многие другие. Причём в работе с подобными программными продуктами задействовано, судя по всему, не меньше половины всех ИТ-специалистов по всему миру. По крайней мере, основатель «1C» [утверждает](https://roem.ru/08-06-2015/197404/1s-nuraliev-view/), что из миллиона ИТ-специалистов в России треть — специалисты «1С».
В то же время, всегда есть более локальные задачи, где привлечение подобных систем проблематично. Допустим, имеется интернет-магазин, а «позади» него должна стоять некоторая бизнес-логика, обрабатывающая заказы. Можно ли поставить для обработки бизнес-логики одну из вышеперечисленных больших систем? Вполне. Но неудобство заключается в том, что если весь магазин, допустим, написан в Java-экосистеме, то система создания бизнес-приложений — уже совсем не в Java-экосистеме, что затрудняет интеграцию. Система дорога в лицензировании и поддержке, требует особых специалистов. А задачи, которые в этих случаях возлагаются на данную систему, не такие уж глобальные. Цена вопроса оказывается неоправданно высокой, и решение калибра Celesta может выглядеть неплохой альтернативой.
Очень часто возникают задачи, связанные с реализацией какого-либо процесса работы с документом. Например, согласование договора или заявки на оплату. Классическим решением является использование систем типа Documentum, Alfresco и т.п. (часто используется термин CMS + BPM, т.е. Управление контентом + Управление бизнес-процессами). Однако, это все довольно сложные инфраструктурные системы. Имеет смысл их использовать, если необходимо обеспечивать работу с большим количеством документов разного типа и поддерживать много бизнес-процессов. А если не хочется выходить за рамки конкретного проекта? Celesta + [Activiti](https://www.activiti.org/) прекрасно решат задачу. Celesta при этом обеспечит содержательную работу с документом, а Activiti будет показывать, что и в каком порядке должно выполняться.
Поэтому мы решили создать решение, которое позволило бы нам, не выходя за пределы Java-экосистемы, и не вводя новые большие составляющие в инфраструктуру, создавать вполне эффективные модули, управляющие бизнес-логикой, необходимые нашему заказчику.
За несколько лет работы мы внедрили решения на базе нашей платформы в достаточно многих организациях, некоторые из которых [перечислены](https://corchestra.ru#users) на сайте платформы.
### Чем «бизнес-логика» отличается от просто логики?
Почему вообще нужны особенные системы для бизнес-логики? Почему «нельзя просто взять» и написать на Java, скажем, учёт финансов или товарных остатков? Ведь, казалось бы, какая разница, где складывать денежные суммы — в Java или в 1C (в Java, причём, вычисления-то наверняка побыстрее будут). Почему же у нас есть 1C, SAP и им подобные платформы?
Проблема в первую очередь заключается в **изменчивости** логики системы. Бизнес-приложение невозможно создать «раз и навсегда»: изменения в требования к бизнес-приложению поступают непрерывным потоком на всех этапах его жизненного цикла: разработки, внедрения, эксплуатации — потому что живёт и развивается бизнес-процесс, который приложение должно автоматизировать. Можно подумать, что такое количество изменений — результат неправильного первоначального анализа или плохой организации всего процесса. Но нет, это объективное свойство реальной жизни, причём не только в коммерческих организациях. Например, в государственных структурах требования по сути определяются нормативными документами (законами, постановлениями, приказами и т.п.). Бывает так, что проект для государственной структуры надо сдавать к некоторой дате, но до последнего момента неизвестно, подпишет или не подпишет премьер-министр постановление, от которого будут зависеть функциональные требования к системе, неизвестно бывает и его точное содержание.
Другая специфическая черта бизнес-приложений — **потребность в обеспечении целостности данных**. Если у нас учтена продажа, она должна отразиться во всех необходимых книгах операций. Если, скажем, продажа, отражаясь в подсистеме, ответственной за логистику, не отражается в бухгалтерском балансе — это приведет к большим проблемам.
Третья специфическая особенность — **невозможность спрогнозировать требования доступа к данным**. На начальном этапе даже бывает невозможно чётко определить, в каком формате данные потребуются на выходе, как они будут сегментированы, в каких документах. Необходимо закладывать такую систему, чтобы вывод данных можно было изменять достаточно быстро, на ходу.
Как обычно решения для бизнес-логики справляются с этими задачами?
Во-первых, за счёт разделения кода на платформу и бизнес-логику. Это применяется во всех системах такого класса. Есть код платформы, обеспечивающий базовые вещи, и есть код бизнес-логики, который пишется чаще всего на специализированном языке: например, 1C, Microsoft Dynamics и SAP предлагают собственные языки для написания бизнес-логики.
Код платформы, решающий самые базовые задачи, производят авторы платформы и изменяют его только вместе с выходами новых версий платформы. Код бизнес-логики изменяется разработчиками бизнес-логики постоянно.
Во-вторых (в наше время это особенно приходится подчеркнуть) – использование реляционных СУБД. Несмотря на сильное развитие NoSQL-баз, для решения задач построения бизнес-логики на сегодня лучшим инструментом остаются реляционные СУБД. Лучшим — хотя бы потому, что это более старые, более зрелые проекты. Все основные преимущества реляционных СУБД, не присутствующие во многих из NoSQL-баз, остаются востребованными. Это и атомарность операций — возможность в случае ошибки откатить транзакцию с большим количеством изменений, так, как будто она и не начиналась. Это и изоляция. Это и обеспечение целостности через внешние ключи. И возможность обеспечить быстрое извлечение данных в произвольном формате. Не забудем также о необходимости интеграции с огромным количеством legacy-систем, данные которых находятся в реляционных СУБД. В общем, реляционные СУБД были и остаются главным инструментом хранения данных в подобных системах.
### Чем создание бизнес-логики не отличается от «обычного» кодирования?
С вещами, делающими разработку бизнес-логики «особенной», понятно. Чем же она похожа на весь остальной программный код — будь то игры или операционные системы?
* Прежде всего, мы должны иметь стандартные инструменты контроля кода, управления версиями. Сегодня все используют Git — пусть это будет Git. Появится еще более удобный «Git++», значит пусть это будет еще более удобный «Git++». Удивительно, но у многих «больших» платформ создания бизнес-логики этот вопрос не решён: например, в системе Microsoft Dynamics код хранится непосредственно в базе данных, отсутствует даже элементарный контроль версий!
* Должен быть удобный IDE, желательно, тот, к которому все привыкли и умеют продуктивно работать: в Java-мире это IDEA или Eclipse. Производители «больших» платформ, создавая свои языки программирования, зачастую не уделяют удобству IDE должного внимания.
* Должна существовать удобная возможность тестирования кода, должны быть легко доступны модульные тесты, должна существовать возможность осуществлять test-driven development. Как и любые другие приложения, бизнес-приложения не должны ошибаться.
Бизнес-приложения должны соответствовать общей ИТ-инфраструктуре проекта.
### Где здесь место для Celesta?
На практике совместить платформу разработки бизнес-логики и перечисленные требования практически нельзя. Мы имеем две крайности.
Одна крайность – тотальное использование крупной системы типа 1C, Microsoft Dynamics, SAP и т. п. для решения вообще любых задач. Зачастую эти системы сковывают разработчиков, лишают их привычных инструментов и методов разработки (например, нельзя стандартными инструментами произвести автоматизированное тестирование), это повышает стоимость и удлиняет сроки разработки. Для типовых задач большого масштаба это оправдано, однако для небольших задач этот подход может оказаться губительным.
Противоположная крайность заключается в том, чтобы браться за любую задачу на системе разработки общего назначения. Открываем IDEA, создаём новый Java-проект, а там посмотрим — удастся или нет нам реализовать, например, для системы онлайн-продаж финансовый учёт и оборотно-сальдовую ведомость. Что в этом сложного? На первый взгляд ничего, пока не начнёте делать и не убедитесь в том, что без трудоёмкой реализации специальных паттернов и подходов сделать это нельзя, и что это отнимает все ваши ресурсы. Мы не утверждаем, что так добиться успеха невозможно, но есть определённые вещи, за которые браться не стоит.
Celesta здесь занимает промежуточное положение. Будучи Java-библиотекой (celesta.jar), она является «движком» бизнес-логики. Это «движок», который либо встраивается в Java-приложение, либо с помощью модуля Flute существует самостоятельно и обеспечивает возможность быстрой и правильной реализации бизнес-логики.
Сама Celesta написана на Java, а бизнес-логика пишется на языке Jython. Jython – это Java-реализация Python. Сейчас она имеется для версии Python 2.7. Изящность Python-кода, лёгкость освоения играли не последнюю роль при выборе языка для бизнес-логики, и он с нами уже несколько лет.
Однако мы не привязываемся к Python/Jython так уж сильно. Нам годится любой скриптовый язык, в последнее время мы присматриваемся к тому, чтобы встроить в Celesta Groovy.
Часть II, техническая
---------------------
### Что такое Celesta и что она умеет?
Место платформы Celesta как промежуточного слоя между реляционной базой и кодом бизнес-логики на общей картинке можно изобразить так:
Мы поддерживаем четыре типа реляционных БД и код бизнес-логики на Jython. При этом Celesta немного присутствует и внутри базы данных, создавая для себя служебные объекты и триггеры.
Основные функциональные возможности Celesta:
1. Принцип, очень похожий на основной принцип Java: «Write once, run on every supported RDBMS». Код бизнес-логики не знает, на каком типе базы данных он будет исполняться. **Вы можете написать код бизнес-логики и запускать его в MS SQL Server, потом перейти на PostgreSQL, и это произойдет без осложнений** (ну, почти :)
2. Автоматическое изменение структуры на «живой» базе данных. Большая часть жизненного цикла Celesta-проектов происходит, когда уже база данных есть, когда она уже наполняется реальными продуктивными данными, которые нельзя просто так куда-то деть, выкинуть и начать с нового листа. При этом необходимо менять постоянно структуру. Одна из ключевых возможностей — **Celesta сама автоматически «подгоняет» структуру БД под вашу модель данных**.
3. Тестирование. Большое внимание мы уделили тому, чтобы код под Celesta был тестируемым, чтобы мы могли **автоматически тестировать процедуры, изменяющие данные в базе, делая это легко и изящно, без использования внешних инструментов типа DbUnit и контейнеров**.
4. Легкое разворачивание изменений на «живой» системе. Мы работаем с постоянно используемой системой, и ситуация такова, что иногда какие-то исправления приходится в самый разгар работы делать и включать. Удобно, когда всё разворачивание сводится к простой подмене исходников на скриптовом языке, т. е. когда скрипт и является тем артефактом, который можно поставить на машину, избегая необходимости что-то компилировать и упаковывать.
5. Модульность решений, то есть возможность переноса какого-то стандартного куска функциональности между разными проектами. Всегда или очень часто у заказчиков есть повторяющиеся от раза к разу требования. Например, что система должна поддерживать распределение прав доступа, она должна интегрироваться с LDAP, она должна записывать все изменения, производимые в некоторых критически важных таблицах, выполнять аудит успешных/неуспешных входов. Все это настолько стандартные, частые требования, что хорошо, когда платформа их реализует раз и навсегда. Разработчик бизнес-логики использует стандартные модули и даже не думает о том, чтобы в который раз собирать «велосипед».
### Для чего нужна независимость от типа СУБД?
Независимость кода бизнес-логики от типа СУБД мы поставили первым пунктом не случайно: код, написанный для Celesta, вообще не знает, на какой СУБД он исполняется. Зачем это сделано?
Во-первых, из-за того, что выбор типа СУБД – это вопрос не технологический, а политический. Приходя к новому заказчику, мы чаще всего обнаруживаем, что у него уже есть Oracle или SQL Server, в который инвестированы средства, и заказчик хочет видеть и другие решения на существующей инфраструктуре. Технологический ландшафт постепенно меняется: в госструктурах и частных компаниях все больше встречается PostgreSQL, хотя ещё несколько лет назад в нашей практике превалировал MS SQL Server. Celesta поддерживает наиболее часто встречающиеся СУБД, и нас эти изменения не тревожат.
Во-вторых, код, уже созданный для решения стандартных задач, хотелось бы переносить от одного заказчика другому, создавать переиспользуемую библиотеку. Вещи вроде иерархических справочников или модулей рассылки уведомлений на email по сути своей стандартны, и зачем нам поддерживать несколько версий под заказчиков с разными реляционками?
В-третьих — последнее по порядку, но не важности — возможность запуска модульных тестов без использования DbUnit и контейнеров с использованием базы данных H2, работающей в режиме in-memory. В этом режиме база H2 запускается моментально. Celesta очень быстро создаёт в ней схему данных, после чего можно провести необходимые тесты и «забыть» базу. Так как код бизнес-логики действительно не знает, на какой базе он бежит, то соответственно, если он без ошибок отрабатывает на H2, то без ошибок он будет работать и на PostgreSQL. Конечно, в задачу разработчиков самой системы Celesta входит сделать все тесты с задействованием подъема реальных СУБД, чтобы убедиться, что наша платформа одинаково свой API выполняет на разных реляционках (и мы это делаем). Но разработчику бизнес-логики этого уже не требуется.
### CelestaSQL
За счет чего достигается «кроссбазданческость»? Конечно, за счёт того, что с данными можно работать только через специальный API, изолирующий логику от любой специфики БД. Celesta кодогенирирует Python-классы для доступа к данным, с одной стороны, и SQL-код и некоторые вспомогательные объекты вокруг таблиц, с другой стороны.
Celesta не предоставляет object-relational mapping в чистом виде, потому что при проектировании модели данных мы исходим не от классов, а от структуры базы данных. Т. е. сначала выстраиваем ER-модель таблиц, а затем на основе этой модели Celesta сама генерирует классы-курсоры для доступа к данным.
Достигнуть одинаковой работы на всех поддерживаемых СУБД можно только лишь для той функциональности, которая приблизительно одинаково реализована в каждой из них. Если условно в виде «кругов Эйлера» изобразить множества функциональных возможностей каждой из поддерживаемых нами баз, то получается такая картина:
Если мы обеспечиваем полную независимость от типа БД, то те функциональные возможности, которые мы открываем программистам бизнес-логики, должны лежать внутри пересечения по всем базам. На первый взгляд кажется, что это существенное ограничение. Да: какие-то специфические возможности, допустим, SQL Server мы не можем использовать. Но все без исключения базы поддерживают таблицы, внешние ключи, представления, SQL-запросы с JOIN и GROUP BY. Соответственно, мы можем дать эти возможности разработчикам. Мы предоставляем разработчикам «обезличенный SQL», который называем «CelestaSQL», а в процессе работы мы модифицируем SQL-запросы для диалектов соответствующих баз.
У каждой базы данных есть свой набор типов данных. Т. к. мы работаем через язык CelestaSQL, у нас тоже есть свой набор типов. Их всего семь, вот они и их сопоставление с реальными типами в базах:
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| | CelestaSQL | Microsoft SQL Server | Oracle | PostgreSQL | H2 |
| Integer (32-bit) | INT | INT | NUMBER | INT4 | INTEGER |
| Floating point (64-bit) | REAL | FLOAT(53) | REAL | FLOAT8 | DOUBLE |
| String (Unicode) | VARCHAR(n) | NVARCHAR(n) | NVARCHAR2(n) | VARCHAR(n) | VARCHAR(n) |
| Long string (Unicode) | TEXT | NVARCHAR
(MAX) | NCLOB | TEXT | CLOB |
| Binary | BLOB | VARBINARY
(MAX) | BLOB | BYTEA | VARBINARY
(MAX) |
| Date/Time | DATETIME | DATETIME | TIMESTAMP | TIMESTAMP | TIMESTAMP |
| Boolean | BIT | BIT | NUMBER
CHECK IN (0, 1) | BOOL | BOOLEAN |
Может показаться, что всего семь типов — это мало, но на самом деле это те самые типы, которых всегда достаточно, чтобы хранить финансовую, торговую, логистическую информацию: строк, целых чисел, дробных, дат, boolean-значений и BLOB-ов всегда хватит для представления таких данных.
Сам язык CelestaSQL описан в [документации](https://corchestra.ru/wiki/index.php?title=%D0%AF%D0%B7%D1%8B%D0%BA_Celesta-SQL) с большим количеством диаграмм Вирта.
### Модификация структуры базы данных. Идемпотентный DDL
Еще одна ключевая функциональная возможность Celesta – это подход к модификации структуры, которая должна происходить на «живой» базе данных.
Какие вообще имеются возможные подходы к решению задачи контроля изменений структуры базы данных?
Есть очень распространенный подход, который можно условно назвать *«лог изменений»*. [Liquibase](http://www.liquibase.org/) — наиболее известный в Java-мире инструмент, который решает задачу таким образом. В Python-мире тем же самым занимается фреймворк [Django](https://www.djangoproject.com/). Этот подход заключается в постепенном наращивании лога изменений базы данных, database change log. По мере того, как в структуре базы надо производить изменения, вы добавляете к этому логу инкрементные change set-ы. Постепенно ваш лог изменений накапливается, вбирая в себя всю историю модификаций вашей БД: ошибочных, исправляющих, рефакторингов и т. п. Через какое-то время изменений становится настолько много, что понять текущую структуру таблиц непосредственно по логу становится невозможно.
Хотя на сайте системы Liquibase и пишут, что их подход обеспечивает рефакторинг и контроль версий структуры базы данных — ни то, ни другое по-настоящему при помощи database change log-а не достигается. Понять это довольно просто, сравнив с тем, как вы выполняете рефакторинг обычного кода. Если, например, вам необходимо добавить какие-то методы в класс, то вы их добавляете непосредственно в определение класса, а не дописываете в change log код вроде «alter class Foo add method bar {....}». То же и с контролем версий: при работе с обычным кодом сама система контроля версий создаёт для вас лог изменений, а не вы дописываете changeset-ы в конец какого-нибудь журнала.
Понятно, что для структуры базы данных так делается неспроста: причина в том, что в таблицах базы уже существуют данные, и change set призван конвертировать не только структуру, но и ваши данные. Таким образом change log *как будто* дает уверенность в том, что вы всегда сможете обновиться с его использованием с любой версии базы данных. Но на самом деле это ложная уверенность. Ведь если вы протестировали код модификации ваших данных на какой-то копии базы данных и он сработал, нет гарантии, что он же сработает на базе с какими-то другими данными, где могут быть какие-то особые случаи, которых вы не учли в вашем changeset-е. Самое неприятное, что может случиться с такой системой — это changeset, отработавший наполовину и закоммитивший часть изменений: база оказывается «посередине» между версиями, и потребуется ручное вмешательство, чтобы исправить ситуацию.
Есть другой подход, условно назовем его *«configuration management-подход»* или иначе — «идемпотентный DDL».
По аналогии с тем, как configuration management системах типа Ansible у вас есть **идемпотентные скрипты**, которые говорят не «сделай что-то», а «приведи что-то к желаемому состоянию», точно так же и мы, когда пишем на CelestaSQL следующий текст:
```
CREATE TABLE OrderLine(
order_id VARCHAR(30) NOT NULL,
line_no INT NOT NULL,
item_id VARCHAR(30) NOT NULL,
item_name VARCHAR(100),
qty INT NOT NULL DEFAULT 0,
cost REAL NOT NULL DEFAULT 0.0,
CONSTRAINT Idx_OrderLine PRIMARY KEY (order_id, line_no)
);
```
— этот текст интерпретируется Celesta не как «создай таблицу, а если таблица уже есть, то выдай ошибку», а «приведи таблицу к желаемой структуре». То есть: «если таблицы нет — создай, если таблица есть, посмотри, какие в ней поля, с какими типами, какие индексы, какие внешние ключи, какие default-значения и т. п. и не надо ли что-то изменить в этой таблице, чтобы привести её к нужному виду».
При таком подходе мы достигаем настоящего рефакторинга и настоящего контроля версий на наших скриптах определения структуры базы:
1. Мы видим в скрипте текущий «желаемый образ» структуры.
2. Что, кем и почему в структуре изменялось со временем, мы можем посмотреть с помощью системы контроля версий.
3. Что до ALTER-команд, то их автоматически, «под капотом» формирует и выполняет Celesta по мере необходимости.
Может возникнуть вопрос: а как же быть с трансформацией данных, ведь простого ALTER не всегда достаточно? Да, действительно это работает не всегда в автоматическом режиме. Например, если мы добавим в непустую таблицу NOT NULL-поле и не снабдим его DEFAULT-значением, то Celesta не сможет добавить поле: она просто не знает, какие данные туда подставить для существующих строк, и база данных не даст такое поле создать. Но в этом нет ничего страшного. Во-первых, Celesta сигнализирует, что такой-то апдейт она выполнить полностью не сумела по такой-то причине, с такой-то ошибкой БД. В отличие от «changelog»-систем, апдейты, не выполненные до конца, для Celesta не являются проблемой, т. к. для генерации ALTER-команд она сравнивает текущее *фактическое* состояние базы с желаемым, и изменения, не выполненные при одной попытке, она будет пытаться доделать в другой. Вы, со своей стороны, можете сделать ad hoc скрипт, трансформирующий данные и «помогающий» Celesta выполнить апдейт. Этот скрипт можно отладить на тестовой базе, выполнить на продуктовой базе, закончить апдейт Celesta — после чего ваш ad hoc скрипт можно просто выкинуть, потому что больше он вам не понадобится никогда! Ведь ваша рабочая база уже находятся в нужном вам состоянии по структуре, а если вы задумаете делать новую базу «с нуля», то тогда вам не надо заставлять базу проходить весь тот путь, который вы прошли, дорабатывая её структуру в процессе разработки.
На практике, создание «вспомогательных» скриптов требуется нечасто. Абсолютное большинство изменений (добавление полей, перестройка индексов, изменение views) производятся в Celesta автоматически «на ходу».
### Структура проекта Celesta. Гранулы
Для того, чтобы начать пользоваться Celesta, нужно понять, как устроен Celesta-проект с бизнес-логикой.
Совокупность всей бизнес-логики мы называем «score» («партитура»), внутри «score» находятся «grains» — гранулы, они же модули:
Здесь пунктирными стрелками показаны зависимости, то есть гранулы могут использовать объекты из других гранул. И эти зависимости могут быть сложными, но главное ограничение состоит в том, чтобы зависимости по внешним ключам не были циклическими — это нужно для обеспечения успешного обновления структуры БД по гранулам, когда Celesta начинает с того, что выбирает правильный порядок обновления.
Что такое гранула?
С точки зрения **исходных кодов**, гранула – это папка. Требования к папке следующие:
* в ней находится CelestaSQL файл, называющийся как сама гранула, с символом подчёркивания в начале (так сделано, чтобы этот особо важный файл оказывался наверху в файловом менеджере при сортировке по имени)
* содержимое этого файла начинается с декларации гранулы — её имени и версии — с помощью выражения create grain … version …;
* в этом файле содержится DDL со структурой таблиц гранулы
С точки зрения **базы данных** гранула превращается в схему. Все таблицы, определённые в грануле foo, в итоге окажутся в SCHEMA foo.
С точки зрения **Python** (или Jython в нашем случае) гранула — это пакет, в котором будут находиться сгенерированные классы доступа к данным, и в котором можно будет создать свои модули с кодом бизнес-логики. Поэтому также в папке гранулы должен находиться файл с именем \_\_init\_\_.py
### Запуск Celesta и синхронизация структуры базы
При запуске Celesta занимается синхронизацией структуры базы данных. Примерная последовательность шагов такова:
1. Выполняется топологическая сортировка списка гранул по foreign key-зависимостям, чтобы выполнить обновление в порядке, не приводящем к конфликтам.
2. Контрольная сумма DDL-скрипта гранулы сравнивается с контрольной суммой последнего успешного апдейта, сохранённой в служебной таблице. Если эти суммы совпадают — Celesta считает, что можно пропустить этап сверки структуры таблиц, чтобы ускорить запуск.
3. Если контрольная сумма изменилась, а версия — осталась прежней или выросла, то Celesta начинает обходить все объекты гранулы и исследовать, какие из метаданных разошлись. Если метаданные разошлись, тогда генерируются и выполняются CREATE и ALTER-команды, которые в абсолютном большинстве случаев проходят без проблем и ручного вмешательства.
4. Параллельно по необходимости генерируются или пересоздаются Python-модули с классами доступа к данным — по одному классу на каждую таблицу.
Это весьма краткий пересказ того, что происходит на многоэтапном процессе запуска, включающем в себя и генерацию классов для доступа к данным, и инициализацию пакетов гранул. Более детально процесс запуска описан на [этой странице](https://corchestra.ru/wiki/index.php?title=%D0%97%D0%B0%D0%BF%D1%83%D1%81%D0%BA_Celesta_%D0%B8_%D0%B0%D0%B2%D1%82%D0%BE-%D0%BE%D0%B1%D0%BD%D0%BE%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D0%91%D0%94) документации.
### Создание модели данных и базы данных в Celesta
Давайте посмотрим, как в Celesta можно создавать модель данных и разворачивать базу данных.
Допустим, мы делаем проект для компании интернет-торговли, которая недавно объединилась с другой компанией. У каждой есть своя база данных. Они собирают заказы, но пока они не слили свои базы данных воедино, нужна единая точка входа для того, чтобы собирать заказы, поступающие извне.
Для начала нам надо создать структуру таблиц, хранящих заказы. Заказ, как известно, сущность составная: он состоит из заголовка, где хранится информация о клиенте, дате заказа и прочих атрибутов заказа, а также из множества строк (товарных позиций).
Итак, за дело: создаём
1. папку score,
2. в ней гранулу — папку orders,
3. в папку orders вставляем пустой файл \_\_init\_\_.py (благодаря этому файлу Python будет воспринимать данную папку как пакет)
4. в папке orders создаём файл \_orders.sql следующего содержания:
```
CREATE GRAIN orders VERSION '1.0';
-- ТАБЛИЦЫ
/**Заголовок заказа*/
CREATE TABLE OrderHeader(
id VARCHAR(30) NOT NULL,
date DATETIME,
customer_id VARCHAR(30),
/**Имя клиента*/
customer_name VARCHAR(50),
CONSTRAINT Pk_OrderHeader PRIMARY KEY (id)
);
/**Строка заказа*/
CREATE TABLE OrderLine(
order_id VARCHAR(30) NOT NULL,
line_no INT NOT NULL,
item_id VARCHAR(30) NOT NULL,
item_name VARCHAR(100),
qty INT NOT NULL DEFAULT 0,
cost REAL NOT NULL DEFAULT 0.0,
CONSTRAINT Idx_OrderLine PRIMARY KEY (order_id, line_no)
);
ALTER TABLE OrderLine ADD CONSTRAINT fk_OrderLine FOREIGN KEY (order_id) REFERENCES OrderHeader(id);
/*ПРЕДСТАВЛЕНИЯ*/
CREATE VIEW OrderedQty AS
SELECT item_id, sum(qty) AS qty FROM OrderLine GROUP BY item_id;
```
Здесь мы описали две таблицы, соединённые внешним ключом, и одно представление, которое будет возвращать сводное количество по товарам, присутствующим во всех заказах. Как видим, это не отличается от обычного SQL, за исключением команды CREATE GRAIN, в которой мы задекларировали версию гранулы orders. Но есть и особенности. Например, все имена таблиц и полей, которые мы используем, могут быть только такими, чтобы их можно было превратить в допустимые в языке Python имена классов и переменных. Поэтому пробелы, спецсимволы, нелатинские буквы исключены. Ещё можно заметить, что комментарии, которые мы поставили над названиями таблиц и некоторых из полей, мы начали не с /\*, как обычно, а с /\*\*, как начинаются комментарии JavaDoc — и это неспроста! Комментарий, определённый над некоторой сущностью, начинающийся с /\*\*, будет доступен во время исполнения в свойстве .getCelestaDoc() данной сущности. Это бывает полезно, когда мы хотим снабдить элементы базы дополнительной мета-информацией: например, human readable названиями полей, информацией о том, как представлять поля в пользовательском интерфейсе и т. п.
Первый этап сделан: модель данных построена в первом приближении, и теперь нам хотелось бы применить её к базе данных. Для этого мы создаём пустую базу данных и напишем простое Java-приложение, использующее Celesta.
Используем Maven-dependency для Celesta (актуальную версию можно взять на сайте [corchestra.ru](https://corchestra.ru/#download)):
```
ru.curs
celesta
6.0RC2
compile
```
Создаём boilerplate-код и запускаем его:
```
public class App
{
public static void main( String[] args ) throws CelestaException
{
Properties settings = new Properties();
settings.setProperty("score.path", "c:/path/to/score");
settings.setProperty("pylib.path", "d:/jython2.7.1b3/Lib") ;
settings.setProperty("rdbms.connection.url", "jdbc:postgresql://localhost:5432/mytest");
settings.setProperty("rdbms.connection.username", "postgres");
settings.setProperty("rdbms.connection.password", "123");
Celesta.initialize(settings);
Celesta c = Celesta.getInstance();
}
}
```
Через объект Properties передаются базовые настройки Celesta, такие как путь к папке score (её подпапкой должна быть /orders), путь к стандартной библиотеке Jython (Jython должен быть установлен на вашей машине!) и параметры JDBC-подключения к базе данных. Полный перечень параметров Celesta приведён в [wiki-документации](https://corchestra.ru/wiki/index.php?title=%D0%91%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D1%8F_%D0%BD%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0_Celesta).
Если параметры заданы правильно и всё прошло успешно, то можно посмотреть, что случилось с базой данных mytest. Мы увидим, что в базе появилась схема orders с нашими таблицами «OrderHeader» и «OrderLine», а также представление «OrderedQty». Теперь допустим, что спустя какое-то время мы решили изменить нашу модель данных. Допустим, мы хотим в заголовке заказа расширить поле с именем клиента до 100 символов и добавить поле с кодом менеджера. Сделать это мы можем прямым редактированием определения таблицы в файле \_orders.sql, буквально изменив одну строку и и дописав другую:
```
customer_name VARCHAR(100),
manager_id VARCHAR(30),
```
Запустив приложение ещё раз, мы можем убедиться, что структура базы данных изменилась, чтобы отвечать новой модели.
Помимо схемы orders, в базе данных создаётся служебная схема celesta. Полезно заглянуть в таблицу grains, чтобы увидеть в ней запись о грануле orders, её статусе и контрольной сумме скрипта \_orders.sql.
### Создание Celesta-процедур: контексты сессии и вызова, запуск «hello, world!»
Разобравшись с созданием структуры базы данных, можно приступать к написанию бизнес-логики.
Для того, чтобы можно было реализовать требования распределения прав доступа и логирования действий, любая операция над данными в Celesta производится от имени некоторого пользователя, «анонимных» операций быть не может. Поэтому любой Celesta-код выполняется в некотором контексте вызова, который, с свою очередь, существует в контексте сессии.
Появление и удаление контекста сессии через методы login/logout позволяют осуществлять аудит входов-выходов. Привязка пользователя к контексту определяет разрешения на доступ к таблицам, а также обеспечивает возможность логирования изменений, производимых от его имени.
Чтобы убедиться, что мы можем запускать код Celesta-процедур как таковой, для начала рассмотрим пример «Hello, world», а потом построим менее тривиальную систему, которая будет модифицировать данные в базе и использовать модульные тесты для проверки своей корректности.
Вернёмся в папку score/orders и создадим в ней Python-модуль hello.py следующего содержания:
```
# coding=UTF-8
def run(context, name):
print u'Привет, %s' % name
```
Любая Celesta-процедура должна своим первым аргументом иметь context, который является экземпляром класса [ru.curs.celesta.CallContext](https://corchestra.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BD%D1%82%D0%B5%D0%BA%D1%81%D1%82%D1%8B_%D1%81%D0%B5%D1%81%D1%81%D0%B8%D0%B8_%D0%B8_%D0%B2%D1%8B%D0%B7%D0%BE%D0%B2%D0%B0) — в нашем примитивном примере он не требуется, но как мы увидим далее, он играет ключевую роль. Кроме того, Celesta-процедуры могут иметь произвольное количество других дополнительных параметров (в том числе не иметь вовсе). В нашем примере присутствует один дополнительный параметр name.
Чтобы запустить Celesta-процедуру, её нужно идентифицировать по *трехкомпонентному имени*. Внутри гранулы orders у нас находится питоновский модуль hello, внутри которого находится функция run — значит, трёхкомпонентное имя нашей процедуры будет **orders.hello.run**. Если бы мы использовали несколько вложенных питоновских модулей, тогда их имена также можно было бы перечислить через точку, например: orders.subpackage.hello.run.
Модифицируем немного наш код на Java, дописав создание контекстов сессии и вызова и, собственно, запуск процедуры:
```
Celesta c = Celesta.getInstance();
String sessionId = String.format("%08X", (new Random()).nextInt()); //разнообразия ради
c.login(sessionId, "super"); //super -- создаваемый по умолчанию пользователь со всеми правами
c.runPython(sessionId, "orders.hello.run", "Ivan");
c.logout(sessionId, false);
```
Запустив Java-программу, мы получим приветствие от питоновского кода, который выполняется из-под Celesta.
```
Привет, Ivan
```
### Создание Celesta-процедур: модификация данных, защита от race conditions и транзакции
Теперь мы покажем, как написать на Celesta код, читающий и изменяющий данные в базе. Для этого мы используем так называемые курсоры — классы, которые Celesta сгенерировала для нас. Мы можем увидеть что они из себя представляют, зайдя в папку с гранулой orders: т. к. мы уже запускали Celesta, то кодогенерация была выполнена, и в папке orders будет находиться файл **\_orders\_orm.py**.
Внутри него обнаружатся классы курсоров OrderHeaderCursor, Order LineCursor и OrderedQtyCursor. Как видим, по одному классу создано на каждый из объектов гранулы – на две таблицы и одно представление. И теперь эти классы мы можем использовать для доступа к объектам базы данных в нашей бизнес-логике.
Чтобы создать курсор на таблицу заказов и выбрать первую запись, нужно написать такой Python-код:
```
header = OrderHeaderCursor(context)
header.tryFirst()
```
После создания объекта header мы можем получить доступ к полям записи таблицы через переменные:
Как мы уже говорили, первым аргументом любой Celesta-процедуры является контекст вызова, и этот контекст мы обязаны передать в качестве первого аргумента конструктора любого курсора — это единственный способ создать курсор. Контекст вызова несёт в себе информацию о текущем пользователе и его правах доступа.
С объектом-курсором мы можем производить разные вещи: фильтровать, переходить по записям, а также, естественно, вставлять, удалять и обновлять записи. Весь API курсоров подробно описан в [документации](https://corchestra.ru/wiki/index.php?title=%D0%A0%D0%B0%D0%B1%D0%BE%D1%82%D0%B0_%D1%81_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D0%BC%D0%B8_%D1%87%D0%B5%D1%80%D0%B5%D0%B7_%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D1%8B_%D0%B4%D0%BE%D1%81%D1%82%D1%83%D0%BF%D0%B0_%D0%BA_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D0%BC#.D0.9A.D1.83.D1.80.D1.81.D0.BE.D1.80.D1.8B_.D0.B8_.D0.B8.D1.85_.D1.81.D1.82.D0.B0.D0.BD.D0.B4.D0.B0.D1.80.D1.82.D0.BD.D1.8B.D0.B5_.D0.BC.D0.B5.D1.82.D0.BE.D0.B4.D1.8B).
Например, код нашего примера можно было бы развить следующим образом:
```
def run(context, delta):
header = OrderHeaderCursor(self.context)
header.setRange('city', 'MSK')
header.tryFirst()
header.counter = orderHeader.counter + delta
header.update()
```
В этом примере мы выставляем фильтр по полю city, затем находим первую запись методом tryFirst.
**(почему «try»)**Методы get, first, insert, update имеют два варианта: без приставки try (просто get(...) и т. д.) и с приставкой try (tryGet(...), tryFirst() и т. д.). Методы без приставки try вызывают исключение, если в базе данных нет подходящих данных для выполнения действия. К примеру, first() вызовет исключение, если в установленный на курсор фильтр не попадёт ни одной записи. В то же время методы с приставкой try исключения не вызывают, а вместо этого возвращают булевское значение, сигнализирующее об успешности или неуспешности соответствующей операции. Рекомендуемой практикой является использование методов *без* приставки try везде, где это возможно. Таким образом создаётся «сам себя тестирующий» код, вовремя сигнализирующий об ошибках в логике и/или в данных базы данных.
В момент срабатывания tryFirst переменные курсора заполняются данными одной записи, мы можем читать и присваивать им значения. А когда данные в курсоре полностью подготовлены, мы выполняем update(), и он сохраняет содержимое курсора в базе данных.
Какой проблеме может быть подвержен этот код? Конечно же, возникновению race condition/lost update! Потому что между моментом, когда мы получили данные в строке с «tryFirst», и моментом, когда мы пытаемся обновить эти данные в точке «update», кто-то другой уже может получить, изменить и обновить эти данные. После того, как данные прочитаны, курсор никаким образом не блокирует их использование другими пользователями! Потерянные обновления были бы большой проблемой в такой системе, но Celesta содержит защиту, основанную на проверке версий данных. В каждой таблице по умолчанию Celesta создаёт поле recversion, и на уровне ON UPDATE-триггера выполняет инкремент номера версии и проверяет, что обновляемые данные имеют ту же версию, что и в таблице. Если произошла проблема — выбрасывает исключение. Подробнее об этом можно прочитать в статье документации [«защита от потерянных обновлений»](https://corchestra.ru/wiki/index.php?title=%D0%97%D0%B0%D1%89%D0%B8%D1%82%D0%B0_%D0%BE%D1%82_%D0%BF%D0%BE%D1%82%D0%B5%D1%80%D1%8F%D0%BD%D0%BD%D1%8B%D1%85_%D0%BE%D0%B1%D0%BD%D0%BE%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B9).
В случае, если выход из Celesta-процедуры происходит по необработанному исключению, Celesta откатывает неявную транзакцию, которую она начинает перед выполнением процедуры. Важно понимать, что call context — это не только контекст вызова, но ещё и транзакция. Если Celesta-процедура заканчивается успешно, тогда происходит commit. Если Celesta-процедура заканчивается с необработанным исключением, тогда происходит rollback.
Специалист, который пишет бизнес-логику, может не знать всех тонкостей, происходящих «за кулисами»: он просто пишет бизнес-логику, а система обеспечивает консистентность данных. Если ошибка происходит в какой-то сложной процедуре — откатывается вся связанная с контекстом вызова транзакция, как будто бы мы ничего и не начинали делать с данными, данные не испорчены. Если же зачем-то нужен commit в середине, допустим, какой-то большой процедуры, то явный commit можно выполнить, вызвав context.commit().
### Создание Celesta-процедур: модульное тестирование
Давайте рассмотрим более продвинутый пример.
Допустим, у нас имеются вот JSON-файлы, которые мы хотим класть в базу данных, состоящую из **двух таблиц**
```
request1 = {
'id': 'no1',
'date': '2017-01-02',
'customer_id': 'CUST1',
'customer_name': u'Василий',
'lines': [
{'item_id': 'A',
'qty': 5
},
{'item_id': 'B',
'qty': 4
}
]
}
request2 = {
'id': 'no2',
'date': '2017-01-03',
'customer_id': 'CUST1',
'customer_name': u'Андрей',
'lines': [
{'item_id': 'A',
'qty': 3
}
]
}
```
В каждом из этих JSON у нас есть поля, относящиеся к заголовку заказа, и есть массив, относящийся к его строкам. Как быстро и надёжно создать приложение, которое обрабатывает эти данные и укладывает в СУБД? Конечно, через тестирование!
Начнём с того, что создадим класс модульного теста, который наследуем от CelestaUnit. В свою очередь, CelestaUnit является наследником unittest.TestCase системы PyUnit:
```
#coding=utf-8
from celestaunit.celestaunit import CelestaUnit, clean_db
from basic_operations import post_order, get_aggregate_report
from _orders_orm import OrderHeaderCursor
class test_basic_operations(CelestaUnit):
request1 =....
request2 = ...
def setUp(self):
CelestaUnit.setUp(self)
clean_db(self.context)
```
И напишем модульный тест для проверяемой процедуры:
```
def test_document_is_put_to_db(self):
#Вызываем тестируемую процедуру (она пока не реализована)
post_order(self.context, test_basic_operations.request1)
#Проверяем, что данные попали в базу
header = OrderHeaderCursor(self.context)
header.tryFirst()
#Мы знаем, что вставляемый документ имеет id='no1'
self.assertEquals('no1', header.id)
```
Обратите внимание на то, что мы имеем возможность писать модульные тесты в предположении, что к моменту их выполнения база данных будет абсолютно пустой, но со структурой, которая нам нужна, а после их выполнения мы можем не заботиться о том, что мы оставили «мусор» в базе. Более того: используя импорт CelestaUnit, мы можем вовсе не заботиться о том, чтобы хоть какая-то БД стояла у нас на рабочей машине. CelestaUnit поднимает H2 in-memory базу и все конфигурирует за нас, а нам остаётся только брать из self готовый контекст вызова и пользоваться им для создания курсоров.
Если запустить этот тест сразу, то он не сработает, т. к. мы не реализовали тестируемый метод. Напишем его:
```
def post_order(context, doc):
header = OrderHeaderCursor(context)
line = OrderLineCursor(context)
#заполняем заголовок
header.id = doc['id']
header.date = datetime.datetime.strptime(doc['date'], '%Y-%m-%d')
header.customer_id = doc['customer_id']
header.customer_name = doc['customer_name']
header.insert()
lineno = 0
#заполняем строки в цикле
for docline in doc['lines']:
lineno += 1
line.line_no = lineno
line.order_id = doc['id']
line.item_id = docline['item_id']
line.qty = docline['qty']
line.insert()
```
Снова запустим тест в IDE и ура:
Мы также можем добавить в тест какие-то более сложные проверки, например, что строки заказа вставились, что их ровно две и т. д.
Давайте создадим вторую процедуру, возвращающую JSON с агрегированными значениями, показывающими, сколько каких товаров заказали у нас.
Тест записывает в базу два заказа, после чего проверяет суммарное значение, возвращаемое новым методом get\_aggregate\_report:
```
def test_report_returns_aggregated_qtys(self):
post_order(self.context, test_basic_operations.request1)
post_order(self.context, test_basic_operations.request2)
result = get_aggregate_report(self.context)
#Первого товара 8 штук: 5 в 1м заказе и 3 во 2м
self.assertEquals(8, result['A'])
#Второго товара 4 штуки во 2м заказе
self.assertEquals(4, result['B'])
```
Для реализации метода get\_aggregate\_report мы воспользуемся представлением OrderedQty, которое, напомню, в CelestaSQL-файле выглядит так:
```
create view OrderedQty as
select item_id, sum(qty) as qty from OrderLine group by item_id;
```
Запрос стандартный: мы суммируем строки заказов по количеству и группируем по коду товара. Для представления уже создался курсор OrderedQtyCursor, которым мы можем воспользоваться. Мы объявляем этот курсор, итерируем по нему и собираем нужный JSON:
```
def get_aggregate_report(context):
result = {}
ordered_qty = OrderedQtyCursor(context)
for ordered_qty in ordered_qty.iterate():
result[ordered_qty.item_id] = ordered_qty.qty
return result
```
### Материализованные представления Celesta
Чем плохо использование представления для получения агрегированных данных? Этот подход вполне работоспособен, но в действительности он подкладывает бомбу замедленного действия под всю нашу систему: ведь представление, которое является SQL-запросом, выполняется все медленнее и медленнее по мере накопления данных в системе. Ему придется суммировать и группировать все больше строк. Как этого избежать?
Celesta старается все стандартные задачи, с которыми постоянно сталкиваются программисты бизнес-логики, реализовать на уровне платформы.
В MS SQL Server есть прекрасная концепция материализованных (индексированных) представлений, которые хранятся как таблицы и быстро обновляются по мере того, как изменяются данные в исходных таблицах. Если бы мы работали в «чистом» MS SQL Server, то для нашего случая замена представления на индексированное была бы как раз то, что надо: извлечение агрегированного отчёта не замедлялось бы по мере накопления данных, а работа по обновлению агрегированного отчёта выполнялась бы в момент вставки данных в таблицу строк заказа и также не сильно увеличивалась бы при росте числа строк.
Но мы работаем с PostgreSQL через Celesta. Что мы можем сделать? Переопределим представление, добавив слово materialized:
```
create materialized view OrderedQty as
select item_id, sum(qty) as qty from OrderLine group by item_id;
```
Запустим систему и посмотрим, что сделалось с базой данных.
Мы заметим, что представление OrderedQty исчезло, а вместо него появилась таблица OrderedQty. При этом, по мере наполнения данными таблицы OrderLine, в таблице OrderedQty будет «волшебным образом» обновляться информация, так, как будто бы OrderedQty являлось бы представлением.
Никакого волшебства тут нет, если мы взглянем на триггеры, построенные на таблице OrderLine. Celesta, получив задачу создать «материализованное представление», проанализировала запрос и создала триггеры на таблице OrderLine, обновляющие OrderedQty. Вставкой единственного ключевого слова — materialized — в CelestaSQL-файл мы решили проблему деградации производительности, а код бизнес-логики даже не потребовалось изменять!
Естественно, этот подход имеет свои, и довольно жёсткие, ограничения. «Материализованными» в Celesta могут становиться только представления, построенные на одной таблице, без JOIN-ов, с агрегацией по GROUP BY. Однако этого достаточно для того, чтобы строить, например, ведомости остатков средств по счетам, товаров по ячейкам склада и т. п. часто встречающиеся на практике отчёты.
### Flute: REST-endpoints, расписания, очереди и т. п.
В конце нашего введения в Celesta остаётся обсудить, как код, который мы запускали в IDE как модульный тест «связать с внешним миром», превратить в работающий сервис.
Например, это можно сделать, взяв Maven-зависимость Celesta в ваш Java-проект и запуская нужные методы через Celesta.getInstance().runPython(<трёхкомпонентное имя процедуры>).
Но можно обойтись и вовсе без Java-программирования. У нас есть модуль, называемый [Flute](https://corchestra.ru/wiki/index.php?title=Flute) (он же — «Флейта»), который устанавливается как сервис на Windows и Linux. Он использует Celesta и реализует много способов, которые позволят ваши скрипты «проигрывать». Вот эти способы:
1. поднимать REST-сервис и мапить запуск задач на URL-ы
2. подхватывать задачи из очереди Redis или SQL-таблицы
3. выполнять процедуры по CRON-расписанию
4. выполнять процедуры раз за разом в бесконечном цикле с заданной паузой между выполнениями
Каким образом создаётся REST-endpoint во «Флейте»? Примерно так же, как в Spring, в Java:
```
# coding=utf-8
from flute.mappingbuilder import mapping
@map('/foo')
def processor(context, request, response):
# whatever
```
В данном случае декоратор map указывает системе Flute, с каким URL-ом будет связан данный код.
Модуль Flute конфигурируется через файл flute.xml примерно следующего содержания:
```
jdbc:postgresql://127.0.0.1:5432/celesta
postgres
123
localhost
6379
D:/score2
8888
...
q1
5 \* \* \* \*
foo.module.script
...
```
Подробное описание возможностей Flute приведено в [документации](https://corchestra.ru/wiki/index.php?title=Flute#.D0.9E.D0.B1.D1.89.D0.B8.D0.B5_.D1.81.D0.B2.D0.B5.D0.B4.D0.B5.D0.BD.D0.B8.D1.8F).
Заключение
----------
Мы пробежались по основным возможностям системы Celesta и Flute. Если вас заинтересовала наша технология — добро пожаловать к нам на [сайт](https://corchestra.ru) и в нашу [wiki](https://corchestra.ru/wiki/). А также приходите в сентябре на [встречу jug.msk.ru](https://jugmsk.timepad.ru/event/569994/), где мы всё покажем «вживую» и ответим на все вопросы! | https://habr.com/ru/post/335966/ | null | ru | null |
# Hibernate-Extender или Hibernate, Spring и OSGi
К сожалению, на данный момент Hibernate не обладает необходимыми механизмами интеграции для работы в OSGi среде, хотя подвижки в этом направлении заметны (начальная OSGi-фикация путём разделения пакетов в 4-ой ветке). Это побуждает разрабатывать собственные механизмы, что требует немалых дополнительных усилий.
Эта статья предназначается для тех разработчиков, кому интересно: как можно использовать Hibernate со связкой Spring+OSGi; что такое паттерн Extender; как реализовать ClassLoader со специфичным поведением; как поддерживается Hibernate в Spring Framework и немного о расширении этого кода. Разумеется, для чтения статьи необходимо разбираться в технологиях Spring, Hibernate, OSGi, а также понимать основные проблемы выполнения кода в многопоточной среде. Те же кто незнаком с использованием Spring Framework в OSGi среде могут обратиться к вводной статье [«Использование Spring в OSGi-контейнере»](http://habrahabr.ru/blogs/java/128653/).
Весь представленный код является частью учебного проекта ссылка на который расположена в конце статьи. Поэтому просьба рассматривать все представленные примеры скорее как прототип, нежели как готовые к использованию фрагменты.
### Паттерн Extender
Программное обеспечение выполняющееся в OSGi-контейнере состоит из обособленных модулей (bundle), каждый из которых выполняет свои специфические обязанности. Что делать, когда один модуль должен использовать какие-либо сложные runtime-механизмы находящиеся в другом модуле? Ответ очевиден — использовать сервисы-OSGi. А что делать, когда эти механизмы требую, например, инициализации (регистрация сервлета в сервлет-контейнере или, как в нашем случае, регистрация маппированных классов Hibernate-сущностей). Ответ на данный вопрос уже менее очевиден. По сути, существуют только два основных варианта: первый — каждый модуль нуждающийся в такой инициализации вызывает её самостоятельно (например из BundleActivator); второй — модуль нуждающийся в такой инициализации обладает некими характерными метаданными по которым другой модуль может инициировать выполнение всей необходимой работы, благо в OSGi хорошо развита система событий. Второй вариант обладает несомненным преимуществом — мы не распространяем кучу одинакового кода по модулям и не обременяем их дополнительной работой, а выносим эту обязанность в отдельный модуль. Собственно по такому принципу работает Spring DM. Этот принцип работы и есть паттерн Extender[http://www.aqute.biz/Snippets/Extender] и он очень распространён в мире OSGi.
### Описание общей картины работы Hibernate-Extender
Приступим к обсуждению общей схемы работы Hibernate-Extender. Прежде всего необходимо выбрать метаданные благодаря которым наш extender будет отличать нуждающиеся в расширении модули от не являющихся таковыми. Пусть это будет заголовок Entity-Classes в META-INF/MANIFEST.MF содержащий список классов Hibernate-сущностей (любители xml-маппингов пока останутся не у дел). Далее необходимо получать события от модулей переходящих в состояние Active и от модулей выходящих из этого состояния, для этого воспользуемся механизмом событий OSGi и реализуем интерфейс SynchronousBundleListener. Мы используем синхронный обработчик событий от модулей, дабы незамедлительно реагировать на изменения состояний модулей перед вызовом асинхронных BundleListener. При этом мы должны обеспечить наименьшее возможное время обработки события, чтобы не блокировать поток вызвавший наш обработчик. Это достигается путём реализации паттерна Producer-Consumer (Производитель-Потребитель), где в качестве Producer выступает наш обработчик событий, который передает информацию о модулях в Consumer, выполняющий все длительные операции в отдельном потоке. В нашем случае он реинициализирует runtime-структуры Hibernate.
Механизм Extender является достаточно обобщёнными, поэтому реализация представленная ниже придерживается Dependency Inversion Principle (SOLID) для облегчения повторного использования кода.
```
public class Extender implements SynchronousBundleListener {
private BundleContext bundleContext;
private Executor executor;
private BlockingQueue bundles
= new LinkedBlockingQueue();
private BundleConsumer bundleConsumer;
private ExtendedBundleFactory extendedBundleFactory;
// getter's и setter's
@Override
public void bundleChanged(BundleEvent event) {
Actions action = null;
switch (event.getType()) {
case BundleEvent.STARTED:
action = Actions.ADDING;
break;
case BundleEvent.STOPPING:
action = Actions.REMOVING;
break;
};
if (action == null) return;
ExtendedBundle extendedBundle =
extendedBundleFactory.newExtendedFactory(
event.getBundle(),
action
);
try {
bundles.put(extendedBundle);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
public void initialize() {
getBundleConsumer().initialize(getBundles());
getExecutor().execute(bundleConsumer);
getBundleContext().addBundleListener(this);
for (Bundle bundle: getBundleContext().getBundles()) {
if (Bundle.ACTIVE != bundle.getState()) continue;
ExtendedBundle extendedBundle =
extendedBundleFactory.newExtendedFactory(
bundle,
Actions.ADDING
);
try {
bundles.put(extendedBundle);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}
}
```
Реализация Extender задействует: BundleContext в котором регистрируется сам Extender в качестве слушателя событий от модулей; Executor реализация исполнителя из фреймворка java.util.concurrent, в котором выполняется потребитель выполняющий длительные операции; BlockingQueue блокирующая очередь с помощью которой синхронизируются потоки выполнения Producer-Consumer; BundleConsumer конкретная реализация потребителя событий модулей; ExtendedBundleFactory фабрика «расширенных» модулей.
Метод public void initialize() вызывается сразу после конструирования объекта. В этом методе происходит регистрация нашего Extender в качестве обработчика, запуск выполнения потребителя и обработка модулей, которые уже находятся в OSGi-контейнере, на случай когда Extender запускается после расширяемых модулей.
### BundleConsumer
BundleConsumer — это интерфейс, объект с типом реализующим этот интерфейс должен выполнять обработку модулей поставленных в очередь Extender.
```
public interface BundleConsumer extends Runnable {
void run();
void initialize(
BlockingQueue newBundles
);
}
```
Из кода представленного выше видно, что это всего лишь Runnable с дополнительным методом инициализации. Всё интересное должно происходить в реализации метода void run(). Давайте рассмотрим конкретную реализацию этого интерфейса, которая выполняет основную работу для нашего Hibernate-Extender.
```
public class SessionFactoryCreator implements BundleConsumer {
private volatile Extendable extendable;
private volatile ExtenderClassLoader extenderClassLoader;
private volatile BlockingQueue newBundles;
// getter's, setter's и прочие методы
@Override
public void run() {
ExtendedBundle bundle = null;
while (!Thread.currentThread().isInterrupted()) {
try {
bundle = newBundles.take();
}
catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
if (!bundle.isValidForExtending()) continue;
if (Actions.ADDING.equals(bundle.getAction())) {
addBundle(bundle);
}
else if (Actions.REMOVING.equals(bundle.getAction())) {
removeBundle(bundle);
}
}
}
private void addBundle(ExtendedBundle bundle) {
bundle.extend();
extenderClassLoader.addBundle(bundle);
extendable.addBundle(bundle);
bundle.markAsCompleted();
}
private void removeBundle(ExtendedBundle bundle) {
bundle.extend();
extendable.removeBundle(bundle);
extenderClassLoader.removeBundle(bundle);
bundle.markAsCompleted();
}
}
```
Главный цикл в методе void run() выполняет обработку очереди newBundles. При отсутствии расширяемых модулей в очереди, выполнение блокируется в вызове метода newBundles.take(). При появлении расширяемых модулей они перебираются по одному. На каждом из таких модулей вызывается метод isValidForExtending(), который должен возвращать истинное значение в случае если модуль подходит для расширения. Этот метод проверки может занимать значительное время при обращении к внутренним ресурсам пакетов (например вызывать операции ввода/вывода), поэтому он вызывается именно здесь, а не в Extender. Если модуль подходит для расширения, то проверяется мета информация о действии которое необходимо над ним произвести Actions.ADDING или Actions.REMOVING. В зависимости от требуемого действия выполняется операция добавления либо удаления и модули помечается как обработанные.
Хочу обратить внимание читателя на условия выхода из главного цикла обработки !Thread.currentThread().isInterrupted(), оно обеспечивает корректное завершения потока при установки флага прерывания. Ещё одно место, где задействуется данный флаг — это обработка исключения выбрасываемого блокирующимся методом newBundles.take() при возникновении которого происходит установка флага прерывания потока и выход из главного цикла.
Аттрибуты класса помечены как volatile для обеспечения гарантий видимости в многопоточной среде. Создание объекта происходит в одном потоке, а дальнейшее использование в другом. Реализация BlockingQueue является потокобезопасной поэтому её использование в многопточной среде не требует дополнительной синхронизации.
### HibernateSessionFactoryBean
Большое количество разнообразных фреймворков не случайно. Использование стороннего, хорошо оттестированного, готового к эксплуатации кода сильно облегчает разработку. Поэтому мы тоже постараемся не изобретать лишнего. Spring Framework поддерживает интеграцию с Hibernate. Одним из основных классов данной интеграции является LocalSessionFactoryBean. В нём осуществляется инициализация и создание фабрики сессий, которая затем используется в любом коде применяющим Hibernate API. У этого класса есть потомок AnnotationSessionFactoryBean, который добавляет некоторый функционал с поддержкой аннотаций. От последнего мы и будем наследовать нашу реализацию, код которой представлен далее.
```
public class HibernateSessionFactoryBean
extends AnnotationSessionFactoryBean {
private SessionFactory sessionFactoryProxy;
private Lock sessionFactoryAccessLock =
new ReentrantLock(true);
private ClassLoader classLoader;
private Set> annotatedClasses
= new CopyOnWriteArraySet>();
/\*\*
\* Установить свой ClassLoader
\* @param classLoader
\*/
public void setClassLoader(ClassLoader classLoader) {
super.setBeanClassLoader(classLoader);
this.classLoader = classLoader;
}
/\*\*
\* Отключения установки ClassLoader контейнером через интерфейс BeanClassLoaderAware
\* @param beanClassLoader
\*/
@Override
public void setBeanClassLoader(ClassLoader beanClassLoader) {
}
@Override
public void afterPropertiesSet() throws Exception {
//Установка своего ClassLoader
ProxyFactory.classLoaderProvider = new ClassLoaderProvider() {
public ClassLoader get(ProxyFactory pf) {
return HibernateSessionFactoryBean.this.classLoader;
}
};
super.afterPropertiesSet();
sessionFactoryProxy = createSessionFactoryProxy();
}
@Override
public SessionFactory getObject() {
return sessionFactoryProxy;
}
/\*\*
\* Пересоздать фабрику сессий Hibernate
\*/
protected void recreateSessionFactory() throws Exception {
sessionFactoryAccessLock
.tryLock(3000, TimeUnit.MILLISECONDS);
try {
//разрушение всего runtime-контекста связанного с Hibernate
super.destroy();
//создание нового runtime-контекста связанного с Hibernate
super.afterPropertiesSet();
}
finally {
sessionFactoryAccessLock.unlock();
}
}
protected SessionFactory createSessionFactoryProxy()
throws InstantiationException,
IllegalAccessException, InterruptedException {
// создание фабрики прокси объектов
// для интерфейсов SessionFactory и Extendable
ProxyFactory sessionFactoryProxyFactory = new ProxyFactory();
sessionFactoryProxyFactory.setInterfaces(
new Class[] {SessionFactory.class, Extendable.class}
);
//Не обрабатываем вызов метода finalize
sessionFactoryProxyFactory.setFilter(new MethodFilter() {
public boolean isHandled(Method m) {
return !m.getName().equals("finalize");
}
});
Class sessionFactoryProxyClass =
sessionFactoryProxyFactory.createClass();
MethodHandler mi = new MethodHandler() {
public Object invoke(
Object self,
Method thisMethod,
Method proceed,
Object[] args) throws Throwable {
Object result = null;
//Переопределение TCCL
ClassLoader defaultClassLoader =
Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(classLoader);
try {
if (thisMethod.getName().contains("addBundle")) {
addBundle((HibernateBundle) args[0]);
}
else if (thisMethod.getName().contains("removeBundle")) {
removeBundle((HibernateBundle) args[0]);
}
else {
sessionFactoryAccessLock
.tryLock(3000, TimeUnit.MILLISECONDS);
try {
//выполнить оригинальный метод SessionFactory
result = thisMethod
.invoke(getSessionFactory(), args);
}
finally {
sessionFactoryAccessLock.unlock();
}
}
}
finally {
//Восстановление TCCL действующего до переопределения
Thread.currentThread()
.setContextClassLoader(defaultClassLoader);
}
return result;
}
};
SessionFactory sessionFactory =
(SessionFactory)sessionFactoryProxyClass.newInstance();
((ProxyObject)sessionFactory).setHandler(mi);
return sessionFactory;
}
private void addBundle(HibernateBundle bundle) throws Exception {
for (String entityClassName: bundle.getEntityClassNames()) {
annotatedClasses.add(classLoader.loadClass(entityClassName));
}
setAnnotatedClasses(
annotatedClasses.toArray(
new Class[annotatedClasses.size()]));
recreateSessionFactory();
}
private void removeBundle(HibernateBundle bundle) throws Exception {
for (Class annotatedClass: annotatedClasses) {
if (bundle.getEntityClassNames().contains(
annotatedClass.getCanonicalName())) {
annotatedClasses.remove(annotatedClass);
}
}
setAnnotatedClasses(
annotatedClasses.toArray(
new Class[annotatedClasses.size()]));
recreateSessionFactory();
}
}
```
Основной план выполнения данного кода следующий. AbstractSessionFactoryBean реализует интерфейс FactoryBean, обработка создания объекта класса реализующего этот интерфейс в Spring контейнере происходит особым образом. Более подробно об этом смотрите документацию Spring Framework. Здесь стоит упомянуть лишь то, что это просто фабрика объектов SessionFactory, а не конкретная его реализация. Вместо объекта SessionFactory создаваемого в LocalSessionFactoryBean код возвращает прокси объект который переадресует практически все вызовы к родным методам SessionFactory при этом защищая любые обращения к нему глобальной блокировкой (данную архитектуру можно переработать с точки зрения проиводительности, в добавок не учитывается возможность пересоздание SessionFactory в момент использования объектов Session). При каждом изменении множества расширяемых модулей происходит пересоздания объекта SessionFactory c учётом этого.
В обработчике вызова метода прокси объекта используется переопределение Thread Context Classloader (TCCL). В качестве TCCL на время вызова метода устанавливает наш собственный Classloader речь о котором пойдёт далее.
### OSGi и ClassLoader
В обычном приложении, выполняющемся в среде jvm, загрузчики классов иерархически связаны (ссылка на родителя) и загружают классы и ресурсы сначала делегированием к своему родителю и в случае неуспеха уже самостоятельно. Для OSGi среды такое поведения не подходит. Аналогично оно не подходит для нашего случая с Extender. В OSGi контейнере каждый модуль получает свой собственный загрузчик классов который полностью обеспечивает его (модуля) потребности. И загрузчики классов модулей соединены в более сложную сеть делегирования. Каждый такой загрузчик имеет ссылку на загрузчик класса фреймворка, а также на загрузчики модулей из которых осуществляется импорт. Данная сеть делегирования строится в результате процесса Resolving в OSGi-контейнере.
В случае с Extender типовой загрузчик классов модуля не годится, потому что отсутствует возможность объявления импортируемых классов сущностей в MANIFEST.MF. О таких классах просто неизвестно на момент разработки Extender. Следовательно необходимо реализовать свой собственный загрузчик с нужным нам поведением. Код загрузчика классов для Extender представлен ниже.
```
public class ExtenderClassLoader extends ClassLoader {
private volatile ClassLoader defaultClassLoader = null;
private Set bundles =
new CopyOnWriteArraySet();
public ClassLoader getDefaultClassLoader() {
return defaultClassLoader;
}
public void setDefaultClassLoader(
ClassLoader defaultClassLoader) {
this.defaultClassLoader = defaultClassLoader;
}
public void addBundle(
ExtendedBundle bundle) {
bundles.add(bundle);
}
public void removeBundle(ExtendedBundle bundle) {
bundles.remove(bundle);
}
@Override
public Class loadClass(
String name) throws ClassNotFoundException {
Class c = null;
for (ExtendedBundle bundle: bundles) {
try {
c = bundle.loadClass(name);
break;
}
catch (ClassNotFoundException e) {}
}
if (c == null && getDefaultClassLoader() != null) {
try {
c = getDefaultClassLoader().loadClass(name);
}
catch (ClassNotFoundException e) {}
}
if (c == null) throw new ClassNotFoundException(name);
return c;
}
// прочие методы
}
```
Давайте подробно рассмотрим представленный код. Основная логика его работы находится в методе loadClass. Нужно подчеркнуть, что аналогично реализованы методы по загрузке ресурсов которые опущены в данном фрагменте. ExtenderClassLoader содержит коллекцию модулей содержащих классы сущностей и делегирует загрузку классов и ресурсов им. Это обеспечивает доступ к необходимому коду без нужды в импорте. Загрузку остальных нужных классов ExtenderClassLoader делегирует загрузчику установленному по-умолчанию. Потокобезопасность данного кода обеспечивается за счёт использования неблокируемой реализации множества CopyOnWriteArraySet и потокобезопасных загрузчиков классов.
### Собираем всё вместе
К этому моменту у читателя должно сформироваться понимание работы основных элементов Hibernate-Extender. Теперь необходимо собрать все части воедино. Для этого необходимо сконфигурировать модуль для работы в OSGi-среде со spring dm. Для лучшего понимание конфигурирования объектов рассмотрим диаграмму классов нашей системы.
[](http://habrastorage.org/storage2/ad2/c9a/284/ad2c9a28472dd1ba55dc1e96924c5335.png)
Согласно устоявшимся канонам конфигурация модуля spring dm разбивается как минимум на два файла. В первом находится собственно конфигурация spring-контейнера. Во втором расположена конфигурация специфичная для OSGi-окружения. В нашем случае это файлы context.xml и osgi-context.xml.
Конфигурация Hibernate-Extender для spring dm идентична диаграмме классов. В начале конфигурационного файла context.xml описан объект dataSource — это источник данных с помощью которого осуществляется всё взаимодействие с базой данных. Следом идёт конфигурация объекта transactionManager обеспечивающего поддержку транзакций в Spring окружении. Объект sessionFactory это инстанс описанного выше класса HibernateSessionFactoryBean который отвечает за создание SessionFactory. Ссылка на sessionFactory передаётся в transactionManager. Очередной объект в конфигурации это extenderClassLoader в котором при создании в качестве defaultClassLoader устанавливается загрузчик классов по умолчанию в Spring окружении. Объект sessionFactoryCreator выполняет всю основную работу по инициированию переконфигурирования окружения Hibernate с учётом изменившихся данных о модулях. Центральным объектом нашего модуля является Extender который в процессе создания получает ссылки на объекты: bundleContext, новый безымянный Executor, новый безымянный ExtendedBundleFactory и sessionFactoryCreator. Во втором конфигурационном файле osgi-context.xml объявлены сервисы OSGi: dataSource, transactionManager, sessionFactory.
context.xml
```
xml version="1.0" encoding="UTF-8"?
```
osgi-context.xml
```
xml version="1.0" encoding="UTF-8"?
org.springframework.transaction.support.ResourceTransactionManager
```
### Недоработки прототипа
Как и любой прототип Hibernate-Extender обладает рядом недоработок. С одной стороны трудно донести основную идею если она смешана с большим количеством второстепенных деталей. С другой, нельзя не упомянуть совсем явные недостатки, которые препятствуют использованию данного кода в реальном приложении.
Из spring конфигурации первое, что бросается в глаза — наличие установки свойств источника данных прямо в самом файле context.xml. Любое реальное приложение требует изменение этого. Например установка этих данных из внешнего файла свойств используя Spring-механизм property-placeholder или реализация более сложной системы обеспечивающей изменения параметров подключения к базе данных во время выполнения.
В представленных выше листингах опущен код отвечающий за логирование, без которого немыслимо практически любое использование модуля.
Описанная реализация обладает следующим серьёзным недостатком. Что произойдёт если будет добавлен модуль на расширение в момент, когда другой, уже расширенный модуль, будет выполнять какую-либо операцию используя Hibernate API и находится внутри транзакции? Такая операция при текущей реализации обречена на провал, хотя если это учитано в коде, то неудобство вызовет только обработка специфических исключений, связанных с вызовом операций на уже не актуальном объекте Session.
И последним недостатком, который я хочу выделить, является проблема с точки зрения производительности, возникающая при переконфигурирование runtime-окружения Hibernate происходящее после каждого изменения множества расширяемых модулей.
### OSGi-фикация сторонних библиотек
Много java библиотек уже поставляются в виде готовом для выполнения в среде OSGi, но к сожалению, не все. Выхода из этого положения два, либо использовать OSGi-фицированные версии подготовленные третьей стороной (например SpringSource Enterprise Bundle Repository[http://ebr.springsource.com/repository/app/]), либо подготовить такие версии библиотек самостоятельно. В проекте с исходным кодом примеров выполняется такая подготовка (подпроект lib). Хочу заметить, что для сложной библиотеки это отнюдь не тривиальная задача. Необходимо понимать структуру библиотеки для экспорта пакетов которые могут быть использованы сторонним кодом. Дополнительные проблемы могут возникнуть из-за внутренних механизмов библиотек плохо совместимых или несовместимых с OSGi-средой. Но всё это, в большинстве случаев, решаемые задачи. Технические проблемы архитектуры библиотек решаются только вручную, тогда как вопрос экспорта поддаётся автоматизации с помощью различных утилит (bnd, maven-плагины и др.)
### Заключение
На этом описание Extender-подхода работы с Hibernate в OSGi завершается. Единственное, что осталось — это добавить каким образом можно использовать полученный модуль. Расширяемый модуль в заголовке Entity-Classes в META-INF/MANIFEST.MF должен поместить список полных имён класов сущностей Hibernate. Далее при запуске этого модуля Extender загрузит эти классы с помощью нашей реализации ClassLoader и переинициализирует runtime-окружение Hibernate. Кроме того, модуль нуждающийся в использовании Hibernate API должен импортировать OSGi сервис SessionFactory и ResourceTransactionManager. После этого модуль может использовать Hibernate API в Spring окружении в привычной манере (согласно официальному руководству).
Полный код Extender совместно с модульными и интеграционными тестами размещен в googlecode репозитории ссылка на который размещена в конце статьи. Этот код будет развиваться, поэтому все кто заинтересован в нём могут следить за изменениями. Кто же имеет желание поучаствовать в развитии этого кода может связаться со мной. Ну и как обычно, у кого возникли какие-то вопросы добро пожаловать в комментарии!
### Дополнительные источники
[code.google.com/p/iconcerto/source/browse](http://code.google.com/p/iconcerto/source/browse/)
[www.aqute.biz/Bnd/Bnd](http://www.aqute.biz/Bnd/Bnd)
[www.aqute.biz/Snippets/Extender](http://www.aqute.biz/Snippets/Extender)
[static.springsource.org/spring/docs/3.1.x/spring-framework-reference/html](http://static.springsource.org/spring/docs/3.1.x/spring-framework-reference/html/)
[docs.jboss.org/hibernate/core/3.6/reference/en-US/html](http://docs.jboss.org/hibernate/core/3.6/reference/en-US/html/)
[static.springsource.org/osgi/docs/1.2.1/reference/html](http://static.springsource.org/osgi/docs/1.2.1/reference/html/) | https://habr.com/ru/post/135651/ | null | ru | null |
# Физика Человека-паука с его новыми паутинными крыльями
Врать не буду, я очень жду фильм «Человек-паук: Возвращение домой» [Spider-Man: Homecoming]. А пока что единственной отдушиной для меня будет заняться физикой Человека-паука. И я займусь его новыми паутинными крыльями, увиденными в последнем трейлере.
Для фанатов отмечу, что в некоторых из оригинальных комиксов про Человека-паука действительно было показано, как он их использует, хотя он не всегда использовал их для полётов.
Физика планирования
-------------------
Что случится после прыжка Человека-паука со здания? Я могу смоделировать его движение, приняв, что на него действуют три силы – гравитация, сопротивление воздуха и подъёмная сила. С вашего позволения, я опишу каждую из них.
• Гравитация – постоянная, направленная вниз сила, пропорциональная массе ЧП (на поверхности Земли, по крайней мере).
• Сопротивление. Представьте, что вы тянете объект через гигантское море шариков для пинг-понга. Замените шарики воздухом – и будет примерно то же самое. Сопротивление увеличивается вместе со скоростью.
• Подъёмная сила. Опять-таки представьте столкновения с шариками, но такие, после которых шарики отскакивают вниз. Заменив шарики воздухом, вы получите подъёмную силу, зависящую от угла атаки, поверхности и скорости.
Вот вам красивая диаграмма сил планирующего на крыльях ЧП. Да, пока мы смоделируем его при помощи треугольника.
В нашей простой модели подъёмная сила перпендикулярна скорости, а сопротивление направлено в противоположную ей сторону. Для моделирования движения ЧП с крыльями, мне нужна формула для них обеих.
Это величины важных нам сил. Они похожи, за исключением CL (подъёмного коэффициента) и CD (коэффициента сопротивления). В обоих случаях ρ это плотность воздуха (1,2 кг/м3), а v – скорость.
Что есть А? Это площадь поперечного сечения человека (ЧП в нашем случае). По идее, А для сопротивления и для подъёмной силы должны отличаться, в зависимости от угла атаки. Но я не всегда точно знаю, что я делаю – поэтому я сверился с разными источниками, и больше всего к моему случаю подходит статья 2011 года "[Траектория падающего Бэтмена](https://physics.le.ac.uk/journals/index.php/pst/article/view/484/289)" из физического журнала Journal of Physics Special Topics. В ней авторы использовали одну и ту же площадь для сопротивления и подъёмной силы, так что я сделаю то же самое.
Моделирование траектории
------------------------
Если ЧП спрыгнет со здания, как далеко он сможет сместиться в падении? Какую разницу дадут ему паутинные крылья? Моделировать движение ЧП не так уж просто, поскольку сопротивление и подъёмная сила зависят от скорости. Такую траекторию можно рассчитать только при использовании [числовой модели](https://www.wired.com/?p=1766358), в которой движение разбивается на небольшие шаги.
Займёмся аппроксимацией. Сначала посчитаем площадь поверхности ЧП. Грубо прикинув, я получил:
Что даёт нам площадь около 0,651 м2 с крыльями и 0,513 м2 без них. Остальные значения:
• Подъёмный коэффициент = 1,45 (значение взято из работы о Бэтмене)
• Коэффициент сопротивления = 0,4 (оттуда же)
• Масса = 64 кг
• Начальная скорость = 8 м/с (горизонтальная)
• И ещё одно предположение: постоянный угол атаки, в связи с чем коэффициенты сопротивления и подъёма не меняются.
Без колебаний я прыгнул в мир числовых моделей. Я оставил в коде комментарии, чтобы вы смогли переделать её для использования в качестве домашней работы.
```
GlowScript 2.1 VPython
#this is the area with the wings
A1=0.651
#area without wings
A2=0.513
g=vector(0,-9.8,0)
m=64 #mass of Spider-Man
CL=1.45 #coefficient of lift
CD=0.4 #coefficient of drag
rho=1.2 #density of air
#starting velocity
#try changning this
v0=8
#starting momentum assuming horizontal - change this
p=vector(v0,0,0)*m
#p2 is just the momentum for the comparison
p2=p
t=0
dt=0.01
#starting height
h=40
#starting position
r=vector(0,h,0)
r2=r
#these are for the graphs
f1=series(color=color.red)
f2=series(color=color.blue)
while r.y>0:
#calculate the velocity to use in lift-drag
v=p/m
v2=p2/m
#calculate the drag force
Fd=-.5*rho*A1*CD*(mag(v)**2)*norm(v)
Fd2=-.5*rho*A2*CD*(mag(v2)**2)*norm(v2)
#calculate lift (notice cross product to get direction)
FL=-.5*rho*A1*CL*(mag(v)**2)*cross(norm(v),vector(0,0,1))
FL2=-.5*rho*A2*CL*(mag(v2)**2)*cross(norm(v2),vector(0,0,1))
#total force
F=m*g+Fd+FL
F2=m*g+Fd2+FL2
#update momentum
p=p+F*dt
p2=p2+F2*dt
#update position
r=r+p*dt/m
r2=r2+p2*dt/m
#update time
t=t+dt
#plot stuff
#change this if it makes you happy
f1.plot(r.x,r.y)
f2.plot(r2.x,r2.y)
print("Glide Ratio 1 = ",-p.x/p.y)
print("Glide Ratio 2 = ", -p2.x/p2.y)
```
В моей модели красная линия представляет траекторию ЧП с крыльями, а голубая – без крыльев. Также я вывожу значение аэродинамического качества. Поскольку в конце он двигается с постоянной скоростью, это соотношение будет равняться просто отношению х-компоненты импульса, делённой на у-компоненту.
Домашнее заданее
Для ответа на следующие вопросы используйте [эту числовую модель](https://trinket.io/glowscript/94a62d77aa). Не волнуйтесь, вы ничего не сломаете. Если что-то сделаете с кодом, просто перезагрузите и начните сначала.
• [Согласно Википедии](https://en.wikipedia.org/wiki/Wingsuit_flying), у прыгающего в крылатом костюме парашютиста аэродинамическое качество (отношение подъёмной силы к лобовому сопротивлению) имеет значение порядка 2,5:1 (то есть, наша программа вывела бы число 2,5). Сможете ли вы так подправить код, чтобы программа выдала такое значение? Подсказка: меняйте как площадь поверхности, так и начальную скорость.
• Что, если ЧП упадёт вертикально вниз? Какую предельную скорость он приобретёт с крыльями, и без них?
• Как быстро ЧП нужно двигаться по горизонтали, чтобы он полетел вверх, а не вниз, в начале полёта?
• Может ли ЧП прыгнуть, целясь вниз, так, чтобы набрать большую скорость и на какое-то время перейти в горизонтальный полёт?
• Можете ли вы построить улучшенную модель, принимающую во внимание угол атаки? Возможно, и сможете, но мне кажется, что полёты с малой скоростью – достаточно сложная тема. | https://habr.com/ru/post/399957/ | null | ru | null |
# Property-based тестирование для JavaScript и UI: необычный подход к автоматизированным тестам
*[Falcon Heavy Demo Mission](https://www.flickr.com/photos/spacex/40143096241/)*
Писать тесты скучно. А то, что скучно делать, постоянно откладывается. Меня зовут Назим Гафаров, я разработчик интерфейсов в [Mail.ru Cloud Solutions](https://mcs.mail.ru/), и в этой статье покажу вам другой, немного странный подход к автоматизированному тестированию.
Что не так с обычным тестированием и что делать
-----------------------------------------------
Итак, представьте, что у вас есть такая функция суммирования:
```
function sum (a, b) {
return a + b
}
```
Все мы понимаем важность юнит-тестов. Давайте напишем тест на эту функцию:
```
const {equal} = require('assert')
const actual = sum(1, 2)
const expected = 3
equal(actual, expected)
```
Передаем на вход 1 и 2, на выходе ожидаем 3. Все просто — это классическое юнит-тестирование на основе примеров, так называемый example-based testing. Тест работает, все довольны, можно катить в прод. Но тут в игру вступает ваш коллега — сказочный энтерпрайз-программист. Однажды ему понадобилась ваша функция суммирования, но по каким-то причинам он решил ее немного подправить:
```
function sum (a, b) {
return 3
}
```
В этом коде есть какая-то проблема, но с другой стороны — все тесты проходят, а TDD нас учит, что нужно писать минимальный код, который заставит ваши тесты проходить. Это справедливо. Преодолев свой подростковый гнев, вы пишете еще один тест — передаете 4 и 8, ожидаете 12:
```
equal(
sum(4, 8),
12
)
```
Но энтерпрайз-программист не успокаивается. Он еще раз правит функцию суммирования так, чтобы тесты не падали:
```
function sum (a, b) {
if (a == 4 && b == 8) return 12
return 3
}
```
Вы могли бы добавить в тестовый набор еще примеры, и так продолжалось бы до бесконечности. В этот момент вы думаете: «Зачем его только на работу взяли?», но деваться некуда. Вы выпускаете свое секретное оружие — рандом:
```
const a = Math.random()
const b = Math.random()
const actual = sum(a, b)
const expected = a + b
equal(actual, expected)
```
Теперь все хорошо, но огромная проблема такого теста — то, что вы реализацию функции дублируете в коде теста. То есть используете одну реализацию для тестирования другой:
* теперь у вас есть две реализации одной и той же функции, которые нужно держать в актуальном состоянии;
* очевидно, что функция суммирования довольно примитивна, а представьте, если ваш код делает что-то посложнее суммирования.
Кроме того, когда мы так тестируем код, то понимаем, что это некоторое лукавство, ведь мы проверили его только на двух парах входных данных.
```
equal( sum(1, 2), 3 )
equal( sum(4, 8), 12 )
```
Этот тест показывает, что код правильно отрабатывает только в этих двух случаях. Лучшие из нас догадываются, что неплохо протестировать граничные случаи, вроде отрицательных чисел, чисел с плавающей точкой и других. Но это все равно отражает предвзятость разработчика.
Опять же возникает проблема с чертовым энтерпрайз-программистом (The Enterprise Developer From Hell). Этот термин ввел [Скотт Влашин](https://fsharpforfunandprofit.com/posts/property-based-testing/), известный популяризатор F#. Вы можете подумать, что энтерпрайз-программист нереалистичен. Понятно, что в здоровой компании ни один нормальный человек не будет ломать функции, но во многих случаях мы сами действуем таким образом.
Мы ведь пишем функции намного сложнее, чем A+B, и в процессе реализации можем написать код, который работает в частных конкретных случаях, а не в общем. Это происходит не из-за злого умысла, а непреднамеренно, из-за неосознанности и слепоты.
Итак, что мы можем сделать с этим. Давайте думать.
**A + B**
Нет смысла завязывать тесты на A или на B, нужно тестировать то, что посередине, сам плюсик. То есть нужно написать такой тест, который сфокусируется не на входе-выходе, а на свойствах. Эти свойства должны быть истинными для любой правильной реализации. Поэтому давайте подумаем, какие свойства есть у суммирования.
### Коммутативность
По школьной программе мы знаем такое свойство: «от перемены мест слагаемых сумма не меняется». То есть сложение обладает свойством переместительности — коммутативностью. Давайте напишем тест, который проверит, что наша реализация соответствует этому свойству:
```
const actual = sum(1, 2)
const expected = sum(2, 1)
equal(actual, expected)
```
В этом тесте хорошо то, что он работает с любыми входными данными, а не только со специальными магическими числами. Ничего не мешает нам сделать что-то такое:
```
const rand = Math.random
const [n1, n2] = [ rand(), rand() ]
const actual = sum( n1, n2 )
const expected = sum( n2, n1 )
equal(actual, expected)
```
Сложение двух чисел — не то что мы делаем каждый день, однако подобный подход можно использовать не только для математических операций, но и для тестирования реальных веб-служб, баз данных и даже интерфейсов. Поэтому следующий пример с делением двух чисел:
```
function div (dividend, divisor) {
return dividend / divisor
}
```
Заходим в Википедию, и оказывается, что у деления есть свойство [дистрибутивность справа](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_(%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)#%D0%A1%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2%D0%B0). Оно означает, что деление суммы двух чисел на какой-то делитель — это то же самое, что деление их по отдельности. Отлично, давайте протестируем это:
```
const [n1, n2, n3] = [rand(), rand(), rand()]
const left = div(n1 + n2, n3)
const right = div(n1, n3) + div(n2, n3)
equal(left, right)
```
Теперь запускаем этот тест в цикле много-много раз и при должном терпении получаем такую комбинацию входных данных:
```
const [n1, n2, n3] = [0, 0, 0]
```
И тест не проходит, потому что деление нуля на ноль дает NaN:
```
assert.js:85
throw new AssertionError(obj);
^
AssertionError [ERR_ASSERTION]: NaN == NaN
```
А NaN, как известно, не равен NaN. Это нормальное поведение JavaScript, но теперь мы понимаем, что в нашей функции деления нужно сделать проверку на нули. Крутим наш тест в цикле дальше, каждый раз генерируя новую порцию случайных данных. В какой-то момент получаем такую комбинацию:
```
const [n1, n2, n3] = [2, 1, -347]
```
И тест опять падает:
```
assert.js:85
throw new AssertionError(obj);
^
AssertionError [ERR_ASSERTION]:
-0.008645533141210375 == -0.008645533141210374
```
Это [неточность округления](https://0.30000000000000004.com/) чисел с плавающей точкой. То есть опять [нормальные ограничения](https://en.wikipedia.org/wiki/IEEE_754-1985) вычислений, но когда мы генерируем входные данные, эти ограничения становятся явными. Теперь нам в нашей функции нужно подумать про явное округление или алгоритм, который уменьшит вычислительную погрешность, например алгоритм [Кахана Бабушки](https://www.semanticscholar.org/paper/A-Generalized-Kahan-Babu%C5%A1ka-Summation-Algorithm-Klein/17607d467cda1d0277ad272deb2113533131dc09).
Казалось бы, мы написали обычный тест, но в нем нет магических значений, взятых из нашего воображения. Мы используем произвольные значения и получаем возможность выполнять тест много-много раз на разных входных данных, проверяя саму спецификацию, то есть то, что функция должна делать, а не ее поведение на единичных примерах.
Это и есть тестирование на основе свойств — property-based testing. То есть комбинация следующих вещей:
1. Сначала мы описываем входные данные — говорим системе, какие случайные данные нужно сгенерировать.
2. Потом описываем ожидаемые свойства — какие-то условия прохождения теста.
3. А потом просто запускаем этот тест много-много раз.
Как выявлять свойства?
----------------------
Чтобы выявить свойство для вашей конкретной функции, сначала нужно сформулировать требования. При таком тестировании даже не надо генерировать случайные данные. Вы можете проверять свойства на конкретных примерах, допустим, на сильно отличающихся значениях, каких-то граничных случаях.
Но мы прежде всего хотим убедиться, что наша функция [тождественна на заданном множестве](https://ru.wikipedia.org/wiki/%D0%9A%D0%B2%D0%B0%D0%BD%D1%82%D0%BE%D1%80_%D0%B2%D1%81%D0%B5%D0%BE%D0%B1%D1%89%D0%BD%D0%BE%D1%81%D1%82%D0%B8). То есть она работает правильно на всех допустимых значениях.
Конечно, никто не запрещает гонять тест в цикле, вручную подставляя эти иксы, но нам обязательно нужен надежный способ воспроизводить упавшие тесты. К счастью, для этого есть готовые фреймворки.
Фреймворки
----------
Как известно, все лучшее в программировании было изначально придумано в мире Haskell. 20 лет назад идея property-тестирования была реализована во фреймворке [QuickCheck](https://www.cs.tufts.edu/~nr/cs257/archive/john-hughes/quick.pdf).
Сейчас эта форма тестирования в экосистеме Haskell фактически является доминирующей. Для JavaScript есть несколько библиотек, но я остановлюсь на двух: [JSVerify](https://github.com/jsverify/jsverify) и [fast-check](https://github.com/dubzzz/fast-check).
```
const jsc = require('jsverify')
jsc.assertForall(
jsc.integer, jsc.integer,
(a, b) => a + b === b + a
)
```
Это простой тест на переместительное свойство сложения, о котором мы говорили в начале. Так как у нас нетипизированный язык, надо как-то сообщить фреймворку, какие аргументы мы ожидаем. Тут мы говорим, что нам нужно два числа и последним аргументом передаем предикат. По умолчанию JSVerify запустит тест сто раз, каждый раз генерируя новую пару входных значений.
Давайте проверим переместительное свойство у вычитания. Конечно, такого свойства у вычитания нет, поэтому мы получим объект с ошибкой и законсолим ее:
```
const subtractionIsCommutative = jsc.checkForall(
jsc.integer, jsc.integer,
(a, b) => a - b === b - a
)
console.log(subtractionIsCommutative)
{
counterexample: [ 0, 1 ],
tests: 1,
shrinks: 4,
rngState: '0e168f30eac572b94d'
}
```
Система говорит, что упала после первого же теста на контрпримере 0 и 1. RngState — это состояние генератора случайных чисел. В данном случае тестовые данные являются детерминировано случайными. Random number generator выводит для нас seed, который можно подсунуть в test runner, чтобы воспроизвести упавший кейс. Это удобно для отладки, помогает с воспроизводимостью в CI/CD.
```
mocha test.js --jsverifyRngState 0e168f30eac572b94d
```
JSVerify имеет небольшой DSL для типов, который позволяет немного сократить запись. Иногда это бывает удобно, например, когда нужны пользовательские типы, легче написать так:
```
jsc.assert(jsc.forall(
'{ name: asciinestring; age: nat }',
(obj) => {
console.log(obj) // { name: '9lfpy', age: 34 }
return true
}
))
```
Чем так:
```
jsc.record({
name: jsc.asciinestring,
age: jsc.nat,
})
```
Выбирайте удобный вам способ. Так мы можем генерировать любые собственные типы, например объекты, которые приходят нам с бэкенда. Если встроенных генераторов не хватает, вы легко можете написать собственный. Допустим, вам нужна не просто строка, а строка с email-адресом. Можно сгенерировать ее таким образом:
```
const emailGenerator = jsc
.asciinestring.generator
.map(str => `${str}@example.com`)
```
В реальной жизни
----------------
Теперь давайте посмотрим, как это можно применять в реальной жизни. У библиотеки [query-string](https://www.npmjs.com/package/query-string) шесть миллионов скачиваний в неделю. Этот пакет указан в зависимостях более чем четырех тысяч других пакетов.
Query-string делает одну простую вещь — парсит URL-строку в объект и, наоборот, может из объекта сгенерировать URL или его часть:
```
queryString.parseUrl('https://foo.bar?foo=bar')
//=> {url: 'https://foo.bar', query: {foo: 'bar'}}
queryString.stringify({b: 1, c: 2, a: 3})
//=> 'b=1&c=2&a=3'
```
Естественно, эта библиотека покрыта кучей классических example-based тестов. Суммарно 400 строк [кода тестов](https://github.com/sindresorhus/query-string/tree/master/test).
Но вы не можете учесть все варианты, сколько бы тестов ни написали. Вместо того чтобы выдумывать новые примеры, автор библиотеки fast-check написал один единственный [тест](https://github.com/sindresorhus/query-string/blob/master/test/properties.js), сконцентрированный на свойствах библиотеки:
```
fastCheck.property(
queryParamsArbitrary, optionsArbitrary,
(object, options) => deepEqual(
queryString.parse(queryString.stringify(object, options), options),
object
)
)
```
Query-string — классическая инверсия, то есть любой объект должен быть переведен в query-строку, а если спарсить эту строку, то должен получиться исходный объект.
Как вы понимаете, он тут же словил [баг](https://github.com/sindresorhus/query-string/pull/138).
Этот же подход он применил для тестирования печально известной библиотеки left-pad и обнаружил [баг](https://github.com/left-pad/left-pad/issues/58) со строками, которые содержат символы вне основной [плоскости Юникод](https://ru.wikipedia.org/wiki/%D0%9F%D0%BB%D0%BE%D1%81%D0%BA%D0%BE%D1%81%D1%82%D1%8C_(%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4)), например emoji.
Но как ему удавалось так легко выводить свойства, которые находят баги? Все потому, что он знаком с популярными свойствами. Давайте тоже рассмотрим их.
### Инверсия
Подход известен так же, как Бильбо-тестирование в честь повести Толкиена «Туда и обратно».
Допустим, у нас есть функция шифрования. Если к полученному результату применить дешифрование, в итоге мы должны получить исходное сообщение:
```
const string = 'ANY_STRING'
const encrypted = encrypt(string)
expect( decrypt(encrypted) ).toBe( string )
```
При этом не важно, какое именно сообщение мы зашифровали — это может быть любая строка. Соответственно, мы можем ее сгенерировать. То же самое можем применить для сериализации-десериализации, кодирования-декодирования, сжатия без потерь и так далее.
Именно это свойство мы видели при тестировании query-string:
```
const obj = {any: 'object'}
_.isEqual(
JSON.parse( JSON.stringify(obj) ),
obj,
)
```
Запись/чтение, вставка/поиск также соответствуют этому шаблону, даже если они не являются строгими инверсиями.
### Обратимость
Также частным случаем инверсии является round-trip. Это когда мы берем обратимую функцию и применяем ее дважды:
```
_.isEqual(
[...array].reverse().reverse(),
array,
)
```
То есть если наша функция переворачивает массив, мы можем сгенерировать массив с любыми данными внутри, перевернуть его дважды и получившийся результат должен соответствовать исходному массиву.
### Инвариантность
Поиск инвариантов — это поиск чего-то, что не меняется при применении функции. Допустим, у нас есть функция сортировки. Если применить сортировку к любому массиву, длина этого массива не должна поменяться:
```
equal(
[...array].sort().length,
array.length,
)
```
Кроме того, элементы массива тоже не должны меняться: они могут поменять свой порядок, но сами по себе не меняются — каждый элемент исходного массива должен быть найден в отсортированном массиве.
Размер, длина, содержимое — отличные характеристики для проверки того, что ваша функция не меняет то, что не должна менять. Обычно такая проверка недостаточна сама по себе, но часто действуют как контрпроверка к другим свойствам.
### Идемпотентность
Например, к свойству идемпотентности. Это свойство при повторном применении функции будет давать тот же результат, что и при первом. Например, если мы единожды отсортировали массив, повторная сортировка ничего не изменит:
```
_.isEqual(
[...array].sort().sort(),
array.sort(),
)
```
```
string.padStart(10) === string.padStart(10).padStart(10)
```
Форматирование, поиск уникальных значений, нормализация, добавление существующего элемента в множество — все эти операции при повторном применении не должны ничего менять.
### Трудно доказать, легко проверить
Это свойство обычно иллюстрируют на примере лабиринта. Найти выход из лабиринта трудно, но если ваша функция умеет находить выход, ее легко протестировать — нужно просто следовать ее указаниям. В результате она должна нас привести к выходу. Мы не знаем кратчайший это путь или нет, но хотя бы уверены — это правильный путь, который ведет к выходу.
Другой пример — опять же функция сортировки. Правильно отсортировать массив довольно трудно. Но мы легко можем проверить результат сортировки — нужно последовательно брать элементы массива и сравнивать их с последующими. Если мы сортируем по возрастанию, то текущий элемент всегда должен быть меньше последующего (или равен ему).
### Эталонная реализация
Также этот подход называют тестовым оракулом. Допустим, у нас есть две функции, которые делают одно и то же.
Например, нам пришло в голову реализовать собственную функцию сортировки. При этом у нас есть встроенная в JavaScript функция сортировки, которую мы принимаем за эталонную. Идея тестового оракула в том, чтобы сравнивать результаты нашей сортировки с результатами эталонной.
Таким образом, мы можем генерировать рандомные данные, подавать их в обе функции и проверять, что результаты совпадают:
```
_.isEqual(
[...array].sort(),
fastestSortingAlgorithm(array),
)
```
Это хороший шаблон, если вы рефакторите старый код. Вы можете убедиться, что новая реализации выдает такие же результаты, как ее старый аналог. Тестовый оракул в данном случае проверяет свойство соответствия эталонной реализации.
### Только не падай
В данном случае свойством выступает то, что функция хотя бы не падает. Такой способ тестирования называют фаззингом, когда мы передаем на вход приложению неправильные или случайные данные и смотрим, падает ли система, нет ли зависаний, нарушений внутренней логики и неожиданного поведения.
Допустим, у нас есть API — неважно, какие ручки мы дергаем, какие данные передаем, в любом случае сервер не должен отвечать 500. Само по себе это свойство имеет немного смысла, но как отправная точка — сгодится.
Тестирование UI
---------------
Представьте, что у вас интернет-магазин с корзиной товаров, вам надо ее протестировать. Сначала нужно определить доступные действия:
* мы можем добавить товар в корзину;
* удалить товар;
* очистить корзину.
Теперь давайте выявлять свойства. Навскидку можно сказать, что количество товаров не может быть отрицательной величиной: *Корзина >= 0*. При этом в корзине не может быть товаров больше, чем в каталоге: *Корзина <= Каталог*. А сумма всей корзины не может быть меньше, чем цена самого дорогого товара в ней: *sum(Корзина) >= max(Товары)*.
Дальше вы в цикле много-много раз генерируете допустимую последовательность действий и проверяете все свойства после каждого шага. Условно говоря, вы в рандомном порядке много-много раз что-то добавляете в корзину, что-то удаляете, очищаете ее и так далее. И после каждого шага проверяете истинность всех свойств.
При таком тестировании вы можете проходить через пользовательский интерфейс и нажимать на кнопочки как в обычных e2e-тестах. Но если у вас на фронте фреймворк, в котором представление — это чистая функция от модели, то вы можете просто манипулировать моделью.
Такой подход применили разработчики Spotify для [тестирования плейлиста](https://labs.spotify.com/2015/06/25/rapid-check/).
Плюсы и минусы тестирования на основе свойств
---------------------------------------------
### Плюсы
1. Тесты на основе свойств заменяют множество example-based тестов, то есть вы пишете меньше кода, а тестов получаете намного больше.
2. Такие тесты могут сами находить крайние случаи, о которых вы могли не подумать: деление на ноль, строки с emoji и тому подобное.
3. Их легче поддерживать, потому что у вас нет жестко закодированных данных в тестовом наборе — каких-то магических строк и чисел, непонятно откуда взявшихся. Такие тесты являются более общими, поэтому менее хрупкими.
4. Писать такие тесты намного интереснее, чем традиционные, так как придумывать примеры скучно, а здесь за вас это делает библиотека.
5. Тесты на основе свойств заставляют вас думать. Если вы лучше понимаете бизнес-требования, это заставляет вас иметь чистый дизайн и в тестах, и в коде.
### Минусы
1. Написание каждого теста требует больше усилий. Нужно подумать о требованиях и вывести свойства.
2. Классические тесты служат документацией к коду, то есть показывают пример использования ваших функций. Property-based тесты получаются более абстрактными, а значит, сложными для понимания.
3. Каждый тест нужно запустить сотню раз, поэтому немного увеличивается время выполнения тестов.
4. Такие тесты дают ложное ощущение безопасности. Допустим, вы выявили несколько свойств у функции и это дает вам уверенность, что реализация правильная. Однако свойство может быть необходимым, но недостаточным. Например, функция умножения обладает свойством переместительности точно так же, как суммирование, но делают эти функции немного разные вещи.
Выводы
------
Мы не должны отказываться от классических тестов, но можем их комбинировать с тестированием на основе свойств.
Например, можно базовый функционал покрывать классическими тестами на основе примеров, а критически важные функции дополнительно покрывать property-тестами.
P.S.
----
Это текстовая версия доклада с [HolyJS Piter 2019](https://www.youtube.com/watch?v=H-cBhNMxlCw) и [Panda Meetup #22](https://www.youtube.com/watch?v=pAKapxZ9fak).
---
**Что еще почитать**:
* [Как технический долг убивает ваши проекты](https://mcs.mail.ru/blog/kak-tekhnicheskij-dolg-ubivaet-vashi-proekty).
* [Мой второй год в качестве независимого разработчика](https://mcs.mail.ru/blog/moj-vtoroj-god-v-kachestve-nezavisimogo-razrabotchika).
* [Наш телеграм-канал с новостями о цифровой трансформации](https://tele.click/zavtra_oblachno). | https://habr.com/ru/post/494110/ | null | ru | null |
# Прокладываем тропинки до микросервисов
Одна из наиболее важных задач при разделении системы на микросервисы - обеспечить надежный механизм их репликации и обнаружения и создать набор правил для маршрутизации входящих запросов к соответствующим контейнерам или сетевым узлам. Идеальная система также должна уметь отслеживать состояние доступности и исключать недоступные реплики из маршрутизации. В этой статье мы поговорим об использовании маршрутизатора [Kong](https://konghq.com/kong), который принимает на себя не только задачи умной маршрутизации, но и возможности по протоколированию и трансформации запросов, контролю доступа, мониторингу запросов, а также может быть расширен с использованием плагинов.
Маршрутизатор Kong Gateway существует в свободном и коммерческом варианте, может быть запущен как самостоятельное приложение (например, через docker-контейнер [kong](https://hub.docker.com/_/kong)), либо установлен в Kubernetes (в этом случае он представляется как специализированный Ingress-контроллер). Для управления Kong можно использовать как запросы к API, так и веб-интерфейсы Kong Manager или [Konga](https://hub.docker.com/r/pantsel/konga). Многие расширения предустановлены в официальном контейнере, но они также могут быть найдены в [Kong Plugin Hub](https://docs.konghq.com/hub/). Мы с вами рассмотрим установку и настройку на примере простого приложения, состоящего из трех микросервисов (один из которых представляет публичный интерфейс без авторизации, для одного мы будем задавать сложные правила маршрутизации, а третий будет требовать обязательное использование токена для доступа к точкам подключения).
Для начала составим топологию нашей системы и выделим микросервисы:
* сервис поиска местоположения и расширенной информации о городе по стране и названию (используется приложение Chercheville на Elixir , доступное на [Docker Hub](https://hub.docker.com/r/weatherforce/chercheville));
* сервис для получения информации из профиля авторизованного пользователя;
* сервис для выполнения авторизации и получения токена.
Каждый сервис будет иметь собственную базу данных (или сторонний источник данных) и все взаимодействие между системами будет выполняться через шлюз API, который мы и будем настраивать с использованием Kong API Gateway.
Kong использует для сохранения своей конфигурации базу данных PostgreSQL, либо может быть запущен с определением сервисов и привязок к json/yaml-файле. Мы будем рассматривать вариант запуска с базой данных. Для координации запуска будем использовать Docker Compose, который можно найти в официальном репозитории: <https://github.com/Kong/docker-kong> (путь /compose).
```
docker compose --profile database up -d
```
После выполнения первоначальных миграций базы данных запускается основной процесс, который начинает прослушать несколько TCP-портов:
* 8000/8443 - HTTP/HTTPS-трафик для маршрутизации к серверам;
* 8001/8444 - HTTP/HTTPS порты для отправки административных запросов (также используется веб-интерфейсом Konga для управления ресурсами);
* 8002/8445 - HTTP/HTTPS подключение к Kong Manager (веб-интерфейс), должен быть дополнительно разрешен и опубликован через docker-compose.yaml.
Перед настройкой маршрутов нужно разобраться с используемыми терминами в Kong:
* Service - конфигурация backend-сервиса (протокол http/https, адрес хоста, порт, количество попыток подключения и таймауты, идентификатор клиентского сертификата при использовании https). К конфигурации сервиса могут быть подключены плагины для аудита/трансформации запросов, а также определены допустимые потребители (consumer).
* Route - правило маршрутизации входящих запросов, включает в себя перечисления связанных сервисов (может быть больше одного для отказоустойчивости) и группу фильтров (для http-протоколов) или набор правил для tcp-stream маршрутизации. К каждому маршруту может быть также добавлен плагин для обработки запросов.
+ название домена (Hosts);
+ префиксы пути (Paths);
+ HTTP-методы (Methods);
+ протоколы (http / https);
+ проверка доменов для tcp-stream маршрутизации (SNI);
+ источники запроса для tcp-stream (sources);
+ получатели запроса для tcp-stream (destinations).
* Certificate - зарегистрированные клиентские сертификаты для подключения к https backend-сервисам (для каждого формируется уникальный id, который используется при конфигурации сервиса).
* Upstream - правило пересылки http/https трафика на один или несколько сервисов. После создания и настройки upstream появляется возможность добавить targets (ip/dns-адреса целевых серверов, порты и значение веса, которое влияет на вероятность выбора сервера при использовании хэш-правила none), а также Alert для отправки уведомлений администраторам по почте или в Slack при недоступности целевого сервера:
+ Hash on - метод хэширования для выбора целевого сервиса из пула (может быть consumer, ip, cookie, header, none). В случае none используется последовательный выбор сервисов для равномерного распределения;
+ Hash fallback - альтернативный метод хэширования, если основной не вернул результат (например, отсутствовал cookie или заголовок);
+ Active Health Check - конфигурация проверки доступности (http-метод, путь, коды успешных и неуспешных ответов, количество попыток проверки, интервал проверки);
* Consumer - зарегистрированные авторизованные пользователи сервисов и метод их авторизации. Для Consumer определяется набор Credentials - это может быть Basic Auth (имя и пароль), API Key, Hash-based message authentication code (HMAC) - имя и секрет, OAuth2 (id и секрет приложения, redirect uri), JSON Web Token (JWT).
Для управления ресурсами можно использовать http-запросы к порту администрирования 8001 (или 8444 для https-запросов):
* `http://ip:8001/services` - просмотр списка/регистрация нового сервиса;
* `http://ip:8001/routes` - просмотр/создание маршрута;
* `http://ip:8001/consumers` - управление авторизованными пользователями;
* `http://ip:8001/upstreams` - изменение правил проксирования с проверкой доступности (upstream);
* `http://ip:8001/certificates` - управление клиентскими сертификатами;
* `http://ip:8001` - просмотр информации о запущенном экземпляре kong.
Для удобства доступа можно создать маршрут к admin api через основной порт (8000):
```
curl -X POST http://127.0.0.1:8001/services \
--data name=admin-api \
--data host=127.0.0.1 \
--data port=8001
curl -X POST http://127.0.0.1:8001/services/admin-api/routes \
--data paths[]=/admin-api
```
И далее будет возможно получить доступ к сервису администрирования через http://localhost:8000/admin-api/. Наличие API для администрирования позволяет выполнить саморегистрацию сервиса и маршрута при запуске, но сейчас у нас доступ к api выполняется без авторизации, что нельзя назвать безопасным решением. Создадим новый consumer с APIKey и назначим его на доступ к маршруту api:
```
curl -i -X POST \
--url http://localhost:8001/services/admin-api/plugins/ \
--data 'name=key-auth'
curl -i -X POST \
--url http://localhost:8000/admin-api/consumers/ \
--data "username=admin"
curl -i -X POST \
--url http://localhost:8000/admin-api/consumers/admin/key-auth/ \
--data 'key=6Y6fKCsFWWWSRMXGyUWs8g9q'
```
Теперь доступ к API будет происходить только с использованием заголовка apikey: 6Y6fKCsFWWWSRMXGyUWs8g9q.
Кроме плагинов авторизации, можно добавить следующие расширения:
* `session` - отслеживание сессии между запросами (чаще всего с использованием cookie);
* `bot detection` - обнаружение активности ботов;
* `cors` - управление политикой cors;
* `ip restriction` - ограничение доступа по белым и черным спискам;
* `acme` - интеграция с letsencrypt для автоматического обновления сертификатов;
* `rate limiting` - ограничение количества запросов в секунду;
* `response ratelimiting` - ограничение количества ответов в секунду;
* `request size limiting` - ограничение размера запроса;
* `proxy cache` - кэширование ответа;
* `pre function` - запустить lua-функцию перед обработкой запроса;
* `post function` - запустить lua-функцию после обработки запроса;
* `aws lambda` - запустить внешнюю функцию с AWS при обработке правила;
* `azure functions` - запустить Azure-функцию при обработке правила;
* `datadog` - отправить метрики запросов в datadog;
* `prometheus` - отправить метрики по правилам в prometheus;
* `zipkin` - отправка меток по обработке правил для распределенной трассировки zipkin;
* `request transformer` - изменение запроса перед передачей на upstream-сервер;
* `response transformer` - изменение ответа upstream-сервера;
* `correlation ID` - отслеживание связи в цепочке пересылок;
* `tcp/udp/http log` - отправка информации о запросе и ответе на сервер журналирования через tcp/udp/http;
* `file log` - запись информации о запросе/ответе в файл;
* `syslog` - отправка запроса и ответа в системный процесс syslog;
* `statsd` - отправка статистики по обработке запроса в statsd;
* `loggly` - пересылка информации о запросе/ответе в loggly.
При необходимости создания собственных расширений можно использовать [Python Developent Kit](https://github.com/Kong/kong-python-pdk).
Для управления также можно установить konga для настройки всех ресурсов через веб-интерфейс:
```
docker network create konga
docker rm -f konga-db
docker run -d --network=konga --name konga-db -v /data/mongo:/data/db mongo
docker rm -f konga2
docker run -d --network=konga --name konga -e NODE_ENV=production -e "TOKEN_STRING=fdoER#2sa" -e DB_ADAPTER=mongo -e DB_HOST=konga-db -e DB_DATABASE=konga --network=konga -p 443:1337 -v /data/konga:/data -e SSL_KEY_PATH=/data/cert.key -e SSL_CRT_PATH=/data/cert.crt pantsel/konga
```
При выполнении первого подключения нужно будет сконфигурировать адрес Kong API и далее можно будет подключиться к https и выполнить аналогичные настройки через веб-интерфейс:
Интерфейс KongaЗапустим теперь наш сервис для маршрутизации и выполним привязку его методов к префиксу /place. Для этого клонируем [репозиторий](https://github.com/weatherforce/chercheville) и запустим docker compose up -d. После запуска будет необходимо выполнить импорт данных по странам:
```
docker exec -ti chercheville-app-1 sh
./bin/chercheville rpc 'ChercheVille.SeedData.import_data(["FR"])'
```
Для проверки доступности сервиса выполним запрос `http://localhost:5000/cities/?q=Paris`. Теперь выполним связывание сервиса и маршрута через konga:
Здесь Host - внешний адрес сервера (альтернативно можно использовать DNS-имя во внутренней сети или через используемый Service Discovery, например Consul). Дальше необходимо настроить привязку сервиса к внешнему маршруту:
Strip Path позволяет трансформировать адрес и убрать префикс /places при пересылке запроса. Теперь сервис будем доступен через адрес http://localhost:8000/places/ и можно будет выполнить запрос между микросервисами или от внешнего клиента через API Gateway.
Следующим шагом выполним саморегистрацию сервиса авторизации в kong, который также будет управлять Consumer для доступа к сервису профиля:
```
import requests
import socket
from flask import Flask
gateway = "http://localhost:8000"
kong_api = f"{gateway}/admin-api"
headers = {
"apikey": "6Y6fKCsFWWWSRMXGyUWs8g9q"
}
hostname = socket.gethostname()
local_ip = socket.gethostbyname(hostname)
# саморегистрация сервиса
requests.post(f"{kong_api}/services", headers=headers, data={
"name": "authorizer",
"url": "http://{local_ip}:10080"
})
requests.post(f"{kong_api}/services/authorizer/routes", data={
"paths[]=/auth"
})
app = Flask(__name__)
@app.route("/login")
def login():
# extract and check login/password
login = "login"
requests.post(f"{kong_api}/consumers", data={"username": login}) # регистрируем consumer
@app.route("/logout")
def logout():
requests.delete(f"{kong_api}/consumers/{login}")
app.run(port=10080)
```
При регистрации сервиса profile необходимо добавить плагин key-auth для проверки токена при обращении к адресам profile. При авторизации будет добавлен заголовок X-Consumer-ID для хранения идентификатора, который соответствует представленному токену.
```
import requests
import socket
import json
import flask
gateway = "http://localhost:8000"
kong_api = f"{gateway}/admin-api"
headers = {
"apikey": "6Y6fKCsFWWWSRMXGyUWs8g9q"
}
hostname = socket.gethostname()
local_ip = socket.gethostbyname(hostname)
# саморегистрация сервиса
requests.post(f"{kong_api}/services", headers=headers, data={
"name": "profile",
"url": "http://{local_ip}:9080"
})
requests.post(f"{kong_api}/services/profile/routes", data={
"paths[]=/profile"
})
requests.post(f"{kong_api}/services/profile/plugins", data={
"name=key-auth"
})
app = flask.Flask(__name__)
@app.route("/profile")
def login():
consumers = json.loads(requests.get(f"{kong_api}/consumers"))
# определение имени (идентификатора) пользователя
# список содержит id (consumer id) и имя пользователя (name)
id = flask.request.headers.get("X-Consumer-ID")
username = None
for c in consumers:
if c["id"]==id:
username = c["username"]
if not username:
flask.abort(403, "Not authorized")
return f"Logged user: {username}"
app.run(port=9080)
```
Аналогично можно настроить удаление сервисов и маршрутов при завершении приложения. Таким образом с использованием API-шлюза Kong можно динамически изменять привязку маршрутов к экземплярам сервисов, а также решать типичные задачи контроля доступа и получения метрик по времени выполнения запросов.
---
Всех, кому интересна тема микросервисов, хочу пригласить на бесплатный урок по теме: "Авторизация и аутентификация в микросервисной архитектуре". Регистрация доступна по ссылке ниже.
* [Зарегистрироваться на вебинар](https://otus.pw/9o8R/) | https://habr.com/ru/post/669342/ | null | ru | null |
# Кому с Redux жить хорошо
Приветствую всех любителей хорошей инженерки! Меня зовут Евгений Иваха, я фронтенд-разработчик в команде, занимающейся дев-программой в ManyChat. В рамках дев-программы мы разрабатываем инструменты, позволяющие расширять функциональность ManyChat за счет интеграции со сторонними системами.
Существует мнение, что разработка через тестирование, или по канонам **Test Driven Development (TDD)** для фронтенда не применима. В данной статье я постараюсь развенчать этот миф и покажу, что это не только возможно, но и очень удобно и приятно.
Сам по себе [React](https://reactjs.org/) достаточно понятен любому разработчику, чего не скажешь про [Redux](https://redux.js.org/). На первый взгляд может показаться, что это какой-то монструозный и непонятный инструмент. Прочитав данную статью, вы узнаете как разрабатывать приложения через тестирование на React, используя Redux, поймёте преимущества его использования, научитесь не открывать браузер при разработке фронтенд-приложений и экономить время на дебаге. Возможно, найдёте что-то новое для себя про написание фронтовых тестов.
Про TDD вообще и частный случай тестирования React-компонентов можно прочитать в [статье моего коллеги Андрея](https://habr.com/ru/company/manychat/blog/528794/), в данном материале я не буду заострять внимания на нюансах, но целиком и полностью пройду весь путь создания приложения через написание тестов.
Любой фронтенд-компонент продукта сам по себе делится на несколько составляющих. Для простоты можно считать, что в браузерном приложении есть свой фронтенд и свой бэкенд. Первый отвечает за непосредственный пользовательский интерфейс, а второй за бизнес-логику. React нам помогает с интерфейсами, а Redux представляет собой очень удобный инструмент для обработки бизнес-логики.
Поскольку, мы в ManyChat в начале 2020 года полностью перешли на [TypeScript](https://www.typescriptlang.org/), будем писать код сразу с использованием строгой типизации.
### Redux
Что такое Redux? Redux — это паттерн и библиотека для управления и обновления состоянием приложения с использованием специальных событий, называемых Action. Он предоставляет централизованное хранилище состояния, которое используется во всём приложении с правилами, гарантирующими предсказуемое изменение этого состояния. Если посмотреть на диаграмму потока данных в Redux для приложений на React, мы увидим примерно следующее:
При необходимости изменения состояния, например, при клике на элемент в DOM, вызывается Action creator, который создаёт определенный Action. Этот Action c помощью метода Dispatch отправляется в Store, где он передаётся на обработку в Reducers. Редьюсеры, в свою очередь, на основании текущего состояния и информации, которая находится в экшене, возвращают новое состояние приложения, которое принимает React с помощью Selectors для нового рендера DOM. Более подробно о каждом компоненте Redux будет рассказано ниже по ходу разработки приложения.
Такой однонаправленный поток данных даёт множество преимуществ, таких как — ослабление связанности компонентов, один источник информации о том, как должно выглядеть и действовать приложение, плюс разделение бизнес-логики и отображения, что приводит к значительному упрощению тестирования кода.
### Задача
Создадим форму принятия какого-то пользовательского соглашения. Форма должна содержать чекбокс, который следует отметить пользователем, в случае, если он принимает соглашение, а так же кнопку **Submit**, которая становится активной только при активации чекбокса. Выглядеть это должно примерно вот так:
Воспользуемся шаблоном create-react-app:
```
npx create-react-app my-app --template typescript
cd my-app
npm start
```
Запустили, убедились, что приложение работает.
Можем остановить сборщик, поскольку он понадобится нам ещё очень не скоро. Можем даже закрыть браузер.
Теперь приступим к самому вкусному — подключению Redux в наш проект. Т.к. приложение у нас совершенно пустое, мы не знаем структуру стора, оставим его напоследок.
Установим нужные пакеты:
```
npm i redux react-redux redux-mock-store @types/redux @types/react-redux @types/redux-mock-store
```
### Actions
Что такое Action? Это обычный Javascript объект, у которого есть обязательное свойство **type**, в котором содержится, как правило, осознанное имя экшена. Создатели Redux рекомендуют формировать строку для свойства type по шаблону **домен/событие**. Также в нём может присутствовать дополнительная информация, которая, обычно, складывается в свойство **payload**. Экшены создаются с помощью **Action Creators** — функций, которые возвращают экшены.
Раз у нас всего лишь чекбоксы, кажется, достаточно одного экшена, отрабатывающего изменение его состояния, нам нужно только придумать ему название или `type`.
Напишем первый тест. Для тестирования используем уже ставший стандартным фреймворк [Jest](https://jestjs.io/). Для запуска тестов в следящем режиме, достаточно в корне проекта выполнить команду `npm test`.
```
// actions/actions.test.ts
import { checkboxClick } from '.'
describe('checkboxClick', () => {
it('returns checkboxClick action with action name in payload', () => {
const checkboxName = 'anyCheckbox'
const result = checkboxClick(checkboxName)
expect(result).toEqual({ type: 'checkbox/click', payload: checkboxName })
})
})
```
Здесь мы проверяем, Action Creator вернёт экшн с нужным типом и правильными данными, а именно — с названием чекбокса. И больше нам здесь нечего проверять.
Само собой, тест у нас красный (сломанный), т.к. код ещё не написан:
Пора написать код:
```
// actions/package.json
{
"main": "./actions"
}
// actions/actions.ts
export const checkboxClick = (name: string) => ({ type: 'checkbox/click', payload: name })
```
Проверяем:
Тест пройден, можем приступить к рефакторингу. Здесь мы видим явное дублирование константы с типом экшена, вынесем её в отдельный модуль.
```
// actionTypes.ts
export const CHECKBOX_CLICK = 'checkbox/click'
```
Поправим тест:
```
// actions/actions.test.ts
import { CHECKBOX_CLICK } from 'actionTypes'
import { checkboxClick } from '.'
describe('checkboxClick', () => {
it('returns checkboxClick action with action name in payload', () => {
const checkboxName = 'anyCheckbox'
const result = checkboxClick(checkboxName)
expect(result).toEqual({ type: CHECKBOX_CLICK, payload: checkboxName })
})
})
```
Тест не проходит, потому что мы не использовали относительный путь к `actionTypes`. Чтобы это исправить, добавим в `tsconfig.json` в секцию `compilerOptions` следующий параметр `"baseUrl": "src"`. После этого понадобится перезапустить тесты вручную.
Убедимся, что тест позеленел, теперь поправим сам код:
```
// actions/actions.ts
import { CHECKBOX_CLICK } from 'actionTypes'
export const checkboxClick = (name: string) => ({ type: CHECKBOX_CLICK, payload: name })
```
Ещё раз убеждаемся, что тест проходит, и можем двигаться дальше.
### Reducers
Напишем обработчик события изменения состояния чекбокса, т.е. **Reducer**. Редьюсеры — это специальные чистые функции, которые принимают на вход текущий **state** и **action**, решают как нужно изменить состояние, если это требуется, и возвращают новый **state**. Редьюсеры [должны содержать всю бизнес-логику приложения](https://redux.js.org/style-guide/style-guide#put-as-much-logic-as-possible-in-reducers), насколько это возможно.
Хранить состояние чекбоксов (отмечены они или нет) мы будем простым объектом, где ключом будет выступать название чекбокса, а в булевом значении непосредственно его состояние.
```
{
checkboxName: true
}
```
Приступим. Первый тест будет проверять, что мы получаем исходное состояние, т.е. пустой объект.
```
// reducers/reducers.test.ts
import { checkboxReducer } from '.'
describe('checkboxReducer', () => {
it('creates default state', () => {
const state = checkboxReducer(undefined, { type: 'anyAction' })
expect(state).toEqual({})
})
})
```
Т.к. у нас даже нет файла с редьюсером, тест сломан. Напишем код.
```
// reducers/package.json
{
"main": "./reducers"
}
// reducers/reducers.ts
const initialState: Record = {}
export const checkboxReducer = (state = initialState, action: { type: string }) => {
return state
}
```
Первый тест редьюсера починили, можем написать новый, который уже проверит, что получим в результате обработки экшена с информацией о нажатом чекбоксе.
```
// reducers/reducers.test.ts
import { CHECKBOX_CLICK } from 'actionTypes'
import { checkboxReducer } from '.'
describe('checkboxReducer', () => {
it('creates default state', () => {
const state = checkboxReducer(undefined, { type: 'anyAction' })
expect(state).toEqual({})
})
it('sets checked flag', () => {
const state = checkboxReducer(undefined, { type: CHECKBOX_CLICK, payload: 'anyName' })
expect(state.anyName).toBe(true)
})
})
```
Минимальный код для прохождения данного теста будет выглядеть следующим образом:
```
// reducers/reducers.ts
import { CHECKBOX_CLICK } from 'actionTypes'
const initialState: Record = {}
export const checkboxReducer = (
state = initialState,
action: { type: string; payload?: string },
) => {
if (action.type === CHECKBOX\_CLICK && action.payload) {
return { ...state, [action.payload]: true }
}
return state
}
```
Мы убедились, что при обработке экшена, в котором содержится имя чекбокса, в `state` будет состояние о том, что он отмечен. Теперь напишем тест, который проверит обратное поведение, т.е. если чекбокс был отмечен, то отметка должна быть снята, свойство должно получить значение **false**.
```
// reducers/reducers.test.ts
it('sets checked flag to false when it was checked', () => {
const state = checkboxReducer({ anyName: true }, { type: CHECKBOX_CLICK, payload: 'anyName' })
expect(state.anyName).toBe(false)
})
```
Убеждаемся, что тест красный, т.к. у нас всегда устанавливается значение в `true`, ведь до сего момента у нас не было других требований к коду. Исправим это.
```
// reducers/reducers.ts
import { CHECKBOX_CLICK } from 'actionTypes'
const initialState: Record = {}
export const checkboxReducer = (
state = initialState,
action: { type: string; payload?: string },
) => {
if (action.type === CHECKBOX\_CLICK && action.payload) {
return { ...state, [action.payload]: !state[action.payload] }
}
return state
}
```
Отлично! Мы описали всю необходимую бизнес-логику в тестах, написали код, который этим тестам удовлетворяет.
### Selectors
Чтобы получить состояние чекбокса, нам понадобится **Selector**. Селекторы — это функции, которые умеют извлекать требуемую информацию из общего состояния приложения. Если в нескольких частях приложения требуется одинаковая информация, используется один и тот же селектор.
Напишем первый тест для селектора.
```
// selectors/selectors.test.ts
import { getCheckboxState } from './selectors'
describe('getCheckboxState', () => {
const state = {
checkboxes: { anyName: true },
}
it('returns current checkbox state', () => {
const result = getCheckboxState('anyName')(state)
expect(result).toBe(true)
})
})
```
Теперь заставим его «позеленеть».
Так как селектор должен знать, откуда извлекать информацию, определим структуру хранения.
```
// types.ts
export type State = {
checkboxes: Record
}
```
Теперь напишем код селектора. Здесь используется функция высшего порядка из-за особенностей хука `useSelector` пакета `react-redux`, который принимает на вход функцию, принимающую один аргумент — текущее состояние стора, а нам требуется сообщить ещё дополнительные параметры — название чекбокса.
```
// selectors/package.json
{
"main": "./selectors"
}
// selectors/selectors.ts
import { State } from 'types'
export const getCheckboxState = (name: string) => (state: State) => state.checkboxes[name]
```
Кажется, мы всё сделали правильно, тест теперь зелёный. Но что произойдёт, если у нас ещё не было информации о состоянии чекбокса? Напишем ещё один тест.
```
// selectors/selectors.test.ts
it('returns false when checkbox state is undefined', () => {
const result = getCheckboxState('anotherName')(state)
expect(result).toBe(false)
})
```
Получим вот такую картину:
И это правильно, мы получили на выходе `undefined`, т.е. state ничего не знает об этом чекбоксе. Исправим код.
```
// selectors/selectors.ts
import { State } from 'types'
export const getCheckboxState = (name: string) => (state: State) => state.checkboxes[name] ?? false
```
Вот теперь селектор работает, как и требуется.
### Store
Давайте теперь создадим сам **Store**, т.е. специальный объект Redux, в котором хранится состояние приложения.
```
// store.ts
import { AnyAction, createStore, combineReducers } from 'redux'
import { State } from 'types'
import { checkboxReducer } from 'reducers'
export const createAppStore = (initialState?: State) =>
createStore(
combineReducers({
checkboxes: checkboxReducer,
}),
initialState,
)
export default createAppStore()
```
Этот код мы отдельно тестировать не будем, т.к. мы используем стороннюю библиотеку, которая уже протестирована. Но далее мы напишем интеграционный тест, который проверит всю связку React + Redux.
### React Components
Т.к. всю необходимую бизнес-логику мы уже описали, можем приступить к слою отображения.
Для более удобной работы мы написали небольшую утилиту для тестов. В ней несколько больше функциональности, чем требуется для нашего первого теста, но далее мы всё это применим. Используем удобную библиотеку `react-test-renderer`, которая позволяет не производить рендер в настоящий DOM, а получать его JS представление. Установим пакет:
```
npm i react-test-renderer @types/react-test-renderer
```
Приступим к написанию тестов на компоненты. Начнём непосредственно с чекбокса.
### Checkbox
```
// components/Checkbox/Checkbox.test.tsx
import { create } from 'react-test-renderer'
import Checkbox from '.'
describe('Checkbox', () => {
it('renders checkbox input', () => {
const checkboxName = 'anyName'
const renderer = create()
const element = renderer.root.findByType('input')
expect(element.props.type).toBe('checkbox')
})
})
```
Первый тест компонента проверяет, что внутри `Checkbox` рендерится стандартный `input` с типом `checkbox`.
Сделаем тест зелёным.
```
// components/Checkbox/package.json
{
"main": "Checkbox"
}
// components/Checkbox/Checkbox.tsx
import React from 'react'
const Checkbox: React.FC = () => {
return (
)
}
export default Checkbox
```
Отлично, теперь добавим свойство `label`, содержащее текст для html элемента `label`, который должен отображаться рядом с чекбоксом.
```
// components/Checkbox/Checkbox.test.tsx
it('renders label', () => {
const labelText = 'anyLabel'
const renderer = create()
const element = renderer.root.findByType('label')
expect(element.props.children).toBe(labelText)
})
```
Заставим тест пройти.
```
// components/Checkbox/Checkbox.tsx
const Checkbox: React.FC<{ label: string }> = ({ label }) => {
return (
{label}
)
}
```
Осталась небольшая деталь — чекбокс как-то должен себя идентифицировать, кроме того, для корректной работы клика по `label`, нужно прописать id чекбокса в свойство `htmlFor`. Напишем тест, проверяющий установку свойства id:
```
// components/Checkbox/Checkbox.test.tsx
it('sets name prop as input id', () => {
const checkboxName = 'anyCheckbox'
const renderer = create()
const element = renderer.root.findByType('input')
expect(element.props.id).toBe(checkboxName)
})
```
Убедившись, что он красный, исправим код:
```
// components/Checkbox/Checkbox.tsx
const Checkbox: React.FC<{ name: string; label: string }> = ({ name, label }) => {
return (
{label}
)
}
```
Тест зеленый, можем написать ещё один, который проверит установку свойства name в свойство `htmlFor` элемента `label`.
```
// components/Checkbox/Checkbox.test.tsx
it('sets name prop as label htmlFor', () => {
const checkboxName = 'anyCheckbox'
const renderer = create()
const element = renderer.root.findByType('label')
expect(element.props.htmlFor).toBe(checkboxName)
})
```
Тест красный, нужно снова поправить код.
```
// components/Checkbox/Checkbox.tsx
const Checkbox: React.FC<{ name: string; label: string }> = ({ name, label }) => {
return (
{label}
)
}
```
Пора бы подключить Store к компоненту. Напишем тест, который покажет, что состояние чекбокса (свойство `checked`) соответствует тому, что хранится в Store.
```
// components/Checkbox/Checkbox.test.tsx
import { Provider } from 'react-redux'
import { create } from 'react-test-renderer'
import { createAppStore } from 'store'
import Checkbox from '.'
// omit old code
it('sets checked flag from store when it`s checked', () => {
const store = createAppStore({ checkboxes: { anyName: true } })
const renderer = create(
,
)
const element = renderer.root.findByType('input')
expect(element.props.checked).toBe(true)
})
```
Тест пока красный, т.к. компонент ничего не знает о сторе. Заставим тест «позеленеть».
```
// components/Checkbox/Checkbox.tsx
import React from 'react'
import { useSelector } from 'react-redux'
import { getCheckboxState } from 'selectors'
const Checkbox: React.FC<{ name: string; label: string }> = ({ name, label }) => {
const checked = useSelector(getCheckboxState(name))
return (
{label}
)
}
export default Checkbox
```
Тест пройден. Наконец-то, мы задействовали Redux! Мы использовали ранее написанный селектор `getCheckboxState`, который вызвали с помощью хука `useSelector`, получили значение и передали его в свойство `checked` элемента `input`. Но сейчас произошла другая проблема — сломались остальные тесты на компонент.
Дело в том, что ранее в тестах мы не передавали стор в компонент. Выделим часть с провайдером стора в функцию и перепишем наши тесты.
```
// components/Checkbox/Checkbox.test.tsx
import { ReactElement } from 'react'
import { Provider } from 'react-redux'
import { create } from 'react-test-renderer'
import { createAppStore } from 'store'
import { State } from 'types'
import Checkbox from '.'
export const renderWithRedux = (node: ReactElement, initialState: State = { checkboxes: {} }) => {
const store = createAppStore(initialState)
return create({node})
}
describe('Checkbox', () => {
it('renders checkbox input', () => {
const checkboxName = 'anyName'
const renderer = renderWithRedux()
const element = renderer.root.findByType('input')
expect(element.props.type).toBe('checkbox')
})
it('renders label', () => {
const labelText = 'anyLabel'
const renderer = renderWithRedux()
const element = renderer.root.findByType('label')
expect(element.props.children).toBe(labelText)
})
it('sets name prop as input id', () => {
const checkboxName = 'anyCheckbox'
const renderer = renderWithRedux()
const element = renderer.root.findByType('input')
expect(element.props.id).toBe(checkboxName)
})
it('sets name prop as label htmlFor', () => {
const checkboxName = 'anyCheckbox'
const renderer = renderWithRedux()
const element = renderer.root.findByType('label')
expect(element.props.htmlFor).toBe(checkboxName)
})
it('sets checked flag from store when it`s checked', () => {
const initialState = { checkboxes: { anyName: true } }
const renderer = renderWithRedux(, initialState)
const element = renderer.root.findByType('input')
expect(element.props.checked).toBe(true)
})
})
```
Функция **renderWithRedux** выглядит достаточно полезной, вынесем её в отдельный модуль и импортируем в тестах.
```
// utils.tsx
import { ReactElement } from 'react'
import { Provider } from 'react-redux'
import { create } from 'react-test-renderer'
import { Store } from './types'
import { createAppStore } from './store'
export const renderWithRedux = (node: ReactElement, initialState: Store = { checkboxes: {} }) => {
const store = createAppStore(initialState)
return create({node})
}
```
В итоге, шапка тестового файла будет выглядеть вот так:
```
// components/Checkbox/Checkbox.test.tsx
import { renderWithRedux } from 'utils'
import Checkbox from '.'
describe('Checkbox', () => {
```
Для полной уверенности напишем ещё один тест, который проверит, что `checked` бывает и `false`.
```
// components/Checkbox/Checkbox.test.tsx
it('sets checked flag from store when it`s unchecked', () => {
const initialState = { checkboxes: { anyName: false } }
const renderer = renderWithRedux(, initialState)
const element = renderer.root.findByType('input')
expect(element.props.checked).toBe(false)
})
```
Тест пройден, но у нас теперь появилось два теста с похожими описаниями и почти идентичным кодом, давайте немного модифицируем наши тесты, создав табличный тест. Последние два теста превратятся в один:
```
// components/Checkbox/Checkbox.test.tsx
test.each`
storedState | state
${true} | ${'checked'}
${false} | ${'unchecked'}
`('sets checked flag from store when it`s $state', ({ storedState }) => {
const initialState = { checkboxes: { anyName: storedState } }
const renderer = renderWithRedux(, initialState)
const element = renderer.root.findByType('input')
expect(element.props.checked).toBe(storedState)
})
```
Так уже лучше. А теперь самое вкусное — напишем интеграционный тест, который проверит, что при нажатии на чекбокс, он изменит своё состояние, т.е. свойство **checked**.
```
// components/Checkbox/Checkbox.test.tsx
import { act } from 'react-test-renderer'
// omit old code
it('changes it`s checked state when it`s clicked', () => {
const initialState = { checkboxes: { anyName: false } }
const renderer = renderWithRedux(, initialState)
const element = renderer.root.findByType('input')
act(() => {
element.props.onChange()
})
expect(element.props.checked).toBe(true)
})
```
Здесь мы воспользовались функцией `act`, пакета `react-test-renderer`, выполняя которую, мы убеждаемся в том, что все сайд-эффекты уже произошли и мы можем продолжить проверки. И далее проверяем, что когда будет вызвано событие `onChange` на нашем чекбоксе, он изменит свойство `checked` на `true`. Пока этого не происходит, требуется написать код. Окончательный вариант компонента примет вот такой вид.
```
// components/Checkbox/Checkbox.tsx
import React from 'react'
import { useDispatch, useSelector } from 'react-redux'
import { getCheckboxState } from 'selectors'
import { checkboxClick } from 'actions'
const Checkbox: React.FC<{ name: string; label: string }> = ({ name, label }) => {
const dispatch = useDispatch()
const checked = useSelector(getCheckboxState(name))
const handleClick = React.useCallback(() => {
dispatch(checkboxClick(name))
}, [dispatch, name])
return (
{label}
)
}
export default Checkbox
```
В коде мы навесили обработчик на событие `change`, который отправляет action в store, создаваемый функцией `checkboxClick`. Как видим, тест позеленел. Не открывая браузера и даже не запуская сборку приложения, мы имеем протестированный компонент с отдельным слоем бизнес-логики, заключенной в Redux.
### AgreementSubmitButton
Нам требуется ещё один компонент — непосредственно кнопка Submit, создадим его. Конечно, вначале тест:
```
// components/AgreementSubmitButton/AgreementSubmitButton.test.tsx
import { renderWithRedux } from 'utils'
import AgreementSubmitButton from '.'
describe('AgreementSubmitButton', () => {
it('renders button with label Submit', () => {
const renderer = renderWithRedux()
const element = renderer.root.findByType('input')
expect(element.props.type).toBe('button')
expect(element.props.value).toBe('Submit')
})
})
```
Теперь заставим тест «позеленеть»:
```
// components/AgreementSubmitButton/package.json
{
"main": "./AgreementSubmitButton"
}
// components/AgreementSubmitButton/AgreementSubmitButton.tsx
import React from 'react'
const AgreementSubmitButton: React.FC = () => {
return
}
export default AgreementSubmitButton
```
Тест зелёный, начало положено. Напишем новый тест, проверяющий зависимость свойства **disabled** новой кнопки от состояния чекбокса. Т.к. может быть два состояния, вновь используем табличный тест:
```
// components/AgreementSubmitButton/AgreementSubmitButton.test.tsx
test.each`
checkboxState | disabled | agreementState
${false} | ${true} | ${'not agreed'}
${true} | ${false} | ${'agreed'}
`(
'render button with disabled=$disabled when agreement is $agreementState',
({ checkboxState, disabled }) => {
const initialState = { checkboxes: { agree: checkboxState } }
const renderer = renderWithRedux(, initialState)
const element = renderer.root.findByType('input')
expect(element.props.disabled).toBe(disabled)
},
)
```
Имеем двойной красный тест, напишем код для прохождения этого теста. Компонент станет выглядеть вот так:
```
// components/AgreementSubmitButton/AgreementSubmitButton.tsx
import React from 'react'
import { useSelector } from 'react-redux'
import { getCheckboxState } from 'selectors/selectors'
const AgreementSubmitButton: React.FC = () => {
const checkboxName = 'agree'
const agreed = useSelector(getCheckboxState(checkboxName))
return
}
export default AgreementSubmitButton
```
Ура, все тесты зелёные!
Следует обратить внимание, что в табличном тесте мы намеренно использовали два различных параметра `checkboxState` и `disabled`, хотя может показаться, что достаточно только первого, а в тесте написать вот так `**expect(element.props.disabled).toBe(!disabled)**`. Но это плохой паттерн — закладывать какую-то логику внутри тестов. Вместо этого мы явно описываем входные и выходные параметры. Так же, мы здесь немного ускорились, т.к., фактически написали два теста за раз. Такое допустимо, когда чувствуешь в себе силы и понимаешь, что реализация достаточно очевидная. Когда уровень владения TDD ещё не совершенный, лучше создавать по одному тесту за раз. В нашем случае — это писать по одной строчке в таблице.
### LicenseAgreement
Оформим нашу работу в то, ради чего мы всё это затевали — в форму принятия лицензионного соглашения. Какие имеются требования к форме:
1. Содержится заголовок и непосредственно текст лицензионного соглашения. Эта часть компонента не требует тестирования.
2. На форме имеется компонент `Checkbox` с определенными `label` и `name`. Это можно и нужно тестировать.
3. На форме имеется кнопка `AgreementSubmitButton`. Это тоже прекрасно поддаётся тестированию.
Приступим, первый тест на то, что на форме есть `Checkbox`:
```
// components/LicenseAgreement/LicenseAgreement.test.tsx
import { renderWithRedux } from 'utils'
import Checkbox from 'components/Checkbox'
import LicenseAgreement from '.'
jest.mock('components/Checkbox', () => () => null)
describe('LicenseAgreement', () => {
it('renders Checkbox with name and label', () => {
const renderer = renderWithRedux()
const element = renderer.root.findByType(Checkbox)
expect(element.props.name).toBe('agree')
expect(element.props.label).toBe('Agree')
})
})
```
На что тут стоит обратить внимание — мы использовали тестовый дублёр для компонента `Checkbox` в строчке `jest.mock('components/Checkbox', () => () => null)`. Это делает наш тест изолированным, таким образом он не зависит от реализации `Checkbox`, возможные ошибки в этом компоненте не повлияют на результат выполнения данного теста. Дополнительно это экономит вычислительные ресурсы и время выполнения тестов. Тест красный, требуется написать правильный код:
```
// components/LicenseAgreement/package.json
{
"main": "./LicenseAgreement"
}
// src/components/LicenseAgreement/LicenseAgreement.tsx
import React from 'react'
import Checkbox from 'components/Checkbox'
const LicenseAgreement: React.FC = () => {
return (
)
}
export default LicenseAgreement
```
Получили зеленый тест, можем написать второй для этого компонента. Файл с тестами изменится:
```
// components/LicenseAgreement/LicenseAgreement.test.tsx
import { renderWithRedux } from 'utils'
import Checkbox from 'components/Checkbox'
import AgreementSubmitButton from 'components/AgreementSubmitButton'
import LicenseAgreement from '.'
jest.mock('components/Checkbox', () => () => null)
jest.mock('components/AgreementSubmitButton', () => () => null)
describe('LicenseAgreement', () => {
it('renders Checkbox with name and label', () => {
const renderer = renderWithRedux()
const element = renderer.root.findByType(Checkbox)
expect(element.props.name).toBe('agree')
expect(element.props.label).toBe('Agree')
})
it('renders SubmitAgreementButton', () => {
const renderer = renderWithRedux()
expect(() => renderer.root.findByType(AgreementSubmitButton)).not.toThrow()
})
})
```
Чтобы он позеленел, добавим `AgreementSubmitButton` в компонент:
```
// src/components/LicenseAgreement/LicenseAgreement.tsx
import React from 'react'
import Checkbox from 'components/Checkbox'
import AgreementSubmitButton from 'components/AgreementSubmitButton'
const LicenseAgreement: React.FC = () => {
return (
)
}
export default LicenseAgreement
```
Заметим, что `Checkbox` и `AgreementSubmitButton` не зависят друг от друга. Каждый компонент зависит только от стора и больше ни от чего.
### Ключ на старт!
Вставим над компонентами сам текст соглашения, далее можем добавлять компонент в приложение. В сгенерированном приложении имеется корневой компонент `App`, модифицируем его тесты на проверку рендера `LicenseAgreement`:
```
// App.test.tsx
import { renderWithRedux } from 'utils'
import LicenseAgreement from 'components/LicenseAgreement'
import App from 'App'
jest.mock('components/LicenseAgreement', () => () => null)
test('renders LicenseAgreement', () => {
const renderer = renderWithRedux()
expect(() => renderer.root.findByType(LicenseAgreement)).not.toThrow()
})
```
Заставим тест позеленеть:
```
// App.tsx
import React from 'react'
import LicenseAgreement from 'components/LicenseAgreement'
const App: React.FC = () => {
return
}
export default App
```
Мы получили зелёный тест, можно, наконец, запустить сборку приложения с помощью `npm start`. Сборка пройдёт успешно, но в браузере мы увидим следующую картину:
Это говорит о том, что мы не подключили Redux store в само приложение. Сделаем это в файле `index.tsx`:
```
// index.tsx
import React from 'react'
import ReactDOM from 'react-dom'
import { Provider } from 'react-redux'
import 'index.css'
import store from 'store'
import App from 'App'
ReactDOM.render(
,
document.getElementById('root'),
)
```
Теперь приложение запускается, всё работает, как ожидается, кроме внешнего вида:
Исправим это, поправив вёрстку, и получим конечный результат:
### Заключение
Я намеренно выбрал максимально простой пример, чтобы не перегружать статью текстом и кодом. Конечно, здесь можно было обойтись и без Redux, а хранить состояние чекбокса в локальном стейте компонента, и на мелких компонентах это может быть оправдано. Но по мере роста приложения, преимущества Redux будут становиться всё более очевидными, особенно когда появляется более сложная бизнес-логика, которую потребуется тестировать. Redux позволяет избавиться от прокидывания свойств через множество компонентов, каждый компонент либо достает необходимую информацию из стора самостоятельно, либо сам же диспатчит экшены.
Во второй части данной статьи предполагался рассказ о библиотеке Redux Tookilt, которая значительно упрощает использование Redux в разработке фронтенд-приложений, но я решил в следующей статье показать, как можно написать настоящее полезное приложение, хоть и очень простое, на React, Redux и Redux Toolkit.
Исходные коды полученного приложения доступны на [GitHub](https://github.com/ivahaev/redux-article-app).
Дополнительные источники информации:
* [Официальный сайт Redux](https://redux.js.org)
* [Best practice по разработке приложений с использованием Redux](https://redux.js.org/style-guide/style-guide)
* [Фреймворк для тестирования JS приложений Jest](https://jestjs.io/)
* [Хабрастатья Андрея Хижняка REACT + JEST = TDD ️️](https://habr.com/ru/company/manychat/blog/528794/) | https://habr.com/ru/post/541794/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.