text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Джавапокалипсис в отдельно взятой системе
*Эта статья ориентирована на ABAP-разработчиков в системах SAP ERP. Она содержит много специфических для платформы моментов, которые малоинтересны или даже спорны для разработчиков, использующих другие платформы.*
Есть такой эвфемизм: “исторически сложилось”.
Так вот, в моей основной системе исторически так сложилось, что:* много пользователей работают через SAP GUI for HTML;
* практически вся отчетность выгружается в Excel через ZWWW.
А это значит что без правильно настроенной связки Браузер+Java жить непросто.
Java нужна для работы с файлами (выгрузить, загрузить). Принципиально веб-приложение должно работать только внутри своего окна и его нельзя подпускать к файловой системе пользователя даже на пушечный выстрел. С файлами должен работать лично браузер удобным ему способом, но это противоречит подходу SAP GUI, который хочет контролировать всё: показ диалога открытия, заголовок окна диалога, список доступных расширений файлов, разрешение множественного выбора, выбор каталога, чтение каталога, считывание содержимого файла или запись. Так как SAP GUI for HTML должен повторять функциональность большого брата, поэтому они там решили не менять подход, а ввести дополнительную прослойку в виде Java-апплета, который бы выполнял эти действия на стороне клиента. ABAP-часть при таком подходе остаётся практически без изменений.
Кроме этого, ZWWW работает через технологию OLE, без вариантов. А веб-приложение нельзя подпускать к OLE-интерфейсам клиентской машины даже в радиусе поражения ракет класса “земля-воздух”. Следовательно, нужна ещё одна прослойка в виде Java-апплета, которая будет проксировать OLE-вызовы и выполнять сопутствующие махинации.
Так как SAP GUI for HTML и сам является прослойкой между ABAP-инстанцией и ITS-сервером, то всё это сооружение начинает походить на игру Дженга.
Такая игра идёт постоянно. То браузеры начинают отключать старую джаву, то джава-апплеты теряют полномочия, то что-то происходит с проверкой подписи апплета, то появляются какие-то черные/белые списки исключений, то вдруг апплет начинает жутко тормозить на какой-то версии JRE, то выходит новая версия офиса, то обновляют ITS/ABAP, то пользователи в другом конце страны не могут настроить политику безопасности, то вдруг кому-то кажется что проще выставить в браузере низкий уровень безопасности …
Если следить за хронологией, то можно заметить:* Firefox – [прекратит поддерживать Java-апплеты уже через год](https://blog.mozilla.org/futurereleases/2015/10/08/npapi-plugins-in-firefox/)
* Chrome – даже если когда-то и поддерживал, то уже всё закончилось
* Edge – не поддерживал Java-апплеты, и не будет поддерживать
* Oracle – [отказывается от поддержки Java-плагинов начиная с Java 9](https://blogs.oracle.com/java-platform-group/entry/moving_to_a_plugin_free)
Скоро останется только старый и не очень добрый IE. Евошний разработчик хоть и обещал поддерживать IE11 в Windows 10, но мы-то с вами знаем …
Что будет, если у бухгалтера внезапно отобрать возможность выгрузить любой отчет в Excel? Апокалипсис!
И вот Джавапокалипсис прилижается.
Рассмотрим варианты.
\* \* \*
Поменять браузер (SAP GUI for HTML) на полноценный SAP GUI. Отпадает по административным показаниям.
Поменять браузер (SAP GUI for HTML) на NWBC. Но NWBC — это только оболочка вокруг того же IE, поэтому глубинных проблем данный подход не решает. Отпадает.
\* \* \*
Заставить ZWWW работать на сервере и скидывать результат клиенту. Невозможно.
\* \* \*
Если ~~гора не идет к~~ платформа не походит к движку, то можно поменять ZWWW на другой движок:1. Формуляры PDF
2. Отчеты BI (BObj/BW/другое)
3. Альтернативный движок Abap2xlsx
Все три сценария трудоёмки, но есть показания:
1. PDF генерируется на стороне сервера. Пользователь не может подправить содержимое. Некоторые формы нужны только для печати (“не отходя от кассы”) и не нужны в качестве рабочих документов в файловом виде. Самые простые примеры: приходный кассовый ордер, расходный кассовый ордер, счет к оплате и другие мелкие формы на одну страницу.
2. Некоторые отчеты нужны не только пользователям внутри системы, но и внешним пользователям, причём у этих внешних пользователей есть доступ к BI системе. Отчеты не требуют актуальности в режиме реального времени. Если в отчете есть нетривиальные расчеты, то можно выгружать итоговые расчеты в BI-систему и не заставлять BI-систему повторять эту сложную логику. Снижение нагрузки на ERP-систему. Возможна экономия на количестве лицензий. Рабочие отчеты могут остаться в системе, но без выгрузки в красивый Excel.
3. Всё оставшееся можно переписать с ZWWW на Abap2xlsx. Эта библиотека позволяет сделать генерацию файла Excel непосредственно на сервере. Подходы у этих двух библиотек кардинально разные, тут просто нельзя одни вызовы заменить на другие вызовы. Скорость существенно возрастёт, особенно для сложных документов. Необходимость поддержки старых форматов XLS уже не актуальна.
Это всё предыстория, а ради чего я начал писать-то… Допустим, переписали генерацию файла на Abap2xlsx, но его ещё и как-то скинуть на клиента надо красиво!
Скидывание файла на клиента по браузерному подходу можно выполнить с использованием функционального метода ALEWEB\_DOWNLOAD. Дело-то он делает, но вот не очень красиво. Например, в нём нельзя управлять именем файла, а временные имена из случайных букв нравятся только системе, а людей от такого просто тошнит. Если покрутиться в том районе, то можно и подстучать, допилить, скопировать в Z-область. Скукота!
А можно сделать финт через сервис и HTTP-обработчик. Это очень интересно!
Первым делом создадим таблицу, например:
В эту таблицу мы будем складывать бинарные файлы, которые необходимо отдать клиенту. Сам файл хранится в поле XDATA.
HTTP-обработчики в системе реализуются в виде классов. За образец возьмём класс CL\_HTTP\_EXT\_PING.
Создадим класс ZCL\_WWW\_FILE\_DOWNLOAD и реализуем в нём метод HANDLE\_REQUEST:
```
data lt_query_string type tihttpnvp,
ls_query_string type ihttpnvp.
data ls_zwww_content type zwww_content.
data lv_mimetype type string.
data lv_filename type string.
server->request->get_form_fields( changing fields = lt_query_string ).
read table lt_query_string into ls_query_string
with key name = 'file_uid'.
ls_zwww_content-file_uid = ls_query_string-value.
select single * from zwww_content into ls_zwww_content
where file_uid = ls_zwww_content-file_uid.
lv_mimetype = ls_zwww_content-mimetype.
concatenate 'attachment; filename="'
ls_zwww_content-filename
'"' into lv_filename.
server->response->set_header_field( name = 'Content-Type'
value = lv_mimetype ).
server->response->set_header_field( name = 'Content-Disposition'
value = lv_filename ).
server->response->set_data( ls_zwww_content-xdata ).
```
Всё тривиально:1. Считываем параметр file\_uid из HTTP-запроса
2. Достаём содержимое из таблицы
3. Выставляем заголовки HTTP-ответа
4. Скидываем содержимое файла в тело HTTP-ответа
Затем мы зарегистрируем в транзакции SICF новый сервис, и присвоим ему только что созданный обработчик:
После этого сервис станет доступен по ссылке вида:
<http://host:8000/sap/bc/ZFILE_DL?file_uid=5A2D5067C04D1ED5AFB71835DF981A07>
Отлично! Осталось дело за малым: сделать выгрузку.
Сначала любым способом получаем бинарный файл XLSX. Например: посредством конвертации из ALV:
```
data lo_converter type ref to zcl_excel_converter.
create object lo_converter.
lo_converter->convert(
exporting
io_alv = gr_table
it_table = gt_report[]
i_row_int = 2
i_column_int = 2 ).
```
Затем добавляем файл в таблицу:
```
data ls_zwww_content type zwww_content.
clear ls_zwww_content.
call function 'GUID_CREATE'
importing ev_guid_32 = ls_zwww_content-file_uid.
ls_zwww_content-filename = sy-repid && '.xlsx'.
ls_zwww_content-mimetype = 'application/msexcel'.
ls_zwww_content-uname = sy-uname.
get time stamp field ls_zwww_content-timestamp.
lo_converter->get_file( importing e_file = ls_zwww_content-xdata ).
insert into zwww_content values ls_zwww_content.
commit work and wait.
```
Затем пинаем загрузчик:
```
data lv_url type string.
concatenate 'http://host:8000/sap/bc/ZFILE_DL?file_uid='
ls_zwww_content-file_uid
'&sap-client=100&sap-language=RU' into lv_url.
call function 'ITS_BROWSER_WINDOW_OPEN'
exporting
url = lv_url
window_name = '_top'
exceptions
its_not_available = 1
others = 2.
```
Пробуем, драфт работает!
Но как можно подход ZWWW применить к Abap2xlsx?
А дальше происходит диалог:* А давай переделаем все отчеты…
* Все?
* Их сто! А у нас есть на это время?
* Там есть группировки, динамические столбцы и макросы!
* Макросы на бейсике, Карл!
**То же самое, но в картинках**
На этой оптимистичной ноте я откланиваюсь. Спасибо за внимание и до новых встреч! | https://habr.com/ru/post/275477/ | null | ru | null |
# Настройка аутентификации в сети L2TP с помощью Рутокен ЭЦП 2.0 и Рутокен PKI
Проблематика
============
Ещё совсем недавно многие не знали, как это — работать из дома. Пандемия резко изменила ситуацию в мире, все начали адаптироваться к сложившимся обстоятельствам, а именно к тому, что выходить из дома стало просто небезопасно. И многим пришлось быстро организовывать работу из дома для своих сотрудников.
Однако отсутствие грамотного подхода в выборе решений для удалённой работы может привести к необратимым потерям. Пароли пользователей могут быть украдены, а это даст возможность злоумышленнику бесконтрольно подключаться к сети и ИТ-ресурсам предприятия.
Именно поэтому сейчас выросла потребность в создании надёжных корпоративных VPN сетей. Я расскажу вам о **надёжной**, **безопасной** и **простой** в использовании VPN сети.
Она работает по схеме IPsec/L2TP, использующей для аутентификации клиентов неизвлекаемые ключи и сертификаты, хранящиеся на токенах, а также передает данные по сети в зашифрованном виде.
В качестве демонстрационных стендов для настройки использовались сервер с CentOS 7 (адрес: centos.vpn.server.ad) и клиент с Ubuntu 20.04, а также клиент с Windows 10.
Описание системы
================
VPN будет работать по схеме IPSec + L2TP + PPP. Протокол **Point-to-Point Protocol** (**PPP**) работает на канальном уровне модели OSI и обеспечивает аутентификацию пользователя и шифрование передаваемых данных. Его данные инкапсулируются в данные протокола L2TP, который собственно обеспечивает создание соединения в VPN сети, но не обеспечивает аутентификацию и шифрование.
Данные L2TP инкапсулируются в протокол IPSec, который тоже обеспечивает аутентификацию и шифрование, но в отличие от протокола PPP аутентификация и шифрование происходит на уровне устройств, а не на уровне пользователей.
Данная особенность позволяет обеспечить аутентификацию пользователей только с определённых устройств. Мы же будем использовать протокол IPSec как данное и позволим производить аутентификацию пользователей с любого устройства.
Аутентификация пользователя с помощью смарт-карт будет производиться на уровне протокола PPP с помощью протокола EAP-TLS.
Более подробную информации о работе данной схемы можно найти в [этой статье](https://www.itprotoday.com/security/pptp-vs-l2tp).
Почему данная схема отвечает всем трём требованиям хорошей VPN сети
===================================================================
1. Надёжность данной схемы проверена временем. Она используется для развёртывания VPN сетей с 2000 года.
2. Безопасную аутентификацию пользователя обеспечивает протокол PPP. [Стандартная реализация протокола PPP разработанная Paul Mackerras](https://github.com/paulusmack/ppp) не обеспечивает достаточного уровня безопасности, т.к. для аутентификации в лучшем случае случае используется аутентификация с помощью логина и пароля. Все мы знаем, что логин-пароль можно подсмотреть, подобрать или украсть. Тем не менее уже давно разработчик [Jan Just Keijser](mailto:janjust@nikhef.nl) в [своей реализации](https://github.com/paulusmack/ppp/pull/151) данного протокола исправил этот момент и добавил возможность использования для аутентификации протоколы, основанные на асимметричном шифровании, такой как EAP-TLS. Кроме того, он добавил возможность использования смарт-карт для аутентификации, что сделало данную систему более безопасной.
В настоящий момент ведутся активные переговоры для слияния этих двух проектов и можно быть уверенными в том, что рано или поздно это всё равно произойдёт. Так, например, в репозиториях Fedora уже давно лежит пропатченная версия PPP, использующая для аутентификации безопасные протоколы.
3. Ещё совсем недавно данную сеть могли использовать только пользователи Windows, но наши коллеги из МГУ Василий Шоков и Александр Смирнов нашли [старый проект L2TP клиента для Linux](https://sourceforge.net/projects/l2tp-ipsec-vpn/files/l2tp-ipsec-vpn/) и доработали его. Совместными усилиями мы исправили множество багов и недочетов в работе клиента, упростили установку и настройку системы, даже при сборке из исходников. Наиболее существенными из них являются:
* Исправлены проблемы совместимости старого клиента с интерфейсом новых версий openssl и qt.
* Удалена передача pppd PIN-кода токена через временный файл.
* Исправлен некорректный запуск программы запроса пароля через графический интерфейс. Это было сделано за счет установки корректного окружения для xl2tpd сервиса.
* Сборка демона L2tpIpsecVpn теперь осуществляется совместно со сборкой самого клиента, что облегчает процесс сборки и настройки.
* Для удобства разработки подключена система Azure Pipelines для тестирования корректности сборки.
* Добавлена возможность принудительно понижать [security level](https://www.openssl.org/docs/man1.1.0/man3/SSL_CTX_get_security_level.html#:~:text=The%20default%20security%20level%20can,with%20the%20set%20security%20level.) в контексте openssl. Это полезно для корректной поддержки новых операционных систем, где стандартный security level установлен на 2, с VPN сетями, в которых используются сертификаты, не удовлетворяющие требованиям безопасности данного уровня. Данная опция будет полезна для работы с уже существующими старыми VPN сетями.
Исправленную версию можно найти в [данном репозитории](https://github.com/Sander80/l2tp-ipsec-vpn).
Данный клиент поддерживает использование смарт-карт для аутентификации, а также максимально скрывает все тяготы и невзгоды настройки данной схемы под Linux, делая настройку клиента максимально простой и быстрой.
Конечно, для удобной связи PPP и GUI клиента не обошлось и без дополнительных правок каждого из проектов, но тем не менее их удалось минимизировать и свести к минимуму:
* Исправлена [ошибка некорректного пробрасывания PIN-кода токена из PPP в контекст openssl](https://github.com/jjkeijser/ppp/pull/1)
* Исправлена [ошибка в порядке загрузки конфигурации и инициализации openssl контекста](https://github.com/jjkeijser/ppp/pull/2). Данная ошибка не позволяла подгружать из локального /etc/ppp/openssl.cnf файла с конфигурацией ничего, кроме сведений о движках openssl для работы со смарт-картами, что составляло серьёзное неудобство, если, например, кроме информации об энджинах мы хотели задать что-то ещё. Например, зафиксировать security level при установке соединения.
Теперь можно приступить к настройке.
Настройка сервера
=================
Установим все необходимые пакеты.
Установка strongswan (IPsec)
----------------------------
В первую очередь, настроим firewall для работы ipsec
```
sudo firewall-cmd --permanent --add-port=1701/{tcp,udp}
sudo firewall-cmd --permanent --add-service=ipsec
sudo firewall-cmd --reload
```
Затем приступим к установке
```
sudo yum install epel-release ipsec-tools dnf
sudo dnf install strongswan
```
После установки необходимо задать конфигурацию для strongswan (одну из реализаций IPSec). Для этого отредактируем файл **/etc/strongswan/ipsec.conf** :
```
config setup
nat_traversal=yes
virtual_private=%v4:10.0.0.0/8,%v4:192.168.0.0/16,%v4:172.16.0.0/12
oe=off
protostack=netkey
conn L2TP-PSK-NAT
rightsubnet=vhost:%priv
also=L2TP-PSK-noNAT
conn L2TP-PSK-noNAT
authby=secret
pfs=no
auto=add
keyingtries=3
rekey=no
ikelifetime=8h
keylife=1h
type=transport
left=%any
leftprotoport=udp/1701
right=%any
rightprotoport=udp/%any
ike=aes128-sha1-modp1536,aes128-sha1-modp1024,aes128-md5-modp1536,aes128-md5-modp1024,3des-sha1-modp1536,3des-sha1-modp1024,3des-md5-modp1536,3des-md5-modp1024
esp=aes128-sha1-modp1536,aes128-sha1-modp1024,aes128-md5-modp1536,aes128-md5-modp1024,3des-sha1-modp1536,3des-sha1-modp1024,3des-md5-modp1536,3des-md5-modp1024
```
Также зададим общий пароль для входа. Общий пароль должен быть известен всем участникам сети для аутентификации. Данный способ и является заведомо ненадёжным, т.к. данный пароль с лёгкостью может стать известным личностям, которым мы не хотим предоставлять доступ к сети.
Тем не менее, даже этот факт не повлияет на безопасность организации сети, т.к. основное шифрование данных и аутентификация пользователей осуществляется протоколом PPP. Но справедливости ради стоит заметить, что strongswan поддерживает более безопасные технологии для аутентификации, например, с помощью приватных ключей. Так же в strongswan имеется возможность обеспечить аутентификацию с помощью смарт-карт, но пока поддерживается ограниченный круг устройств и поэтому аутентификация с помощью токенов и смарт-карт Рутокен пока затруднительна. Зададим общий пароль через файл **/etc/strongswan/ipsec.secrets**:
```
# ipsec.secrets - strongSwan IPsec secrets file
%any %any : PSK "SECRET_PASSPHRASE"
```
Перезапустим strongswan:
```
sudo systemctl enable strongswan
sudo systemctl restart strongswan
```
Установка xl2tp
---------------
```
sudo dnf install xl2tpd
```
Сконфигурируем его через файл **/etc/xl2tpd/xl2tpd.conf**:
```
[global]
force userspace = yes
listen-addr = 0.0.0.0
ipsec saref = yes
[lns default]
exclusive = no
; определяет статический адрес сервера в виртуальной сети
local ip = 100.10.10.1
; задает диапазон виртуальных адресов
ip range = 100.10.10.1-100.10.10.254
assign ip = yes
refuse pap = yes
require authentication = yes
; данную опцию можно отключить после успешной настройки сети
ppp debug = yes
length bit = yes
pppoptfile = /etc/ppp/options.xl2tpd
; указывает адрес сервера в сети
name = centos.vpn.server.ad
```
Перезапустим сервис:
```
sudo systemctl enable xl2tpd
sudo systemctl restart xl2tpd
```
Настройка PPP
-------------
**UPD**: предложенные нами изменения были приняты начиная с версии pppd 2.4.9. Поэтому пакет pppd можно взять из репозиториев.
Желательно поставить последнюю версию pppd. Для этого выполним следующую последовательность команд:
```
sudo yum install git make gcc openssl-devel
git clone "https://github.com/jjkeijser/ppp"
cd ppp
./configure --prefix /usr
make -j4
sudo make install
```
Впишите в файл **/etc/ppp/options.xl2tpd** следующее (если там присутствуют какие-то значения, то их можно удалить):
```
ipcp-accept-local
ipcp-accept-remote
ms-dns 8.8.8.8
ms-dns 1.1.1.1
noccp
auth
crtscts
idle 1800
mtu 1410
mru 1410
nodefaultroute
debug
lock
proxyarp
connect-delay 5000
```
Выписываем корневой сертификат и сертификат сервера:
```
#директория с сертификатами пользователей, УЦ и сервера
sudo mkdir /etc/ppp/certs
#директория с закрытыми ключами сервера и УЦ
sudo mkdir /etc/ppp/keys
#запрещаем любой доступ к этой дирректории кроме администатора
sudo chmod 0600 /etc/ppp/keys/
#генерируем ключ и выписываем сертификат УЦ
sudo openssl genrsa -out /etc/ppp/keys/ca.pem 2048
sudo openssl req -key /etc/ppp/keys/ca.pem -new -x509 -out /etc/ppp/certs/ca.pem -subj "/C=RU/CN=L2TP CA"
#генерируем ключ и выписываем сертификат сервера
sudo openssl genrsa -out /etc/ppp/keys/server.pem 2048
sudo openssl req -new -out server.req -key /etc/ppp/keys/server.pem -subj "/C=RU/CN=centos.vpn.server.ad"
sudo openssl x509 -req -in server.req -CAkey /etc/ppp/keys/ca.pem -CA /etc/ppp/certs/ca.pem -out /etc/ppp/certs/server.pem -CAcreateserial
```
Таким образом, мы закончили с основной настройкой сервера. Остальная часть конфигурации сервера связана с добавлением новых клиентов.
Добавление нового клиента
-------------------------
Чтобы добавить нового клиента в сеть, необходимо записать его сертификат в список доверенных для данного клиента.
Если пользователь хочет стать участником VPN сети, он создаёт ключевую пару и заявку на сертификат для данного клиента. Если пользователь доверенный, то данную заявку можно подписать, а получившийся сертификат записать в директорию сертификатов:
```
sudo openssl x509 -req -in client.req -CAkey /etc/ppp/keys/ca.pem -CA /etc/ppp/certs/ca.pem -out /etc/ppp/certs/client.pem -CAcreateserial
```
Добавим строчку в файл /etc/ppp/eaptls-server для сопоставления имени клиента и его сертификата:
```
"client" * /etc/ppp/certs/client.pem /etc/ppp/certs/server.pem /etc/ppp/certs/ca.pem /etc/ppp/keys/server.pem *
```
**NOTE**
Чтобы не запутаться, лучше чтобы: Common Name, имя файла с сертификатом и имя пользователя были уникальными.
Также стоит проверить, что в других файлах аутентификации нигде не фигурирует имя пользователя, которого мы добавляем, иначе возникнут проблемы со способом аутентификации пользователя.
---
Этот же сертификат необходимо отправить пользователю обратно.
Генерация ключевой пары и сертификата
-------------------------------------
Для успешной аутентификации клиенту необходимо:
1. сгенерировать ключевую пару;
2. иметь корневой сертификат УЦ;
3. иметь сертификат для своей ключевой пары, подписанный корневым УЦ.
### для клиента на Linux
Для начала сгенерируем ключевую пару на токене и создадим заявку на сертификат:
```
#идентификатор ключа (параметр --id) можно заменить на любой другой.
pkcs11-tool --module /usr/lib/librtpkcs11ecp.so --keypairgen --key-type rsa:2048 -l --id 45
openssl
OpenSSL> engine dynamic -pre SO_PATH:/usr/lib/x86_64-linux-gnu/engines-1.1/pkcs11.so -pre ID:pkcs11 -pre LIST_ADD:1 -pre LOAD -pre MODULE_PATH:librtpkcs11ecp.so
...
OpenSSL> req -engine pkcs11 -new -key 45 -keyform engine -out client.req -subj "/C=RU/CN=client"
```
Появившуюся заявку client.req отправьте в УЦ. После того как вы получите сертификат для своей ключевой пары, запишите его на токен с тем же id, что и у ключа:
```
pkcs11-tool --module /usr/lib/librtpkcs11ecp.so -l -y cert -w ./client.pem --id 45
```
### для клиентов Windows и Linux (более универсальный способ)
Данный способ является более универсальным, т.к. позволяет сгенерировать ключ и сертификат, который будет успешно распознаваться у пользователей Windows и Linux, но он требует наличие машины на Windows для проведения процедуры генерации ключей.
Перед генерацией запросов и импортом сертификатов необходимо добавить корневой сертификат VPN сети в список доверенных. Для этого откроем его и в открывшемся окне выберем опцию "Установить сертификат":
В открывшемся окне выберем установку сертификата для локального пользователя:
Установим сертификат в хранилище доверенных корневых сертификатов УЦ:
После всех этих действий соглашаемся со всеми дальнейшими пунктами. Теперь система настроена.
Создадим файл cert.tmp со следующим содержимым:
```
[NewRequest]
Subject = "CN=client"
KeyLength = 2048
KeySpec = "AT_KEYEXCHANGE"
ProviderName = "Microsoft Base Smart Card Crypto Provider"
KeyUsage = "CERT_KEY_ENCIPHERMENT_KEY_USAGE"
KeyUsageProperty = "NCRYPT_ALLOW_DECRYPT_FLAG"
RequestType = PKCS10
SMIME = FALSE
```
После этого сгенерируем ключевую пару и создадим заявку на сертификат. Для этого откроем powershell и введём следующую команду:
```
certreq.exe -new -pin $PIN .\cert.tmp .\client.req
```
Отправьте созданную заявку client.req в ваш УЦ и дождитесь получения сертификата client.pem. Его можно записать на токен и добавить в хранилище сертификатов Windows с помощью следующей команды:
```
certreq.exe -accept .\client.pem
```
Стоит заметить, что аналогичные действия можно воспроизвести с помощью графического интерфейса программы mmc, но данный способ является более времязатратным и менее программируемым.
Настройка клиента Ubuntu
========================
**NOTE**
Настройка клиента на Linux в данный момент является достаточно длительной по времени, т.к. требует сборки отдельных программ из исходников. Мы постараемся в ближайшее время добиться, чтобы все изменения попали в официальные репозитории.
---
Для обеспечения подключения на уровне IPSec к серверу — используется пакет strongswan и демон xl2tp. Для упрощения подключения к сети с помощью смарт-карт – будем использовать пакет l2tp-ipsec-vpn, обеспечивающий графическую оболочку для упрощенной настройки подключения.
Начнём сборку элементов поэтапно, но перед этим установим все необходимые пакеты для непосредственной работы VPN:
```
sudo apt-get install xl2tpd strongswan libp11-3
```
Установка ПО для работы с токенами
----------------------------------
Установите последнюю версию библиотеки librtpkcs11ecp.so с [сайта](https://www.rutoken.ru/support/download/pkcs/), также библиотеки для работы со смарт-картами:
```
sudo apt-get install pcscd pcsc-tools opensc libengine-pkcs11-openssl
```
Подключите Рутокен и проверьте, что он распознается системой:
```
pkcs11-tool --module /usr/lib/librtpkcs11ecp.so -O -l
```
Установка пропатченного ppp
---------------------------
**UPD**: предложенные нами изменения были приняты начиная с версии pppd 2.4.9. Поэтому пакет pppd можно взять из репозиториев.
```
sudo apt-get -y install git make gcc libssl-dev
git clone "https://github.com/jjkeijser/ppp"
cd ppp
./configure --prefix /usr
make -j4
sudo make install
```
Установка клиента L2tpIpsecVpn
------------------------------
В данный момент клиента тоже нужно собирать из исходников. Делается это с помощью следующей последовательности команд:
```
sudo apt-get -y install git qt5-qmake qt5-default build-essential libctemplate-dev libltdl-dev
git clone "https://github.com/Sander80/l2tp-ipsec-vpn"
cd l2tp-ipsec-vpn
make -j4
sudo make install
```
Настройка клиента L2tpIpsecVpn
------------------------------
Запускаем установленный клиент:
После запуска у вас должен открыться апплет L2tpIpsecVPN. Нажмём на него правой кнопкой мыши и произведём настройку соединения:
Для работы с токенами, в первую очередь, укажем путь opensc движка OpenSSL и PKCS#11 библиотеки. Для этого откройте вкладку "Preferences" для настройки параметров openssl:
.
Закроем окно настроек OpenSSL и перейдём к настройке сети. Добавим новую сеть, нажав на клавишу Add… в панели настроек и введите имя сети:
После этого данная сеть станет доступна в панели настроек. Дважды кликнем правой кнопкой мыши по новой сети, чтобы настроить её. На первой вкладке необходимо произвести настройки IPsec. Зададим адрес сервера и общий ключ:
После этого переходим на вкладку настройки PPP и укажем там имя пользователя, под которым мы хотим зайти в сеть:
После этого откроем вкладку Properties и укажем путь до ключа, сертификата клиента и УЦ:
Закроем данную вкладку и выполним финальную настройку, для этого откроем вкладку "IP settings" и поставим галочку напротив опции "Obtain DNS server address automatically":
Данная опция позволит клиенту получать от сервера личный IP-адрес внутри сети.
После всех настроек закроем все вкладки и перезагрузим клиент:
Подключение к сети
------------------
После настроек можно произвести подключение к сети. Для этого откроем вкладку апплета и выберем сеть, к которой мы хотим подключиться:
В процессе установки соединения клиент попросит ввести нас PIN-код Рутокен:
Если в статус-баре появится оповещение о том, что соединение успешно установлено, значит, настройка была произведена успешно:
В противном случае стоит разобраться, почему соединение не было установлено. Для этого стоит посмотреть лог программы, выбрав в апплете команду "Connection information":
Настройка клиента Windows
=========================
Настройка клиента в Windows осуществляется гораздо проще, чем в Linux, т.к. весь необходимый софт уже встроен в систему.
Настройка системы
-----------------
Установим все необходимые драйверы для работы с Рутокенами скачав их c [оф. сайта](https://www.rutoken.ru/support/download/windows/).
Импорт корневого сертификата для аутентификации
===============================================
Скачаем корневой сертификат сервера и установим в систему. Для этого откроем его и в открывшемся окне выберем опцию "Установить сертификат":
В открывшемся окне выберем установку сертификата для локального пользователя. Если хочется, чтобы сертификат был доступен всем пользователям на компьютере, то тогда следует выбрать установку сертификата на локальный компьютер:
Установим сертификат в хранилище доверенных корневых сертификатов УЦ:
После всех этих действий соглашаемся со всеми дальнейшими пунктами. Теперь система настроена.
Настройка VPN соединения
------------------------
Для настройки VPN соединения перейдите в панель управления и выберите пункт для создания нового соединения.
Во всплывшем окне выберите опцию создания соединения для подключения к рабочему месту:
В следующем окне выберете подключение по VPN:
и введите данные VPN соединения, а также укажите опцию для использования смарт-карты:
На этом настройка не закончена. Осталось указать общий ключ для протокола IPsec, для этого перейдём на вкладку “Настройки сетевых подключений” и затем перейдём на вкладку “Свойства для данного соединения”:
В открывшемся окне перейдём на вкладку "Безопасность", укажем в качестве типа сети "Сеть L2TP/IPsec" и выберем "Дополнительные параметры":
В открывшемся окне укажем общий ключ IPsec:
Подключение
-----------
После завершения настройки можно попробовать подключиться к сети:
В процессе подключения от нас потребуют ввести PIN-код токена:
Мы с вами настроили безопасную VPN сеть и убедились в том, что это несложно.
Благодарности
=============
Хотелось бы ещё раз поблагодарить наших коллег Василия Шокова и Александра Смирнова за совместно проделанную работу для упрощения создания VPN соединений для клиентов Linux. | https://habr.com/ru/post/506256/ | null | ru | null |
# Курс по Ruby+Rails. Часть 5. Паттерн MVC
MVC — это главный архитектурный принцип, вокруг которого строится не только Ruby on Rails, но и любой другой фреймворк, работающий со сложными структурами данных и их отображением. Этот архитектурный паттерн появился довольно давно, на заре объектно-ориентированного программирования, но он не сразу был принят веб-программистами.
Довольно долго они работали с данными и веб-страницами в общей куче. Каждая веб-страница содержала код множества операций, которые рисовали нужный пользовательский интерфейс. Разделение обязанностей между элементами приложения отдавалась на усмотрение программиста без строгой фиксации каких-либо паттернов или стандартов. Однако с течением времени разработчики перешли к более удобной работе — с моделями и с паттерном MVC как стандартом де-факто.
Аббревиатура MVC (или model-view controller) отражает систему, состоящую из модели, отображения (view) и контроллера. Разбирая MVC-приложение, мы столкнёмся с множеством файлов, каждый из которых определяет либо `model`, либо `view`, либо `controller`. Время от времени будут встречаться промежуточные сущности, примеры которых мы увидим чуть позже.
Процесс работы сложного веб-приложения разделен на работу с данными, представленными в виде моделей, с отображениями, с которыми взаимодействует конечный пользователь, и контроллерами — специальными механизмами, связывающими модель и отображение.
На диаграмме видно, как взаимодействуют эти сущности. Модель хранит данные, контроллер управляет вводом-выводом, а view — отображает. Обязательный элемент тут — пользователь, с которого начинается и которым заканчивается сложная цепочка взаимодействий. Давайте подробнее разберёмся во взаимодействиях и рассмотрим каждый элемент в отдельности:
### M — model
Модель — это сущность для работы с данными. Она хранит данные, контролирует их целостность и консистентность (то есть соответствие между разными моделями и статусу, который имеет приложение). Ещё модель производит и обрабатывает запросы на чтение или изменение данных к лежащему ниже механизму базы данных. Например, нельзя сохранить сущность пользователя, если для него не существует записи e-mail — это проверка на целостность.
Перед вами типичная модель:
```
# /app/models/payments.rb
# == Schema Information
#
# Table name: payments
#
# id :integer not null, primary key
# user_id :integer indexed
# sum :decimal(10, 2)
# paid_at :datetime
# creator_id :integer indexed
# description :string
# created_at :datetime
# updated_at :datetime
# notify :boolean default(TRUE)
#
class Payment < ApplicationRecord
include ArelHelpers::ArelTable
include UserFinance
belongs_to :user
validates :sum, :paid_at, presence: true
validates :sum, numericality: { greater_than_or_equal_to: 1 }
after_create :notify_user, if: :notify
has_paper_trail
private
def notify_user
text = %(
Hi, #{user.profile.name}! :slightly_smiling_face:
:money_with_wings: Money was transferred from your balance.
Details here: #{RoutesUrlHelper.new.work_url}
)
NotifierService.send_slack_message user, text
end
end
```
Этот код взят из живого проекта Evrone. Здесь много непонятных пока для вас слов, но мы выделим несколько основных элементов. Мы видим здесь описание связей между этой моделью и другой моделью `user`. Видим проверку консистентности и целостности данных — объявление `validates`. Также мы видим бизнес-логику: что делает эта модель после сохранения данных, а также обращения к некоторым библиотечным функциям. Ещё тут можно увидеть служебный метод для нотификации пользователя.
В Ruby on Rails для создания моделей мы чаще всего пользуемся библиотекой ActiveRecord. Подробно мы разберём её в одной из будущих лекций, а пока нам будет достаточно знать, что она реализует шаблон проектирования «object-relation mapper». Это значит, что модель формирует единую сущность из объектно-ориентированного кода на Ruby и таблицы в базе данных.
В примере вы видите сущность, которая реализует модель `payment` — на нижнем уровне это таблица с некоторыми необходимыми полями. В ходе взаимодействия базы данных и кода этого ruby-объекта и создаётся модель.
### V — view
Перейдём к view или «отображениям». Их задача — взаимодействовать с пользователем. Пользователем может быть человек, который видит наше приложение через браузер или мобильное устройство.
Пользователем может быть и не человек, а сервис или микросервис, который обращается к нашему приложению по JSON API и запрашивает или отправляет нам какие-то данные.
Важно, что этот абстрактный пользователь работает с нашим приложением через «view» или «отображения». Он не лезет напрямую в базу данных, не работает напрямую с моделями. Он пользуется теми отображениями, которые наше приложение ему предоставляет.
На иллюстрации — типичное отображение:
```
-# /app/views/payments/_form.html.haml
- inline ||= false
= bootstrap_form_for [:admin, payment.user, payment], remote: true,
data: { type: 'json',
prompt: ({ message: 'Enter the reason of payment:',
default: '',
param: 'payment[description]' } if inline) },
html: ({ class: 'd-flex' } if inline) do |f|
= f.number_field :sum, { label: 'Sum for payment',
step: '0.01' }.merge(inline ? { label_class: 'erp-label-sm',
class: 'form-control-sm',
wrapper: { class: 'mb-0' },
style: 'width: 130px' } : {})
= f.check_box :notify, { label: 'Notify employee' } unless inline
= f.text_area :description unless inline
= instance_form_submit f, caption: 'Pay', class: ('btn-sm ml-2' if inline), disabled: inline
```
Оно представляет собой форму, которая вносит изменения в модель, которую мы рассматривали до этого — модель `payment`. Отображения могут быть статическими, пассивными — они просто показывают состояние объекта, нашу модель. А могут быть интерактивными и указывать на способы взаимодействия с моделью.
### C — controller
Теперь настало время заняться контроллерами. Дело в том, что модель не образует сама своё отображение. Она не общается с пользователем напрямую. Должен быть инструмент, который поможет им взаимодействовать. Например, создаст эту модель из данных, хранящихся в СУБД, сформирует отображение, отправит его пользователю. Или такой сценарий: пользователь работает с формой в отображении, нажимает «enter» или «ok», и отправляет в наше приложение какой-то HTTP-запрос. Посредником между пользователем, моделью и отображением является контроллер. Контроллер можно представить себе как умный маршрутизатор, который управляет взаимодействиями между моделью и пользователем или отображением.
Кратко по контроллеру:
1. Он принимает, интерпретирует и валидирует всё, что вводит пользователь.
2. Он создаёт на основе имеющихся моделей отображения и отправляет их пользователям.
3. Он принимает от пользователей и отправляет моделям сообщения, вызывая те или иные методы в моделях или иную бизнес-логику.
На иллюстрации вы видите код одного из контроллеров:
```
# /app/controllers/payments_controller.rb
class PaymentsController < BaseController
respond_to :html, :json
before_action :load_user
before_action :load_and_authorize_payment, except: %i[new create]
def new
@payment = @user.payments.build(params[:payment] ? payment_params : {})
authorize! :create, @payment
render layout: false
end
def create
@payment = @user.payments.build(
{ creator_id: current_user.id, paid_at: DateTime.current }.merge(payment_params)
)
authorize! :create, @payment
@payment.save
respond_with :admin, @payment, location: (request.referer unless referer_params[:controller] == 'admin/main')
end
# ...
private
# ...
end
```
В нём содержится несколько выражений, которые программируют поведение приложения при получении какого-то http-запроса или при формировании http-ответа.
> Давайте повторим полученные сведения: MVC — это базовый архитектурный паттерн, на котором построен Ruby on Rails. Он определяет компонентную структуру приложения: оно состоит из моделей, отображений и контроллеров. Каждый из этих компонентов играет свою роль в стеке приложения. Модель отвечает за данные, контроллер маршрутизирует сообщения между моделью и отображением, отображение показывает состояние модели пользователю и позволяет с ней взаимодействовать.
>
>
MVC образует замкнутый поток управления внутри приложения. Он позволяет эффективно описывать компоненты, эффективно компоновать код и бизнес-логику. При этом приложение не является произвольным набором кода, в котором сложно понять, что с чем взаимодействует.
Теперь давайте представим себе маршрут, по которому движутся данные в MVC-приложении:
1. Процесс начинается с того, что пользователь видит на веб-странице какое-то состояние приложения — это работает отображение. Какой-то экран или форму, с которыми можно что-то сделать. Пользуясь доступными в отображении элементами управления, пользователь отправляет приложению HTTP-запрос.
2. Контроллер получает этот запрос и интерпретирует. Данные, которые ввёл пользователь, проходят через защитные конструкции — валидаторы. Запрос превращается в вызов методов в логике приложения.
3. Контроллер вызывает исполнение бизнес-логики. Бизнес-логика — это сложное понятие. Для простоты мы будем представлять её себе как обобщённое функциональное содержимое приложения.
4. Бизнес-логика внутри нашего приложения выполняет нужную трансформацию состояния моделей. Производимые действия на этом уровне разнообразны, но в итоге всё приводит к изменению состояния модели и сохранению этого состояния.
Настало время упомянуть важную особенность веб-технологии в целом. HTTP-протокол, в котором мы работаем, — это stateless-протокол. То есть программная логика нашего приложения живёт в пределах обработки одного HTTP-запроса: от получения запроса до отправки ответа. Важно, чтобы информация, связывающая разные запросы, некое общее состояние системы сохранялось. Бизнес-логика как раз формирует и сохраняет это состояние.
После того, как новый статус приложения сохранён в базе данных, формируется нужный ответ на запрос. Бизнес-логика возвращает данные ответа в контроллер. Контроллер на основании этих данных формирует и отправляет пользователю отображение модели, которую мы изменили. Отображение показывает пользователю новое состояние модели. Круг замыкается.
### Структура бизнес-логики и паттерны проектирования
Давайте подробнее остановимся на структуре бизнес-логики. Мы уже знаем, что приложения сложны, в них много страниц, форм, кнопок. Даже если перед нами только одна кнопка, например, «вызвать такси» — под капотом, как мы уже знаем, движется сложный поток управления и трансформации.
Бизнес-логика — не какой-то отдельный элемент. Это совокупность элементов, которые выполняют трансформацию данных в соответствии с «заказом» пользователя. Она должна эффективно работать в коде приложения, поэтому важно её правильно скомпоновать и разместить — приложение должно работать быстро и корректно. И вот тут может возникнуть ряд проблем, которые могут сделать код и структуру приложения избыточно сложными.
Разработчики давно спорят, где размещать бизнес-логику. Что предлагает нам Ruby on Rails?
«По учебнику» бизнес-логика размещается в моделях. Там можно и нужно размещать код, который следит за корректностью и консистентностью данных, за тем, как формируются запросы к этим данным. Но если мы разместим всё возможное взаимодействие с данными в моделях, то объём кода в них вырастет. Классы станут огромными, кодом будет трудно управлять. Учтём, что над программой работает часто не один человек, а целая команда. Программисты сменяют друг друга на одних и тех же участках кода. Код должен быть понятен и читаем.
При утяжелении кода модели возникает проблема привнесённой сложности — сложности не задачи, которую решает бизнес-логика, а сложность именно кода, его тяжеловесность. Работа с таким кодом требует лишнего времени. Но логику ведь надо куда-то деть? Часть её можно поместить в контроллеры. Но тут нас поджидают другие грабли — избыточно сложные контроллеры — тоже плохо. Ведь контроллер управляет запросами и сообщениями, он должен оставаться компактным маршрутизатором.
Можно некоторые элементы бизнес-логики помещать и во view. Например, какую-то сложную логику формы для взаимодействия с пользователем. Но если мы например, засунем туда формирование запроса к данным через обращения к моделям, то перегрузим view. Физически язык это позволяет, но так теряется контроль за кодом, взаимосвязанные части логики нестуктурированно расползаются по приложению.
Чтобы упорядочить распределение логики между моделями, отображениями и контроллерами, есть ряд приёмов, которые называются «паттерны проектирования». Эти инструменты — следствие компромиссов. Мы с одной стороны размещаем логику наиболее правильно, а с другой — приложение работает достаточно быстро. Вот эти инструменты.
#### Service-object
Первый паттерн проектирования, с которым мы познакомимся — это service object или service. Он ещё может называться interactor, transaction, operation или saga.
Пример такого сервиса:
```
# Service
class CsvGenerator
attr_reader :filename
def call(input_data)
headers, *body = input_data
CSV.generate do |csv|
csv << headers
body.each { |row| csv << row }
end
end
end
```
Это инструмент для группировки бизнес-логики вокруг одной, возможно сложной, многосоставной или продолжительной по времени операции.
До появления этого инструмента многие «организующие» операции помещали в контроллерах. Сейчас сложное взаимодействие стали выносить в специальные классы. Классы эти, как правило, имеют интерфейс, состоящий из одного публичного метода call. Если вспомните лекцию по функциональному программированию, то узнаете в сервисах паттерн «функциональный объект». Это значит, что объект, порождаемый этим классом, служит функцией, которая получает аргументы для своих параметров, объявленных в методе call, и производит с ними нужные действия.
На примере мы видим генерацию CSV в ответ на введённые данные. Этот код выделен в отдельный класс, лежит в своём файле, который правильно поименован. У других программистов, которые поддерживают этот проект, не возникает проблем с тем, чтобы найти этот код и изменить его, если это необходимо.
Получается, что мы избавили модель, view и контроллер от лишнего процедурного кода и не свели с ума других программистов, которые должны знать, где лежит часть бизнес-логики. Проблема решена!
Вызываются сервис-объекты контроллерами изнутри action'ов контроллера и возвращают порождённые данные в action контроллера для отображения пользователю.
Посмотрите на более сложный пример интерактора:
```
# Interactor
class ShowDaysOff < BaseInteractor
Dry::Validation.load_extensions(:monads)
param :filter_params, proc(&:to_h)
FilterSchema = Dry::Validation.Params do
required(:user_id).filled(:int?)
required(:since).filled(:date?)
required(:through).filled(:date?)
end
def call
filters = yield accept_filter_params
slots = yield apply_filters(initial_scope, filters)
grouped_slots = slots.group_by { |slot| Project::VACATION_TYPES_BY_PROJECT_ID[slot.project_id] }
build_days_off(grouped_slots, filters)
end
private
# ...
end
```
Предыдущий сервис до этого состоял из пары операций, а в интеракторе возможно построение длинных цепочек операций, где каждая следующая операция зависит от предыдущей. Вместе с тем, по сути и то, и другое — сервис-объекты.
#### Value object
Следующий паттерн проектирования — это value object или «объект для значений». В таком объекте можно группировать сложные данные в виде компактной структуры. Value object’ы переносят между частями бизнес-логики пакеты связанных между собой данных. Данные в Value object’ах можно передавать из контроллера в модель, между моделями, между моделями и view и так далее.
Вот пример value object:
```
class DetailedPayment < Dry::Struct
attribute :payment
attribute :payment_salaries
attribute :unrecognized_salaries
attribute :payment_expenses
attribute :unrecognized_expenses
attribute? :unknown_sum
def details
# ... constructing details
details
end
delegate :paid_at, to: :payment
private
def salary_details(salary)
# ...
end
def expense_details(expense)
# ...
end
end
```
Их особенность в том, что они содержат методы, которые должны возвращать данные, характерные для наших взаимодействий.
Данные они не преобразуют, являясь, по сути, просто контейнерами. Они, конечно, могут порождать какие-то данные на основе данных, например, модели или какой-то формы. Но это должны быть несложные операции, чаще всего — конвертирование типов или структур. Сложную логику сюда помещать не надо.
#### Presenter
Ещё один интересный паттерн — presenter. Его можно назвать близким родственником view. Он берёт какой-то объект, например, модель и «представляет» её для взаимодействия с отображением.
Посмотрите на пример такого объекта:
```
class EventPlanPresenter
attr_reader :object
def initialize(object)
@object = object
end
def time_until_end_of_day
time_diff = Time.current.end_of_day - Time.current
Time.at(time_diff.to_i.abs).utc.strftime '%H hours %M minutes'
end
end
```
Presenter добавляет к модели некоторые методы, которые управляют её презентационной логикой (отсюда и название паттерна). Он группирует элементы для более удобной передачи данных во view. Получается, что эта логика вынесена из view, за счёт чего отображения получаются легче. Одновременно, модель не перегружена чисто презентационным кодом.
#### Decorator
У presenter есть брат — паттерн decorator. Иногда их даже путают. Decorator «украшает» другие объекты (чаще всего модели) тем, что добавляет к ним какую-то функциональность. Но отличие от presenter всё таки есть: decorator содержит элементы логики преобразования данных, а не чисто презентационные.
Посмотрим:
```
class EventPlanDecorator
attr_reader :object
def initialize(object)
@object = object
end
def last_call_days_left
(object.last_call - Date.current).to_i
end
def last_call_soon?
last_call_days_left.in?(0..14)
end
def users_not_going
EventPlanUser.where(event_plan: object).refused.count
end
end
```
И presenter, и decorator «украшают» одну и ту же сущность — `event_plan`. Но в presenter была «художественная» логика, которая формировала сообщение с часами и минутами, а decorator содержит вычисления и преобразования данных.
При работе с презентерами и декораторами встречается процедурная ловушка, в которую иногда попадают программисты. Они перегружают presenter'ы и decorator'ы бизнес-логикой. Другие программисты, которые будут читать ваш код, должны понимать, что декорирующий или презентующий объект охватывает какой-то компактный, понятный и законченный кусок логики, поэтому не старайтесь впихнуть в один класс слишком много.
#### Form object
Для работы с бизнес-логикой форм существует паттерн Form Object. Эти объекты формируются из данных, которые приходят в запросе от пользователя. Например, пользователь заполнил какую-то форму в приложении и послал данные серверу. Контроллер принял запрос, интерпретировал его, превратил в некоторую структуру данных с элементами этого запроса: поля, параметры и так далее.
Сами по себе запросы могут быть очень сложными. Элементы в них могут взаимодействовать друг с другом, поэтому надо сложно проверять корректность сложных запросов. Эту логику можно разместить в контроллер, а можно вынести как раз в form object'ы. Вот довольно большой пример одного из них:
```
class UserVacationForm < AbstractUserVacationForm
include ActiveModel::Validations::Callbacks
attribute :type, Integer
attribute :hours, Float
# ...
validates :type, presence: true
validate :sanitize_hours, if: -> { hours.present? }
validate :check_vacation
validate :check_hours, if: -> { hours.present? && begin_date.present? && end_date.present? }
before_validation :improve_attributes
def improve_attributes
self.end_date = begin_date if begin_date.present? && end_date.blank?
end
def min_date
if vacation?
Date.current + Settings.vacation.vacation_buffer_period.months
else
Date.current.beginning_of_month - Settings.vacation.min_begin_date_for_vacation.months
end
end
def project
@project ||= Project.find(type)
end
private
# ...
end
```
Они похожи на модель: принимают и трансформируют данные, чтобы потом передать на хранение. С другой стороны — это всё-таки не модели. Механизма сохранения данных тут нет. Цель такого объекта — предварительно обработать данные, перед тем, как они попадут в модель, интерактор, сервис и так далее. Используя form object'ы, мы разгружаем отображения и модели, так как убрали из них препроцессинг данных.
#### Query object
Переходим к последнему на сегодня паттерну, query object — объект-запрос. Он формирует сложные запросы к базе данных.
Библиотека active record, с помощью которой мы создаём модели в rails-приложениях, очень умная. Она хорошо конструирует сложные sql-запросы, но иногда накопленного кода не хватает, элементы бизнес-логики требуют ещё более сложных запросов, чем доступны в active record «из коробки». Тогда мы используем query object'ы. Они получают данные HTTP-запроса и на выходе формируют сложные sql-запросы, или из сложных предварительных запросов делают простые окончательные. Данные, которые они получают, отправляются в модель, интерактор или другой компонент бизнес-логики.
И снова пример:
```
class IndexQuery < BaseQuery
param :filter, reader: :private do
option :key_accounter_id, Dry::Types['coercible.integer'], optional: true
end
option :initial_scope, reader: :private, default: proc { Project.active.not_vacations }
delegate :key_accounter_id, to: :filter
private :key_accounter_id
def where(scope)
scope.yield_self { |sc| simple_cond(sc, :key_accounter_id, key_accounter_id) }
end
end
```
### Короткое summary
Главная задача всех инструментов выше — сформировать логику изящно и понятно, чтобы код можно было легко поддерживать, чтобы соблюдались базовые принципы проектирования — своеобразый этикет разработчиков.
Один из таких принципов, например, единственной ответственности. Он гласит, например, что модель должна заниматься хранением и контролем консистентности данных, но не производить бухгалтерские расчёты. Или корзина, в которую покупатель онлайн-магазина набирает товары, не должна формировать заказ или считать налоги. Эти элементы логики должны быть вынесены в соответствующие им классы.
> То, что мы изучили сегодня, является архитектурным ядром Ruby on Rails. Фреймворк Ruby on Rails построен на основе архитектурного паттерна MVC. Важными архитектурными компонентами rails-приложения являются: модели, которые хранят данные и управляют их консистентностью, view или отображения, которые представляют эти данные пользователю и контроллеры, которые являются посредниками между моделями и view с одной стороны, и пользователями и моделями с другой.
>
> Кроме этого мы разобрали, как можно управлять сложностью кода, используя некоторые паттерны проектирования. С ними код можно делать код изящным и удобным в поддержке.
>
>
Спасибо за внимание, не стесняйтесь задавать вопросы — мы обязательно ответим. | https://habr.com/ru/post/695880/ | null | ru | null |
# Добавляем в Go-проект конфигурацию на языке Terraform
Конфигурирование приложений — это интересная тема. Мало того, что форматов конфигурации в сообществе инженеров много, ситуация осложняется тем, что выбор того или иного языка определяет, как вашим приложением будут пользоваться люди. Инженеры, которые будут выкладывать ваш бэкенд в абстрактную dev- или prod-среду, будут смотреть на ваше приложение как на чёрный ящик с одной лишь ручкой: механизмом настроек.
Я, как инженер, встречал удобные и не очень текстовые конфигурации: conf в Nginx, ini в systemd, JSON в VSCode… А также YAML. Он не стал новым словом в языках, но показал, какой красивой может быть конфигурация. Впрочем, сам по себе язык тупой как пробка: если вы попробуете писать на YAML что-то сложное, с переменными или циклами, то получится химера вроде Ansible. Или вроде манифестов Kubernetes, у которого диалект настолько переусложнён, что его приходится шаблонизировать с помощью Helm.
Да, как понятно из заголовка, я хочу поговорить про язык Terraform, но сначала…
Существующие решения
--------------------
Какие вообще есть языки в мире open source:
* **ini**, пришедший из Windows.
* А также его духовный наследник **TOML**, отличающийся большей структурированностью и типами.
* **Java properties**. Просто набор из строк ключ-значение.
* **dotenv**. Тоже в каком-то смысле популярный язык конфигурации из ключ-значение.
* **JSON**, который ещё можно встретить как язык конфигурации…
* …и **YAML**, наследующий структуру и типы JSON в более читаемом формате, и предоставляющий несколько расширений для строк и блоков.
* **HOCON**, интересный язык, который можно периодически встретить в мире Java.
* **XML**. Боже упаси. Нет, нет и нет. Не используйте XML как язык конфигурации в 2022 году. Пожалуйста.
* **Starlark**, который можно встретить в Bazel. Очень похож на Python.
* **conf**, антиформат, под которым вообще может скрываться что угодно: от конфигов того же Nginx или какой-нибудь Icinga2 до чёрт знает чего. Грубо говоря, это универсальное расширение для DSL.
* **Groovy**, который, вообще-то, полноценный язык программирования, но его можно применять как встраиваемый язык конфигурации, чем пользуется Jenkins и Gradle.
* **KotlinScript**, который дальше Gradle и TeamCity я нигде не встречал.
* И многие, многие другие.
А ещё есть HCL, язык, знакомый многим по Terraform.
Hashicorp Configuration Language
--------------------------------
Так де-юре расшифровывается HCL, но на деле это больше, чем язык конфигурации: согласно официальному описанию, это инструментарий для создания своего языка, который одинаково хорошо парсится человеком и машиной. По синтаксису он больше похоже на DSL, поскольку структура конфигурации очень гибкая, может содержать блоки, переменные и вызовы функций.
Грамматика языка описана [в этом документе](https://github.com/hashicorp/hcl/blob/main/hclsyntax/spec.md), а, попросту говоря, код вдохновлён конфигурацией Nginx и выглядит так:
```
variable = “value”
block {
type = list(string)
attribute = [123, 456]
innerblock {
key = “val”
}
}
# more real example
document “markdown” “example” {
name = “example”
content = file(“example.md”)
}
```
Здесь видно следующее:
* У языка есть все необходимые для жизни типы: числа, строки, списки и map-ы ключ-значение.
* Данные структурированы в блоки, которые могут быть вложенными. В объявлении блоков может быть два дополнительных поля (type и id).
* Можно вызывать функции.
Хорошо, с языком, в целом, разобрались. А как с ним работать из Go? На сцену приглашается фреймворк [hashicorp/hcl](https://pkg.go.dev/github.com/hashicorp/hcl/v2@v2.14.1#section-readme)! Он состоит из следующих библиотек:
* Одноимённая библиотека **hcl/v2** содержит примитивы и интерфейсы, общие для других библиотек: `Body` (ветвь в дереве конфигурации), `Diagnostic` (структура сообщений от парсера языка) и другие.
* **gohcl** используется для преобразования `hcl.Body` в структуры Go.
* **hcldec** — это высокоуровневый API для валидации и работы с интерфейсом `hcl.Body`.
* **hclparse** содержит инструменты для разбора как «нативного» синтаксиса HCL, так и JSON HCL. Да, у любого HCL-кода есть и JSON-эквивалент.
* Пакет **hclsimple** хорош для начала работы с фреймворком, в нём есть функции высокого порядка для парсинга файлов и байтов в те же структуры.
* **hclsyntax** — это пакет с парсером, AST и другим низкоуровневым кодом.
* **hclwrite** позволяет сгенерировать HCL-конфиг по спецификации и данным.
* **json** — JSON-парсер HCL, о JSON-формате упоминалось чуть выше.
### Пакет hclsimple
Итак. Есть hclsimple, идеальный для знакомства с системой. Попробуем написать тест?
```
import (
"os"
"path"
"testing"
"github.com/hashicorp/hcl/v2/hclsimple"
)
type Config1 struct {
Name string `hcl:"name"`
Count int64 `hcl:"count"`
}
func TestConfig1(t *testing.T) {
content := []byte(`
name = "Дороу"
count = 64
`)
var cfg Config1
err := hclsimple.Decode("test.hcl", content, nil, &cfg)
if err != nil {
t.Error(err)
}
if cfg.Name != "Дороу" {
t.Errorf("cfg.name: expected 'Дороу', got %v", cfg.Name)
}
if cfg.Count != 64 {
t.Errorf("cfg.count: expected 64, got %v", cfg.Count)
}
}
```
Что можно сказать об этом коде? Здесь есть `hclsimple.Decode()`, который принимает на вход имя файла (можно несуществующее) и байты, которые затем парсит в структуру. У функции есть ещё компаньон `DecodeFile()`, принимающий имя файла.
Что произойдёт, если Decode получит некорректное содержимое?
```
count = "Пашов нафих"
=== RUN TestConfig1
/home/igor/…/config_test.go:52: test.hcl:3,10-21: Unsuitable value type; Unsuitable value: a number is required
```
Конечно, мы получили сообщение об ошибке, но вот что интересно: HCL вывел позицию ошибки в файле, что крайне удобно при последующей диагностике неполадок.
Также в синтаксисе HCL допускается добавлять в объявления блока двух специальных полей (label): `id` и `type`. Пробуем:
```
type Document struct {
Format string `hcl:"type,label"`
Name string `hcl:"id,label"`
Content string `hcl:"content"`
}
type Config2 struct {
Docs []Document `hcl:"document,block"`
}
func TestConfig2(t *testing.T) {
content := []byte(`
document "markdown" "readme" {
content = "this is readme"
}
document "rst" "development" {
content = "dev process"
}
`)
// …
```
Остальная часть теста остаётся той же.
Также можно описать в структуре только `id`:
```
type Folder struct {
Name string `hcl:"id,label"`
Items []string `hcl:"items"`
}
type Config3 struct {
Docs []Document `hcl:"document,block"`
Folders []Folder `hcl:"folder,block"`
}
func TestConfig3(t *testing.T) {
content := []byte(`
document "markdown" "readme.md" {
content = "this is readme"
}
document "rst" "development.rst" {
content = "dev process"
}
folder "project" {
items = ["readme.md", "development.rst"]
}
`
```
Отлично! С блоками и примитивными типами разобрались
### Выполнение выражений
Но бывает так, что примитивных типов мало, и хочется, например, обращаться к другим атрибутам других блоков, как в Terraform. Для этого есть тип поля `hcl.Expression`. Но для работы с ним придётся спуститься немного поглубже в фреймворк HCL, точнее, в его систему типов и их преобразования. Этими задачами занимается библиотека [zclconf/go-cty](https://github.com/zclconf/go-cty). В общем, довольно лирики:
Код
```
import (
"testing"
"github.com/hashicorp/hcl/v2"
"github.com/hashicorp/hcl/v2/hclsimple"
"github.com/zclconf/go-cty/cty"
"github.com/zclconf/go-cty/cty/gocty"
)
type Document struct {
Format string `hcl:"type,label" cty:"format"`
Name string `hcl:"id,label" cty:"name"`
Filename string `hcl:"filename" cty:"filename"`
Content string `hcl:"content" cty:"content"`
}
type Folder struct {
Name string `hcl:"id,label"`
Items hcl.Expression `hcl:"items,attr"`
ParsedItems []string
}
type Config3 struct {
Docs []Document `hcl:"document,block"`
Folders []Folder `hcl:"folder,block"`
}
func TestConfig3(t *testing.T) {
content := []byte(`
document "markdown" "readme" {
filename = "readme.md"
content = "this is readme"
}
document "rst" "development" {
filename = "development.rst"
content = "dev process"
}
folder "project" {
items = [doc.readme.name, doc.development.name]
}
`)
docType := cty.Object(map[string]cty.Type{
"format": cty.String,
"filename": cty.String,
"name": cty.String,
"content": cty.String,
})
ctx := hcl.EvalContext{
Variables: map[string]cty.Value{
"doc": cty.EmptyObjectVal,
},
}
var cfg Config3
err := hclsimple.Decode("docs.hcl", content, &ctx, &cfg)
if err != nil {
t.Error(err)
}
docs := make(map[string]Document)
docMapType := make(map[string]cty.Type)
for _, doc := range cfg.Docs {
docs[doc.Name] = doc
docMapType[doc.Name] = docType
}
ctx.Variables["doc"], err = gocty.ToCtyValue(docs, cty.Object(docMapType))
if err != nil {
t.Error(err)
}
for _, folder := range cfg.Folders {
val, diags := folder.Items.Value(&ctx)
if diags.HasErrors() {
t.Error(diags)
}
items := val.AsValueSlice()
folder.ParsedItems = make([]string, 0, len(items))
for _, v := range items {
folder.ParsedItems = append(folder.ParsedItems, v.AsString())
}
}
}
```
Что в коде нового:
* В структуре `Document` появились теги `cty`. Они нужны для функции `ToCtyValue()`.
* Переменная `docType`, в которой явно описываем поля и типы структуры `Document`.
* В `Folder` поле `Items` теперь типа `hcl.Expression`. Почему не `[]hcl.Expression`? Просто потому, что, во-первых, массив с переменными — это тоже выражение; во-вторых, десериализатор не сможет привести массив выражений к нужной структуре.
* В `EvalContext` появилась пустая переменная doc типа объекта.
* Проходимся по десериализованным документам, создаём map-ы с именем и структурой документа, а также с именем и описанием типов структуры. Для чего перечислять тип документа в каждом элементе? Если мы хотим обращаться к данным через точку, то надо во всех местах ставить тип `cty.Object()`. А так как у объектов атрибуты могут быть разных типов, то придётся указывать тип каждого документа.
* Записываем в переменную `doc` `EvalContext`-а результат преобразования структуры в `cty.Value` (функция `gocty.ToCtyValue()`).
* Для выполнения выражения используется метод `Expression.Value(ctx)`. Контекст при желании может быть нулевым, но сейчас мы его заполнили переменной для того, чтобы в выражениях можно было обращаться к ним.
* Кастуем значение выражения к слайсу, каждый его элемент кастуем к строке, и только тогда добавляем в каталог.
Если в двух словах, то да, работа с переменными и выражениями в HCL трудна: надо проходить по конфигурации в несколько этапов, а если появляются графы зависимостей, как в Terraform, то становится вообще понуро! С другой стороны, легко это всё равно нельзя сделать, и вообще здорово, что фреймворк позволяет отложенно обрабатывать выражения, а не в один прогон, когда парсится файл.
### Анализ выражений
К слову, если хочется не обрабатывать все переменные, а просто определить по выражению, к каким переменным идёт обращение, то есть метод `Expression.Variables()`. Он возвращает `[]hcl.Traversal`, то есть массив из обращений к переменным. `Traversal`, в свою очередь, это путь поиска значения: в пути могут встречаться обращения к индексам, к ключам map-ы, к атрибутам структуры, и так далее.
Попробуем реализовать разбор `[]hcl.Traversal` для частного случая с переменной `doc`:
Код
```
func TestConfig4(t *testing.T) {
var cfg Config3
// …
docRefs := make(map[string]int, 0)
for _, f := range cfg.Folders {
varRefs := f.Items.Variables()
for _, varref := range varRefs {
if varref.RootName() != "doc" {
t.Errorf("%s is not a doc variable", varref.RootName())
}
for lvl, it := range varref[1:] {
switch value := it.(type) {
case hcl.TraverseAttr:
if lvl == 0 {
if _, ok := docRefs[value.Name]; !ok {
docRefs[value.Name] = 1
}
}
case hcl.TraverseIndex:
t.Error("indexing operations not supported")
}
}
}
}
docType := cty.Object(map[string]cty.Type{
"format": cty.String,
"name": cty.String,
"filename": cty.String,
"content": cty.String,
})
docVars := make(map[string]Document)
docTypes := make(map[string]cty.Type)
for _, doc := range cfg.Docs {
for ref, _ := range docRefs {
if ref == doc.Name {
docVars[doc.Name] = doc
docTypes[doc.Name] = docType
break
}
}
}
var err error
ctx.Variables["doc"], err = gocty.ToCtyValue(docVars, cty.Object(docTypes))
// дальше парсим как раньше
}
```
Из интересного:
* У `Config`.Items (тип `hcl.Expression`) вызываем метод `Variables()`, который возвращает перечень обращений к переменным (`[]hcl.Traversal`, о котором говорилось ранее).
* Поскольку `Traversal` — это псевдоним для `[]Traverser`, то по нему тоже можно итерироваться.
* `Traverser` — это общий интерфейс, поэтому в обходе цикла понадобится кастовать к конкретным структурам, то есть делать `switch value := it.(type)`.
* У `Traverse` три реализации — это `TraverseAttr`, `TraverseIndex`, а также `TraverseSplat`.
* Если переменная типа `doc..`, то записываем `name` в `docRefs` (это наше а-ля set) с исключением дубликатов.
* Проходимся по `cfg.Docs`, если имя документа есть в `docRefs`, то добавляем его в объект переменной.
### Частичный парсинг
Потенциально можно пойти ещё дальше в сторону не просто разбора обращения к переменным, а ещё и в сторону частичного разбора конфига в целом:
```
func TestConfig4(t *testing.T) {
// ...
hclfile, diags := hclsyntax.ParseConfig(content, "docs.hcl", hcl.InitialPos)
if diags.HasErrors() {
t.Error(diags)
}
bc, _, _ := hclfile.Body.PartialContent(folderSchema)
folder := bc.Blocks[0]
if folder.Labels[0] != "project" {
t.Errorf("folder name: expected %v, got %v", "project", folder.Labels[0])
}
attrs, diags := folder.Body.JustAttributes()
if diags.HasErrors() {
t.Error(diags)
}
for key, _ := range attrs {
if key != "items" {
t.Errorf("folder attr: expected %v, got %v", "items", key)
}
}
}
var folderSchema = &hcl.BodySchema{
Blocks: []hcl.BlockHeaderSchema{
{
Type: "folder",
LabelNames: []string{"name"},
},
},
Attributes: []hcl.AttributeSchema{
{Name: "items", Required: true},
},
}
```
* Здесь через низкоуровневый `hclsyntax`.ParseConfig() конфиг парсится в `hcl.File`.
* Это нужно для того, чтобы потом обратиться к его полю `Body` (тип `hcl.Body`) и получить частичный результат (`hcl.BodyContent`).
* Также `PartialContent()` возвращает оставшуюся часть `hcl.Body` и «диагностику». Диагностика при частичном парсинге будет содержать ошибки, поэтому её мы игнорируем, как и тело, которое нам сейчас не нужно.
* `PartialContent()` принимает только один аргумент — `hcl.BodySchema`, схему документа для валидации.
* В конце берём первый попавшийся блок, смотрим на его первую метку, а также на атрибуты.
### Функции
HCL, как уже упоминалось, поддерживает функции, а как их объявлять в контексте? Примерно следующим образом:
Код
```
func TestConfig5(t *testing.T) {
content := []byte(`
document "markdown" "readme" {
filename = "readme.md"
content = file("readme.md")
}
document "rst" "development" {
filename = "development.rst"
content = file("development.rst")
}
folder "project" {
items = [doc.readme.name, doc.development.name]
}
`)
ctx := hcl.EvalContext{
Functions: map[string]function.Function{
"file": FileFunc,
},
}
var cfg Config3
err := hclsimple.Decode("docs.hcl", content, &ctx, &cfg)
if err != nil {
t.Error(err)
}
for _, v := range cfg.Docs {
if v.Name == "readme" && v.Content != "" {
t.Error("readme has content:", v.Content)
}
if v.Name == "development" && v.Content != "" {
t.Error("development has content:", v.Content)
}
}
}
var FileFunc = function.New(&function.Spec{
VarParam: nil,
Params: []function.Parameter{
{Type: cty.String},
},
Type: func(args []cty.Value) (cty.Type, error) {
return cty.String, nil
},
Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
filename := args[0].AsString()
var err error
// content, err := os.ReadFile(filename)
content, err := []byte(fmt.Sprintf("<%s content>", filename)), nil
if err != nil {
return cty.NilVal, err
}
return cty.StringVal(string(content)), nil
},
})
```
* `VarParam` — это тип для `varargs`-аргумента функции. Если таковой у функции есть.
* `Params` — набор аргументов, которые принимает функция.
* `Type` — тип возвращаемого значения, можно вычислить на основе полученных аргументов.
* `Impl` — собственно, тело функции. `os.ReadFile` подменён фейковыми данными, но принцип работы понятен.
Также в библиотеке cty есть пакет `functions.stdlib` с уже готовыми функциями для работы с числами, массивами, строками и их форматированием, и другие.
В заключение
------------
Hashicorp Configuration Language выделяется из других языков хорошим синтаксисом и одноимённым фреймворком. По функциональности язык можно сравнить можно со Starlark, Groovy и KotlinScript, однако в отличие от первого hashicorp/hcl умеет парсить код в несколько этапов и с разными подходами, а Groovy/Kotlin требуют свой компилятор в runtime. На мой взгляд, HCL — это отличное решение для сложной и декларативной конфигурации, или если вы пишете инструмент для DevOps, которые тоже любят описывать инфраструктуру в декларативной конфигурации. | https://habr.com/ru/post/692814/ | null | ru | null |
# Использование gpio-generic и irq_chip_generic для драйвера gpio
Данная статья является логичным продолжением предыдущей и её прочтение рекомендуется после ознакомления с [предшествующим материалом](https://habrahabr.ru/post/303060/). Текущая заметка необходима для понимания последующего материала, дополнительного понимания подсистемы gpio в целом и способствует разработке собственных gpio драйверов. Положения данной статьи уже применимы не только к нашему виртуальному драйверу gpio, но и к любому mmio gpio драйверу в целом. Речь пойдет об упомянутой в предыдущей части "оптимизации".
Цель
====
Прежде чем приступать к более интересным и полезным вещам, необходимо навести порядок. Как и упоминалось ранее количество кода можно сократить. Для этого воспользуемся двумя подсистемами (драйверами) gpio-generic (gpio-mmio начиная с 4.7) и irq\_chip\_generic.
Согласно принципам ядра linux лучше пожертвовать производительностью ради понятности и отсутствию повторяющегося типового кода. А использованию существующих реализаций в ядре linux, несомненно служит данной цели.
Реализация
==========
pci\_ids
--------
> Небольшое отступление.
Первоначально при переходе на bgpio был проведен небольшой успешный эксперимент для виртуального драйвера с поддержкой устройств по 8, 16 и 32 входа. Итоговый код можно посмотреть [здесь](https://github.com/maquefel/virtual_gpio_basic/tree/pci_ids). Данного результата удалось достичь благодаря небольшой, всего 7 строк, модификации ivshmem, чтобы добавить передаваемые параметры sub-vendor-id и sub-device-id для pci устройства (патч входящий в ветку предназначен для версии qemu 2.5.1.1).
Использование gpio-mmio
-----------------------
> В ядре данный драйвер зависит от **CONFIG\_GPIO\_GENERIC**.
Начнем с простого, драйвера, который создавался для различных MMIO gpio, и в последствии части которого стали достаточно активно использоваться некоторыми драйверами. Он был представлен Антоном Воронцовым в 2010 году (<https://lkml.org/lkml/2010/8/25/303>). В своем патче он анонсировал для драйвера следующие возможности:
* Поддержку 8/16/32/64 битных регистров
* Поддержку контроллеров gpio с регистрами задания/очистки
* Поддержку контроллеров gpio только с регистром данных
* Поддержку big-endian
В принципе данный драйвер избавляет нас от необходимости самим реализовывать такие функции как, задание состояния и выбор направления контакта.
Для использование достаточно всего лишь передать размер и регистр данных, все остальное опционально и зависит от конкретной реализации контроллера gpio, функция инициализации принимает в качестве параметров:
* Регистр состояния
* Регистр задания состояния
* Регистр очистки состояния
* Регистр переключения контакта в состояние выхода
* Регистр переключения контакта в состояние входа
То есть возможны следующие ситуации:
* Регистр dat только для чтения состояния, регистр set для задания и регистр clr для очистки состояния
* Регистр dat только для чтения, регистр set для задания и очистки
* Регистр dat для всего
Тоже самое справедливо и для направлений. Либо регистр задания как выхода, либо как входа. Или отсутствие самой возможности переключить контакт в состояние выхода или входа.
Симулировать можно любое из выше перечисленных проведений. Для наших целей вполне достаточно поведения номер 3 и задания состояния как выхода, с состоянием для контакта по умолчанию как вход.
[bgpio\_init](http://lxr.free-electrons.com/source/drivers/gpio/gpio-generic.c?v=4.6#L507)
```
#if IS_ENABLED(CONFIG_GPIO_GENERIC)
int bgpio_init(struct gpio_chip *gc,
struct device *dev,
unsigned long sz,
void __iomem *dat,
void __iomem *set,
void __iomem *clr,
void __iomem *dirout,
void __iomem *dirin,
unsigned long flags);
#define BGPIOF_BIG_ENDIAN BIT(0)
#define BGPIOF_UNREADABLE_REG_SET BIT(1) /* reg_set is unreadable */
#define BGPIOF_UNREADABLE_REG_DIR BIT(2) /* reg_dir is unreadable */
#define BGPIOF_BIG_ENDIAN_BYTE_ORDER BIT(3)
#define BGPIOF_READ_OUTPUT_REG_SET BIT(4) /* reg_set stores output value */
#define BGPIOF_NO_OUTPUT BIT(5) /* only input */
#endif
```
Необходимо обратить внимание, что в качестве размера bgpio\_init принимает не количество входов, а параметр кратный 8, то есть ngpio/8.
```
err = bgpio_init(&vg->chip, dev, BITS_TO_BYTES(VIRTUAL_GPIO_NR_GPIOS),
data, NULL, NULL, dir, NULL, 0);
```
Использование irq\_chip\_generic
--------------------------------
> В ядре данный драйвер зависит от **GENERIC\_IRQ\_CHIP**, что является недостатком, так как нет возможности включить данный параметр через menuconfig или oldconfig.
Теперь рассмотрим немного более сложную часть. irq\_chip\_generic был представлен в версии ядра [v3.0-rc1](https://github.com/torvalds/linux/commit/7d8280624797bbe2f5170bd3c85c75a8c9c74242) и выполняет функции схожие с gpio-mmio, то есть предоставляет стандартную имплементацию для многих случаев irq\_chip.
Стандартные функции чтения/записи регистра являются 32 битными, это была одна из причин по которой я решил отказаться от 8/16 битных версий драйвера, тем не менее [есть возможность предоставить подсистеме irq\_chip\_generic свои функции для чтения/записи или указать стандартные](https://lkml.org/lkml/2014/11/7/68) (например ioread8, iowrite8).
### Совместное использование irq\_chip\_generic и функций gpiochip\_irqchip\_add, gpiochip\_set\_chained\_irqchip
Память под irq\_chip\_generic и инициализация происходит с помощью irq\_alloc\_generic\_chip. Функция, помимо тривиальных параметров, требует еще и irq\_base, который, вообще говоря, нам неизвестен до вызова gpiochip\_irqchip\_add, что в свою очередь требует struct irq\_chip. Но irq\_alloc\_generic\_chip отвечает только за выделение памяти и инициализацию некоторых параметров, так что мы можем передать 0 в качестве параметра irq\_base и присвоить реальное значение после вызова функции gpiochip\_irqchip\_add.
```
gc = irq_alloc_generic_chip(VIRTUAL_GPIO_DEV_NAME, 1, 0, vg->data_base_addr, handle_edge_irq);
```
Для использования достаточно указать стандартные функции маскирования/демаскирования, подтверждения прерывания и регистры. Функция задания типа прерывания у нас остается неизменной, как и наш обработчик прерывания.
```
ct->chip.irq_ack = irq_gc_ack_set_bit;
ct->chip.irq_mask = irq_gc_mask_clr_bit;
ct->chip.irq_unmask = irq_gc_mask_set_bit;
ct->chip.irq_set_type = virtual_gpio_irq_type;
```
Смещение регистров для подтверждения и маскирования/демаскирования:
```
ct->regs.ack = VIRTUAL_GPIO_INT_EOI;
ct->regs.mask = VIRTUAL_GPIO_INT_EN;
```
Регистрами типа прерывания мы по-прежнему заведуем сами, в функции virtual\_gpio\_irq\_type.
Соответственно в инициализацию gpiochip\_irqchip\_add и gpiochip\_set\_chained\_irqchip мы передаем экземпляр irq\_chip выделенный в irq\_chip\_generic->chip\_types[0] (irq\_chip\_generic может иметь несколько типов irq\_chip ассоциированных с одним и тем же подмножеством irq).
После чего используем полученный irq\_base и завершим настройку irq\_chip\_generic.
```
irq_setup_generic_chip(gc, 0, 0, 0, 0);
gc->irq_cnt = VIRTUAL_GPIO_NR_GPIOS;
gc->irq_base = vg->chip.irq_base;
u32 msk = IRQ_MSK(32);
u32 i;
for (i = gc->irq_base; msk; msk >>= 1, i++) {
if (!(msk & 0x01))
continue;
struct irq_data *d = irq_get_irq_data(i);
d->mask = 1 << (i - gc->irq_base);
irq_set_chip_data(i, gc);
}
```
Мы намеренно передаем 0 в качестве параметра msk, чтобы избежать повторной инициализации номеров irq.
irq\_chip\_generic используется для вполне себе серьёзных контроллеров irq в основном платформенных, поэтому маска для регистров irq вычисляется заранее, чтобы ускорить обработку прерываний и не тратить время на вычисление маски в процессе работы. Поскольку мы передаем 0 в качестве параметра в функцию irq\_setup\_generic\_chip, инициализируем маски самостоятельно.
Остается еще одна проблема, связанная с irq\_set\_chip\_data (которая ничто иное как `irq_data.chip_data = (void*)struct irq_chip_generic;`). Дело в том, что gpiolib тоже опирается на void\* chip\_data и полагает, что там должен находится указатель на struct gpio\_chip (<http://lxr.free-electrons.com/source/drivers/gpio/gpiolib.c#L1138>). Проблема решается предоставлением собственных реализаций функций irq\_request\_resources и irq\_release\_resources вместо стандартных gpiochip\_irq\_reqres и gpiochip\_irq\_relres.
[Исходный код для данного примера.](https://github.com/maquefel/virtual_gpio_basic/blob/5af1e6eb8137780be343559bb69f096144902e71/virtual_gpio_basic.c)
### Альтернативный подход
Строго говоря перечисленные выше манипуляции не очевидны, и может возникнуть некоторая сложность с их пониманием. Попробуем отказаться от gpiochip\_irqchip\_add.
Перво-наперво запросим irq\_base сами:
```
irq_base = irq_alloc_descs(-1, 0, vg->chip.ngpio, 0);
```
Как мы помним из предыдущей статьи наш случай линейный (функция irq\_domain\_add\_simple делает почти то же самое, но является устаревшей).
```
vg->irq_domain = irq_domain_add_linear(0, vg->chip.ngpio, &irq_domain_simple_ops, vg);
irq_domain_associate_many(vg->irq_domain, irq_base, 0, vg->chip.ngpio);
```
Следующий шаг остается практически неизменным и заключается в связывании gpio\_chip с irq\_chip:
```
vg->chip.irqdomain = vg->irq_domain;
gpiochip_set_chained_irqchip(&vg->chip, &ct->chip, pdev->irq, NULL);
```
Единственный момент — чтобы был доступен файл "edge" в соответствующей директории управления контактом ([gpiolib-sysfs](http://lxr.free-electrons.com/source/drivers/gpio/gpiolib-sysfs.c#L353)), необходимо указать функцию трансляции to\_irq:
```
vg->chip.to_irq = virtual_gpio_to_irq;
```
Заключение
==========
Благодаря использованию уже существующих подсистем код немного сократился. В понимании драйвер так же стал проще, так как использование данных подсистем достаточно распространено, и сразу видно, что это стандартный драйвер без подводных камней. К тому же с такой структурой будет гораздо проще воспользоваться механизмами Device Tree.
Условным недостатком следует считать зависимость от **CONFIG\_GPIO\_GENERIC** и **GENERIC\_IRQ\_CHIP**, но первый параметр легко включается в конфигурации ярда linux, а второй, вполне возможно, уже включен.
Материалы рекомендованные к дополнительному чтению:
1. [High-level IRQ flow handlers](https://www.kernel.org/doc/htmldocs/genericirq/Highlevel_IRQ_flow_handlers.html)
2. [Linux Kernel IRQ Domain](http://invo-tronics.com/linux-kernel-irq-domain/)
3. [Edge Triggered Vs Level Triggered interrupts](https://venkateshabbarapu.blogspot.ru/2013/03/edge-triggered-vs-level-triggered.html)
» [Исходные коды, Makefile и README](https://github.com/maquefel/virtual_gpio_basic/tree/v4.6) | https://habr.com/ru/post/307840/ | null | ru | null |
# Кастомный ExpandableListView в Android
В данной статье хочу привести небольшой пример работы с кастомизацией **ExpandableListView** — двухуровневого списка.
То, что должно получиться в итоге
Приступим, создадим проект и добавим в активити данный код
```
public class ExpActivity extends Activity
{
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
// Находим наш list
ExpandableListView listView = (ExpandableListView)findViewById(R.id.exListView);
//Создаем набор данных для адаптера
ArrayList> groups = new ArrayList>();
ArrayList children1 = new ArrayList();
ArrayList children2 = new ArrayList();
children1.add("Child\_1");
children1.add("Child\_2");
groups.add(children1);
children2.add("Child\_1");
children2.add("Child\_2");
children2.add("Child\_3");
groups.add(children2);
//Создаем адаптер и передаем context и список с данными
ExpListAdapter adapter = new ExpListAdapter(getApplicationContext(), groups);
listView.setAdapter(adapter);
}
}
```
Добавляем в **main.xml** ExpandableListView
```
xml version="1.0" encoding="utf-8"?
```
Теперь создадим класс адаптера
```
public class ExpListAdapter extends BaseExpandableListAdapter {
private ArrayList> mGroups;
private Context mContext;
public ExpListAdapter (Context context,ArrayList> groups){
mContext = context;
mGroups = groups;
}
@Override
public int getGroupCount() {
return mGroups.size();
}
@Override
public int getChildrenCount(int groupPosition) {
return mGroups.get(groupPosition).size();
}
@Override
public Object getGroup(int groupPosition) {
return mGroups.get(groupPosition);
}
@Override
public Object getChild(int groupPosition, int childPosition) {
return mGroups.get(groupPosition).get(childPosition);
}
@Override
public long getGroupId(int groupPosition) {
return groupPosition;
}
@Override
public long getChildId(int groupPosition, int childPosition) {
return childPosition;
}
@Override
public boolean hasStableIds() {
return true;
}
@Override
public View getGroupView(int groupPosition, boolean isExpanded, View convertView,
ViewGroup parent) {
if (convertView == null) {
LayoutInflater inflater = (LayoutInflater) mContext.getSystemService(Context.LAYOUT\_INFLATER\_SERVICE);
convertView = inflater.inflate(R.layout.group\_view, null);
}
if (isExpanded){
//Изменяем что-нибудь, если текущая Group раскрыта
}
else{
//Изменяем что-нибудь, если текущая Group скрыта
}
TextView textGroup = (TextView) convertView.findViewById(R.id.textGroup);
textGroup.setText("Group " + Integer.toString(groupPosition));
return convertView;
}
@Override
public View getChildView(int groupPosition, int childPosition, boolean isLastChild,
View convertView, ViewGroup parent) {
if (convertView == null) {
LayoutInflater inflater = (LayoutInflater) mContext.getSystemService(Context.LAYOUT\_INFLATER\_SERVICE);
convertView = inflater.inflate(R.layout.child\_view, null);
}
TextView textChild = (TextView) convertView.findViewById(R.id.textChild);
textChild.setText(mGroups.get(groupPosition).get(childPosition));
Button button = (Button)convertView.findViewById(R.id.buttonChild);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Toast.makeText(mContext,"button is pressed",5000).show();
}
});
return convertView;
}
@Override
public boolean isChildSelectable(int groupPosition, int childPosition) {
return true;
}
}
```
Названия методов и параметров довольно информативны. Методы **getGroupView** и **getChildView** возвращают View для «родителей» и «детей» соответственно. Используя параметр isExpanded в методе getGroupView, можно, например, менять фон group при разных состояниях. С помощью **LayoutInflater** используем кастомные layout для нашего списка.
**group\_view.xml**
```
xml version="1.0" encoding="utf-8"?
```
**child\_view.xml**
```
xml version="1.0" encoding="utf-8"?
```
В **child\_view.xml** добавлена кнопка, а в адаптере в методе **getChildView** обработали ее нажатие. Таким же образом можно добавлять кнопки и другие элементы в **group\_view.xml.**
Так же списку можно «навесить» слушателей:
* OnChildClickListener — нажатие на элемент
* OnGroupCollapseListener – сворачивание группы
* OnGroupExpandListener – разворачивание группы
* OnGroupClickListener – нажатие на группу
Теперь рассмотрим **groupIndicator** — индикатор состояния группы. Его положение задано в **main.xml** параметрами **indicatorLeft** и **indicatorRight** — соответственно левой и правой границей. По умолчанию индикатор располагается слева, что не очень привычно. Также можно подставить свои изображения, для этого нужно создать **indicator.xml** в папке drawable с таким кодом
```
xml version="1.0" encoding="utf-8"?
```
Где **imageOpen** – будет отображаться при раскрытой группе, а **imageClose** – закрытой. Далее в **main.xml** нужно добавить строчку к параметрам нашего списка **android:groupIndicator="@drawable/indicator"**. При подготовке изображений нужно учесть то, что они будут растянуты по всей высоте лэйаута group\_view. Так что если нужен кастомный значок индикатора — лучше использовать пару изображений и контролировать их появления в методе getView. В этой [статье](http://habrahabr.ru/post/133575/) хорошо описаны нюансы работы с адаптерами, а также хочу обратить ваше внимание на использование класса ViewHolder.
Ну вот и все, надеюсь, что пост поможет начинающим разработчикам. | https://habr.com/ru/post/147546/ | null | ru | null |
# Оптимизация и Generics в CLR
 *В этой статье Джон Скит будет описывать как простейшие конструкции языка замедляют вашу программу и как их можно ускорить.*
Как и в любой работе, сваязанной с производительностью приложений, результат может варьироваться в зависимости от условий (в частности, например, 64-разрядный `JIT` может работать несколько иначе), и в большинстве случаев это не должно вас волновать. Несмотря на это, относительно небольшое количество разработчиков пишут продакшен-код, состоящий из большого количества микрооптимизаций. Потому, пожалуйста, не принимайте этот пост как призыв к усложнению кода ради иррациональной оптимизации, которая якобы ускорит вашу программу. Используйте это только там, где это реально может понадобиться.
#### Ограничение new()
Пусть, нарпимер, у нас есть тип `SteppedPattern` (автор обсуждает оптимизацию на примере своей библиотеки, `Noda Time`, — прим. перев.), у которого есть generic-тип `TBucket`. Отмечу только, что важно, что перед тем, как я буду парсить value, я хочу создать новый объект класса `TBucket`. Идея состоит в том что крупицы информации складываются в `Bucket`, где они парсятся. И после окончания операции они складываюся в `ParseResult`. Так что каждая операция разбора строки требует создания экземпляра `TBucket`. Как мы можем создавать их в случае с Generic — типами?
Мы можем это сделать вызвав конструктор типа без параметров. Я не хочу задумываться, есть ли у передаваемых типов такой конструктор, потому я просто добавлю ограничение `new()` и вызову `new TBucket()`.
```
// Somewhat simplified...
internal sealed class SteppedPattern : IParsePattern
where TBucket : new()
{
public ParseResult Parse(string value)
{
TBucket bucket = new TBucket();
// Rest of parsing goes here
}
}
```
Великолепно! Совсем просто. Однако, к сожалению, я упустил из виду, что эта единственная строка кода будет занимать у нас 75% времени выполнения разбора строки. А это всего лишь создание пустого `Bucket` — самого простого класса, который разбирает самую простую строчку! Когда я это понял, меня это потрясло.
##### Исправляем, используя провайдер
Наше исправление будет очень простым. Нам всего лишь надо сказать нашему типу, как создавать экземпляр объекта. Сделаем это при помощи делегата:
```
// Somewhat simplified...
internal sealed class SteppedPattern : IParsePattern
{
private readonly Func bucketProvider;
internal SteppedPattern(Func bucketProvider)
{
this.bucketProvider = bucketProvider;
}
public ParseResult Parse(string value)
{
TBucket bucket = bucketProvider();
// Rest of parsing goes here
}
}
```
Теперь я могу вызвать `new StoppedPattern(() => new OffsetBucket())`, или что-то в этом духе. Это также означает, что я могу оставить коструктор как internal и больше никогда о нем не заботиться. И, что еще более упростит написание последующего кода, я даже смог бы использовать старые Bucket для разбора последующих строк.
##### Хочу таблички!
Мне так кажется, что далеко не всем захочется прогонять тесты самостоятельно, а больше захочется посмотреть на готовые результаты. Потому я решил привести результаты benchmarks, которые я сделал чтобы проверить только время создания Generic-типов. Для того чтобы показать насколько незначительными будут эти результаты, я указжу, что значения, записанные в таблице, измеряются в миллисекундах. И за это время было выполнено 100 миллионов операций, которые мы будем тестировать. Потому если только ваш код не основан на частом обращении к операции создания generic-типов, это не должно вызвать в вас желание переписывать код. Однако, запомните это на будущее.
Так или иначе, наш код разработан для работы с четыремя типами: двумя классами и двумя структурами. И для каждого из них — с маленькой и большой версией (имеется в виду, видимо, маленькие и большие версии для `GAC`, меньшие и большие чем 85K), на 32-х и 64-разрядных машинах, для `CLR v2`, v4. 64-разрядная машина у меня сама по себе более быстрая, так что необходимо сравнивать результаты внутри одной машины.
**CLR v4: 32-bit results (ms per 100 million iterations)**
| | | |
| --- | --- | --- |
| Test type | new() constraint | Provider delegate |
| Small struct | 689 | 1225 |
| Large struct | 11188 | 7273 |
| Small class | 16307 | 1690 |
| Large class | 17471 | 3017 |
**CLR v4: 64-bit results (ms per 100 million iterations)**
| | | |
| --- | --- | --- |
| Test type | new() constraint | Provider delegate |
| Small struct | 473 | 868 |
| Large struct | 2670 | 2396 |
| Small class | 8366 | 1189 |
| Large class | 8805 | 1529 |
**CLR v2: 32-bit results (ms per 100 million iterations)**
| | | |
| --- | --- | --- |
| Test type | new() constraint | Provider delegate |
| Small struct | 703 | 1246 |
| Large struct | 11411 | 7392 |
| Small class | 143967 | 1791 |
| Large class | 143107 | 2581 |
**CLR v2: 64-bit results (ms per 100 million iterations)**
| | | |
| --- | --- | --- |
| Test type | new() constraint | Provider delegate |
| Small struct | 510 | 686 |
| Large struct | 2334 | 1731 |
| Small class | 81801 | 1539 |
| Large class | 83293 | 1896 |
Посмотрите на результаты для классов. Это реальные результаты — они занимают около 2-х минут на моем ноутбуке при использовании ограничения `new()` и всего пару секунд при использовании провайдера. И, что очень важно отметить, эти результаты актуальны для `.Net 2.0` (имеется в виду `CLR`, а версия 2.0 скорее написана для того чтобы удивить читателя тем что вплоть до `.Net 3.5` все работает на `CLR v2`, для `.Net 2.0`).
И, конечно же, вы можете скачать [benchmark](http://pobox.com/~skeet/csharp/blogfiles/NewConstraint.cs) чтобы посмотреть и убедиться как это отработает на вашей машине.
##### Что же происходит «под капотом»?
Насколько я понимаю, не существует никакой `IL` инструкции чтобы поддержать ограничение `new()`. Вместо этого компилятор вставляет инструкции вызова [Activator.CreateInstance[T]](http://msdn.microsoft.com/en-us/library/0hcyx2kd.aspx). Очевидно, это в любом случае медленнее вызова делегата, т.к. В этом случае мы пытаемся найти подходящий для нас конструктор через рефлексию и вызываем его. Меня по-настоящему удивило точто это не было соптимизировано. Ведь очевидное решение — это использование делегатов и их кэширование для дальшнейшего использования. Я не буду разводить дебатов по вопросам принятого ими решения, ведь в конечном итоге их решение не расходует дополнительной памяти, которую будет занимать кэш.
#### Хочу больше бенчмарков!!
(взято из второй части статьи)
Здесь мы посмотрим на производительность работы с делегатами. А также попробуем их ускорить.
Полный исходный код тестирования производительности вы можете скачать [у меня с сайта](http://pobox.com/~skeet/csharp/blogfiles/GenericsAndLambdas.cs). Здесь, по сути, я делаю аналогичные действия каждый раз, когда пишу тест. Создаю делегат типа `Action`, который ничего не делает и проверяю что ссылка на него не является обнуленной. Это я делаю только чтобы избежать оптимизаций `JIT`. Каждый тест выполнен в виде generic-метода, который принимает один Generic-параметр. Я вызываю каждый метод два раза: в первый раз я передаю в качестве аргумента `Int32`, а во второй — `String`. Также а включил несколько кейсов:
* Я использую лямбда-выражения: Action foo = () => ();
```
private static void Lambda()
{
Action foo = () => {};
if (foo == null)
{
throw new Exception();
}
}
```
* То, что я хотел бы, чтобы делал за меня компилятор: отдельный кэш, хранящий делегат создания экземпляра класса.
```
private static void FakeCachedLambda()
{
if (FakeLambdaCache.CachedAction == null)
{
FakeLambdaCache.CachedAction = FakeLambdaCache.NoOp;
}
Action foo = FakeLambdaCache.CachedAction;
if (foo == null)
{
throw new Exception();
}
}
private static class FakeLambdaCache
{
internal static Action CachedAction;
internal static void NoOp() {}
}
```
* То, что компилятор делает в реальности с лямбда-выражением: мы напишем отдельный generic-метод, и будем делать `method group conversion`
```
private static void GenericMethodGroup()
{
Action foo = NoOp;
if (foo == null)
{
throw new Exception();
}
}
```
* То, что компилятор мог бы сделать: использовать отдельный не-`generic` метод, чтобы впоследствии применить `method group conversion`
```
private static void NonGenericMethodGroup()
{
Action foo = NoOp;
if (foo == null)
{
throw new Exception();
}
}
```
* Использование `method group conversion` в статическом не-`generic` методе generic-типа;
```
private static void StaticMethodOnGenericType()
{
Action foo = SampleGenericClass.NoOpStatic;
if (foo == null)
{
throw new Exception();
}
}
```
* Использование `method group conversion` в не статическом не-generic методе generic-типа, с использованием generic-классом кэша с единственным полем, указывающем на экземпляр generic-класса.
Да, последнее выглядит несколько замысловатым, однако это выглядит намного проще:
```
private static void InstanceMethodOnGenericType()
{
Action foo = ClassHolder.SampleInstance.NoOpInstance;
if (foo == null)
{
throw new Exception();
}
}
```
Также раскрою все нераскытые определения:
```
private static void NoOp() {}
private static void NoOp() {}
private class ClassHolder
{
internal static SampleGenericClass SampleInstance = new SampleGenericClass();
}
private class SampleGenericClass
{
internal static void NoOpStatic()
{
}
internal void NoOpInstance()
{
}
}
```
Заметьте, что все это мы делаем в generic-методе, и вызываем его для каждого типа: `Int32` и `String`. И, что важно заметить, мы не захватываем никаких переменных, и generic-параметр не участвует ни в какой части реализации тела метода.
##### Результаты тестирования
Опять же, результаты представлены в миллисекундах, на 10 миллионах операциях. Я не хочу запускать их на 100 миллиона операциях, потому что это будет очень медленно. Также уточню, что тестирование производилось на x64 JIT
| | | |
| --- | --- | --- |
| **Test** | **TestCase[int]** | **TestCase[string]** |
| Lambda expression | 180 | 29684 |
| Generic cache class | 90 | 288 |
| Generic method group conversion | 184 | 30017 |
| Non-generic method group conversion | 178 | 189 |
| Static method on generic type | 180 | 29276 |
| Instance method on generic type | 202 | 299 |
Да, создание делегата на generic-метод, с ссылочным типом в качестве generic-параметра в 150 раз медленнее чем для value-типа в качестве generic-параметра. И, похоже, что я первый кто об этом узнал. Было бы, конечно, очень интересно услышать ответ в блоге команды `CLR`…
#### Выводы
Я бы никогда не нашел этот подводный камень, еслибы у меня не было никаких тестов. Урок, который можно извлечь из этого сообщения — никогда не использовать ограничение `new()` если ваша цель — производительность приложения и если ваш код опирается на большое количество операций выделения новых объектов в Generic-типах.
Одним из самых сложных вопросов, на которых сложно знать точный ответ — это что будет делать компилятор с лямбда-выражением. В нашем варианте, компилятор не сильно заботится о производительности, и нам придется позаботиться о ней самим.
 | https://habr.com/ru/post/144193/ | null | ru | null |
# Добавление скриптинга в программу с помощью Lua
Lua это мощный, быстрый, легкий, встраиваемый язык сценариев. С его помощью можно легко и быстро добавить поддержку скриптинга в вашу программу.
Это может понадобиться в тех случаях, когда вы хотите дать возможность пользователям производить самостоятельную донастройку (кастомизацию) вашей программы, когда вы не хотите перекомпилировать весь проект, при внесении каких-либо изменений в логику работы программы, либо хотите разделить работу над движком и работу над логикой между разработчиками (например, при написании игр).
В этой статье, с помощью простой программы, я хочу показать пример встраивания Lua в ваш проект.
Примеров программ, которые используют Lua достаточно много. Далеко не полный список программ, использующих Lua, можно посмотреть здесь [Lua Wiki](http://lua-users.org/wiki/) и здесь [Wikipedia](http://en.wikipedia.org/wiki/Lua_%28programming_language%29#Applications)
Я приведу пример простой программы, которая принимает в качестве аргументов путь к директории, перечисляет файлы и подкаталоги, передает их в скрипт. Скрипт, с помощью регулярных выражений ищет соответствие в путях, передаваемых файлов и, если находит, переименовывает файл согласно определенным правилам.
Пример я создавал в Visual Studio под Windows. Несмотря на это, приведенный код, за исключением нескольких функций (перечисление файлов, переименование файла), специфичных для Windows, после небольшой адаптации будет работать и на других платформах, т.к. Lua является кроссплатформенным языком сценариев.
Начнем с того, что посетим [официальный сайт](http://www.lua.org/) и скачаем Lua для [своей платформы](http://luabinaries.luaforge.net/download.html). Для Windows подойдет вот [этот архив](http://luabinaries.luaforge.net/download.html), включающий в себя библиотеки линковщика, динамические библиотеки и заголовочные файлы Lua.
Распаковываем, указываем в настройках Visual Studio пути к заголовочным файлам и библиотекам линковщика (*Tools -> Options -> Projects and Solutions -> VC++ Directories*).
Если кратко, по шагам, то добавление Lua скриптинга в проект происходит в несколько шагов:
* Добавление в проект заголовочных файлов и библиотеки компоновщика
* Инициализация виртуальной машины Lua
* Реализация и регистрация экспортируемых функций
Создадим консольный проект. Назвать его можно как угодно. Первым делом добавим заголовочные файлы:
> `extern "C"
>
> {
>
> #include
>
> #include
>
> #include
>
> }`
Почему extern «C»? Lua написан на ANSI C, если попытаться включить файлы без extern «C» то мы получим множество ошибок, таких как:
> `unresolved external symbol "char const * __cdecl lua_tolstring(struct lua_State *,int,unsigned int *)" (?lua_tolstring@@YAPBDPAUlua_State@@HPAI@Z)`
Это вызвано тем, что соглашения о вызовах в C отличаются от соглашений в C++.
Не забудем подключить библиотеку линковщика:
> `#pragma comment(lib, "lua51.lib")`
Теперь необходимо объявить и инициализировать экземпляр Lua интерпретатора.
> `// Объявляем
>
> lua_State *g_LuaVM = NULL;
>
>
>
> int _tmain(int argc, _TCHAR* argv[])
>
> {
>
> // Инициализируем экземпляр
>
> g_LuaVM = lua_open();
>
> ...
>
> // Закрываем
>
> lua_close(g_LuaVM);
>
> }`
Теперь нам необходимо объявить и реализовать две функции, которые будут вызываться из Lua. Первая будет искать соответствие имени файла регулярному выражению:
> `int LuaMatchString(lua_State *luaVM)`
Вторая — переименовывает файл:
> `int LuaRenameFile(lua_State *luaVM)`
Остановимся подробнее на реализации второй:
> `// В качестве параметров принимает текущий путь к файлу и новое имя файла
>
> // В случае успеха возвращает 1, иначе 0
>
> int LuaRenameFile(lua_State *luaVM)
>
> {
>
> // Получаем число переданных из Lua скрипта аргументов
>
> int argc = lua_gettop(luaVM);
>
>
>
> // Если аргументов меньше двух - возвращаем ошибку
>
> if(argc < 2)
>
> {
>
> cerr << "RenameFile - wrong number of arguments!" << endl;
>
> // Вернем 0 в Lua скрипт
>
> lua_pushnumber(luaVM, 0);
>
>
>
> // Количество возвращаемых значений
>
> return 1;
>
> }
>
>
>
> // Проверяем типы аргументов, если это не строки
>
> // возвращаем 0 (признак ошибки)
>
> if(!lua_isstring(luaVM, 1) || !lua_isstring(luaVM, 2))
>
> {
>
> cout << "RenameFile - invalid arguments!" << endl;
>
> lua_pushnumber(luaVM, 0);
>
>
>
> // Количество возвращаемых значений
>
> return 1;
>
> }
>
>
>
> // Получаем значение первого аргумента, путь к файлу
>
> // Обратите внимание - индекс первого элемента - 1, а не 0, как принято в С++
>
> string strSource = lua_tostring(luaVM, 1);
>
> // Получаем значение второго аргумента, новое имя файла
>
> string strDestination = lua_tostring(luaVM, 2);
>
>
>
> strDestination = strSource.substr(0, strSource.rfind('\\') + 1) + strDestination;
>
>
>
> int nResult = (int)::MoveFileEx(strSource.c_str(), strDestination.c_str(), MOVEFILE_REPLACE_EXISTING|MOVEFILE_WRITE_THROUGH);
>
>
>
> // Возвращаем в Lua скрипт результат выполнения MoveFileEx
>
> lua_pushnumber(luaVM, nResult);
>
>
>
> // Количество возвращаемых значений
>
> return 1;
>
> }`
Как видно — ничего сложного: проверяем количество переданных аргументов, проверяем тип аргументов, извлекаем, выполняем переименование файла и возвращаем результат.
Теперь нам необходимо дать Lua знать, о экспортируемых функциях, делается это просто:
> `lua_register(g_LuaVM, "RenameFile", LuaRenameFile);
>
> lua_register(g_LuaVM, "MatchString", LuaMatchString);`
*RenameFile* и *MatchString* это имена функций, которые будут «видны» в скрипте.
Создадим скрипт, выполняющий всю работу:
> `-- Вызывается для обработки имени файла
>
> -- В качестве параметра передается полный путь к файлу
>
> -- и да, -- это комментарии в Lua
>
> function onFileFound(fileName)
>
> patt = MatchString('103([0-9]{1,12}).txt', fileName)
>
>
>
> -- Если совпадение найдено patt будет содержать
>
> -- найденно совпадение - ([0-9]{1,12})
>
> -- иначе nil
>
> if patt ~= nil then
>
> -- Переименовываем файл, заменяя 103 на XXX
>
> -- Пример: было 103180998.txt, станет XXX180858.txt
>
> RenameFile(fileName, 'XXX' .. patt .. '.txt')
>
> end
>
> end`
Чтобы совсем стало понятно, привожу кусок кода, который вызывает эту функцию
> `// Переместить на начало стека функцию onFileFound
>
> lua_getglobal(g_LuaVM, "onFileFound");
>
> // Поместить следующим элементом в стек путь к найденному файлу (fileName в скрипте)
>
> lua_pushstring(g_LuaVM, strFilePath.c_str());
>
>
>
> // Вызвать функцию onFileFound
>
> if(lua_pcall(g_LuaVM, 1, 0, 0) != 0)
>
> {
>
> // Проверить возвращенное значение,
>
> // если это не 0, сообщить об ошибке
>
> // lua\_tostring(g\_LuaVM, -1) содержит описание ошибки
>
> cerr << "Error calling function onFileFound: " << lua_tostring(g_LuaVM, -1) << endl;
>
> }`
Осталось только загрузить скрипт из нашей программы:
> `BOOL LoadScript()
>
> {
>
> // Получение полного пути к скрипту
>
> CHAR szScriptPath[1024] = {0};
>
> GetModuleFileName(NULL, szScriptPath, _countof(szScriptPath) - 1);
>
> TCHAR *szSlashPos = strrchr(szScriptPath, '\\');
>
> if(szSlashPos != NULL)
>
> {
>
> szScriptPath[szSlashPos - szScriptPath + 1] = '\0';
>
> }
>
> strcat_s(szScriptPath, _countof(szScriptPath), _T("script.lua"));
>
>
>
> // Загружаем скрипт
>
> int s = luaL_loadfile(g_LuaVM, szScriptPath);
>
>
>
> // Если результат загрузки не 0 - произошла ошибка
>
> // lua\_tostring(g\_LuaVM, -1) содержит описание ошибки
>
> if(s != 0)
>
> {
>
> cout << "Error while loading script file!" << endl << "Error: " << lua_tostring(g_LuaVM, -1) << endl;
>
>
>
> return FALSE;
>
> }
>
>
>
> // Выполняем крипт
>
> s = lua_pcall(g_LuaVM, 0, LUA_MULTRET, 0);
>
>
>
> return TRUE;
>
> }`
Как видно встраивание Lua скриптинга в программу является, по сути, тривиальной задачей и вместе с тем дает широкое поле для творчества.
[Исходники проекта](http://intelloware.com/download/lua/luarenamer.zip)
Ниже приведен список ресурсов, на которых можно почитать о Lua более подробно.
[Официальный сайт](http://www.lua.org)
[Live Demo](http://www.lua.org/cgi-bin/demo)
[Русская документация](http://www.lua.ru/doc/)
[Я люблю Lua. I love Lua](http://ilovelua.narod.ru/)
[Создание встраиваемых сценариев на языке Lua](http://www.ibm.com/developerworks/ru/library/l-lua/) | https://habr.com/ru/post/74382/ | null | ru | null |
# Salesforce Apex – как первый язык программирования. Плюсы и минусы
Моим первым языком программирования стал Apex. Это Java-подобный язык, который автоматизирует backend-логику в приложения на платформе [Salesforce.com](https://www.salesforce.com/).
Нельзя сказать, что я до этого не был знаком с ООП или другими языками. Мое знакомство ограничивалось теоретическими знаниями, полупройденными курсами на [Codecademy](https://www.codecademy.com/)или лабораторными работами в институте. Естественным образом все тонкости технологии, синтаксис языка, его возможности и ограничения быстро выветривались из памяти, поскольку практического применения этим навыкам я не находил.
В 2019 году я пришёл в Accenture как специалист по поддержке и доработке CRM Salesforce. Диапазон задач сначала был очерчен недостаточно чётко, поэтому я стал изучать инструменты как администрирования, так и разработки на Salesforce.
Сейчас мой опыт разработки на Apex около года, я стал сертифицированным разработчиком Salesforce. Могу подвести первые итоги.
Будет полезно для:
* новичков в программировании
* администраторов Salesforce, которые хотят освоить разработку
* опытных разработчиков, которые хотят узнать о разработке на платформе Salesforce
Ниже я кратко приведу все плюсы и минусы Apex, с точки зрения выбора его как языка для обучения. Затем подробнее рассмотрю каждый пункт.
Плюсы Apex:
-----------
1. Apex приучает к написанию оптимального, ресурсоэффективного кода
2. Apex приучает к юнит-тестированию и к test-driven разработке
3. Apex имеет единую и обновляемую документацию, собранную на портале Salesforce
4. Apex имеет out-of-the-box доступ к БД (не нужно писать коннекторов)
5. Apex – это на 90% Java. Вы с легкостью сможете понимать Java-код после разработки на Apex
6. Salesforce поставляет собственную онлайн IDE Developer Console, которая позволяет новичку быстро начать программировать без погружения в мир кастомных IDE
7. Apex можно осваивать в Trailhead-песочницах, без установки и настройки дополнительного софта.
8. Trailhead обучает программированию на Apex с полного нуля. Trailhead-модули обучают вас концепциям ООП и синтаксису Apex на языке простых смертных (к сожалению, только на английском)
Минусы Apex:
------------
1. Мало материалов на русском языке (почти нет)
2. Немногочисленное русскоязычное сообщество
3. Применимость только для продуктов на платформе Salesforce
Apex приучает к написанию оптимального, ресурсоэффективного кода
----------------------------------------------------------------
Ресурсоэффективный код в Apex – это не блажь и не рекомендация, а почти необходимое условие. Поскольку Salesforce – это облачная платформа, программные ресурсы у каждого клиента платформы ограничиваются лицензией. Иными словами, ресурсы, которые есть у вас в распоряжении, как разработчика, ограничены [лимитами Salesforce](https://developer.salesforce.com/docs/atlas.en-us.salesforce_app_limits_cheatsheet.meta/salesforce_app_limits_cheatsheet/salesforce_app_limits_platform_apexgov.htm).
Код, исполнение которого нарушает лимиты, приведет к системной ошибке и откату транзакции. По этой причине у Salesforce есть [рекомендации](https://developer.salesforce.com/page/Apex_Code_Best_Practices), которых нужно придерживаться, чтобы писать оптимальный код.
Этот пункт я считаю плюсом Apex, поскольку вы с самого начала привыкаете писать оптимальный код, который экономно распоряжается облачными ресурсами. Это формирует полезный для разработчика способ мыслить.
Apex приучает к юнит-тестированию и к test-driven разработке
------------------------------------------------------------
Покрытие кода юнит-тестами на 75% – обязательное условие для переноса этого кода на PROD-среду. Поэтому вы с самого начала учитесь создавать тест-классы. Это полезный навык – менять ментальный ракурс, с которого вы смотрите на свой код, таким образом, чтобы написать тест.
Salesforce в этом вопросе идет дальше и пропагандирует при разработке начинать с написания юнит-тестов. Это помогает лучше осознать все пользовательские сценарии, которые должен обрабатывать ваш будущий код. Поэтому Apex, как первый язык программирования, не оставляет вам выбора: вы сразу учитесь лучшим практикам и осознанному подходу к процессу разработки.
#### Пример класса и тест-класса в Apex
Класс:
```
public class TVRemoteControl {
// Volume to be modified
Integer volume;
// Constant for maximum volume value
static final Integer MAX_VOLUME = 50;
// Constructor
public TVRemoteControl(Integer v) {
// Set initial value for volume
volume = v;
}
public Integer increaseVolume(Integer amount) {
volume += amount;
if (volume > MAX_VOLUME) {
volume = MAX_VOLUME;
}
return volume;
}
public Integer decreaseVolume(Integer amount) {
volume -= amount;
if (volume < 0) {
volume = 0;
}
return volume;
}
public static String getMenuOptions() {
return 'AUDIO SETTINGS - VIDEO SETTINGS';
}
}
```
Тест-класс:
```
@isTest
class TVRemoteControlTest {
@isTest static void testVolumeIncrease() {
TVRemoteControl rc = new TVRemoteControl(10);
Integer newVolume = rc.increaseVolume(15);
System.assertEquals(25, newVolume);
}
@isTest static void testVolumeDecrease() {
TVRemoteControl rc = new TVRemoteControl(20);
Integer newVolume = rc.decreaseVolume(15);
System.assertEquals(5, newVolume);
}
@isTest static void testVolumeIncreaseOverMax() {
TVRemoteControl rc = new TVRemoteControl(10);
Integer newVolume = rc.increaseVolume(100);
System.assertEquals(50, newVolume);
}
@isTest static void testVolumeDecreaseUnderMin() {
TVRemoteControl rc = new TVRemoteControl(10);
Integer newVolume = rc.decreaseVolume(100);
System.assertEquals(0, newVolume);
}
@isTest static void testGetMenuOptions() {
// Static method call. No need to create a class instance.
String menu = TVRemoteControl.getMenuOptions();
System.assertNotEquals(null, menu);
System.assertNotEquals('', menu);
}
}
```
Apex имеет единую и обновляемую документацию, собранную на портале Salesforce
-----------------------------------------------------------------------------
Salesforce развивает Apex как основной язык для разработки на своей проприетарной платформе, поэтому все обновления и вся документация содержатся на едином официальном портале [Apex Developer Guide](https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_dev_guide.htm).
На ней собраны все системные классы и методы, подробно описано их назначение и применение. Можно найти однозначный ответ на большинство вопросов. А вопросов при обучении всегда много.
Apex имеет out-of-the-box доступ к базе данных
----------------------------------------------
Большим плюсом для начинающего разработчика Apex считаю простоту обращения в базу данных из кода. В базу данных можно обратиться из любого места в коде, для этого не нужно дополнительных настроек и соединений.
Вот несколько примеров обращения к базе данных из кода:
```
Account A = new Account(Name='xxx');
insert A;
Account B;
// A simple bind
B = [SELECT Id FROM Account WHERE Id = :A.Id];
// A bind with arithmetic
B = [SELECT Id FROM Account
WHERE Name = :('x' + 'xx')];
String s = 'XXX';
// A bind with expressions
B = [SELECT Id FROM Account
WHERE Name = :'XXXX'.substring(0,3)];
// A bind with an expression that is itself a query result
B = [SELECT Id FROM Account
WHERE Name = :[SELECT Name FROM Account
WHERE Id = :A.Id].Name];
Contact C = new Contact(LastName='xxx', AccountId=A.Id);
insert new Contact[]{C, new Contact(LastName='yyy',
accountId=A.id)};
// Binds in both the parent and aggregate queries
B = [SELECT Id, (SELECT Id FROM Contacts
WHERE Id = :C.Id)
FROM Account
WHERE Id = :A.Id];
// One contact returned
Contact D = B.Contacts;
// A limit bind
Integer i = 1;
B = [SELECT Id FROM Account LIMIT :i];
// An OFFSET bind
Integer offsetVal = 10;
List offsetList = [SELECT Id FROM Account OFFSET :offsetVal];
// An IN-bind with an Id list. Note that a list of sObjects
// can also be used--the Ids of the objects are used for
// the bind
Contact[] cc = [SELECT Id FROM Contact LIMIT 2];
Task[] tt = [SELECT Id FROM Task WHERE WhoId IN :cc];
// An IN-bind with a String list
String[] ss = new String[]{'a', 'b'};
Account[] aa = [SELECT Id FROM Account
WHERE AccountNumber IN :ss];
```
Apex – это на 90% Java. Вы с легкостью сможете понимать Java-код после разработки на Apex
-----------------------------------------------------------------------------------------
Salesforce создавала Apex на основе синтаксиса Java. Есть небольшие исключения, обусловленные спецификой Salesforce. Все отличия собраны [на этой странице](https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_classes_java_diffs.htm ).
Но, если посмотреть на методы работы с примитивами и коллекциями, то они работают аналогично Java.
Сравните, к примеру, методы работы со [String в Apex](https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_methods_system_string.htm) и [String в Java](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html).
Выходит, что обучаясь Apex вы во многом обучаетесь и Java. Это правило работает и наоборот.
Если вы решите перейти в Java-разработчики, вам не придется начинать с нуля. А полезные парадигмы мышления из Apex-разработки дадут вам хороший фундамент для написания ресурсоэффективного Java-кода.
Salesforce поставляет собственную онлайн IDE Developer Console
--------------------------------------------------------------
Developer Console позволяет новичку быстро начать программировать без погружения в мир кастомных IDE.
Я помню, как раньше делал попытки самостоятельно учить Python, C#. И начинать нужно было с установки IDE, ее настройки. Разобраться, как работает эта IDE – отдельная история. Много папок, много кнопок, много пунктов меню, много панелей. Это было серьёзным барьером на пути начинающего разработчика.
С Apex ничего подобного не было, поскольку любой инстанс Salesforce содержит в себе встроенную IDE, которая называется Developer Console. Устанавливать ничего не нужно, достаточно открыть в браузере Developer Console и сразу писать код. Код можно запустить сразу и проверить его работу в реальном (или «песочном») приложении.
Да, более опытные разработчики Salesforce предпочитают работать в Visual Studio Code или Eclipse, но для начинающих Developer Console – то, что нужно.
Developer Console выглядит так:
Apex можно осваивать в Trailhead-песочницах, без установки и настройки дополнительного софта
--------------------------------------------------------------------------------------------
Salesforce разработал собственную платформу для обучения – [trailhead.salesforce.com](https://trailhead.salesforce.com/ ). Она великолепна геймификацией процесса обучения и тем, что создавать тестовые среды можно непосредственно со страницы практического задания:
В рамках обучения можно иметь одновременно до 10 (!) активных песочниц. Песочницы можно удалять и создавать новые для каждой следующей задачи, а можно работать в одной песочнице по нескольким заданиям сразу. Любая новая песочница создаётся с уже предзаполненными данными, чтобы вы могли сразу начать эксперементировать и не тратить время на заполнение тестовыми данными.
Trailhead обучает программированию на Apex с полного нуля
---------------------------------------------------------
В Trailhead множество обучающих модулей и «троп» (последовательностей модулей). Главный плюс для начинающего в том, что для обучения программированию можно выбрать «тропу», которая предназначена для учеников с нулевым опытом или только с админским опытом. В таком случае обучение начнется с самых основ ООП, а в качестве примеров будет использоваться Apex-код.
Примеры обучающих модулей по разработке на Apex для администраторовВсе модули Trailhead написаны на английском языке. Авторы модулей стараются максимально просто описывать концепции, поэтому языковой барьер быстро перестает чувствоваться.
Текст часто снабжается забавными примерами и просто шутками. Типичный пример на рисунке ниже:
В изучении Apex есть и минусы. Ниже рассмотрю их подробнее.
Мало материалов на русском языке (почти нет)
--------------------------------------------
На русский язык не переведены такие официальные ресурсы, как:
1. [Trailhead](https://trailhead.salesforce.com/ )
2. [Apex Developer Guide](https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_dev_guide.htm)
Это затрудняет обучение ребятам, которые не знают английский язык.
Немногочисленное русскоязычное сообщество
-----------------------------------------
Количество разработчиков из России и СНГ относительно небольшое, поэтому достаточно трудно найти блоги и обсуждение Apex на русском языке. Вот, например, как выглядят профессиональные сообщества Salesforce-специалистов ВКонтакте
Надо заметить, что в Беларуси разработка на Salesforce стремительно популяризуется. В русскоязычном Youtube появляется всё больше качественных видео про Salesforce и Apex ([пример](https://youtu.be/i4amvO9IaYQ)). Количество специалистов растёт, но работы всё ещё больше, чем людей.
Этот минус можно конвертировать в преимущество вас как специалиста на рынке труда. Чем меньше специалистов, тем они дороже.
Применимость только для продуктов на платформе Salesforce
---------------------------------------------------------
В отличие от Java, Python и других кроссплатформенных языков, Apex может использоваться только для разработки на платформе Salesforce.com. Несмотря на многообразие продуктов Salesforce, вы ограничены этим стеком.
Заключение
----------
Apex прекрасно подходит для обучения программированию. Правила и рекомендации Salesforce с самого начала научат вас лучшим практикам ООП, которые применимы к коду на любом другом языке.
Однако, лучше посмотреть в сторону других языков для старта, если:
* Вы не планируете профессионально развиваться в качестве специалиста Salesforce;
* Вы плохо владеете английским языком. Это затруднит вам изучение любого языка программирования, но Apex - в особенности. | https://habr.com/ru/post/536814/ | null | ru | null |
# TypeScript: не выходите за рамки
О том, как снизить риск дефектов программы на TypeScript, величину технического долга проекта и, одновременно, улучшить читаемость кода TypeScript.
### Фабрика кэша
Вычислив объект, нужный для работы программы, вы сталкиваетесь с характерным рисунком своих желаний: значение хочется отложить в сторонку, чтобы в следующий раз не вычислять его снова, а воспользоваться прошлыми успехами.
Этот рисунок в коде превращается в кэш. Когда-то правильнее воспользоваться сторонними пакетами с готовой реализацией кэша, с большим количеством полезного сервиса, а иногда проще сделать свои четыре строки. Вот тут ключом к значению может быть целое число, а хранилищем для кэша - массив.
```
const createCache = ()=>{
const items:T[] = [];
return {
getItem: (key:number)=>items[key],
setItem: (key:number, item:T)=>{items[key]=item;},
};
};
```
Обратитесь [к песочнице](https://www.typescriptlang.org/play?jsx=0&ssl=10&ssc=1&pln=9&pc=1#code/MYewdgzgLgBMBOBTAhlRBhZwAWiYF4YAeAFQD4AKASnzIG8BYAKBjnGhgEs0BbCALhIBtALoEYogNzNWSKAFd4YGIxasYAc0RQAkr34wKAa0QBPfmHk8ARong0y3RHyEnTIgDQz1EbXucGxmYWVrbwHlz6JA50Ti5uIvhxkgC+Xmop0kyZzMygkLB0Wrq8Eb4lziniCChomDiIRNDwnGAalFRZQA) и выясните каким образом TypeScript типизирует результат создания кэша.
```
const {getItem, setItem} = createCache();
```
В частности getItem имеет тип `(key: number) => string`. Правда ли что в кэше всегда есть нужное нам значение? Нет! Ведь значение в кэш нужно еще положить. До этого момента результат `getItem` не возвращает строку.
В контексте задачи про кэш недостаток TypeScript достаточно очевиден. Мы ожидаем неверный тип значения извлеченного по индексу. Эта особенность не изобретение TypeScript, а является наследством JavaScript. Многие языки при попытке доступа за пределы массивы выдают исключение, но не JavaScript.
Быть может ошибочное суждение о типе результата доступа по индексу характерно для TypeScript только в отношении массива? Посмотрим.
### Индекс ассоциативного массива (чисто объекта)
Решение использовать массив в качестве хранилища для кэша, как минимум, странно, согласен. Привычнее видеть строку в качестве ключа. С такой реализацей вы можете познакомится в [следующей песочнице](https://www.typescriptlang.org/play?jsx=0&noUncheckedIndexedAccess=true#code/JYOwLgpgTgZghgYwgAgCLAWYB7EcoCeAPACoB8yA3gLABQyyA2pFALYBcyAzmFKAOYBdTiQDcdAL50EuHsgRQIcSAGFEACxQBeZKTIAKAJRayNevNlhkwSKy7t0mHHkJ7kOyhPHnFYAK5QIFR0DAz8EGAAkrac+gDWEATsPHwg-MZkNhB2jAkEggA0IaFcEdHZsXnJvAIF1jEkGZRZOXmCWi2iEkXmXpLe0pZU4VG2daWj2RLu8orKEGoImkQpAgaG3kA).
```
interface Dictionary {
[term: string]: T;
}
const createCache = ()=>{
const items:Dictionary = {};
return {
getItem: (key:string)=>items[key],
setItem: (key:string, item:T)=>{items[key]=item;},
};
};
const {getItem, setItem} = createCache();
```
И все равно getItem, по мнению TypeScript, возвращает строку.
### Риск дефекта
Уже два примера убеждают нас, что TypeScript где-то не дорабатывает. Как компилятор, так и сервисы в редакторе, в один голос твердят, что результатом работы функции `getItem` будет строка. Мы, поверив компилятору, попытаемся работать с неинициализированным значением дальше и, рано или поздно, наткнемся на ошибку во время исполнения. Ошибка-то будет где-то у клиента. Пойди, найди причину!
### Ручное управление
Выход есть. [Вот решение](https://www.typescriptlang.org/play?jsx=0#code/MYewdgzgLgBMBOBTAhlRBhZwAWiYF4YAeAFQD4AKASgLJgG8BYAKBjnGhgEs0BbCAFwwSAbQC6BGOIDcLNkigBXeGAZy2MAOaIoAST5CKAa0QBPIWEW8ARong18dHon4iTpicgjCYAHxiKYAAmiABmXGCIQQA06mwQOvouhu4WVrbw0dwGwg509NkuEG5mEoTOvNIwAL6xrDWyzNWNLKCQsAXaenxZCd0uNZIIKGiYOIhE0PARmpRUjUA) проблемы типа значения, полученного по индексу. Действительно, аннотации типа и утверждения о типах никто не отменял.
```
const createCache = () => {
const items: T[] = [];
return {
getItem: (key: number) => items[key] as T | undefined,
setItem: (key: number, item: T) => { items[key] = item; },
};
};
const { getItem, setItem } = createCache();
```
> **Замечание**. в отличие от c#, например, в TypeScript утверждение типа `as *type*` не влечет за собой никаких накладных расходов во время [исполнения программы](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#type-assertions). Этот оператор используется на этапе статического анализа кода и просто удаляется после компиляции. В результирующую программу он не попадает.
>
>
В отрывке приведенном ниже, сразу после инициализации считается, что переменная item содержит значение типа `string | undefined`. Нам приходится провести проверку полученного значения, тем самым устранить риск дефекта.
TypeScript дальше проявляет свою сообразительность и понимает, методом исключения, раз не undefined, значит string и [радостно компилирует](https://www.typescriptlang.org/play?jsx=0#code/MYewdgzgLgBMBOBTAhlRBhZwAWiYF4YAeAFQD4AKASgLJgG8BYAKBjnGhgEs0BbCAFwwSAbQC6BGOIDcLNkigBXeGAZy2MAOaIoAST5CKAa0QBPIWEW8ARong18dHon4iTpicgjCYAHxiKYAAmiABmXGCIQQA06mwQOvouhu4WVrbw0dwGwg509NkuEG5mEoTOvNIwAL6xrDWyzNWNLKCQsAXaenxZCd0uNZIIKGiYOIhE0PARmpRULcxtnBWSXUm8FAAM8yxcoRRQpgAOiCChhbwwAIT4hABEgSHhkUF3VEz1SyAANogAdN8QJoKBU-lAQABVI4neCYBLUHZNFhAA) программу без ошибок.
```
const { getItem, setItem } = createCache();
const item = getItem(0);
if(typeof item !== "undefined"){
console.log(item.toUpperCase());
}
```
Но мы можем поступить лучше.
### Флаги строгости: noUncheckedIndexedAccess
Компилятор tsc TypeScript-а управляется флагами из tsconfig.json. Cреди прочих флагов есть флаги "строгости". Для включения многих из них достаточно указать флаг strict. Установка этого флага неявно включает, в частности, все флаги, имена которых начинаются со слова strict.
Флаг `noUncheckedIndexedAccess` включается отдельно. Но когда он включен, TypeScript автоматически объединяет тип значения, полученного доступом по индексу, и тип `undefined`, таким образом заставляя нас перепроверить наличие полезного значения каждый раз, когда мы извлекаем что-то через квадратные скобки.
[В этой песочнице](https://www.typescriptlang.org/play?noUncheckedIndexedAccess=true&jsx=0#code/MYewdgzgLgBMBOBTAhlRBhZwAWiYF4YAeAFQD4AKASnzIG8BYAKBjnGhgEs0BbCALhIBtALoEYogNzNWSKAFd4YGIxasYAc0RQAkr34wKAa0QBPfmHk8ARong0y3RHyEnTIgDQz1EbXucGxmYWVrbwHlz6JA50Ti5uIvhxkgC+Xmop0kyZzMygkLB0Wrq8Eb4lziniCChomDiIRNDwnGAalFRZQA), на закладке TSConfig установлен флаг noUncheckedIndexedAccess и как результат, тип функции getItem магически улучшился до: `(key: number) => string | undefined`. Ручная настройка определения функции не потребовалась.
### В сухом остатке
Разработка программы для повседневного использования, а не для игры в песочнице, часто сопровождается накоплением технического долга. В погоне за скоростью, разработчик может принять решение позднее вернуться к коду и добавить аннотацию типа `T | undefined`. И, конечно, не возвращается, пока не придет время исправлять обнаруженный заказчиком дефект.
Правильное использование возможностей компилятора позволяет в таких случаях снизить технический долг. Дополнительно, разработчик не загромождает код аннотациями типов, что улучшает читаемость текста. А как известно, исходные коды большую часть времени читают, а не пишут.
---
И, вот когда с типами все стало лучше, пользователь отправил в кэш значение с ключом (-1)... Как быть, ведь в TypeScript нет безнаковых целых чисел?... Об этом в следующий раз. | https://habr.com/ru/post/654241/ | null | ru | null |
# Как генерировать правильную подпись (SIG) в API OK.RU. Работаем с ошибкой 104
Не так давно я столкнулся с трудностью. У меня не получалось при запросе по API в OK.RU (одноклассники) создать правильную SIG (ошибка 104). Как оказалось, я не единственный такой был, предлагаемые в сети рецепты не очень работали (проверил многие методом тыка). На самом деле работали, просто я не понимал, как правильно построить нужный запрос, чтобы ещё и SIG был правильным.
Конкретно, этот пост посвящен именно 104 ошибке API OK.RU.
```
PARAM_SIGNATURE 104 Неверная подпись
```
Ниже простенький код для получения списка альбомов. Код немного костыльный (для себя я написал нужный класс, но он специфический и мало кому пригодится), но описывает суть, а многие начинающие программисты могут на основе примера создать свой собственный класс.
```
protected $params = array(
'application_id' => '5*******6',
'application_key' => 'C***********A',
'session_secret_key' => '*************0'
);
protected $apiUrl = 'https://api.ok.ru/fb.do?';
public function getalbums( Request $request ) {
//access_token я записываю в БД и вытаскиваю его оттуда.
$userok = Userok::where('useroks.user_id', '=', $request->user_id)->first();
$paramsArray = array(
'application_key' => $this->params['application_key'],
'format' => 'json',
'method' => 'photos.getAlbums',
);
ksort($paramsArray);
foreach($paramsArray as $k=>$v) {
$paramsStr .= $k . "=" . $v;
}
/*** Отредактировано уже в статье. Это кусок кода, как делать не надо (в первой редакции забыл закоментировать).
$sig = strtolower(
md5(
$paramsStr)
. md5(
$userok->access_token
.$this->params['session_secret_key']
)
);
**/
$sectret_key = md5($userok->access_token.$this->params['session_secret_key']);
$sig = md5($paramsStr.$sectret_key);
$paramsArray['sig'] = $sig;
$paramsArray['access_token'] = $userok->access_token;
return $this->sendRequest(
$this->apiUrl,
$paramsArray,
'POST'
);
}
protected function sendRequest($url = '', $params = array(), $method = 'POST') {
if(is_array($params)) {
$params = http_build_query($params);
}
$ch = curl_init();
if($method == 'GET') {
$url .= $params;
} else if($method == 'POST') {
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $params);
}
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
$result = curl_exec($ch);
curl_close($ch);
return json_decode($result, true);
}
```
Но чтобы это работало, нужен правильный $paramsArray, иначе Вы решите 104-ю ошибку, но получите другую. Многие начинающие программисты, наверняка, игнорируют старания OK.RU помочь разработчикам.
Итак, переходим по ссылке **<https://apiok.ru/dev/methods/>**.
Находим вот такую форму:
Заполняем нужными данными и получаем по сути готовую инструкцию, а вдобавок тестируем свой запрос.
Надеюсь, статья была полезной. | https://habr.com/ru/post/468315/ | null | ru | null |
# Корректное завершение работы pod’ов в Kubernetes-кластере
*Корректное завершение работы контейнеров в Kubernetes*
Это вторая часть [нашего пути](https://habr.com/ru/company/nixys/blog/489164/) (прим. пер. — ссылка на первую статью) к достижению нулевого времени простоя при обновлении Kubernetes-кластера. В первой части мы изложили проблемы и задачи, возникающие при выполнении операции drain для нод в кластере. В этом посте мы расскажем, как решить одну из таких проблем: корректно завершить работу pod’ов.
Жизненный цикл переселения pod’а
--------------------------------
По умолчанию `kubectl drain` при выселении pod’ов учитывает схему их жизненного цикла. На практике это означает, что он будет действовать по следующей схеме:
* `drain` создаст запрос на удаление pod’ов на выбранной ноде в control plane. Это впоследствии уведомит `kubelet` на выбранной ноде, чтобы он начал завершать работу pod’ов.
* `kubelet` на ноде запустит в pod’е хук `preStop`
* как только хук `preStop` завершится, `kubelet` на ноде подаст сигнал `TERM` работающему приложению в контейнере pod’а.
* `kubelet` на ноде будет ждать определенный период (определенный в pod’е, или заданный из командной строки; по умолчанию это 30 секунд) пока контейнер выключится, прежде чем принудительно убить процесс (через `SIGKILL`). Запись о времени ожидания включает в себя время для выполнения `preStop` хука.
Согласно данной схеме, можно задействовать `preStop` хук и подать сигнал для завершения работы, чтобы приложение смогло “сделать очистку” и завершиться корректно. Например, если у вас есть работающий процесс, отслеживающий задачи в очереди, ваше приложение может перехватить сигнал `TERM`, и воспринять его как указание для того, чтобы перестать принимать для выполнения новые задачи и завершиться, после того, как все задачи будут выполнены. Или, если ваше приложение нельзя модифицировать, чтобы оно перехватывало `TERM` сигнал (например, какое-либо стороннее приложение), тогда вы можете использовать `preStop` хук для реализации API, который бы предоставил возможность корректного завершения работы приложения.
В нашем примере Nginx по умолчанию не завершится корректно при подаче сигнала `TERM`, потому что существующие обращения к нему завершатся с ошибкой. Поэтому мы будем использовать для корректного завершения `preStop` хук. Мы модифицируем наш resource и добавим этап `lifecycle` в спецификацию контейнера. Этап `lifecycle` выглядит следующим образом:
```
lifecycle:
preStop:
exec:
command: [
# Gracefully shutdown nginx
"/usr/sbin/nginx", "-s", "quit"
]
```
Согласно этой настройке, при выключении, перед тем как отправить сигнал `SIGTERM` в контейнер с Nginx будет выполнена команда `/usr/sbin/nginx -s quit`. Обратите внимание, что, поскольку команда корректно завершит процесс Nginx и сам pod, сигнал `TERM` по факту становится noop (ничего не делает — прим.переводчика).
Данная настройка прописывается в спецификации контейнера Nginx. Когда мы добавим её, полный конфиг для `Deployment` будет выглядеть следующим образом:
```
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-deployment
labels:
app: nginx
spec:
replicas: 2
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.15
ports:
- containerPort: 80
lifecycle:
preStop:
exec:
command: [
# Gracefully shutdown nginx
"/usr/sbin/nginx", "-s", "quit"
]
```
Обслуживание трафика после выключения pod’а
-------------------------------------------
При корректном выключении pod’а должна обеспечиваться остановка Nginx таким образом, чтобы обслужить текущий трафик перед выключением. В любом случае, как вы могли заметить, несмотря на благие намерения, контейнеру с Nginx продолжает поступать трафик после его отключения, создавая время простоя в работе вашего сервиса.
Чтобы понять всю сложность ситуации, давайте взглянем на пример с нашим deployment. Для примера, рассмотрим, что нода приняла клиентский трафик. При этом внутри нее запустится процесс обработки запроса. Обозначим этот процесс кружком в контейнере pod’а.
Предположим, что в этот момент оператор кластера решает провести работы на Node 1. В рамках этой задачи оператор запускает команду `kubectl drain node-1`, в результате чего процесс `kubelet` на узле выполняет хук `preStop`, запуская команду для корректного завершения работы процесса Nginx:
Так как nginx все ещё обрабатывает исходный запрос, его процесс не завершается сразу. Однако, когда nginx начинает последовательное завершение работы, он начинает выдавать ошибки и отклоняет дополнительный трафик, который к нему приходит.
Предположим, в этот момент на наш сервис пришел новый запрос. Так как сервис все еще видит этот pod, он все ещё может принимать трафик. Если он его примет, то вернет ошибку, потому что nginx завершает работу:
Чтобы завершить процедуру выключения, в конечном итоге nginx завершит обработку исходного запроса, который завершит работу pod’а и на ноде будет выполнена операция `drain`:
В этом примере, в случае, если приложение в pod’е получает запрос после запуска его отключения, первый клиент получит ответ от сервера. Однако, второй клиент получит ошибку, которая будет восприниматься как время простоя.
Так почему это происходит? И как можно уменьшить потенциальное время простоя для клиентов, которые выполняют запрос к серверу в момент, когда он начинает выключаться? В [следующей части нашего цикла](https://habr.com/en/company/nixys/blog/490380/), мы будем подробно рассказывать о жизненном цикле выселении pod’а и описывать, как можно ввести задержку в `preStop` хуке так, чтобы смягчить последствия подачи непрерывного трафика от `Service`.
*Чтобы получить полностью внедренную и протестированную версию обновлений кластера Kubernetes для нулевого временем простоя на AWS и других ресурсах, посетите [Gruntwork.io](https://gruntwork.io/).*
Также читайте другие статьи в нашем блоге:
------------------------------------------
* [Blue-Green Deployment приложений на Spring c веб-сервером Nginx](https://habr.com/ru/company/nixys/blog/470568/)
* [Как запустить несколько пайплайнов с помощью GitLab CI/CD](https://habr.com/ru/company/nixys/blog/467107/)
* [/etc/resolv.conf для Kubernetes pods, опция ndots:5, как это может негативно сказаться на производительности приложения](https://habr.com/ru/company/nixys/blog/464371/)
* [Разбираемся с пакетом Context в Golang](https://habr.com/ru/company/nixys/blog/461723/)
* [Три простых приема для уменьшения Docker-образов](https://habr.com/ru/company/nixys/blog/437372/)
* [Traefik как Ingress-контроллер для K8S](https://habr.com/ru/company/nixys/blog/427655/) | https://habr.com/ru/post/489992/ | null | ru | null |
# DBX: попытка избавиться от составления MySQL запросов
Давным давно, когда я только начинал изучать PHP и тонкости составления запросов MySQL (2011 год) у меня возникла мысль написать обертку для MySQLi наподобие Doctrine для упрощения синтаксиса обращения к базе данных. На дворе уже 2019 и решил поделиться своим велосипедом на тему ORM.
И так, это DBX — движок базы данных MySQL для PHP на основе библиотеки MySQLi основанный на запросах вида структурного описания таблиц и полей базы данных в виде обычного массива с функцией статического кэширования запросов и автообновления хэша статики.
Вопреки всеобщей любви к PDO, была выбрана именно легковесная MySQLi функциональность, которая мягче и проще программируется и более лаконично вписывается в предложенное API DBX. Я даже не использовал composer, потому что у меня нет ни одного проекта, где я использую сторонние зависимости кроме самописных.
Собственно, рассмотрим пример объявления структуры простейшей тестовой базы данных и ее таблиц. Для начала подключим саму библиотеку с классом и отправим данные авторизации с хостом базы данных:
```
require_once './DBX.php';
$dbx_data = ['localhost', 'root', 'root', 'dbx_test', '8889'];
```
Теперь представим, что нам нужно описать и создать таблицу в БД используя синтаксис обычного массива PHP:
```
php
/**
* CREATE TABLE EXAMPLE
*/
$table_1 = 'example'; // table name
$query_1 = 'c'; // create table sql
$fields_1 = [
'field_id' = [
'type' => 'num', // int
'auto' => true, // auto increment
'length' => 255,
'fill' => true // not null
],
'field_text' => [
'type' => 'text', // varchar
'length' => 255,
'fill' => true
],
'field_date' => [
'type' => 'time', // TIMESTAMP
'value' => date('Y-m-d')
]
];
?>
```
Здесь синтаксис простой. Я не использовал строгую типизацию и выбрал просто значения TEXT, NUMBER и TYMESTAMP. Конечно же, для более «рульной» структуры таблицы используется ключевое поле ID с автоинкрементом (не встречал случаев в реальных проектах, когда задание автоинкремента и ключа мешает проектированию запросов и связей таблиц). Для указания может ли поле быть пустым указывается параметр fill => true.
Типы запросов DataBaseX очень просты и содержат основные методы вроде select, insert, delete, update, drop, truncate и так далее.
К примеру запрос для создания таблицы:
```
// perform queries
$dbx::query("c", $table_1, $fields_1);
```
Или запрос добавления данных и структуры столбцов может выглядеть вот так:
```
// fields values for table_1 example
$fields_2 = [
'field_id' => [
'value' => 456
],
'field_text' => [
'value' => 'I have to add into my table'
],
'field_date' => [
'value' => date('Y-m-d')
]
];
// perform queries
$dbx::query('i', $table_1, $fields_2);
```
Структура массива позволяет однажды описать базу данных и в последующем лишь манипулировать полями value для изменения данных, которые используются для формирования запросов.
Вот пример update инструкции, которую я упраздню в следующем примере:
```
// fields values for table_1 example
$fields_3 = [
'field_id' => [
'value' => 456
],
'field_text' => [
'new_value' => 'I was updated',
'criterion_field' => 'field_id',
'criterion_value' => 456
],
'field_date' => [
'value' => date('Y-m-d')
]
];
// perform queries
$dbx::query('u', $table_1, $fields_3);
```
Мне показалось, что использование полей criterion\_field и criterion\_value усложняет систему, поэтому я создал запрос, который автоматически либо добавляет данные в БД, если они еще не были созданы, либо обновляет существующие данные. Этот запрос я назвал INJECT QUERY и вызывается он префиксом «in»:
```
// fields values for table_1 example
$fields_2 = [
'field_id' => [
'value' => 0
],
'field_text' => [
'value' => 'Yo if field_id = 0 it\'s an insert or if id exists it\'s an update'
],
'field_date' => [
'value' => date('Y-m-d')
]
];
// perform queries
$dbx::query('in', $table_1, $fields_2);
```
Работает это на низком уровне так:
```
INSERT INTO `revolver__comments` (`field_id`, `field_content`)
VALUES ('5', 'TEST UPDATE')
ON DUPLICATE KEY UPDATE `field_id`='5', `field_content`='TEST UPDATE';
```
Все остальные запросы простейшие и описывать их не имеет смысла(смотрите примеры в файле тестов index.php), но я не могу не показать как работает запрос SELECT:
```
php
// perform queries
$dbx::query('s|field_id|asc|100|0', $table_1, $fields_1);
?
php
// print structure
print '<h2DBX STRUCTURE';
print '
```
';
print_r( $fields_1 );
print '
```
';
// print result
print 'DBX QUERY RESULT
----------------
';
print '
```
';
print_r( $dbx::$result );
print '
```
---
';
?>
```
```
```
Здесь с использованием префикса «s» можно сгруппировать параметры запроса **s|field\_id(*order*)|asc(*direction*)|100(*limit*)|0(*offset*)**.
Кроме прочего DBX обладает такой отличительностью, как встроенный файловый кэш на базе JSON статики. Каждый запрос изменения (INSERT, UPDATE, DELETE, TRUNCATE) вызывает пресчёт хэша в таблице хэшей кэша и автоматически обновляет статический кэш, что позволяет не думать о нагрузке на запросы SELECT.
В будущем я планирую до развить движок DBX и расширить возможности конструктора SQL запросов системой конфигурации UNION и JOIN, а также добавить новую из MySQL 8 поддержку базы данных на типе JSON структуры.
Сейчас DBX используется в моей системе управления контентом [RevolveR](https://github.com/xShiftx/RevolveR_CMS) и показывает неплохие характеристики (весь сайт при условии наличия обновленного кэша инициализируется одним запросом к БД и потребляет около 0.7 Mb оперативной памяти интерпретатора). А также мне очень удобно видеть всю структуру БД в одном отдельном файле, что в разы ускоряет наращивание и проектирование новых модулей.
**Репозиторий проекта: [DBX v1.1.1 на GitHub](https://github.com/xShiftx/Revolver_DBX).** | https://habr.com/ru/post/438762/ | null | ru | null |
# Инвентаризация в компании: Установка GLPI
Пришло время и в нашей компании провести учет компьютерной техники. Компания растет, расширяется, и памяти IT отдела плюс нескольких XLS-файлов уже не хватает для быстрого и достоверного ответа что у нас и где находится.
Что имеем:
1) каждому пользователю выдано необходимое оборудование (несколько мониторов, планшет, принтер, сканер, бесперебойник etc);
2) каждому на компьютер установлен набор бесплатного софта, плюс платные программы;
3) есть несколько датацентров, в каждом из которых есть несколько стоек, заполненных серверами и активным оборудованием;
Чего хотелось достичь:
1) вести учет комплектующих в каждом компьютере, возможность видеть проделанные апгрейды и ремонты;
2) иметь полный список купленного софта, с серийниками и дистрибутивами;
3) видеть какие лицензии кому выданы, и на каких машинах они установлены;
4) возможность строить любые отчеты, например у Петра Иванова находится — системный блок в такой-то конфигурации, 2 монитора, ноутбук, рабочее место на 99 этаже, в комнате 9901, пользуется лицензиями Windows XP, Office 2007, WinRar, Total Commander; или сколько у нас осталось лицензий на Photoshop и кому выданы занятые; или сколько и каких серверов (серийники и инвентарники такие-то) занято под такой то проект, какой на них установлен софт, во сколько обходится стоимость проекта (внесена стоимость серверов и лицензий); и так далее и тому подобное.
P.S. Также GLPI может использоваться как система подачи заявок в HelpDesk, но мы уже используем JIRA, если будет интересно расскажу, но пока не планировал.
Итак, я бы хотел рассказать о том, как я выполнил поставленные задачи. Было бы интересно рассказать сколько я продуктов перепробовал, перед тем как остановится на этом, но может в следующий раз. В данном посте приступлю конкретно к необходимым действиям, с помощью которых любой сможет установить такой же сервис у себя (это будет пошаговое руководство для начинающих с примерами команд и их выводом в консоль, не считая кучи картинок). Сейчас рассмотрим только установку и необходимую настройку, в дальнейшем хочу еще немного практики (связка с OCS Inventory), а уж после наверно теория. В нашей компании среди Linux-систем выбран Debian, на его примере и будем настраивать.
Часть 1: Установка
------------------
### 1. Установка ОС
Качаем последний образ Debian с сайта:
> [www.debian.com/CD/netinst](http://www.debian.com/CD/netinst/)
У меня это ***debian-504-i386-netinst.iso*** Нам будет достаточно сетевой установки, остальное мы будем доставлять сами. После установки установим следующие компоненты:
> apt-get install ssh, apache2, mysql-server, php5
### 2.Настраиваем MySQL
2.1 Логинимся под рутом, вводим пароль, который мы ввели при установке MySQL:
> mysql -uroot -p
`inventory:/home/tyran# mysql -uroot -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 28
Server version: 5.0.51a-24+lenny3 (Debian)
Type 'help;' or '\h' for help. Type '\c' to clear the buffer.
mysql>`
2.2 Создаем базу данных для нашей программы:
> create database glpidb;
`mysql> create database glpidb;
Query OK, 1 row affected (0.00 sec)`
2.3 Создаем пользователя, и выдаем ему права от созданной базы:
> grant all privileges on glpidb.\* to glpiuser@localhost identified by 'Здесь укажите ваш пароль для него';
`mysql> grant all privileges on glpidb.* to glpiuser@localhost
-> identified by 'password';
Query OK, 0 rows affected (0.00 sec)`
### 2. Установка GLPI
2.1 Качаем последнюю стабильную версию с сайта
> [www.glpi-project.org/?article41⟨=en](http://www.glpi-project.org/?article41&lang=en)
Я устанавливаю **GLPI Version 0.72.4**
2.2 Распаковываем архив в /var/www/
> tar xzvf glpi-0.72.4.tar.gz -C /var/www
2.3 Переходим в папку, и выдаем необходимые права на папки:
> cd /var/www/glpi
>
> chown www-data:www-data config files files/\* inc
>
>
3. Конфигурируем GLPI
Заходим по адресу:
**> <http://IP_адрес_сервера/glpi>**
3.1 Выбираем язык
3.2 Принимаем лицензионное соглашение
3.3 Выбираем установку
3.4 Проверяем окружение
3.5 Вот так например выглядит ошибка, если не хватает прав на запись в папки
3.6 Вводим данные для коннекта к MySQL
3.7 Выбираем свою базу данных GLPIDB
3.8 База успешно подключена
3.9 Все готово, здесь перечислены дефолтные логины и пароли.
3.10 Можем проверить и зайти под супер-админом (glpi:glpi)
3.11 чтобы поменять пользователю интерфейс на русский, необходимо выбрать справа вверху «Setting» и на страничке выбрать язык. Причем можно выбрать как глобальный для всех новых пользователей, так и для текущего аккаунта.
И так, на этом установка окончена. Можно логиниться используя дефолтные пароли и заносить данные.
Часть 2.Настройка
-----------------
### 1. Настройка LDAP
Теперь нам было бы удобнее привязать LDAP к нашей системе инвентаризации. Мы сможем импортировать пользователей к нам в систему, ну а после раздавать им права и привязывать к ним технику.
1.1 Выбираем в меню Setup -> Authentication
1.2 Далее нам нужен LDAP
1.3 И тут же видим ошибку
Устанавливаем недостающее
> apt-get install php5-ldap
`inventory:~# apt-get install php5-ldap
Reading package lists... Done
Building dependency tree
Reading state information... Done
The following NEW packages will be installed:
php5-ldap
0 upgraded, 1 newly installed, 0 to remove and 0 not upgraded.
Need to get 18.2kB of archives.
After this operation, 102kB of additional disk space will be used.
Get:1 security.debian.org lenny/updates/main php5-ldap 5.2.6.dfsg.1-1+lenny6 [18.2kB]
Fetched 18.2kB in 2s (6613B/s)
Selecting previously deselected package php5-ldap.
(Reading database ... 18693 files and directories currently installed.)
Unpacking php5-ldap (from .../php5-ldap_5.2.6.dfsg.1-1+lenny6_i386.deb) ...
Setting up php5-ldap (5.2.6.dfsg.1-1+lenny6) ...`
1.4 Рестартим Apache
> ./etc/init.d/apache2 restart
1.5 Обновляем страницу и добавляем сервер LDAP
1.5.1 Теперь подробнее по полям, которые необходимо заполнить
(В версии 0.72.4 добавили кнопку Active Directory, нажимая которую, подставятся значения специфичные для AD)
*Имя* — Какое вам нравится такое и пишите
*Server* — Указываем домен контроллер к которому будем обращаться ldap://dc1.domain.com
*LDAP Port* — по умолчанию 389
*Basedn* — где будем искать пользователей, например все пользователи домена dc=domain,dc=com
*rootdn* — путь к пользователю, от имени которого будет проиcходить запрос к LDAP, я создал пользователя web в подразделении, итого cn=web,ou=allusers,dc=domain,dc=com
*Pass* — пароль от пользователя web
*Login Field* — samaccountname
*Connection filter* — (&(objectClass=user)(objectCategory=person)(!(userAccountControl:1.2.840.113556.1.4.803:=2))) (поиск только активных пользователей)
*USE TLS* — No
*Time zone* — GMT +3 Hour
*HOw LDAP aliases should be handle* — Never
Группы я не использую.
GLPI/LDAP Links — Здесь заполняем привязку полей AD к полям пользователей в GLPI, так у нас импортируются в GLPI пользователи AD с полями имя, фамилия, емайл.
*Surname* — sn
*Firstname* — givenname
*E-Mail* — mail
1.6 Здесь же можем протестировать соединение. Если все ок — получим ответ:
1.7 Также можем добавить второй сервер LDAP, на случай если откажет первый, и также можем его протестировать:
### 2.Настройка бекапа
2.1 Создадим файл **backup.sh** следующего содержания
`#!/bin/sh
user="-uroot"
pass="-pПарольотMySQL"
path="/var/www/glpi/files/_dumps"
date="`date +%Y-%m-%d`"
mysqldump $user $pass glpidb > $path/$date.glpidb.backup.sql`
2.2 Выставляем планировщик на запуск нашего бекапа, например ежедневно в 23 часа:
> crontab -e
`# m h dom mon dow command
0 23 * * * /home/tyran/backup.sh`
Теперь в меню Administration — Data видим сделанный нами бекап, и можем его оттуда же восстановить.
### 3. Экспорт в PDF по-русски
Подробная инструкция у [молодого админа](http://angel2s2.blogspot.com/2009/10/glpi-pdf.html "спасибо") | https://habr.com/ru/post/101914/ | null | ru | null |
# E-learning на костылях. Исправляем курсы из Articulate Rise
Рынок насыщен разными программами для разработки электронных курсов — авторскими средствами (authoring tools). Есть продукты на любой вкус: хочешь прогу, чтобы просто конвертировать электронные презентации в HTML5? Да пожалуйста! Хочешь делать одностраничники в редакторе вроде Тильды? Держи! Хочешь создать игрушку в стиле Interactive Fiction? Да кто же тебе запретит, родной? Любой каприз, как говориться.
Каждое авторское средство склоняет на свою сторону простотой использования. Разработчик без какого-либо технического бекграунда может особо не напрягаясь склеить электронный курс и опубликовать его в LMS.
Но всё ли так гладко на самом деле? Что делать, когда кажущаяся простота разворачивается и стреляет вам в колено?
Давайте препарируем несколько популярных инструментов и посмотрим, какие неприятные сюрпризы поджидают наивных Instructional Designer-ов. Сеанс чёрной магии с последующим её разоблачением, так сказать.
Эта статья посвящается Articulate Rise.
Что это такое? Облачный сервис для разработки лонгридов. Вроде Тильды, только ориентированный на e-learning. Берёте контент, берёте готовые компоненты и в визуальном редакторе создаете веб-страницу. Добавляете электронные тесты и экспортируете в нужном вам формате (по нужному стандарту). Просто, быстро, интуитивно понятно. Изюм. [Вот пример](https://webshare.upsidelearning.com/Upside_FTP/group_5/upside/Articulate_Rise_Workplace_Productivity_Demo_20122016/index.html#/?_k=hwwb8w).
И в чем проблема, спросите вы?
Что ж, господа. Присаживайтесь…
### Как убить титульную страницу
Начнём с простого. Вот, поставьте себя на место пользователя. Идёте вы по LMS, нашли в каталоге курс, посмотрели, полюбовались картинкой на баннере, почитали описание. Поняли: хочу! Жмёте «Начать». И вместо того, чтобы сразу получить всё самое вкусное, вам предлагают ещё раз посмотреть на баннер, почитать описание и нажать «Начать». Неприятно? Меня, вот, бесит. Причём, создатели тулзы не догадались сделать в интерфейсе разработчика чекбокс «убрать титульную страницу».
#### Итак, первый костыль
1. Экспортируем курс.
2. Открываем файл *scormdriver/indexAPI.html*
3. Находим переменную *strContentLocation*. Это URL первой страницы, которая будет показана пользователю. По дефолту значение
```
scormcontent/index.html#/preview/
```
Чтобы пользователь переходил сразу к «вкусному», после хеша нужно прописать идентификатор урока.
Как его узнать? Просто открываем *scormcontent/index.html* в браузере переходим к первому уроку и копируем значение из урла. Всё что после хеша. Должно получиться что-то типа:
```
scormcontent/index.html#/lessons/rri34kKfn2348234
```
### Как исправить контент в курсе без доступа авторскому средству
Ситуация. Подписка закончилась, исходники не расшарены, а уже экспортированный курс срочно нужно исправить. Бывает такое? Иногда, увы, бывает.
#### Костыль
1. Экспортируем курс
2. Открываем scormcontent/index.html, находим переменную *courseData*. Она содержит все данные курса в base64.
3. Декодируем (например с помощью notepad++) и получаем уже читаемый и редактируемый JSON. С ним можно делать всякие упражнения. Я например сшивал несколько райзовских курсов в один, просто добавляя значения в массив *lessons*.
4. Перед сохранением кодируем строку *courseData* назад в base64.
5. Справедливости ради стоит заметить, что исправить можно не все данные. Так, например, перед рендерингом страницы Райз проверяет и изменяет гиперссылки. Об этом мы поговорим ниже.
### Встраиваем веб-страницы
Райз позволяет встроить в курс фрейм и показывать в нем веб-страницы. Проблема в том, что это может быть либо курс собранный в Storyline (другое авторское средство от той же компании), либо сайт, доступный по абсолютному URL. А вот возможность положить веб-страницу в пакет с курсом и сослаться на неё относительно index.html нет. Более того, если вы попытаетесь прописать абсолютную ссылку, экспортировать курс, а затем поменять её на относительную, как описано выше, ничего не выйдет. Райз проверит URL перед рендерингом страницы и если в нем не будет подстроки «://» просто тихонько загнётся.
#### Костыль
1. Добавляем на страницу объект из Storyline
2. Узнаем его id. Либо методом научного тыка, либо через *courseData*.
3. Экспортируем курс. Находим в scormcontent/assets папку с соответствующим id.
4. Заменяем содержимое папки. Свою страницу сохраняем как story.html
### Удаляем название курса из темы письма при переходе по ссылке mailto
Когда я впервые с этим столкнулся, я начал курить. Создатели Райза почему-то решили, что пользователь будет в восторге, если к ссылкам начинающимся на *mailto* без спроса добавлять сабжект с названием курса. Естественно, опции, которая это запрещает в интерфейсе нет.
#### Костыль
1. Экспортируем курс. Открываем scormcontent/lib/main.bundle.js.
2. Находим во всем этом месиве подстроку
```
(w="mailto:".concat(E,"?subject=")).call(w,o)
```
3. Меняем на
```
(w="mailto:".concat(E,"")).call(w,"")
```
### Заставляем Райз отдавать в LMS больше скормовых данных и делать это лучше
Да, я до сих пор работаю по SCORM 2004 4th edition. Более того, мне нравится этот стандарт. Но мне не нравится, как его трактуют создатели некоторых авторских средств. Райз, например, отправляет в LMS жалкую кучку переменных, причем делает это исключительно перед разрывом сессии (один-единственный *Commit()* перед *Terminate()*, для тех кто понимает).
Например, я хочу, чтобы курс по ходу пьесы сохранял сведения о прогрессе пользователя в LMS, чтобы выводить это значение в интерфейс LMS, а не только на счетчик на сайдбаре внутри самого курса.
#### Костыль
1. Экспортируем курс
2. Открываем scormcontent/index.html
3. Добавляем в массив *stuffToPick* значения:
```
stuffToPick = [
...,
"CommitData",
"GetProgressMeasure",
"SetProgressMeasure"
]
```
4. Дописываем функцию *setCourseProgress*:
```
setCourseProgress(courseProgress) {
…
var lastProgress = LMSProxy.GetProgressMeasure();
if (lastProgress < progress.p/100) {
LMSProxy.SetProgressMeasure(progress.p/100);
LMSProxy.CommitData();
}
}
```
5. В качестве бонуса, можно заставить курс коммитить почаще для профилактики «застревания» данных при разрыве сессии. Для этого добавляем *LMSProxy.CommitData()*; в конфе функций *completeOut*, и *reportAnswer*.
Надеюсь, материал вам пригодится, и вы сможете сделать свои курсы красивее и удобнее.
В следующий раз мы будем издеваться над iSpring. | https://habr.com/ru/post/509234/ | null | ru | null |
# Истории аварий с Patroni, или Как уронить PostgreSQL-кластер
В PostgreSQL нет High Availability из коробки. Чтобы добиться HA, нужно что-то поставить, настроить — приложить усилия. Есть несколько инструментов, которые помогут повысить доступность PostgreSQL, и один из них — Patroni.
На первый взгляд, поставив Patroni в тестовой среде, можно увидеть, какой это прекрасный инструмент и как он легко обрабатывает наши попытки развалить кластер. Но на практике в production-среде не всегда всё происходит так красиво и элегантно. Data Egret начали использовать Patroni еще в конце 2018 года и накопили определенный опыт: как его диагностировать, настраивать, а когда вовсе не полагаться на автофейловер.
На HighLoad++ Алексей Лесовский обстоятельно, на примерах и с разбором логов рассказал о типовых проблемах, возникающих при работе с Patroni, и best practice для их преодоления.
В статье не будет: инструкций по установке Patroni и примеров конфигураций; проблем за пределами Patroni и PostgreSQL; историй, основанных на чужом опыте, а только те проблемы, с которыми в Data Egret разобрались сами.
**О спикере:** Алексей Лесовский ([lesovsky](https://habr.com/ru/users/lesovsky/)) начинал системным администратором (Linux system administrator), работал в web-разработке (PostgreSQL database administrator). С 2014 года работает в Data Egret. Data Egret занимается консалтингом в сфере PostgreSQL, помогает многим-многим компаниям правильно использовать PostgreSQL и, конечно, накопила обширный опыт эксплуатации БД.
*Доклад, на котором основана эта статья, называется «Patroni Failure Stories or How to crash your PostgreSQL cluster», здесь [ссылка на презентацию](https://www.highload.ru/moscow/2019/abstracts/5779).*
### Перед тем, как начать
Напомню, что такое Patroni, для чего предназначен и что умеет.
**Patroni — это шаблон для построения HA из коробки.** Так написано в документации и с моей точки зрения — это очень правильное уточнение. То есть Patroni — это не серебряная пуля, которую поставил и она решит все проблемы. Нужно приложить усилия, чтобы он начал работать и приносить пользу.
**Patroni — агентская служба.** Устанавливается на каждом сервере с базой данных и является своего рода init-системой для PostgreSQL: запускает, останавливает, перезапускает, меняет конфигурацию и топологию кластера.
**Patroni хранит «состояние кластера» в DCS.** Чтобы хранить состояние кластера, его текущее представление, нужно хранилище. Patroni хранит состояние во внешней системе — распределенном хранилище конфигураций. Это может быть один из вариантов: Etcd, Consul, ZooKeeper либо Etcd Kubernetes.
**Автофейловер в Patroni включен по умолчанию.** Вы получаете автофейловер из коробки, сразу же после установки Patroni.
Плюс есть много других вещей, таких как: обслуживание конфигураций, создание новых реплик, резервное копирование и т.д. Но в этот раз это останется за рамками доклада.
> Основная задача Patroni — обеспечивать надежный автофейловер.
Patroni не должен следить за оборудованием, рассылать уведомления, делать сложные вещи по потенциальному предотвращению аварий и т.п. От него требуется, чтобы кластер оставался работоспособным и приложение могло продолжать работать с БД независимо от случившихся изменений в топологии кластера.
Но когда мы начинаем использовать Patroni с PostgreSQL, наша система становится чуть сложнее. Теперь, кроме самой БД, когда мастер или реплика выходят из строя, у нас может сломаться собственно Patroni, распределенное хранилище состояний кластера или сеть. Рассмотрим все варианты по мере их усложнения с точки зрения того, насколько трудно разобраться в их причинах.
Проблема 1. СУБД и DCS на одном кластере
----------------------------------------
Рассмотрим самый простой случай: взяли кластер баз данных и на этом же кластере развернули DCS. Эта распространенная ошибка связана не только с ошибками развертывания PostgreSQL и Patroni. Это ошибка вообще построения архитектур — совмещение множества разных компонентов в одном месте.
Итак, произошел фейловер. Начинаем разбираться с тем, что произошло. Здесь нас интересует, когда произошел фейловер, то есть **момент времени, когда произошло изменение состояния кластера.**
### Когда произошел фейловер?
Фейловер не всегда происходит мгновенно, он может быть продолжительным по времени. Поэтому у него есть время начала и время завершения. Все события делятся на «до», «во время» и «после» фейловера.
Первым делом, когда произошел фейловер, мы ищем причину.
```
pgdb-2 patroni: INFO: promoted self to leader by acquiring session lock
pgdb-2 patroni: WARNING: Loop time exceeded, rescheduling immediately.
pgdb-2 patroni: INFO: Lock owner: pgdb-2; I am pgdb-2
pgdb-2 patroni: INFO: updated leader lock during promote
pgdb-2 patroni: server promoting
pgdb-2 patroni: INFO: cleared rewind state after becoming the leader
pgdb-2 patroni: INFO: Lock owner: pgdb-2; I am pgdb-2
```
Выше стандартные логи Patroni, где он сообщает, что роль сервера изменилась и роль мастера перешла с другого на этот узел.
### Почему произошел фейловер?
Дальше нужно понять, какие события заставили роль мастера перейти с одного узла на другой, что случилось со старым мастером.
```
pgdb-2 patroni: patroni.utils.RetryFailedError: 'Exceeded retry deadline'
pgdb-2 patroni: ERROR: Error communicating with DCS
pgdb-2 patroni: INFO: demoted self because DCS is not accessible and i was a leader
pgdb-2 patroni: WARNING: Loop time exceeded, rescheduling immediately.
```
В данном случае все просто: `Error communicating with DCS` — ошибка взаимодействия с системой хранения конфигураций. Мастер понял, что не может работать с DCS, и сказал, что он не может далее быть мастером и слагает с себя полномочия. `demoted self` говорит именно об этом.
### Что предшествовало фейловеру?
Если посмотреть на события, которые предшествовали фейловеру, можно увидеть те самые причины, которые стали проблемой для продолжения работы мастера:
```
pgdb-2 patroni: ERROR: touch_member
... python trace
pgdb-2 patroni: socket.timeout: timed out
pgdb-2 patroni: During handling of the above exception, another exception occurred:
... python trace
pgdb-2 patroni: raise ReadTimeoutError(self, url, "Read timed out. (read timeout=%s)" % timeout_value)
pgdb-2 patroni: urllib3.exceptions.ReadTimeoutError: HTTPConnectionPool(host='127.0.0.1', port=8500): Read timed out. (read timeout=3.3333333333333335)
pgdb-2 patroni: During handling of the above exception, another exception occurred:
... python trace
pgdb-2 patroni: raise MaxRetryError(_pool, url, error or ResponseError(cause))
pgdb-2 patroni: urllib3.exceptions.MaxRetryError: HTTPConnectionPool(host='127.0.0.1', port=8500): Max retries exceeded with url: /v1/kv/service/pgdb/members/pgdb-2?acquire=19598b72-c0d5-f066-5d24-09c1a9ad61ee&dc=maindb (Caused by ReadTimeoutError("HTTPConnectionPool(host='127.0.0.1', port=8500): Read timed out. (read timeout=3.3333333333333335)",))
pgdb-2 patroni: INFO: no action. i am the leader with the lock
pgdb-2 patroni: WARNING: Loop time exceeded, rescheduling immediately.
```
В логах Patroni видна масса разных ошибок, связанных с таймаутами. Агент Patroni не смог работать с DCS (в данном случае это Consul, port=8500). Patroni и база данных были запущены на одном хосте, и на этом же узле были запущены Consul-серверы. Создав нагрузку на сервере, мы создали проблемы и для сервера Consul, из-за которых они не смогли нормально общаться.
### Все вернулось, как было
Через некоторое время, когда нагрузка спала, наш Patroni смог снова общаться с агентами, все возобновилось:
```
pgdb-2 patroni: INFO: promoted self to leader by acquiring session lock
pgdb-2 patroni: WARNING: Loop time exceeded, rescheduling immediately.
pgdb-2 patroni: INFO: Lock owner: pgdb-2; I am pgdb-2
pgdb-2 patroni: INFO: updated leader lock during promote
pgdb-2 patroni: server promoting
pgdb-2 patroni: INFO: cleared rewind state after becoming the leader
pgdb-2 patroni: INFO: Lock owner: pgdb-2; I am pgdb-2
```
Тот же самый сервер pgdb-2 снова стал мастером. Был небольшой “флип” — за относительно короткое время он сложил с себя полномочия мастера, потом снова взял их на себя.
Это можно расценивать либо как ложное срабатывание, либо как то, что Patroni сделал все правильно.
### Решение
Мы решили для себя, что проблема в том, что Consul-серверы находятся на том же оборудовании, что и базы. Соответственно любая нагрузка на CPU и на диски (тяжелый запрос по IO, временные файлы, автовакуумы, миграции, бэкап и т.п.) также влияет на взаимодействие с кластером Consul. Мы решили, что это не должно жить на одном оборудовании с БД, и выделили отдельный кластер для Consul.
В качестве альтернативы можно покрутить параметры `ttl`, `loop_wait`, `retry_timeout`, попытаться за счет их увеличения пережить кратковременные пики нагрузки. Но если нагрузка будет продолжительной, мы выйдем за пределы этих параметров, и способ не сработает.
Проблема 2. Перебои в сети
--------------------------
Вторая проблема похожа на первую тем, что у нас снова есть проблемы взаимодействия с системой DCS:
```
maindb-1 patroni: ERROR: get_cluster
maindb-1 patroni: Traceback (most recent call last):
... python trace
maindb-1 patroni: RetryFailedError: 'Exceeded retry deadline'
maindb-1 patroni: ERROR: Error communicating with DCS
maindb-1 patroni: INFO: closed patroni connection to the postgresql cluster
maindb-1 patroni: INFO: postmaster pid=214121
...
...
maindb-1 patroni: INFO: demoted self because DCS is not accessible and i was a leader
maindb-1 patroni: WARNING: Loop time exceeded, rescheduling immediately.
```
Patroni снова говорит, что не может взаимодействовать с DCS, поэтому текущий мастер перестает быть мастером и переходит в режим реплики. Старый мастер становится репликой:
```
maindb-1 patroni: INFO: Lock owner: maindb-2; I am maindb-1
maindb-1 patroni: INFO: does not have lock
maindb-1 patroni: INFO: running pg_rewind from maindb-2
maindb-1 patroni: INFO: running pg_rewind from user=postgres host=192.168.11.18 port=5432 ...
maindb-1 patroni: servers diverged at WAL location 1FA/A38FF4F8 on timeline 6
maindb-1 patroni: rewinding from last common checkpoint at 1FA/A38FF450 on timeline 6
maindb-1 patroni: INFO: Lock owner: maindb-2; I am maindb-1
maindb-1 patroni: INFO: running pg_rewind from maindb-2 in progress
maindb-1 patroni: Done!
```
Здесь Patroni отрабатывает как и положено — запускает `pg_rewind`, чтобы отмотать журнал транзакций, потом подключиться к новому мастеру и уже догнать новый мастер.
### Что предшествовало фейловеру?
Давайте, найдем первое, что предшествовало фейловеру, — ошибки, которые послужили его причиной. В этом плане удобны логи Patroni: он с определенным интервалом пишет одни и те же сообщения. Можно их быстро промотать и увидеть, когда поменялись логи. В этот момент начались какие-то проблемы.
В нормальной ситуации логи Patroni выглядят примерно так:
```
maindb-1 patroni: INFO: Lock owner: maindb-1; I am maindb-1
maindb-1 patroni: INFO: no action. i am the leader with the lock
maindb-1 patroni: INFO: Lock owner: maindb-1; I am maindb-1
maindb-1 patroni: INFO: no action. i am the leader with the lock
```
Проверяется владелец блокировки, если он поменяется, могут наступить события, на которые Patroni должен отреагировать. В данном случае у нас все в порядке.
Промотав до того места, когда ошибки начали появляться, мы видим, что произошел автофейловер. Раз ошибки были связаны со взаимодействием с DCS, мы заодно смотрим и в логи Consul — что происходило там. Примерно сопоставив время фейловера и время в логах Consul, видим, что соседи по Consul-кластеру стали сомневаться в существовании других участников:
```
maindb-2 consul[11581]: serf: EventMemberFailed: maindb-1 192.168.11.19
maindb-2 consul[11581]: [INFO] serf: EventMemberFailed: maindb-1 192.168.11.19
maindb-2 consul[11581]: memberlist: Suspect maindb-1 has failed, no acks received
maindb-2 consul[11581]: [INFO] memberlist: Suspect maindb-1 has failed, no acks received
```
Если посмотреть на логи других Consul-агентов, то там тоже видно, что происходит сетевой коллапс: все участники Consul-кластера сомневаются в существовании друг друга. Это и послужило толчком к фейловеру.
Если посмотрим еще более ранние записи, увидим, что Consul-система для агента PostgreSQL испытывает сложности с коммуникацией (`deadline reached`, `RPC failed`):
```
maindb-1 consul: memberlist: Suspect lbs-4 has failed, no acks received
maindb-1 consul: [ERR] yamux: keepalive failed: i/o deadline reached
maindb-1 consul: yamux: keepalive failed: i/o deadline reached
maindb-1 consul: [ERR] consul: "KVS.List" RPC failed to server 192.168.11.115:8300: rpc error making call: EOF
maindb-1 consul: [ERR] http: Request GET /v1/kv/service/sam_prod/?recurse=1, error: rpc error making call: EOF from=192.168.11.19
maindb-1 consul: [ERR] consul: "KVS.List" RPC failed to server 192.168.11.115:8300: rpc error making call: EOF
maindb-1 consul: [ERR] agent: Coordinate update error: rpc error making call: EOF
maindb-1 consul: [ERR] http: Request GET /v1/kv/service/sam_prod/?recurse=1, error: rpc error making call: EOF from=192.168.11.19
```
### Решение
Самый простой ответ — это **чинить сеть**. Это легко советовать, но обстоятельства могут складываться по-разному, и не всегда это возможно. Система может жить в дата-центре, где мы не можем влиять на оборудование. Нужны другие варианты.
Варианты решения без работы с сетью есть:
* **Отключить Consul-проверки** — `checks: []`.
Это самый простой вариант, который и написан в документации. Можно передать пустой массив, то есть сказать Consul-агенту не использовать никакие проверки. За счет этого можно игнорировать сетевые штормы и не инициировать фейловер.
* **Перепроверить** `raft_multiplier`.
Это параметр самого Consul-сервера, который по умолчанию равен 5 (это значение в документации рекомендуется для staging-окружения). Параметр влияет на скорость обмена сообщениями между участниками Consul-кластера. Для продакшен-окружения его рекомендуется уменьшить.
* **Использовать** `renice -n -10 consul`.
Здесь мы хотим увеличить приоритет для планировщика процессов ОС. Параметр renice определяет приоритет процессов. Мы выбрали именно такой вариант и просто уменьшили приоритет Consul-агентам, чтобы ОС давала этому процессу больше времени на работу и исполнение своего кода.
* **Не использовать consul?**
Consul-агент должен быть запущен на каждом узле с базой данных. Patroni взаимодействует с Consul-кластером через этот самый агент, и он становится узким местом: если с агентом что-то происходит, то Patroni уже не может работать с кластером. Если использовать etcd, то такой проблемы не возникнет, потому что в etcd никакого агента нет. Patroni может напрямую работать со списком etcd-серверов. Мы же как компания-консультант ограничены тем, что выбрал и использует клиент, пока так получается, что чаще всего это Consul.
* **Пересмотреть значения параметров** `ttl, loop_wait, retry_timeout`.
Можно увеличить эти параметры в надежде, что кратковременные сетевые проблемы не выйдут за выставленные значения. Таким образом уменьшается агрессивность Patroni в выполнении автофейловера в случае сетевых проблем.
Проблема 3. Потеря узла
-----------------------
Если вы используете Patroni, то знакомы с командой patronictl list, которая показывает текущее состояние кластера:
```
$ patronictl list
+-----------------+-------------------------+--------------+--------+---------+-----------+
| Cluster | Member | Host | Role | State | Lag in MB |
+-----------------+-------------------------+--------------+--------+---------+-----------+
| patroni_cluster | pg01.dev.zirconus.local | 10.202.1.101 | | running | 0.0 |
| patroni_cluster | pg03.dev.zirconus.local | 10.202.1.103 | Leader | running | 0.0 |
+-----------------+-------------------------+--------------+--------+---------+-----------+
```
На первый взгляд такой вывод может показаться нормальным — есть мастер, реплики, а лага репликации нет. Но эта картина нормальна ровно до тех пор, пока мы не знаем, что в этом кластере должно быть 3 узла, а не 2.
### Почему произошел фейловер?
Мы понимаем, что произошел автофейловер и после этого пропала одна реплика. Нужно выяснить, почему она пропала, и вернуть ее обратно.
Снова изучаем логи, чтобы понять, почему произошел автофейловер:
```
pg02 patroni[1425]: ERROR: failed to update leader lock
pg02 patroni[1425]: INFO: demoted self because failed to update leader lock in DCS
pg02 patroni[1425]: WARNING: Loop time exceeded, rescheduling immediately.
pg02 patroni[1425]: INFO: Lock owner: None; I am pg02.dev.zirconus.local
pg02 patroni[1425]: INFO: not healthy enough for leader race
pg02 patroni[1425]: INFO: starting after demotion in progress
```
Мастер pg02 не смог обновить мастер-ключ — `ERROR: failed to update leader lock`.
Тогда мастером стала вторая реплика db03, здесь все в порядке:
```
pg03 patroni[9648]: INFO: promoted self to leader by acquiring session lock
pg03 patroni[9648]: server promoting
pg03 patroni[9648]: INFO: cleared rewind state after becoming the leader
```
### Что со старым мастером?
pg02, решив стать репликой, начал с перемотки журнала транзакций. Здесь нам нужно уже смотреть логи реплики, которой нет в кластере. Открываем логи Patroni и смотрим, что в процессе подключения к кластеру возникла проблема на стадии `pg_rewind`.
```
pg02 patroni[1425]: INFO: running pg_rewind from pg03
pg02 patroni[1425]: INFO: running pg_rewind from user=postgres host=10.202.1.103 port=5432 ...
pg02 patroni[1425]: servers diverged at WAL location 33F/68E6AD10 on timeline 28
pg02 patroni[1425]: could not open file "/data/pgdb/11/pg_wal/0000001C0000033F00000059": No such file or directory
pg02 patroni[1425]: could not find previous WAL record at 33F/59FFE368 pg02 patroni[1425]: Failure, exiting
pg02 patroni[1425]: ERROR: Failed to rewind from healty master: pg03
pg02 patroni[1425]: WARNING: Postgresql is not running.
```
Чтобы подключиться к кластеру, узел должен запросить журнал транзакций у мастера и по нему догнать мастера. В данном случае журнала транзакций нет (`No such file or directory`), и реплика не может запуститься. Соответственно PostgreSQL останавливается с ошибкой. Надо понять, почему не оказалось журнала транзакций.
Посмотрим, что в WAL у нового мастера:
```
LOG: checkpoint complete:
wrote 62928 buffers (16.0%); 0 WAL file(s) added, 0 removed, 23 recycled;
write=12.872 s, sync=0.020 s, total=13.001 s;
sync files=16, longest=0.009 s, average=0.001 s;
distance=520220 kB, estimate=520220 kB
```
Оказывается, в то время, когда выполнялся `pg_rewind`, произошел чекпоинт, и **часть старых журналов транзакций была переименована**. Когда старый мастер попытался подключиться к новому мастеру и запросить эти логи, они уже были переименованы, их попросту не было.
По timestamp время между этими событиями буквально в 150 мс.
```
2019-08-26 00:06:11,369 LOG: checkpoint complete
2019-08-26 00:06:11,517 INFO: running pg_rewind
```
Но этого хватило, чтобы реплика не смогла подключиться и заработать.
### Решение
Изначально мы использовали слоты репликации. Это решение казалось нам хорошим, хотя на первом этапе эксплуатации мы слоты отключали. Мы думали, что если слоты будут копить много wal-сегментов, мастер может упасть. Помучившись какое-то время без слотов, мы поняли, что они нужны, и вернули их.
Проблема в том, что мастер при переходе в состояние реплики удаляет слоты и вместе с ними wal-сегменты. Чтобы нивелировать эту проблему, мы увеличили параметр `wal_keep_segments`. По умолчанию он равен 8 сегментов, мы **подняли `wal_keep_segments` до 1000**. Мы выделили 16 Гбайт на `wal_keep_segments`, и теперь при переключении у нас всегда на всех узлах есть запас 16 Гбайтов журналов транзакций.
Это актуально и для продолжительных maintenance-задач. Допустим, нужно обновить одну из реплик (софт, ОС, еще что-то), и мы хотим ее выключить. Когда мы выключаем реплику, для нее также удаляется слот. Если использовать маленькое значение параметра `wal_keep_segments`, то при продолжительном отсутствии реплики она запросит те журналы транзакций, которых на мастере уже может и не оказаться — тогда реплика не сможет подключиться. Поэтому мы держим большой запас журналов.
Проблема 4. Потеря данных
-------------------------
Произошел фейловер на production-базе. Проверили кластер: всё в порядке, все реплики на месте, лага репликации нет, ошибок по журналам тоже нет. Но продуктовая команда сообщает, что **в базе не хватает данных** — в одном источнике они есть, а в базе нет. Необходимо понять, что с ними произошло.
Мы сразу поняли, что это `pg_rewind` их затер, но нужно выяснить, почему.
### Когда произошел фейловер?
В логах мы всегда можем найти, когда произошел фейловер, кто стал новым мастером, кто был мастером до этого и когда он захотел стать репликой.
```
pgdb-1 patroni[17836]: INFO: promoted self to leader by acquiring session lock
pgdb-1 patroni[17836]: server promoting
pgdb-1 patroni[17836]: INFO: cleared rewind state after becoming the leader
pgdb-1 patroni[17836]: INFO: Lock owner: pgdb-1; I am pgdb-1
```
По логам мы можем определить, какой объем журналов транзакций был потерян.
Дело было так: старый мастер перезагрузился, после его перезагрузки автозапуском был запущен Patroni, который следом запустил PostgreSQL. PostgreSQL решил стать участником Patroni-кластера и запустил процесс `pg_rewind`, который в свою очередь стер часть журналов транзакций, скачал новые и подключился.
Patroni отработал совершенно так, как и было задумано. Кластер восстановился: было 3 узла, после фейловера 3 узла и осталось. Но часть данных потеряна, и нужно понять, какая это часть.
Найдем в логах старого мастера момент, когда происходил `pg_rewind`:
```
pgdb-2 patroni[4149]: INFO: running pg_rewind from pgdb-1
pgdb-2 patroni[4149]: Lock owner: pgdb-1; I am pgdb-2
pgdb-2 patroni[4149]: Deregister service pgdb/pgdb-2
pgdb-2 patroni[4149]: running pg_rewind from pgdb-1 in progress
pgdb-2 patroni[4149]: running pg_rewind from user=replica host=10.10.1.31 port=5432 ...
pgdb-2 patroni[4149]: servers diverged at WAL location 0/5AD1BFD8 on timeline 66
pgdb-2 patroni[4149]: rewinding from last common checkpoint at 0/59DD1070 on timeline 66
pgdb-2 patroni[4149]: Done!
```
Нужно найти позицию в журнале транзакций, на которой остановился старый мастер.
```
pgdb-2 patroni[4149]: INFO: Local timeline=66 lsn=0/5BDA8EB8
pgdb-2 patroni[4149]: INFO: master_timeline=67
...
pgdb-2 patroni[4149]: servers diverged at WAL location 0/5AD1BFD8 on timeline 66
postgres=# select pg_wal_lsn_diff('0/5BDA8EB8','0/5AD1BFD8');
pg_wal_lsn_diff
----------------
17354464
```
В данном случае это отметка 0/5BDA8EB8. Вторая отметка — 0/5AD1BFD8 — нужна, чтобы найти расстояние, на которое отличается старый мастер от нового. С помощью функции `pg_wal_lsn_diff` сравниваем эти две отметки, получаем 17 Мбайт.
Большая ли потеря 17 Мбайт данных, каждый для себя решает сам. Для кого-то это незначительно, а для кого-то недопустимо много. Каждый для себя индивидуально определяет в соответствии с потребностями бизнеса.
### Решение
Прежде всего необходимо решить, **всегда ли нужен автозапуск Patroni после перезагрузки системы**. Чаще всего мы должны зайти на старый мастер, посмотреть, насколько он отличается от актуального состояния, возможно, проинспектировать сегменты журнала транзакций. Нужно понять, можно ли эти данные потерять, либо нужно в standalone-режиме запустить старый мастер, чтобы вытащить данные. Только уже после этого принять решение, что делать с данными, и подключить этот узел в качестве реплики в наш кластер.
Помимо этого есть параметр `maximum_lag_on_failover`, по умолчанию его значение 1 Мб. Он работает так: если реплика отстает на 1 Мб данных по лагу репликации, то эта реплика не принимает участия в выборах. Если вдруг происходит фейловер, Patroni смотрит, какие реплики отстают, и те из них, которые отстают на большое количество журналов транзакций, не могут стать мастером. Это хорошая защитная функция, которая позволяет не потерять слишком много данных.
Но есть проблема: лаг репликации обновляется с определенным интервалом, значение `ttl` по умолчанию 30 с. Вполне возможна ситуация, когда значение лага репликации для реплик в DCS одно, а на самом деле оно совершенно другое или лага вообще нет. Это не real-time значение, оно не всегда отражает реальную картину и завязывать на него сложную логику не стоит.
Риск «потеряшек» всегда остается:
* В худшем случае: `maximum_lag_on_failover + ttl`.
* В среднем случае: `maximum_lag_on_failover + (loop_wait / 2)`.
Когда планируете внедрение Patroni и оцениваете, сколько данных можно потерять, учитывайте эти формулы, чтобы примерно представлять возможные потери.
Хорошая новость — в «потеряшках» могут быть WAL от фоновых процессов. Эти данные можно запросто игнорировать и потерять, в этом нет никакой проблемы.
Так выглядят логи в случае, если выставлен `maximum_lag_on_failover`, произошел фейловер и нужно выбрать нового мастера:
```
pgdb-1 patroni[6202]: INFO: Lock owner: None; I am pgdb-1
pgdb-1 patroni[6202]: INFO: not healthy enough for leader race
pgdb-1 patroni[6202]: INFO: changing primary_conninfo and restarting in progress
...
pgdb-1 patroni[6202]: INFO: following a different leader because i am not the healthiest node
pgdb-1 patroni[6202]: INFO: following a different leader because i am not the healthiest node
```
Реплика просто видит, что она `not healthy enough for leader race`, и отказывается от участия в гонке за лидерство. Поэтому просто ждет, когда будет выбран новый мастер, чтобы к нему подключиться. Это дополнительная мера от потери данных.
Проблема 5. Диски
-----------------
Продуктовая команда написала, что приложение испытывает проблемы при работе с PostgreSQL. При этом на мастер нельзя зайти, потому что он недоступен по SSH, но и автофейловер тоже не происходит. Тогда хост принудительно перезагрузили и таким образом запустили автофейловер. Хотя можно было сделать и ручной фейловер.
После перезагрузки идем смотреть, что было с мастером.
Нам заранее было известно о проблемах с дисками, по мониторингу мы знали, где копать.
В логах PostgreSQL видим следующее:
```
[COMMIT] LOG: duration: 1138.868 ms statement: COMMIT
...
[] WARNING: autovacuum worker started without a worker entry
...
[SELECT] LOG: temporary file: path "base/pgsql_tmp/pgsql_tmp11247.983", size 532996096
...
```
На лицо все показатели проблем с дисками: коммиты, которые длятся секунды, autovacuum запускается очень долго и странно и временные файлы на диске.
Мы заглянули в системный dmesg — лог сообщений ядра, и увидели проблему с одним из дисков:
```
md/raid10:md2: sde3: rescheduling sector 351273392
blk_update_request: I/O error, dev sde, sector 64404728
md/raid10:md2: sde3: rescheduling sector 63161592
blk_update_request: I/O error, dev sde, sector 64404760
...
md2 : active raid10 sda3[0] sdc3[2] sdd3[3] sdb3[1] sdh3[7] sdf3[5] sdg3[6]
15623340032 blocks super 1.2 512K chunks 2 near-copies [8/7] [UUUUUUU_]
bitmap: 58/59 pages [232KB], 131072KB chunk
```
Дисковая подсистема на сервере представляла собой софтверный Raid из 8 дисков, но одного не хватало. В строке `sda3[0] sdc3[2] sdd3[3] sdb3[1] sdh3[7] sdf3[5] sdg3[6]` не хватает `sde[4]`. Условно говоря, выпал один диск, это вызвало дисковые проблемы, и у приложения возникли проблемы при работе с кластером PostgreSQL.
### Решение
В данном случае Patroni никак бы не смог помочь, потому что у Patroni нет задачи отслеживать состояние сервера и дисков. Во время проблем Patroni продолжал взаимодействовать с кластером DCS и не видел никаких трудностей. Для таких ситуаций нужен внешний мониторинг.
Проблема 6. Кластер-симулянт
----------------------------
Это одна из самых странных проблем. Я её исследовал очень долго, перечитал много логов и назвал «Кластер-симулянт».
Проблема заключалась в том, что старый мастер не мог стать нормальной репликой. Patroni его запускал, показывал, что этот узел присутствует как реплика, но в то же время он не был нормальной репликой, сейчас увидите, почему.
Все началось, как и в предыдущем случае, с проблем с дисками:
```
14:48:55.601 [COMMIT] LOG: duration: 1478.118 ms statement: COMMIT
14:48:56.287 [COMMIT] LOG: duration: 1290.203 ms statement: COMMIT
14:48:56.287 [COMMIT] LOG: duration: 1778.465 ms statement: COMMIT
14:48:56.287 [COMMIT] LOG: duration: 1778.449 ms statement: COMMIT
```
Были обрывы соединений:
```
14:48:58.078 [idle in transaction] LOG: could not send data to client: Broken pipe
14:48:58.078 [idle] LOG: could not send data to client: Broken pipe
14:48:58.078 [idle] FATAL: connection to client lost
14:48:58.107 [idle in transaction] FATAL: connection to client lost
```
Были долгие ожидания ответа и блокировки разной степени тяжести:
```
14:49:26.929 [UPDATE waiting] LOG: process 4298 acquired ExclusiveLock on tuple (2,10) of relation 52082 of database 50587 after 52487.463 ms
14:49:26.929 [UPDATE waiting] STATEMENT: UPDATE sessions SET lastaccess='1565005714' WHERE sessionid=...
14:49:27.929 [UPDATE waiting] LOG: process 4298 still waiting for ShareLock on transaction 364118337 after 1000.088 ms
14:49:27.929 [UPDATE waiting] DETAIL: Process holding the lock: 4294. Wait queue: 4298.
```
В общем, явные проблемы с дисками, включая снова временные файлы.
Но самое загадочное для меня — это прилетевший `immediate shutdown request`:
```
14:49:34.102 MSK 5335 @ from [] LOG: received immediate shutdown request
14:49:34.689 [authentication] WARNING: terminating connection because of crash of another server process
14:49:34.689 [authentication] DETAIL: The postmaster has commanded this server process to roll back the current transaction and exit, because another server process exited abnormally and possibly corrupted shared memory
```
У PostgreSQL есть три режима выключения:
* Graceful, когда мы ждем, когда все клиенты отключатся самостоятельно.
* Fast, когда мы говорим клиентам отключаться, потому что идем на выключение.
* Immediate, которые не сообщает клиентам, что нужно отключиться, а просто выключает и всем клиентам отправляет сообщение RST (TCP-сигнал, что соединение прервано).
Фоновые процессы PostgreSQL друг другу сигналы immediate shutdown request не посылают, а только на них реагируют. Это экстренный перезапуск, и кто его послал, непонятно. Если бы это был `kill -9`, то я бы увидел это в логах, но там этого не было.
Разбираясь дальше, я увидел, что Patroni не писал в лог довольно долго — 54 секунды сообщений просто не было. За это время одна из реплик сделала «promote» и произошел автофейловер:
```
pgsql03 patroni: 14:48:25,000 INFO: Lock owner: pgsql03; I am pgsql03
pgsql03 patroni: 14:48:25,013 INFO: no action. i am the leader with the lock
pgsql03 patroni: 14:48:37,159 INFO: Lock owner: pgsql03; I am pgsql03
pgsql03 patroni: 14:49:31,155 WARNING: Exception hened during processing of request from 10.1.0.12
pgsql03 patroni: 14:49:31,297 WARNING: Exception hened during processing of request from 10.1.0.11
pgsql03 patroni: 14:49:31,298 WARNING: Exception hened during processing of request from 10.1.0.11
```
Patroni здесь снова отработал прекрасно, старый мастер был недоступен, поэтому начались выборы нового мастера.
```
pgsql01 patroni: 14:48:57,136 INFO: promoted self to leader by acquiring session lock
pgsql01 patroni: server promoting
pgsql01 patroni: 14:48:57,214 INFO: cleared rewind state after becoming the leader
pgsql01 patroni: 14:49:05,013 INFO: Lock owner: pgsql01; I am pgsql01
pgsql01 patroni: 14:49:05,023 INFO: updated leader lock during promote
```
pgsql01 стал новым лидером, а со второй репликой как раз были проблемы. Она честно пыталась переконфигурироваться:
```
pgsql02 patroni: 14:48:57,124 INFO: Could not take out TTL lock
pgsql02 patroni: 14:48:57,137 INFO: following new leader after trying and failing to obtain lock
pgsql02 patroni: 14:49:05,014 INFO: Lock owner: pgsql01; I am pgsql02
pgsql02 patroni: 14:49:05,025 INFO: changing primary_conninfo and restarting in progress
pgsql02 patroni: 14:49:15,011 INFO: Lock owner: pgsql01; I am pgsql02
pgsql02 patroni: 14:49:15,014 INFO: changing primary_conninfo and restarting in progress
pgsql02 patroni: 14:49:25,011 INFO: Lock owner: pgsql01; I am pgsql02
pgsql02 patroni: 14:49:25,014 INFO: changing primary_conninfo and restarting in progress
pgsql02 patroni: 14:49:35,011 INFO: Lock owner: pgsql01; I am pgsql02
pgsql02 patroni: 14:49:35,014 INFO: changing primary_conninfo and restarting in progress
```
Она пыталась поменять recovery.conf, перезапустить PostgreSQL, подключиться к новому мастеру. Каждые 10 секунд идут сообщения, что она пытается, но никак не может.
Тем временем на старый мастер прилетел тот самый immediate-shutdown-сигнал. Мастер начал аварийную перезагрузку, recovery также прекращается. Реплика не может подключиться к мастеру, потому что он в режиме выключения.
```
14:49:34.293 [idle] LOG: received replication command: IDENTIFY_SYSTEM
WARNING: terminating connection because of crash of another server process
DETAIL: The postmaster has commanded this server process to roll back the current transaction and exit, because another server process exited abnormally and possibly corrupted shared memory.
14:49:35.232 FATAL: could not receive data from WAL stream: server closed the connection unexpectedly
This probably means the server terminated abnormally
before or while processing the request.
14:49:35.232 LOG: record with incorrect prev-link 142D46/315602C at 14CF/CF38C160
14:49:35.305 FATAL: could not connect to the primary server: FATAL: the database system is shutting down
14:49:40.241 FATAL: could not connect to the primary server: FATAL: the database system is shutting down
```
В какой-то момент реплика заработала, но репликация при этом не запустилась.
```
14:50:14.024 [] LOG: record with incorrect prev-link 142D46/315602C at 14CF/CF38C160
14:50:14.028 [] LOG: fetching timeline history file for timeline 72 from primary server
14:50:14.104 [] FATAL: could not start WAL streaming: ERROR: requested starting point 14CF/CF000000 on timeline 71 is not in this server's history
DETAIL: This server's history forked from timeline 71 at 14CF/CEC32E40.
14:50:14.104 [] LOG: new timeline 72 forked off current database system timeline 71 before current recovery point 14CF/CF38C160
```
У меня есть единственная гипотеза: в recovery.conf был адрес старого мастера. Когда уже появился новый мастер, вторая реплика пыталась подключиться к старому мастеру. Когда Patroni запустился на второй реплике, узел запустился, но не смог подключиться по репликации. Образовался лаг репликации, который выглядел примерно так:
```
+-----------------+----------+--------------+--------+---------+-----------+
| Cluster | Member | Host | Role | State | Lag in MB |
+-----------------+----------+--------------+--------+---------+-----------+
| patroni_cluster | pgsql01 | 10.2.200.151 | Leader | running | 0.0 |
| patroni_cluster | pgsql02 | 10.2.200.152 | | running | 9153.0 |
| patroni_cluster | pgsql03 | 10.2.200.153 | | running | 0.0 |
+-----------------+----------+--------------+--------+---------+-----------+
```
То есть все три узла были на месте, но второй узел отставал. Репликация не могла запуститься, потому что журналы транзакций отличались. Журналы транзакций, которые предлагал мастер, указанные в recovery.conf, просто не подходили текущему узлу. PostgreSQL каждые 5 секунд сообщал об ошибке
```
14:50:44.143 FATAL: could not start WAL streaming: ERROR: requested starting point 14CF/CF000000 on timeline 71 is not in this server's history
DETAIL: This server's history forked from timeline 71 at 14CF/CEC32E40.
14:50:44.143 LOG: new timeline 72 forked off current database system timeline 71 before current recovery point 14CF/ CF38C160
```
Здесь я допустил ошибку и не проверил свою гипотезу, что мы подключаемся не к тому мастеру. Я просто перезапустил Patroni на реплике. Честно говоря, я уже поставил на ней крест и думал, что придется её переналивать, но все равно решил попробовать перезапустить.
```
15:14:13.511 LOG: consistent recovery state reached at 14CF/A3F657B0
15:14:13.511 LOG: database system is ready to accept read only connections
```
Запустился recovery, и даже база открылась, она была готова принимать соединение, репликация запустилась:
```
15:14:17.072 LOG: record with incorrect prev-link 142D46/315602C at 14CF/CF38C160
15:14:17.077 LOG: started streaming WAL from primary at 14CF/CF000000 on timeline 72
15:14:17.536 LOG: invalid record length at 14CF/CF38C160: wanted 24, got 1
```
Но через минуту отвалилась с ошибкой `terminating walreceiver process due to administrator command` — реплика сказала, что ей не подходят журналы транзакций.
```
15:15:27.823 FATAL: terminating walreceiver process due to administrator command
15:15:27.895 LOG: invalid record length at 14CF/CF38C160: wanted 24, got 1
15:15:27.895 LOG: invalid record length at 14CF/CF38C160: wanted 24, got 1
```
Причем я не перезапускал PostgreSQL, а перезапускал именно Patroni в надежде, что он магическим образом запустит базу. Репликация снова запустилась, но база открылась на том же месте:
```
15:17:33.553 LOG: consistent recovery state reached at 14CF/A3F657B0
15:17:33.554 LOG: database system is ready to accept read only connections
```
Отметки в журнале транзакций отличались, они были другими, чем в предыдущей попытке запуска — позиция журнала транзакция была раньше:
```
15:17:37.299 LOG: invalid contrecord length 5913 at 14CF/CEFFF7B0
15:17:37.304 LOG: started streaming WAL from primary at 14CF/CE000000 on timeline 72
```
Репликация снова остановилась, причем сообщение об ошибке было другое и снова не особо информативное:
```
15:18:12.208 FATAL: terminating walreceiver process due to administrator command
15:18:12.240 LOG: record with incorrect prev-link 60995000/589DF000 at 14CF/CEFFF7B0
15:18:12.240 LOG: record with incorrect prev-link 60995000/589DF000 at 14CF/CEFFF7B0
```
Для эксперимента рестартанул снова, база открывалась на том же месте:
```
15:21:25.135 LOG: consistent recovery state reached at 14CF/A3F657B0
15:21:25.135 LOG: database system is ready to accept read only connections
```
Тут мне пришла идея: что если я перезапущу PostgreSQL, в этот момент на текущем мастере сделаю чекпойнт, чтобы подвинуть точку в журнале транзакций чуть-чуть вперед и recovery началось с другого момента.
Запустил Patroni, сделал пару чекпоинтов на мастере, пару рестарт-пойнтов на реплике, когда она открылась:
```
15:22:43.727 LOG: invalid record length at 14D1/BCF3610: wanted 24, got 0
15:22:43.731 LOG: started streaming WAL from primary at 14D1/B000000 on timeline 72
```
Это сработало — репликация запустилась уже с другого места и больше не рвалась. Но для меня это одна из наиболее загадочных проблем, над которой я до сих пор ломаю голову. Особенно тот странный immediate shutdown request.
Из этого можно сделать вывод: Patroni может отработать, как задумано и без ошибок, но это не стопроцентная гарантия того, что все на самом деле в порядке. После фейловера всегда нужно перепроверить, что с кластером все хорошо: нужное количество реплик, нет лага репликации.
Итоги
-----
На основе этих и многих других подобных проблем я сформулировал общие рекомендации, которые советую иметь в виду при эксплуатации Patroni.
> * Когда вы используете Patroni, у вас обязательно должен быть мониторинг. Всегда нужно знать, когда произошел автофейловер, потому что если вы не знаете, что у вас случился автофейловер, вы не контролируете кластер.
> * После каждого фейловера всегда проверяйте кластер. Необходимо убедиться, что: реплик всегда актуальное количество; нет лага репликации; в логах нет ошибок, связанных с потоковой репликацией, с Patroni, с системой DCS.
>
Patroni — очень хороший инструмент, но это как ни крути не серебряная пуля. Автоматика может успешно отработать, но при этом объекты автоматики могут находиться в полурабочем состоянии. Все равно нужно иметь представление о том: как работает PostgreSQL и репликация, как Patroni управляет PostgreSQL и как обеспечивается взаимодействие между узлами. Это нужно для того, чтобы уметь чинить руками возникающие проблемы.
### Этапы диагностики
Так сложилось, что мы работаем с разными клиентами, стека ELK по больше части у них нет, и приходится разбираться в логах, открыв 2 вкладки и 6 консолей: в одной вкладке Patroni для каждого узла, в другой — логи Consul либо PostgreSQL. Диагностировать все это тяжело.
Я выработал следующий подход. Я всегда смотрю, когда произошел фейловер. Для меня это некий водораздел. Я смотрю, что произошло до, во время и после фейловера. Фейловер имеет два timestamp — начало и конец. В логах я смотрю, что предшествовало фейловеру, то есть ищу причины. Это дает понимание картины, что происходило и что можно сделать в будущем, чтобы фейловер при таких же обстоятельствах не происходил.
Для этого я смотрю:
* Первым делом логи Patroni.
* Дальше логи PostgreSQL или логи DCS в зависимости от того, что нашлось в логах Patroni.
* Логи системы — они тоже иногда помогают понять, что послужило причиной фейловера.
### Послесловие
Есть много других продуктов для автофейловера: stolon, repmgr, pg\_auto\_failover, PAF. Я пробовал все 4 инструмента и на мой взгляд Patroni — лучшее, что есть сегодня на рынке.
Рекомендую ли я Patroni? Определенно, да, потому что Patroni мне нравится, как мне кажется, я научился его готовить.
Если вам интересно посмотреть, какие еще бывают проблемы с Patroni, кроме описанных в статье, вы всегда можете зайти на страницу <https://github.com/zalando/patroni/issues>. Там много разных историй. Несмотря на то, что половина из них от неграмотных пользователей, которые задают глупые вопросы не удосужившись озаботиться простым поиском, там обсуждаются и интересные проблемы и по итогу обсуждений при необходимости открываются задачи на исправление багов.
Спасибо компании Zalando за то, что они развивают этот проект, а также двум людям, которые начинали работать над этим продуктом: Александру Кукушкину и Алексею Клюкину. Большое спасибо вообще всем контрибьюторам Patroni.
*После этого доклада мы записали небольшое интервью, в котором Алексей попытался уместить свой доклад в один совет и рассказал, зачем участвовать и выступать на конференциях. Берите на вооружение и приходите проверять подход на Saint HighLoad++.*
> Питерский HighLoad++ запланирован на 6-7 апреля. Мы тщательно мониторим ситуацию с коронавирусом, изучаем рекомендации компетентных источников. В данный момент мы планируем провести конференцию в назначенные даты, предприняв целый ряд профилактических и информационных мер (каких именно, перечислили на [специальной странице](https://ontico.ru/COVID-19.html)). В случае ухудшения ситуации или форс-мажоров мы **перенесём** конференцию с сохранением всех билетов, партнёрских опций, докладчиков и всех других обязательств, которые мы на себя берём.
>
>
>
> Поэтому ждём вас на [Saint HighLoad++](https://www.highload.ru/spb/2020)! Тем более в программе, как всегда, много полезных докладов относятся к PostgreSQL: Олег Бартунов [расскажет](https://www.highload.ru/spb/2020/abstracts/6721), что уже есть в PostgreSQL для работы с JSON и что скоро появится; Иван Панченко [познакомит](https://www.highload.ru/spb/2020/abstracts/6542) с фичами PostgreSQL 13, повышающими производительность; Николай Самохвалов [разберёт](https://www.highload.ru/spb/2020/abstracts/6588) распространённые ошибки изменения схемы БД. | https://habr.com/ru/post/489206/ | null | ru | null |
# Python: коллекции, часть 3/4: объединение коллекций, добавление и удаление элементов
| [Часть 1](https://habrahabr.ru/post/319164/ "Python: коллекции, часть 1/4: классификация, общие подходы и методы, конвертация") | [Часть 2](https://habrahabr.ru/post/319200/ "Python: коллекции, часть 2/4: индексирование, срезы, сортировка") | Часть 3 | [Часть 4](https://habrahabr.ru/post/320288/ "Python: коллекции, часть 4/4: Все о выражениях-генераторах, генераторах списков, множеств и словарей") |
| --- | --- | --- | --- |
Продолжим изучать общие принципы работы со стандартными коллекциями (модуль collections в ней не рассматривается) Python. Будут рассматриваться способы объединения и обновления коллекций с формированием новой или изменением исходной, а также способы добавлять и удалять элементы в изменяемые коллекции.
**Для кого**: для изучающих Python и уже имеющих начальное представление о коллекциях и работе с ними, желающих систематизировать и углубить свои знания, сложить их в целостную картину.
#### Оглавление:
1. Объединение строк, кортежей, списков, словарей без изменения исходных.
2. [Объединение множеств без изменения исходных.](#2)
3. [Объединение списка, словаря и изменяемого множества с изменением исходной коллекции.](#3)
4. [Добавление и удаление элементов изменяемых коллекций.](#4)
5. [Особенности работы с изменяемой и не изменяемой коллекцией.](#5)
### 1. Объединение строк, кортежей, списков, словарей без изменения исходных
Рассмотрим способы объединения строк, кортежей, списков, словарей без изменения исходных коллекций — когда из нескольких коллекций создаётся новая коллекция того же тип без изменения изначальных.
1. **Объединение строк (string) и кортежей (tuple)** возможна с использованием оператора сложения «+»
```
str1 = 'abc'
str2 = 'de'
str3 = str1 + str2
print(str3) # abcde
tuple1 = (1, 2, 3)
tuple2 = (4, 5)
tuple3 = tuple1 + tuple2
print(tuple3) # (1, 2, 3, 4, 5)
```
2. Для **объединения списков** (list) возможны три варианта без изменения исходного списка:
* Добавляем все элементы второго списка к элементам первого, (аналог метод .extend() но без изменения исходного списка):
```
a = [1, 2, 3]
b = [4, 5]
c = a + b
print(a, b, c) # [1, 2, 3] [4, 5] [1, 2, 3, 4, 5]
```
* Добавляем второй список как один элемент без изменения исходного списка (аналог метода.append() но без изменения исходного списка):
```
a = [1, 2, 3]
b = [4, 5]
c = a + [b]
print(a, b, c) # [1, 2, 3] [4, 5] [1, 2, 3, [4, 5]]
```
3. UPD: Способ добавленный [longclaps](https://habrahabr.ru/users/longclaps/) в комментариях:
```
a, b = [1, 2, 3], [4, 5]
c = [*a, *b] # работает на версии питона 3.5 и выше
print(c) # [1, 2, 3, 4, 5]
```
4. Со **словарем** (dict) все не совсем просто.
Сложить два словаря чтобы получить третий оператором + Питон не позволяет «TypeError: unsupported operand type(s) for +: 'dict' and 'dict'».
Это можно сделать по-другому комбинируя методы .copy() и .update():
```
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
dict3 = dict1.copy()
dict3.update(dict2)
print(dict3) # {'a': 1, 'c': 3, 'b': 2, 'd': 4}
```
В Питоне 3.5 появился новый более изящный способ:
```
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
dict3 = {**dict1, **dict2}
print(dict3) # {'a': 1, 'c': 3, 'b': 2, 'd': 4}
```
2. Объединение множеств без изменения исходных
----------------------------------------------
Для обоих типов множеств (set, frozenset) возможны различные варианты комбинации множеств (исходные множества при этом не меняются — возвращается новое множество).
```
# Зададим исходно два множества (скопировать перед каждым примером ниже)
a = {'a', 'b'}
b = { 'b', 'c'} # отступ перед b для наглядности
```
1. **Объединение** (union):
```
c = a.union(b) # c = b.union(a) даст такой же результат
# c = a + b # Обычное объединение оператором + не работает
# TypeError: unsupported operand type(s) for +: 'set' and 'set'
c = a | b # Альтернативная форма записи объединения
print(c) # {'a', 'c', 'b'}
```
2. **Пересечение** (intersection):
```
c = a.intersection(b) # c = b.intersection(a) даст такой же результат
c = a & b # Альтернативная форма записи пересечения
print(c) # {'b'}
```
Пересечение более 2-х множеств сразу:
```
a = {'a', 'b'}
b = { 'b', 'c'}
c = { 'b', 'd'}
d = a.intersection(b, c) # Первый вариант записи
d = set.intersection(a, b, c) # Второй вариант записи (более наглядный)
print(d) # {'b'}
```
3. **Разница** (difference) — результат зависит от того, какое множество из какого вычитаем:
```
c = a.difference(b) # c = a - b другой способ записи дающий тот же результат
print(c) # {'a'}
c = b.difference(a) # c = b - a другой способ записи дающий тот же результат
print(c) # {'c'}
```
4. **Симметричная разница** (symmetric\_difference) Это своего рода операция противоположная пересечению — выбирает элементы из обеих множеств которые не пересекаются, то есть все кроме совпадающих:
```
c = b.symmetric_difference(a)
# c = a.symmetric_difference(b) # даст такой же результат
c = b ^ a # Альтернативная форма записи симметричной разницы
print(c) # {'a', 'c'}
```
### 3. Объединение списка, словаря и изменяемого множества с изменением исходной коллекции
1. Для **списка**
* Добавляем все элементы второго списка к элементам первого с измением первого списка методом .**extend**():
```
a.extend(b) # a += b эквивалентно a.extend(b)
print(a, b) # [1, 2, 3, 4, 5] [4, 5]
```
* Добавляем второй список как один элемент с изменением первого списка методом .**append**():
```
a.append(b) # a += [b] эквивалентно a.append(b)
print(a, b) # [1, 2, 3, [4, 5]] [4, 5]
```
2. Для изменения **словаря** с добавления элементов другого словаря используется метод .**update**().
Обратите внимание: для совпадающих ключей словаря при этом обновляются значения:
```
dict1 = {'a': 1, 'b': 2}
dict2 = {'a': 100, 'c': 3, 'd': 4}
dict1.update(dict2)
print(dict1) # {'a': 100, 'c': 3, 'b': 2, 'd': 4}
```
3. Для **изменяемого множества** (set) кроме операций, описанных в предыдущем разделе, также возможны их аналоги, но уже с изменением исходного множества — эти методы заканчиваются на \_update. Результат зависит от того, какое множество каким обновляем.
* .**difference\_update**()
```
a = {'a', 'b'}
b = { 'b', 'c'}
a.difference_update(b)
print(a, b) # {'a'} {'b', 'c'}
a = {'a', 'b'}
b = { 'b', 'c'}
b.difference_update(a)
print(a, b) # {'a', 'b'} {'c'}
```
* .**intersection\_update**()
```
a = {'a', 'b'}
b = { 'b', 'c'}
a.intersection_update(b)
print(a, b) # {'b'} {'b', 'c'}
a = {'a', 'b'}
b = { 'b', 'c'}
b.intersection_update(a)
print(a, b) # {'b', 'a'} {'b'}
```
* .**symmetric\_difference\_update**()
```
a = {'a', 'b'}
b = { 'b', 'c'}
a.symmetric_difference_update(b)
print(a, b) # {'c', 'a'} {'c', 'b'}
a = {'a', 'b'}
b = { 'b', 'c'}
b.symmetric_difference_update(a)
print(a, b) # {'a', 'b'} {'c', 'a'}
```
4 Добавление и удаление элементов изменяемых коллекций
------------------------------------------------------
Добавление и удаление элементов в коллекцию возможно только для изменяемых коллекций: списка (list), множества (только set, не frozenset), словаря (dict). Причём для списка, который является индексированной коллекцией, также важно на какую позицию мы добавляем элемент.
[](https://habrastorage.org/files/be6/e54/3a9/be6e543a942a45d6b80480c946deb583.png)
**Примечания:**
* **Примеры использования метода .insert(index, element)**
```
my_list = [1, 2, 3]
my_list.insert(0, 0) # index = 0 - вставляем в начало
print(my_list) # [0, 1, 2, 3]
my_list.insert(10, 4) # Индекс выходит за границы списка - просто добавим в конец
print(my_list) # [0, 1, 2, 3, 4]
my_list.insert(-10, -1) # Индекс выходит за границы в минус - добавим в начало
print(my_list) # [-1, 0, 1, 2, 3, 4]
my_list = [1, 2, 3]
my_list.insert(1, 1.5) # Вставим между 1 и 2 (индексация с нуля!)
# То есть вставляется на позицию с указанным индексом, а то значение что на ней было
# и те что правее - сдвигаются на 1 индекс вправо
print(my_list) # [1, 1.5, 2, 3]
```
* **Примеры использования оператора del**
```
# Работает со списком
my_list = [1, 2, 3, 4, 5, 6, 7]
del my_list[1] # Удаление элемента по индексу
print(my_list) # [1, 3, 4, 5, 6, 7]
del my_list[-3:-1] # Удаление элементов выбранных срезом
print(my_list) # [1, 3, 4, 7]
# del my_list[10] # IndexError: list assignment index out of range
# Работает со словарем
my_dict = {'a': 1, 'b': 2, 'c': 3}
del my_dict['b']
print(my_dict) # {'a': 1, 'c': 3}
# del my_dict['z'] # KeyError при попытке удалить не сушествующий
```
* Удаление и добавление элементов списка срезом [рассматривается во второй статье](https://habrahabr.ru/post/319200/#2).
* Пример работы .append() и .extend() рассматривается в [третьей главе этой статьи](#3).
5 Особенности работы с изменяемой и не изменяемой коллекцией
------------------------------------------------------------
1. **Строка неизменяемая** коллекция — если мы ее меняем — мы создаем новый объект!
```
str1 = 'abc'
print(str1, id(str1)) # abc 140234080454000
str1 += 'de'
print(str1, id(str1)) # abcde 140234079974992 - Это НОВЫЙ объект, с другим id!
```
Пример кода с двумя исходно идентичными строками.
```
str1 = 'abc'
str2 = str1
print(str1 is str2) # True - это две ссылки на один и тот же объект!
str1 += 'de' # Теперь переменная str1 ссылается на другой объект!
print(str1 is str2) # False - теперь это два разных объекта!
print(str1, str2) # abcde abc - разные значения
```
2. **Список изменяем** и тут надо быть очень внимательным, чтобы не допустить серьезную ошибку! Сравните данный пример с примером со строками выше:
```
list1 = [1, 2, 3]
list2 = list1
print(list1 is list2) # True - это две ссылки на один и тот же объект!
# А дальше убеждаемся, насколько это важно:
list1 += [4]
print(list1, list2) # [1, 2, 3, 4] [1, 2, 3, 4]
# изменилось значение ОБЕИХ переменных, так как обе переменные ссылаются на один объект!
```
А если нужна **независимая копия**, с которой можно работать отдельно?
```
list1 = [1, 2, 3]
list2 = list(list1) # Первый способ копирования
list3 = list1[:] # Второй способ копирования
list4 = list1.copy() # Третий способ копировани - только в Python 3.3+
print(id(list1), id(list2), id(list3), id(list4))
# все 4 id разные, что значит что мы создали 4 разных объекта
list1 += [4] # меняем исходный список
print(list1, list2, list3, list4) # [1, 2, 3, 4] [1, 2, 3] [1, 2, 3] [1, 2, 3]
# как мы и хотели - изменив исходный объект, его копии остались не тронутыми
```
| [Часть 1](https://habrahabr.ru/post/319164/ "Python: коллекции, часть 1/4: классификация, общие подходы и методы, конвертация") | [Часть 2](https://habrahabr.ru/post/319200/ "Python: коллекции, часть 2/4: индексирование, срезы, сортировка") | Часть 3 | [Часть 4](https://habrahabr.ru/post/320288/ "Python: коллекции, часть 4/4: Все о выражениях-генераторах, генераторах списков, множеств и словарей") |
| --- | --- | --- | --- |
#### Приглашаю к обсуждению:
* Если я где-то допустил неточность или не учёл что-то важное — пишите в комментариях, важные комментарии будут позже добавлены в статью с указанием вашего авторства.
* Если какие-то моменты не понятны и требуется уточнение — пишите ваши вопросы в комментариях — или я или другие читатели дадут ответ, а дельные вопросы с ответами будут позже добавлены в статью. | https://habr.com/ru/post/319876/ | null | ru | null |
# Составляем документацию разработчика пошагово без диет и тренировок
Недостаточно просто написать инструкции — важно, как, в каком порядке и где вы их разместите.
Привет! Это Теодора — технический писатель Платформы, жизненно важного департамента Ozon. Документация для нас имеет большое значение, потому что вся компания пользуется нашими разработками:
* инфраструктурой as a service;
* фреймворками и библиотеками на Go, C#, TypeScript;
* трейсингом, мониторингом, логированием, нагрузочным тестированием;
* инструментами для работы с базами данных и аналитикой;
* виртуализацией и контейнеризацией.
Опираясь на свой опыт, я пошагово расскажу, как привести в порядок документацию технической команды, чтобы избавить коллег от однотипных вопросов и наладить межкомандную коммуникацию.
Это гусь Гоша и его постоянно отвлекают техническими вопросами
> ***Дисклеймер****: в этой статье упор сделан на содержание, структуру и формат. Сугубо гуманитарные вещи вроде орфографии и пунктуации обсуждать не будем — они на вашей совести.*
>
>
Зачем вам документация
----------------------
Документация — один из вариантов коммуникации. Обычно к ней прибегают, когда личное общение не решает проблему. Например, когда вы физически не успеваете до всех донести информацию, а кроме вас, это сделать никто не может.
**Плюсы хорошей документации:**
* увеличивается bus-фактор: знание распространяется между большим числом людей, и его сложнее потерять;
* команда не отвлекается на ответы на одни и те же вопросы и занимается своей работой;
* коллеги быстро находят ответы (в том числе через `Ctrl+F`), решают проблемы и разбираются в технологии: как следствие, увеличиваются их продуктивность и доход компании;
* для внешней документации: разгружает сотрудников техподдержки.
Да и, согласитесь, вам просто приятно читать документацию, в которой всё понятно описано и легко искать информацию. Если у вас есть примеры, делитесь в комментариях.
---
Хорошая ли у вас документация?
------------------------------
Пройдите маленький тест и посчитайте набранные баллы:
Результаты:* **5 баллов**: у вас хорошая документация, автор вами гордится!
* **0–4 балла**: есть что доработать — переходите к практическим шагам.
У всех разные ситуации с документацией, поэтому алгоритм действий может различаться для каждого конкретного случая. В статье описаны десять шагов, но не все из них подойдут именно вам. Например, если у вас вообще нет документации, вам не нужно выполнять шаг про удаление неактуального.
Не торопитесь переходить к действиям — сначала налейте чай и просто прочитайте статью.
---
Шаг 1. Соберите всю информацию
------------------------------
Давайте посмотрим, какой материал у вас уже есть. Для этого соберите все описания вашей технологии из разных источников:
* старая документация;
* личные страницы — ваши и коллег (например, в Confluence);
* ответы в чатах;
* репозитории (например, в GitLab);
* Word и другие текстовые редакторы;
* ссылки в закладках браузера.
На будущее: никогда не дублируйте инструкции в разных ресурсах, так их будет сложнее поддерживать:
* легче обновить одну, чем две;
* одну из версий точно забудут обновить — и она будет вводить в заблуждение; как назло всегда будут находить именно её.
---
Шаг 2. Выбросите мусор
----------------------
> Одна актуальная статья лучше десяти устаревших.
>
> Проверено: если у вас в документации найдут устаревшие сведения, никто не будет читать дальше — спросят у вас лично.
>
>
Самый важный шаг перед написанием документации — это избавление от устаревшей информации. Перечитайте всё, что собрали, и удалите неактуальные статьи, разделы и предложения.
Под «избавлением» имеется в виду одно из двух:
* добавление в архив — предпочтительно;
* безвозвратное удаление.
Если после этого вообще ничего не осталось, это нормально.
Если вы детально не знаете начинку описываемой технологииОбычно это актуально для [техписов](https://habr.com/ru/company/ozontech/blog/559544/), аналитиков и менеджеров, которые разработкой не занимались.
✅ **Удачно**: позвать на встречу или созвон эксперта из команды (обычно это тимлид или старший разработчик) и вычитать с ним весь материал полностью, не поверхностно.
❌ **Неудачно**: скинуть материал эксперту и попросить его самого удалить лишнее.
Если плохо выполнить этот шаг, вы потратите много времени зря в будущем. Проверено мной.
После такой «чистки» обычно очень легко дышится — будто камень с шеи снял.
---
### Шаг 3. Найдите частые вопросы и сценарии
Наша новая задача — определить, что нужно задокументировать или актуализировать в первую очередь. Обычно это выясняется так:
1. Вы перечитываете все вопросы в чате за последний месяц, выписываете их на отдельную страницу (не удаляйте её) и считаете их количество.
2. Читаете комментарии с вопросами под инструкциями, если есть.
3. Опрашиваете аудиторию. Обычно это либо пост в публичном чате, либо вопросы знакомому коллеге лично. Формы с опросами, как правило, неэффективны, поскольку собирают мало ответов.
4. Продумываете популярные сценарии с командой, ведь лучше вас продукт никто не знает.
Вначале выпишите вопросы и сценарии, а потом начинайте писать для них тексты.
Если вашей разработкой пока никто не пользовался, будьте готовы собрать обратную связь после релиза и дописать то, что было неясно.
---
Шаг 4. Поделите на разделы
--------------------------
Цель — наметить примерный план будущей базы знаний. Он может дополняться, когда появятся новые данные, но пока нужно сделать «скелет» для всего остального.
Структура нужна, чтобы пользователю было понятно, в каком разделе искать нужную информацию. Это особенно актуально, если в вашей документации много страниц.
Добавить их все сплошным списком вразнобой — провальный вариант. Ctrl+F тут тоже не всегда поможет, потому что, например, вы пишете в названии страницы «кубер», а ваш читатель ищет «Kubernetes» или «k8s», ничего не находит — и идёт к вам в личку.
Целевая аудитория
-----------------
> Читатель должен видеть только то, что ему полезно. Разделяйте документацию в зависимости от потребностей аудитории.
>
>
Подумайте, какие люди будут её читать. Например:
* только ваша команда;
* другие команды, им нужна одна функциональность;
* другие команды, им нужна разная функциональность;
* и ваша команда, и другие команды.
Внешние команды не должны видеть странички «Черновик to do», «[убрать в архив] 2 декабря». Держите их в отдельной папке для черновиков.
Например, если ваша аудитория — продуктовые разработчики и команда мониторинга критичных сервисов, которые ищут в документации абсолютно разные вещи, разделите её соответствующим образом.
---
Шаг 5. Составьте словарь терминов
---------------------------------
> Одна сущность — один термин.
>
>
Договоритесь с командой, как вы что будете называть. Иногда один и тот же термин в разных компаниях используют по-разному, и это путает людей.
Термины должны легко находиться через `Ctrl+F`.
| | |
| --- | --- |
| **Неудачные варианты** | **Удачные варианты** |
| «Пушка», «долбилка» и «стрелялка»;***Почему****:* кажется, что это разные термины, возникает путаница. Не найдётся по `Ctrl+F`. | «Пушка»***Почему***: все коллеги в Ozon знают этот термин. |
| «СronJob'ы», «кроны» и «джобы»;***Почему***: неясно, составляющие это друг друга или одно и то же. Не найдётся по `Ctrl+F`. | «CronJob»***Почему***: все коллеги знают этот термин, он цельный. |
| «Фэктори» и «фабрика», «эккаунт» и «аккаунт», «экшен» и «действие»***Почему***: будьте осторожны с англицизмами. Не используйте их, если есть подходящий термин на русском языке. Не найдётся по `Ctrl+F`. | «Фабрика», «аккаунт» и «действие»***Почему***: популярные, понятные всем термины на русском языке. |
Если у вас в команде есть авторские разработки, названия которых придумали вы сами, заведите словарь терминов с пояснениями. Это особенно актуально, если статей много и неудобно в каждую добавлять расшифровки. Людям будет в разы проще вникнуть в вашу разработку: оставляете везде ссылку на словарь и радуетесь жизни.
---
Шаг 6. Утвердите правила для команды
------------------------------------
> Заранее обговорите с командой правила и план ведения документации.
>
>
Представим, что вы уже составили структуру базы по шагам выше и теперь её нужно поддерживать.
Обычно инструкции в команде пишут разные люди. Часто процессам ведения документации не уделяют должного внимания.
Если не договориться «на берегу», документация всегда превращается в хаос:
* нет структуры — статьи добавляют куда попало;
* никто не убирает устаревшую информацию;
* команда не всегда знает, что у неё есть в документации;
* много заброшенных статей;
* много пустых статей из 2016 с пометкой «to do»;
* перемешаны внутренние черновики и внешняя документация;
* нет архива;
* ведётся на русском, английском, латинском и древнегреческом.
Донесите до команды, что документация — это ваш общий продукт и от её качества зависит эффективность: ваша и других команд.
Пример правил по созданию новых страниц:1. Черновик статьи создавайте в папке для черновиков.
2. Не добавляйте статью в список публичных, пока не допишете.
3. Чтобы перенести статью в список публичных:
* отправьте её в чат команды;
* её должны прочитать минимум два человека, дать обратную связь и утвердить;
* решите с командой, в какой раздел её перенести.
4. Статью можно переносить.
Советую почитать о [методике совместного ведения документации](https://habr.com/ru/post/430500/).
---
Шаг 7. Напишите тексты
----------------------
Лучший способ научиться писать хорошие инструкции — это отдавать их на вычитку. Желательно — редактору. Если его нет — любому коллеге. Я не о проверке пунктуации, а о том, понятно ли написана статья, полная ли в ней информация.
Некоторые советы могут показаться сложными, но в них описаны базовые вещи.
* Освойте инструменты форматирования там, где вы ведёте документацию. Примеры: макросы Confluence, синтаксис Markdown и HTML.
* Укажите, для кого страница и что в ней описано, — тогда человек сразу поймёт, нужно ли ему это читать.
* Не пишите сплошные тексты — делите их на логические абзацы и разделы. При грамотной вёрстке легче сходу найти ответ.
* Добавляйте оглавление. Его цель — дать читателю возможность быстро понять, в какую часть текста ему нужно переместиться. Если оно получилось на сто пунктов, сократите его или разбейте статью на несколько.
* Оформите разводящую страницу. Это главная страница с основной информацией и разделами по темам. Она нужна, чтобы читатель быстро понял, где искать необходимую инструкцию.
[Пример Ozon Docs](https://docs.ozon.ru/main)[Пример Yandex Cloud](https://cloud.yandex.ru/docs)[Пример Amazon EC2](https://docs.aws.amazon.com/ec2/index.html?nc2=h_ql_doc_ec2)
* Соблюдайте форматирование — не пишите весь текст в заголовке или жирным шрифтом, не создавайте таблицу в таблице, не убирайте весь текст под каты.
* Добавляйте ссылки на другие инструкции и сервисы, если они упоминаются в тексте. Это сильно экономит время читателей. Может, они найдут устаревший дубль из [**шага 1**](#step1).
* Избегайте канцеляризмов — они утяжеляют тексты: «~~для того~~ чтобы в ~~данном~~ процессе ~~осуществить определённую~~ функциональность».
* Выделяйте в тексте важное, но не превращайте его в одни сплошные плашки.
* Укажите контакты команды, чтобы читатели знали, к кому обращаться.
---
Шаг 8. Добавьте FAQ
-------------------
FAQ — страница с часто задаваемыми вопросами и ответами на них.
Многие технические писатели считают наличие FAQ признаком плохой структуры документации. Я же советую добавить эту страницу, потому что она может спасти ситуацию, если у вас не очень удачная разводящая страница.
Используйте список из [**шага 3**](#step3), если он есть.
FAQ — это не полноценная инструкция. Не дублируйте тексты и не делайте ответы очень подробными.
Оптимальный вариант — краткий ответ со ссылкой на полную инструкцию. Например, «Да, это возможно. Подробнее в статье “Как создать N”».
Для продвинутых идеалистов:Вопросы можно сгруппировать по темам — так их будет проще найти. Такие страницы FAQ обычно очень нравятся разработчикам, но это не принципиально, потому что обычно вопросы ищут с помощью `Ctrl+F`.
---
Шаг 9. Продумайте, как вашу документацию будут находить
-------------------------------------------------------
> Чтобы ваши труды не пропали даром, вашу документацию должно быть легко найти.
>
>
Подумайте, куда ваши коллеги чаще обращаются за помощью:
* к вам в личку: закрепите ссылку на документацию у себя в профиле на корпоративном портале;
* в ваш чат: закрепите ссылку в шапке, закреплённом сообщении, сделайте так, чтобы каждому вступившему ссылку отправлял бот;
* в поиск Confluence: удалите устаревшую информацию, если ещё этого не сделали, чтобы она не всплывала, понятно называйте статьи.
Уведомите аудиторию, что у вас появилась документация, вы за ней следите и обращаться нужно именно туда.
---
Шаг 10. Проанализируйте результат
---------------------------------
Лучший источник для анализа — ваша аудитория.
Есть несколько способов понять, решает ли проблемы ваша документация.
Что обычно делаю я:
* Считаю количество запросов в чатах.
* Провожу мини-исследование среди читателей: готовлю открытые вопросы, спрашиваю, долго ли они искали информацию, что именно они искали, нашли ли ответы на свои вопросы.
* Изучаю статистику просмотров в Confluence и Grafana: если за месяц никто не обратился к документации, нужна ли она?
Сама не практикую, но отличная идея:
* Добавить фичу «Оцените статью». Такие макросы точно есть в Confluence.
Если на этом этапе не всё гладко — это нормально, просто будьте готовы что-то дописать, поменять местонахождение статьи.
---
Итог
----
Наверное, достаточно информации за раз. Посоветуйтесь с командой, решите, нужна ли вам документация, есть ли ресурсы для её разработки и поддержки.
> И помните, что документация — ваш общий продукт.
>
>
Буду рада ответить на ваши вопросы. Делитесь мнением и историями в комментариях. | https://habr.com/ru/post/687024/ | null | ru | null |
# Эксперименты над олимпиадной задачей
Так получилось, что я попал в магистратуру, и как то гуляя мимо кафедры на глаза попалась олимпиадная задача по 1С. Кратко задача звучит так: «Есть записи продажи за каждый день, необходимо найти наибольший период когда план выполнялся». А потом когда я гулял со спящей дочкой у меня встав вопрос, а сколькими способами это можно сделать на SQL. Решения будут на основе MS SQL.
Создадим таблицу и начнем
**Текст SQL скрипта по созданию таблицы**
```
CREATE TABLE [tmp].[forFindDate](
[date] [datetime] NOT NULL,
[value] [int] NOT NULL,
CONSTRAINT [PK_forFindDate] PRIMARY KEY CLUSTERED
(
[date] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170401', 10)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170402', 20)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170403', 20)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170404', 20)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170405', 10)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170406', 10)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170407', 30)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170408', 36)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170409', 35)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170410', 30)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170411', 30)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170412', 20)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170413', 10)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170414', 40)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170415', 40)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170416', 10)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170417', 50)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170418', 52)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170419', 53)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170420', 53)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170421', 50)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170422', 51)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170423', 52)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170424', 50)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170425', 50)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170426', 50)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170427', 10)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170428', 10)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170429', 10)
INSERT INTO [tmp].[forFindDate] ([date], [value]) VALUES ('20170430', 10)
GO
```
**Первый способ** через соединения самого на себя (через join-ы).
**SQL запросы через join**
```
declare @planValue int = 15
--самый очевидный left
select
top 1
'сам на себя',
BeginDate,
DATEADD(Day, -1, EndDate) EndDate
from (select
s.date BeginDate,
ISNULL(min(e.date), '20170501') EndDate
from [tmp].[forFindDate] s
left join [tmp].[forFindDate] e
on
s.date < e.date
and
not e.value > @planValue
where
s.value > @planValue
group by
s.date) tmp
order by
DATEDIFF(day, BeginDate, EndDate) desc
-- или как мне нравиться больше через with
;with periodDate1 as(
select
s.date BeginDate,
ISNULL(min(e.date), '20170501') EndDate
from [tmp].[forFindDate] s
left join [tmp].[forFindDate] e
on
s.date < e.date
and
not e.value > @planValue
where
s.value > @planValue
group by
s.date
)
select
top 1
'сам на себя (with left)' title,
BeginDate,
DATEADD(Day, -1, EndDate) EndDate
from periodDate1
order by
DATEDIFF(day, BeginDate, EndDate) desc
--меняем на full
;with periodDate2 as(
select
s.date BeginDate,
ISNULL(min(e.date), '20170501') EndDate
from [tmp].[forFindDate] s
full join [tmp].[forFindDate] e
on
s.date < e.date
and
not e.value > @planValue
where
s.value > @planValue
group by
s.date
)
select
top 1
'сам на себя (with full)' title,
BeginDate,
DATEADD(Day, -1, EndDate) EndDate
from periodDate2
order by
DATEDIFF(day, BeginDate, EndDate) desc
--меняем на right
;with periodDate3 as(
select
ISNULL(max(s.date), '20170401') BeginDate,
e.date EndDate
from [tmp].[forFindDate] s
right join [tmp].[forFindDate] e
on
s.date < e.date
and
not s.value > @planValue
where
e.value > @planValue
group by
e.date
)
select
top 1
'сам на себя (with right)' title,
DATEADD(Day, 1, BeginDate) BeginDate,
EndDate
from periodDate3
order by
DATEDIFF(day, BeginDate, EndDate) desc
```
Причем при любом join получим абсолютно одинаковый план (через NESTED LOOP (left outer join)).
**Планы исполнения запросов через join**
**Второй способ** через корреляционный запрос
**SQL запросы через корреляционный запрос**
```
declare @planValue int = 15
;with periodDate4 as(
select
s.date BeginDate,
ISNULL((select DATEADD(DAY, -1, isNull(min(d.date), '20170501')) from [tmp].[forFindDate] d where d.date > s.date and not d.value > @planValue), '20170501') EndDate
from
[tmp].[forFindDate] s
where
s.value > @planValue
)
select top 1
'корреляционный запрос', p.BeginDate, p.EndDate
from
periodDate4 p
order by
DATEDIFF(DAY, p.BeginDate, p.EndDate) desc
```
В данном случай мы получаем NESTED LOOP (inner join)).
**Планы исполнения корреляционного запроса**
**Третий способ** пока все не интересно, теперь возьмем функцию APPLY (появилась в MS SQL 2005). Фактически на каждую строку будем делать под запрос.
**SQL запросы через outer apply**
```
declare @planValue int = 15
;with periodDate5 as(
select
s.date BeginDate,
ISNULL(min(e.date), '20170501') EndDate
from [tmp].[forFindDate] s
outer apply
(
--особенностью храненим данных (сортировка по дате)
select
top 1
ee.date
from
[tmp].[forFindDate] ee
where
s.date < ee.date
and
not ee.value > @planValue
) e
where
s.value > @planValue
group by
s.date
)
select
top 1
'sql 2005 apply' title,
BeginDate,
DATEADD(Day, -1, EndDate) EndDate
from periodDate5
order by
DATEDIFF(day, BeginDate, EndDate) desc
```
В данном случай опять получаем NESTED LOOP (left outer join), но этот способ самый оптимальный на данный момент (по крайне мере так считает MS SQL).
**Планы исполнения apply**
Пока все было скучно и обыденно.
**Четвертый способ** поиграем с рекурсией: к текущей строке будем клеить данные если дата на один день старше и выполняется план продаж. Таким образом будем расширять интервал.
Т.к. данных не много, то длина последовательности небольшая, как и глубина стека вызовов (CTE recursive возможно начиная с 2005).
**SQL запросы рекурсия**
```
declare @planValue int = 15
;with periodDate6 as (
select
f.date BeginDate,
DATEADD(day, 1, f.date) EndDate
from
[tmp].[forFindDate] f
where
f.date = '20170417'
and
f.value > @planValue
union all
select
r.BeginDate,
DATEADD(day, 1, f.date) EndDate
from
[tmp].[forFindDate] f
inner join periodDate6 r
on
r.EndDate = f.Date
and
value > @planValue
)
select
top 1
'recursive' title,
BeginDate,
DATEADD(Day, -1, EndDate) EndDate
from periodDate6
order by
DATEDIFF(day, BeginDate, EndDate) desc
```
**Планы исполнения корреляционного запроса**
**Пятый способ** перейдем к возможностям MS SQL 2012 к аналитической функций LEAD (оконные функций). Функция LEAD возвращает следующие значения со сдвигом в пределах секций по сортировке. Секций в данных у нас две: выполнения и не выполнения плана, сортировка нужна по датам, что бы найти максимальный период поступим хитро: будем искать пропуски в не выполнении плана, т.е. потом когда мы сдвинем даты начала вперед, а конец назад, то получим отрезки выполнения плана. В данном случай нам интересна только секция не выполнения плана её и возьмем, но в целом деление можно сделать так
```
OVER ( PARTITION BY iif(f.value < @planValue, 1, 0) order by f.date)
```
**SQL запросы LEAD**
```
declare @planValue int = 15
with tmp as (
select '20170331' [date]
union all
select
date
from [tmp].[forFindDate] f
where
f.value < @planValue
union all
select '20170501'
), periodDate4 as (
select
date beforDate,
lead(f.date, 1, '20170501')
OVER (order by f.date) afterDate
from tmp f
)
select
top 1
'func 2012 t' title,
DATEADD(Day, 1, beforDate) BeginDate,
DATEADD(Day, -1, afterDate) EndDate
from periodDate4
order by
DATEDIFF(day, beforDate, afterDate) desc
```
На плане исполнения видно, что не происходит соединения таблиц, за исключение добавления дат вне отрезка для корректной работы с концами отрезков.
**Планы исполнения LEAD**
**Шестой способ** А теперь побалуемся перемножим таблицу саму на себя: найдем все возможные сочетания дат (30\*30 = 900), отберем те у которых дата начало меньше даты конца и в этом интервале нет события не исполнения плана.
**SQL запросы рекурсия**
```
declare @planValue int = 15
;with periodDate8 as(
select
ISNULL(s.date, '20170401') BeginDate,
ISNULL(e.date, '20170501') EndDate
from [tmp].[forFindDate] s, [tmp].[forFindDate] e
)
select top 1
'for Fun', p.BeginDate, p.EndDate
from periodDate8 p
left join [tmp].[forFindDate] b
on
b.date between p.BeginDate and p.EndDate
and
not b.value > @planValue
where
p.BeginDate < p.EndDate
and
b.date is null
order by
DATEDIFF(day, BeginDate, EndDate) desc
```
Самый медленный и тяжелый способ. Но мы гонимся не за производительностью, а за количество решений задачи.
**Планы исполнения перемножения таблицы**
**Седьмой способ** Обычный курсор. По перебираем данные у которых план выполнен, и ищем максимальный последовательный участок.
**SQL запросы курсором**
```
declare @planValue int = 15
declare @endDate datetime = null,
@Intervat int = 0,
@maxIntervat int = 0,
@old_date datetime = '20170401',
@cur_date datetime
DECLARE date_cursor CURSOR
FOR SELECT date FROM [tmp].[forFindDate] where value > @planValue
OPEN date_cursor
FETCH NEXT FROM date_cursor
INTO @cur_date
WHILE @@FETCH_STATUS = 0
BEGIN
IF (@cur_date = DATEADD(DAY, 1, @old_date)) BEGIN
SET @Intervat = @Intervat + 1
IF(@Intervat > @maxIntervat) BEGIN
SET @maxIntervat = @Intervat
SET @endDate = @cur_date
END
END else
Begin
set @Intervat = 0
end
SET @old_date = @cur_date
FETCH NEXT FROM date_cursor
INTO @cur_date
END
CLOSE date_cursor;
DEALLOCATE date_cursor;
select 'cursor' title, DATEADD(DAY, - @maxIntervat, @endDate) BeginDate, @endDate EndDate
```
Пока это все, что смог придумать. Жду еще вариантов в комментариях.
**UPD1:**: Вариант от stotsky71@outlook.com. Через оконный функций найдем переходы, между состояниями выполнено/не выполнение плана. И потом подбор интервалов. Могут быть проблемы из-за того, что интервал начался с выполнения плана или закончился выполнение плана, то не произойдет переход и данные подберутся не верно.
**SQL запросы LEAD и LAG**
```
declare @planValue int = 15
;WITH Step01 AS
(SELECT
*
FROM
tmp.forFindDate
WHERE
value > @planValue
)
, Step02 AS
(SELECT
date
, CASE
WHEN date - LAG([date], 1, '20170401') OVER(ORDER BY date) > 1
THEN 1
ELSE 0
END AS isStart
, CASE
WHEN LEAD([date], 1, '20170430') OVER(ORDER BY date) - date > 1
THEN 1
ELSE 0
END AS isEnd
FROM
Step01)
, Step03 AS (
SELECT
date AS rangestart
, CASE
WHEN isEnd = 1
THEN date
ELSE LEAD(date, 1) OVER(ORDER BY date)
END AS rangeend
, isstart
FROM
Step02
WHERE
isstart = 1
OR isend = 1)
SELECT TOP 1
rangestart
, rangeend
, DATEDIFF(day, rangestart, rangeend) AS 'дни'
FROM
Step03
WHERE
isstart = 1
ORDER BY 'дни' DESC
```
Вариант из писем помог оптимизировать мой LEAD запрос (избавился от PARTITION BY в запросе)
**UPD2:** Вариант из переписки. С определение интервалов по сдвигу дат: последовательно идущие даты имеют одинаковое приращения по дням, как обычный инкремент по строкам. На это свойстве можно получить какое то смещения и если смещения у нескольких дат совпадает при росте инкремента, то эти даты идут последовательно.
**SQL ROW\_NUMBER**
```
declare @planValue int = 15
;with internals AS (
SELECT
dateadd(day, -ROW_NUMBER() OVER (ORDER BY date), [date]) fake_start,
[date]
FROM tmp.forFindDate
where
value > 15
)
SELECT TOP 1
'new method' as title,
MIN([date]) AS BeginDate,
MAX([date]) AS EndDate
FROM
internals
GROUP BY
fake_start
ORDER BY
COUNT(*) DESC
``` | https://habr.com/ru/post/327862/ | null | ru | null |
# Компенсация подсветки телевизора
[](https://habr.com/ru/company/ruvds/blog/693268/)
При просмотре телевизора я постоянно вижу красный. В прямом смысле – подсветка моего Panasonic частично не работает, что вызывает неравномерное розовое свечение там, где должен быть белый цвет.
Мне этот старый хлам достался даром, поэтому я особо не жалуюсь, но пару недель назад все же решил как-то отображение цвета наладить.
▍ Проблема
----------
Светодиоды подсветки излучают недостаточно синего или зеленого света. Это означает, что в большинстве участков экрана превалирует красный. Во многих фильмах это выгладит на удивление годно, но в черно-белом кино изображение становится ужасным. С помощью стандартной коррекции цвета исправить преобладание красного спектра невозможно, поскольку из строя вышли лишь некоторые светодиоды. Поэтому я задумался, а не удастся ли мне скорректировать цвета только рядом с этими нерабочими светодиодами?
*Красноватые пятна при просмотре фильма “Береги свою косынку, Татьяна»*
Предположим, дано изображение *x*, которое телевизор искажает в *y = f(x)*. Нам нужно найти обратную функцию *f-1(x)*, которая обратит искажение цвета, на выходе дав *y = f-1(f(x))*. Затем можно использовать ее для компенсации красного цвета перед отправкой изображения на экран.
*Схема предполагаемой конфигурации. Скорректированное изображение *f-1(x)* передается с компьютера через HDMI, искажается функцией *f(x)* телевизора, после чего итоговый цвет воспринимается зрителем*
К сожалению, я знаю, что такой *f-1(x)* не существует. Как уже говорилось, частично рабочая подсветка недостаточно ярко излучает свет на определенных частотах. Компенсировать это с помощью какой-либо предварительной обработки не выйдет.
Вы можете подумать: «А почему бы просто не приглушить каналы зеленого и синего?» Верная мысль – именно так я и собираюсь поступить. Здесь нам потребуется решить уравнение:
Где *с* – это некая константа, предположим *с = 0.9*, а *y* – это реальное изображение, которое зритель хочет видеть. Мы принимаем тот факт, что достичь удастся лишь 90% от максимальной яркости. Теперь пора начать поиск *f-1*. Как вы видели в начале, в разных частях экрана красный проявляется с разной интенсивностью, поэтому постоянная цветокоррекция изображения не сработает. Значит, есть смысл попробовать перехватить искажение, чтобы его отменить.
▍ Чрезмерное усложнение решения
-------------------------------
Я настроил ТВ на показ белого экрана и сделал несколько фото с телефона, чтобы получить изображение неравномерного паттерна распределения пятен. После некоторой коррекции перспективы и размытия в GIMP получилось вот что:
*Это изображение паттерна распределения пятен получено усреднением трех разных картинок с целью устранения муарового узора. Помимо этого, здесь применено гауссово размытие.*
Чисто интуитивно мы решили обратить эффект паттерна тусклой подсветки. Значит, нам нужно как-то «вычесть» это изображение из выходного изображения до его показа на ТВ. Но какой операцией это можно сделать?
Пусть исходное изображение будет *x*, а изображение с пятнами *z*. Утвердим допущение, что искомая функция *f-1(x)* имеет вид *f-1(x) = x \* (gain \* z + offset)* и в коде выглядит так:
```
z = load_image("blobs.png")
def finv(x):
return x * (gain * z + offset)
```
Здесь `gain` и `offset` являются скалярами. В этом коде мы сначала подстраиваем цвета изображения `z`, после чего модулируем с его помощью исходный входной сигнал. Теперь проблема сводится к поиску удачных значений для `gain` и `offset`.
▍ Нахождение обратной функции
-----------------------------
На этом этапе все начало сходить с рельс. Вместо того, чтобы просто попытаться вычислить функцию от руки, я пошел по пути «оптимизации», подключив через USB камеру и направив ее на экран ТВ. При этом я также написал скрипт Python, перебирающий случайные значения для `gain` и `offset` до тех пор, пока не будет получено хорошее изображение. В результате конфигурация стала уже такой:
*В схему добавилась камера. Она видит показываемые телевизором цвета, повторно искажает их собственным откликом g(x) и отправляет кадр на компьютер для анализа.*
Но откуда компьютер знает, как выглядит хорошая картинка? Какой будет функция пригодности? Нельзя ли просто попиксельно вычислить разницу с помощью `error = |x - camera_img|`? Проблема этого подхода в том, что у камеры есть собственное искажение цветов, которое на схеме представлено как *g(x)*. Это усложняет составление грамотной функции пригодности.
После нескольких тщетных попыток получить статистику изображения я понял, что можно вручную подредактировать картинку с камеры и использовать ее в качестве эталона.
*Исходное изображение с камеры (слева) и отредактированная картинка (справа), которая будет считаться эталоном*
Теперь можно минимизировать среднюю разницу в пикселях между эталонным изображением и любым другим, поступающим с камеры. Получается следующий цикл:
```
import numpy as np
z = load_image('blobs.png')
gt = load_image('ground_truth.png')
# Здесь мы применяем ранее упомянутую константу "c".
gt *= 0.9
# Индексы в массиве "params".
GAIN = 0
OFFSET = 1
params = np.zeros(2)
params[GAIN] = 1.0
params[OFFSET] = 0.0
# Наша функция f^-1, описанная ранее.
def finv(x):
return x * (z * params[GAIN] + params[OFFSET])
best_fitness = 0
best_params = np.copy(params)
while True:
# "frame" по факту получается с выдержкой в одну секунду для исключения шума.
frame = capture_camera_img()
# Предположим, что интенсивность изображения находится в диапазоне [0, 1].
# Функция пригодности равна один минус норма L1 разницы в пикселях.
fitness = 1 - np.mean(np.abs(frame - gt))
if fitness > best_fitness:
best_fitness = fitness
best_params = np.copy(params)
print(best_fitness, best_params)
# Рандомизация параметров.
params[GAIN] = np.random.random() * -1. - 0.1 # диапазон [-1.1, -0.1]
params[OFFSET] = np.random.random() * 2 # диапазон [0, 2]
# Обновление изображения, показываемого на ТВ.
# Мы показываем скорректированную пустую белую картинку, оценивая относительно нее очередной кадр.
white_img = np.ones_like(frame)
show_on_tv(finv(white_img))
```
Итак, по итогу у нас получилась следующая функция:
Здесь *z* по-прежнему является тем же изображением с пятнами.
Вот, что получается при применении этой функции к видеокадру:
*Результаты обратной функции. Входные изображения (левый столбец) и соответствующие изображения на ТВ (правый столбец). Скорректированная картинка показана в левом нижнем углу и имеет зеленоватый оттенок, однако ее результат справа получился по цветам уже более сбалансированным. Заметьте, что сюда также входит глобальная коррекция цвета конечного шейдера. [Полноразмерная картинка](http://www.lofibucket.com/articles/img/tv/fourway_comparison.jpg)*
Оглядываясь назад, можно заметить, что она очень похожа на *f-1(x) = x \* (-z + 1.5)*, к чему можно было прийти и без какого-либо автоматизированного поиска. Кроме того, остальные решения, возвращенные в его результате, оказались совсем безобразными. Но сейчас это уже не важно, поскольку у нас есть обратная функция, которую самое время использовать.
▍ Добавление в MPC-BE собственного шейдера
------------------------------------------
Вся суть этого эксперимента в улучшении изображения в черно-белом кино. Я решил добавить в [проигрыватель MPC-BE](http://forum.doom9.org/showthread.php?t=165890) собственный шейдер. Было бы здорово применить коррекционный фильтр ко всему экрану, а не только к воспроизводимому в приложении видео, но способа это реализовать я не придумал. MPC-BE хорош тем, что предоставляет возможность редактирования шейдеров в реальном времени:
*Редактор шейдеров в MPC-BE*
Основная проблема заключалась в необходимости передать в шейдер изображение *blobs.png*. Это заняло немало времени, но в конечном итоге мне удалось взломать поддержку внешних текстур и немного подстроить яркость и цвета. Получилось превосходно:
*Цветокоррекция с помощью f-1(x) сильно помогла*
Работает! По краям все еще наблюдается эффект виньетирования, но самый неприятный частотный разнобой устранен. Можете также посмотреть полноценные снимки [до](http://www.lofibucket.com/articles/img/tv/kaurism%C3%A4ki_before.jpg) и [после](http://www.lofibucket.com/articles/img/tv/kaurism%C3%A4ki_after.jpg).
▍ Заключение
------------
Конкретно этот телевизор уже дважды бывал в ремонте, поэтому здорово, что мне удалось еще немного продлить его срок службы с помощью небольшого хака. После корректировки цветов я еще не смотрел фильм целиком, поэтому может обнаружиться необходимость дополнительных доработок.
В статье я не затронул тему калибровки камеры. Пришлось поломать голову в поиске простейшего способа сделать это (без использования проекционных матриц), о чем я, возможно, напишу отдельный пост.
**Дополнение: конечный шейдер colorfix.hlsl**
Предполагается, что `sampler s0` содержит входное видео, а `sampler s1` изображение с пятнами.
```
// $MinimumShaderProfile: ps_2_0
sampler s0 : register(s0);
sampler s1 : register(s1);
float4 main(float2 tex : TEXCOORD0) : COLOR {
float4 c0 = tex2D(s0, tex);
float4 c1 = tex2D(s1, tex);
float3 c1b = float3(-0.9417, -0.9417, -0.9417) * c1.rgb + float3(1.48125, 1.48125, 1.48125);
float4 c2 = c0 * float4(c1b.rgb, 1.);
c2 *= float4(1.05, 1., 1.15, 1.);
c2 *= 0.95;
return c2 ;
}
```
**Дополнение: патч для MPC BE**
```
Index: src/filters/renderer/VideoRenderers/SyncRenderer.cpp
===================================================================
--- src/filters/renderer/VideoRenderers/SyncRenderer.cpp (revision 5052)
+++ src/filters/renderer/VideoRenderers/SyncRenderer.cpp (working copy)
@@ -45,6 +45,16 @@
#include "../DSUtil/DXVAState.h"
#include "../../../apps/mplayerc/resource.h"
+#define NOMINMAX
+#include
+namespace Gdiplus
+{
+ using std::min;
+ using std::max;
+}
+#include "../../../apps/mplayerc/PngImage.h"
+
+
using namespace GothSync;
using namespace D3D9Helper;
@@ -654,6 +664,45 @@
}
hr = m\_pD3DDevEx->ColorFill(m\_pVideoSurfaces[m\_iCurSurface], nullptr, 0);
+
+
+ CMPCPngImage pattern;
+ DLog(L"Loading pattern texture");
+ // TODO use relative path
+ if (pattern.Load(L"C:\\dev\\opensource\\mpcbe-code\\pattern2.png") == E\_FAIL) {
+ DLog(L"Loading failed");
+ }
+ else {
+ DLog(L"Pattern: %dx%d @ %d bpp, IsDIB: %d", pattern.GetWidth(), pattern.GetHeight(), pattern.GetBPP(), pattern.IsDIBSection());
+ if (FAILED(hr = m\_pD3DDevEx->CreateTexture(
+ pattern.GetWidth(), pattern.GetHeight(), 1, D3DUSAGE\_DYNAMIC, D3DFMT\_A8R8G8B8, D3DPOOL\_DEFAULT, &m\_pPatternTexture, nullptr))) {
+
+ DLog(L"Texture creation failed");
+ return hr;
+ }
+ else {
+ DLog(L"Pattern texture OK");
+ unsigned char\* data = (unsigned char\*)pattern.GetBits();
+ int pitch = pattern.GetPitch();
+ DLog("Data: %p, pitch: %d bytes\n", data, pitch);
+
+ D3DLOCKED\_RECT rect = {};
+ m\_pPatternTexture->LockRect(0, ▭, NULL, D3DLOCK\_DISCARD);
+ DLog("Rect pBits: %p, rect.pitch: %d bytes\n", rect.pBits, rect.Pitch);
+ for (int y = 0; y < pattern.GetHeight(); y++) {
+ for (int x = 0; x < pattern.GetWidth(); x++) {
+ unsigned char\* pix = (unsigned char\*)rect.pBits + (y \* rect.Pitch + 4 \* x);
+ pix[0] = data[y \* pitch + 4 \* x + 0];
+ pix[1] = data[y \* pitch + 4 \* x + 1];
+ pix[2] = data[y \* pitch + 4 \* x + 2];
+ pix[3] = data[y \* pitch + 4 \* x + 3];
+ }
+ }
+
+ m\_pPatternTexture->UnlockRect(0);
+ }
+ }
+
return S\_OK;
}
@@ -669,6 +718,7 @@
m\_pRotateTexture = nullptr;
m\_pRotateSurface = nullptr;
m\_pResizeTexture = nullptr;
+ m\_pPatternTexture = nullptr;
}
// ISubPicAllocatorPresenter3
@@ -1483,6 +1533,8 @@
Shader.Compile(m\_pPSC);
}
hr = m\_pD3DDevEx->SetPixelShader(Shader.m\_pPixelShader);
+
+ hr = m\_pD3DDevEx->SetTexture(1, m\_pPatternTexture);
TextureCopy(m\_pScreenSizeTextures[src]);
std::swap(src, dst);
Index: src/filters/renderer/VideoRenderers/SyncRenderer.h
===================================================================
--- src/filters/renderer/VideoRenderers/SyncRenderer.h (revision 5052)
+++ src/filters/renderer/VideoRenderers/SyncRenderer.h (working copy)
@@ -153,6 +153,7 @@
CComPtr m\_pOSDSurface;
CComPtr m\_pScreenSizeTextures[2];
CComPtr m\_pResizeTexture;
+ CComPtr m\_pPatternTexture;
CComPtr m\_pLine;
CComPtr m\_pFont;
CComPtr m\_pSprite;
```
> **RUVDS | Community [в telegram](https://bit.ly/3KZeaxv) и [уютный чат](https://bit.ly/3qoIOXs)**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=kompensaciya_podsvetki_televizora) | https://habr.com/ru/post/693268/ | null | ru | null |
# В поисках пропавшего программиста. Новогодний квест
Всем здравствуйте.
Вот в преддверии нового года решил написать, такой экспериментально развлекательный пост-квест. Сил на серьезную статью уже нет, и мысленно находясь уже на каникулах, решил немного развлечь «хабронаселение» сим творением. Тем кто решиться разгадать эту тайну придется немного выбраться за пределы «хабра» и расследовать таинственное исчезновение одного незадачливого программиста.
А если серьезно, то это несколько занимательных, несложных задачек связанных незатейливым сюжетом. Ценителям жанра думаю «зайдет», да и просто тем кто любит задачки на логику. Для разгадки достаточно будет элементарных знаний в программировании.
Всем приятного чтения, надеюсь квест вам понравится.
### Пролог
— Абонент не отвечает, или находится вне зоны действия сети. Вы можете оставить свое сообщение после сигнала.
Это стандартное сообщение, которое вот уже два дня я слышу, пытаясь дозвониться своему другу и коллеге Валерию N. И на данный момент терпение мое достигло предела, а все из-за того, что через день нам нужно сдавать проект, а он (Валера) куда-то пропал и не выходит на связь. Ни в соцсетях, ни в мессенджерах, ни даже по телефону.
### Визит к другу
Ну все. Терпение закончилось, причем закончилось настолько, что была преодолена даже лень выходить на улицу и на метро тащиться через пол города к нему домой! Район для жизни конечно Валера выбрал исключительно не жизнеутверждающий, что сразу же и подтвердилось. Как только я зашел в подъезд, бросилось в глаза что в ряду почтовых ящиков, висящих на противоположной от входа стене, один вскрыт, самым варварским способом. Ну и конечно же это оказался ящик моего друга. С мыслью что сейчас поднимусь и вручу ему героически спасенную корреспонденцию, вытащил из ящика письмо и сунул его в карман. Письмо еще тогда привлекло внимание тем, что было подписано от руки и не походило на спам, я даже успел удивился, что до сих пор кто-то пишет письма.
Поднявшись на седьмой этаж, я обнаружил, что его дверь приоткрыта. Изнутри доносились шаги. Я конечно не паникер, мало ли, забыл закрыть дверь, но все же стало как-то не по себе. Человек два дня не выходит на связь, а тут еще и его квартира чуть ли не на распашку. Решил включить на всяких случай камеру на запись.
— Валера – кричу в приоткрытую дверь
— Нет его дома
Голос его подружки Мари (на самом деле она Маша, но требует, чтобы все называли ее Мари). Вот блин, не знал, что они уже живут вместе, буквально как неделю назад Валерка жаловался, что она ему шагу ступить не дает, а тут — на тебе — уже съехались. Не самый конечно приятный разговор у нас состоялся, точнее это был не разговор, а допрос, вперемешку с оправданиями. В результате безуспешных, вследствии того, что я и сам ничего не знаю, попыток выведать у меня где же пропадает ее любимый, я быстро потерял для Мари интерес и был «отпущен» домой.
### Странности продолжаются
Я же из разговора смог узнать, что Валера пропал внезапно, их общие знакомые про это ничего не знают, записок никаких не оставлял, писем и сообщений не отправлял, а вместо этого, зачем-то повесил на зеркало странную карту, на которой ничего не отмечено. Вот она:
Всю дорогу до дома я размышлял, куда же Валера мог так неожиданно исчезнуть. Что-то мне не давало покоя, но никак не мог понять, что, и только дома я понял. Письмо. Письмо же я не отдал, ну и конечно с угрызениями совести, но понимая, что там может быть разгадка, я вскрыл конверт. Вот что в нем было:
> `Ясность нашей позиции очевидна: реализация намеченных плановых заданий позволяет выполнить важные задания по разработке переосмысления внешнеэкономических политик. Идейные соображения высшего порядка, а также сложившаяся структура организации предопределяет высокую востребованность модели развития. И нет сомнений, что независимые государства, превозмогая сложившуюся непростую экономическую ситуацию, представлены в исключительно положительном свете. Каждый из нас понимает очевидную вещь: экономическая повестка сегодняшнего дня предполагает независимые способы реализации экономической целесообразности принимаемых решений. Равным образом, повышение уровня гражданского сознания выявляет срочную потребность благоприятных перспектив.`
Тарабарщина какая-то. Кто мог это написать? В общем в этот момент я уже начал не на шутку волноваться. Это же явный псих только мог написать такое. Судя по всему, Валера вляпался во что-то не очень хорошее. Вспомнив про бесполезную карту, которая висела на зеркале, сопоставив пропажу и письмо во вскрытом ящике, пришла мысль, а что, если все это не такое уж и бесполезное, может просто чего-то не хватает для полноты картины. Как хорошо, что пока я разговаривал с Мари, не выключил запись видео на телефоне, и сейчас самое время ее просмотреть более подробно.
### Зацепки
И вот что первое бросилось в глаза. Я тоже долго не мог понять, что тут не так, вроде бы стол как стол, завален всяким хламом, но что-то на нем не так, что-то туда не вписывается.
[Оригинальный кадр по ссылке](https://yadi.sk/i/L46iPaQQzy5WFQ)
Пересмотрев практически покадрово видео, в одном из кадров тоже удалось заметить кое-что странное, но неразборчивое. После долгих попыток приблизить, как в кино, этот кадр и попыток изменением контрастности и цветности сделать его сколь-нибудь удобочитаемым, вот что получилось:
Итого, мы имеем: конверт с неразборчивым почерком; бессмысленное письмо внутри конверта; карту, прилепленную к зеркалу и два скрина с видео. Не густо конечно, но думаю этого хватит, чтобы разгадать это коварное преступление!
Подсказки, если понадобятся, будут позже :) | https://habr.com/ru/post/481956/ | null | ru | null |
# Обзор python-пакета yadirstat — самый простой способ получить статистику из API Яндекс Директ
Здравствуйте, мне приходится собирать статистику из Яндекс Директ и, чтобы упростить работу, я опубликовал свой python-пакет, с помощью которого это можно делать очень просто.
*Сначала вам следует получить токен для своего аккаунта ([подробнее тут](https://yandex.ru/dev/oauth/doc/dg/tasks/get-oauth-token-docpage/))*
Пакет yadirstat уже опубликован на pypi — вы сможете установить его с помощью pip
```
pip install yadirstat
```
Пакет позволяет получить следующую статистику:
* Статистика по кампаниям
* Статистика по условиям показов (например, ключевые слова и аудитории)
* Статистика по поисковым запросам
#### Как запрашивается статистика:
```
yadirstat.yadirstat.тип запроса(Токен клиента, Логин клиента, Дата начала, Дата окончания)
```
Примерно так будет выглядеть **запрос для получения статистики по поисковым запросам**
```
query_report =yadirstat.yadirstat.query('блаблаБЛАБЛАблаблАбалблаблаб','клиент-1245234','2020-05-10','2020-07-15')
print(query_report)
```
А так **запрос для получения статистики по кампаниям**:
```
campaign_report = yadirstat.yadirstat.campaign('блаблаБЛАБЛАблаблАбалблаблаб','клиент-1245234','2020-05-10','2020-07-15')
print(campaign_report)
```
А так **запрос для получения статистики по условиям показов**:
```
criteria_report = yadirstat.yadirstat.criteria('блаблаБЛАБЛАблаблАбалблаблаб','клиент-1245234','2020-05-10','2020-07-15')
print(criteria_report)
```
Пример моего запроса:
```
from yadirstat import yadirstat
x = yadirstat.yadirstat.campaign('AgAAAxxxxxxxXXXXXXxxxxxXXXXXcI','BxxxxXXXX','2020-05-10','2020-07-15')
print(x)
```
Вывод выглядит следующим образом:
Если во время вывода данные не помещаются, можете использовать следующее:
```
import pandas as pd
pd.set_option('display.max_columns', None)
pd.set_option('display.expand_frame_repr', False)
pd.set_option('max_colwidth', 80)
pd.set_option('max_rows', 600000)
```
На выходе мы получаем DataFrame.
Для полноценного использования я заменяю "--" на «0»
#### Структура данных
Поисковые запросы:
* CampaignName
* Query
* Impressions
* Clicks
* Ctr
* Cost
* AvgCpc
* ConversionRate
* CostPerConversion
* Conversions
Кампании\*:
* Date
* CampaignName
* Impressions
* Clicks
* Ctr
* Cost
* AvgCpc
* BounceRate
* AvgPageviews
* ConversionRate
* CostPerConversion
* Conversions
* Date
Условия показа:
* CampaignName
* Criterion
* Impressions
* Clicks
* Ctr
* Cost
* AvgCpc
* Date
\*- Добавление даты последним столбцом позволяет не терять данные по датам при передачи DataFrame (Например, при передаче в BigQuery, теряется столбец с датами из-за того, что он индексный, чтобы избежать проблем я просто продублировал этот столбец).
Почему именно такая структура? Именно так я собираю статистику, чтобы потом отправлять ее в Google BigQuery и далее визуализировать в Google DataStudio.
Буду рад выслушать предложения по развитию данного пакета и ваш опыт сбора статистики.
P.S:
* С агентскими аккаунтами это тоже работает
* И с аккаунтами еламы | https://habr.com/ru/post/512902/ | null | ru | null |
# Sapper: Royal Engineer
Хабраразработчики, приветствую!
В данном посте я расскажу «историю» разработки и публикации первой нашей игры: как рисовался дизайн, как разрабатывали, с какими трудностями столкнулись, почему StackOverflow лучше Apple Dev Forums и т.д.
Игра делалась с целью формирования механизмов взаимодействия с дизайнером, для последующего ускорения разработки на более сложных играх, поэтому судите строго (на столько, насколько это возможно).
Картинки для привлечения внимания:
 
 
#### С чего всё началось?
Так получилось, что на новой работе, по определенным причинам, пришлось заниматься разработкой игр для автоматов. Работал я с талантливым дизайнером, который очень сильно хотел разрабатывать другие игры (на мобильные платформы, под PC, XBox и т.д). Вот мы с ним и решили параллельно разработать что-то интересное, но в то же время не слишком сложное, чтобы наша разработка не затянулась на 4-5-6 месяцев. Ни я, ни он не были готовы к такому затяжному прыжку.
Сапёр был не той идеей за которую мы хотели с самого начала взяться.
Вот, за что мы хотели браться, но рады очень, что вовремя верно оценили наши силы:
**Скриншоты**
Во-первых не хотелось брать слишком сложную игру потому, что я не мог еще оценить возможности SpriteKit и очень не хотелось оказаться в середине разработки и понять, что реализовать какую-то фичу получится только через пень-колоду.
На StackOverflow я видел, что очень активно поддерживается Cocos2D самим автором (LearnCocos2D), но мне очень хотелось попробовать именно SpriteKit после презентации Apple и показа игры [Adventure](https://developer.apple.com/Library/ios/documentation/GraphicsAnimation/Conceptual/CodeExplainedAdventure/AdventureArchitecture/AdventureArchitecture.html#//apple_ref/doc/uid/TP40013140). Огорчил меня правда тот факт, что в XCode встроена визуализация частиц, а я XCode хочу реже открывать.
#### Инструменты
На начальных этапах связка XCode + AppCode, Photoshop.
Потом только AppCode и Photoshop.
Про SpriteKit можно посмотреть [здесь](https://developer.apple.com/library/ios/documentation/GraphicsAnimation/Conceptual/SpriteKit_PG/Introduction/Introduction.html) или [здесь](http://devstreaming.apple.com/videos/wwdc/2013/503xbx3xoaktjug4e05xvl04/503/503-HD.mov?dl=1).
#### Дизайн (ретина, не ретина, 4 и 5 iPhone)
Я сразу был за то, чтобы 4 iPhone мы не поддерживали и не парились с еще кучей изображений, которых у нас и так было достаточно из-за особенностей локализации приложения. Раз отказались от 4 и всего, что ниже, значит рисовать надо только под ретину — отлично!
Вот, например, как выглядел наш первый вариант:
**Скриншоты**
Дальше мы задавались примерно такими вопросами:
* Должна ли быть реклама на игровом экране и закрывать игровое поле?
* Учитывать ли при отрисовке фонового изображения размеры и положение рекламного блока?
* Должна ли быть кнопка «Меню» или же кнопка «Назад»?
* Что показывать после того, как пользователь выиграл или проиграл?
* и т.д.
Следующие уже версии выглядели примерно так:
**Скриншоты**
Давайте дизайнеру волю, но контролируйте. Дело в том, что шрифта, который он использовал для надписей затраченного времени и кол-ва бомб на поле, нет в стандартном списке, значит надо искать в интернете. Но это еще ничего, дело в том, что надо еще найти \_правильный\_ шрифт с учетом того, что за надписью находится фоновое изображение с 4 серыми цифрами с определенными расстояниями между ними, а в большинстве случаев мы сталкивались с тем, что при изменении надписи с «111» до «888» ширина текстовой надписи (UILabel) изменялась и менялось само расстояние между символами, что нас не устраивало… однако, нужный шрифт был найден, слава Богу, иначе пришлось бы делать 10 изображений, позиционировать их и обновлять счетчик соответствующим образом. Казалось бы, простой шрифт, но увы, не всё так просто (в разделе «Разработка» расскажу, что еще интересного было со шрифтом этим).
Со спрайтами проблем не было никаких. Больше всего нам доставлял удовольствие вот этот переключатель:
 
Три вещи над которыми дизайнер дольше всего работал:
* Фоновое изображение главного экрана
* Фоновое изображение экрана настроек
* Анимация взрыва бомбы
Анимация взрыва бомбы содержит порядка 40 кадров (на скриншоте ниже два типа взрыва).
Столкнулись мы с дизайнером еще с одной проблемкой — позиционирование элементов и указание позиций. Для него это совершенно не принципиально, пиксель влево, пиксель вправо — не имеет значения… он рисует всё без линеек, уж такой вот творческий человек :)
Меня этот вариант совсем не устраивал, потому что позиционировать мне как-то надо, а значит нужны хоть какие-то координаты/размеры.
Получилось как-то так:
Удобно, но что-то здесь не так, меня не покидает такое чувство.
#### Звуки
Со звуками тоже пришлось разбираться дизайнеру. Мы нашли подходящий сайт [www.freesound.org](http://www.freesound.org/) и использовали некоторые звуки (совсем без обработки не получилось — обрезание, фильтрация):
* Взрыв
* Откапывание
* Нажатие на любой «кнопочный» элемент
#### Разработка
Начиналось всё со сторибордов:
Закончилось:
Проектирование, проектирование, проектирование… херня полная. Создаешь каркас, а дальше на него начинаешь наворачивать функционал, логику, графику и т.д. От начала разработки до конца у меня структура проекта не менялась, но схемы взаимодействия и логики работы контроллеров — множество раз.
Начнем с главного экрана. Две кнопки, по тапу осуществляется переход на экран игры и в настройки. Барабанная дробь… по тапу еще проигрывается звук, а значит здесь либо SystemSound, либо AVAudioPlayer (либо еще что-то), а значит нужна предзагрузка, а значит нужен еще какой-то класс, который бы отвечал за предзагрузку всех звуков и их воспроизведение. Так и получилось — BGAudioPreloader.
```
@interface BGResourcePreloader : NSObject
+ (instancetype)shared;
// предзагружает аудио файл и готовит его к проигрыванию
- (void)preloadAudioResource:(NSString \*)name;
// возвращает аудиопроигрыватель для воспроизведения аудио файла с именем name и
// расширением type
// nil - если звуки отключены
- (AVAudioPlayer \*)playerFromGameConfigForResource:(NSString \*)name;
// возвращает аудиопроигрыватель для воспроизведения аудио файла с именем name и
// расширением type. Не зависит от настроек звука
- (AVAudioPlayer \*)playerForResource:(NSString \*)name;
@end
```
Реализация вот такая:
```
//
// BGResourcePreloader.m
// Miner
//
// Created by AndrewShmig on 4/5/14.
// Copyright (c) 2014 Bleeding Games. All rights reserved.
//
#import "BGResourcePreloader.h"
#import "BGSettingsManager.h"
@implementation BGResourcePreloader
{
NSMutableDictionary *_data;
}
#pragma mark - Class methods
static BGResourcePreloader *shared;
+ (instancetype)shared
{
static dispatch_once_t once;
dispatch_once(&once, ^{
shared = [[self alloc] init];
shared->_data = [[NSMutableDictionary alloc] init];
});
return shared;
}
#pragma mark - Instance methods
- (void)preloadAudioResource:(NSString *)name
{
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
NSString *soundPath = [[NSBundle mainBundle]
pathForResource:name
ofType:nil];
NSURL *soundURL = [NSURL fileURLWithPath:soundPath];
AVAudioPlayer *player = [[AVAudioPlayer alloc]
initWithContentsOfURL:soundURL
error:nil];
[player prepareToPlay];
_data[name] = player;
});
}
- (AVAudioPlayer *)playerFromGameConfigForResource:(NSString *)name
{
// звуки отключены
if ([BGSettingsManager sharedManager].soundStatus == BGMinerSoundStatusOff)
return nil;
return [self BGPrivate_playerForResource:name];
}
- (AVAudioPlayer *)playerForResource:(NSString *)name
{
return [self BGPrivate_playerForResource:name];
}
#pragma mark - AVAudioDelegate
- (void)audioPlayerBeginInterruption:(AVAudioPlayer *)player
{
[player stop];
player.currentTime = 0.0;
}
#pragma mark - Private method
- (AVAudioPlayer *)BGPrivate_playerForResource:(NSString *)name
{
return (AVAudioPlayer *) _data[name];
}
@end
```
На главном экране больше ничего интересного.
Переходим к экрану настроек.
У нас тут сразу UISegmentedControl (похожий) и переключатель (UIButton).
Перед тем, как писать велосипед с собственным UISegmentedControl я очень тщательно порыл StackOverflow и понял, что лучше не наследоваться, а писать всё-таки велосипед… ничего сложного, но кое-какие особенности есть (механизм работы переключателя таков, что даже водя пальцев по нему, опция активая изменяется и зависит не только от того, где вы подняли палец, но и от того, где сейчас ваш палец находится).
Основная обработка изменения состояния переключателя выглядит следующим образом:
```
#pragma mark - Touches
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{
[self updateSegmentedControlUsingTouches:touches];
}
- (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event
{
[self updateSegmentedControlUsingTouches:touches];
}
- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event
{
[self updateSegmentedControlUsingTouches:touches];
}
#pragma mark - Private method
- (void)updateSegmentedControlUsingTouches:(NSSet *)touches
{
UITouch *touch = [touches anyObject];
CGPoint touchPoint = [touch locationInView:self];
for (NSUInteger i = 0; i < _selectedSegments.count; i++) {
CGRect rect = ((UIImageView *) _selectedSegments[i]).frame;
if (CGRectContainsPoint(rect, touchPoint)) {
if (self.selectedSegmentIndex != i) {
// проигрываем звук нажатия - единожды и только на новом
// значении
[[[BGResourcePreloader shared]
playerFromGameConfigForResource:@"buttonTap.mp3"]
play];
}
self.selectedSegmentIndex = i;
break;
}
}
[_target performSelector:_action
withObject:@(_selectedSegmentIndex)];
}
```
Вопросов не возникает.
Любимый наш элемент — переключатель. Сперва он работал как обычная кнопка, но меня это постоянно бесило потому, что ощущения не те и хочется чувствовать, что он настоящий и работает так, как это делает настоящий.
В итоге получил следующий код для переключения между состояниями:
```
#pragma mark - Touches
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{
// не надо обрабатывать это нажатие
}
- (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event
{
BGLog();
[self updateActiveRegionUsingTouches:touches];
if ((self.isOn && self.activeRegion == BGUISwitchLeftRegion) ||
(!self.isOn && self.activeRegion == BGUISwitchRightRegion)) {
[super touchesMoved:touches withEvent:event];
[self playSwitchSound];
[_target performSelector:_action withObject:self];
self.on = !self.on;
}
}
- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event
{
BGLog();
[self updateActiveRegionUsingTouches:touches];
if ((self.isOn && self.activeRegion == BGUISwitchLeftRegion) ||
(!self.isOn && self.activeRegion == BGUISwitchRightRegion)) {
[super touchesEnded:touches withEvent:event];
[self playSwitchSound];
[_target performSelector:_action withObject:self];
self.on = !self.on;
}
}
- (void)updateActiveRegionUsingTouches:(NSSet *)touches
{
UITouch *touch = [touches anyObject];
CGPoint touchPoint = [touch locationInView:self];
CGRect leftRect = CGRectMake(0, 0, self.bounds.size.width / 2, self.bounds.size.height);
CGRect rightRect = CGRectMake(self.bounds.size.width / 2, 0, self.bounds.size.width / 2, self.bounds.size.height);
if (CGRectContainsPoint(leftRect, touchPoint)) {
_activeRegion = BGUISwitchLeftRegion;
} else if (CGRectContainsPoint(rightRect, touchPoint)) {
_activeRegion = BGUISwitchRightRegion;
} else {
_activeRegion = BGUISwitchNoneRegion;
}
}
```
При каждом изменении состояния мы сохраняем новое значение настроек в менеджере настроек. Менеджер настроек (который в релизнутом приложении) получился дерьмовым, потом я написал новый, но пока не заменил.
Вот исходный код нового менеджера настроек:
```
static NSString* const kBGSettingManagerUserDefaultsStoreKeyForMainSettings = @"kBGSettingsManagerUserDefaultsStoreKeyForMainSettings";
static NSString* const kBGSettingManagerUserDefaultsStoreKeyForDefaultSettings = @"kBGSettingsManagerUserDefaultsStoreKeyForDefaultSettings";
// Class allows to work with app settings in a simple and flexible way.
@interface BGSettingsManager : NSObject
// Delimiters for setting paths. Defaults to "." (dot) character.
@property (nonatomic, readwrite, strong) NSCharacterSet *pathDelimiters;
// Boolean value which specifies if exception should be thrown if settings path
// doesn't exist or they are incorrect. Defaults to YES.
@property (nonatomic, readwrite, assign) BOOL throwExceptionForUnknownPath;
+ (instancetype)shared;
// creates default settings which are not used as main settings until
// resetToDefaultSettings method is called
// example: [[BGSettingsManager shared] createDefaultSettingsFromDictionary:@{@"user":@{@"login":@"Andrew", @"password":@"1234"}}]
- (void)createDefaultSettingsFromDictionary:(NSDictionary *)settings;
// resets main settings to default settings
- (void)resetToDefaultSettings;
// clears/removes all settings - main and default
- (void)clear;
// adding new setting value for settingPath
// example: [... setValue:@YES forSettingsPath:@"user.personalInfo.married"];
- (void)setValue:(id)value forSettingsPath:(NSString *)settingPath;
// return setting value with specified type
- (id)valueForSettingsPath:(NSString *)settingsPath;
- (BOOL)boolValueForSettingsPath:(NSString *)settingsPath;
- (NSInteger)integerValueForSettingsPath:(NSString *)settingsPath;
- (NSUInteger)unsignedIntegerValueForSettingsPath:(NSString *)settingsPath;
- (CGFloat)floatValueForSettingsPath:(NSString *)settingsPath;
- (NSString *)stringValueForSettingsPath:(NSString *)settingsPath;
- (NSArray *)arrayValueForSettingsPath:(NSString *)settingsPath;
- (NSDictionary *)dictionaryValueForSettingsPath:(NSString *)settingsPath;
- (NSData *)dataValueForSettingsPath:(NSString *)settingsPath;
@end
```
Часть с реализацией:
```
//
// Copyright (C) 4/27/14 Andrew Shmig ( andrewshmig@yandex.ru )
// Russian Bleeding Games. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
#import "BGSettingsManager.h"
@implementation BGSettingsManager
{
NSMutableDictionary *_defaultSettings;
NSMutableDictionary *_settings;
}
#pragma mark - Class methods
+ (instancetype)shared
{
static dispatch_once_t once;
static BGSettingsManager *shared;
dispatch_once(&once, ^{
shared = [[self alloc] init];
shared->_pathDelimiters = [NSCharacterSet characterSetWithCharactersInString:@"."];
shared->_throwExceptionForUnknownPath = YES;
[shared BGPrivateMethod_loadExistingSettings];
});
return shared;
}
#pragma mark - Instance methods
- (void)createDefaultSettingsFromDictionary:(NSDictionary *)settings
{
_defaultSettings = [self BGPrivateMethod_deepMutableCopy:settings];
[self BGPrivateMethod_saveSettings];
}
- (void)resetToDefaultSettings
{
_settings = [_defaultSettings mutableCopy];
[self BGPrivateMethod_saveSettings];
}
- (void)clear
{
_settings = [NSMutableDictionary new];
_defaultSettings = [NSMutableDictionary new];
[self BGPrivateMethod_saveSettings];
}
- (void)setValue:(id)value forSettingsPath:(NSString *)settingPath
{
NSArray *settingsPathComponents = [settingPath componentsSeparatedByCharactersInSet:self
.pathDelimiters];
__block id currentNode = _settings;
[settingsPathComponents enumerateObjectsUsingBlock:^(id pathComponent,
NSUInteger idx,
BOOL *stop) {
id nextNode = currentNode[pathComponent];
BOOL nextNodeIsNil = (nextNode == nil);
BOOL nextNodeIsDictionary = [nextNode isKindOfClass:[NSMutableDictionary class]];
BOOL lastPathComponent = (idx == [settingsPathComponents count] - 1);
if ((nextNodeIsNil || !nextNodeIsDictionary) && !lastPathComponent) {
[currentNode setObject:[NSMutableDictionary new]
forKey:pathComponent];
} else if (idx == [settingsPathComponents count] - 1) {
if ([value isKindOfClass:[NSNumber class]])
currentNode[pathComponent] = [value copy];
else
currentNode[pathComponent] = [value mutableCopy];
}
currentNode = currentNode[pathComponent];
}];
[self BGPrivateMethod_saveSettings];
}
- (id)valueForSettingsPath:(NSString *)settingsPath
{
NSArray *settingsPathComponents = [settingsPath componentsSeparatedByCharactersInSet:self
.pathDelimiters];
__block id currentNode = _settings;
__block id valueForSettingsPath = nil;
[settingsPathComponents enumerateObjectsUsingBlock:^(id obj,
NSUInteger idx,
BOOL *stop) {
// we have a nil node for a path component which is not the last one
// or a node which is not a leaf node
if ((nil == currentNode && idx != [settingsPathComponents count]) ||
(currentNode != nil && ![currentNode isKindOfClass:[NSDictionary class]])) {
[self BGPrivateMethod_throwExceptionForInvalidSettingsPath];
}
NSString *key = obj;
id nextNode = currentNode[key];
if (nil == nextNode) {
*stop = YES;
} else {
if (![nextNode isKindOfClass:[NSMutableDictionary class]])
valueForSettingsPath = nextNode;
}
currentNode = nextNode;
}];
return valueForSettingsPath;
}
- (BOOL)boolValueForSettingsPath:(NSString *)settingsPath
{
return [[self valueForSettingsPath:settingsPath] boolValue];
}
- (NSInteger)integerValueForSettingsPath:(NSString *)settingsPath
{
return [[self valueForSettingsPath:settingsPath] integerValue];
}
- (NSUInteger)unsignedIntegerValueForSettingsPath:(NSString *)settingsPath
{
return (NSUInteger) [[self valueForSettingsPath:settingsPath] integerValue];
}
- (CGFloat)floatValueForSettingsPath:(NSString *)settingsPath
{
return [[self valueForSettingsPath:settingsPath] floatValue];
}
- (NSString *)stringValueForSettingsPath:(NSString *)settingsPath
{
return (NSString *) [self valueForSettingsPath:settingsPath];
}
- (NSArray *)arrayValueForSettingsPath:(NSString *)settingsPath
{
return (NSArray *) [self valueForSettingsPath:settingsPath];
}
- (NSDictionary *)dictionaryValueForSettingsPath:(NSString *)settingsPath
{
return (NSDictionary *) [self valueForSettingsPath:settingsPath];
}
- (NSData *)dataValueForSettingsPath:(NSString *)settingsPath
{
return (NSData *) [self valueForSettingsPath:settingsPath];
}
- (NSString *)description
{
return [_settings description];
}
#pragma mark - Private methods
- (void)BGPrivateMethod_saveSettings
{
[[NSUserDefaults standardUserDefaults]
setValue:_settings
forKey:kBGSettingManagerUserDefaultsStoreKeyForMainSettings];
[[NSUserDefaults standardUserDefaults]
setValue:_defaultSettings
forKey:kBGSettingManagerUserDefaultsStoreKeyForDefaultSettings];
[[NSUserDefaults standardUserDefaults] synchronize];
}
- (void)BGPrivateMethod_loadExistingSettings
{
id settings = [[NSUserDefaults standardUserDefaults]
valueForKey:kBGSettingManagerUserDefaultsStoreKeyForMainSettings];
id defaultSettings = [[NSUserDefaults standardUserDefaults]
valueForKey:kBGSettingManagerUserDefaultsStoreKeyForDefaultSettings];
_settings = (settings ? settings : [NSMutableDictionary new]);
_defaultSettings = (defaultSettings ? defaultSettings : [NSMutableDictionary new]);
}
- (NSMutableDictionary *)BGPrivateMethod_deepMutableCopy:(NSDictionary *)settings
{
NSMutableDictionary *deepMutableCopy = [settings mutableCopy];
[settings enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
if ([obj isKindOfClass:[NSDictionary class]])
deepMutableCopy[key] = [self BGPrivateMethod_deepMutableCopy:obj];
else
deepMutableCopy[key] = obj;
}];
return deepMutableCopy;
}
- (void)BGPrivateMethod_throwExceptionForInvalidSettingsPath
{
if (self.throwExceptionForUnknownPath)
[NSException raise:@"Invalid settings path."
format:@"Some of your setting path components may intersect incorrectly or they don't exist."];
}
@end
```
Использовать очень просто и, как я потом выяснил и понял, удобно:
```
// CODE -- begin
BGSettingsManager *settingsManager = [BGSettingsManager shared];
[settingsManager createDefaultSettingsFromDictionary:@{
@"user": @{
@"info":@{
@"name": @"Andrew",
@"surname": @"Shmig",
@"age": @22
}
}
}];
[settingsManager resetToDefaultSettings];
[settingsManager setValue:@"+7 920 930 87 56"
forSettingsPath:@"user.info.contacts.phone"];
NSLog(@"%@", settingsManager);
[settingsManager clear];
NSLog(@"%@", settingsManager);
// CODE - end
```
В консоли получим такой вывод:
```
2014-04-30 23:45:03.842 BGUtilityLibrary[13730:70b] {
user = {
info = {
age = 22;
contacts = {
phone = "+7 920 930 87 56";
};
name = Andrew;
surname = Shmig;
};
};
}
2014-04-30 23:45:03.847 BGUtilityLibrary[13730:70b] {
}
```
Переходим к игровому экрану. Этот экран стал для меня по-настоящему «кровавым»… дело в том, что в самом начале, при нажатии на кнопку «Играть», происходил переход на игровой экран и там, в viewDidLoad методе генерировалось и заполнялось поле (SKScene), но задержка была такой большой, что пришлось задаться вопросами:
* Поможет ли предзагрузка спрайтов?
* Поможет ли создание единой SKNode, добавление спрайтов в неё и лишь потом добавление на SKScene?
На оба вопроса ответ «Нет». Первый вопрос вытекает из второго… вся проблема в том, что addChild: метод работает крайне медленно, именно поэтому надо стараться держать на сцене как можно меньше нод. ФПС кстати у меня на симуляторе больше 30 не поднимался, девайс же выдавал чистые 60.
Методом научного тыка и вопросами на SO:
1. [SKSpriteNode takes too much time to be created from texture](https://stackoverflow.com/questions/23027173/skspritenode-takes-too-much-time-to-be-created-from-texture)
2. [Strange thing happens with SKSpriteNode with transparent borders](https://stackoverflow.com/questions/23070591/strange-thing-happens-with-skspritenode-with-transparent-borders) (не совсем по этому вопросу, но тоже очень интересный момент)
Пришел к тому, что создал игровой экран в виде синглтона, который инициализируется при старте приложения, поле заполняется только травой (нижний слой генерируется лишь после того, как пользователь нажал на какую-то ячейку… это решение еще было принято и потому, что с первого же нажатия пользователь не должен попасть на мину).
Все спрайты предзагружаются, далее — копируются, а не создаются заново, потому что процесс создания спрайта с уже загруженной в память текстуры оказался очень медленным и проигрывает простому копированию.
Звуки тоже подгружаются при запуске приложения следующим образом:
```
// предзагрузка звуков в фоновом режиме для избежания затормаживания
NSArray *audioResources = @[@"switchON.mp3",
@"switchOFF.mp3",
@"flagTapOn.mp3",
@"grassTap.mp3",
@"buttonTap.mp3",
@"flagTapOff.mp3",
@"explosion.wav"];
for (NSString *audioName in audioResources) {
[[BGResourcePreloader shared] preloadAudioResource:audioName];
}
```
После каждого изменения настроек поле обновляется (перегенерируется и заполняется спрайтами), чтобы при быстром переходе не возникало задержек.
В разделе о дизайне я упоминал, что работа с кастомными шрифтами еще то веселье — так и есть. Мало того, что название шрифта != названию файла со шрифтом, так еще без предзагрузки шрифта эта зараза неплохо тормозит (к сожалению все скрины из Instruments уже давно удалены, но проверить не составит труда).
Поле у меня заполняется (генерируется) вот таким образом:
```
- (void)generateFieldWithExcludedCellInCol:(NSUInteger)cellCol
row:(NSUInteger)cellRow
{
BGLog();
// множество клеток
NSMutableArray *cells = [NSMutableArray new];
// заполняем поле пустыми значениями
_field = [NSMutableArray new];
for (NSUInteger i = 0; i < self.cols; i++) {
[_field addObject:[NSMutableArray new]];
for (NSUInteger j = 0; j < self.rows; j++) {
[_field[i] addObject:@(BGFieldEmpty)];
// добавляем ячейку в множество, если она не "запрещена"
if (!(i == cellCol && j == cellRow))
[cells addObject:@(i * kBGPrime + j)];
}
}
// произвольно располагаем бомбы на поле
sranddev();
for (NSUInteger i = 0; i < self.bombs; i++) {
NSUInteger index = arc4random() % [cells count];
NSUInteger randomCell = [cells[index] unsignedIntegerValue];
NSUInteger col = randomCell / kBGPrime;
NSUInteger row = randomCell % kBGPrime;
_field[col][row] = @(BGFieldBomb);
// удаляем использованную клетку
[cells removeObjectAtIndex:index];
}
// расставляем цифры
_x = @[@0, @1, @1, @1, @0, @(-1), @(-1), @(-1)];
_y = @[@(-1), @(-1), @0, @1, @1, @1, @0, @(-1)];
for (NSUInteger i = 0; i < self.cols; i++) {
for (NSUInteger j = 0; j < self.rows; j++) {
NSInteger cellValue = [_field[i][j] integerValue];
NSInteger count = 0;
if (cellValue == BGFieldEmpty) {
for (NSUInteger k = 0; k < _x.count; k++) {
NSInteger newY = i + [_x[k] integerValue];
NSInteger newX = j + [_y[k] integerValue];
if (newX >= 0 && newY >= 0 && newX < self.rows && newY < self.cols) {
if ([_field[(NSUInteger) newY][(NSUInteger) newX] integerValue] == BGFieldBomb) {
count++;
}
}
}
_field[i][j] = @(count);
}
}
}
}
```
В стороне остались детали работы с SKAction, которые на первый взгляд кажутся удобными, но в сапёре я столкнулся с необходимостью их комбинировать таким образом, чтобы сохранить читабельный код, но увы… это с большим трудом получилось.
#### App Store
Коротко и ясно:
#### Конец
Всем спасибо за внимание.
Любые вопросы в комментарии и с удовольствием отвечу на них. Если что забыл в статье указать — пишите.
В ближайшее время планирую открыть полностью проект и выложить на GitHub, но сперва будут реализованы задуманные вещи. | https://habr.com/ru/post/221519/ | null | ru | null |
# Реализация простого видеочата на ASP.NET MVC
Доброго времени суток, господа хабраюзеры!
В данном топике я расскажу, как можно сделать простой видео-чат на ASP.NET MVC.
Но для начала предыстория. Мы запускаем сервис видеоконсультаций с врачом через интернет. О нём обязательно будет отдельная статья, а сейчас хотим выяснить, насколько большую нагрузку смогут выдержать сервера и каналы.
Для этого мы написали небольшое веб-приложение, исходным кодами и описанием которого рад с вами поделиться.
Основная идея позаимствована у [чатрулетки](http://chatroulette.com): заходишь в общий чат, выбираешь любого собеседника и общаешься по видео.
Исходный код проекта [опубликован](http://videochat.codeplex.com/) на codeplex.com под свободной лицензией, буду рад комментариям/замечаниям/предложениям.
Итак. В качестве протокола я выбрал RTMP как наиболее распространённый. Почему не RTMFP? Просто используя RTMFP сложно добиться устойчивого соединения между клиентами, что необходимо для оказания платных видеоконсультаций, да и серверная реализация раздачи айдишников недоступна для стабильного использования. В качестве сервера – [Wowza Media Server](http://www.wowza.com/), т.к. в отличие от бесплатного [Red5](http://www.red5.org/) (да простят меня его сторонники) у него внятная документация с примерами, и в отличие от [FMS](http://www.adobe.com/ru/products/adobe-media-server-family.html) пробный период в 30 дней и приемлемая ценовая политика. А качество работы проверим на практике, насколько я представляю, сильной разницы между всеми тремя по производительности нет. Как альтернативу мы рассматриваем [erlyvideo](http://erlyvideo.org/), но подробно посмотреть и попробовать его пока возможности не было.
Пишется всё под ASP.NET MVC 4. И для реализации текстового чата и общения между клиентами используется библиотека [SignalR](http://signalr.net/).
Далее по пунктам.
**Реализация чата.**
Основное здесь – два класса ChatMessage и Chat.
Класс Chat наследован от SignalR.Hubs.Hub и реализует основные методы работы с клиентами:
```
// вызывается клиентом для подключения к комнате.
public void JoinRoom(string roomKey, string userName)
{
// Сохраняем описание пользователя только если он в основном чате
if (roomKey == C.MAIN_CHAT_GROUP)
Store.Add(new User(Context.ConnectionId, userName));
// Возвращаем клиенту его id
Clients[Context.ConnectionId].OnJoinRoom(Context.ConnectionId);
// Добавляем пользователя в комнату
Groups.Add(Context.ConnectionId, roomKey);
// Опопвещаем клиентов о изменении списка пользователей
UpdateUsers();
}
// вызывается клиентом для отправки сообщения
public void Send(ChatMessage message)
{
// Что-то делаем только если сообщение не пустое
if (message.Content.Length > 0)
{
//проставляем дату отправки
message.Date = DateTime.Now;
// идентификатор отправителя
message.SenderKey = Context.ConnectionId;
// экранируем пришедший текст во избежание хулиганства
message.Content = HttpUtility.HtmlEncode(message.Content);
message.SenderName = HttpUtility.HtmlEncode(message.SenderName);
// Оповещаем клиентов о новом сообщении
Clients[message.RoomKey].OnSend(message);
Store.SaveMessage(message);
}
}
```
Store здесь – статическая коллекция пользователей, которую при желании можно легко заменить на свою реализацию.
В нашей демке она сохраняется в базу вместо статической переменной.
На клиенте создаём соответствующие методы. Для краткости я скрыл конкретную реализацию
```
var CHAT = {};
var OPTIONS = {};
function Start(data)
{
// Инициализируме переменные, подключение
OPTIONS.SenderName = data.name;
OPTIONS.RoomKey = 'MAIN';
CHAT = $.connection.chat;
// Присваиваем обработчики методов, вызываемых с сервера
CHAT.OnSend = OnSend;
CHAT.OnJoinRoom = OnJoinRoom;
}
// Вызывается с сервера после подключения клиента
function OnJoinRoom(key) {
OPTIONS.SenderKey = key;
}
// Вызывается с сервера для обновления списка пользователей онлайн
function OnUpdateUsers(data) {
/* ...Обновляем пользователей, в data коллекция прокси-объектов User, по интерфейсу идентичная интерфейсу IUser */
}
// Функция для отправки сообщения, вызывает серверный Chat.Send
function Send() {
var messageInput = $("#msg"),
// Создаём объект, нименования полей которого соответствуют полям ChatMessage
msg = {
'SenderName': OPTIONS.MyName,
'RoomKey': OPTIONS.RoomKey,
'Content': messageInput.val()
};
CHAT.send(msg); // Важный момент: серверные методы в прокси-объекте начинаются с прописной буквы
messageInput.val("");
messageInput.focus();
}
// Метод, вызываемый с сервера для публикации сообщения
function OnSend(msg) {
var chatContent = $(".chat_content"),
msgClass = 'chat_message';
/* ...Добавляем полученное сообщение на страницу,
в msg - объект, поля которого соответствуют полям ChatMessage */
}
```
Далее необходимо обеспечить функционал «звонков». Для этого в Chat добавляем методы, обрабатывающие начало звонка, отклонение и принятие звонка.
```
// Метод звонка (вызов абонента)
public void Call(string recieverKey, string senderKey, string senderName)
{
Clients[recieverKey].OnCall(senderKey, senderName);
}
// Метод отклонения звонка
public void RejectCall(string senderKey, string recieverKey, string recieverName)
{
Clients[senderKey].OnRejectCall(recieverKey, recieverName);
}
// Принятие звонка
public void AcceptCall(string calleePulicKey, string calleeName, string myName)
{
string myKey = Guid.NewGuid().ToString().Replace("-", "");
string calleeKey = Guid.NewGuid().ToString().Replace("-", "");
string roomKey = Guid.NewGuid().ToString().Replace("-", "");
var model = new RoomModel
{
MyPublicKey = Context.ConnectionId,
MyKey = myKey,
MyName = myName,
CalleePublicKey = calleePulicKey,
CalleeKey = calleeKey,
CalleeName = calleeName,
RoomKey = roomKey
};
// Сохраняем информацию о начинающемся сеансе
Store.SaveRoomInfo(model);
// Рассылаем уведомления
Clients[calleePulicKey].OnAcceptCall(false, roomKey);
Clients[Context.ConnectionId].OnAcceptCall(true, roomKey);
}
```
Схема работы следующая: когда один абонент (допустим, Ангелина) хочет позвонить другому (к примеру, Пете), Ангелина вызывает метод Call и передаёт ему ключ Пети, свой ключ и своё имя. Пете мы высылаем уведомление OnCall, на клиенте его обрабатываем и отображаем сообщение о звонке от Ангелины. В случае, если Петя решит отклонить звонок, он вызывает метод RejectCall и возвращает ключ звонящего, свой ключ и своё имя. Мы отправляем Ангелине уведомление OnRejectCall, в обработчике которого отображаем Ангелине уведомление об отклонении звонка.
Если же Петя принимает звонок, он вызывает метод AcceptCall, в котором мы генерируем для обоих абонентов новые идентификаторы и ключ для комнаты личного чата. После чего отправляем обоим уведомления OnAcceptCall, передавая с ними необходимые ключи. На клиенте в обработчике уведомления перенаправляем и Петю и Ангелину на страницу личного чата:
```
function OnAcceptCall(isMy, roomKey) {
document.location = '@Url.Action("Room", "Home")' + '?isMy=' + isMy + '&roomKey=' + roomKey;
}
```
На странице личного чата с помощью переданных ключей инициализируем флешку и текстовый чат. Для текстового чата на странице Room используем тот же объект Chat, просто не обрабатывая на клиенте события обновления списка пользователей и звонков.
**Далее переходим к флешке.**
Для организации общения мы должны создать поток, который будем «публиковать» на сервер и подписаться на поток, публикуемый собеседником. Потоки на сервере идентифицируются посредством ключей, передаваемых на сервер при начале публикации.
При инициализации флешки мы получаем ключи со страницы, сохраняем их в локальные переменные и запускаем таймер, который будет следить за началом и ходом сеанса связи. Работу по созданию подключения к серверу, публикации и подписке на поток осуществляют три метода:
```
private function Connect():void
{
if (!isConnected && rtmpConnection == null)
{
// Создаём подключение
rtmpConnection = new NetConnection();
rtmpConnection.connect(connectStr);
// Добавляем обработчик события изменения состояния подключения
rtmpConnection.addEventListener(NetStatusEvent.NET_STATUS, onNetStatus_rtmpConnection);
}
isConnected = true;
}
private function StartPublish():void
{
// Создаём поток для публикации
nsPublish = new NetStream(rtmpConnection);
nsPublish.addEventListener(NetStatusEvent.NET_STATUS, onNetStatus_nsPublish);
// устанавливаем буфер потока в 0
nsPublish.bufferTime = 0;
// Публикуем
nsPublish.publish(publishName);
// Подсоединяем камеру и микрофон
nsPublish.attachCamera(camera);
nsPublish.attachAudio(microphone);
isPublish = true;
}
private function StartSubscribe():void
{
// Cоздаём поток для подписки на трансляцию собеседника
nsSubscribe = new NetStream(rtmpConnection);
// Добавляем обработчик событий потока
nsSubscribe.addEventListener(NetStatusEvent.NET_STATUS, onNetStatus_nsSubscribe);
// Устанавливаем буфер потока в 0
nsSubscribe.bufferTime = 0;
// Устанавливаем громкость потока
var volume:Number = sldrVolume.value / 100;
var st:SoundTransform = new SoundTransform(volume);
nsSubscribe.soundTransform = st;
// Подключаемся к потоку
nsSubscribe.play(subscribeName);
// Подключаем к потоку камеру
videoRemote.attachNetStream(nsSubscribe);
isSubscribe = true;
}
```
При срабатывании таймера проверяем, подключены ли мы к серверу и состояния потоков публикации и подписки. И в случае успеха всех проверок считаем время разговора
```
private function onTick_Timer(event:TimerEvent):void
{
if(!isConnected)//Проверяем состояние подключения
{
lblEndTime.text = "Подключение...";
Connect();
startTime = new Date();
}
else
{
if(!isPublish && needPublish)//Проверяем состояние публикации
{
lblEndTime.text = "Публикация...";
StartPublish();
}
if(!isSubscribe)// Проверяем состояние подписки
{
lblEndTime.text = "Подписка...";
StartSubscribe();
}
if(isPublish && isSubscribe)// Если всё ОК, пишем время разговора
{
var now:Date = new Date();
var toStart:TimeSpan = new TimeSpan(now.getTime() - startTime.getTime());
lblEndTime.text = toStart.getTotalMinutes() + ':' + toStart.getSeconds();
}
}
}
```
На этом практически всё.
**Последний компонент — Медиасервер.**
Wowza Media Server особых сложностей в установке и настройке не вызвал. Загружаете дистрибутив с официального сайта, ставите, открываете на машине 1935-й порт и прописываете в флешку адрес сервера. При желании можно воспользоваться любым другим сервером, поддерживающим RTMP: Red5, Adobe FlashMediaServer, erlyvideo. Клиентская реализация никак не зависит от серверной.
Наши цели данного тестирования:
1. Выяснить, сколько одновременно общающихся пользователей мы можем выдержать без потери качества.
2. Получить советы по более грамотной реализации
3. Возможно, найти дыры в безопасности
**UPD: Тестирование закончилось, ссылки на онлайн-демку из поста убрал.**
По итогам должен сказать, что хабраэффект прошёл мимо. Сервер работал максимум в половину нагрузки.
Немного цифр:
1. Сколько максимально находилось в видео-чате в единицу времени — 5 сеансов началось в одно время с точностью до минуты из них 4 продлилось больше минуты
2. Всего попыток звонков — 361
1) Из них попыток, длившихся более 30-ти секунд — 174
2) Длившихся более 2-х минут — 38
3) Некорректно завершённых (без простановки времени завершения) — 62
3. Всего сообщений в чате — 12347
1) Из них в главном — 11256
2) В личных — 1125
Благодарю всех, кто принял участие в нагрузочном тестировании! | https://habr.com/ru/post/154455/ | null | ru | null |
# Ещё немного про телефоны Xiaomi и борьбу с ними. Updated
Честно признаться, у меня не было планов писать и публиковать эту статью, но, после того, как за два месяца увидел в ближнем кругу коллег 5 штук свежеприобретённых телефонов от Xiaomi, и недавнюю [статью](https://geektimes.ru/company/gearbest/blog/276400/) на Geektimes, рекламирующую управление умным домом от Xiaomi, ко мне пришла совесть и, ~~сцуко~~, потребовала поделиться знанием с остальными.
Для начала небольшая вводная часть для тех кто не в теме. Есть такая компания Xiaomi, которая делает неплохие по начинке телефоны и заливает в них кастомизированный Android. Бизнес модель, как недавно официально было заявлено — «По сути мы раздаём наши смартфоны, не зарабатывая на этом денег. Нас больше заботят долгосрочные источники дохода. Мы могли бы продать 10 миллиардов смартфонов и не заработать на них ни цента». Источник [раз](http://www.playground.ru/blogs/other/xiaomi_priznalas_chto_prodaet_svoi_smartfony_po_sebestoimosti-224463/) и [два](http://www.reuters.com/article/us-xiaomi-china-idUSKBN13K0XE).
Заглянув в сентябрьскую [статью](http://www.securitylab.ru/news/483861.php) на Security lab и ещё вот в [эту](http://en.miui.com/forum.php?mod=viewthread&tid=370873&page=3#pid7721079) жалобу, у меня лично возникло ощущение, что телефон Xiaomi это что-то типа поводка на котором владельца водит Большой брат (утрирую, конечно же).
Это и стало основным мотивом проведения исследования поведения телефона Xiaomi redmi 3S
с прошивкой MIUI Global 8.1 Стабильная 8.1.1.0 (MALMIDI)
Исследование подопытного кролика и обнаружение проблемы
Беру новенький телефон из коробки. Включаю его и прохожу через мастера начальной настройки, предварительно включив запись трафика на Wi-Fi роутере. Ровно через две секунды, после того как телефон подключился к точке доступа, началось скачивание файла размером около 8Мбайт с одного из серверов Xiaomi. Это был обычный zip архив, внутри которого лежала куча всего и, в том числе, файл AnalyticsCore.apk, упомянутый в статье на SecurityLab.
Дальше — больше. В общей сложности, за всё время наблюдения, я насчитал **чуть меньше восьми десятков имён серверов** в разных доменах. Сразу оговорюсь, что в этом числе нет серверов Google и Facebook, приложения которых также предустановлены. Просто потому что я их считал отдельно. С ними тоже всё «весело».
Большая часть коннектов к серверам Xiaomi шла через HTTPS, поэтому разобраться в деталях ЧТО именно передаётся напрямую возможности не было. Отключение всевозможных логинов, синхронизаций и т.п. к исчезновению этого трафика не привело.
Дополнительно смущало то, что большей частью запросы были небольшими (объём принятого переданного трафика TCP сессий не превышал 1-2Кб), но, т.к. наши сотовые операторы округляют объём трафика вверх (Например, Tele2 до 150Кб), то, при неудачном совпадении, можно «накачать» таким образом существенные объёмы трафика, а в роуминге неожиданно попасть на деньги.
Тех, кого сей факт не смущает могут дальше не читать, т.к. дальше будет описание конкретики изоляции трафика от приложений, вшитых в заводскую прошивку.
### Предварительные условия
Первое что необходимо — это рутовать телефон. Как это делается в случае Xiaomi я здесь описывать не буду, отсылаю желающих пройти этот путь к полной версии этой статьи (ссылка в конце).
Второе — это влить в телефон прошивку через кабель и стереть ВСЕ пользовательские данные.
Третье — телефон НЕ ДОЛЖЕН иметь доступа в интернет после залива свежей прошивки.
Update. До момента установки нижеописываемых ограничений, разумеется.
**Disclamier. Все дальнейшие манипуляции над телефоном Вы делаете на свой страх и риск.
Ответственность за любой результат лежит на том, кто именно делал описываемые ниже действия.**
### Небольшая техническая вводная часть
Серверы, к которым обращается телефон, в большинстве своём расположены в облаке Amazon, поэтому обращения к ним происходит по именам, которые ресолвятся через round-robin DNS в разные IP адреса из разных подсетей /16. Блокировать их все по подсетям смысла особого нет — так можно половину интернета отфильтровать, что не есть хорошо. Блокировать по именам — хорошо, но не факт, что имена хостов из L3 доменов не генерируются динамически. Идеально было бы прибить все приложения, которые обращаются к серверам Xiaomi, но, как показала практика, глубина их интеграции в Android такова, что после удаления некоторых из них телефон может просто отказаться загружаться.
Далее. К внешним серверам обращается не один процесс, а многие, при этом задачу усложняет наличие в Android UID sharing, когда под одним UID могут генерировать сетевой трафик разные процессы (приложения). Более того, один из полезных процессов (отвечающий за GPS) надо выпускать во внешний мир, чтобы скачивать небольшие обновления, но при этом он сидел под тем же UID, что и восемь штук процессов, рвущихся к серверам Xiaomi.
Также надо упомянуть про ограниченность инструментария, доступного для решения вышеописанных задач, т.к. большая часть приложений имеющих в названии firewall доступных на Play Market работают через т.н. VPN, т.е. от сливов информации до запуска приложения они не защищают.
Большая часть того, что будет рассказано дальше для профессиональных разработчиков Android есть банальная истина, но всем остальным это позволит понять почему фильтрация построена именно таким образом.
В отличие от обычного Linux, где есть файлы конфигурации и стартовые скрипты, лежащие в /etc, в Android всё сделано несколько иначе. Общее управление сетью осуществляет Connection Manager, который дёргает системный демон netd, который, в свою очередь, вызывает iptables с определёнными параметрами командной строки. Соответственно, вызывать IPtables из скрипта начальной загрузки (init и прочих) особого смысла нет — netd при старте всё равно вызовет iptables, очистит правила и зальёт свои.
Единственный выход оставленный Google — писать необходимые команды конфигурации iptables в скрипте /system/bin/oem-iptables-init.sh. Путь к этому скрипту и его имя жёстко прописаны внутри исходного кода демона netd.
Для фильтрации статических имён хостов можно редактировать файл /etc/hosts, но при этом надо помнить про их количество и возможность их динамической генерации.
Дальше будет рассказ как это всё делалось.
### Удаление и заморозка (если нет уверенности) ненужных программ
При помощи бесплатной версии Titanium Backup можно посмотреть соответствие между именем программы, показываемое в системе (Play Market), её кодовым именем (com.google.vending) и, при необходимости, удалить то, что **явно** не нужно.
Недостаток бесплатной версии — не умеет делать заморозку программ, посему заморозку делаем через ADB shell при помощи package manager. Пример:
```
root@land:/ # pm disable com.miui.analytics
pm disable com.miui.analytics
Package com.miui.analytics new state: disabled
root@land:/ # pm disable com.miui.systemAdSolution
pm disable com.miui.systemAdSolution
Package com.miui.systemAdSolution new state: disabled
root@land:/ # reboot
reboot
```
### Фильтрация сетевых запросов
*Disclamier 2.В данной статье описано КАК можно фильтровать «левую» сетевую активность телефона. Что конкретно фильтровать — каждый волен решать сам.*
Как это можно делать.
**1.** Cамое простое — заполнение файла /etc/hosts записями имён серверов c IP адресом 127.0.0.1. Мой набор серверов лежит на [Google Drive](https://drive.google.com/drive/folders/0B_27A62KIOxURzhBaWxzRFo3Znc?usp=sharing) в папке Files.
Недостаток варианта — невозможность блокировки неизвестных и динамически генерируемых имён хостов и доменов L3/L4.
**Update.** Несколько раз обнаруживал странное поведение Netfilter/IPtables. После загрузки телефона в таблице действующих правил оказывались не все правила, перечисленные в скрипте. Если перезагрузить телефон ещё раз — все правила оказывались на месте. ~~Прям шайтан-машина, а не телефон.~~В [документации](http://ipset.netfilter.org/iptables.man.html) нашёл описание параметра --wait, который вроде бы должен решать эту проблему. Но, для гарантированного решения проблемы, сделал ещё вызов IPtables из скрипта не напрямую, а через несложную функцию, которая проверяет код завершения и, при необходимости, повторно выполняет команду с небольшой задержкой, опять же проверяя результат.
**2.** пишем команды фильтрация отправки пакетов на подсети /16 и /24 стандартными правилами Netfilter/IPtables в файл oem-iptables-init.sh. Здесь их не описываю, желающие напишут их сами, либо найдут в полной версии статьи.
Update. Недостаток варианта — большая часть серверов расположена в облаке Amazon и имеет переменные (round-robin DNS) IP адреса. Для гарантированной их фильтрации придётся закрыть не один десяток подсетей /16, что не есть хорошо. Можно ненароком забанить и полезные сайты. Но для статичных хостов (если их немного) это решение вполне подходит.
**3.** Фильтруем DNS запросы к ненужным нам доменам. Это несколько сложнее, поэтому опишу подробнее.
Updated.В составе IPtables, штатно идущем в Android есть модули расширения функционала, которыми мы дальше и воспользуемся. Помня, что DNS запросы отправляет система (UID 0) пишем правило:
```
$IPTABLES -A oem_out --protocol udp --dport 53 -m owner --uid-owner 0 -m string --algo bm --hex-string '|04|miui|03|com|00|' -m comment --comment "Deny UID 0 DNS queries for miui.com domain" -j DROP
#
$IPTABLES -A oem_out --protocol udp --dport 53 -m owner --uid-owner 0 -j ACCEPT
```
Updated. Первая строчка отфильтрует все UDP пакеты, отправленные системой (UID 0) на 53 UDP порт любого IP адреса и содержащие в себе байты 046d69756903636f6d00 (запросы к DNS серверу содержащие в себе .miui.com). IPtables самостоятельно преобразуют строчку |04|miui|03|com|00| в чисто шестнадцатиричый вид 046d69756903636f6d00.
Наличие шестнадцатиричной цифры на первой позиции для параметра --hex-string — обязательно, иначе IPtables не примет команду. Точки-разделители в доменном имени при формировании DNS запроса преобразуются в шестнадцатиричные цифры, означающие количество байт до следующего разделителя. Поэтому последний байт равен нулю (00h).
Вторая строчка пропустит все остальные DNS запросы. Комментарии я указал для удобства, чтобы команда iptables -L -v показывала результаты блокировок нагляднее.
**4.** Для работы Assited GPS необходимо дать возможность доступа к серверам QualComm процессу с UID 1000. Здесь всё сложнее, т.к. простая фильтрация пакетов по содержимому, как в случае DNS серверов, не сработает — начальные пакеты установления TCP соединения c флагами SYN, ACK **ещё** НЕ содержат в себе имя хоста, которое обязательно присутствует в HTTP запросе, а пакеты идущие после заголовка HTTP запроса **уже** могут не содержать в себе имя хоста. В результате фильтр пропустит из всей TCP сессии только часть пакетов, что равносильно её запрету или обрыву.
Поэтому рисуем вот такой костыль для фильтрации запросов седьмого уровня средствами 3-4 уровня:
```
# разрешаем инициировать установление TCP соединений на 80 порт всем процессам работающим под UID 1000.
$IPTABLES -A oem_out -m owner --uid-owner 1000 --protocol tcp --dport 80 -m conntrack --ctstate NEW -j ACCEPT
#проверяем наличие слова xtrapath в пакетах TCP соединений установленных на 80 порт процессами с UID 1000 и помечаем эти соединения шестнадцатиричным числом 5555.
$IPTABLES -A oem_out -m owner --uid-owner 1000 --protocol tcp --dport 80 -m conntrack --ctstate ESTABLISHED -m string --algo bm --string 'xtrapath' -j CONNMARK --set-xmark 0x5555
# убиваем пакеты всех установленных процессами с UID 1000 TCP соединений не имеющих нашей пометки число 5555
$IPTABLES -A oem_out -m owner --uid-owner 1000 --protocol tcp --dport 80 -m conntrack --ctstate ESTABLISHED -m connmark ! --mark 0x5555 -j DROP
```
**5.** Фильтруем доступ в интернет по приложениям (у меня Google Chrome имел UID 10060). Разрешаем выход в интернет Google Chrome и запрещаем всем остальным приложениям.
```
$IPTABLES -A oem_out -m owner --uid-owner 10060 -m comment --comment "Permit Google Chrome internet access" -j ACCEPT
#
# Block all other processes
#
$IPTABLES -A oem_out -m owner --uid-owner 0-9999 -m comment --comment "Block all other system processes internet access" -j DROP
$IPTABLES -A oem_out -m owner --uid-owner 10000-99999 -m comment --comment "Block all other user processes internet access" -j DROP
```
Слабым местом этого способа фильтрации является его опора на наличие отметки UID на каждом конкретном пакете при прохождении его через Netfilter/IPtables. Обнаружилось это по непонятным TCP соединениям к серверам Google, пакеты которых не содержали UID. Исследование показало, что эти пакеты инициированы процессом Google Captive portal login. Я решил эту проблему обходным путём — просто выключив эти запросы командами в ADB shell:
```
root@land:/ # settings put global captive_portal_detection_enabled 0
root@land:/ # reboot
```
~~Радует, что (судя по накопленной статистике за несколько суток перехвата Wi-Fi трафика), никаких иных системных процессов отсылающих пакеты без UID в исследовавшемся телефоне нет.~~
**Update.** Дальнейшее наблюдение показало как я ошибался. Такие «тихие» процессы есть, но часть из них невинно общается друг с другом через адрес 127.0.0.1, что ненаказуемо.
Всё остальное надо банить.
Поэтому, для их правильной фильтрации, надо добавить в самое начало скрипта ещё две строчки:
```
$IPTABLES -A oem_out --protocol all --source 127.0.0.0/8 --destination 127.0.0.0/8 -m comment --comment "Accept internal traffic" --jump ACCEPT
$IPTABLES -A oem_out --protocol all -m owner ! --uid-owner 0-99999 -m comment --comment "Drop any traffic which does not have UID." --jump DROP
```
**Update.** Уже после опубликования статьи для меня окончательно стало ясно, что UID приложений, задаваемый системой при установке приложения, при обновлении и/или переустановке приложений может непредсказуемым образомменяться. Следовательно, доступ в интернет для приложения тоже отвалится и надо будет переписывать правило Netfilter/IPtables заново.
Для решения этой проблемы набросал небольшой кусок скрипта, который читает из хвоста файла наименования приложений, проверяет их наличие в системной базе приложений, и, при наличии, берёт оттуда же UID приложения и динамически (в процессе работы скрипта) формирует правило Netfilter/IPtables.
*Строго говоря — чтение параметров из тела скрипта — это тоже костыль. Но меня оправдывает то, что на момент работы скрипта, подмонтировать файловую систему доступную снаружи при обычной работе телефона — невозможно. В папке /dev нет соответствующих файлов устройств. Допускаю, что это может быть особенность прошивки конкретного телефона.*Текст специально сделал максимально подробным, для лучшего понимания.
```
# Permit intenet access for the packages listed at the end of this file. White list mode.
#
SU=`/system/bin/which su`
# changing reading file behavior (read whole file with \r\n into variable)
IFS=""
# reading first and second fields of every line of the system packages database into variable PACKAGESDB.
# Escalating privileges via su because of filesystem packages database file access limitations.
PACKAGESDB=`$SU -c "/system/bin/cut -d' ' -f 1,2 /data/system/packages.list"`
#
# Reading last lines of current script form the end till "exit 0" line
# Filtering empty lines, lines started with # and all symbols after # (comments) in every line.
#
# 's/#.*//' - remove all in every line after #
# '/^#/d' - remove lines staring with #
# '/./!d' - remove empty lines
# '/exit 0/,$ d' - remove all lines starting line with "exit 0"
# 's/ //g' - remove spaces from line
#
/system/bin/tac $0 | /system/bin/sed -e '/^#/d' -e 's/#.*//' -e '/exit 0/,$ d' -e '/./!d' -e 's/ //g'| while read line;
do
# Just in case 8-)
OUR_PACKAGE_NAME=$line
# Strict checking for existence of our package name in the system packages database. Checking first field.
PACKAGE_NAME_IN_DB=`echo $PACKAGESDB | /system/bin/cut -f 1 -d' ' | /system/bin/grep -Fx "$line"`
if
# Checking grep utility exit code. "0" means pattern found
test "$?" == "0"
then
#
# Looking for package UID in database. Checking second field. VERY important space after $line!!!
#
PACKAGE_UID=`echo $PACKAGESDB | /system/bin/grep "$line " | /system/bin/cut -f 2 -d' '`
else
# All other exit codes return us to the beginning of the cycle.
# echo "Package $OUR_PACKAGE_NAME not found"
$IPTABLES -A $CHAIN -m comment --comment "Package name $OUR_PACKAGE_NAME not found. Check package name." --jump LOG
continue
fi
#
# Set the package right for Internet access
#
$IPTABLES -A $CHAIN -m owner --uid-owner $PACKAGE_UID -m comment --comment "Permit $OUR_PACKAGE_NAME Internet access" -j ACCEPT
#
done
######
... skipped...
####
exit 0
####
####### Do NOT edit before this line #########
# Please add package names and comments after this line for granting them internet access.
#####
# Google Play Store and its companion processes
#
com.google.android.gms # Google Services Framework Internet access
com.android.vending # Google Play Market internet access
com.android.providers.downloads # Download manager service internet access
#
# Other Google apps
com.google.android.youtube # Youtube application internet access
com.google.android.apps.maps # Google Maps application internet access
com.google.android.googlequicksearchbox # Google Assistant internet access
#
#
com.android.chrome # Google Chrome browser internet access
```
После переустановки/обновления приложения нужно всего лишь перезагрузить телефон.
**6.** Для целей мониторинга работы правил Netfilter/IPtables можно добавить ещё вот такую строчку:
```
$IPTABLES -A oem_out --source 10.1.30.42 --protocol tcp --jump LOG --log-prefix "IPtables log:" --log-uid
```
Параметр IP адрес отправителя (--source 10.1.30.42) можно опустить, но в этом случае лог будет завален записями сетевой активности процессов, завёрнутых на адрес 127.0.0.1 файлом hosts. Лог можно читать через команду dmesg (dmesg | grep IPtables) в ADB Shell.
Версию статьи, которая писалась как полная инструкция по решению этой проблемы с Xioami Redmi 3S я выложил на [Google Drive](https://drive.google.com/drive/folders/0B_27A62KIOxURzhBaWxzRFo3Znc?usp=sharing). Сюда её выкладывать не рискнул именно из-за объёма.
**P.S.** Я не разработчик Android-приложений, просто жизнь заставила два месяца поразбираться с сабжевым телефоном. Посему, господа профи, если я где ошибаюсь — поправляйте. Буду признателен.
**P.P.S.** В качестве средства перехвата использовался Zyxel Keenetic Extra. У него есть возможность перехватывать Wi-Fi трафик и сливать его на флэшку для последующего анализа. | https://habr.com/ru/post/320612/ | null | ru | null |
# Что нового в Selenium 4 — ключевые особенности и отличия
Сегодня для каждого бизнеса требуется высококачественное программное обеспечение в сжатые сроки, чтобы достигнуть этого организациям необходимо проводить эффективное тестирование программ с помощью автоматизации. С развитием agile и DevOps методологий автоматизация тестирования программного обеспечения достигает новых высот. Процесс автоматизации тестирования ускоряется при помощи повторного использования тест-сьютов, также существует множество фреймворков, используемых QA-тестировщиками .
### Обзор инструментов Selenium
Несмотря на то, что существует множество фреймворков автоматизации, одним из наиболее распространенных является Selenium. Различные версии Selenium, выпущенные на рынок: **Selenium 1 (Selenium RC), Selenium 2, Selenium 3 и обновленная бета-версия Selenium 4**. Selenium занимает заметное место в мире автоматизированного тестирования благодаря открытому исходному коду и многочисленным функциям, которые ускоряют процесс тестирования по сравнению с другими инструментами.
Selenium - это наиболее предпочтительный набор инструментов, используемый для автоматизации тестирования веб-приложений. Он способен работать в различных браузерах и операционных системах. Selenium - это набор средств автоматизации тестирования, который состоит из различных компонентов, приведенных ниже:
* Selenium Core
* Selenium RC
* Selenium IDE
* Selenium Grid
* Selenium Webdriver
Selenium 2 и Selenium 3 применяются уже много лет, и имеют различия, представленные в таблице ниже.
**Основные различия между Selenium 2 и Selenium 3**
| | |
| --- | --- |
| **Selenium 2** | **Selenium 3** |
| Selenium 2 поддерживает Selenium WebDriver и Selenium RC (Selenium 1). Он использует Selenium Core для обратной совместимости. | Selenium 3 поддерживает Selenium Grid и Selenium WebDriver.Selenium Core удалено. Поддерживает Selenium RC косвенно через внутренний веб-драйвер. |
| Firefox - браузер по умолчанию. Поддерживаются версии Firefox ниже 47.0.2 | Для Firefox был представлен отдельный драйвер, который называется GeckoDriver. Он поддерживает версии 47.0.2 и выше. |
| Поддерживает “безголовый” браузер HTMLUnit | Не поддерживает “безголовый” браузер HTMLUnit |
| Не является стандартом W3C (World Wide Web Consortium) | Стал стандартом W3C (World Wide Web Consortium) |
| Поддерживает и автоматизирует мобильные приложения с помощью AndroidDriver и iPhoneDriver. | Поддержка мобильной автоматизации удалена, т.е. AndroidDriver и iPhoneDriver были убраны из библиотеки Selenium WebDriver. Для автоматизации мобильного тестирования можно использовать такие инструменты, как Appium |
### Что такое Selenium 4?
Selenium 4 Beta 1 - последняя версия Selenium, которая была выпущена 15 февраля 2021 года. В этом новом наборе инструментов есть такие расширенные возможности, как Selenium Grid, соответствие W3C, усовершенствованная IDE, новые API и многое другое. Selenium 4 - набор инструментов, в который входят различные компоненты, приведенные ниже:
**Selenium WebDriver -**
Это API с открытым исходным кодом, который позволяет создавать надежные комплекты автоматизации регрессии на основе браузера, тестировать, масштабировать и распространять скрипты во многих средах. WebDriver также позволяет взаимодействовать с браузером, как настоящий пользователь.
**Selenium IDE -**
Это дополнение для Chrome и Firefox, которое просто записывает и воспроизводит взаимодействие пользователя с браузером.
**Selenium Grid -**
Позволяет экономить время, распределяя и запуская тесты на нескольких браузерах, операционных системах и машинах. Он позволяет управлять несколькими средами из одной центральной точки.
**В чем разница между Selenium 3 и Selenium 4?**
Как правило, между Selenium 3 и Selenium 4 есть несколько существенных различий, перечисленных ниже:
| | |
| --- | --- |
| **Selenium 3** | **Selenium 4** |
| В Selenium 3 драйвер chrome расширяется непосредственно до Remote Web Driver. | В Selenium 4 класс драйвера Chrome расширяется до Chromium Driver, который имеет некоторые предустановленные методы для доступа к инструменту разработчика. |
| В Selenium 3 протокол JSON Wire Protocol был основным способом связи между тестовым кодом и браузером. | В Selenium 4 используется протокол WebDriver W3C, поскольку он соответствует требованиям W3C. |
| Сложной задачей в Selenium 3 было то, что тестировщики должны были каждый раз запускать файлы Java-архивов (jar-ы) хаба (Hub) и узла (Node) для выполнения автоматизированного тестирования на Grid. | В Selenium 4 тестировщикам не нужно запускать jar-ы Hub и Node каждый раз, когда они выполняют автоматизированное тестирование. |
**Каковы новые возможности Selenium 4?**
**1. WebDriver стал стандартом W3C (World Wide Web Consortium):**
* Selenium WebDriver теперь соответствует стандарту W3C, и предоставляет дружественный и гибкий API для автоматизации браузера.
* Стандарт W3C способствует совместимости различных программных имплементаций WebDriver и API.
* Большинство стандартов W3C крутятся вокруг стандартизации веб-технологий, делая систему более стабильной и облегчая работу браузеров.
**2. Selenium Grid дополнен обновлениями:**
* Ранние версии Selenium Grid были сложными, поскольку они были основаны на архитектуре Hub и Node(s). Во время выполнения тестов автоматизации Hub и Node(s) должны быть запущены отдельно.
* В Selenium 4 Hub и Node (s) упакованы в один jar-файл, это означает, что после запуска сервера он одновременно выполняет функции Hub и Node.
* Grid также поддерживает адреса IPV6, что позволяет пользователям общаться с Grid по стандарту HTTPS с помощью TLS-соединений.
* Selenium Grid имеет более масштабируемую и отслеживаемую инфраструктуру, которая поддерживает четыре процесса: Router, Session Map, Distributor и Node.
* Новый Selenium Grid поставляется с поддержкой Docker, что позволяет тестировщикам и разработчикам запускать контейнеры, а не устанавливать тяжеловесные виртуальные машины.
Эта функция предоставляет пользователям возможность для более гибкого развертывания Selenium Grid на Kubernetes. Selenium Grid 4 способен благотворно повлиять на [процесс DevOps](https://www.testingxperts.com/blog/what-is-devops), поскольку он поддерживает такие инструменты, как AWS, Azure и другие.
**3. Обновление Selenium 4 IDE:**
* Selenium IDE - это инструмент записи и воспроизведения, который был доступен в качестве дополнения для Firefox в ранних версиях Selenium, но утратил свою актуальность, поскольку последние версии Firefox были стандартизированы в соответствии с механизмом веб-расширений.
* В **Selenium 4** он доступен в качестве дополнения для основных веб-браузеров, таких как Firefox, Chrome, MS Edge и др.
* Последнее обновление имеет интуитивно понятный пользовательский интерфейс, а также поставляется с инструментом SIDE, то есть Selenium IDE runner, который позволяет QA специалистам (QA) запускать проекты на платформе node.js.
* Эта функция позволяет QA-командам запускать кросс-браузерные тесты на локальной или облачной Selenium Grid. Она имеет усовершенствованный механизм потока управления, который позволяет тестировщикам писать лучшие условия "while" и "if".
* Еще одна особенность - код тестовых примеров, записанных с помощью обновленной Selenium IDE, может быть экспортирован в нужный язык программирования, такой как Java, C#, Python, .NET и JavaScript, что открывает перед тестировщиками дополнительные возможности.
**4. Относительные локаторы для сценариев автоматизации**
* В Selenium 4 появился простой способ определения местоположения элементов благодаря включению относительных локаторов.
* Относительные локаторы, также называемые дружественными локаторами, помогают размещать Web-элементы рядом, слева, справа, выше и ниже указанного элемента.
* Поддерживается использование функции `withTagName` (в Selenium 4 Java) или `with_tag_name` (в Selenium 4 Python). Он помогает находить веб-элементы на основе визуального расположения относительно других элементов DOM.
**5. Протокол отладки Chrome (CDP)**
* Selenium 4 обеспечивает нативную поддержку протокола Chrome DevTools Protocol (CDP) через интерфейс DevTools.
* Он позволяет QA использовать такие свойства разработки Chrome, как Fetch, Network, Profiler, Performance, Application cache и другие.
* Эта функция помогает разработчикам и QA быстрее и на лету тестировать и устранять критические ошибки для конкретных веб-страниц.
* QA-команды также могут использовать API, предлагаемые Chrome DevTools, для моделирования плохих сетевых условий и проведения геолокационного тестирования.
* Эта функция также позволяет тестировщикам проверить работу продукта в изменяющихся сетевых условиях, таких как 3G, 4G, 5G и т. д.
**6. Управление несколькими окнами и вкладками**
* В процессе тестирования программного обеспечения приходится переключаться между несколькими окнами, вкладками или приложениями в одном потоке.
* В ранних версиях Selenium управлять несколькими окнами или вкладками было непросто, поскольку для этого требовалось создавать новый объект Web Driver, который использовался для переключения на новое окно (или вкладку) с помощью уникального WindowHandle для выполнения последующих действий в этом окне (или вкладке).
* Но в **Selenium 4** эта функция была улучшена. Последняя версия Selenium поставляется с новым API - **newWindow**, который позволяет тестировщикам создавать и переключаться на новое окно/вкладку без создания нового объекта WebDriver в одном тестовом потоке или сессии.
**7. Телеметрия и GraphQL:**
В Selenium Grid был добавлен фреймворк под названием Open Telemetry. Эта функция привносит в Grid больше наглядности, поскольку позволяет тестировщикам видеть, что происходит внутри Grid, особенно когда что-то идет не так во время выполнения теста.
Кроме того, в Grid появилась новая фронтенд консоль, которая работает с конечной точкой GraphQL. Она позволяет тестировщикам выполнять запросы GraphQL к Selenium Grid, как в распределенном режиме, так и на локальной машине. Эта функция помогает им извлекать полезные метрики и информацию из Grid для выполнения задач мониторинга.
[Joe Colantonio](https://testguild.com/selenium-4/) в своей последней статье "Что такое Selenium 4? Последние достижения в области автоматизированного тестирования браузеров" подробно рассказал обо всех вышеперечисленных функциях и важности Selenium 4.
**8. Улучшенная документация:**
В ранних версиях Selenium пользователи сталкивались с большими трудностями при работе с документацией, так как возможности Selenium по документированию были недостаточны.
В последних версиях Selenium эта ситуация значительно улучшилась. Selenium 4.0 предоставляет более широкие возможности документирования.
* Его документационная часть была полностью обновлена с удобным UI, который позволяет пользователям легко переходить к нужному разделу страницы и охватывает всю информацию об инструментах и API, входящих в группу Selenium.
* Это поможет тестировщикам получить информацию обо всех функциях, необходимых для начала работы с [Selenium-тестированием](https://www.testingxperts.com/blog/selenium-testing).
#### Что утратило актуальность и изменилось в Selenium 4?
**1. Депрекация желаемых возможностей**
Желаемые возможности в основном использовались в сценарии тестирования для определения среды (имя браузера, версия, операционная система) при выполнении тестов на Selenium Grid. Теперь они заменены на Options. Это означает, что тестировщики теперь создают объект Options, задают требования к тесту и передают объект в конструктор Driver. Ниже перечислены объекты Options, которые были включены в Selenium 4.0
Firefox - FirefoxOptions
Chrome - ChromeOptions
Internet Explorer (IE) - InternetExplorerOptions
Microsoft Edge - EdgeOptions
Safari - SafariOptions
**2. Изменения в классе Action**
Класс Action используется для имитации действий ввода с клавиатуры или мыши на определенных веб-элементах. Например, щелчок левой или правой кнопкой мыши, двойной щелчок и т.д.
В Selenium 4.0 в класс Action были внесены следующие изменения
* `click(WebElement)` заменил `moveToElement(onElement).click() {}`
* `clickAndHold(WebElement)` заменен `moveToElement(onElement).clickAndHold()`
* `contextClick(WebElement)` заменен `moveToElement(onElement).contextClick()`
* `doubleClick(WebElement)` заменил `moveToElement(element).doubleClick()`
* `release()`, который ранее был частью класса `org.openqa.selenium.interactions.ButtonReleaseAction`, теперь перенесен в класс `Action` в соответствии с новым обновлением Selenium 4.0.
**3. Депрекация FindsBy**
В старой версии **Selenium** интерфейсы FindsBy были частью пакета `org.openqa.selenium.internal`. Он содержал методы `findElement(By)` и `findElements(By)`, реализованные классом `RemoteWebDriver`. Однако в версии Selenium 4.0 они были упразднены.
**4. Изменения в FluentWait**
В Selenium 4.0 методы `withTimeout()` и `pollingEvery()`, которые являются частью класса `FluentWait`, были изменены. Метод `pollingEvery()` принимает только один параметр - `Duration`, который может задаваться в секундах, миллисекундах, наносекундах, часах, днях и т.д. Аналогично, метод `withTimeOut()` также принимает только один параметр - `Duration`.
**Как TestingXperts (Tx) может помочь компаниям в автоматизации тестирования Selenium?**
Предприятия должны учитывать, что **тестирование Selenium** проводится опытными инженерами по автоматизации. Чтобы получить все преимущества **тестирования на Selenium**, предприятия могут сотрудничать с опытным инженером по автоматизации от независимого поставщика услуг в этой области.
#### Заключение
Сегодня почти каждый бизнес осознал важность автоматизации тестирования. И чтобы удовлетворить растущий спрос на автоматизацию тестирования, на современном рынке предлагается множество инструментов и фреймворков для этого. Из всех доступных средств автоматизации тестирования одним из инструментов, который широко используется по всему миру, является Selenium. Недавно появилось обновление Selenium, которое привлекло большое внимание аудитории. Последняя версия - Selenium 4.0, имеет ряд дополнительных преимуществ, таких как бесшовная интеграция, параллельное тестирование, кросс-браузерное тестирование, улучшенная документация и т.д., которые значительно упрощают **тестирование Selenium**. Предприятия должны ознакомиться со всеми особенностями и отличительными чертами Selenium 4.0, упомянутыми в этом блоге, прежде чем делать инвестиции в какую-либо [систему автоматизации тестирования](https://www.testingxperts.com/blog/test-automation-frameworks) или инструмент.
*Материал подготовлен для будущих учащихся на курсе «Java QA Engineer. Professional». Всех желающих приглашаем на* [***открытый урок***](https://otus.pw/yNDM/)*"Selenide". На занятии познакомимся с фреймворком Selenide, узнаем, какие проблемы он решает и напишем простой тест с его использованием.* | https://habr.com/ru/post/649615/ | null | ru | null |
# QtCreator: Qt кросс-компиляция из linux 64 в linux 32, win32, win64 и Mac OS X; upx, usb, dmg, etc
Библиотека [Qt](http://qt-project.org/) позволяет делать действительно кроссплатформенные приложения. Единожды написанный код можно откомпилировать под многие операционные системы. Но проблема именно в слове «компилировать», т.к. подразумевается, что необходимо перезагрузиться под целевую систему, иметь в ней настроенную среду разработки, установленный и настроенный зоопарк библиотек. Спасает кросс-компиляция — компиляция, производящая исполняемый код для платформы, отличной от той, на которой исполняется.
##### Кросс-компиляция для Windows 64
Обычно одной из наиболее востребованных проблем является сборка Windows-версии своего приложения, изначально разрабатывающегося под Linux. Пример решения этой проблемы можно увидеть [тут](http://silmor.de/qtstuff.cross.php) или [на русском](http://qtlinux.narod.ru/make_for_win.htm). Необходимо создать mkspecs-конфигурацию, положить файлы Qt в соответствующие директории и всё. Компилировать Qt в таком случае не обязательно, можно скачать бинарники с официального сайта.
У такого подхода есть несколько минусов: 1) QtCreator об установленной таким образом библиотеке ничего не знает; 2) Официальной сборки Qt для Windows x64 не существует. И если с первой проблемой ещё как-то можно бороться, то против второй поможет только компиляция…
Перед кросс-компиляцией не забудьте поставить непосредственно сам кросс-компилятор (ищется в пакетом менеджере по названию «mingw»). И скачать исходники qt-everywhere с официального сайта. В директории *mkspecs* распакованного архива копируем папку *win32-g++* в *win64-x-g++* и корректируем содержимое файла *qmake.conf*. У меня получилось следующее:
**Скрытый текст**
```
#
# qmake configuration for win64-x-g++
#
# Written for MinGW
#
# Cross compile example for i686-w64-mingw32-g++:
# configure -xplatform win32-g++ -device-option CROSS_COMPILE=i686-w64-mingw32-
#
MAKEFILE_GENERATOR = MINGW
load(device_config)
equals(QMAKE_HOST.os, Windows): EXE_SUFFIX = .exe
TEMPLATE = app
CONFIG += qt warn_on release link_prl copy_dir_files debug_and_release debug_and_release_target precompile_header
QT += core gui
DEFINES += UNICODE
#QT_LARGEFILE_SUPPORT
QMAKE_COMPILER_DEFINES += __GNUC__ WIN WIN32 WIN64
QMAKE_EXT_OBJ = .o
QMAKE_EXT_RES = _res.o
QMAKE_CC = $${CROSS_COMPILE}gcc
QMAKE_LEX = flex
QMAKE_LEXFLAGS =
QMAKE_YACC = byacc
QMAKE_YACCFLAGS = -d
QMAKE_CFLAGS = -pipe -m64
QMAKE_CFLAGS_DEPS = -M
QMAKE_CFLAGS_WARN_ON = -Wall -Wextra
QMAKE_CFLAGS_WARN_OFF = -w
QMAKE_CFLAGS_RELEASE = -O2
QMAKE_CFLAGS_DEBUG = -g
QMAKE_CFLAGS_YACC = -Wno-unused -Wno-parentheses
QMAKE_CXX = $${CROSS_COMPILE}g++
QMAKE_CXXFLAGS = $$QMAKE_CFLAGS
QMAKE_CXXFLAGS_DEPS = $$QMAKE_CFLAGS_DEPS
QMAKE_CXXFLAGS_WARN_ON = $$QMAKE_CFLAGS_WARN_ON
QMAKE_CXXFLAGS_WARN_OFF = $$QMAKE_CFLAGS_WARN_OFF
QMAKE_CXXFLAGS_RELEASE = $$QMAKE_CFLAGS_RELEASE
QMAKE_CXXFLAGS_DEBUG = $$QMAKE_CFLAGS_DEBUG
QMAKE_CXXFLAGS_YACC = $$QMAKE_CFLAGS_YACC
QMAKE_CXXFLAGS_THREAD = $$QMAKE_CFLAGS_THREAD
QMAKE_CXXFLAGS_RTTI_ON = -frtti
QMAKE_CXXFLAGS_RTTI_OFF = -fno-rtti
QMAKE_CXXFLAGS_EXCEPTIONS_ON = -fexceptions -mthreads
QMAKE_CXXFLAGS_EXCEPTIONS_OFF = -fno-exceptions
QMAKE_INCDIR = /usr/x86_64-w64-mingw32/include
QMAKE_INCDIR_QT = $$[QT_INSTALL_HEADERS]
QMAKE_LIBDIR_QT = $$[QT_INSTALL_LIBS]
QMAKE_RUN_CC = $(CC) -c $(CFLAGS) $(INCPATH) -o $obj $src
QMAKE_RUN_CC_IMP = $(CC) -c $(CFLAGS) $(INCPATH) -o $@ $<
QMAKE_RUN_CXX = $(CXX) -c $(CXXFLAGS) $(INCPATH) -o $obj $src
QMAKE_RUN_CXX_IMP = $(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<
QMAKE_LINK = $${CROSS_COMPILE}g++
QMAKE_LINK_C = $${CROSS_COMPILE}gcc
#QMAKE_LFLAGS = -m64
QMAKE_LFLAGS = -m64 -mthreads -static-libgcc -static -Wl,-enable-stdcall-fixup -Wl,-enable-auto-import -Wl,-enable-runtime-pseudo-reloc -mwindows
QMAKE_LFLAGS_EXCEPTIONS_ON = -mthreads
QMAKE_LFLAGS_EXCEPTIONS_OFF =
QMAKE_LFLAGS_RELEASE = -Wl,-s
QMAKE_LFLAGS_DEBUG =
QMAKE_LFLAGS_CONSOLE = -Wl,-subsystem,console
QMAKE_LFLAGS_WINDOWS = -Wl,-subsystem,windows
QMAKE_LFLAGS_DLL = -shared
QMAKE_LINK_OBJECT_MAX = 10
QMAKE_LINK_OBJECT_SCRIPT= object_script
QMAKE_PREFIX_STATICLIB = lib
QMAKE_EXTENSION_STATICLIB = a
QMAKE_LIBS =
QMAKE_LIBS_CORE = -lole32 -luuid -lws2_32 -ladvapi32 -lshell32 -luser32 -lkernel32
QMAKE_LIBS_GUI = -lgdi32 -lcomdlg32 -loleaut32 -limm32 -lwinmm -lwinspool -lws2_32 -lole32 -luuid -luser32 -ladvapi32
QMAKE_LIBS_NETWORK = -lws2_32
QMAKE_LIBS_OPENGL = -lglu32 -lopengl32 -lgdi32 -luser32
QMAKE_LIBS_COMPAT = -ladvapi32 -lshell32 -lcomdlg32 -luser32 -lgdi32 -lws2_32
QMAKE_LIBS_QT_ENTRY = -lmingw32 -lqtmain
!isEmpty(QMAKE_SH) {
MINGW_IN_SHELL = 1
QMAKE_DIR_SEP = /
QMAKE_QMAKE ~= s,\\\\,/,
QMAKE_COPY = cp
QMAKE_COPY_DIR = cp -r
QMAKE_MOVE = mv
QMAKE_DEL_FILE = rm
QMAKE_MKDIR = mkdir -p
QMAKE_DEL_DIR = rmdir
QMAKE_CHK_DIR_EXISTS = test -d
} else {
QMAKE_COPY = copy /y
QMAKE_COPY_DIR = xcopy /s /q /y /i
QMAKE_MOVE = move
QMAKE_DEL_FILE = del
QMAKE_MKDIR = mkdir
QMAKE_DEL_DIR = rmdir
QMAKE_CHK_DIR_EXISTS = if not exist
}
QMAKE_MOC = $$[QT_INSTALL_BINS]$${DIR_SEPARATOR}moc$${EXE_SUFFIX}
QMAKE_UIC = $$[QT_INSTALL_BINS]$${DIR_SEPARATOR}uic$${EXE_SUFFIX}
QMAKE_IDC = $$[QT_INSTALL_BINS]$${DIR_SEPARATOR}idc$${EXE_SUFFIX}
QMAKE_IDL = midl
QMAKE_LIB = $${CROSS_COMPILE}ar -ru
QMAKE_RC = $${CROSS_COMPILE}windres
QMAKE_ZIP = zip -r -9
QMAKE_STRIP = $${CROSS_COMPILE}strip
QMAKE_STRIPFLAGS_LIB += --strip-unneeded
load(qt_config)
```
По сути в файле спецификации были заменены только пути.
Я выполнял *configure* со следующими параметрами:
`./configure -xplatform win64-x-g++ CROSS_COMPILE=x86_64-w64-mingw32- -prefix /usr/local/qt4win64 -no-webkit -no-phonon -no-phonon-backend -no-script -no-scripttools -no-multimedia -no-qt3support -fast -nomake demos -nomake examples -nomake tools -device-option -little-endian -qt-zlib -qt-libpng -qt-libjpeg -openssl-linked -no-fontconfig -no-3dnow -no-ssse3 -continue`
Здесь собираю минимальную версию Qt без webkit, phonon, multimedia и т.п. Полный список опций можно посмотреть по команде *./configure --help*
Соответственно, для такой сборки должен быть установлен пакет *g++-mingw-w64-x86-64*, содержащий в себе *x86\_64-w64-mingw32-***g++** (в убунту пакет надо ставить отдельно).
Далее *make && sudo make install*. На первом этапе компиляции используется родной системный компилятор, он собирает необходимые утилиты для linux, которые будут использоваться для сборки уже windows-бинарников.
После установки у меня в */usr/local/qt4win64/bin* лежат PE32+ DLL и несколько ELF 64-bit LSB executable, в том числе: *qmake, uic, moc, rcc*. Вот они то и пригодятся для QtCreator!
После установки **не** удаляйте распакованную директорию — она используется.
##### Кросс-компиляция для Windows 32
Аналогична компиляции для Win64. За исключением того, что есть официальная сборка, и саму библиотеку компилировать не нужно! Достаточно собрать *qmake, uic, moc, rcc*.
configure:
**Скрытый текст**`./configure -xplatform win32-x-g++ -prefix /usr/local/qt4win32 CROSS_COMPILE=i686-w64-mingw32- -no-webkit -no-phonon -no-phonon-backend -no-script -no-scripttools -no-multimedia -no-qt3support -fast -nomake demos -nomake examples -nomake tools -device-option -little-endian -qt-zlib -qt-libpng -qt-libjpeg -openssl-linked -no-fontconfig -no-3dnow -no-ssse3 -continue`
qmake.conf
**Скрытый текст**
```
#
# qmake configuration for win32-x-g++
#
# Written for MinGW
#
# Cross compile example for i686-w64-mingw32-g++:
# configure -xplatform win32-g++ -device-option CROSS_COMPILE=i686-w64-mingw32-
#
MAKEFILE_GENERATOR = MINGW
load(device_config)
equals(QMAKE_HOST.os, Windows): EXE_SUFFIX = .exe
TEMPLATE = app
CONFIG += qt warn_on release link_prl copy_dir_files debug_and_release debug_and_release_target precompile_header
QT += core gui
DEFINES += UNICODE
#QT_LARGEFILE_SUPPORT
QMAKE_COMPILER_DEFINES += __GNUC__ WIN WIN32
QMAKE_EXT_OBJ = .o
QMAKE_EXT_RES = _res.o
QMAKE_CC = $${CROSS_COMPILE}gcc
QMAKE_LEX = flex
QMAKE_LEXFLAGS =
QMAKE_YACC = byacc
QMAKE_YACCFLAGS = -d
QMAKE_CFLAGS = -pipe -m32
QMAKE_CFLAGS_DEPS = -M
QMAKE_CFLAGS_WARN_ON = -Wall -Wextra
QMAKE_CFLAGS_WARN_OFF = -w
QMAKE_CFLAGS_RELEASE = -O2
QMAKE_CFLAGS_DEBUG = -g
QMAKE_CFLAGS_YACC = -Wno-unused -Wno-parentheses
QMAKE_CXX = $${CROSS_COMPILE}g++
QMAKE_CXXFLAGS = $$QMAKE_CFLAGS
QMAKE_CXXFLAGS_DEPS = $$QMAKE_CFLAGS_DEPS
QMAKE_CXXFLAGS_WARN_ON = $$QMAKE_CFLAGS_WARN_ON
QMAKE_CXXFLAGS_WARN_OFF = $$QMAKE_CFLAGS_WARN_OFF
QMAKE_CXXFLAGS_RELEASE = $$QMAKE_CFLAGS_RELEASE
QMAKE_CXXFLAGS_DEBUG = $$QMAKE_CFLAGS_DEBUG
QMAKE_CXXFLAGS_YACC = $$QMAKE_CFLAGS_YACC
QMAKE_CXXFLAGS_THREAD = $$QMAKE_CFLAGS_THREAD
QMAKE_CXXFLAGS_RTTI_ON = -frtti
QMAKE_CXXFLAGS_RTTI_OFF = -fno-rtti
QMAKE_CXXFLAGS_EXCEPTIONS_ON = -fexceptions -mthreads
QMAKE_CXXFLAGS_EXCEPTIONS_OFF = -fno-exceptions
QMAKE_INCDIR = /usr/i686-w64-mingw32/include
QMAKE_INCDIR_QT = $$[QT_INSTALL_HEADERS]
QMAKE_LIBDIR_QT = $$[QT_INSTALL_LIBS]
QMAKE_RUN_CC = $(CC) -c $(CFLAGS) $(INCPATH) -o $obj $src
QMAKE_RUN_CC_IMP = $(CC) -c $(CFLAGS) $(INCPATH) -o $@ $<
QMAKE_RUN_CXX = $(CXX) -c $(CXXFLAGS) $(INCPATH) -o $obj $src
QMAKE_RUN_CXX_IMP = $(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<
QMAKE_LINK = $${CROSS_COMPILE}g++
QMAKE_LINK_C = $${CROSS_COMPILE}gcc
QMAKE_LFLAGS = -m32 -mthreads -static-libgcc -static -Wl,-enable-stdcall-fixup -Wl,-enable-auto-import -Wl,-enable-runtime-pseudo-reloc -mwindows
QMAKE_LFLAGS_EXCEPTIONS_ON = -mthreads
QMAKE_LFLAGS_EXCEPTIONS_OFF =
QMAKE_LFLAGS_RELEASE = -Wl,-s
QMAKE_LFLAGS_DEBUG =
QMAKE_LFLAGS_CONSOLE = -Wl,-subsystem,console
QMAKE_LFLAGS_WINDOWS = -Wl,-subsystem,windows
QMAKE_LFLAGS_DLL = -shared
QMAKE_LINK_OBJECT_MAX = 10
QMAKE_LINK_OBJECT_SCRIPT= object_script
QMAKE_PREFIX_STATICLIB = lib
QMAKE_EXTENSION_STATICLIB = a
QMAKE_LIBS =
QMAKE_LIBS_CORE = -lole32 -luuid -lws2_32 -ladvapi32 -lshell32 -luser32 -lkernel32
QMAKE_LIBS_GUI = -lgdi32 -lcomdlg32 -loleaut32 -limm32 -lwinmm -lwinspool -lws2_32 -lole32 -luuid -luser32 -ladvapi32
QMAKE_LIBS_NETWORK = -lws2_32
QMAKE_LIBS_OPENGL = -lglu32 -lopengl32 -lgdi32 -luser32
QMAKE_LIBS_COMPAT = -ladvapi32 -lshell32 -lcomdlg32 -luser32 -lgdi32 -lws2_32
QMAKE_LIBS_QT_ENTRY = -lmingw32 -lqtmain
!isEmpty(QMAKE_SH) {
MINGW_IN_SHELL = 1
QMAKE_DIR_SEP = /
QMAKE_QMAKE ~= s,\\\\,/,
QMAKE_COPY = cp
QMAKE_COPY_DIR = cp -r
QMAKE_MOVE = mv
QMAKE_DEL_FILE = rm
QMAKE_MKDIR = mkdir -p
QMAKE_DEL_DIR = rmdir
QMAKE_CHK_DIR_EXISTS = test -d
} else {
QMAKE_COPY = copy /y
QMAKE_COPY_DIR = xcopy /s /q /y /i
QMAKE_MOVE = move
QMAKE_DEL_FILE = del
QMAKE_MKDIR = mkdir
QMAKE_DEL_DIR = rmdir
QMAKE_CHK_DIR_EXISTS = if not exist
}
QMAKE_MOC = $$[QT_INSTALL_BINS]$${DIR_SEPARATOR}moc$${EXE_SUFFIX}
QMAKE_UIC = $$[QT_INSTALL_BINS]$${DIR_SEPARATOR}uic$${EXE_SUFFIX}
QMAKE_IDC = $$[QT_INSTALL_BINS]$${DIR_SEPARATOR}idc$${EXE_SUFFIX}
QMAKE_IDL = midl
QMAKE_LIB = $${CROSS_COMPILE}ar -ru
QMAKE_RC = $${CROSS_COMPILE}windres
QMAKE_ZIP = zip -r -9
QMAKE_STRIP = $${CROSS_COMPILE}strip
QMAKE_STRIPFLAGS_LIB += --strip-unneeded
load(qt_config)
```
##### Кросс-компиляция для Mac OS X
Кросс-компиляция для мака тоже очень похожа, за исключением того, что надо будет собрать и компилятор. Я собирал по [этой инструкции](https://github.com/Tatsh/xchain). Это отняло полный день времени и кучу нервов. В процессе будет нужна рабочая Mac OS X (как минимум на виртуальной машине) с установленным XCode, чтобы взять оттуда необходимые файлы. При компилировании своих Qt-приложений запущенная Mac OS X не нужна.
configure:
**Скрытый текст**`./configure -xplatform macx-x-g++ -prefix /usr/x86_64-apple-darwin11/usr/Qt CROSS_COMPILE=/usr/x86_64-apple-darwin11/usr/bin/x86_64-apple-darwin11- -no-webkit -no-phonon -no-phonon-backend -no-script -no-scripttools -no-multimedia -no-qt3support -fast -nomake demos -nomake examples -nomake tools -device-option -little-endian -qt-zlib -qt-libpng -qt-libjpeg -openssl-linked -no-fontconfig -no-3dnow -no-ssse3 -continue`
qmake.conf:
**Скрытый текст**
```
#macx-x-g++ (different from g++.conf)
#
# qmake configuration for macx-g++
#
# Mac OS X + command-line compiler
#
MAKEFILE_GENERATOR = UNIX
TARGET_PLATFORM = macx
TEMPLATE = app
CONFIG += qt warn_on release app_bundle incremental global_init_link_order lib_version_first plugin_no_soname link_prl
QT += core gui
QMAKE_INCREMENTAL_STYLE = sublib
#include(../common/mac.conf)
#
# qmake configuration for common Mac OS X
#
#QMAKE_RESOURCE = /Developer/Tools/Rez
QMAKE_EXTENSION_SHLIB = dylib
QMAKE_INCDIR = /usr/x86_64-apple-darwin11/usr/include
QMAKE_LIBDIR =
QMAKE_INCDIR_QT = /usr/x86_64-apple-darwin11/usr/Qt/include
QMAKE_LIBDIR_QT = /usr/x86_64-apple-darwin11/usr/Qt/lib
QMAKE_INCDIR_OPENGL = /System/Library/Frameworks/OpenGL.framework/Headers \
/System/Library/Frameworks/AGL.framework/Headers/
QMAKE_FRAMEWORKDIR_QT= /usr/x86_64-apple-darwin11/usr/QtFrameworks
QMAKE_FIX_RPATH = install_name_tool -id
QMAKE_LFLAGS_RPATH =
QMAKE_LIBS_DYNLOAD =
QMAKE_LIBS_OPENGL = -framework OpenGL -framework AGL
QMAKE_LIBS_OPENGL_QT = $$QMAKE_LIBS_OPENGL
QMAKE_LIBS_THREAD =
QMAKE_MOC = $$[QT_INSTALL_BINS]/moc
QMAKE_UIC = $$[QT_INSTALL_BINS]/uic
QMAKE_AR = /usr/x86_64-apple-darwin11/usr/bin/x86_64-apple-darwin11-ar cq
QMAKE_RANLIB = /usr/x86_64-apple-darwin11/usr/bin/x86_64-apple-darwin11-ranlib -s
QMAKE_TAR = tar -cf
QMAKE_GZIP = gzip -9f
QMAKE_COPY = cp -f
QMAKE_COPY_FILE = $$QMAKE_COPY
QMAKE_COPY_DIR = $$QMAKE_COPY -R
QMAKE_MOVE = mv -f
QMAKE_DEL_FILE = rm -f
QMAKE_DEL_DIR = rmdir
QMAKE_CHK_DIR_EXISTS = test -d
QMAKE_MKDIR = mkdir -p
QMAKE_MACOSX_DEPLOYMENT_TARGET = 10.5 # overridden to 10.5 for Cocoa on the compiler command line
#
# qmake configuration for common unix
#
QMAKE_LEX = flex
QMAKE_LEXFLAGS +=
QMAKE_YACC = yacc
QMAKE_YACCFLAGS += -d
QMAKE_YACCFLAGS_MANGLE += -p $base -b $base
QMAKE_YACC_HEADER = $base.tab.h
QMAKE_YACC_SOURCE = $base.tab.c
QMAKE_PREFIX_SHLIB = lib
QMAKE_PREFIX_STATICLIB = lib
QMAKE_EXTENSION_STATICLIB = a
#include(../common/gcc-base-macx.conf)
#
# This file is used as a basis for the following compilers:
#
# - The QNX qcc compiler
#
# The only difference between this and gcc-base.conf is that -pipe is removed
# as it's on by default in qcc (and has an analogous -nopipe option)
#
QMAKE_CFLAGS +=
QMAKE_CFLAGS_DEPS += -M
QMAKE_CFLAGS_WARN_ON += -Wall -W
QMAKE_CFLAGS_WARN_OFF += -w
QMAKE_CFLAGS_RELEASE += -O2
QMAKE_CFLAGS_DEBUG += -g
QMAKE_CFLAGS_SHLIB += -fPIC
QMAKE_CFLAGS_STATIC_LIB += -fPIC
QMAKE_CFLAGS_YACC += -Wno-unused -Wno-parentheses
QMAKE_CFLAGS_HIDESYMS += -fvisibility=hidden
QMAKE_CXXFLAGS += $$QMAKE_CFLAGS
QMAKE_CXXFLAGS_DEPS += $$QMAKE_CFLAGS_DEPS
QMAKE_CXXFLAGS_WARN_ON += $$QMAKE_CFLAGS_WARN_ON
QMAKE_CXXFLAGS_WARN_OFF += $$QMAKE_CFLAGS_WARN_OFF
QMAKE_CXXFLAGS_RELEASE += $$QMAKE_CFLAGS_RELEASE
QMAKE_CXXFLAGS_DEBUG += $$QMAKE_CFLAGS_DEBUG
QMAKE_CXXFLAGS_SHLIB += $$QMAKE_CFLAGS_SHLIB
QMAKE_CXXFLAGS_STATIC_LIB += $$QMAKE_CFLAGS_STATIC_LIB
QMAKE_CXXFLAGS_YACC += $$QMAKE_CFLAGS_YACC
QMAKE_CXXFLAGS_HIDESYMS += $$QMAKE_CFLAGS_HIDESYMS -fvisibility-inlines-hidden
QMAKE_LFLAGS +=
QMAKE_LFLAGS_DEBUG +=
QMAKE_LFLAGS_APP +=
QMAKE_LFLAGS_RELEASE +=
#
# Base qmake configuration for GCC on Mac OS X
#
# Before making changes to this file, please read the comment in
# gcc-base.conf, to make sure the change goes in the right place.
#
# To verify that your change has the desired effect on the final configuration
# you can use the manual test in tests/manual/mkspecs.
#
QMAKE_COMPILER_DEFINES += __APPLE__ __GNUC__
QMAKE_CFLAGS_X86 += -arch i386
QMAKE_CFLAGS_X86_64 += -arch x86_64
QMAKE_CFLAGS_PPC += -arch ppc
QMAKE_CFLAGS_PPC_64 += -arch ppc64
QMAKE_CFLAGS_DWARF2 += -gdwarf-2
QMAKE_CXXFLAGS_X86 += $$QMAKE_CFLAGS_X86
QMAKE_CXXFLAGS_X86_64 += $$QMAKE_CFLAGS_X86_64
QMAKE_CXXFLAGS_PPC += $$QMAKE_CFLAGS_PPC
QMAKE_CXXFLAGS_PPC_64 += $$QMAKE_CFLAGS_PPC_64
QMAKE_CXXFLAGS_DWARF2 += $$QMAKE_CFLAGS_DWARF2
QMAKE_OBJECTIVE_CFLAGS = $$QMAKE_CFLAGS
QMAKE_OBJECTIVE_CFLAGS_WARN_ON = $$QMAKE_CFLAGS_WARN_ON
QMAKE_OBJECTIVE_CFLAGS_WARN_OFF = $$QMAKE_CFLAGS_WARN_OFF
QMAKE_OBJECTIVE_CFLAGS_DEBUG = $$QMAKE_CFLAGS_DEBUG
QMAKE_OBJECTIVE_CFLAGS_RELEASE = $$QMAKE_CFLAGS_RELEASE
QMAKE_OBJECTIVE_CFLAGS_HIDESYMS = $$QMAKE_CXXFLAGS_HIDESYMS
QMAKE_OBJECTIVE_CFLAGS_X86 = $$QMAKE_CFLAGS_X86
QMAKE_OBJECTIVE_CFLAGS_X86_64 = $$QMAKE_CFLAGS_X86_64
QMAKE_OBJECTIVE_CFLAGS_PPC = $$QMAKE_CFLAGS_PPC
QMAKE_OBJECTIVE_CFLAGS_PPC_64 = $$QMAKE_CFLAGS_PPC_64
QMAKE_LFLAGS_X86 += $$QMAKE_CFLAGS_X86
QMAKE_LFLAGS_X86_64 += $$QMAKE_CFLAGS_X86_64
QMAKE_LFLAGS_PPC += $$QMAKE_CFLAGS_PPC
QMAKE_LFLAGS_PPC_64 += $$QMAKE_CFLAGS_PPC_64
QMAKE_LFLAGS += -headerpad_max_install_names
QMAKE_LFLAGS_SHLIB += -single_module -dynamiclib
QMAKE_LFLAGS_PLUGIN += $$QMAKE_LFLAGS_SHLIB
QMAKE_LFLAGS_INCREMENTAL += -undefined suppress -flat_namespace
QMAKE_LFLAGS_SONAME += -install_name$${LITERAL_WHITESPACE}
QMAKE_LFLAGS_VERSION += -current_version$${LITERAL_WHITESPACE}
QMAKE_LFLAGS_COMPAT_VERSION += -compatibility_version$${LITERAL_WHITESPACE}
#
# Qmake configuration for the GNU C++ compiler
#
# Before making changes to this file, please read the comment in
# gcc-base.conf, to make sure the change goes in the right place.
#
# To verify that your change has the desired effect on the final configuration
# you can use the manual test in tests/manual/mkspecs.
#
QMAKE_CC = /usr/x86_64-apple-darwin11/usr/bin/x86_64-apple-darwin11-g++
QMAKE_LINK_C = $$QMAKE_CC -F/usr/x86_64-apple-darwin11/usr/Frameworks
QMAKE_LINK_C_SHLIB = $$QMAKE_CC -F/usr/x86_64-apple-darwin11/usr/Frameworks
QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO += -O2 -g
QMAKE_CXX = /usr/x86_64-apple-darwin11/usr/bin/x86_64-apple-darwin11-g++
QMAKE_LINK = /usr/x86_64-apple-darwin11/usr/bin/x86_64-apple-darwin11-g++ -F/usr/x86_64-apple-darwin11/usr/Frameworks
QMAKE_LINK_SHLIB = $$QMAKE_CXX -F/usr/x86_64-apple-darwin11/usr/Frameworks
QMAKE_CXXFLAGS_RELEASE_WITH_DEBUGINFO += $$QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO
QMAKE_PCH_OUTPUT_EXT = .gch
QMAKE_CFLAGS_PRECOMPILE = -x c-header -c ${QMAKE_PCH_INPUT} -o ${QMAKE_PCH_OUTPUT}
QMAKE_CFLAGS_USE_PRECOMPILE = -include ${QMAKE_PCH_OUTPUT_BASE}
QMAKE_CXXFLAGS_PRECOMPILE = -x c++-header -c ${QMAKE_PCH_INPUT} -o ${QMAKE_PCH_OUTPUT}
QMAKE_CXXFLAGS_USE_PRECOMPILE = $$QMAKE_CFLAGS_USE_PRECOMPILE
#include(../common/g++-macx.conf)
#
# Qmake configuration for the GNU C++ compiler on Mac OS X
#
# Before making changes to this file, please read the comment in
# gcc-base.conf, to make sure the change goes in the right place.
#
# To verify that your change has the desired effect on the final configuration
# you can use the manual test in tests/manual/mkspecs.
#
QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO += $$QMAKE_CFLAGS_DWARF2
QMAKE_CXXFLAGS_RELEASE_WITH_DEBUGINFO += $$QMAKE_CFLAGS_DWARF2
QMAKE_LFLAGS_RELEASE_WITH_DEBUGINFO += -g $$QMAKE_CFLAGS_DWARF2
QMAKE_LFLAGS_STATIC_LIB += -all_load
QMAKE_CFLAGS_X86_64 += -Xarch_x86_64 -mmacosx-version-min=10.5
QMAKE_CFLAGS_PPC_64 += -Xarch_ppc64 -mmacosx-version-min=10.5
QMAKE_CXXFLAGS_X86_64 = $$QMAKE_CFLAGS_X86_64
QMAKE_CXXFLAGS_PPC_64 = $$QMAKE_CFLAGS_PPC_64
QMAKE_OBJECTIVE_CFLAGS_X86_64 = $$QMAKE_CFLAGS_X86_64
QMAKE_OBJECTIVE_CFLAGS_PPC_64 = $$QMAKE_CFLAGS_PPC_64
QMAKE_LFLAGS_X86_64 = $$QMAKE_CFLAGS_X86_64
QMAKE_LFLAGS_PPC_64 = $$QMAKE_CFLAGS_PPC_64
QMAKE_OBJCFLAGS_PRECOMPILE = -x objective-c-header -c ${QMAKE_PCH_INPUT} -o ${QMAKE_PCH_OUTPUT}
QMAKE_OBJCFLAGS_USE_PRECOMPILE = $$QMAKE_CFLAGS_USE_PRECOMPILE
QMAKE_OBJCXXFLAGS_PRECOMPILE = -x objective-c++-header -c ${QMAKE_PCH_INPUT} -o ${QMAKE_PCH_OUTPUT}
QMAKE_OBJCXXFLAGS_USE_PRECOMPILE = $$QMAKE_CFLAGS_USE_PRECOMPILE
load(qt_config)
```
Помните, в Mac OS X для линковки с библиотекой **.a**-файлы не нужны.
##### Настройка QtCreator
Сначала нужно добавить в список все установленные компиляторы. Инструменты — Параметры — Сборка и запуск — Инструментарии:
QtCreator обычно нормально определяет ABI, но лучше перепроверить. Так же можно заметить, что системный x64 GCC в linux умеет генерировать и 32-битные приложения. Однако это не отменяет того, что также необходимы 32-битные версии библиотек.
После компиляторов можно добавить профили Qt:
Вот при добавлении профиля и пригодятся собранные ранее *qmake, uic, moc, rcc*, ведь нужно выбрать директорию с *qmake*. Жёлтый значок с восклицательным знаком слева от профиля означает warning, но QtCreator может использовать такой профиль Qt. А вот если значок красный, то профиль нерабочий. Такое может случиться при неправильной структуре каталогов. Или если удалить директорию, в которой компилировали Qt.
Следующие настройки нужно делать в каждом создаваемом проекте.
Для добавления конкретного профиля Qt надо при активном проекте зайти на вкладку «Проекты» (Ctrl+5):
По умолчанию в списке «Изменить конфигурацию сборки» есть только системный профиль Qt. Зато в списке кнопки «Добавить» есть все профили Qt, добавленные в параметры сборки.
В основных настройках сборки необходимо проверить пару библиотека-компилятор. Чтоб и то и другое было от одной и той же операционной системы.
Этапы сборки «qmake» и «Сборка» QtCreator ставит по умолчанию. А вот особые этапы «upx» и «dmgbuild» я добавил вручную для своего проекта. Этап «upx» выполняется каждый раз при нажатии на кнопку «Собрать проект». Однако если исполняемый файл не был изменён, то *upx* вернёт ошибку, что файл им уже обработан. В случае ошибки следующий этап не вызывается, т.е. dmg-файл обновится только если upx отработал успешно.
Для работы этапа *upx* он должен быть установлен в системе. Однако даже работая в linux-окружении и поставленный из пакетного менеджера *upx* умеет ужимать приложения: linux32/64, win32, macos32/64. Далеко не для всех проектов upx-сжатие реально нужно, этап показан скорее для примера.
Для этапа «dmgbuild» я воспользовался скриптом [make\_dmg](http://confluence.concord.org/display/CCTR/Creating+MacOS+dmg+files+in+Linux). Ему нужны права *root*, поэтому добавил скрипт в файл */etc/sudoers*
##### Изменения в проектном файле и использование сторонних библиотек
В моём проекте используется *libusb*, а это далеко не часть Qt. Также необходимо было включить платформенно-зависимую реализацию HID. В проектный файл были добавлены строки:
```
macx {
INCLUDEPATH += $$PWD/libusbx/
SOURCES += BootLoader/HIDAPI/mac/hid.c
LIBS += -framework IOKit -framework CoreFoundation -lusb-1.0
ICON = AqPicFlash.icns
}
win32: {
INCLUDEPATH += $$PWD/libusbx/
LIBS += -lsetupapi -lole32
SOURCES += BootLoader/HIDAPI/windows/hid.cpp
RC_FILE = WinIcon.rc
}
win32: !win64-x-g++ {
LIBS += -L$$PWD/libusbx/ -lusb-1.0-32.dll
}
win64-x-g++ {
LIBS += -L$$PWD/libusbx/ -lusb-1.0-64.dll
}
unix: !macx {
CONFIG += link_pkgconfig
PKGCONFIG += libusb-1.0
SOURCES += BootLoader/HIDAPI/linux/hid-libusb.c
}
```
В Mac OS X и Linux линкуемся с системной libusb, в Windows в зависимости от разрядности линкуемся с *libusb-1.0-32.dll.a* или *libusb-1.0-64.dll.a*. Помним, что **.a**-файл может быть переименован, но зависеть приложение всё-равно будет от *libusb-1.0.dll*. В Linux параметры для libusb берём через системную утилиту pkgconfig. Кроме libusb подключаем для каждой операционной системы необходимые системные библиотеки и иконки.
Удобно разнести итоговые файлы для разных операционных систем по директориям. Сделать это можно так:
```
macx {
DESTDIR = mac
OBJECTS_DIR = mac
MOC_DIR = mac
UI_DIR = mac
RCC_DIR = mac
}
unix: !macx {
DESTDIR = linux
OBJECTS_DIR = linux
MOC_DIR = linux
UI_DIR = linux
RCC_DIR = linux
}
win32 {
DESTDIR = windows/release
OBJECTS_DIR = windows
MOC_DIR = windows
UI_DIR = windows
RCC_DIR = windows
}
win64-x-g++ {
DESTDIR = win64/release
OBJECTS_DIR = win64
MOC_DIR = win64
UI_DIR = win64
RCC_DIR = win64
}
```
Цель *win64-x-g++* относится к *win32*, однако в проектном файле идёт последней и переписывает настройки.
##### Результат
Теперь чтобы собрать приложение под ту или иную операционную систему достаточно выбрать тип сборки, как показано на самом первом скриншоте, и нажать «Собрать проект» | https://habr.com/ru/post/198142/ | null | ru | null |
# Справа налево. Как перевернуть интерфейс сайта под RTL
Мы недавно перевели онлайн-версию 2ГИС на арабский язык, и в [прошлой статье](https://habr.com/company/2gis/blog/358148/) я рассказал о необходимой для этого теории — что такое `dir="rtl"`, по каким правилам отображается текст смешанной направленности и как держать себя в руках.
Настало время приступить к практике — перевернуть с минимальными усилиями весь интерфейс справа налево так, чтобы даже настоящий араб не почувствовал подвоха.
В этой статье я расскажу, как быстро сделать прототип, что сделать со сборкой CSS и какие костыли разложить в JS, замечу немного об особенностях перевода и локализации, напомню про логические свойства CSS и затрону тему RTL в CSS-in-JS.
Переворачиваем стили
--------------------
Когда я применил к тегу атрибут dir="rtl", поменялся только неявный порядок элементов — например, порядок ячеек таблицы или flex-элементов. С явно заданными в стилях значениями ничего не произошло.
Возьмём стили какой-нибудь нотификации, расположенной снизу справа:
```
.tooltip {
position: 'absolute';
bottom: 10px;
right: 10px;
}
```
`dir="rtl"` никак не повлияет на эти стили — в RTL-версии тултип будет так же справа, хотя ожидается он слева.
Что делать? Нужно заменить `right: 10px` на `left: 10px`. И так со всеми остальными стилями. Абсолютное позиционирование, margin/padding, выравнивание текста — всё нужно для арабской версии перевернуть в другую сторону.
### Быстрый прототип
Для начала можно, не задумываясь, поменять все вхождения left на right и немножко поколдовать с shorthand значениями:
* left: 0 → right: 0
* padding-left: 4px → padding-right: 4px
* margin: 0 16px 0 0 → margin: 0 0 0 16px
Для этого подходит плагин [postcss-rtl](https://github.com/vkalinichev/postcss-rtl). Удобно — нужно только вбросить его в список всех postcss-плагинов проекта. Он заменяет все направленные правила на зеркальные и оборачивает это в `[dir="rtl"]`. Например:
```
/* input */
.foo {
color: red;
margin-left: 16px;
}
/* output */
[dir] .foo {
color: red;
}
[dir="ltr"] .foo {
margin-left: 16px;
}
[dir="rtl"] .foo {
margin-right: 16px;
}
```
После этого нужно только задать `dir="rtl"` и автоматически применятся только нужные правила. Всё работает и кажется, что почти всё готово к продакшену, но это решение годится только для быстрого прототипа:
* **увеличивается специфичность каждого правила**. Это не обязательно будет проблемой, но хотелось бы этого избежать;
* **такие манипуляции порождают баги**. Например, может [ломаться порядок свойств](https://github.com/vkalinichev/postcss-rtl/issues/9);
* **заметно растёт размер css-файла**. К каждому селектору добавляется `[dir]`, каждое направленное свойство дублируется. В нашем случае размер увеличился на одном проекте на 21%, на другом — на 35%:
| | исходный размер (gzip) | двунаправленный размер (gzip) | распухло на |
| --- | --- | --- | --- |
| 2gis.ru | 272.3 kB | 329.7 kB | 21% |
| m.2gis.ru | 24.5 kB | 33.2 kB | 35% |
| habr.com | 33.1 kB | 41.4 kB | 25% |
### Есть вариант лучше?
Нужно собирать стили для LTR и RTL раздельно. Тогда не нужно будет трогать селекторы и размер css почти не изменится.
Для этого я выбрал:
1. [RTLCSS](https://github.com/MohammadYounes/rtlcss) — эта библиотека под капотом у postcss-rtl.
2. [webpack-rtl-plugin](https://github.com/romainberger/webpack-rtl-plugin) — готовое решение для стилей, собираемых через ExtractTextPlugin. Тот же RTLCSS под капотом.
И стал собирать RTL и LTR в разные файлы — `styles.css` и `styles.rtl.css`. Единственный минус сборки в разные файлы — нельзя заменить dir на лету, не загружая предварительно нужный файл.
RTLCSS позволяет использовать директивы, чтобы контролировать обработку конкретных правил, например:
```
.foo {
/*rtl:ignore*/
right: 0;
}
.bar {
font-size:16px/*rtl:14px*/;
}
```
#### Какие ещё есть решения?
Все существующие решения почти не отличаются от RTLCSS.
* [css-flip](https://github.com/twitter/css-flip) от Twitter;
* [cssjanus](https://github.com/cssjanus/cssjanus) от Wikimedia;
* да и [postcss-rtl](https://github.com/vkalinichev/postcss-rtl) поддерживает параметр `onlyDirection`, с помощью которого можно собирать стили только для одной направленности, но размер всё равно растёт — например, для мобильного 2ГИС это 18% вместо 35% (24.5 kB → 29 kB).
#### Когда нужны директивы?
**Когда стили не должны зависеть от направленности**
Например, угол поворота стрелки, указывающей направление ветра:
```
.arrow._nw {
/*rtl:ignore*/
transform: rotate(135deg);
}
```
Или фейд у номера телефона — числа всегда пишутся слева направо, значит, и градиент должен быть всегда справа:
**Когда нужно центрировать иконку**
Это частный случай предыдущего пункта. Если центрируем несимметричную иконку через отступы/позиционирование, мы смещаем её блок в сторону, и если это смещение отразить, иконка «съедет» в другую сторону:
Лучше в таких ситуациях центрировать иконку в самой svg:
**Когда нужно изолировать целый виджет, который не должен реагировать на RTL**
В нашем случае это карта. Мы оборачиваем все её стили при сборке в блочные директивы: `/*rtl:begin:ignore*/ ... /*rtl:end:ignore*/`.
### Есть ли вариант ещё лучше?
Решение с переворачиванием правил прекрасно работает, но возникает вопрос — а не костыль ли это? Зависимость стилей от направления — естественная задача для современного веба, и её актуальность с каждым годом растёт всё больше. Это должно было найти отражение в современных стандартах и подходах. И нашло!
Logical properties
------------------
Для адаптации вёрстки под разную направленность существует стандарт [логических свойств в css](https://www.w3.org/TR/css-logical-1/). Он касается не только направлений слева направо и справа налево, но и направления сверху вниз, но его мы рассматривать не будем.
Мы уже пользуемся чем-то похожим во флексах и гридах — например, `flex-start`, `flex-end`, `grid-row-start`, `grid-column-end` отвязаны от «лево/право».
Вместо понятий `left`, `right`, `top` и `bottom` предлагается использовать `inline-start`, `inline-end`, `block-start` и `block-end`. Вместо `width` и `height` — `inline-size` и `block-size`. А вместо шортхендов `a b c d` — `logical a d c b` (логические шортхенды идут против часовой стрелки). Также для существующих шортхендов появляются новые парные версии — `padding-block`, `margin-inline`, `border-color-inline`, и т.д.
* `left: 0 → inset-inline-start: 0`
* `padding-left: 4px → padding-inline-start: 4px`
* `margin: 0 16px 0 0 → margin: logical 0 0 0 16px`
* `padding-top: 8px; padding-bottom: 16px → padding-block: 8px 16px`
* `margin-left: 4px; margin-right: 8px → margin-inline: 4px 8px`
* `text-align: right → text-align: end`
А ещё появляется долгожданный шортхенд для позиционирования:
* `left: 4px; right: 8px → inset-inline: 4px 8px`
* `top: 8px; bottom: 16px → inset-block: 8px 16px`
* `top: 0; right: 2px; bottom: 2px; left: 0 → inset: logical 0 0 2px 2px`
Это [уже доступно](https://caniuse.com/#feat=css-logical-props) в firefox без флагов и в вебкитовых браузерах под флагом.
**Плюсы** — решение нативное, будет работать вообще без сборки/плагинов, если нужные браузеры поддерживаются. Нет потребности в директивах — просто пиши `left` вместо `inline-start`, когда имеется в виду физическое «слева».
**Минусы** вытекают из плюсов — без плагинов код в большинстве браузеров невалиден, нужно проделать много работы, чтобы перевести большой существующий проект.
### Как подключить?
Самый простой способ — [postcss-logical](https://github.com/jonathantneal/postcss-logical). Без параметра `dir` собирает стили для обоих направлений аналогично postcss-rtl, с заданным параметром `dir` — только для указанной направленности:
```
.banner {
color: #222222;
inset: logical 0 5px 10px;
padding-inline: 20px 40px;
resize: block;
transition: color 200ms;
}
/* becomes */
.banner {
color: #222222;
top: 0; left: 5px; bottom: 10px; right: 5px;
&:dir(ltr) {
padding-left: 20px; padding-right: 40px;
}
&:dir(rtl) {
padding-right: 20px; padding-left: 40px;
}
resize: vertical;
transition: color 200ms;
}
/* or, when used with { dir: 'ltr' } */
.banner {
color: #222222;
top: 0; left: 5px; bottom: 10px; right: 5px;
padding-left: 20px; padding-right: 40px;
resize: vertical;
transition: color 200ms;
}
```
### Как убедить команду начать писать offset-inline-start вместо left?
Никак. Но мы у себя на проекте решили упростить — писать `start: 0` вместо `offset-inline-start: 0`, как только все привыкнут, начну навязывать валидную запись :)
RTL + CSS-in-JS = ️️<3
----------------------
CSS-in-JS не нужно собирать заранее. Значит, можно в рантайме определять направленность компонентов и выбирать, какие переворачивать, а какие нет. Полезно, если нужно вставить какой-то виджет, не поддерживающий RTL вообще.
В целом задача состоит в том, чтобы превращать объекты типа `{ paddingInlineStart: '4px' }` (или `{ paddingLeft: '4px' }`, если не удалось перейти на логические свойства) в объекты типа `{ paddingRight: '4px' }`:
1. Вооружаемся [bidi-css-js](https://github.com/TxHawks/bidi-css-js) или [rtl-css-js](https://github.com/kentcdodds/rtl-css-js). Они предоставляют функцию, которая принимает объект стилей и возвращает трансформированный под нужную направленность.
2. ???
3. PROFIT!
### Пример с реактом
Оборачиваем каждый стилизуемый компонент в [HOC](https://reactjs.org/docs/higher-order-components.html), принимающий стили:
```
export default withStyles(styles)(Button);
```
Он берёт из контекста направленность компонента и выбирает конечные стили:
```
function withStyles(styles) {
const { ltrStyles, rtlStyles } = bidi(styles);
return function WithStyles(WrappedComponent) {
...
render() {
return ;
};
};
...
};
}
```
А направленность в контекст прокидывает провайдер:
```
...
...
```
Похожий подход используют airbnb: <https://github.com/airbnb/react-with-styles-interface-aphrodite#built-in-rtl-support>, если на проекте уже используется [aphrodite](https://github.com/Khan/aphrodite), можно воспользоваться этим готовым решением.
Для JSS всё ещё проще — нужно только подключить [jss-rtl](https://github.com/alitaheri/jss-rtl):
```
jss.use(rtl());
```
### styled-components
```
const Button = styled.button`
background: #222;
margin-left: 12px;
`;
```
Что делать, если мы работаем с шаблонными строками, а не с объектами? Всё сложно, но выход есть — вычислять название свойства из направления, заданного в `props`:
```
const marginStart = props =>
props.theme.dir === "rtl" ? "margin-left" : "margin-right";
const Button = styled.button`
background: #222;
${marginStart}: 12px;
`;
```
Но кажется проще перейти со строк на объекты, styled-components [умеют это с версии 3.3.0](https://github.com/styled-components/styled-components/releases/tag/v3.3.0).
Особенности перевода и локализации
----------------------------------
Мы разобрались с технической частью. Изолировали контент неопределённой направленности, отзеркалили стили, расставили исключения в нужных местах, перевели тексты на арабский. Кажется, всё готово — при переключении языка весь интерфейс оказывается с другой стороны экрана, никакая вёрстка не едет и всё выглядит лучше, чем на любом арабском сайте.
**Показываем настоящему арабу, и...**
Оказывается, не каждый носитель арабского языка знает, что такое Twitter. Это касается почти всех слов на английском. Для такого случая есть арабский транслит: «تويتر».
Оказывается, в арабском свои запятые, и то, что мы везде по коду конкатенировали через «,», на арабском нужно конкатенировать через «،».
Оказывается, в некоторых мусульманских странах официальный календарь — исламский. Он лунный и обычной формулой перевода не обойтись.
Оказывается, в Дубае не бывает отрицательной температуры и знак «плюс» в прогнозе «+40» не имеет никакого смысла.
### Не просто взял и отзеркалил стили
Если мы делаем `dir="auto"` на блочный элемент и его контент окажется LTR, текст прибьётся к левой стороне контейнера, даже если вокруг RTL. Это можно просто вылечить, явно задав `text-align: right`. Можно даже применить это ко всей странице в арабской версии — значение этого свойства наследуется.
Иконки тоже автоматически не отзеркалятся. А без этого направленные иконки, такие как стрелки в галерее, могут смотреть в неправильную сторону. Представь себе, это единственный случай, в котором стрелки, [сделанные через border](https://stackoverflow.com/questions/27492191/how-to-make-a-fancy-arrow-using-css), оправдали себя!
Для отражения иконок поможет незамысловатая трансформация:
```
[dir="rtl"] .my-icon {
transform: scaleX(-1);
}
```
Она, правда, не поможет, если в иконке содержатся буквы или цифры. Тогда придётся сделать две разные иконки и вставлять их условно:
А ещё, оказывается, не все элементы интерфейса нужно зеркалить. Например, в нашем случае мы решили оставить чекбоксы обычными:
Как из всего интерфейса выбрать такие элементы — не знаю. Тут может помочь только носитель языка, который скажет, что ему привычно, а что нет.
### Пользовательский ввод
Даже если мы полностью контролируем все данные своего приложения, это может быть пользовательский ввод. Например, название файла. Можно даже исхитриться и выдать .js файл за .png, — такая уязвимость [была в Телеграме](https://www.kaspersky.ru/blog/telegram-rlo-vulnerability/19644/):
> прикольная\_картинка**\*U+202E\***gnp.js → прикольная\_картинкаsj.png
В таких случаях стоит отфильтровать неуместные utf-символы из строки.
Переворачиваем скрипты
----------------------
В RTL-джаваскрипте синтаксис немного меняется. Цикл, который выглядел так:
```
for (let i = 0; i < arr.length; i++) {
```
Теперь нужно писать так:
```
for (++i; length.arr > i; let 0 = i) {
```
Шутка.
Всё, что нужно делать — избегать понятий «left» и «right» в коде. Например, мы столкнулись с проблемами в подсчёте координат центра экрана — раньше все карточки висели слева, а теперь справа, но код приложения об этом не знал. Все расчёты и инлайн-стили нужно проводить, учитывая базовую направленность.
### Смекалочка
В некоторых ситуациях сложно внедрить поддержку RTL в какой-то компонент системы. Тогда нужно попробовать адаптировать этот компонент под RTL снаружи, но оставить LTR внутри.
Например, у нас есть слайдер. Он поддерживает только положительные упорядоченные значения. Он может быть линейным и логарифмическим (в начале плотность значений меньше, чем в конце). Нужно отразить его с сохранением поведения шкалы.
Можно отразить слайдер с помощью `transform: scaleX(-1)`. Тогда придётся инвертировать работу с мышью (клики и драги) относительно центра слайдера. Плохой вариант.
Есть другой вариант — развернуть ось в другую сторону, изменив только передачу и получение значений из слайдера. Если это линейная шкала, вместо набора значений [10, 100, 1000] передадим набор [N-1000, N-100, N-10], а в хендлере преобразуем обратно. Для логарифмической шкалы вместо набора [10, 100, 1000] передадим [1/1000, 1/100, 1/10]:
```
function flipSliderValues(values, scale, isRtl) {
if (!isRtl) {
return values;
}
if (scale === 'log') {
// [A, B] --> [1/B, 1/A]
return values.map(x => 1 / x).reverse();
}
// [A, B] --> [MAX-B, MAX-A]
return values.map(x => Number.MAX_SAFE_INTEGER - x).reverse();
};
```
Вот так слайдер стал поддерживать RTL, хотя он сам об этом не знает.
Storybook
---------
В отличие от проверки вёрстки под каким-нибудь IE9, для проверки вёрстки под RTL не нужно запускать отдельный браузер. Можно даже верстать и видеть вёрстку LTR и RTL одновременно в одном окне. Для этого можно, например, сделать декоратор в [сторибуке](https://storybook.js.org/), который рендерит сразу две версии истории:
На скриншоте видно, что без изоляции `text-overflow: ellipsis` ведёт себя не так, как хотелось бы — лучше сразу пофиксить.
Намного проще поддерживать RTL сразу при вёрстке, чем потом тестировать абсолютно весь проект.
Нерешаемые проблемы
-------------------
Знание теории не помогает решить абсолютно все задачи. Приведу один пример.
Подсказчик, появляющийся по направлению текста при вводе. Когда мы говорим о мультиязычном вводе, мы не можем заранее знать, с какой стороны выводить эту подсказку:
Нужно стараться избегать таких проблем на этапе дизайна и иногда отказываться от очевидных для LTR решений, никак не применимых в RTL. В данном кейсе можно при навигации по подсказкам подставлять весь текст целиком (как, например, делает Яндекс или Google).
Выводы
------
### RTL — это не просто «перевернуть всё»
Нужно учитывать особенности языка, что-то переворачивать не нужно, что-то нужно адаптировать иначе. Где-то в логике совсем нужно отказаться от «право»/«лево».
### Очень сложно что-то сделать без знания языка
Ты будешь думать, что всё готово, пока не покажешь свой проект настоящему носителю языка. Разрабатывай с точки зрения человека, не знающего *никакого* языка. Ведь даже такие очевидные для тебя слова, как, например, «Twitter», возможно, придётся переводить. И знаки препинания, оказывается, не на всей планете одинаковые.
### Итоговый рецепт
Сложно описать в одном списке всё, о чём шла речь в двух статьях. Пошагового руководства не будет, но вот главное, что нужно сделать:
* обязательно найди носителя языка и покажи ему прототипы как можно раньше;
* собирай стили для LTR и RTL в разные файлы. Для этого подходят rtlcss и webpack-rtl-plugin;
* добавь исключения для всего, что переворачивать не нужно и явно отрази то, что не перевернулось само;
* изолируй весь контент произвольной направленности с помощью и `dir="auto"`;
* явно задай `text-align` на всю страницу;
* избегай `left`/`right` в js-коде, когда имеешь в виду начало и конец.
Готовься к тому, что больше всего времени придётся потратить на самые мелкие детали.
### Быть заранее готовым — не сложно
И немного советов для тех, кто пока что не собирается адаптировать сайт под RTL, но хочет подстелить соломку:
* не используй свойство `direction` не по назначению;
* на всякий случай всё-таки изолируй весь произвольный контент (да и ведь даже в английском интерфейсе юзеры могут что-нибудь написать на арабском и всё сломать);
* если есть возможность, используй [логические css-свойства](https://www.w3.org/TR/css-logical-1/);
* проверяй вёрстку не только в разных браузерах, но и иногда в RTL, хотя бы ради любопытства. А лучше ненавязчиво контролируй вёрстку под RTL при помощи инструментов вроде [storybook](https://storybook.js.org/);
* не допускай хардкода языковых конструкций (например, конкатенация строк через запятую), по возможности конфигурируй всё, включая знаки препинания. Это пригодится не только для RTL — к примеру, на греческом языке вопросительный знак — «;».
Эти правила не должны доставить хлопот. Но если внезапно придёт желание запустить RTL-версию, это достанется намного дешевле, чем могло бы. | https://habr.com/ru/post/416635/ | null | ru | null |
# Вышел релиз GitLab 13.0 с кластерами Gitaly, иерархией эпиков на дорожных картах и автоматическим развертыванием для ECS
Что изменилось со времени 12.0
------------------------------
Прежде чем приступить к описанию нового мажорного релиза 13.0, мы хотели бы уделить внимание пройденному пути. Мы столького достигли с момента выхода версии 12.0! Недавно в блоге вышел специальный [пост](https://about.gitlab.com/blog/2020/05/21/version-12-year-in-review/), в котором мы сделали обзор релизов GitLab с 12.0 по 12.10. Три наших фаворита из этой серии релизов это [управление требованиями](https://habr.com/ru/post/500734/#sozdavayte-i-prosmatrivayte-trebovaniya-v-gitlab), [сетевая безопасность контейнеров](https://about.gitlab.com/direction/defend/container_network_security/) и [конвейеры (в русской локализации GitLab «сборочные линии») родитель-ребенок](https://habr.com/ru/post/487266/#konveyery-roditel-rebenok).
В дополнение к улучшениям самого продукта мы также обновили наши [партнерские программы и интеграции](https://about.gitlab.com/press/releases/2020-04-21-gitLab-ramps-up-channel-and-partner-investment-with-launch-of-a-new-global-partner-program.html), добавили [рекомендации по интеграции](https://docs.gitlab.com/ee/development/integrations/secure.html) для использования сторонних сканеров безопасности, а также расширили наши [пакеты услуг техподдержки](https://about.gitlab.com/services/catalog/), чтобы помочь вам с такими вещами, как миграции Jira и Jenkins. На нашем новом видеоканале [Learn@GitLab](https://www.youtube.com/playlist?list=PLFGfElNsQthYDx0A_FaNNfUm9NHsK6zED) вы найдете множество видеоуроков. Например, [Начало работы с CI](https://www.youtube.com/watch?v=e0iQD1qgxZg&list=PLFGfElNsQthYDx0A_FaNNfUm9NHsK6zED&index=10&t=0s).
Итерации — ключ к устойчивости
------------------------------
GitLab помогает ИТ- и бизнес-командам развиваться, вовремя реагировать и адаптироваться, и ключ ко всему этому — [итерации](https://about.gitlab.com/blog/2020/02/04/power-of-iteration/). Пользователям необходимо быстро взаимодействовать, оптимизировать работу и автоматизировать процессы для обеспечения безопасности и соответствия требованиям, не забывая при этом о качестве продукта. GitLab 13.0 поможет вам итерировать быстро и с более глубоким пониманием процесса. Доступ к Git-репозиториям также является критически важным, и мы усовершенствовали наш [кластер Gitaly для высокодоступных (HA) хранилищ Git](#klaster-gitaly-dlya-vysokodostupnyh-hranilisch-git), чтобы в случае сбоя всегда имелось несколько свежих и готовых к работе реплик.
### Оперативное реагирование и сотрудничество всей команды
GitLab расширяет возможности, которые способствуют [совместной разработке](https://www.youtube.com/watch?v=OFNUjvgm2_4), созданию отчетов, организации и управлению работой. В основе совместной работы лежит контроль версий, и в релизе 13.0 мы добавляем [контроль версий для сниппетов](#kontrol-versiy-dlya-snippetov). Для управления более сложными проектами в 13.0 появилась возможность просматривать [иерархию эпиков (в русской локализации GitLab «цели») на вашей дорожной карте](#prosmotr-ierarhii-epikov-na-dorozhnoy-karte) (в русской локализации GitLab «план развития»), [как соотносятся ваши эпики и майлстоуны](#prosmotr-maylstounov-na-dorozhnoy-karte) (в русской локализации GitLab «этапы») и [добавлять один или несколько майлстоунов к своим релизам](#obnovlenie-maylstounov-reliza-cherez-polzovatelskiy-interfeys-gitlab). [Оповещения о закрытии тикета с открытыми блокирующими тикетами](#preduprezhdenie-pri-zakrytii-tiketa-s-nerazreshennymi-zavisimostyami) помогут вам обратить внимание на ключевые моменты пути.
Дизайнеры — важная часть команды разработчиков. Работая над одной из самых популярных новых фич, [темной темой для Web IDE](#temnaya-tema-v-web-ide), мы [поняли, как привлечь дизайнеров к более тесному сотрудничеству](https://about.gitlab.com/blog/2020/05/20/creating-a-dark-ui-for-gitlabs-web-ide/index.html). Также мы переместили [управление дизайном в план Core](#upravlenie-dizaynami-teper-v-core), тем самым отмечая пользователей, которые занимаются дизайном продуктов, как отдельных участников.
### Оптимизация для повышения эффективности
Поскольку многие компании стремятся быть более оперативными и более эффективными, GitLab старается упростить существующие процессы разработки программного обеспечения. Новые фичи, направленные на повышение эффективности, включают в себя [упрощенное развертывание на Amazon ECS](#avtomaticheskoe-razvertyvanie-v-ecs) и новый объединенный [список оповещений](#agregirovanie-opovescheniy-iz-vneshnih-instrumentov-v-gitlab), который объединяет IT-оповещения, поступающие из нескольких источников, в едином интерфейсе. Кроме того, у нас есть хорошая новость и для пользователей Terraform. В GitLab 13.0 появился [краткий обзор результата terraform plan в мерж-реквестах](#kratkiy-obzor-rezultata-terraform-plan-v-merzh-rekvestah) (в русской локализации GitLab «запросы на слияние») и [использование GitLab в качестве бэкенда для state файла](#ispolzovanie-gitlab-v-kachestve-bekenda-dlya-state-fayla-terraform).
### Доверяйте вашим процессам и не жертвуйте безопасностью и соответствием требованиям
GitLab помогает компаниям комплексно внедрять средства контроля безопасности и соответствия требованиям в жизненный цикл разработки ПО, снижая риски и высвобождая ресурсы для критически важных потребностей бизнеса. Наши возможности тестирования безопасности приложений помогают вам [быстрее находить и исправлять уязвимости безопасности](https://www.youtube.com/watch?v=UgCHtr-6uG8&list=PLFGfElNsQthYDx0A_FaNNfUm9NHsK6zED&index=2&t=0s), благодаря чему GitLab недавно был назван [нишевым игроком](https://about.gitlab.com/resources/report-gartner-mq-ast/) в Gartner Magic Quadrant for Application Security Testing 2020 года.
С момента оценки Gartner релиза 12.4 мы добавили много новых фич. А в 13.0 мы добавили возможность [сканирования REST API через DAST](#podderzhka-rest-api-v-skanirovaniyah-dast) и [полное сканирование истории коммитов на наличие секретных ключей](#poisk-sekretnyh-klyuchey-v-polnoy-istorii-repozitoriya). Более того, мы поменяли наш способ работы с [объектами уязвимостей](#otdelnye-obekty-uyazvimostey). Благодаря этому появилась возможность [экспортировать уязвимости из панели безопасности](#eksport-spiska-uyazvimostey-iz-paneley-bezopasnosti-instansa-i-proekta) и в будущем будут доступны более широкие возможности [управления уязвимостями](https://about.gitlab.com/direction/defend/vulnerability_management/).
В дополнение к сканированию безопасности в релизе 13.0 GitLab автоматизирует правила и обеспечивает более детальный контроль с помощью [заморозки развертывания с помощью API Freeze Periods](#zamorozka-razvertyvaniya-cherez-api-freeze-period). Это поможет легко предотвратить непреднамеренные релизы в продакшн на указанный промежуток времени. Для упрощения аудитов в 13.0 появилась [фильтрация в поиске событий аудита на уровне инстанса](#filtr-dlya-poiska-po-sobytiyam-audita-v-instanse), это часть нашего [эпика по событиям аудита](https://gitlab.com/groups/gitlab-org/-/epics/3179).
А что впереди?
--------------
Мы с энтузиазмом готовим [предстоящие релизы](https://about.gitlab.com/upcoming-releases/), в частности, фичи, которые помогут вам:
* Обеспечить [соответствие требованиям](https://about.gitlab.com/direction/dev/#enterprise-compliance) и автоматически применять соответствующие меры контроля и отчетности.
* Получать больше инсайтов благодаря выпуску версий с [A/B-тестированием](https://gitlab.com/groups/gitlab-org/-/epics/2966) и контролировать их с помощью нескольких улучшений для переключаемых фич — [фильтрация фич по статусу](https://gitlab.com/gitlab-org/gitlab/-/issues/35558), [A/B-тестирование на основе переключаемых фич](https://gitlab.com/gitlab-org/gitlab/-/issues/34813) и [возможность создавать переключаемые фичи из мерж-реквеста](https://gitlab.com/gitlab-org/gitlab/-/issues/33394)).
* Определять узкие места и потери благодаря отображению [стадий в аналитике цикла разработки в виде потока](https://gitlab.com/gitlab-org/gitlab/-/issues/210315).
* [Управлять правилами](https://gitlab.com/gitlab-org/gitlab/-/issues/214729) и оставлять GitLab автоматизацию их использования, включая [готовый набор сетевых правил безопасности контейнера](https://gitlab.com/gitlab-org/gitlab/-/issues/216074).
* Тестировать API приложений [фаззингом](https://gitlab.com/gitlab-org/gitlab/-/issues/33906), а также [считывать переменные CI из хранилища HashiCorp](https://gitlab.com/gitlab-org/gitlab/-/issues/28321).
Хотите увидеть полный список того, что выйдет в следующем месяце? Наша [дорожная карта](https://about.gitlab.com/upcoming-releases/) открыта и всегда доступна для всех желающих внести свой вклад.
Теперь, без лишних слов, приступим к описанию всех классных фич релиза 13.0!
[Приглашаем на наши встречи](https://about.gitlab.com/events/).
[MVP](https://about.gitlab.com/community/mvp/) этого месяца — [Sashi](https://gitlab.com/ksashikumar)
-----------------------------------------------------------------------------------------------------
Sashi [добавил огромное количество улучшений в релиз 13.0](https://gitlab.com/dashboard/merge_requests?scope=all&utf8=%E2%9C%93&state=merged&author_username=ksashikumar&milestone_title=13.0) в различных разделах GitLab. Его работа помогла улучшить [контроль версий сниппетов](#kontrol-versiy-dlya-snippetov), удалить ошибки, связанные с тегом Releases, и минимизировать дублирование событий, посылаемых веб-хуками. Также он улучшил [структуру и читаемость кода](https://gitlab.com/gitlab-org/gitlab/-/merge_requests/31346/), обеспечив каждому формату пакета уникальную модель для хранения метаданных.
Спасибо [Sashi](https://gitlab.com/ksashikumar) за всю эту работу!
Ключевые фичи релиза GitLab 13.0
--------------------------------
### Кластер Gitaly для высокодоступных хранилищ Git
(PREMIUM, ULTIMATE) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
GitLab теперь поддерживает высокодоступные системы хранения Git без использования NFS. Конфигурации высокой доступности (high availability, HA) повышают доступность важных систем, таких как хранилища Git, за счет устранения единичных точек отказа, обнаружения сбоев и автоматического переключения на реплику. Это означает, что отдельный компонент системы может выйти из строя, не вызвав сбоя у конечного пользователя. Доступ к репозиториям Git очень важен для разработчиков и компаний, поскольку при его выходе из строя разработчики не смогут отправлять код и развертывание будет заблокировано.
Внутри Git-репозитория хранилище обрабатывается [Gitaly](https://about.gitlab.com/blog/2018/09/12/the-road-to-gitaly-1-0/), а теперь еще и Praefect. Praefect — это новый маршрутизатор и менеджер транзакций, который мы создали специально для Gitaly, чтобы координировать выбор лидера и асинхронную репликацию. При использовании кластера Gitaly запросы на данные Git направляются через одну из нескольких нод Praefect на ноду Gitaly. Таким образом всегда есть несколько реплик, готовых принять управление на себя в случае сбоя в работе.
В будущем мы планируем добавить поддержку [сильной согласованности](https://gitlab.com/groups/gitlab-org/-/epics/1189), чтобы операции записи успешно выполнились на нескольких нодах Gitaly, прежде чем отправится ответ об успешности записи, и поддержку [горизонтального распределения чтения](https://gitlab.com/groups/gitlab-org/-/epics/2013), чтобы ресурсы процессора и памяти могли быть лучше масштабированы.
[Документация по Praefect](https://docs.gitlab.com/ee/administration/gitaly/praefect.html) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/842).
### Автоматическое развертывание в ECS
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Release](https://about.gitlab.com/stages-devops-lifecycle/release/)
До сих пор у нас не было простого способа развертывания в Amazon Web Services. Из-за этого пользователям GitLab приходилось тратить много времени на настройку собственной конфигурации.
В GitLab 13.0 поддержка развертывания в AWS уже ждет вас в Auto DevOps! Пользователи GitLab, которые развертывают в Elastic Container Service (ECS) от AWS, теперь могут воспользоваться возможностями Auto DevOps, даже если они не используют Kubernetes. Auto DevOps упрощает и ускоряет поставку и облачное развертывание с помощью полного конвейера поставки сразу из коробки. Благодаря устранению лишних сложностей вы сможете сконцентрироваться на аспектах создания программного обеспечения. Просто отправьте коммит, а GitLab сделает все остальное!
Чтобы подключить эту фичу, необходимо определить переменные окружения для AWS: ‘AWS\_ACCESS\_KEY\_ID’, ‘AWS\_ACCOUNT\_ID’ и ‘AWS\_REGION’, а также включить Auto DevOps. Затем ваше развертывание ECS будет автоматически собрано для вас с полным автоматическим конвейером поставки.
[Документация по развертыванию в ECS](https://docs.gitlab.com/ee/topics/autodevops/index.html#aws-ecs) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/208132).
### Просмотр иерархии эпиков на дорожной карте
(ULTIMATE, GOLD) [Стадия цикла DevOps: Plan](https://about.gitlab.com/stages-devops-lifecycle/plan/)
При работе с многоуровневыми эпиками бывает сложно отследить, где находится каждый дочерний эпик на дорожной карте. Теперь вы сможете развернуть родительский эпик на вашей дорожной карте, чтобы просмотреть все его вложенные эпики и обеспечить правильную организацию работы и соблюдение запланированного графика.
[Документация по дорожным картам](https://docs.gitlab.com/ee/user/group/roadmap/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/7077).
### Контроль версий для сниппетов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Сниппеты полезны для обмена небольшими фрагментами кода и текста, которые могут не входить в основную кодовую базу проекта. Эти фрагменты важны для групп и пользователей, которые используют их для таких задач, как скрипты, генерирующие результаты диагностики, или настройка поддерживающих сервисов для тестовых и демонстрационных окружений. К сожалению, из-за отсутствия контроля версий было трудно выяснить, был ли этот сниппет последней версии, какие изменения могли произойти и как их свести воедино.
Теперь сниппеты в GitLab также находятся под контролем версий в Git-репозитории. При редактировании сниппета каждое изменение создает коммит. Сниппеты также можно клонировать для локального редактирования, а затем отправлять в репозиторий Snippet.
Это — первый шаг на пути к удобной совместной работе над сниппетами. В будущих релизах мы введем поддержку для [нескольких файлов](https://gitlab.com/groups/gitlab-org/-/epics/2829), продолжим расширять [возможности](https://gitlab.com/groups/gitlab-org/-/epics/2830) и [разрешения](https://gitlab.com/groups/gitlab-org/-/epics/2521) для сниппетов.
[Документация по контролю версий в сниппетах](https://docs.gitlab.com/ee/user/snippets.html#versioned-snippets) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/14228).
### Темная тема в Web IDE
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Для людей, которые проводят много времени за работой в редакторах кода, очень важна возможность настраивать среду разработки в соответствии с их предпочтениями. Темные темы являются одними из наиболее [популярных](https://marketplace.visualstudio.com/search?target=VSCode&category=Themes&sortBy=Installs) для редакторов и играют важную роль в обеспечении комфортной работы. Также очевидно, что пользователи GitLab любят темные темы, поскольку тема Dark Application для всего интерфейса GitLab является вторым по популярности запросом в [нашем трекере задач](https://gitlab.com/gitlab-org/gitlab/-/issues?sort=popularity).
Web IDE теперь полностью темная для всех пользователей, выбравших **Dark** в [настройках темы подсветки синтаксиса](https://docs.gitlab.com/ee/user/profile/preferences.html#syntax-highlighting-theme). Это важный шаг в обеспечении удобства редактирования и в понимании того, как пользовательский интерфейс GitLab взаимодействует с темными темами. Вы можете узнать больше о разработке этого дизайна [в соответствующем посте](https://about.gitlab.com/blog/2020/05/20/creating-a-dark-ui-for-gitlabs-web-ide/index.html).
[Документация о темах в Web IDE](https://docs.gitlab.com/ee/user/project/web_ide/#themes) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/209808).
### Отдельные объекты уязвимостей
(ULTIMATE, GOLD) [Стадия цикла DevOps: Defend](https://about.gitlab.com/stages-devops-lifecycle/defend/)
Мы представляем первую фичу для управления уязвимостями: отдельные объекты уязвимостей. В 13.0 мы создали новую модель объектов уязвимостей, что позволило нам получить совершенно новый набор возможностей, охватывающих весь жизненный цикл управления уязвимостями.
Одно из самых больших преимуществ заключается в том, что теперь каждая уязвимость будет иметь уникальный URL. Это означает, что на уязвимость можно ссылаться напрямую, делиться ей и отслеживать ее как единый источник информации. На этой странице вы можете изменить статус уязвимости на «Обнаружена» ("Detected"), «Подтверждена» ("Confirmed"), «Проигнорирована» ("Dismissed") или «Решена» ("Resolved"). Еще одним преимуществом является то, что обнаруженные уязвимости будут сохраняться при следующем запуске сканера. Ранее запуск сканирования на той же ветке перезаписывал все предыдущие результаты новыми. Сохранение прошлых объектов уязвимостей улучшит качество отслеживания, наглядность и сократит дублирование результатов между прогонами сканера. Кроме того, это даст в будущем возможность создавать отчеты о тенденциях уязвимостей в группах и проектах с течением времени по широкому ряду параметров.
[Документация по уязвимостям](https://docs.gitlab.com/ee/user/application_security/vulnerabilities/index.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/13561).
### Поддержка REST API в сканированиях DAST
(ULTIMATE, GOLD) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
В GitLab 13.0 мы добавили DAST сканирования REST API. Это позволит обеспечить полное DAST-покрытие безопасности всего приложения, а не только пользовательского интерфейса. DAST поддерживает использование спецификации OpenAPI в качестве руководства по сканированию URL-адресов и конечных точек REST, что позволит обеспечить безопасность всех направлений атак и даст больше информации о потенциальных уязвимостях любого работающего приложения.
[Документация по DAST-сканированию API](https://docs.gitlab.com/ee/user/application_security/dast/#api-scan) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/10928).
### SAST для .NET Framework
(ULTIMATE, GOLD) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Мы представляем начальную поддержку .Net Framework, которая позволит разработчикам запускать [сканирования безопасности SAST](https://docs.gitlab.com/ee/user/application_security/sast/#overview) в дополнительных типах .NET проектов. Как и в других наших заданиях SAST, в них будут использоваться обработчики заданий GitLab (runner) для Linux. В будущем мы планируем добавить поддержку обработчиков заданий Windows. С момента появления в GitLab 11.0, [SAST для .NET](https://gitlab.com/gitlab-org/gitlab/issues/4824) включал в себя поддержку только для проектов .NET Core.
| [Поддерживаемый язык](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks) | Инструмент сканирования | Представлен в версии GitLab |
| --- | --- | --- |
| .NET Core | [Сканирование безопасности кода](https://security-code-scan.github.io) | 11.0 |
| .Net Framework | [Сканирование безопасности кода](https://security-code-scan.github.io) | 13.0 |
[Документация по поддерживаемым SAST языкам](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/6289).
### Краткий обзор результата terraform plan в мерж-реквестах
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Configure](https://about.gitlab.com/stages-devops-lifecycle/configure/)
Если вы используете Terraform для определения вашей инфраструктуры в виде кода, вы знаете, как удручает необходимость постоянно передавать коллегам итоговые изменения из команды `terraform plan` в slack и комментариях в мерж-реквестах. В GitLab 13.0 теперь вы будете видеть краткий обзор вывода команды `terraform plan` в том контексте, где это наиболее полезно — непосредственно в вашем мерж-реквесте. Это поможет вам быстрее проверять изменения в вашей инфраструктуре и предоставит удобное место для взаимодействия с членами вашей команды по предполагаемому влиянию на вашу инфраструктуру по мере изменения кода.
Пользователи шаблона [Terraform, предлагаемого GitLab](https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/templates/Terraform.gitlab-ci.yml), увидят виджет мерж-реквеста `terraform plan` без какой-либо дополнительной настройки. Пользователи персонализированных шаблонов CI/CD могут обновить свой шаблон, чтобы использовать образ и скрипты [официального шаблона Terraform от GitLab](https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/templates/Terraform.gitlab-ci.yml).
[Документация по работе с инфраструктурой с помощью Terraform](https://docs.gitlab.com/ee/user/infrastructure/) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2676).
### Использование GitLab в качестве бэкенда для state файла Terraform
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Configure](https://about.gitlab.com/stages-devops-lifecycle/configure/)
Пользователи Terraform прекрасно знакомы с трудностями настройки state файла (карта связей вашей конфигурации с реальными ресурсами, в которой также отслеживаются дополнительные метаданные). Этот процесс включает в себя создание нового проекта Terraform и настройку стороннего бэкенда для хранения надежного, безопасного и не зависящего от вашего git-репозитория файла состояния.
Многие пользователи искали более простой способ настройки файлового хранилища без использования дополнительных сервисов или настроек. Начиная с GitLab 13.0 как HTTP-бэкенд для Terraform можно использовать сам GitLab, что устраняет необходимость настраивать отдельное хранилище для state файлов для каждого нового проекта.
Бэкенд состояний Terraform от GitLab обеспечивает простоту настройки и возможность хранить ваши state файлы в месте, контролируемом инстансом GitLab. Доступ к ним можно получить с помощью специального [HTTP-бэкенда](https://www.terraform.io/docs/backends/types/http.html), используя GitLab для аутентификации. Пользователи смогут легко мигрировать на HTTP-бэкенд Terraform от GitLab, а также получить к нему доступ со своих локальных терминалов.
HTTP-бэкенд для состояний Terraform от GitLab поддерживает:
* Многочисленные именованные файлы состояния в одном проекте
* Блокировку
* Хранилище объектов
* Шифрование в состоянии покоя
Все это теперь доступно и для пользовательских инстансов GitLab, и на GitLab.com.
[Документация по работе с инфраструктурой с помощью Terraform](https://docs.gitlab.com/ee/user/infrastructure/) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2673).
### Исключайте большие файлы с помощью частичного клонирования
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Хранение больших бинарных файлов в Git обычно не приветствуется, поскольку все добавленные файлы будут загружены каждым, кто впоследствии клонирует или проверяет обновления (`git fetch`) репозитория. Это сильно замедляет, если вовсе не останавливает, работу при медленном или ненадежном соединении.
В GitLab 13.0 частичное клонирование было включено для фильтров по размеру блоба, а также экспериментально для других фильтров. Это позволяет исключить проблемные большие файлы из клонирований и скачиваний обновлений. Когда Git обнаруживает недостающий файл, он будет загружен по требованию. При клонировании проекта используйте `--filter=blob:none` для полного исключения блобов или `--filer=blob:limit=1m` для исключения по размеру файла. Обратите внимание, что для частичного клонирования требуется версия Git не ниже 2.22.0.
Узнайте все подробности в нашем недавнем посте [Как частичное клонирование в Git позволяет вам получать только необходимые большие файлы](https://about.gitlab.com/blog/2020/03/13/partial-clone-for-massive-repositories/).
[Документация по частичному клонированию](https://docs.gitlab.com/ee/topics/git/partial_clone.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitaly/-/issues/2553).
### Управление панелями метрик через переменные
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Monitor](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
В GitLab 13.0 вы можете создавать панели метрик, управляемые через переменные. Это позволит вам использовать одну панель метрик для мониторинга нескольких различных сервисов и компонентов, вместо того, чтобы каждый раз создавать панели метрик со вшитыми параметрами для каждого сервиса, который вы хотите мониторить. Вместо того, чтобы много раз подолгу создавать похожие панели метрик, теперь вы можете создать одну панель метрик и использовать переменные, чтобы настраивать, какие данные будут на ней выводиться.
[Документация по шаблонам переменных для панелей метрик](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#templating-variables-for-metrics-dashboards) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2538).
### Сниженное потребление памяти GitLab с Puma
(CORE, STARTER, PREMIUM, ULTIMATE) [Доступность](https://about.gitlab.com/handbook/engineering/development/enablement/)
Puma теперь по умолчанию является сервером веб-приложений для установок на основе Omnibus и Helm. Puma снижает объем памяти, потребляемой GitLab, примерно на 40% по сравнению с Unicorn, что повышает эффективность работы GitLab и позволяет потенциально сэкономить на стоимости инстансов с самостоятельным управлением.
Установкам, которые настроили количество процессов Unicorn, или используют более медленные диски с NFS, возможно придется изменить конфигурацию Puma по умолчанию. Посмотрите [важные заметки по обновлениям](https://about.gitlab.com/releases/2020/05/22/gitlab-13-0-released/#upgrade) и [улучшения в GitLab chart](https://about.gitlab.com/releases/2020/05/22/gitlab-13-0-released/#gitlab-helm-chart-improvements), чтобы узнать больше.
[Документация по Puma](https://docs.gitlab.com/ee/administration/operations/puma.html) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/954).
Другие улучшения в GitLab 13.0
------------------------------
### Фильтр для поиска по событиям аудита в инстансе
(STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Если вам нужно найти определенное событие для отчета по аудиту или для расследования инцидента, это должно быть просто. Вы не должны тратить кучу времени на то, чтобы вручную копаться в большом наборе данных.
Теперь вы можете искать одиночный объект (например, пользователя, группу или проект) с помощью фильтров в таблице событий аудита инстанса, что значительно упрощает этот процесс. Эта фича доступна только для пользователей в инстансах с самостоятельным управлением, однако она будет расширена до групп и проектов как часть [большого эпика по событиям аудита](https://gitlab.com/groups/gitlab-org/-/epics/3179). Это позволит привести события аудита инстанса, группы и проекта к единому стандарту и сделает их более удобными для использования.
[Документация по событиям аудита](https://docs.gitlab.com/ee/administration/audit_events.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/216127).
### Включение защиты веток по умолчанию на уровне группы
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Раньше при переносе настроек [защиты ветки по умолчанию](https://gitlab.com/gitlab-org/gitlab/issues/7583) с уровня инстанса на уровень проектов можно было легко запутаться, потому что в некоторых сценариях этот процесс был неинтуитивным: разработчики не могли добавлять новые коммиты в проекты, которые они же и создали. Из-за этого организациям было сложно найти баланс между снижением рисков и предоставлением свободного доступа к проектам для всех разработчиков, так как решение проблемы требовало повышения их до maintainer (в русской локализации GitLab «сопровождающий»).
Теперь защиту веток по умолчанию можно настроить на уровне группы, чтобы предоставить большую гибкость для администраторов и владельцев групп. Используя комбинацию защиты веток по умолчанию и настроек создания проекта по умолчанию, организации смогут [найти нужный баланс](https://gitlab.com/gitlab-org/gitlab/-/issues/7583#note_288469003) между автономией и контролем. Например, использовать свои настройки для защиты веток по умолчанию и разрешать создавать новые проекты только пользователям с ролями maintainer. Это позволит разработчикам добавлять новые коммиты (без принудительного пуша или удаления веток) к новым проектам, при этом оставляя создание проектов maintainers.
Настройку владельцем группы защиты веток по умолчанию [может отключить администратор](https://docs.gitlab.com/ee/user/admin_area/settings/visibility_and_access_controls.html#disable-group-owners-from-updating-default-branch-protection-premium-only), если в вашей организации требуется больше контроля. После ее отключения maintainers смогут более строго управлять доступом и разрешениями для разработчиков.
[Документация по настройке защиты веток по умолчанию на уровне группы](https://docs.gitlab.com/ee/user/group/index.html#changing-the-default-branch-protection-of-a-group) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/7583).
### Аналитика цикла разработки: график задач по типу
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Новый мощный график позволит командам наблюдать, как время поставки распределяется по разным типам работ. Используйте метки, чтобы посмотреть, сколько времени тратится на фичи по сравнению с багами из релиза в релиз, или сколько элементов поставляет одна команда по сравнению с другой. Анализируя циклы работы, команды смогут регулировать свои процессы, чтобы они лучше согласовывались со стратегическими целями или для более сбалансированного распределения ресурсов между командами.
[Документация по графику задач по типу работы](https://docs.gitlab.com/ee/user/analytics/value_stream_analytics.html#type-of-work---tasks-by-type-chart) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/32421).
### Email-уведомления при авторизации из неизвестного источника
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Пользователи теперь будут получать email-уведомление, когда их данные для входа используются с нового устройства или IP-адреса. Это позволит пользователям быстро обнаруживать потенциальную активность злоумышленников, связанную с их учетными записями.
[Документация по уведомлениям при авторизации из неизвестных источников](https://docs.gitlab.com/ee/user/profile/unknown_sign_in_notification.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/27211).
### Предупреждение при закрытии тикета с неразрешенными зависимостями
(STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Plan](https://about.gitlab.com/stages-devops-lifecycle/plan/)
В GitLab 12.8 мы [добавили](https://habr.com/ru/post/491780/#blokirovka-tiketov) возможность создавать зависимости между тикетами, так что один тикет может блокировать другой. Это означает, что зависимый тикет не может быть закрыт, пока не будет завершен и закрыт главный. Из-за этого вам приходилось перед закрытием тикета проверять, не является ли он заблокированным другими.
Проверка тикета на блокировщики перед его закрытием – это лишний шаг, про который легко забыть. Мы избавили вас от необходимости делать этот шаг, добавив предупреждение, которое будет появляться при попытке закрыть тикет с неразрешенными зависимостями, а также ссылки на неразрешенные блокирующие тикеты, чтобы вы могли проверить, безопасно ли закрывать этот тикет.
Эти уведомления о зависимостях позволят вашим проектам работать без заминок, а также обеспечат правильную последовательность тикетов.
[Документация по зависимостям между тикетам](https://docs.gitlab.com/ee/user/project/issues/related_issues.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/34239).
### Более удобное добавление эпиков и тикетов через дерево эпиков
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: Plan](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Создание и добавление тикетов и эпиков через дерево эпиков ранее было разделено по нескольким кнопкам и выпадающим меню, и поэтому его было неудобно использовать. Мы объединили действия “add” (добавить) и “create” (создать) в отдельную кнопку с меню, чтобы добавлять новые тикеты и эпики было проще и быстрее!
[Документация по добавлению тикетов в эпик](https://docs.gitlab.com/ee/user/group/epics/manage_epics.html#add-an-issue-to-an-epic) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/214419).
### Эмодзи в обсуждении дизайнов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
В версии 13.0 обсуждения дизайнов стали на шаг ближе к комментариям в GitLab. Мы добавили поддержку эмодзи, чтобы вы могли давать обратную связь более веселым и креативным способом!
[Документация по обсуждениям дизайнов](https://docs.gitlab.com/ee/user/project/issues/design_management.html#starting-discussions-on-designs) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/208973).
### Новый режим сравнения для мерж-реквестов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Мерж-реквесты, особенно вкладка **Изменения** (**Changes**), — это место, где происходит обсуждение и ревью исходного кода. В случаях, когда целевая ветка была смержена в исходную ветку мерж-реквеста, изменения в исходной и целевой ветках могут оказаться перемешанными, из-за чего становится сложно понять, какие изменения добавляются, а какие уже существуют в целевой ветке.
В GitLab 13.0 мы добавляем экспериментальный режим сравнения. Он будет показывать дифф, рассчитанный путем симуляции мержа, что даст более точное представление изменений, чем использование мержей обеих веток. Этот режим доступен в выпадающем меню ветки, выбранной для сравнения через пункт **master (HEAD)**. В будущем этот режим [заменит](https://gitlab.com/gitlab-org/gitlab/issues/198458) текущий способ сравнения по умолчанию.
[Документация по режиму сравнения для мерж-реквестов](https://docs.gitlab.com/ee/user/project/merge_requests/versions#head-comparison-mode-for-merge-requests) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/27008).
### Темы подсветки синтаксиса для Web IDE
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
GitLab поддерживает шесть [тем подсветки синтаксиса](https://docs.gitlab.com/ee/user/profile/preferences.html#syntax-highlighting-theme) при просмотре кода. Темы крайне важны для удобства разработчиков при просмотре и редактировании кода в GitLab. Теперь мы добавили поддержку всех шести тем подсветки синтаксиса в Web IDE, включая [Solarized Dark](https://gitlab.com/gitlab-org/gitlab/-/issues/201927), [Solarized Light](https://gitlab.com/gitlab-org/gitlab/-/issues/201930), [Monokai](https://gitlab.com/gitlab-org/gitlab/-/issues/199883) и [режим «без подсветки»](https://gitlab.com/gitlab-org/gitlab/-/issues/216543).
На протяжении нескольких последних релизов (например, в [12.8](https://habr.com/ru/post/491780/#temnaya-tema-podsvetki-sintaksisa-dlya-web-ide) и [12.9](https://about.gitlab.com/releases/2020/03/22/gitlab-12-9-released/#white-syntax-highlighting-theme-for-web-ide)) мы добавляли и улучшали поддержку тем подсветки в Web IDE. Новые темы подсветки являются продолжением этой работы и помогли заложить основу для нашей [темной темы в Web IDE](#temnaya-tema-v-web-ide), которая также выходит в 13.0. Мы продолжаем улучшать интерфейс для разработчиков и делать нашу Web IDE более комфортной.
[Документация по темам Web IDE](https://docs.gitlab.com/ee/user/project/web_ide/#themes) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2389).
### Подсветка пинов комментариев к дизайну для удобного обсуждения
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Когда над одним дизайном ведется много обсуждений, становится сложно определить, какие обсуждения относятся к какому пину, без поиска номера этого комментария.
В релизе 13.0 мы добавили механизм подсветки пинов релевантных комментариев при клике на исходный комментарий. Мы также добавили обратную фичу, чтобы вы могли кликнуть на пин и перейти к исходному комментарию. Это позволит не тратить время на то, чтобы вручную листать комментарии в поисках нужного, когда под дизайном много комментариев.
[Документация по обсуждениям дизайнов](https://docs.gitlab.com/ee/user/project/issues/design_management.html#starting-discussions-on-designs) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/33161).
### Правила пушей для групп
(STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Правила пушей обеспечивают дополнительный контроль за тем, что можно и нельзя отправлять в ваш репозиторий. Они позволяют вам создавать свои стандарты, которые соответствуют правилам вашей организации.
Ранее правила пушей можно было задавать только на уровне инстанса или проекта, из-за чего админам приходилось управлять большим числом людей и проектов независимо. Настройка правил пушей на уровне групп позволит владельцам групп централизованно управлять безопасностью, и в то же время оставлять независимость отдельным владельцам проектов.
[Документация по правилам пушей для групп](https://docs.gitlab.com/ee/user/group/index.html#group-push-rules-starter) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/34370).
### Кнопки навигации по коммитам в мерж-реквестах
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Удобная навигация по коммитам в больших мерж-реквестах позволяет более эффективно проводить ревью с перемещением между коммитами.
Новые кнопки навигации по коммиту позволяют пользователям удобно перемещаться от текущего коммита к следующему или предыдущему, делая более эффективным процесс ревью мерж-реквестов с большим числом изменений.
[Документация о навигации по коммитам мерж-реквеста](https://docs.gitlab.com/ee/user/project/merge_requests/reviewing_and_managing_merge_requests.html#merge-requests-commit-navigation) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/18140).
### Доступ к отчетам JUnit через API GitLab
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Отчет JUnit может содержать информацию для обновления планов тестирования, истории выполнения тестов и других артефактов, которые команды используют, чтобы следить за качеством своего кода. Обновление этих артефактов может быть долгим и утомительным процессом. Что еще хуже, отчеты были JUnit доступны только путем скачивания через пользовательский интерфейс GitLab. Начиная с версии GitLab 13.0 пользователи API GitLab смогут получать доступ к отчетам JUnit напрямую. Это позволит пользователям парсить данные JUnit для создания новых тикетов или [обновления истории выполнения тестов](https://gitlab.com/gitlab-org/quality/team-tasks/issues/387).
[Документация по отчетам о выполнении тестов на конвейере](https://docs.gitlab.com/ee/api/pipelines.html#get-a-pipelines-test-report) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/202525).
### Фильтр для конвейеров по автору триггера и названию ветки
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Поиск конвейеров, запущенных определенным пользователем или на определенной ветке, стал проще, чем когда-либо. С новым фильтром на странице конвейеров вы сможете фильтровать коммиты по автору коммита и/или по названию ветки. Настройка страницы конвейеров при помощи этих фильтров позволит вам получать актуальную информацию об активности тех конвейеров, которые наиболее важны для вас.
[Документация по странице конвейеров](https://docs.gitlab.com/ee/ci/pipelines/#view-pipelines) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/215367).
### Доступ к реестру пакетов GitLab для чтения или записи через токены развертывания
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
Токены развертывания позволяют вам получать доступ к репозиториям группы, репозиториям проекта и реестрам контейнеров. Команды `read_repository`, `read_registry` и `write_registry` ранее не позволяли вам получать доступ к реестру пакетов GitLab. В результате командам DevOps приходилось использовать небезопасные или дорогостоящие обходные пути.
В GitLab 13.0 мы добавили более точные настройки разрешений токенов развертывания GitLab. Теперь вы можете задавать доступ к реестру пакетов для чтения или записи. Создавать токены развертывания и управлять ими можно из приложения GitLab или через [API](https://docs.gitlab.com/ee/api/deploy_tokens.html).
[Документация по токенам развертывания](https://docs.gitlab.com/ee/user/project/deploy_tokens/#limiting-scopes-of-a-deploy-token) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/213566).
### Все версии пакета под одним именем
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
Реестр пакетов GitLab ранее рассматривал каждую новую версию пакета как *новый* пакет. Из-за этого было сложно искать нужные пакеты или сравнивать изменения между разными версиями пакета.
В GitLab 13.0 каждая версия пакета будет находиться под родительским пакетом с уникальным именем. Это упростит поиск нужного пакета через пользовательский интерфейс и просмотр изменений между версиями. Это обновление применяется для уровней групп и проектов в реестре пакетов. Кроме того, при использовании [API пакетов](https://docs.gitlab.com/ee/api/packages.html) версии пакета будут возвращаться как массив под именем родительского пакета.
[Документация по получению пакета проекта](https://docs.gitlab.com/ee/api/packages.html#get-a-project-package) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/197962).
### Заморозка развертывания через API Freeze Period
(ULTIMATE, GOLD) [Стадия цикла DevOps: Release](https://about.gitlab.com/stages-devops-lifecycle/release/)
С этим релизом GitLab предоставляет больше способов управлять окружениями. Новый API Freeze Period позволит вам легко предотвратить непреднамеренный релиз в продакшн в течение заданного вами периода, например, во время праздника или корпоративного события. Теперь вы можете пользоваться правилами, которые обычно находятся за пределами GitLab, чтобы уменьшить неопределенность и риск при автоматизации развертываний.
[Документация по замораживанию развертываний](https://docs.gitlab.com/ee/user/project/releases/#set-a-deploy-freeze) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/214328/).
### Обновление майлстоунов релиза через пользовательский интерфейс GitLab
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Release](https://about.gitlab.com/stages-devops-lifecycle/release/)
Команда управления разделом Релизов GitLab работает над расширением страницы релиза для использования всей функциональности API релизов. В версии 13.0 стало проще добавлять один или несколько майлстоунов к вашим релизам. С этим обновлением вам больше не придется вручную вызывать API релизов, чтобы пользоваться фичами для планирования, такими как просмотр прогресса по релизу, который был [представлен](https://gitlab.com/gitlab-org/gitlab/-/issues/31289) в версии 12.9.
[Документация по редактированию релиза](https://docs.gitlab.com/ee/user/project/releases/#editing-a-release) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/39467).
### Поиск образов по имени в реестре контейнеров GitLab
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
Когда вы или кто-то в вашей команде публикует образ в реестр контейнеров GitLab, вам нужен способ быстро найти этот образ и убедиться, что он был собран правильно. Раньше, если вы использовали GitLab CI/CD для публикации образов с каждой сборкой, через пользовательский интерфейс было сложно эффективно проводить поиск образов. Вместо этого вам приходилось полагаться на командную строку или [API](https://docs.gitlab.com/ee/api/container_registry.html#list-registry-repository-tags).
В версии 13.0 мы добавили поиск по реестру контейнеров GitLab. Просто перейдите к реестру вашего проекта или группы и введите имя образа, чтобы просмотреть список всех образов, которые у вас есть.
[Документация по управлению реестром контейнеров через GitLab](https://docs.gitlab.com/ee/user/packages/container_registry/#control-container-registry-from-within-gitlab) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/216122).
### Просмотр нагрузки и аннотаций внешних IT-уведомлений в GitLab
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Monitor](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Список уведомлений полезен при сортировке проблем на высоком уровне, однако в нем недостаточно места для всех атрибутов уведомлений и для нагрузки. Новая страница с деталями по уведомлению предназначена для отображения и организации нагрузки и аннотаций, чтобы при расследовании проблемы было проще находить критически важную информацию.
[Документация по странице уведомлений](https://docs.gitlab.com/ee/user/project/operations/alert_management.html#alert-detail-page) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/213911).
### Рендер эмодзи на странице состояния проекта
(ULTIMATE, GOLD) [Стадия цикла DevOps: Monitor](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Тикеты GitLab поддерживают эмодзи в имени тикета и во всех полях с поддержкой Markdown. Теперь при публикации тикета через публичный URL как [страницы статуса проекта](https://docs.gitlab.com/ee/user/project/status_page/) на этой странице поддерживаются и рендерятся эмодзи, использованные в имени, описаниях и комментариях к тикету.
[Документация по странице информации по инциденту](https://docs.gitlab.com/ee/user/project/status_page/#incident-detail-page) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/212678).
### Переключение видимости панели метрик
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Monitor](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Ранее администраторы проекта не могли управлять разрешениями на просмотр панели метрик проекта. В GitLab 13.0 администраторы смогут разрешать видимость панели метрик либо только участникам проекта, либо всем пользователям с правами доступа.
[Документация по видимости панели метрик](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#metrics-dashboard-visibility) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/201924).
### Добавление аннотаций на панель метрик
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Monitor](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Иногда графики метрик становятся сложными для понимания. Начиная с GitLab 13.0 вы сможете добавлять аннотации к своим графикам метрик, в виде горизонтальных пунктирных линий поверх ваших графиков и диаграмм. Они помогут вам правильно интерпретировать данные.
[Документация по аннотациям на панелях метрик Prometheus](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#dashboard-annotations) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2621).
### Поиск секретных ключей в полной истории репозитория
(ULTIMATE, GOLD) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
В GitLab 13.0 мы обновляем наше [сканирование для поиска секретных ключей](https://docs.gitlab.com/ee/user/application_security/secret_detection/) для поддержки новой переменной [`SAST_GITLEAKS_HISTORIC_SCAN`](https://docs.gitlab.com/ee/user/application_security/secret_detection/#full-history-secret-scan), что позволит проводить сканирование полной истории репозитория. Это поможет вам находить ключи, которые могли затеряться среди старых коммитов. На момент появления в [GitLab 11.9](https://gitlab.softmart.ru/releases/2019/04/08/gitlab-11-9.html#%D0%9E%D0%B1%D0%BD%D0%B0%D1%80%D1%83%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%B9-%D1%81%D0%B5%D0%BA%D1%80%D0%B5%D1%82%D0%BE%D0%B2-%D0%B8-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-%D0%B0%D0%B2%D1%82%D0%BE%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B8-%D0%B2-%D1%80%D0%B5%D0%BF%D0%BE%D0%B7%D0%B8%D1%82%D0%BE%D1%80%D0%B8%D0%B8) сканирование для поиска секретных ключей проводилось по истории изменений в коммитах мерж-реквеста, что позволяло находить новые добавленные ключи, но не затрагивало более давнюю историю коммитов. Наша новая фича будет особенно полезна при использовании поиска секретных ключей в репозитории в первый раз — для полного сканирования репозитория на наличие ключей.
Мы сняли [короткую видеоинструкцию](https://youtu.be/wDtc_K00Y0A), чтобы показать, как вы можете проводить сканирование истории для поиска ключей через [конвейер, работающий по графику](https://docs.gitlab.com/ee/ci/pipelines/schedules.html) или [конвейер с ручным запуском](https://docs.gitlab.com/ee/ci/pipelines/#run-a-pipeline-manually).
[Документация по сканированию истории репозитория для поиска секретных ключей](https://docs.gitlab.com/ee/user/application_security/secret_detection/#full-history-secret-scan) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2921).
### Экспорт списка уязвимостей из панелей безопасности инстанса и проекта
(ULTIMATE, GOLD) [Стадия цикла DevOps: Defend](https://about.gitlab.com/stages-devops-lifecycle/defend/)
Мы представляем первую итерацию экспорта списка уязвимостей из [панели безопасности инстанса](https://gitlab.com/gitlab-org/gitlab/-/issues/213014) и [панели безопасности проекта](https://gitlab.com/gitlab-org/gitlab/-/issues/197494). Хотя панели безопасности позволяют пользователям управлять уязвимостями в рамках их рабочего процесса в GitLab, раньше было непросто получить эту информацию в виде списка для внешнего использования.
Теперь вы можете загружать файл в формате CSV со всеми обнаруженными уязвимостями для определенного проекта или для всех проектов, управляемых на панели безопасности инстанса. Этот список можно использовать для создания отчетов по безопасности или как источник данных для внешних панелей безопасности. Просто перейдите к панели безопасности инстанса или к [панели безопасности любого проекта](https://docs.gitlab.com/ee/user/application_security/security_dashboard/index.html#export-vulnerabilities) и нажмите новую кнопку Export справа вверху или выберите Security в меню More на верхней панели навигации, затем нажмите новую кнопку Export в правом верхнем углу. Ваш браузер автоматически начнет загрузку.
[Документация по экспорту уязвимостей](https://docs.gitlab.com/ee/user/application_security/security_dashboard/#export-vulnerabilities-1) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/213014).
### Интеграция SIEM с файерволом веб-приложений
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Defend](https://about.gitlab.com/stages-devops-lifecycle/defend/)
Мы объявляем о новой интеграции SIEM для файервола веб-приложений (WAF). Эта интеграция позволяет пользователям экспортировать свои логи WAF в SIEM или в централизованное решение для логирования, чтобы можно было просматривать любые аномалии, обнаруженные WAF. Эта фича также облегчает пользователям тестирование и настройку пользовательских правил WAF, что уменьшает количество ложных срабатываний. Интеграцию SIEM можно настроить, включив Fluentd на странице **Операции > Kubernetes** (**Operations > Kubernetes**).
[Документация по Fluentd](https://docs.gitlab.com/ee/user/clusters/applications.html#fluentd) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/199268).
### Вторичные ноды Geo автоматически пересылают запросы SSH для несинхронизированных репозиториев
(PREMIUM, ULTIMATE) [Доступность](https://about.gitlab.com/handbook/engineering/development/enablement/)
Geo поддерживает [выборочную синхронизацию](https://docs.gitlab.com/ee/administration/geo/replication/configuration.html#selective-synchronization) проектов, что позволяет системным администраторам выбирать подмножество данных, реплицируемое во вторичные ноды Geo. Geo уже поддерживает перенаправление запросов HTTP(S) на основной сервер при попытке доступа к этим несинхронизированным репозиториям. Однако пользователи, пытавщиеся получить доступ к несинхронизированным репозиториям на вторичной ноде через SSH, получали сообщение об ошибке, что репозиторий недоступен. Это сбивало с толку пользователей и заставляло их либо ждать синхронизации хранилища, либо выполнять дополнительную работу для подключения к нужному хранилищу.
В GitLab 13.0 любые запросы Git, сделанные через SSH к несинхронизированной вторичной ноде Geo, будут перенаправлены на первичную ноду. Это приводит к гораздо более плавному взаимодействию с пользователями, поскольку им не нужно будет знать, что реплицируется или не реплицируется на эту ноду: Geo выполнит запрос как по HTTP(S), так и по SSH без какой-либо дополнительной настройки.
[Документация по настройке операций Git с нереплицированными репозиториеями](https://docs.gitlab.com/ee/administration/geo/replication/configuration.html#git-operations-on-unreplicated-respositories) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2562).
### Обработчик заданий теперь поддерживает загрузку артефактов непосредственно из хранилища объектов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Обработчик заданий GitLab (GitLab Runner) 13.0 теперь поддерживает загрузку артефактов непосредственно из хранилища объектов. Когда эта опция включена, сервер GitLab будет перенаправлять обработчик заданий непосредственно в хранилище объектов, а не проксировать трафик. Это может привести к значительной экономии затрат на передачу по сети, а также к снижению нагрузки на сервер GitLab.
Для подключения установите переключаемую фичу [`FF_USE_DIRECT_DOWNLOAD`](https://docs.gitlab.com/runner/configuration/feature-flags.html#available-feature-flags) в `true` через переменную окружения.
[Документация по доступным переключаемым фичам](https://docs.gitlab.com/runner/configuration/feature-flags.html#available-feature-flags) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-runner/-/issues/25662).
### Добавлены события аудита для действий администратора под именем пользователя
(PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Возможность проводить аудит и отслеживать изменения являются важными компонентами программы соответствия требованиям для организации. Ранее действия, предпринимаемые администратором от имени другого пользователя, регистрировались в таблице событий аудита, как если бы этот пользователь сам выполнял эти действия. Теперь события аудита покажут вам, когда определенные действия были выполнены администратором от имени пользователя.
Это важное дополнение к событиям аудита исправляет пробел в неоспоримости действий (nonrepudiation) для вашей программы соответствия требованиям и повышает надежность и полноту данных о событиях аудита GitLab.
[Документация по событиям аудита](https://docs.gitlab.com/ee/administration/audit_events.html#instance-events-premium-only) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/536).
### Аналитика цикла разработки: метрики для времени выполнения и времени цикла
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Две новые ключевые метрики в этой аналитике дают командам базу для измерения усилий по улучшению процесса, чтобы влияние изменений было нагляднее. Время выполнения — это время, прошедшее между запрошенным элементом и его поставкой. Время цикла — длина самого цикла разработки. Оптимизируя процесс создания продукта, команды лишний раз не перемещают проблему из одного места в другое, что ускоряет поставку.
[Документация по аналитике цикла разработки](https://docs.gitlab.com/ee/user/analytics/value_stream_analytics.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/21863).
### Приложение интеграции Okta SCIM для GitLab.com
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Теперь мы предлагаем приложение интеграции Okta SCIM для групп на Gitlab.com. Когда Okta SCIM настраивается для группы GitLab, членство в этой группе синхронизируется между GitLab и Okta. Это экономит время администратора группы, затрачиваемое на добавление и удаление пользователей.
[Документация по настройке SCIM](https://docs.gitlab.com/ee/user/group/saml_sso/scim_setup.html#okta-configuration-steps) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/1774).
### Экспорт и импорт групп в пользовательском интерфейсе
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Ранее пользователи могли переносить группы только с помощью [API экспорта и импорта](https://gitlab.com/groups/gitlab-org/-/epics/1952): сначала требовалось создать файл экспорта, а затем снова с помощью API загрузить файл в нужный инстанс.
В качестве первого шага на пути к более удобному решению мы включили экспорт группы в пользовательском интерфейсе GitLab. Мы планируем добавить аналогичную [функциональность для импорта](https://gitlab.com/gitlab-org/gitlab/-/issues/211807) в пользовательский интерфейс в течение нескольких следующих недель.
[Документация по импорту и экспорту](https://docs.gitlab.com/ee/user/group/settings/import_export.html) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2888).
### Просмотр майлстоунов на дорожной карте
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: Plan](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Точное отслеживание состояния процесса работы необходимо, чтобы помочь командам не сбиться с пути. Теперь, просматривая свою дорожную карту, вы можете увидеть, как ваши эпики соотносятся с различными майлстоунами, помогая вам оценить, когда работа завершится, и определить, насколько проекты соответствуют ожидаемому графику.
[Документация по дорожным картам](https://docs.gitlab.com/ee/user/group/roadmap) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issuess/6802).
### Перетаскивание тикетов между эпиками в дереве эпиков
(ULTIMATE, GOLD) [Стадия цикла DevOps: Plan](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Часто при организации или кураторстве эпика вам нужно переместить существующий тикет в другой эпик в дереве. Теперь вы можете сделать это с помощью перетаскивания, вместо того чтобы щелкать по нескольким вкладкам.
[Документация по управлению эпиками](https://docs.gitlab.com/ee/user/group/epics/manage_epics.html#move-issues-between-epics-ultimate) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/33039).
### Управление дизайнами теперь в Core
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
В релизе 12.2 управление дизайнами началось с [загрузки дизайнов](https://gitlab.softmart.ru/releases/2019/09/03/GitLab-12-2.html#%D0%97%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D0%BA%D0%B0-%D0%B4%D0%B8%D0%B7%D0%B0%D0%B9%D0%BD%D0%BE%D0%B2-%D1%87%D0%B5%D1%80%D0%B5%D0%B7-%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%86%D1%83-%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B4%D0%B8%D0%B7%D0%B0%D0%B9%D0%BD%D0%B0%D0%BC%D0%B8) и [обсуждения интересующих мест](https://gitlab.softmart.ru/releases/2019/09/03/GitLab-12-2.html#%D0%90%D0%BD%D0%BD%D0%BE%D1%82%D0%B0%D1%86%D0%B8%D0%B8-%D0%B4%D0%BB%D1%8F-%D0%B4%D0%B8%D0%B7%D0%B0%D0%B9%D0%BD%D0%BE%D0%B2) в рамках GitLab Premium. С тех пор мы рассматривали как отдельных участников наших пользователей, занимающихся дизайном продуктов, а в 13.0 мы переместили эти две фичи в GitLab Core. Это согласуется с нашей [моделью покупки для индивидуальных разработчиков](https://about.gitlab.com/handbook/ceo/pricing/#buyer-based-tiering-clarification). Мы ожидаем, что в будущем по мере развития управления дизайнами мы добавим другие замечательные командные функции, такие как согласование.
Так что теперь все пользователи могут загружать дизайны и давать обратную связь по дизайну в тикетах GitLab. Напоминаем, что вы найдете вкладку **Дизайн** (**Design**) рядом с вкладкой **Обсуждение** (**Discussion**) в любом тикете. Для начала попробуйте загрузить скриншот с помощью перетаскивания.
[Документация по управлению дизайнами](https://docs.gitlab.com/ee/user/project/issues/design_management.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/212566).
### Улучшенный редактор сниппетов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
С выпуском [сниппетов с поддержкой версий](#kontrol-versiy-dlya-snippetov) в GitLab 13.0 мы обновили редактор сниппетов до более легкой версии редактора из нашей Web IDE. С помощью этого редактора пользователи смогут воспользоваться базовым дополнением кода и статическим анализом (линтингом) для некоторых языков. Мы также улучшили определение языка исходного кода для лучшей подсветки синтаксиса и добавили поддержку для всех наших [тем подсветки синтаксиса](https://docs.gitlab.com/ee/user/profile/preferences.html#syntax-highlighting-theme). Эти улучшения облегчат редактирование и совместную работу над сниппетами.
Мы рады обеспечить согласованность редактора сниппетов и редактора в Web IDE. В следующем релизе мы добавим эти возможности также для нашего [редактора одиночного файла](https://gitlab.com/gitlab-org/gitlab/-/issues/198605) и [`редактирования файла .gitlab-ci.yml`](https://gitlab.com/gitlab-org/gitlab/-/issues/198606).
[Документация по сниппетам](https://docs.gitlab.com/ee/user/snippets.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/198604).
### WYSIWYG для редактора статических сайтов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Markdown — это мощный и эффективный синтаксис для создания веб-контента. Но даже опытные авторы контента в Markdown могут подзабыть некоторые из редко используемых параметров форматирования или с трудом пишут даже умеренно сложные таблицы с нуля. Некоторые работы удобнее выполнять с помощью визуального редактора «что видите, то и получите» (WYSIWYG).
GitLab 13.0 добавляет Markdown с WYSIWYG в редактор статических сайтов, включая такие параметры форматирования, как заголовки, полужирный шрифт, курсив, ссылки, списки, цитаты и блоки кода. Визуальный редактор также устраняет обременительную задачу редактирования таблиц в Markdown, позволяя редактировать строки, столбцы и ячейки так же, как в обычной электронной таблице. А для тех, кому удобнее писать сразу в Markdown, есть вкладка для переключения между WYSIWYG и обычным редактированием.
[Документация по редактору статических сайтов](https://docs.gitlab.com/ee/user/project/static_site_editor/#static-site-editor) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/214559/).
### Фильтр Approved-by для мерж-реквестов
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Утверждение мерж-реквеста требует, чтобы определенные люди одобрили изменения, прежде чем их можно будет смержить. При поиске в списке мерж-реквестов вы можете быстро найти, какие из них нуждаются в вашем одобрении, с помощью фильтра **Утверждающие** (**Approvers**). В GitLab 13.0 теперь вы также сможете найти любые ранее одобренные вами мерж-реквесты, используя новый фильтр **Approved-By**.
[Документация по фильтрации мерж-реквестов](https://docs.gitlab.com/ee/user/search/#filtering-merge-requests-by-approved-by-starter) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/39042).
### Поддержка родительских групп и пользователей в файле CODEOWNERS
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Группы можно использовать для организации пользователей в GitLab. Это позволяет легко делиться проектами, упоминать пользователей в комментариях или назначать несколько утверждающих для мерж-реквеста, не выбирая их по одному.
Группы и пользователей можно сделать владельцами кода, но при этом нельзя было использовать родительские группы (непосредственные и более верхнего уровня). Вернее, назначить родительскую группу из иерархии проекта в качестве владельца кода было можно, но от этого ничего не менялось.
GitLab 13.0 добавляет возможность включать пользователей и группы из родительской группы в файл `CODEOWNERS` проекта, обеспечивая больше гибкости при определении правил для владельцев кода.
[Документация по определению владельцев кода](https://docs.gitlab.com/ee/user/project/code_owners.html#the-syntax-of-code-owners-files) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issuess/32432).
### Наследование переменных окружения от других заданий
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Теперь можно передавать переменные окружения и другие данные между заданиями CI. Используя ключевое слово `dependencies` (или ключевое слово `needs` для конвейеров DAG), задание может наследовать переменные от других заданий, если они получены с помощью артефактов отчета `dotenv`. Это предлагает более изящный подход для обновления переменных между заданиями по сравнению с использованием артефактов или передачей файлов.
[Документация по наследованию переменных окружения](https://docs.gitlab.com/ee/ci/variables/README.html#inherit-environment-variables) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/22638).
### Настраиваемый порог тестирования производительности браузера
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
[Тестирование производительности браузера](https://docs.gitlab.com/ee/user/project/merge_requests/browser_performance_testing.html) позволяет пользователям до мержа с мастером обнаруживать, когда происходит ухудшение в их веб-приложении. Во многих случаях эта фича вызывает дополнительный визуальный шум и только загромождает страницу мерж-реквеста, даже для незначительных изменений. В этом майлстоуне у вас появилась возможность устанавливать порог ухудшения в качестве требования, которое определяет, надо ли показывать отчет о производительности.
[Документация по настройке показа отчета о производительности](https://docs.gitlab.com/ee/user/project/merge_requests/browser_performance_testing.html#configuring-degradation-threshold) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/27599).
### Просмотр более надежных данных в списке в пользовательском интерфейсе реестра пакетов
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
До этого релиза в списочном представлении реестра пакетов отображался ограниченный объем информации, относящейся к пакетам. Хотя эта информация важна, в ней отсутствовали ключевые метаданные, такие как версия, ветка и коммит.
В 13.0 мы обновили дизайн этой страницы, добавив в него дополнительные метаданные, чтобы помочь вам найти искомый пакет и убедиться, что он собран правильно. В дополнение к имени пакета, теперь вы можете увидеть версию, тип и многое другое. Посмотрите видео для примера и начните использовать эту фичу сегодня.
[Документация по просмотру дополнительной информации о пакете](https://docs.gitlab.com/ee/user/packages/#view-additional-package-information) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/197923).
### Просмотр всех ваших пакетов Python в одном месте с помощью реестра пакетов GitLab
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
Пользовательский интерфейс реестра пакетов GitLab позволяет вам подтвердить, что ваши пакеты были собраны правильно, и устранить неполадки, если что-то пошло не так. Однако MVC нового репозитория PyPI, запущенного в 12.10, не включал эту функциональность.
В версии 13.0 мы добавили репозиторий PyPI в пользовательский интерфейс реестра пакетов. Теперь вы можете просматривать и загружать пакеты PyPI вашего проекта или группы и проверять метаданные и правильность сборки пакета. Вы также можете скопировать команды настройки и установки для более эффективного совместного использования и разработки. Если пакет был собран с использованием конвейера GitLab, вы сможете просмотреть и связать его с конвейером, а также с коммитом, который использовался для публикации пакета.
[Документация по репозиторию PyPI](https://docs.gitlab.com/ee/user/packages/pypi_repository/index.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/202011).
### Поддержка API для списков переключаемых фич
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: Release](https://about.gitlab.com/stages-devops-lifecycle/release/)
В рамках нашей поддержки [списков переключаемых фич](https://gitlab.com/gitlab-org/gitlab/-/issues/13308) мы добавили поддержку API, позволяющего создавать, редактировать и удалять их. Это облегчит автоматизацию управления и синхронизации этих списков между различными системами.
[Документация по спискам переключаемых фич](https://docs.gitlab.com/ee/api/feature_flag_user_lists.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/205409).
### Определите правила, чтобы важные образы никогда не удалялись
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
Ранее при использовании правила истечения срока действия образов в GitLab невозможно было выразить что-то вроде «несмотря ни на что, не удалять этот тег». Это вносит риск в процесс удаления, поскольку могут быть удалены образы `release` или `master`, которые должны сохраняться.
В 13.0 теперь вы можете обновить правило истечения срока действия для вашего проекта, чтобы идентифицировать образы, которые вы не хотите удалять никогда. Просто включите это правило и используйте регулярные выражения, чтобы определить образ, который вы хотите сохранить.
[Документация по правилам истечения срока действия](https://docs.gitlab.com/ee/user/packages/container_registry/#managing-project-expiration-policy-through-the-ui) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/207267).
### Используйте облачные пакеты сборки для Auto DevOps (бета-версия)
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Configure](https://about.gitlab.com/stages-devops-lifecycle/configure/)
[Облачные пакеты сборки](https://buildpacks.io/) являются следующей итерацией пакетов сборки. В то время как GitLab в настоящее время по умолчанию использует пакеты сборки Herokuish, мы намерены перевести Auto DevOps на облачные пакеты сборки, когда проект созреет, чтобы предоставить нашим пользователям надежное и хорошо поддерживаемое решение. В этом релизе вы можете выбрать использование бета-версии облачных нативных пакетов сборки в конвейерах Auto DevOps, установив переменную CI `AUTO_DEVOPS_BUILD_IMAGE_CNB_ENABLED`.
[Документация по облачным пакетам сборки для Auto DevOps](https://docs.gitlab.com/ee/topics/autodevops/stages.html#auto-build-using-cloud-native-buildpacks-beta) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/25954).
### Агрегирование оповещений из внешних инструментов в GitLab
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Monitor](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
При реагировании на предупреждения респондентам необходим единый интерфейс, объединяющий IT-оповещения, поступающие из нескольких источников. Новый список оповещений позволяет быстро и интуитивно сортировать оповещения, чтобы в первую очередь найти и проанализировать наиболее важные проблемы. Вы можете найти список предупреждений в **Операции > Оповещения** (**Operations > Alerts**).
[Документация по списку оповещений](https://docs.gitlab.com/ee/user/project/operations/alert_management.html#alert-management-list) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/213880).
### Добавьте часто используемые панели мониторинга в избранное
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Monitor](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
В GitLab 13.0 вы сможете добавлять свои часто используемые панели мониторинга в избранное, нажимая кнопку **Star**. Отмеченная звездочкой панель отображается в начале результатов поиска, что экономит ваше время.
[Документация по добавлению панелей мониторинга в избранное](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#mark-a-dashboard-as-favorite) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/3079).
### Отображение графиков в полноэкранном режиме
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Monitor](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
В GitLab 13.0 теперь можно отображать графики метрик в полноэкранном режиме, что позволяет более подробно рассмотреть информацию на них при сортировке инцидентов.
[Документация по разворачиванию панели Prometheus](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#expand-panel) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/3100).
### Анонимизация на страницах статуса
(ULTIMATE, GOLD) [Стадия цикла DevOps: Monitor](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Когда группа реагирования на инциденты делится обновлениями и изменениями статуса, описание инцидента публикуется в открытом доступе, но все имена пользователей и групп в описаниях тикетов анонимизируются для защиты конфиденциальности отдельных лиц и групп.
[Документация по публикации инцидентов](https://docs.gitlab.com/ee/user/project/status_page/#publishing-incidents) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/208993).
### Просмотр списка просканированных DAST ресурсов
ULTIMATE, GOLD) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
DAST проверяет ваше работающее веб-приложение на наличие известных уязвимостей во время выполнения, начиная с каждого мерж-реквеста. DAST сканирует много ресурсов, но точно узнать, какие именно, раньше было невозможно.
GitLab 13.0 предоставляет полный список ресурсов, которые были просканированы DAST. Теперь вы можете оценить DAST-сканирование, чтобы убедиться, что приложение защищено со всех сторон. Для упрощения дальнейшего анализа можно загрузить списки сканирования непосредственно с экрана результатов.
[Документация по списку просканированных объектов](https://docs.gitlab.com/ee/user/application_security/dast/#list-of-urls-scanned) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/11024).
### Интеграции SIEM для правил контейнерных сетей
(ULTIMATE, GOLD) [Стадия цикла DevOps: Defend](https://about.gitlab.com/stages-devops-lifecycle/defend/)
Мы представляем новую интеграцию SIEM для правил сетевой безопасности контейнеров. Интеграция позволяет пользователям экспортировать свои логи Cilium в SIEM или в централизованное решение для логирования, чтобы они могли просматривать любые аномалии, обнаруженные их сетевыми правилами. Просмотр журналов также помогает пользователям тестировать и настраивать свои сетевые правила, чтобы снизить вероятность ложных срабатываний. Интеграцию SIEM можно настроить на странице **Операции > Kubernetes** (**Operations > Kubernetes**).
[Документация по Fluentd](https://docs.gitlab.com/ee/user/clusters/applications.html#fluentd) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/199666).
### Оперативная информация о базе данных уязвимостей
(ULTIMATE, GOLD) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Мы знаем, что понимание возможностей сканирований GitLab важно для того, чтобы вы чувствовали себя в безопасности. В этом релизе мы представляем [новую страницу](https://advisories.gitlab.com) с дополнительной информацией о базе данных уязвимостей, используемой нашими сканерами.
На этой странице вы можете получить информацию о том, что мы ищем, когда мы в последний раз обновляли нашу базу данных, а также найти конкретные уязвимости, которые вас беспокоят.
[Документация по базе данных уязвимостей](https://docs.gitlab.com/ee/user/application_security/sast/#vulnerabilities-database-update) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/212568).
### PostgreSQL 11 теперь минимально необходимая версия для установки GitLab
(CORE, STARTER, PREMIUM, ULTIMATE) [Доступность](https://about.gitlab.com/handbook/engineering/development/enablement/)
Теперь минимальной требуемой версией PostgreSQL для всех пользовательских инстансов стала PostgreSQL 11. PostgreSQL версий 9.6 и 10 были удалены в GitLab 13.0. Это обновление позволяет нам начать вводить улучшения производительности на основе [функций разбиения на разделы, которые были добавлены в PostgreSQL 11](https://www.postgresql.org/about/news/1894/). Мы планируем поддерживать PostgreSQL 11 на протяжении всей серии релизов GitLab 13.x. Поддержка PostgreSQL 12 [будет добавлена в ближайшее время](https://gitlab.com/groups/gitlab-org/-/epics/2374). Посмотрите [важные замечания по обновлению](https://about.gitlab.com/releases/2020/05/22/gitlab-13-0-released/#upgrade) для получения инструкций по обновлению PostgreSQL.
[Документация по настройке баз данных](https://docs.gitlab.com/omnibus/settings/database.html) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2184).
### Улучшена производительность репликации Geo для артефактов заданий, загрузок и файлов LFS
(PREMIUM, ULTIMATE) [Доступность](https://about.gitlab.com/handbook/engineering/development/enablement/)
Чтобы определить, что нужно реплицировать с первичной базы данных, Geo сравнивает базу данных отслеживания с вторичной базой данных только для чтения. Если запросы к базе данных Geo выполняются слишком долго, то данные не могут быть успешно реплицированы. В GitLab 13.0 мы используем [новый подход к синхронизации артефактов заданий и загрузок](https://gitlab.com/gitlab-org/gitlab/-/issues/210525), тем самым исключая возможность таймаутов базы данных. Мы также [улучшили производительность запросов к базе данных для извлечения артефактов заданий, объектов LFS и загрузок, когда эти файлы хранятся локально](https://gitlab.com/gitlab-org/gitlab/-/issues/213382). Это повышает общую масштабируемость и производительность GitLab Geo.
Эти итерации приближают нас к устранению зависимости Geo от [сторонних оболочек данных](https://wiki.postgresql.org/wiki/Foreign_data_wrappers), которые были добавлены для повышения производительности, но делают Geo более сложно устроенным и затрудняют его обслуживание.
[Документация по репликации Geo](https://docs.gitlab.com/ee/administration/geo/replication) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2851).
---
Подробные release notes и инструкции по обновлению/установке можно прочитать в оригинальном англоязычном посте: [GitLab 13.0 released with Gitaly Clusters, Epic Hierarchy on Roadmaps, and Auto Deploy to ECS](https://about.gitlab.com/releases/2020/05/22/gitlab-13-0-released/).
Над переводом с английского работали [cattidourden](https://habr.com/ru/users/cattidourden/), [maryartkey](https://habr.com/ru/users/maryartkey/), [ainoneko](https://habr.com/ru/users/ainoneko/) и [rishavant](https://habr.com/ru/users/rishavant/). | https://habr.com/ru/post/506658/ | null | ru | null |
# Профайлинг NUnit-тестов .NET Framework 4
С профайлингом приложений наверняка сталкивался каждый, но как часто вам приходилось профайлить тесты?
Как показал мой личный опыт, чтобы успешно выполнить эту задачу для сборки, собранной под [.NET Framework 4](http://ru.wikipedia.org/wiki/.NET_Framework#.NET_Framework_4.0), требуется выполнить ряд действий, на поиск которых мне пришлось потратить определенное время. Поэтому я решил обобщить полученный опыт в единую компиляцию и сделать ее доступной для того, чтобы другие смогли избежать тех граблей, на которые пришлось наступить мне.
Задача стояла вполне реальная — необходимо было замерить расход памяти при подъеме большого количества тестов — для того, чтобы убрать утечки памяти.
В рабочем проекте в качестве тестовой среды использовался [NUnit 2.4](http://www.nunit.org/), а в качестве профайлера был выбран [.NET Memory Profiler](http://memprofiler.com/) 4.0.
Тестовые данные
---------------
Сделаем сборку, содержащую пример теста.
Для этого в Visual Studio 2010 создадим новый проект **WPF User Control Library**, добавим в референсы **nunit.framework.dll** и создадим файл *TestClasses* для тестов.
Рис.1 Референсы и состав проекта
Рис.2 Окно опций проекта
Напишем один единственный тест, код которого приведен ниже:
```
using System;
using NUnit.Framework;
using System.Windows.Controls;
using System.Windows;
namespace WpfClassLibrary {
[TestFixture]
public class MyTests {
[Test]
public void TestForProfiling() {
TextBox textBlock = new TextBox();
textBlock.Text = "UIElement Test";
Assert.IsTrue(textBlock.Text.Length > 0);
MessageBox.Show("Ready for Collect Snapshot...");
}
}
}
```
В этом примере я добавил в тест код для выдачи сообщения. Это более наглядно покажет, что код теста действительно был вызван. Для снятия снэпшотов на разных стадиях прохождения выбранного теста расстановка подобных сообщений может оказаться тоже весьма кстати — это позволит сделать необходимую паузу при выполнении теста.
Настройка профайлера
--------------------
C чего начать профайлинг теста?
Запустим профайлер и укажем в качестве запускаемого приложения консольную версию NUnit. Для этого указываем файл nunut-console.exe (в моем случае он был расположен по следующему пути: *C:\Program Files (x86)\TestDriven.NET 3\NUnit\2.4\* ).
Теперь останется задать аргументы. Достаточно запустить nunut-console.exe с ключом "/?" чтобы получить интересующий нас список. Формат запуска файла выглядит так:
**NUNIT-CONSOLE [inputfiles] [options]**
Т.е необходимо указать путь до сборки с тестами, указав опции. Нас будет интересовать только одна:
**/run=STR Name of the test to run**
Хочу заметить, что в качестве имени теста необходимо указывать *полный!* путь до тестового метода, включая и пространство имен.
Приходим к тому, что пропишем следующую строку в качестве аргументов для профайлера:
***C:\Sandbox\WpfClassLibrary\WpfClassLibrary\bin\Debug\WpfClassLibrary.dll /run=WpfClassLibrary.MyTests.TestForProfiling***
Рис.3 Окно настроек профайлера для запуска теста
Вроде бы все готово, но в при данных условиях тест не выполняется. Пришло время разобраться, почему это так…
---
Как позволить NUnit запусть сборки собранные в VS2010 ?
-------------------------------------------------------
Попробуем запустить наш тест, используя nunit-console.exe, а не профайлер.
В результате получаем ошибку **System.BadImageFormatException**:
*Unhandled Exception:
System.BadImageFormatException: Could not load file or assembly 'C:\Sandbox\WpfClassLibrary\WpfClassLibrary\bin\Debug\WpfClassLibrary.dll' or one of its dependencies. This assembly is built by a runtime newer than the currently loaded runtime and cannot be loaded.
File name: 'C:\Sandbox\WpfClassLibrary\WpfClassLibrary\bin\Debug\WpfClassLibrary.dll'*
Т.к. что наша сборка собрана под Framework 4, она не может быть загружена для запуска теста.
Находим файл **nunit-console.exe.config**, расположенный рядом с консольной версией NUnit. На моей машине он расположен тут:
*«C:\Program Files (x86)\TestDriven.NET 3\NUnit\2.4\nunit-console.exe.config»*
Ищем секцию *startup*, в которой описание нам говорит:
> `\* This source code was highlighted with Source Code Highlighter.`
Эта секция содержит информацию о поддержку .NET Framework версий 1 и 2, но никак не 4.
Создаем свою startup-секцию (или модифицируем существующую) и добавляем туда строку для поддержки запуска сборки 4-го фреймворка. Строка для добавления выглядит так:
> `<startup>
>
> <supportedRuntime version="v4.0.30319" />
>
> startup>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Первая проблема решена — NUnit теперь умеет запускать тесты, собранные под .NET Framework 4.**
---
Конфигурируем запуск сборки с тестами в STA
-------------------------------------------
Вернемся к нашему тесту. Он прекрасно запускается и проходит, если запускать его непосредственно из Visual Studio 2010 с помощью интегрированных в нее средств TDD. Если же попытаться выполнить тест из nunit.exe или ее консольной версии (для консольной не забудем указать параметром тестовую сборку), то произойдет следующая ошибка:
*MyTestLib.MyTests.TestForProfiling:
System.InvalidOperationException: The calling thread must be STA, because many UI components require this.*
Рис.4 Ошибка при запуске теста в NUnit
Из сообщения и стека вызовов становится очевидно, что необходимо запускать тесты в потоковом апартменте STA. Интересующиеся могут почитать детали [тут](http://msdn.microsoft.com/en-us/library/ms693344) или [тут](http://www.rsdn.ru/article/dotnet/CSThreading2.xml).
Запуск тестов для WinForms или ASP.NET может отличаться от рассматриваемого WPF примера, но, тем не менее, существует ряд ограничений (таких как OLE drag-n-drop, работа с клипбордом и т.д), которые будут требовать запускать тесты в STA.
В более новой версии NUnit 2.5 даже существует специальный [RequiresSTAAttribute](http://www.nunit.org/index.php?p=requiresSTA&r=2.5) атрибут для этих целей.
Для тех, кто ограничен использованием NUnit версии 2.4 можно воспользоваться [конфигурационными файлами](http://www.nunit.org/index.php?p=configFiles&r=2.5).
Для тестируемой сборки создадим такой файл с указанием необходимости запуска тестов в STA. Хочу заметить, что он должен иметь имя, совпадающее с именем сборки и постфиксом *config*, и должен быть расположен рядом сней.
Создадим файл с именем **WpfClassLibrary.dll.config** следующего содержания:
> `</fontxml version="1.0" encoding="utf-8"?>
>
> <configuration>
>
> <configSections>
>
> <sectionGroup name="NUnit">
>
> <section name="TestRunner" type="System.Configuration.NameValueSectionHandler" />
>
> sectionGroup>
>
> configSections>
>
> <NUnit>
>
> <TestRunner>
>
> <add key="ApartmentState" value="STA" />
>
> TestRunner>
>
> NUnit>
>
> configuration>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
>
>
**Вторая проблема решена — файл тестовой сборки теперь имеет конфигурационный файл, определяющий правильный способ запуска из NUnit.**
---
Профайлим тест
--------------
Пришло время проверить результат. Запустим профайлер и убедимся, что тест был вызван.
Рис.5 Профайлинг теста
**Задача решена — сборка с тестом корректно подгружена и тест запущен.**
В дополнение хочу сказать, что существует другой вариант запуска профайлера. Суть метода в том, что можно указать системе запускать определенный процесс (для TDD это ProcessInvocation86.exe) под отладчиком (профайлером). Это делается прописыванием в реестре ключа [Image File Execution Options](http://msdn.microsoft.com/en-us/library/a329t4ed(v=vs.71).aspx).
Но это уже тема для отдельной статьи…
На этом всё! Надеюсь, что эта информация окажется полезной и сэкономит время на выполнение подобной задачи.
Удачного тестирования и профайлинга! | https://habr.com/ru/post/128338/ | null | ru | null |
# Глубокое обучение для новичков: распознаем рукописные цифры
Представляем первую статью в серии, задуманной, чтобы помочь быстро разобраться в технологии *глубокого обучения*; мы будем двигаться от базовых принципов к нетривиальным особенностям с целью получить достойную производительность на двух наборах данных: MNIST (классификация рукописных цифр) и CIFAR-10 (классификация небольших изображений по десяти классам: самолет, автомобиль, птица, кошка, олень, собака, лягушка, лошадь, корабль и грузовик).
Интенсивное развитие технологий машинного обучения привело к появлению нескольких весьма удобных фреймворков, которые позволяют быстро проектировать и строить прототипы наших моделей, а также предоставляют неограниченный доступ к наборам данных, применяемым для тестирования алгоритмов обучения (таким, как названные выше). Среда разработки, которую мы будем использовать здесь, называется **Keras**; я нашел ее наиболее удобной и интуитивной, но в то же время обладающей выразительными возможностями, достаточными для того, чтобы при необходимости вносить правки в модель.
В конце этого урока вы будете понимать принцип работы простой модели глубокого обучения, называемой “многослойный перцептрон” (MLP), а также научитесь строить ее в Keras, получая достойную степень точности на MNIST. На следующем уроке мы разберем методы решения более сложных задач по классификации изображений (таких, как CIFAR-10).
(Искусственные) нейроны
-----------------------
Хотя термин “глубокое обучение” можно понимать и в более широком смысле, в большинстве случаев он применяется в области **(искусственных) нейронных сетей**. Идея этих конструкций заимствованы из биологии: нейронные сети имитируют процесс обработки нейронами головного мозга воспринимаемых из окружающей среды образов и участие этих нейронов в принятии решений. Принцип работы отдельно взятого искусственного нейрона в сущности очень прост: он вычисляет взвешенную сумму всех элементов *входного вектора* , используя *вектор весов*  (а также аддитивную *составляющую смещения* ), а затем к результату может применяться *функция активации* *σ*.
Среди наиболее популярных функций активации:
* Функция тождества (Identity): *σ*(*z*)=*z*;
* Сигмоидальная функция, а именно, логистическая функция (Logistic): %3D%7B1%5Cover(1%20%2B%20exp(-z))) и гиперболический тангенс (Tanh): %3Dtanh(z))
* Полулинейная функция (Rectified linear, ReLU) %3Dmax(0%2C%20z))
Изначально (с 1950-х) модели перцептронов были полностью линейными, то есть в качестве функции активации служило только тождество. Но вскоре стало понятно, что основные задачи чаще имеют нелинейную природу, что привело к появлению других функций активации. Сигмоидальные функции (обязанные своему названию характерному S-образному графику) хорошо моделируют начальную “неопределенность” нейрона относительно бинарного решения, когда *z* близко к нулю, в сочетании с быстрым насыщением при смещении *z* в каком-либо направлении. Две функции, представленные здесь, очень похожи, но выходные значения гиперболического тангенса принадлежат отрезку [-1, 1], а область значений логистической функции — [0, 1] (таким образом, логистическая функция удобнее для представления вероятностей).
В последние годы в глубоком обучении получили широкое распространение полулинейные функции и их вариации — они появились в качестве простого способа сделать модель нелинейной (“если значение отрицательно, обнулим его”), но в конце концов оказались успешнее, чем исторически более популярные сигмоидальные функции, к тому же они больше соответствуют тому, как биологический нейрон передает электрический импульс. По этой причине в рамках этого урока мы сосредоточим внимание на полулинейных функциях (ReLU).
Каждый нейрон однозначно определяется его весовым вектором , и главная цель *обучающегося алгоритма* — на основе *обучающей выборки* известных пар входных и выходных данных присвоить нейрону набор весов таким образом, чтобы минимизировать ошибку предсказания. Типичный пример такого алгоритма — метод *градиентного спуска (gradient descent)*, который для определенной функции потерь ) изменяет вектор весов в направлении наибольшего убывания этой функции:
%20%5Cover%20%5Cpartial%20%5Cvec%7Bw%7D%7D%20)
где *η* — положительный параметр, называемый *темпом обучения (learning rate)*.
Функция потерь отражает наше представление о том, насколько неточен нейрон в принятии решений при текущем значении параметров. Наиболее простой выбор функции потерь, который при этом хорош для большинства задач — *квадратичная функция*; для заданной обучающей выборки ) она определяется как квадрат разности целевого значения *y* и фактического выходного значения нейрона при данном входном :
%20%3D%20(y%20-%20%5Csigma(w_0%20%2B%20%5Csum_%7Bi%3D1%7D%5E%7Bn%7D%20w_ix_i))%5E2)
В сети есть большое количество обучающих курсов, которые рассматривают алгоритмы градиентного спуска более углубленно. В нашем же случае обо всей оптимизации для нас позаботится фреймворк, поэтому я не буду уделять ей много внимания в дальнейшем.
Введение в нейронные сети (и глубокое обучение)
-----------------------------------------------
Теперь, когда мы ввели понятие нейрона, становится возможно соединить выход одного нейрона со входом другого, таким образом положив начало **нейронной сети**. В целом мы сосредоточим наше внимание на нейронных сетях *прямого распространения*, в которых нейроны формируют слои так, что нейроны одного слоя обрабатывают выходные данные предыдущего слоя. В наиболее мощной из таких архитектур (*многослойные перцептроны*, MLP) все выходные данные одного слоя соединены со всеми нейронами следующего слоя, как на схеме ниже.
Для изменения весов выходных нейронов может быть непосредственно использован описанный выше метод градиентного спуска с заданной функцией потерь, для остальных нейронов необходимо распространить эти потери в обратном направлении (применяя правило дифференцирования сложной функции), таким образом положив начало *алгоритму обратного распространения ошибок* (*backpropagation*). Так же, как и с методом градиентного спуска, я не стану уделять внимание математическому обоснованию алгоритма, так как все вычисления производить наш фреймворк.
По универсальной теореме аппроксимации Цыбенко достаточно широкий многослойный перцептрон с одним скрытым слоем сигмоидальных нейронов может аппроксимировать любую непрерывную функцию действительных переменных на заданном интервале. Доказательство этой теоремы не имеет практического применения и не предлагает эффективного обучающего алгоритма для подобных структур. Ответ дает глубокое обучение: вместо *ширины* увеличивайте *глубину*; по определению любая нейронная сеть с более, чем одним скрытым слоем, считается глубокой.
Перемещение в глубину также позволяет нам подавать на вход нейронной сети *необработанные входные данные*: в прошлом однослойным сетям на вход подавались *ключевые признаки* (*features*), которые выделяли из входных данных с помощью специальных функций. Это значило, что для различных классов задач, например, *компьютерного зрения*, *распознавания речи* или *обработки естественных языков*, требовались разные подходы, что препятствовало научному сотрудничеству между этими областями. Но когда сеть содержит несколько скрытых слоев, она приобретает способность сама обучаться выделять ключевые признаки, которые наилучшим образом описывают входные данные, таким образом находя применение end-to-end learning (без традиционных программируемых обработок между входом и выходом), а также позволяя использовать одну и ту же сеть для *широкого спектра задач*, так как больше нет необходимости выводить функции для получения ключевых признаков. Я приведу графическое подтверждение вышесказанного во второй части лекции, когда мы будем рассматривать сверточные нейронные сети.
Применение глубокого MLP к MNIST
--------------------------------
Теперь реализуем простейшую возможную глубокую нейронную сеть — MLP с двумя скрытыми слоями — и применим ее к задаче распознавания рукописных цифр из набора данных MNIST.
Необходимы только следующие импорты:
```
from keras.datasets import mnist # subroutines for fetching the MNIST dataset
from keras.models import Model # basic class for specifying and training a neural network
from keras.layers import Input, Dense # the two types of neural network layer we will be using
from keras.utils import np_utils # utilities for one-hot encoding of ground truth values
```
Затем определим некоторые параметры нашей модели. Эти параметры часто называют *гиперпараметрами*, так как предполагается, что они будут уточнены еще до начала обучения. В данном руководстве мы возьмем заранее подобранные значения, процессу же их уточнения уделим больше внимания в последующих уроках.
В частности, мы определим:
**batch\_size** — количество обучающих образцов, обрабатываемых одновременно за одну итерацию алгоритма градиентного спуска;
**num\_epochs** — количество итераций обучающего алгоритма по всему обучающему множеству;
**hidden\_size** — количество нейронов в каждом из двух скрытых слоев MLP.
```
batch_size = 128 # in each iteration, we consider 128 training examples at once
num_epochs = 20 # we iterate twenty times over the entire training set
hidden_size = 512 # there will be 512 neurons in both hidden layers
```
Пришло время загрузить MNIST и провести предварительную обработку. С помощью Keras это делается очень просто: он просто считывает данные с удаленного сервера напрямую в массивы библиотеки NumPy.
Чтобы подготовить данные, сперва мы представим изображения в виде одномерных массивов (так как считаем каждый пиксель отдельным входным признаком), а затем разделим значение интенсивности каждого пикселя на 255, чтобы новое значение попадало в отрезок [0, 1]. Это очень простой способ нормализовать данные, мы обсудим другие способы в последующих уроках.
Хорошим подходом к задаче классификации является *вероятностная классификация*, при которой у нас есть один выходной нейрон для каждого класса, выдающий вероятность того, что входной элемент принадлежит данному классу. Это подразумевает необходимость преобразования обучающих выходных данных в прямое кодирование: например, если желаемый выходной класс — 3, а всего классов пять (и они пронумерованы от 0 до 4), то подходящее прямое кодирование — [0, 0, 0, 1, 0]. Повторюсь, что Keras предлагает нам всю эту функциональность “из коробки”.
```
num_train = 60000 # there are 60000 training examples in MNIST
num_test = 10000 # there are 10000 test examples in MNIST
height, width, depth = 28, 28, 1 # MNIST images are 28x28 and greyscale
num_classes = 10 # there are 10 classes (1 per digit)
(X_train, y_train), (X_test, y_test) = mnist.load_data() # fetch MNIST data
X_train = X_train.reshape(num_train, height * width) # Flatten data to 1D
X_test = X_test.reshape(num_test, height * width) # Flatten data to 1D
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255 # Normalise data to [0, 1] range
X_test /= 255 # Normalise data to [0, 1] range
Y_train = np_utils.to_categorical(y_train, num_classes) # One-hot encode the labels
Y_test = np_utils.to_categorical(y_test, num_classes) # One-hot encode the labels
```
А теперь настал момент определить нашу модель! Для этого мы воспользуемся стеком из трех Dense слоев, который соответствует полносвязному MLP, где все выходы одного слоя связаны со всеми входами последующего. Будем использовать ReLU для нейронов первых двух слоев, и softmax для последнего слоя. Эта функция активации разработана, чтобы превратить любой вектор с реальными значениями в вектор вероятностей и определяется для *j*-го нейрона следующим образом:
_j%20%3D%20%7Bexp(z_j)%20%5Cover%20%5Csum_iexp(z_i)%7D)
Замечательная черта Keras, которая отличает его от других фреймворков (например, от TansorFlow) — это автоматический расчет размеров слоев; нам достаточно только указать размерность входного слоя, а Keras автоматически проинициализирует все остальные слои. Когда все слои определены, нам нужно просто задать входные и выходные данные, как это сделано ниже.
```
inp = Input(shape=(height * width,)) # Our input is a 1D vector of size 784
hidden_1 = Dense(hidden_size, activation='relu')(inp) # First hidden ReLU layer
hidden_2 = Dense(hidden_size, activation='relu')(hidden_1) # Second hidden ReLU layer
out = Dense(num_classes, activation='softmax')(hidden_2) # Output softmax layer
model = Model(input=inp, output=out) # To define a model, just specify its input and output layers
```
Теперь нам осталось только определить функцию потерь, алгоритм оптимизации и метрики, которые мы будет собирать.
Когда мы имеем дело с вероятностной классификацией, в качестве функции потерь лучше всего использовать не определенную выше квадратичную ошибку, а перекрестную энтропию. Для определенного выходного вероятностного вектора , сравниваемого с фактическим вектором , потеря (для *k*-го класса) будет определяться как
%20%3D%20-%5Csum_%7Bi%3D1%7D%5Ek%5Chat%7By%7D_i%5Clog%7By_i%7D)
Потери будут меньше для вероятностных задач (например, с логистической/softmax функцией для выходного слоя), в основном из-за того, что данная функция предназначена для максимизации уверенности модели в правильном определении класса, и ее не заботит распределение вероятностей попадания образца в другие классы (в то время как функция квадратичной ошибки стремится к тому, чтобы вероятность попадания в остальные классы была как можно ближе к нулю).
Используемый алгоритм оптимизации будет напоминать какую-то форму алгоритма градиентного спуска, отличие будет лишь в том, как выбирается *темп обучения* *η*. Прекрасный обзор этих подходов представлен [здесь](http://sebastianruder.com/optimizing-gradient-descent/index.html), а сейчас мы будем использовать оптимизатор Адама, который обычно показывает хорошую производительность.
Так как наши классы сбалансированы (количество рукописных цифр, принадлежащих каждому классу, одинаково), подходящей метрикой будет *точность* (*accuracy*) — доля входных данных, отнесенных к правильному классу.
```
model.compile(loss='categorical_crossentropy', # using the cross-entropy loss function
optimizer='adam', # using the Adam optimiser
metrics=['accuracy']) # reporting the accuracy
```
Наконец, мы запускаем обучающий алгоритм. Хорошей практикой будет отложить некоторое подмножество данных для проверки, что наш алгоритм (все еще) верно распознает данные — эти данные еще называют *валидационным набором* (*validation set)*; здесь мы отделяем для этой цели 10% данных.
Еще одна приятная особенность Keras — детализация: он выводит детальное логирование всех шагов алгоритма.
```
model.fit(X_train, Y_train, # Train the model using the training set...
batch_size=batch_size, nb_epoch=num_epochs,
verbose=1, validation_split=0.1) # ...holding out 10% of the data for validation
model.evaluate(X_test, Y_test, verbose=1) # Evaluate the trained model on the test set!
```
```
Train on 54000 samples, validate on 6000 samples
Epoch 1/20
54000/54000 [==============================] - 9s - loss: 0.2295 - acc: 0.9325 - val_loss: 0.1093 - val_acc: 0.9680
Epoch 2/20
54000/54000 [==============================] - 9s - loss: 0.0819 - acc: 0.9746 - val_loss: 0.0922 - val_acc: 0.9708
Epoch 3/20
54000/54000 [==============================] - 11s - loss: 0.0523 - acc: 0.9835 - val_loss: 0.0788 - val_acc: 0.9772
Epoch 4/20
54000/54000 [==============================] - 12s - loss: 0.0371 - acc: 0.9885 - val_loss: 0.0680 - val_acc: 0.9808
Epoch 5/20
54000/54000 [==============================] - 12s - loss: 0.0274 - acc: 0.9909 - val_loss: 0.0772 - val_acc: 0.9787
Epoch 6/20
54000/54000 [==============================] - 12s - loss: 0.0218 - acc: 0.9931 - val_loss: 0.0718 - val_acc: 0.9808
Epoch 7/20
54000/54000 [==============================] - 12s - loss: 0.0204 - acc: 0.9933 - val_loss: 0.0891 - val_acc: 0.9778
Epoch 8/20
54000/54000 [==============================] - 13s - loss: 0.0189 - acc: 0.9936 - val_loss: 0.0829 - val_acc: 0.9795
Epoch 9/20
54000/54000 [==============================] - 14s - loss: 0.0137 - acc: 0.9950 - val_loss: 0.0835 - val_acc: 0.9797
Epoch 10/20
54000/54000 [==============================] - 13s - loss: 0.0108 - acc: 0.9969 - val_loss: 0.0836 - val_acc: 0.9820
Epoch 11/20
54000/54000 [==============================] - 13s - loss: 0.0123 - acc: 0.9960 - val_loss: 0.0866 - val_acc: 0.9798
Epoch 12/20
54000/54000 [==============================] - 13s - loss: 0.0162 - acc: 0.9951 - val_loss: 0.0780 - val_acc: 0.9838
Epoch 13/20
54000/54000 [==============================] - 12s - loss: 0.0093 - acc: 0.9968 - val_loss: 0.1019 - val_acc: 0.9813
Epoch 14/20
54000/54000 [==============================] - 12s - loss: 0.0075 - acc: 0.9976 - val_loss: 0.0923 - val_acc: 0.9818
Epoch 15/20
54000/54000 [==============================] - 12s - loss: 0.0118 - acc: 0.9965 - val_loss: 0.1176 - val_acc: 0.9772
Epoch 16/20
54000/54000 [==============================] - 12s - loss: 0.0119 - acc: 0.9961 - val_loss: 0.0838 - val_acc: 0.9803
Epoch 17/20
54000/54000 [==============================] - 12s - loss: 0.0073 - acc: 0.9976 - val_loss: 0.0808 - val_acc: 0.9837
Epoch 18/20
54000/54000 [==============================] - 13s - loss: 0.0082 - acc: 0.9974 - val_loss: 0.0926 - val_acc: 0.9822
Epoch 19/20
54000/54000 [==============================] - 12s - loss: 0.0070 - acc: 0.9979 - val_loss: 0.0808 - val_acc: 0.9835
Epoch 20/20
54000/54000 [==============================] - 11s - loss: 0.0039 - acc: 0.9987 - val_loss: 0.1010 - val_acc: 0.9822
10000/10000 [==============================] - 1s
[0.099321320021623111, 0.9819]
```
Как видно, наша модель достигает точности приблизительно 98.2% на тестовом наборе данных, это вполне достойно для такой простой модели, несмотря на то что ее далеко превзошли сверхсовременные подходы, описанные [здесь](http://rodrigob.github.io/are_we_there_yet/build/classification_datasets_results.html#4d4e495354).
Я призываю вас еще поэкспериментировать с этой моделью: попробовать различные гиперпараметры, алгоритмы оптимизации, функции активации, добавить скрытых слоев, и т.д. В конце концов у вас должно получиться достичь точности выше 99%.
Заключение
----------
В этом посте мы рассмотрели основные понятия глубокого обучения, успешно реализовали простой двухслойный глубокий MLP с помощью фреймворка Keras, применили его к набору данных MNIST — и все это в менее 30 строках кода.
В следующий раз мы рассмотрим сверточные нейронные сети (CNN), которые решают некоторые проблемы, возникающие при применении MLP к изображениям больших объемов (таких, как CIFAR-10). | https://habr.com/ru/post/314242/ | null | ru | null |
# Пятничный JS: единственно верный способ вычисления факториала
### Введение
Вычисление факториала — одна из традиционных программистских задач для собеседований. Если вдруг кто забыл, факториал натурального числа N обозначается как N! и равняется произведению всех натуральных чисел от единицы до N включительно. Например, . Казалось бы, что тут сложного? Однако есть свои нюансы.
Например, сравним два самых распространённых способа вычисления факториала.
**Через цикл**
```
function factorial(n){
var result = 1;
while(n){
result *= n--;
}
return result;
}
```
**Через рекурсию**
```
function factorial(n, result){
result = result || 1;
if(!n){
return result;
}else{
return factorial(n-1, result*n);
}
}
```
Многие скажут, что первый способ лучше, но это не так. Во-первых, циклы уже не в тренде, сейчас модно функциональное программирование. Во-вторых, чем больше людей используют второй способ, тем быстрее в основных джаваскриптовых движках появится оптимизация [хвостовой рекурсии](https://ru.wikipedia.org/wiki/%D0%A5%D0%B2%D0%BE%D1%81%D1%82%D0%BE%D0%B2%D0%B0%D1%8F_%D1%80%D0%B5%D0%BA%D1%83%D1%80%D1%81%D0%B8%D1%8F).
В любом случае, оба эти способа слишком примитивны, чтобы по ним судить о знаниях кандидата. А вот опытный разработчик на React.js уже может написать что-то в этом роде:
```
var React = require("react");
var Factorial = React.createClass({
render: function(){
var result = this.props.result || 1,
n = this.props.n;
if(!n){
return {result}
}else{
return
}
}
});
module.exports = Factorial;
```
Согласитесь, выглядит гораздо солиднее. Впрочем, невооружённым глазом видно, что это всего лишь вариант рекурсивного вычисления. Сходство станет ещё сильнее, если переписать Factorial как [функциональный компонент](https://facebook.github.io/react/docs/components-and-props.html#functional-and-class-components). И, разумеется, я не стал бы писать этот хабрапост, если бы не был готов предложить нечто принципиально новое.
### Начнём издалека
Какую из возможностей Javascript недолюбливают и недооценивают сильнее всего? Недолюбливают настолько, что про неё даже придумали специальную поговорку? Конечно же, это [eval](http://linterrors.com/js/eval-is-evil). Можно сказать, что **eval** — это тёмная сторона Силы. А как мы помним из фильмов Джорджа Лукаса, нет ничего более крутого и впечатляющего, чем тёмная сторона Силы, поэтому давайте попробуем ей овладеть.
Можно было бы запихнуть в строку какой-нибудь из методов, приведённых в начале поста, а затем передать эту строку в **eval**, но в этом не было бы новизны. Поставим задачу таким образом, чтобы сделать этот хак невозможным. Пусть у нас есть такой вот каркас:
```
function factorial(n){
var f = "это единственное место в коде, которое мы имеем право изменить";
f = f.replace("$", n);
for(let i = 0; i < n; i++){
if(parseInt(f)){
throw new Error("Cheaters are not allowed");
}
f = eval(f);
}
return parseInt(f);
}
```
— и мы хотим, внеся изменения лишь в литерал строки **f**, сделать так, чтобы функция **factorial** взаправду вычисляла факториал. Вот задача, достойная истинного ситха.
### Что-то это напоминает
Нам нужен код, который возвращает код, который возвращает код… Если забыть про конечную задачу — вычисление факториала, то есть одна хорошо известная штука, которая нам подойдёт. Эта штука называется [квайн](https://ru.wikipedia.org/wiki/%D0%9A%D1%83%D0%B0%D0%B9%D0%BD_(%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%D0%B5)) — программа, которая выводит свой собственный текст.
Про квайны на Хабре написано уже немало, потому я напомню лишь основные принципы квайностроительства. Чтобы сделать простейший квайн, нам нужно:
1. Задать строку, которая содержит весь остальной текст программы.
2. Подставить в эту строку её же саму
3. Позаботиться об экранировании символов и прочих мелочах
4. Вывести получившуюся строку
5. ???
6. PROFIT
Вооружившись этим знанием, можно написать следующий квайн на js (отступы и переносы строки добавлены для удобства читателя):
```
var o = {
q: '\'',
b: '\\',
s: 'var o = {q: _q_b_q_q, b:_q_b_b_q, s: _q_s_q}; console.log(Object.keys(o).reduce(function(a, k){return a.split(_q__q + k).join(o[k])}, o.s))'
};
console.log(Object.keys(o).reduce(function(a, k){return a.split('_' + k).join(o[k])}, o.s));
```
В строке **o.s** содержится весь остальной код, а также специальные подстановочные последовательности, начинающиеся с подчёркивания. Страшное выражение внутри **console.log** заменяет каждую подстановочную последовательность на соответствующее свойство объекта **o**, что обеспечивает выполнение пунктов 2 и 3 хитрого плана по созданию квайна.
**Лирическое отступление**Здесь меня могут поправить: товарищ, это не простейший квайн, а монстр какой-то. Простейший квайн на js выглядит так:
```
!function $(){console.log('!'+$+'()')}()
```
Это правда, но не совсем. Такой квайн считается «читерским», поскольку он из тела функции получает доступ к её же тексту. Это почти то же самое, что прочитать с жёсткого диска файл с исходным кодом программы. Моветон, одним словом.
### Скрещиваем ежа с ужом
Как же сделать так, чтобы наш квази-квайн модифицировал сам себя, а в результате превратился в одно-единственное число? Давайте забудем пока про вычисление факториала и постараемся просто написать строку, которая «схлопывается» через определённое количество eval'ов. Для этого нам понадобится:
* Некий счётчик
* Соответствующая ему подстановочная последовательность
* Место, где этот счётчик модифицируется
* Проверка того, завершён ли обратный отсчёт
Выглядеть это будет примерно так:
```
var f =
"var o = {" +
"q: '\\\''," +
"b: '\\\\'," +
"n: 10," +
"s: 'var o = {q: _q_b_q_q, b:_q_b_b_q, n:_n, s: _q_s_q}; o.n--; " +
"o.n ? Object.keys(o).reduce(function(a, k){return a.split(_q__q + k).join(o[k])}, o.s) : 0;'" +
"};" +
"o.n--;" +
"o.n ? Object.keys(o).reduce(function(a, k){return a.split('_' + k).join(o[k])}, o.s) : 0;"
for(let i = 0; i < 10; i++){
f = eval(f);
console.log(f);
}
```
Обратите внимание на отсутствие **return** внутри строки: в нём нет необходимости, **eval** возвращает значение последнего выражения. Запустив этот код в консоли, можно c благоговением наблюдать, как с каждой итерацией цикла значение n уменьшается на 1. Если кто-то скажет, что для такого эффекта достаточно:
```
f.replace(/n: ([0-9]+)/, (_, n) => "n: " + (n - 1))
```
— то у него нет чувства прекрасного.
После этого подготовительного этапа уже совсем нетрудно написать итоговую версию вычисления факториала. Просто добавляется ещё одна переменная и чуть усложняется строчка с изменением.
```
function factorial(n){
var f = "var o = {" +
"q: '\\\''," +
"b: '\\\\'," +
"r: 1," +
"n: $," +
"s: 'var o = {q: _q_b_q_q, b:_q_b_b_q, r: _r, n:_n, s: _q_s_q}; o.r *= o.n--; " +
"o.n ? Object.keys(o).reduce(function(a, k){return a.split(_q__q + k).join(o[k])}, o.s) : o.r;'" +
"};" +
"o.r *= o.n--;" +
"o.n ? Object.keys(o).reduce(function(a, k){return a.split('_' + k).join(o[k])}, o.s) : o.r;"
f = f.replace("$", n);
for(var i = 0; i < n; i++){
if(parseInt(f)){
throw new Error("Cheaters are not allowed.");
}
f = eval(f);
}
return parseInt(f);
}
```
Теперь вы можете смело идти на собеседование.
### Заключение
С живым кодом можно поиграться [здесь](https://jsfiddle.net/pxa6z1qj/3/). Как и в [прошлой статье](https://habrahabr.ru/post/321078/) из рубрики «Пятничный JS» напоминаю: если вы сделаете что-нибудь подобное на продакшене, то попадёте в ад. С другой стороны, если вы сделаете это на собеседовании, то вам не дадут возможности сделать это на продакшене, и вы не попадёте в ад. Так что делайте это на собеседовании. Спасибо за внимание.
 | https://habr.com/ru/post/327544/ | null | ru | null |
# Stimulus 1.0: скромный JavaScript фреймворк для HTML, который у вас уже есть
*От переводчика: [Давид Хейнемейер Ханссон](https://twitter.com/dhh) написал небольшой текст о том, почему он и его команда Ruby on Rails разработала свой собственный Javascript фреймворк. [Оригинал текста](https://github.com/stimulusjs/stimulus/blob/master/ORIGIN.md) размещен в репозитории нового проекта*
***обновлено 4 февраля**: оригинал статьи был официально опубликован в блоге Basecamp. Обновил ссылку на оригинал и название*
Мы пишем много Javascript в [Basecamp](https://basecamp.com), но мы не используем его для создания "JavaScript-приложений" в современном смысле. Все наши приложения рендерят HTML на стороне сервера, затем мы добавляем вкрапления Javascript, чтобы оживить их.
Это путь [величественного монолита](https://m.signalvnoise.com/the-majestic-monolith-29166d022228). Basecamp работает на множестве платформ, включая нативные мобильные приложения, с единым набором контроллеров, представлений и моделей, созданных под Ruby on Rails. Иметь общий интерфейс, который обновляется из единого места, — это ключ к тому, чтобы маленькая команда работала хорошо, несмотря на множество поддерживаемых платформ.
Это позволяет нам быть продуктивными, как и в старые добрые времена. Возвращение к тем дням, когда единственный программист мог обеспечить немалый прогресс, не застревая в слоях абстракций распределенных систем. Время до того, как каждый стал думать, что святым граалем является ограничение серверной стороны до только лишь производства JSON для Javascript-приложений на клиенте.
Это не значит, что нет смысла в таком подходе для некоторых людей в каком-то месте. Но как основной подход ко многим видам приложений, и конечно, таким как Basecamp, — это в целом регрессия с точки зрения простоты и продуктивности.
Также это не значит что распространие одностраничных JavaScript-приложений не принесло никакой пользы. Они принесли скорость, более динамичные интерфейсы и свободу от перезагрузки страницы целиком.
Мы тоже хотели для Basecamp такого ощущения. Чтобы выглядело так, как будто мы последовали стадному чувству и переписали все с клиентским рендерингом или перешли на полностью нативные приложения на мобильных.
Это желание привело нас к двойному решению: [Turbolinks](https://github.com/turbolinks/turbolinks) и Stimulus.
### Turbolinks наверх, Stimulus вниз
Перед тем как я перейду к Stimulus, нашему скромному JavaScript фреймворку, позвольте мне вкратце пересказать назначение Turbolinks.
Turbolinks происходит от так называемого [pjax](https://github.com/defunkt/jquery-pjax), разработанного в GitHub. Основная идея остается той же. Причиной, по которой полная перезагрузка страницы кажется медленной, не является то, что браузеру тяжело обработать HTML, отправленный с сервера. Браузеры реально хороши и быстры в этом. То, что обычно HTML-контент больше аналогичного JSON тоже неважно (особенно с учетом gzip). Нет, основная причина в том, что CSS и Javascript должны переинициализироваться и примениться к странице заново. Вне зависимости от того, закешированы ли файлы. Это может быть медленным, если у вас приличный размер CSS и JavaScript.
Чтобы обойти эту переинициализацию, Turbolinks держит постоянный процесс, так же как одностраничные приложения делают это. Но, в основном, это процесс невидимый. Он перехватывает ссылки и загружает новые страницы по Ajax. Сервер по-прежнему возвращает полные HTML-документы.
Эта стратегия в одиночку может сделать большинство действий в приложениях реально быстрыми (если сервер способен отвечать за 100-200мс, что возможно с кешированием). Для Basecamp это ускорило переходы по страницам в 3 раза. Это дает приложению то самое чувство отзывчивости и динамичности, которое являлось большей частью доводов "за" одностраничные приложения.
Но Turbolinks это лишь половина истории. Ниже уровнем полной смены страниц лежат мелкие обновления в рамках одной страницы. Показ и скрытие элементов, копирование в буффер обмена, добавление новой записи в todo-лист и другие взаимодействия, которые мы делаем в современных веб-приложениях.
До Stimulus Basecamp использовал смесь разных стилей и паттернов, чтобы добавить эти фичи. Часть кода была просто на jQuery, аналогичная по объему часть была на ванильном JavaScript и несколько большая объекто-ориентированная система. Все они вместе работали через явную обработку событий, опираясь на data-behavior атрибуты.
Было легко добавлять новый код наподобие такого, но это не было комплексным решением и мы имели несколько параллельно существующих самодельных стилей и паттернов. Это усложняло переиспользование кода и обучение новых разработчиков какому-то единому подходу.
### Три основных концепта в Stimulus
Stimulus заворачивает лучшее от этих паттернов в скромный маленький фреймворк, крутящийся вокруг трех основных концептов: контроллеров (controllers), действий (actions) и целей (targets).
Он спроектирован так, чтобы прогрессивно улучшать HTML, для которого он предназначен. Чтобы вы могли взять простой шаблон и посмотреть, какое поведение действует на него. Вот пример:
```
PIN:
Copy to Clipboard
```
Вы можете прочесть это и получить вполне хорошее представление о том, что происходит. Даже без знания чего-нибудь о Stimulus и взгляда на код самого контроллера. Это почти как псевдокод. Это очень отличается от чтения куска HTML, у которого есть внешний JavaScript-файл, вешающий сюда обработчики событий. Он также обеспечивант разделение сущностей, потерянное во многих современных JavaScript-фреймворках.
Как вы можете видеть, Stimulus не беспокоится о создании HTML. Скорее он цепляет себя на текущий HTML-документ. А HTML в большинстве случаев рендерится на сервере либо по загрузке страницы (первый заход), либо через Ajax-запрос, который меняет DOM.
Stimulus сконцентрирован на манипуляциях с существующим HTML-документом. Иногда это означает добавление CSS-класса, который прячет, анимирует или подсвечивает элемент. Иногда это означает перестановку элементов в группах. Иногда означает манипуляции с контентом элемента, например, преобразование UTC-времени, которое кешируется вместе с контентом, в локальное, показываемое пользователю.
В этих случаях вы захотите, чтобы Stimulus создавал новые DOM-элементы, и вы определенно вольны делать это. Может быть, в будущем мы даже добавим немного сахара, чтобы сделать это проще. Но это второстепенные сценарии. Основной фокус на манипуляциях, а не создании элементов.
### Как Stimulus отличается от мейнстримовых JavaScript фреймворков
Это делает Stimulus очень отличающимся от большинства современных JavaScript-фреймворков. Почти все они сосредоточены на превращении JSON в DOM-элементы через какой-то вид языка шаблонов. Большинство использует эти фреймворки чтобы родить пустую страницу, заполненную исключительно элементами созданными через JSON-to-template рендеринг.
Stimulus также отличается в вопросах состояния. Большинство фреймворков имеют способы поддержания состояния внутри JavaScript-объектов, чтобы затем отрендерить HTML, основанный на этом состоянии. Stimulus является полной противоположностью. Состояние хранится в HTML, так что контроллеры могут быть выкинуты между сменой страниц, но они переинициализируются, как только закешированный HTML появляется вновь.
Это значительно отличающаяся парадигма. Я уверен, много опытных JavaScript-разработчиков, кому доводилось работать с современными фреймворками, будут издеваться. Но нет, отстаньте. Если вы счастливы со сложностью и усилиями, которые требуются чтобы поддерживать приложение в водовороте, скажем, React + Redux, то Turbolinks + Stimulus не понравятся вам.
Но с другой стороны, если у вас есть чувство, штука над которой вы работаете не требует такого уровня сложности и разделения приложений, которые подразумеваются в современых технологиях, то вы скорее всего обретете спасение в нашем подходе.
### Stimulus и похожие идеи из реального мира
В Basecamp мы использовали эту архитектуру на нескольих версиях Basecamp и других приложений в течение нескольких лет. GitHub использовал похожий подход с замечательным эффектом. Это не просто альтернатива мейнстримовому пониманию, как выглядит современное веб-приложение, но и удивительно конкурентноспособная.
На самом деле это похоже на тот секретный ингредиент, который мы имели в Basecamp, когда делали Ruby on Rails. Чувство, что современные популярные подходы чрезмерно непрямолинейны, так что мы можем делать больше с меньшими усилиями.
Более того, вам даже не нужно выбирать. Stimulus и Turbolinks прекрасно работают в соединении с другими более тяжелыми подходами. Если 80% вашего приложения не вписывается в сложную установку, попробуйте нашу двухкомпонентную сборку для этого. Затем разверните тяжелую технику для той части приложения, где вы реально выиграете от этого.
В Basecamp мы делаем используем несколько более сложных подходов, где есть необходимость. Наша функциональность календарей использует клиентский рендеринг. Наш текстовый редактор, Trix, это полностью собранный обработчик текстов, который не имел бы смысла как пачка контроллеров Stimulus.
Этот набор альтернативных фреймворков про избавление от тяжестей насколько это возможно. Чтобы остаться в рамках парадигмы "запрос-ответ" для большинства взаимодействий, которые прекрасно работают с этой простой моделью. Затем обращаемся к дорогим инструментам, где есть смысл для достижения максимального эффекта.
Прежде всего, это набор инструментов для маленьких команд, которые хотят состязаться в охвате с большими командами, использующими более трудоемкие, мейнстримовые подходы.
Дайте ему шанс!
*[Ссылка на GiHub проекта](https://github.com/stimulusjs/stimulus)* | https://habr.com/ru/post/346132/ | null | ru | null |
# От Java 8 до Java 15 за 10 минут
Данный пост является [переводом статьи](https://medium.com/swlh/from-java-8-to-java-15-in-ten-minutes-f42d422a581e) с некоторыми уточнениями.
В этой статье я хочу рассмотреть основные возможности, добавленные в Java начиная с 7 версии по 15. Я затрону как минимум одно крупное улучшение для каждой версии, вплоть до Java 15, которая, кстати, была выпущена осенью 2020 года.
Java теперь поддерживает **лямбда выражения**, **функциональное программирование**, объявление переменных через **var**, **неизменяемые коллекции с простыми конструкторами** и "многострочные" строки (**Multi-line Strings**). Кроме того, появились новые интересные экспериментальные возможности, такие как дата классы (**record**) и **sealed** классы. Наконец, я расскажу о **Java REPL** (очень удобная вещь для быстрых экспериментов). Итак, начнем.
Функциональное программирование (Java 8)
----------------------------------------
В Java 8 функциональное программирование и лямбды были добавлены в качестве новых возможностей языка. Суть простая: данные разбиваются на шаги, каждый из которых принимает некоторый входной сигнал и преобразует его в новый выходной сигнал. Функциональное программирование можно использовать с потоками данных( `Stream)` и null-safe данными (`Optional)`. Пример рассмотрим ниже.
Stream (Java 8)
---------------
Очень часто во время написания программы приходится работать с масивами и листами. А именно с их преобразованием, фильтрацией, агрегациями и т.д. До появления Java 8 для подобных операций приходилось использовать цикл `for`, но теперь вы можете использовать потоки следующим образом:
```
Stream.of("hello", "great")
.map(s -> s + " world")
.forEach(System.out::println);
> hello world
> great world
```
Функция `map` принимает на вход лямбду, которая будет применена ко всем элементам потока. Потоки могут работать с `List`, `Set` и `Map` (через преобразование). Благодаря потокам вы можете избавиться от практически всех циклов в вашем коде!
Optional (Java 8)
-----------------
Другой распространенной проблемой в Java были **Null Pointer Exceptions**. Для решения данной проблемы появилась `Optional`. По сути является оберткой для объекта, который может быть `null`. Применение обновлений к `Optional` может быть выполнено функциональным способом:
```
Optional.of(new Random().nextInt(10))
.filter(i -> i % 2 == 0)
.map(i -> "number is even: " + i)
.ifPresent(System.out::println);
> number is even: 6
```
В приведенном выше фрагменте мы создаем случайное число, заворачиваем его внутрь объекта `Optional`, фильтруем и оставляем только четные числа и в конце, если объект не является null, выводим его на экран.
JShell (Java 9)
---------------
Наконец у нас есть REPL для Java, и имя ему - **JShell**! В двух слова: JShell позволяет экспериментировать с фрагментами Java без написания и компиляции полного класса. Вместо этого вы можете выполнять по одной команде за раз и сразу видеть результат. Вот простой пример:
```
$ /bin/jshell
jshell> System.out.println("hello world")
hello world
```
Люди, знакомые с интерпретируемыми языками (JavaScript или Python), уже давно имеют возможность пользоваться REPL, но до сих пор эта функция отсутствовала в Java. JShell позволяет определять переменные, а также более сложные сущности, такие как многострочные функции, классы и циклы. Более того, JShell поддерживает автозавершение, что очень удобно, если вы не знаете точных методов, предлагаемых данным Java классом .
Фабричные методы для неизменяемых коллекций (Java 9)
----------------------------------------------------
Простая инициализация списков долгое время отсутствовала в Java, но теперь эти времена прошли. Раньше вам приходилось делать что-то вроде этого:
```
jshell> List list = Arrays.asList(1, 2, 3, 4)
list ==> [1, 2, 3, 4]
```
Теперь это упрощается следующим образом:
```
jshell> List list = List.of(1, 2, 3, 4)
b ==> [1, 2, 3, 4]
```
Метод `of(...)` существует для `List`, `Set` и `Map`. Все они создают неизменяемый объект всего одной простой строчкой кода.
Ключевое слова var (Java 10)
----------------------------
В Java 10 появилось новое ключевое слово `var`, которое позволяет не указывать тип переменной.
```
jshell> var x = new HashSet()
x ==> []
jshell> x.add("apple")
$1 ==> true
```
В приведенном выше фрагменте компилятор может определить тип `x` как `HashSet`. Эта возможность помогает сократить уж очень длинные именна переменных и улучшить читабельность. Однако здесь есть некоторые ограничения: вы можете использовать `var` только внутри тела метода, а компилятор определит тип во время компиляции, так что все по-прежнему статически типизировано.
Single Source File Launch (Java 11)
-----------------------------------
Раньше, при написании простой программы в один файл, приходилось сначала компилировать файл с помощью javac, а затем запускать его с помощью java. Начиная с 11 версии можно выполнить оба действия одной командой. Сначала определяетм свой единственный исходный файл `Main.java`
```
public class Main {
public static void main(String[] args) {
System.out.println("hello world");
}
}
```
Компилируем и запускаем
```
$ java ./Main.java
hello world
```
Для простых программ или экспериментов, состоящих всего из одного класса, эта функция запуска одиночных исходных файлов достаточно полезна.
Switch выражения (Java 12)
--------------------------
Java 12 принесла нам `Switch`выражения . Вот краткая демонстрация того, чем выражение отличается от старого варианта.
Старый оператор switch:
```
jshell> var i = 3
jshell> String s;
jshell> switch(i) {
...> case 1: s = "one"; break;
...> case 2: s = "two"; break;
...> case 3: s = "three"; break;
...> default: s = "unknown number";
...> }
jshell> s
s ==> "three"
```
Новый же способ позволяет делать следующее:
```
jshell> var i = 3;
jshell> var x = switch(i) {
...> case 1 -> "one";
...> case 2 -> "two";
...> case 3 -> "three";
...> default -> "unknown number";
...> };
x ==> "three"
```
Аналогичный оператор уже долгое время существует в Scala, Kotlin. Java решила не отставать. Следует отметить несколько моментов:
1. вместо двойных точек используются стрелки `->`.
2. нет необходимости в `break`
3. `default`может быть опущен, когда рассмотрены все возможные случаи.
4. Чтобы включить эту возможность в Java 12, используйте `--enable-preview --source 12`
Multi-line Strings (Java 13)
----------------------------
Приходилось ли вам когда-нибудь определять длинную многоуровневую строку, например, JSON или XML? До сих пор вы, вероятно, сжимали все в одну строку и использовали символы новой строки `\n`, что делает ее гораздо менее читабельной. Начиная с 13 версии можно делать так:
```
public class Main {
public static void main(String [] args) {
var s = """
{
"recipe": "watermelon smoothie",
"duration": "10 mins",
"items": ["watermelon", "lemon", "parsley"]
}""";
System.out.println(s);
}
}
```
Запускаем и получаем:
```
java --enable-preview --source 13 Main.java
{
"recipe": "watermelon smoothie",
"duration": "10 mins",
"items": ["watermelon", "lemon", "parsley"]
}
```
Все пробелы и табуляции сохранены.
Дата классы: record (Java 14)
-----------------------------
Из всех новых возможностей, описанных в этой статье, это, пожалуй, та, которой я рад больше всего: наконец-то в Java появились дата классы! Объявляются с помощью ключевого слова `record` и имеют автоматические геттеры, конструктор, метод `equals()` и т.д. Короче говоря, вы можете избавиться от огромного куска шаблонного кода!
```
jshell> record Employee (String name, int age, String department) {}
| created record Employee
jshell> var x = new Employee("Anne", 25, "Legal");
x ==> Employee[name=Anne, age=25, department=Legal]
jshell> x.name()
$2 ==> "Anne"
```
Scala имеет аналогичную возможность с `case classes`, а Kotlin - с `data classes`. В Java многие разработчики до сих пор использовали `Lombok`, который предлагал практически все те возможности, которые сейчас вдохновляют записи для Java 14.
instanceof без приведения типа (Java 14)
----------------------------------------
Предыдущие версии Java уже содержали ключевое слово `instanceof`:
```
Object obj = new String("hello");
if (obj instanceof String) {
System.out.println("String length: " + ((String)obj).length());
}
```
Но минусом является то, что даже если мы убедились в типе - нам все равно необходимо его явное приведение. Теперь, в Java 14, компилятор достаточно умен, чтобы автоматически определить тип после проверки `instanceof`:
```
Object obj = new String("hello");
if (obj instanceof String mystr) {
System.out.println("String length: " + mystr.length());
}
```
Sealed classes (Java 15)
------------------------
С помощью ключевого слова `sealed` вы можете ограничить, какие классы могут расширять класс или интерфейс. Вот пример:
```
public sealed interface Fruit permits Apple, Pear {
String getName();
}
public final class Apple implements Fruit {
public String getName() { return "Apple"; }
}
public final class Pear implements Fruit {
public String getName() { return "Pear"; }
}
```
Бонус: Обновленные условия лицензирования, начиная с Java 8
-----------------------------------------------------------
Последняя тема для этой статьи: лицензирование. Большинство из вас слышали, что Oracle прекратила обновления для Java 8 (для бесплатной коммерческой версии). Итак, вот ваши варианты:
1. Использовать более новую версию Oracle JDK (Oracle предлагает бесплатные обновления безопасности только в течение 6 месяцев после каждого выпуска).
2. Использовать старую версию JDK на свой страх и риск
3. Использовать старую версию OpenJDK Java, которая все еще получает обновления безопасности от сообщества разработчиков открытого кода или сторонних производителей.
4. Платить Oracle за премьер-поддержку (например, Java 8: поддержка до 2030 года). Ниже приведены предварительные сроки поддержки Oracle для каждого JDK:
[miro.medium.com](https://miro.medium.com/max/625/1*CMcZQPLx5_7hrXqePmLPKw.png)На новую модель лицензирования Oracle влияет новый цикл выпуска релизов: будет происходить обновление Java каждые 6 месяцев. Данный способ помогает Oracle быстрее совершенствовать язык, быстрее получать обратную связь через экспериментальные функции и догонять более современные языки, такие как Scala, Kotlin и Python. | https://habr.com/ru/post/589605/ | null | ru | null |
# Подробное руководство по инверсии зависимостей. Часть 1
Инверсия зависимостей - один из принципов SOLID, который лежит в основе построения гексагональной архитектуры приложения. Существует множество статей, которые раскрывают суть принципа и объясняют как его применять. И, возможно, читатель уже знаком с ними. Но в рамках данной статьи будет продемонстрирован подробный разбор "тактических" приемов для успешного использования инверсии зависимостей и, возможно, в этом смысле даже искушенный читатель сможет найти для себя что-то новое. Примеры представлены на языке программирования Java с соответствующим окружением, но при этом для чтения достаточно понимания похожих языков программирования.
### 0. Проблема взаимодействия изолируемого модуля с инфраструктурным
Пусть необходимо автоматизировать процесс, который позволяет создавать от пользователя заказы на покупку товара. И в рамках этого процесса необходимо проверять баланс пользователя. Баланс должен быть больше, чем стоимость товара.
В начале рассмотрим классы-данных, соответствующие процессу:
`CreateOrderRequest` - класс-данных запроса, который отправляет пользователь для создания заказа на товар
```
package aa0ndrey.dependency_inversion_guide.step_0.core.order;
public class CreateOrderRequest {
private UUID userId;
private UUID productId;
}
```
`User` - класс-данных пользователя
```
package aa0ndrey.dependency_inversion_guide.step_0.core.user;
public class User {
private UUID id;
private String name;
private int balance;
}
```
`Product` - класс-данных товара
```
package aa0ndrey.dependency_inversion_guide.step_0.core.product;
public class Product {
private UUID id;
private String title;
private int price;
}
```
`Order` - класс-данных заказа
```
package aa0ndrey.dependency_inversion_guide.step_0.core.order;
public class Order {
private UUID id;
private UUID userId;
private UUID productId;
}
```
Для работы с базой данных понадобятся классы репозиториев, которые позволят сохранять и получать данные:
```
package aa0ndrey.dependency_inversion_guide.step_0.postgres.user;
public class UserRepositoryImpl {
public User find(UUID id) {
//реализация select * from user where user.id = ?
}
}
```
```
package aa0ndrey.dependency_inversion_guide.step_0.postgres.product;
public class ProductRepositoryImpl {
public Product find(UUID id) {
//реализация select * from product where product.id = ?
}
}
```
```
package aa0ndrey.dependency_inversion_guide.step_0.postgres.order;
public class OrderRepositoryImpl {
public void create(Order order) {
//реализация insert into order (id, user_id, product_id) values (?, ?, ?)
}
}
```
И в заключении рассмотрим класс сервиса, который будет содержать в себе основную логику, описанную ранее
```
package aa0ndrey.dependency_inversion_guide.step_0.core.order;
import aa0ndrey.dependency_inversion_guide.step_0.postgres.order.OrderRepositoryImpl;
import aa0ndrey.dependency_inversion_guide.step_0.postgres.product.ProductRepositoryImpl;
import aa0ndrey.dependency_inversion_guide.step_0.postgres.user.UserRepositoryImpl;
public class OrderService {
private final UserRepositoryImpl userRepository;
private final ProductRepositoryImpl productRepository;
private final OrderRepositoryImpl orderRepository;
public void create(CreateOrderRequest request) {
var user = userRepository.find(request.getUserId());
var product = productRepository.find(request.getProductId());
if (user.getBalance() < product.getPrice()) {
throw new RuntimeException("Недостаточно средств");
}
var order = new Order(UUID.randomUUID(), user.getId(), product.getId());
orderRepository.create(order);
}
}
```
Теперь предположим, что необходимо разложить представленные классы по двум модулям: core и postgres. Ожидается, что модуль core будет содержать в себе основную логику приложения, которую необходимо изолировать от инфраструктурных зависимостей. В свою очередь в postgres модуле ожидается, что будет размещен весь код, связанный с работой с базой данных postgres.
Важным нюансом является то, что postgres модуль должен зависеть от core модуля, а core модуль **не должен** зависеть от postgres модуля. Postgres и core модули будут собраны с помощью maven как отдельные maven модули. [Maven](https://maven.apache.org/what-is-maven.html) - это инструмент, предназначенный для сборки проекта и управления зависимостями в проекте. Ниже будут представлены конфигурационные pom.xml файлы для core и postgres модуля.
Файл pom.xml, содержащий конфигурацию core модуля
```
xml version="1.0" encoding="UTF-8"?
4.0.0
aa0ndrey
dependency-inversion-guide-step-0-core
1.0-SNAPSHOT
```
Файл pom.xml, содержащий конфигурацию postgres модуля
```
xml version="1.0" encoding="UTF-8"?
4.0.0
aa0ndrey
dependency-inversion-guide-step-0-postgres
1.0-SNAPSHOT
aa0ndrey
dependency-inversion-guide-step-0-core
1.0-SNAPSHOT
```
Если вы не знакомы с maven, то важным, на что необходимо обратить внимание, является блок . В postgres модуле есть ссылка на core модуль. А в core модуле нет блока совсем, что в частности означает что нет зависимости на модуль postgres. Важно отметить, что maven не позволит скомпилировать модуль, ссылающийся на код модуля, которого нет в зависимостях. Также в maven запрещены циклические зависимости, то есть, если postgres модуль зависит от core модуля, то core модуль не может зависеть от postgres модуля.
В файле конфигурации pom.xml для postgres модуля есть комментарий здесь и далее комментарии будут использованы, в том числе для указания ссылок на код. При этом ссылка на код оформляется в блоке кода с помощью круглых скобок, внутри которых указана цифра. На эту цифру в основном тексте будет ссылка. Например, так: в файле pom.xml для postgres модуля в `(1)` указана зависимость на core модуль.
Теперь разложим рассмотренные ранее классы по модулям core и postgres.
Файловая структура core модуля
```
├── order
│ ├── CreateOrderRequest.java
│ ├── Order.java
│ └── OrderService.java
├── product
│ └── Product.java
└── user
└── User.java
```
Файловая структура postgres модуля
```
├── order
│ └── OrderRepositoryImpl.java
├── product
│ └── ProductRepositoryImpl.java
└── user
└── UserRepositoryImpl.java
```
На самом деле как разложены классы внутри модулей, можно было понять ранее. В примерах кода всюду указаны пакеты `package`. При именовании пакетов после `aa0ndrey.dependency_inversion_guide` указывается номер рассматриваемого примера, в данном случае `step-0`, и затем указывается имя модуля, в котором расположен класс. Например, класс, с указанным `package aa0ndrey.dependency_inversion_guide.step_0.core.order`, находится в модуле core.
Если попробовать собрать эти два модуля, то при сборке модуля core возникнет ошибка, связанная с тем, что в классе `OrderService` используются `OrderRepositoryImpl`, `ProductRepositoryImpl` и `UserRepositoryImpl`, которых нет в модуле core и в подключаемых зависимостях, потому что классы этих репозиториев находятся в модуле postgres, на который невозможно и, что самое главное **не нужно** создавать зависимость в модуле core. И тут становится понятна проблема, которая возникает при желании изолировать модуль от другого инфраструктурного модуля, из которого по коду необходимо получать и в который необходимо отправлять данные. Так как же это сделать? Решение будет рассмотрено в следующем разделе.
### 1. Инверсия зависимостей с помощью интерфейсов
Чтобы решить проблему, обозначенную в предыдущем разделе, достаточно в core модуле создать интерфейсы для репозиториев, а сами репозитории из postgres модуля заставить реализовывать указанные интерфейсы.
Добавим интерфейсы репозиториев в core модуль
```
package aa0ndrey.dependency_inversion_guide.step_1.core.user;
public interface UserRepository {
User find(UUID id);
}
```
```
package aa0ndrey.dependency_inversion_guide.step_1.core.product;
public interface ProductRepository {
Product find(UUID id);
}
```
```
package aa0ndrey.dependency_inversion_guide.step_1.core.order;
public interface OrderRepository {
void create(Order order);
}
```
Затем укажем реализацию этих репозиториев в postgres модуле
```
package aa0ndrey.dependency_inversion_guide.step_1.postgres.user;
public class UserRepositoryImpl implements UserRepository {
@Override
public User find(UUID id) {
//реализация select * from user where user.id = ?
}
}
```
```
package aa0ndrey.dependency_inversion_guide.step_1.postgres.product;
public class ProductRepositoryImpl implements ProductRepository {
@Override
public Product find(UUID id) {
//реализация select * from product where product.id = ?
}
}
```
```
package aa0ndrey.dependency_inversion_guide.step_1.postgres.order;
public class OrderRepositoryImpl implements OrderRepository {
@Override
public void create(Order order) {
//реализация insert into order (id, user_id, product_id) values (?, ?, ?)
}
}
```
И в заключении перепишем логику в OrderService так, чтобы он начал использовать вместо UserRepositoryImpl, ProductRepositoryImpl и OrderRepositoryImpl их интерфейсы, которые расположены в модуле core.
```
package aa0ndrey.dependency_inversion_guide.step_1.core.order;
public class OrderService {
private final UserRepository userRepository;
private final ProductRepository productRepository;
private final OrderRepository orderRepository;
public void create(CreateOrderRequest request) {
var user = userRepository.find(request.getUserId());
var product = productRepository.find(request.getProductId());
if (user.getBalance() < product.getPrice()) {
throw new RuntimeException("Недостаточно средств");
}
var order = new Order(UUID.randomUUID(), user.getId(), product.getId());
orderRepository.create(order);
}
}
```
Файловая структура core модуля
```
├── order
│ ├── CreateOrderRequest.java
│ ├── Order.java
│ ├── OrderRepository.java (1)
│ └── OrderService.java
├── product
│ ├── Product.java
│ └── ProductRepository.java (2)
└── user
├── User.java
└── UserRepository.java (3)
```
Файловая структура postgres модуля
```
├── order
│ └── OrderRepositoryImpl.java (4)
├── product
│ └── ProductRepositoryImpl.java (5)
└── user
└── UserRepositoryImpl.java (6)
```
Этими изменениями удалось достигнуть того, что core модуль перестал использовать какие-либо классы из postgres модуля. И теперь оба модуля могут быть скомпилированы. Вместо использования прямых зависимостей на классы из инфраструктурного модуля (postgres) `(4)`, `(5)`, `(6)` можно создавать интерфейсы `(1)`, `(2)`, `(3)` на эти классы в изолируемом модуле (core), которые должны быть реализованы в инфраструктурном модуле (postgres). При этом нет никаких проблем в том, что классы из инфраструктурного модуля (postgres) зависят от классов из изолируемого модуля (core).
```
┌────────────────┐
│ Core │
│┌──────────────┐│
││UserRepository│◄───────┐
│└──────────────┘│ │
└────────────────┘ │
┌────────────────────┐ │
│ Postgres │ │
│┌──────────────────┐│ │
││UserRepositoryImpl│┼─────┘
│└──────────────────┘│
└────────────────────┘
```
Важно понимать и идейную составляющую данного приема. Она заключается в том, что изолируемый модуль (core) предъявляет требования к реализации с помощью интерфейса. То есть "главным" в этом отношении является интерфейс, под который подстраивается реализация.
Возможно, на этом моменте другие руководства по инверсии зависимостей подходят к завершению. Но в рамках данного руководства это только начало.
### 2. Проблема использования интерфейсов, раскрывающих инфраструктуру
Прежде чем перейти к рассмотрению следующей проблемы, стоит отметить, что здесь и далее большинство приведенных примеров очень сильно упрощены, особенно с точки зрения технической реализации. Это сделано намерено для того, чтобы не засорят ненужными деталями рассматриваемые примеры.
Предположим теперь, что есть необходимость управлять транзакциями. И пусть для этого достаточно уметь открывать и фиксировать транзакцию. И также пусть необходимо открыть транзакцию перед получением любых данных из базы данных, а зафиксировать транзакцию необходимо только после последнего обращения к базе данных.
Тогда можно в модуле core создать интерфейс, который позволяет управлять транзакциями.
```
package aa0ndrey.dependency_inversion_guide.step_2.core.transaction_manager;
public interface TransactionManager {
void begin();
void commit();
}
```
В свою очередь реализацию этого интерфейса стоит поместить в модуль postgres
```
package aa0ndrey.dependency_inversion_guide.step_2.postgres.transaction_manager;
public class TransactionManagerImpl implements TransactionManager {
public void begin() {
//реализация начала транзакции
}
public void commit() {
//реализация фиксации транзакции
}
}
```
И теперь появляется возможность добавить использование интерфейса `TransactionManager` в класс с основной логикой `OrderService`.
```
package aa0ndrey.dependency_inversion_guide.step_2.core.order;
public class OrderService {
private final UserRepository userRepository;
private final ProductRepository productRepository;
private final OrderRepository orderRepository;
private final TransactionManager transactionManager;
public void create(CreateOrderRequest request) {
transactionManager.begin(); //(1)
var user = userRepository.find(request.getUserId());
var product = productRepository.find(request.getProductId());
if (user.getBalance() < product.getPrice()) {
throw new RuntimeException("Недостаточно средств");
}
var order = new Order(UUID.randomUUID(), user.getId(), product.getId());
orderRepository.create(order);
transactionManager.commit(); //(2)
}
}
```
В классе `OrderService` в `(1)` транзакция открывается, а в `(2)` происходит ее фиксация. Вообще говоря, код из `(2)` нужно было бы написать в конструкции try-catch-finally, также при этом используя rollback в случае исключения, но напомню, что примеры намерено упрощены. А еще лучше было бы использовать аннотацию `@Transactional` из какого-либо фреймворка, но это не является предметом для обсуждения в данной статье. Использование упрощенной версии интерфейса `TransactionManager` мотивировано тем, что он хорошо известен, по крайней мере Java-разработчикам, и с его участием удобно рассматривать большинство примеров.
Проблема данного решения заключается в том, что управление транзакциями достаточно специфичный механизм по отношению к основной логике. Несмотря на то, что детали реализации скрываются с помощью интерфейса, сам интерфейс рассказывает о каких-то инфраструктурных особенностях. По этой причине наличие такого интерфейса крайне нежелательно.
Тут важно понимать мотивацию, зачем необходимо избегать подобных интерфейсов в построении изолируемого модуля (core). Представим, что есть какая-то конкретная библиотека, например, для работы с mysql. Тогда можно взять и создать на каждый класс для этой библиотеки интерфейс в изолируемом модуле и использовать эти интерфейсы в основной логике внутри изолируемого модуля (core). Но в этом случае потеряются все преимущества от того, что используются интерфейсы.
Например, одной из причин для изолирования модуля от инфраструктуры является обобщение и упрощение использования сложных инфраструктурных модулей для того, чтобы не утопать в их деталях при написании основного кода. Но так как интерфейсы один в один будут повторять классы библиотеки, то в этом смысле не получится добиться какого-либо упрощения.
Также интерфейсы используются для того, чтобы иметь потенциальную возможность подменять решения из группы альтернатив. Но это будет возможно только, если альтернативу можно будет адаптировать к уже существующим интерфейсам. А если они являются точной копией другой используемой библиотеки, то, скорее всего, пропадает всякая возможность замены.
Несмотря на то, что для представленного интерфейса `TransactionManager` можно было бы создать реализацию для большого множества баз данных, данный интерфейс раскрывает детали реализации взаимодействия с базой данных и в этом смысле является чужеродным по отношению к основной логике в изолируемом модуле (core). И поэтому от него необходимо избавиться.
### 3. Инверсия зависимостей с помощью шаблона проектирования наблюдатель
В данном разделе будет предложено решение проблемы из предыдущего раздела. Вместо того чтобы использовать интерфейсы, раскрывающие инфраструктурные особенности, можно использовать шаблон проектирования наблюдатель (observer). Идея заключается в том, чтобы для класса `OrderService` создать общий интерфейс для наблюдателей, которые смогут обрабатывать общие события. При этом сами события будут отправляться в те моменты, когда должен был быть вызван нежелательный раскрывающий детали интерфейс (в данном случае `TransactionManager`).
Создадим для начала классы событий: `CreateOrderEvents.Start` и `CreateOrderEvents.End`
```
package aa0ndrey.dependency_inversion_guide.step_3.core.order;
public class CreateOrderEvents {
public static class Start {
private CreateOrderRequest request; //(1)
}
public static class End {
private CreateOrderRequest request; //(2)
private User user; //(3)
private Product product; //(4)
private Order order; //(5)
}
}
```
При выборе названия события можно отталкиваться от названия места по ходу выполнения основной логики в OrderService. Например, событие `CreateOrderEvents.Start` будет отправляться в самом начале метода при создании заказа. Поэтому оно называется Start. В свою очередь событие `CreateOrderEvents.End` отправляется в конце метода и поэтому оно называется End. Если бы понадобилось отправлять событие перед проверкой баланса пользователя, то можно было бы назвать событие BeforeCheckUserBalance.
Тут важным является не дать название событием так, чтобы по названию можно было бы понять, какая обработка ожидает эти события. Иначе тем самым будут раскрыты детали реализации. Например, такие названия событий не подойдут: `OnTransactionBegin` и `OnTransactionCommit`.
Также стоит отметить, что события необходимо наполнить не конкретными данными, которые будут необходимы конкретному наблюдателю. А общими данными, которые доступны в момент отправки события. Поэтому для события `CreateOrderEvents.Start` указывается только поле с запросом `(1)`, так как только оно доступно в начале метода. В свою очередь в конце выполнения метода доступны: исходный запрос `(2)`, полученный пользователь `(3)`, полученный продукт `(4)`, а также созданный заказ `(5)`.
Это все делается для того, чтобы потенциально наблюдателем этих событий мог быть какой угодно другой инфраструктурный модуль. Причем это может быть необязательно возможная альтернатива текущему модулю. Например, одно и то же событие может обрабатываться модулем базы данных для того, чтобы начать транзакцию, и модулем HTTP клиента, для того, чтобы осуществить получение токена авторизации.
Далее можно создать общий интерфейс для наблюдателя:
```
package aa0ndrey.dependency_inversion_guide.step_3.core.order;
public interface CreateOrderObserver {
void onStart(CreateOrderEvents.Start event);
void onEnd(CreateOrderEvents.End event);
}
```
И затем можно изменить класс `OrderService`
```
package aa0ndrey.dependency_inversion_guide.step_3.core.order;
public class OrderService {
private final UserRepository userRepository;
private final ProductRepository productRepository;
private final OrderRepository orderRepository;
private final List observers; //(6)
public void create(CreateOrderRequest request) {
var startEvent = new CreateOrderEvents.Start(request); //(7)
observers.forEach(observer -> observer.onStart(startEvent)); //(8)
var user = userRepository.find(request.getUserId());
var product = productRepository.find(request.getProductId());
if (user.getBalance() < product.getPrice()) {
throw new RuntimeException("Недостаточно средств");
}
var order = new Order(UUID.randomUUID(), user.getId(), product.getId());
orderRepository.create(order);
var endEvent = new CreateOrderEvents.End( //(9)
request,
user,
product,
order
);
observers.forEach(observer -> observer.onEnd(endEvent)); //(10)
}
}
```
На что стоит обратить внимание? Было удалено всякое использование интерфейса `TransactionManager` более того, он был удален из модуля core. Вместо него теперь используется `CreateOrderObserver` в `(6)`. Для этого в начале метода создаётся событие `CreateOrderEvents.Start` в `(7)` и затем оно отправляется наблюдателям в `(8)`. Аналогично в конце метода создаётся событие `CreateOrderEvents.End` в `(9)` и отправляется в `(10)`.
И затем можно добавить реализацию наблюдателя в postgres модуль
```
package aa0ndrey.dependency_inversion_guide.step_3.postgres.order;
public class CreateOrderObserverImpl implements CreateOrderObserver {
private final TransactionManagerImpl transactionManagerImpl;
@Override
public void onStart(CreateOrderEvents.Start event) {
transactionManagerImpl.begin();
}
@Override
public void onEnd(CreateOrderEvents.End event) {
transactionManagerImpl.commit();
}
}
```
Стоит обратить внимание на то, что внутри уже реализации наблюдателя происходит обращение к `TransactionManagerImpl` для того, чтобы решить задачу по управлению транзакциями.
Теперь приведём текущую файловую структуру модуля core
```
├── order
│ ├── CreateOrderEvents.java
│ ├── CreateOrderRequest.java
│ ├── CreateOrderObserver.java
│ ├── Order.java
│ ├── OrderRepository.java
│ └── OrderService.java
├── product
│ ├── Product.java
│ └── ProductRepository.java
└── user
├── User.java
└── UserRepository.java
```
И модуля postgres
```
├── order
│ ├── CreateOrderObserverImpl.java
│ └── OrderRepositoryImpl.java
├── product
│ └── ProductRepositoryImpl.java
├── transaction_manager
│ └── TransactionManagerImpl.java
└── user
└── UserRepositoryImpl.java
```
Чего в итоге удалось добиться? Удалось полностью избавиться от интерфейса `TranasactionManager`, который частично раскрывал детали реализации инфраструктурного модуля (postgres). И удалось это сделать за счет добавления отправки событий. Стоит отметить, что таких отправок событий можно добавить сколько угодно по ходу метода. И тем самым у разработчика появляется общий механизм для расширения основной логики находящейся в (core) модуле. И с помощью этого можно внедрять произвольную логику, находящуюся в инфраструктурном модуле (postgres). Важно отметить, что такие отправки событий можно использовать не обязательно только в начале и конце метода, но и где-то посередине. Эту особенность стоит запомнить, так как в будущих разделах, когда будет рассмотрен промежуточный модуль (application), будут предложены другие решения, которые не позволяют внедрить какое-либо расширение посередине метода.
Интересно также отметить то, что на самом деле данное решение является небольшой модификацией стандартной инверсии зависимостей. В стандартном решении используется конкретный интерфейс, например, `TransactionManager` и вызываются его конкретные методы `begin` и `commit`, и передаются конкретные данные, но для методов `begin` и `commit` их просто нет. В решении через использование шаблона наблюдатель, интерфейс обобщается в смысле названия и в данном случае это `CreateOrderObserver`. И также обобщаются его методы и передаваемые данные. Методы становятся `onStart` и `onEnd`, а передаваемые данные, то есть события, как это было показано ранее, содержат общие для всех наблюдателей поля.
### 4. Использование контекста вместо событий
Предположим теперь, что реализация TransactionManagerImpl изменилась.
```
package aa0ndrey.dependency_inversion_guide.step_4.postgres.transaction_manager;
public class TransactionManagerImpl {
public long begin() { //(1)
//реализация начала транзакции
}
public void commit(long transactionId) { //(2)
//реализация фиксации транзакции
}
}
```
Теперь в `(1)` метод `begin` возвращает id текущей транзакции. В свою очередь, в `(2)` метод `commit` принимает id транзакции, которую необходимо зафиксировать. То есть теперь появилась потребность передать данные от одного инфраструктурного вызова к другому. Но как это сделать, если теперь эти вызовы осуществляются изолировано в рамках обработки событий по шаблону проектирования наблюдатель? Если проблема не стала ясна, то для понимания рекомендуется вернуться к классам `OrderService` и `CreateOrderObserverImpl` из предыдущего раздела 3 и попытаться представить решение, которое позволит передать id транзакции от метода `begin` в метод `commit`.
Стоит отметить, что подобная проблема не возникла, если бы не было принято решение отказаться от интерфейса `TransactionManager`. Правда, в этом случае в методе с основной логикой в изолируемом модуле (core) начала бы появляться дополнительная логика по работе с транзакциями. То есть основной код начал бы сильнее обрастать инфраструктурными деталями, так как в него была бы добавлена еще и логика по запоминанию id транзакции, чтобы затем использовать этот id для фиксации транзакции.
Как же решить возникшую проблему? Для этого можно воспользоваться контекстом. Контекст - это класс-данных, который содержит необходимую информацию о выполняющемся процессе. Ниже приведен пример контекста, который соответствует процессу создания заказа.
```
package aa0ndrey.dependency_inversion_guide.step_4.core.order;
public class CreateOrderContext {
private CreateOrderRequest request; //(3)
private User user; //(4)
private Product product; //(5)
private Order createdOrder; //(6)
private Map data; //(7)
}
```
`CreateOrderContext` содержит в `(3)` поле исходного запроса, в `(4)` найденного пользователя, в `(5)` найденный продукт, в `(6)` созданный заказ. Состав полей очень похож на событие `CreateOrderEvents.End` за исключением поля `(7)`. Это поле как раз сейчас и понадобится.
Идея в том, что все поля, которые известны основному процессу, находящемуся в изолируемом модуле (core), имеют строгий формат в контексте с конкретными именами, потому что они известны этому процессу. В свою очередь поле `data` в `(7)` представлено ассоциативным массивом, где в качестве ключа используется строка, а в качестве значения используется Object, то есть самый общий тип данных в Java, наследниками которого являются все остальные классы. Это позволяет в поле `data` записывать совершенно произвольные данные в динамическом формате не фиксируя структуру. А это значит, что записывая туда какие-либо инфраструктурные данные, не создается зависимости в основном коде от инфраструктуры, до тех пор пока в нем, в основном коде, не используется поле `data`, что делать не рекомендуется.
Теперь изменим интерфейс `CreateOrderObserver` таким образом, чтобы вместо событий методы принимали контекст.
```
package aa0ndrey.dependency_inversion_guide.step_4.core.order;
public interface CreateOrderObserver {
void onStart(CreateOrderContext context);
void onEnd(CreateOrderContext context);
}
```
На самом деле можно считать, что события существуют, только они все одинаковые и имеют лишь одно поле и это поле всегда контекст. Поэтому, возможно, не имеет смысла явно создавать отдельные классы для каждого такого события.
Теперь изменим логику в `OrderService` так, чтобы использовался контекст
```
package aa0ndrey.dependency_inversion_guide.step_4.core.order;
public class OrderService {
private final UserRepository userRepository;
private final ProductRepository productRepository;
private final OrderRepository orderRepository;
private final List observers;
public void create(CreateOrderContext context) {
observers.forEach(observer -> observer.onStart(context));
var request = context.getRequest();
var user = userRepository.find(request.getUserId());
context.setUser(user); //(8)
var product = productRepository.find(request.getProductId());
context.setProduct(product); //(9)
if (user.getBalance() < product.getPrice()) {
throw new RuntimeException("Недостаточно средств");
}
var order = new Order(UUID.randomUUID(), user.getId(), product.getId());
orderRepository.create(order);
context.setCreatedOrder(order); //(10)
observers.forEach(observer -> observer.onEnd(context));
}
}
```
Необходимо отметить, что каждый раз когда появляются новые **важные** объекты, в методе `create` они обязательно добавляются в контекст в `(8)`, `(9)`, `(10)`. Зачем это делается? А это на самом деле делается аналогично использованию событий. При разработке основной логики нет знания о том, как наблюдатель будет реагировать на то или иное событие. И потенциально ему для работы могут понадобиться данные, которые появляются в основной логике.
И теперь можно перейти к самому важному, к изменению реализации интерфейса `CreateOrderObserver`, то есть к классу `CreateOrderObserverImpl`.
```
package aa0ndrey.dependency_inversion_guide.step_4.postgres.order;
public class CreateOrderObserverImpl implements CreateOrderObserver {
private final TransactionManagerImpl transactionManagerImpl;
@Override
public void onStart(CreateOrderContext context) {
var transactionId = transactionManagerImpl.begin();
context.getData().put("transaction-id", transactionId); //(11)
}
@Override
public void onEnd(CreateOrderContext context) {
var transactionId = (Long) context.getData().get("transaction-id"); //(12)
transactionManagerImpl.commit(transactionId);
}
}
```
Тут все устроено следующем образом. При открытии транзакции в методе
`onStart` в `(11)` id транзакции сохраняется в контексте в поле `data` по ключу `transaction-id`. Затем уже в методе `onEnd`, когда необходимо зафиксировать транзакцию, в `(12)` из контекста по этому же самому ключу извлекается id транзакции, который затем используется для её фиксации.
Чего в итоге удалось добиться? За счет использования контекста между двумя изолированными методами для обработки событий внутри инфраструктурного модуля удалось передать данные. При этом за счёт обобщенного поля `data` внутри контекста детали реализации инфраструктурного модуля не проникли в изолируемый модуль (core). Тут является очень важным, что в контексте не появилось конкретного поля, такого как `long transactionId`, которое раскрывало бы детали реализации.
5. Альтернативы полю data из контекста
--------------------------------------
В данном разделе будут обсуждаться альтернативы полю `data` из контекста для того, чтобы передавать данные из одного инфраструктурного метода в другой. В Java есть механизм, позволяющий привязать данные к потоку. Разрабатываемое приложение может быть построено так, что для каждого обрабатываемого запроса выделяется отдельный поток. И этот поток может эксклюзивно использоваться логикой обработки, до тех пор пока она не завершится. В этом случае можно использовать `ThreadLocal` в качестве альтернативы полю `data`.
Рассмотрим, как можно изменить `CreateOrderObserverImpl` для того, чтобы использовать `ThreadLocal` вместо `data`
```
package aa0ndrey.dependency_inversion_guide.step_5.postgres.order;
public class CreateOrderObserverImpl implements CreateOrderObserver {
private final TransactionManagerImpl transactionManagerImpl;
private final ThreadLocal transactionId = new ThreadLocal<>(); //(1)
@Override
public void onStart(CreateOrderContext context) {
transactionId.set(transactionManagerImpl.begin());
}
@Override
public void onEnd(CreateOrderContext context) {
transactionManagerImpl.commit(transactionId.get());
}
}
```
Для этого достаточно завести поле `transactionId`, как это сделано в `(1)`. И затем можно рассмотреть, что происходит в самих методах. При вызове метода `onStart` происходит запись id транзакции в поле `transactionId`, а в методе `onEnd` значение извлекается из поля `transactionId` для того, чтобы зафиксировать транзакцию. Сигнатуры методов `onStart` и `onEnd` остались без изменений и все также принимают контекст, но в данном случае контекст совсем не используется.
Может возникнуть вопрос, а почему ранее нельзя было создать переменную `long transactionId` и использовать ее аналогично? Предполагалось, что каждый класс сервиса, репозитория и наблюдателя имеет по одному экземпляру в работающем приложении, то есть они реализуют шаблон одиночка (singleton). И в этом случае один и тот же экземпляр класса может параллельно использоваться в нескольких потоках, и потоки могут друг другу мешать, конкурируя за единственное поле. Поэтому прямое использование переменной типа `long` не подойдёт. В свою очередь, тип `ThreadLocal` будет гарантировать, что каждый поток будет работать со своим значением.
Суть данного примера не в том, чтобы показать, как именно в Java через `ThreadLocal` можно решить поставленную проблему, а в том, что, если в используемом фреймворке или библиотеке или языке программирования есть механизм, позволяющий привязать данные к процессу обработки, то это можно использовать для того, чтобы передавать данные между изолированными инфраструктурными методами такими как `onStart` и `onEnd` в `CreateOrderObserverImpl`.
Но если говорить конкретно про Java и `ThreadLocal`, то тут необходимо быть осторожным и всегда рассматривать альтернативу с полем `data` из контекста. `ThreadLocal` может доставить неудобства, если понадобится в рамках обработки дополнительно создать потоки. Также некоторые новые реактивные фреймворки могут не давать гарантии того, что вся логика будет обрабатываться одним потоком для одного запроса. Передавая все в контексте, разработчик получает полный контроль над данными.
### 6. Передача данных от инфраструктурного модуля в изолируемый модуль
Что если теперь потребуется отправлять данные не только из изолируемого модуля (core) в инфраструктурный модуль (postgres), но и обратно из инфраструктурного в изолируемый. Такая необходимость тоже может возникнуть. Но в рамках данного раздела будут предъявлены самые ультимативные требования. Пусть в основной логике в классе `OrderService` необходимо отказаться от использования всех интерфейсов репозиториев. Для этого на самом деле уже все есть. В данном случае достаточно использовать уже созданный ранее контекст со всеми его полями.
Для начала рассмотрим изменения, внесенные в класс `OrderService`
```
package aa0ndrey.dependency_inversion_guide.step_6.core.order;
public class OrderService {
private final List observers;
public void create(CreateOrderContext context) {
observers.forEach(observer -> observer.onStart(context));
var user = context.getUser(); //(1)
var product = context.getProduct(); //(2)
if (user.getBalance() < product.getPrice()) {
throw new RuntimeException("Недостаточно средств");
}
var order = new Order(UUID.randomUUID(), user.getId(), product.getId());
context.setCreatedOrder(order); //(3)
observers.forEach(observer -> observer.onEnd(context));
}
}
```
Теперь вместо использования репозиториев напрямую для получения данных, необходимых для выполнения основной логики, используется контекст. То есть теперь в `(1)` и `(2)` информация о пользователе и продукте извлекается из контекста. В свою очередь вместо вызова метода репозитория для сохранения созданного заказа используется контекст, в который добавляется только что созданный заказ в `(3)`. Стоит отметить, что метод `create` стал меньше и проще.
Но чтобы это работало, необходимо внести изменения в класс `CreateOrderObserverImpl`
```
package aa0ndrey.dependency_inversion_guide.step_6.postgres.order;
public class CreateOrderObserverImpl implements CreateOrderObserver {
private final TransactionManagerImpl transactionManagerImpl;
private final ThreadLocal transactionId = new ThreadLocal<>();
private final UserRepositoryImpl userRepository;
private final ProductRepositoryImpl productRepository;
private final OrderRepositoryImpl orderRepository;
@Override
public void onStart(CreateOrderContext context) {
transactionId.set(transactionManagerImpl.begin());
var request = context.getRequest();
context.setUser(userRepository.find(request.getUserId())); //(4)
context.setProduct(productRepository.find(request.getProductId())); //(5)
}
@Override
public void onEnd(CreateOrderContext context) {
transactionManagerImpl.commit(transactionId.get());
orderRepository.create(context.getCreatedOrder()); //(6)
}
}
```
И здесь как раз в `(4)`, `(5)` и `(6)` добавляются все вызовы репозиториев, которые были вынесены из `OrderService`.
В итоге с помощью внесенных изменений удалось получить возможность передачи данных от инфраструктурного модуля (postgres) в изолируемый модуль (core). Тут стоит обратить внимание, что для этого использовались именно конкретные поля контекста, такие как `user` и `product`, а не обобщенное поле `data`. Это связано стем, что, во-первых, основной логике известны сущности `user` и `product`, а, во-вторых, в основной логике не должно использоваться поле `data`.
Подведем итог. С помощью шаблона наблюдатель с использованием контекста вместо отдельных событий, возможно передавать данные по всем трем направлениям:
* из изолируемого модуля (core) в инфраструктурный модуль (postgres)
* из инфраструктурного модуля (postgres) в изолируемый модуль (core)
* между методами обработки событий инфраструктурного модуля.
При этом для отправки из изолируемого модуля (core) в инфраструктурный модуль (postgres) и обратно используются конкретные поля, а для организации взаимодействия между методами обработки событий инфраструктурного модуля используется обобщенное поле `data`, либо механизмы, обеспечивающие привязку данных к процессу выполнения, такие как `ThreadLocal`. И не стоит также забывать о том, что точек для отправки событий с использованием контекста можно добавить сколько угодно в метод с основной логикой, даже посередине, а не только в начале и конце. При этом не придется даже создавать отдельные события, так как всю необходимую информацию о процессе содержит сам контекст.
После рассмотрения предыдущих разделов какие можно сделать выводы, уточнения и предостережения?
Во-первых, стоит отметить, что предложенные примеры являются искусственными, и не следует их воспринимать буквально. То есть не стоит отказываться от интерфейсов для репозиториев в пользу использования контекста с шаблоном наблюдатель, как это было сделано в последнем разделе, если для этого нет каких-либо дополнительных причин.
Во-вторых, не стоит прибегать к реализации использования `TransactionManager`, как это было продемонстрировано ранее, потому что это и не самый удачный подход конкретно для `TransactionManager`. Это можно будет увидеть в следующих разделах, когда будет продемонстрировано использование промежуточного модуля (application). `TransactionManager` был использован в примерах только потому, что с ним можно было продемонстрировать все возможные приемы, сохраняя при этом размеры примеров и обоснования для использования относительно небольшими и почти реалистичными.
Что является ценным из предыдущих разделов, так это сами приемы. Для типичной ситуации инверсии зависимостей, достаточно использования интерфейса для репозитория или клиента, помещаемого в изолируемый модуль (core). Если в основной логике возникает потребность вызова методов из инфраструктурных модулей, которые раскрывают детали реализации даже при использовании интерфейсов, то именно в этом случае стоит использовать шаблон наблюдатель. И далее в зависимости от того, в каком направлении необходимо организовать передачу данных, можно использовать то или иное решение. Универсальным, но не всегда оптимальным, механизмом для передачи данных является использование контекста.
Итоговый список приемов:
* интерфейс, отделенный от реализации - стандартный прием инверсии зависимостей, для случаев, когда интерфейс скрывает прямое использование общих классов, которые *не богаты* инфраструктурными деталями, таких как репозитории для базы данных или http клиенты и другие.
* шаблон наблюдатель - прием инверсии зависимостей, который скрывает прямое использование классов и их методов. Возможны следующие варианты использования шаблона:
+ стандартный с событиями - передача данных только от изолируемого модуля в инфраструктурный модуль.
+ с контекстом без поля `data` - передача данных от изолируемого модуля в инфраструктурный модуль и обратно
+ с привязкой данных к процессу выполнения - передача данных между изолируемыми инфраструктурными методами обработки событий
+ с контекстом с полем `data` - передача данных от изолируемого модуля в инфраструктурный модуль и обратно, а также между изолируемыми инфраструктурными методами обработки событий
В следующей части (или следующих частях) руководства будет продемонстрировано использование промежуточного модуля (application) и будет определена область его ответственности. Также будет представлен способ организации кода, позволяющий достичь того, что методы основной логики из изолируемого модуля (core) будут удовлетворять критериям "чистых" функций. И также будет представлен способ разделения процесса на этапы, в частности для организации взаимодействия через очередь сообщений.
В заключении для лучшего погружения в материал читателю предлагается решить задачу.
**Задача**
Пусть для каждого запроса при взаимодействии с базой данных необходимо также передавать id транзакции, который появляется при вызове метода `begin` из `TransactionManagerImpl`. То есть необходимо внести некоторые изменения, как минимум, в классы `UserRepositoryImpl`, `ProductRepositoryImpl`, `OrderRepositoryImpl`. Какие приемы и как их применить для того, чтобы удовлетворить поставленному требованию, при этом не добавив лишних инфраструктурных зависимостей в основную логику в изолируемый модуль (core)? Приведите как можно больше возможных вариантов решения поставленной задачи.
**Возможные решения**
Заметим, что данные необходимо передавать между изолированными инфраструктурными методами.
1. Использовать механизм привязки данных к выполняющемуся процессу, например, `ThreadLocal`. При этом сам id транзакции будет некорректно хранить внутри `CreateOrderObserverImpl`, так как репозитории потенциально могут быть переиспользованы в нескольких местах и поэтому они не могут быть привязаны к конкретному наблюдателю. Для этого достаточно завести отдельный класс, который будет хранить информацию о транзакции. Например, `TransactionInfo` с полем `ThreadLocal transactionId`. При этом в реализации `TransactionManagerImpl` можно затребовать, чтобы id транзакции сохранялся в `TransactionInfo` при вызове метода `begin`, а каждый репозиторий при выполнении запроса будет обращаться к `TransactionInfo` за получением id транзакции.
2. Использовать контекст с полем `data`. Для этого создать интерфейс `DynamicContext`, который будет содержать метод `getData()`. Также необходимо указать, что `CreateOrderContext` реализует данный интерфейс. Идея в том, что все методы репозиториев должны будут принимать `DynamicContext` в качестве дополнительного параметра, из которого они смогут получить доступ к полю `data`, в котором будет находиться id транзакции. Интерфейс `DynamicContext` нужен для того, чтобы была возможность переиспользовать репозитории в других местах, поэтому нельзя напрямую использовать тип `CreateOrderContext` в сигнатуре методов.
3. Отказаться от использования репозиториев в основной логике в изолируемом модуле (core) и перенести их в наблюдателя `CreateOrderObserverImpl`, как это было продемонстрировано в последнем разделе. Тогда нет никаких препятствий к тому, чтобы в сигнатуры методов каждого репозитория добавить параметр `long transactionId`, так как теперь эти методы никогда не будут использоваться в изолируемом модуле (core). Тогда в самом наблюдателе `CreateOrderObserverImpl` при вызове методов репозиториев появляется возможность передавать напрямую id транзакции.
Ссылка на github [репозиторий](https://github.com/aa0ndrey/dependency-inversion-guide/tree/habr) со всеми примерами. | https://habr.com/ru/post/582588/ | null | ru | null |
# Мобильные сервисы, блобы и Windows 8. Храним данные в облаке
Добрый день.
Мы живем в мире тотальной глобализации как в реальной жизни, так и в виртуальной. Я имею в виду, что нам хочется иметь одни и те же данные, одни и те же настройки и одно и то же поведение программ на разных устройствах. Такой синхронизации всего и вся в наше время легко добиться с помощью облаков. Об этом и пойдет речь в данной статье, а именно о скрещивании приложения для Windows 8 (WinRT) с облаком Windows Azure для хранения данных и метаданных.
#### Вводная
Итак, предположим, что у нас есть приложение для Windows 8 (пусть это будет сервис хранения неких текстовых записей), которое:
1) Должно отображать список записей с минимальной информацией о каждой из них (допустим, заголовок или дату создания). Назовем это метаданными.
2) Должно иметь возможность показать подробную информацию о записи (контент) при переходе к конкретному элементу. Назовем это данными.
3) Должно синхронизировать данные между различными устройствами под управлением Windows 8 (создал запись дома, просмотрел ее же на работе).
Наиболее правильный подход, который я вижу, это разбить данные и метаданные и хранить их в разных местах. Это позволит нам быстро получить небольшие по объему метаданные для отображения в виде списке, и подгружать «тяжелые» данные по запросу пользователя.
По ходу этой статьи мы познакомимся с Windows Azure Mobile Services для хранения метаданных и Windows Azure Blob Storage для хранения данных. Впереди много текста и картинки.
#### Шаг 1. Работа с облачным хранилищем
Для более гибкой и кроссплатформенной работы с Windows Azure Blob Storage я дополнительно рекомендую ввести еще один слой в виде WCF-сервиса, который будет получать и обрабатывать запросы от мобильных клиентов. Поэтому первый шаг данного руководства будет состоять из нескольких этапов.
##### Создание нужных нам сервисов Windows Azure
Для начала нам необходимо подготовить облачное окружение, создав в Windows Azure две службы — Cloud Service и Storage. Начнем со второго. Заходим в [портал управления Windows Azure](https://manage.windowsazure.com/). Внизу страницы есть большая кнопка с плюсом. По нажатии откроется выбор сервисов для создания. Нам нужен *DATA SERVICES -> STORAGE*:
Вводим любое удобное для нас имя нового сервиса, нажимаем кнопку-галку внизу и ждем, пока сервис не получит статус Online. После этого заходим в настройки нашего хранилища и ищем глазами и мышкой кнопку «Mange keys» с иконкой буквы i на борту. Нажимаем на нее и видим перед собой три поля. В первом будет находиться имя данного сервиса, который мы ему присвоили при создании, а во втором и третьем будут храниться ключи доступа. Запомним первый из них, он нам пригодится уже скоро.
##### Создание WCF сервиса
Для создания WCF сервиса и соотвествующей ему службы в Windows Azure мы воспользуемся Visual Studio 2012. Я буду показывать на примере версии Ultimate, но для бесплатного использования подойдет версия Web.
Итак, открываем студию и создаем новый проект с типом Cloud:
В появившемся окне нам будет предложено выбрать типы проектов, которые надо разместить в облаке. Нас интересует WCF Service Web Role. Выбираем его и добавляем к списку создаваемых (не забываем переименовать):
Visual Studio, после недолгих раздумий, создаст для нас два проекта, один из которых будет проектом WCF службы, а второй — специальный проект для публикации в облако Windows Azure. Давайте немного их понастраиваем.
Чтобы безболезненно публиковать наш сервис в облако, Visual Studio должна знать, в какое именно облако ей это делать, а также понимать, что мы имеем на это право. Чтобы ее убедить, достаточно нажать правой кнопкой мыши на проекте Cloud и выбрать пункт меню Publish:
Если вы ранее не публиковали ничего в облако, то вместо значения WindowsAzureMSDN у вас будет пусто. Чтобы было густо, достаточно перейти [по ссылке](https://windows.azure.com/download/publishprofile.aspx?wa=wsignin1.0), скачать профиль публикаций и импортировать его с помощью кнопки Import в Visual Studio. Это позволит вам выполнять операции над облачными сервисами прямо из IDE.
После того, как у нас появился доступ к облаку из VS2012, переходим на следующий шаг, где создадим непосредственно Cloud Service для хостинга нашей WCF-службы. На вкладке Common Settings выбираем *Cloud Service -> Create New*, а на вкладке Advanced Settings указываем существующий Storage Account (он должен уже быть доступным для выбора в списке). Старайтесь, чтобы и Cloud Service и Storage Account были в одной зоне:
После выполнения этих действий нам достаточно просто нажать кнопку Publish, и проект утечет в сеть.
#### Шаг 2. Использование хранилища
Первым делом надо добавить строку соединения в файл web.config нашего сервиса. Строка выглядит следующим образом:
*DefaultEndpointsProtocol=https;AccountName=имя\_сервиса;AccountKey=тот\_самый\_ключ\_от\_Storage*
Работа с облачным хранилищем может осущетсвляться двумя способами — с помощью REST API и с помощью .NET обертки. В данной статье я буду использовать второй вариант как наиболее простой. Тем более не зря же мы создавали свой собственный сервис.
Итак, для того, чтобы пользоваться данным функционалом, надо подключить к своему проекту NuGet пакет «Windows Azure Storage»:
Подключение и управление BLOB-контейнерами происходит с помощью клиента:
```
using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Blob;
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(_connectionString);
_blobClient = storageAccount.CreateCloudBlobClient();
```
Дальнейшая работа с хранилищем довольно проста:
```
// Получение контейнера
CloudBlobContainer container = BlobClient.GetContainerReference(ContainerName);
// Создание, если его не существует
container.CreateIfNotExists();
// Получение блока по принципу "префикс-"
CloudBlockBlob blockBlob = container.GetBlockBlobReference(BlobNamePrefix + data.Id);
// Сериализуем данные
var serializer = new XmlSerializer(typeof(CompositeType));
using (var s = new MemoryStream())
{
serializer.Serialize(s, data);
s.Seek(0, SeekOrigin.Begin);
// И пишем в blob
blockBlob.UploadFromStream(s);
}
```
Аналогично данные можно получить:
```
// Получение контейнера
CloudBlobContainer container = BlobClient.GetContainerReference(ContainerName);
// Если не существует - возвращаем null
if (!container.Exists())
return null;
// Так же пытаемся получить блок
var blockBlob = container.GetBlockBlobReference(BlobNamePrefix + id);
if (!blockBlob.Exists())
return null;
// И десериализуем бинарные данные
var serializer = new XmlSerializer(typeof(CompositeType));
CompositeType result = null;
using (var s = new MemoryStream())
{
// Скачиваем данные из блоба
blockBlob.DownloadToStream(s);
s.Seek(0, SeekOrigin.Begin);
result = serializer.Deserialize(s) as CompositeType;
}
return result;
```
Вышеописанные методы были помещены в класс обертку, а сам WCF-сервис обаладает простым контрактом из двух действий:
```
[ServiceContract]
public interface IBlobService
{
[OperationContract]
CompositeType GetData(int value);
[OperationContract]
void PutData(CompositeType data);
}
```
**!!!** Тут надо упомянуть важную, но абсолютно неочевидную вещь. Имена блоб контейнеров и блоков должны быть в маленьком регистре. То есть имя *BlobContainer* вызовет ошибку при попытке создания, а, например, *blob-container* создастся без проблем.
После того, как мы написали сервис, еще раз публикуем его в облако и после завершения этой процедуры он будет доступен по адресу *ваше\_имя\_сервиса.cloudapp.net/BlobService.svc*.
#### Шаг 3. Мобильные сервисы
Предыдущие два шага были направлены на создание инфраструктуры для хранения «данных» — информации большого объема, которая нужна не всегда, а по запросу. Теперь давайте перейдем к хранению «метаданных». Для этого мы воспользуемся недавней новинкой в Windows Azure — Mobile Services.
Создать новый мобильный сервис так же просто, как и остальные услуги в Windows Azure. Опять идем на [портал управления](https://manage.windowsazure.com/), где внизу в меню создания выбираем *COMPUTE -> MOBILE SERVICE* и видим перед собой мастер:
Указываем в нем имя будущего сервиса, регион размещения (не забываем размещаться где-то в одном месте), указываем Storage, где будут храниться наши данные (можно использовать уже существующий или создать новый) и завершаем мастер.
Как только сервис будет создан, переходим на его страницу в раздел, помеченный иконкой облака с молнией (названия у него я не знаю). На этой странице есть две опции — *Create a new Windows Store app* и *Connect an existing Windows Store app*. Первая позволит вам скачать архив с приложением, настроенным для работы с вашим мобильным сервисом, а вторая просто даст кусочек кода, который надо внедрить в существующее приложение. В принципе сейчас не важно, какую опцию вы выберете. Я предлагаю использовать вторую и создать приложение вручную.
А пока мы этого не сделали, давайте подготовим Mobile Services к использованию. Для этого сперва пеерйдем в раздел Data (в верхнем меню) и добавим новую таблицу для хранения записей. Назвать можно как угодно, у меня — TestItem:
В этой таблице впоследствии будут размещаться записи метаданных, введенные в приложении для Windows 8.
#### Шаг 4. Windows 8
Настало время сделать то, ради чего все затевалось. Приложение для Windows 8 (WinRT) можно бесплатно создать в Express версии Visual Studio 2012 (наподобие той, что мы использовали для WCF сервиса, но теперь для Win8 приложений).
File -> New Project -> Windows Store:
Сперва надо добавить необходимые ссылки на библиотеки, чтобы можно было пользоваться благами Mobile Services. Если вы обратили внимание, то на предыдущем шаге Windows Azure предалал нам скачать и установить [Mobile Services SDK](https://go.microsoft.com/fwLink/?LinkID=257545&clcid=0x409). Это нужно сделать, ибо с его помощью мы будем работать с облачными сервисами для мобильных устройств.
Как только SDK установлен, мы можем подключить его к проекту с помощью стандартной процедуры *Add Reference*:
Затем подключим еще и ссылку на наш WCF сервис. Делается это также несложно с помощью стандартного диалога *Add Service Reference*:
В результате подключения Service Reference Visual Studio создаст для нас специальный класс обертку, который будет выглядеть как обычный класс с контрактом сервиса, но на самом деле будет обращаться к удаленному WCF по указанному адресу.
Ну и в завершение, добавим код для использования мобильных сервисов, который, как я говорил выше, можно получить на странице с облачком и молнией в Windows Azure. Выглядит он примерно так:
```
public static MobileServiceClient MobileService = new MobileServiceClient(
"https://***.azure-mobile.net/",
"secret_key");
```
Это поле я добавил на страницу App.xaml, чтобы иметь доступ к мобильным сервисам из любого места в приложении.
#### Шаг 5. Собираем все вместе
Настало время соединить все пути в одной точке и написать код, который при добавлении новой записи будет размещать ее в хранилище Azure Blob Storage и Mobile Services.
```
private async Task PutDataTestWCF(CompositeType data)
{
// Получаем клиент для работы с WCF
var cli =
await
Task.Run(() => new BlobServiceClient(new BasicHttpBinding(), new EndpointAddress(CloudServiceEndpoint)));
// Вызываем сгенеренный метод добавления данных (асинхронный)
await cli.PutDataAsync(data);
// Не забываем закрыть клиент
await cli.CloseAsync();
// Получаем таблицу в мобильных сервисах
var table = App.MobileService.GetTable();
// Выбираем из нее записи
var list = await table.Select(x => x.Id == data.Id).ToListAsync();
// Если такая запись есть, то делаем обновление, иначе - вставку
if (list != null && list.Count > 0)
await table.UpdateAsync(new TestItem() {Id = data.Id, Text = data.Text});
else
await table.InsertAsync(new TestItem() {Text = data.Text});
}
```
Тут стоит обратить внимание на несколько вещей. Во первых, все методы, которые так или иначе работают с сетью, являются асинхронными. Даже класс клиента к WCF сервису, который сгенерировался автоматически, тоже содержит асинхронные методы (PutDataAsync). Это здорово, поскольку позволяет делать приложение более отзывчивым, не заставляя пользователя наблюдать заблокированный интерфейс, пока приложение пытается соединиться с Интернетом.
Помимо этого, работа с обоими сервисами стала довольно простой и прозрачной. Что работа с WCF, что с Mobile Services, обе они выглядят как простые вызовы .Net кода, скрывая все детали «где-то там». Я не писал здесь никаких абстрактных слоев доступа к данным, но если заморочиться и сделать все грамотно, то мы сможем легко делать заглушки и моки (mock) для тестирования приложения.
#### Заключение
В этой статье в первую очередь я хотел показать не как писать Windows 8 приложения, а как встроить в них возможность работы с различными типами облачного хранилища разлиными способами. Я сознательно привел не так много кода, поскольку статья и так получилась большой и, возможно, сложной для восприятия. Ниже я прилагаю архив с кодом, который можно использовать для тренировки:
[Скачать архив](https://skydrive.live.com/redir?resid=1A98D7400F0A091A!2230&authkey=!ALQ56zmznPo4nog)
В нем я заменил все упоминания своего сервиса на \*\*\* или \*\*\*\*. Думаю будет понятно, что и куда надо подставить, чтобы все взлетело.
При подготовке статьи и тестового приложения были использованы следующие материалы:
— [Официальное руководство по работе с Blob Storage](https://www.windowsazure.com/en-us/develop/net/how-to-guides/blob-storage/)
— [Официальное руководство по работе с данными в мобильных сервисах](https://www.windowsazure.com/en-us/develop/mobile/tutorials/get-started-with-data-dotnet/)
— [Google](http://www.google.ru), [Bing](http://www.bing.com), [Yandex](http://www.yandex.ru)
— Собственные мысли и догадки
*P.S. Большая просьба к неравнодушным минусаторам — пишите, пожалуйста, аргументацию своих минусов или в комментах, или в личку. Мне важно знать свои огрехи, чтобы исправлять их в будущих публикациях. Спасибо большое.* | https://habr.com/ru/post/157641/ | null | ru | null |
# Vulkan. Руководство разработчика. Краткий обзор
Я работаю техническим переводчиком ижевской IT-компании CG Tribe, которая предложила мне внести свой вклад в сообщество и начать публиковать переводы интересных статей и руководств.
Здесь я буду публиковать перевод руководства к Vulkan API. Ссылка на источник — [vulkan-tutorial.com](https://vulkan-tutorial.com). Поскольку переводом этого же руководства занимается еще один пользователь Хабра — [kiwhy](https://habr.com/ru/users/kiwhy), мы договорились разделить уроки между собой. В своих публикациях я буду давать ссылки на главы, переведенные kiwhy.
**Содержание**
1. [Вступление](http://habr.com/ru/post/462137/)
2. [Краткий обзор](http://habr.com/ru/post/524992/)
3. [Настройка окружения](https://habr.com/ru/post/526320/)
4. [Рисуем треугольник](https://habr.com/ru/post/531196/)
1. [Подготовка к работе](https://habr.com/ru/post/531196/)
* [Базовый код](https://habr.com/ru/post/531196/#base)
* [Экземпляр (instance)](https://habr.com/ru/post/531196/#two)
* [Слои валидации](https://habr.com/ru/post/535342/)
* [Физические устройства и семейства очередей](https://habr.com/ru/post/537208/#phys)
* [Логическое устройство и очереди](https://habr.com/ru/post/537208/#logic)
2. Отображение на экране
* [Window surface](https://habr.com/ru/post/539174/)
* [Swap chain](https://habr.com/ru/post/542942/)
* [Image views](https://habr.com/ru/post/543288/)
3. [Графический конвейер (pipeline)](https://habr.com/ru/post/547576/)
* [Вступление](https://habr.com/ru/post/547576/)
* [Шейдерные модули](https://habr.com/ru/post/547576/#shader)
* [Непрограммируемые стадии конвейера](https://habr.com/ru/post/554492/)
* [Проходы рендера (Render passes)](https://habr.com/ru/post/560816/)
* [Заключение](https://habr.com/ru/post/560816/#conclusion)
4. Отрисовка
* [Фреймбуферы](https://habr.com/ru/post/564100/#frame)
* [Буферы команд](https://habr.com/ru/post/564100/#buffer)
* [Рендеринг и отображение на экране](https://habr.com/ru/post/567754/)
5. [Пересоздание swap chain](https://habr.com/ru/post/569912/)
5. [Вершинные буферы](https://habr.com/ru/post/571944/)
1. [Описание входных данных вершин](https://habr.com/ru/post/571944/)
2. [Создание вершинного буфера](https://habr.com/ru/post/573920/)
3. [Промежуточный буфер](https://habr.com/ru/post/578956/)
4. [Индексный буфер](https://habr.com/ru/users/alexandra_sky/posts/)
6. Uniform-буферы
1. [Layout дескрипторов и буфер](https://habr.com/ru/post/582838/)
2. Пул дескрипторов и сеты дескрипторов
7. Текстурирование
1. Изображения
2. Image view и image sampler
3. Комбинированный image sampler
8. Буфер глубины
9. Загрузка моделей
10. Создание мип-карт
11. Multisampling
FAQ
Политика конфиденциальности
**1. Вступление
-------------**
См. статью автора kiwhy — [habr.com/ru/post/462137](https://habr.com/ru/post/462137/)
**2. Краткий обзор
----------------**
[Предпосылки возникновения Vulkan](#one)
[Как нарисовать треугольник?](#two)
1. [Шаг 1 — Экземпляр (instance) и физические устройства](#three)
2. [Шаг 2 — Логическое устройство и семейства очередей](#four)
3. [Шаг 3 — Window surface и цепочки показа (swap chain)](#five)
4. [Шаг 4 — Image views и фреймбуферы](#six)
5. [Шаг 5 — Проходы рендера](#seven)
6. [Шаг 6 — Графический конвейер (pipeline)](#eight)
7. [Шаг 7 — Пул команд и буферы команд](#nine)
8. [Шаг 8 — Основной цикл](#ten)
9. [Выводы](#eleven)
[Концепты API](#twelve)
1. [Стандарт оформления кода](#thirteen)
2. [Слои валидации](#fourteen)
В этой главе мы начнем знакомство с Vulkan и рассмотрим, какие проблемы он позволяет решить. Мы опишем шаги, необходимые для создания вашего первого треугольника. Это даст вам общее представление о стандарте и позволит понять логику расположения последующих глав. В заключение мы рассмотрим структуру Vulkan API и типичные случаи использования.
**### Предпосылки возникновения Vulkan**
Как и предыдущие графические API, Vulkan задуман как кроссплатформенная абстракция над [GPU](http://en.wikipedia.org/wiki/Graphics_processing_unit). Основная проблема большинства таких API заключается в том, что в период их разработки использовалось графическое оборудование, ограниченное фиксированным функционалом. Разработчики должны были предоставить данные о вершинах в стандартном формате и в плане освещения и теней полностью зависели от производителей графических процессоров.
По мере развития архитектуры видеокарт в ней стало появляться все больше программируемых функций. Все новые функции необходимо было каким-то образом объединить с существующими API. Это привело к неидеальным абстракциям и множеству гипотез со стороны графического драйвера о том, как воплотить замысел программиста в современных графических архитектурах. Поэтому для повышения производительности в играх выпускается большое количество обновлений драйверов. Из-за сложности таких драйверов среди поставщиков часто возникают расхождения, например, в синтаксисе, принятом для [шейдеров](http://en.wikipedia.org/wiki/Shader). Помимо этого, в последнее десятилетие также наблюдался приток мобильных устройств с мощным графическим оборудованием. Архитектуры этих мобильных GPU могут сильно отличаться в зависимости от требований по размерам и энергопотреблению. Одним из таких примеров является [тайловый рендеринг](http://en.wikipedia.org/wiki/Tiled_rendering), который может дать большую производительность за счет лучшего контроля над функционалом. Еще одним ограничением, связанным с возрастом API, является ограниченная поддержка многопоточности, что может привести к появлению узкого места со стороны ЦП.
Vulkan помогает решить эти проблемы, поскольку изначально создан для современных графических архитектур. Это снижает потери на стороне драйвера за счет того, что разработчики могут четко описать свои цели с помощью подробного API. Vulkan позволяет параллельно создавать и отсылать команды в нескольких потоках. Также снижаются расхождения компиляции шейдеров за счет перехода на стандартизованный формат байтового кода и использования одного компилятора. И наконец, Vulkan реализует главную возможность современных видеокарт, объединяя графические и вычислительные возможности в едином API.
**### Как нарисовать треугольник?**
Мы кратко рассмотрим шаги, необходимые для отрисовки треугольника. Это позволит вам получить общее представление о процессе. Подробное описание каждой концепции будет дано в следующих главах.
**Шаг 1 — Экземпляр (instance) и физические устройства**
Работа с Vulkan начинается с настройки Vulkan API через [VkInstance](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInstance.html) (экземпляр). Экземпляр создается с помощью описания вашей программы и всех расширений, которые вы хотите использовать. После создания экземпляра вы можете запросить, какое оборудование поддерживает Vulkan, и выбрать один или несколько [VkPhysicalDevices](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevice.html) для выполнения операций. Вы можете сделать запрос по таким параметрам, как размер VRAM и возможности устройств, чтобы выбрать желаемые устройства, если вы предпочитаете использовать специализированные видеокарты.
**Шаг 2 — Логическое устройство и семейства очередей**
После того, как вы выберете подходящее hardware устройство для использования, вам необходимо создать [VkDevice](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDevice.html) (логическое устройство), где вы более подробно опишете, какие возможности ([VkPhysicalDeviceFeatures](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html)) будете использовать, например, рендеринг в несколько viewport-ов (multi viewport rendering) и 64-битные числа с плавающей точкой. Вам также необходимо установить, какие семейства очередей вы бы хотели использовать. Многие операции, совершаемые с помощью Vulkan, например, команды рисования и операции в памяти, выполняются асинхронно после отправки в [VkQueue](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueue.html). Очереди выделяются из семейства очередей, где каждое семейство поддерживает определенный набор операций. Например, для операций с графикой, вычислительных операций и передачи данных памяти могут существовать отдельные семейства очередей. Кроме того их доступность может использоваться в качестве ключевого параметра при выборе физического устройства. Некоторые устройства с поддержкой Vulkan не предлагают никаких графических возможностей, однако, все современные видеокарты с поддержкой Vulkan, как правило, поддерживают все необходимые нам операции с очередями.
**Шаг 3 — Window surface и цепочки показа (swap chain)**
Если вас интересует не только внеэкранный рендеринг, вам необходимо создать окно для отображения отрендеренных изображений. Окна можно создать с помощью API исходной платформы или библиотек, таких как [GLFW](http://www.glfw.org) и [SDL](http://www.libsdl.org/). В руководстве мы будем использовать GLFW, подробнее о которой мы расскажем в следующей главе.
Нам необходимо еще два компонента, чтобы рендерить в окно приложения: window surface (`VkSurfaceKHR`) и цепочка показа (`VkSwapchainKHR`). Обратите внимание на постфикс `KHR`, который обозначает, что эти объекты являются частью расширения Vulkan. Vulkan API полностью независим от платформы, поэтому нам необходимо использовать стандартизованное расширение WSI (Window System Integration) для взаимодействия с менеджером окон. Surface – это кроссплатформенная абстракция окон для визуализации, которая, как правило, создается с помощью ссылки на собственный дескриптор окна, например `HWND` в Windows. К счастью, библиотека GLFW имеет встроенную функцию для работы со специфичными деталями платформы.
Цепочка показа — это набор целей рендеринга. Ее задача — обеспечивать, чтобы изображение, которое рендерится в текущий момент, отличалось от отображаемого на экране. Это позволяет отслеживать, чтобы отображались только готовые изображения. Каждый раз, когда нам нужно создать кадр, мы должны сделать запрос, чтобы цепочка показа предоставила нам изображение для рендеринга. После того, как кадр создан, изображение возвращается в цепочку показа, чтобы в какой-то момент отобразиться на экране. Количество целей рендеринга и условий для отображения готовых изображений на экране зависит от текущего режима. Среди таких режимов можно выделить двойную буферизацию (vsync) и тройную буферизацию. Мы рассмотрим их в главе, посвященной созданию цепочки показа.
Некоторые платформы позволяют рендерить непосредственно на экран через расширения `VK_KHR_display` и `VK_KHR_display_swapchain` без взаимодействия с каким-либо менеджером окон. Это позволяет создать surface, которая представляет собой весь экран и может использоваться, например, для реализации вашего собственного менеджера окон.
**Шаг 4 — Image views и фреймбуферы**
Чтобы рисовать в изображение (image), полученное из цепочки показа, мы должны обернуть его в [VkImageView](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageView.html) и [VkFramebuffer](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebuffer.html). Image view ссылается на определенную часть используемого изображения, а фреймбуфер ссылается на image views, которые используются как буферы цвета, глубины и шаблонов (stencil). Поскольку в цепочке показа может быть множество разных изображений, мы заранее создадим image view и фреймбуфер для каждого из них и выберем необходимое изображение во время рисования.
**Шаг 5 — Проходы рендера**
Проходы рендера в Vulkan описывают тип изображений, используемых во время операций рендеринга, то, как они используются, и то, как необходимо обрабатывать их содержимое. Перед отрисовкой треугольника мы сообщим Vulkan, что мы хотим использовать одиночное изображение в качестве буфера цвета и что нам нужно очистить его перед рисованием. Если проход рендера описывает только тип изображений, используемых в качестве буферов, то [VkFramebuffer](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebuffer.html) фактически связывает определенные изображения с этими слотами.
**Шаг 6 — Графический конвейер (pipeline)**
Графический конвейер в Vulkan настраивается с помощью создания объекта [VkPipeline](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipeline.html). Он описывает конфигурируемое состояние видеокарты, например, размер viewport или операцию буфера глубины, а также программируемое состояние, используя объекты [VkShaderModule](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModule.html). Объекты [VkShaderModule](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModule.html) создаются из байтового кода шейдера. Драйверу также необходимо указать, какие цели рендеринга будут использоваться в конвейере. Мы задаем их, ссылаясь на проход рендера.
Одна из наиболее отличительных особенностей Vulkan по сравнению с существующими API-интерфейсами заключается в том, что почти все системные настройки графического конвейера должны задаваться заранее. Это значит, что если вы хотите переключиться на другой шейдер или немного изменить vertex layout, вам необходимо полностью пересоздать графический конвейер. Поэтому вам придется заранее создать множество объектов [VkPipeline](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipeline.html) для всех комбинаций, необходимых для операций рендеринга. Только некоторые базовые настройки, такие как размер viewport и цвет очистки, могут быть изменены динамически. Все состояния должны быть описаны явно. Так, например, не существует смешивания цветов (color blend state) по умолчанию.
К счастью, поскольку процесс больше напоминает опережающую компиляцию, вместо компиляции «на лету», у драйвера появляется больше возможностей для оптимизации, а производительность оказывается более предсказуемой, так как значительные изменения состояния, например, переключение на другой графический конвейер, указываются явно.
**Шаг 7 — Пул команд и буферы команд**
Как уже было сказано, многие операции в Vulkan, например операции рисования, должны быть отправлены в очередь. Прежде чем отправить операции, их необходимо записать в [VkCommandBuffer](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBuffer.html). Буферы команд берутся из [VkCommandPool](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPool.html), который связан с определенным семейством очередей. Чтобы нарисовать простой треугольник, нам нужно записать буфер команд со следующими операциями:
* Начать проход рендера
* Привязать графический конвейер
* Нарисовать 3 вершины
* Закончить проход рендера
Поскольку экземпляр изображения во фреймбуфере зависит от того, какое изображение нам даст цепочка показа, нам необходимо записать буфер команд для каждого возможного изображения и выбрать нужный во время рисования. Мы можем записывать буфер команд каждый раз для каждого кадра, но такой способ менее эффективный.
**Шаг 8 — Основной цикл**
После того, как мы отправили команды рисования в буфер команд, основной цикл кажется достаточно простым. Сначала мы получаем изображение из цепочки показа с помощью `vkAcquireNextImageKHR`. Затем мы можем выбрать соответствующий буфер команд для этого изображения и запустить его с помощью [vkQueueSubmit](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueSubmit.html). В конце, мы возвращаем изображение в цепочку показа для вывода на экран с помощью `vkQueuePresentKHR`.
Операции, отправляемые в очереди, выполняются асинхронно. Поэтому мы должны использовать объекты синхронизации — семафоры —, чтобы обеспечить правильный порядок запуска. Необходимо настроить запуск буфера команд рисования таким образом, чтобы он осуществлялся только после того, как изображение будет извлечено из цепочки показа, в противном случае может возникнуть ситуация, когда мы начнем рендерить изображение, которое все еще считывается для отображения на экране. Вызов `vkQueuePresentKHR`, в свою очередь, должен дождаться завершения рендеринга, для которого мы будем использовать второй семафор. Он будет уведомлять об окончании отрисовки.
**Выводы**
Этот краткий обзор позволяет получить общее представление о предстоящей работе по рисованию вашего первого треугольника. В реальности же шагов гораздо больше. Среди них выделение буферов вершин, создание uniform-буферов и загрузка изображений текстур — все это мы рассмотрим в следующих главах, а пока начнем с простого. Чем дальше мы будем двигаться, тем сложнее будет материал. Обратите внимание, что мы решили пойти хитрым путем, изначально встраивая координаты вершины в вершинный шейдер вместо использования буфера вершин. Такое решение связано с тем, что для управления буферами вершин сначала требуется знакомство с буферами команд.
Подведем краткий итог. Для отрисовки первого треугольника нам необходимо:
* Создать [VkInstance](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInstance.html)
* Выбрать поддерживаемую видеокарту ([VkPhysicalDevice](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevice.html))
* Создать [VkDevice](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDevice.html) и [VkQueue](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueue.html) для рисования и отображения
* Создать окно, window surface и цепочку показа
* Обернуть изображения цепочки показа в [VkImageView](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageView.html)
* Создать проход рендера, который определяет цели рендеринга и их использование
* Создать фреймбуфер для прохода рендера
* Настроить графический конвейер
* Распределить и записать команды рисования в буфер для каждого изображения цепочки показа
* Отрисовать кадры в полученные изображения, отправляя правильный буфер команд и возвращая изображения обратно в цепочку показа
Несмотря на то, что шагов достаточно много, смысл каждого из них будет понятен в следующих главах. Если вы не сможете разобраться с каким-либо шагом, вернитесь к этой главе.
**#### Концепты API**
В заключение к текущей главе будет приведен краткий обзор того, как структурируются Vulkan API на более низком уровне.
**Стандарт оформления кода**
Все функции, перечисления и структуры Vulkan обозначены под заголовком `vulkan.h`, который включен в [Vulkan SDK](http://www.lunarg.com/vulkan-sdk/), разработанный LunarG. Установка SDK будет рассмотрена в следующей главе.
Функции имеют префикс `vk` в нижнем регистре, перечисляемые типы (enum) и структуры имеют префикс `Vk`, а перечисляемые значения имеют префикс `VK_`. API активно использует структуры, чтобы предоставить параметры функциям. Например, создание объектов обычно происходит по следующей схеме:
Многие структуры в Vulkan требуют прямого указания типа структуры в члене `sType`. Член `pNext` может указывать на структуру расширения и в нашем руководстве всегда будет иметь тип `nullptr`. Функции, создающие или уничтожающие объект, будут иметь параметр [VkAllocationCallbacks](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAllocationCallbacks.html), который позволяет вам использовать собственный аллокатор памяти и который в руководстве также будет иметь тип `nullptr`.
Почти все функции возвращают [VkResult](http://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkResult.html), который является либо `VK_SUCCESS`, либо кодом ошибки. В спецификации указано, какие коды ошибок может возвратить каждая функция и что они обозначают.
**Слои валидации**
Как уже было сказано, Vulkan был разработан для обеспечения высокой производительности при низких нагрузках на драйвер. Поэтому он включает в себя очень ограниченные возможности автоматического обнаружения и исправления ошибок. Если вы сделаете ошибку, драйвер даст сбой или еще хуже, продолжит работать на вашей видеокарте, но выйдет из строя на других видеокартах.
Поэтому Vulkan позволяет запускать расширенные проверки с помощью функции, известной как *слои валидации*. Слои валидации — это фрагменты кода, которые могут быть вставлены между API и графическим драйвером для выполнения дополнительных проверок параметров функций и отслеживания проблем по управлению памятью. Это удобно тем, что вы можете запустить их во время разработки, а затем полностью отключить при запуске программы без дополнительных затрат. Любой пользователь может написать свои собственные слои валидации, но Vulkan SDK от LunarG предоставляет стандартный набор, который мы будем использовать в руководстве. Вам также необходимо зарегистрировать функцию обратного вызова для получения сообщений отладки от слоев.
Поскольку операции в Vulkan расписываются очень подробно, и слои валидации достаточно обширные, вам будет намного проще установить причину черного экрана по сравнению с OpenGL и Direct3D.
Остался всего один шаг, прежде чем мы начнем писать код, и это — настройка рабочей среды. | https://habr.com/ru/post/524992/ | null | ru | null |
# Особенности получения пакетов через raw socket в Linux
Linux (в отличии, к примеру, от FreeBSD) позволяет использовать сырые сокеты не только для отправки, но и для получения данных. В этом месте существуют интересные грабли, на которые я наступил. Теперь спешу показать их тем, кто еще на знает, чтобы каждый, используя свой любимый язык программирования, будь то C++ или Python, мог опробовать их в деле.
Суть граблей изображена на рисунке, чтобы те, кто уже в курсе, не тратили свое время.
Я буду писать примеры на С, но вы можете перенести их и на другие языки, предоставляющие возможность низкоуровневой работы со стеком TCP\IP в Linux.
Некоторые понятия
-----------------
Напомню, что для инициализации сырого сокета мы передаем параметр, обозначающий тип протокола. Например UDP:
`socket(AF_INET, SOCK_RAW, IPPROTO_UDP)`
Этот протокол я буду называть *уровнем* на котором работает сырой сокет. В примере мы создали сырой сокет на уровне UDP.
Уровень сырого сокета не ограничивает вас в формировании пакета на отправку, вы можете самостоятельно сформировать как UDP, так и IP заголовок. А вот при получении данных начинается самое интересное…
Грабли
------
Допустим мы создали 2 сырых сокета на уровне UDP и воспользовались *одним* из них для отправки UDP пакета на UDP эхо сервер. Эхо вернет нам UDP payload обратно. Так вот, Стек TCP\IP **скопирует** полученный пакет на **все** сырые сокеты того уровня, который указан в поле Protocol IP заголовка пришедшего пакета. Еще раз повторюсь — на **ВСЕ**, даже те, которые открыты в других приложениях (по этой причине приложение, оперирующее сырыми сокетами может быть запущено только с правами суперпользователя). Так как UDP эхо сервер отвечает UDP пакетом, то все сырые сокеты UDP уровня его получат.
Отметим еще одну важную особенность. Не зависимо от уровня сырого сокета, ему доставляется полный пакет, включающий IP заголовки.
Таким образом, каждый сырой сокет в Linux является сниффером на том уровне, на котором он был создан. Следует помнить об этом при разработке приложений.
Пример
------
Не стал нагружать заметку кодом. Для тех, кому интересно попробовать, я
выложил свой пример на [github](https://github.com/hoxnox/rawsock_recv_example). Там cmake проект, который собирает простенький UDP эхо-сервер и приложение, создающее 2 сырых сокета уровня UDP, один из которых посылает данные, но оба отправляются в epoll в ожидании ответа. Для чистоты эксперимента эхо-сервер и пример желательно пустить на разных машинах (не забудьте поправить код в соответствии вашим IP-шникам). Для интереса можно запустить несколько экземпляров примера.
Для внешкольного чтения есть [хорошая статья](http://sock-raw.org/papers/sock_raw).
Спасибо за внимание и поменьше граблей! | https://habr.com/ru/post/183316/ | null | ru | null |
# Learn OpenGL. Урок 6.1. PBR или Физически-корректный рендеринг. Теория
Физически-корректный рендеринг
------------------------------
PBR, или физически-корректный рендеринг (physically-based rendering) это набор техник визуализации, в основе которых лежит теория, довольно хорошо согласующаяся с реальной теорией распространения света. Поскольку целью PBR является физически достоверная имитация света, он выглядит гораздо более реалистичным по сравнению с использованными нами ранее моделями освещения Фонга и Блинна-Фонга. Он не только лучше выглядит, но и дает неплохое приближение к реальной физике, что позволяет нам (и в частности художникам) создавать материалы, основанные на физических свойствах поверхностей, не прибегая к дешевым трюкам дабы заставить освещение выглядеть реалистично. Главным преимуществом такого подхода является то, что создаваемые нами материалы будут выглядеть как задумано независимо от условий освещения, чего нельзя сказать о других, не PBR подходах.
**Содержание****Часть 1. Начало**
1. [OpenGL](https://habrahabr.ru/post/310790/)
2. [Создание окна](https://habrahabr.ru/post/311198/)
3. [Hello Window](https://habrahabr.ru/post/311234/)
4. [Hello Triangle](https://habrahabr.ru/post/311808/)
5. [Shaders](https://habrahabr.ru/post/313380/)
6. [Текстуры](https://habrahabr.ru/post/315294/)
7. [Трансформации](https://habrahabr.ru/post/319144/)
8. [Системы координат](https://habrahabr.ru/post/324968/)
9. [Камера](https://habrahabr.ru/post/327604/)
**Часть 2. Базовое освещение**
1. [Цвета](https://habrahabr.ru/post/329592/)
2. [Основы освещения](https://habrahabr.ru/post/333932/)
3. [Материалы](https://habrahabr.ru/post/336166/)
4. [Текстурные карты](https://habrahabr.ru/post/337550/)
5. [Источники света](https://habrahabr.ru/post/337642/)
6. [Несколько источников освещения](https://habrahabr.ru/post/338254/)
**Часть 3. Загрузка 3D-моделей**
1. [Библиотека Assimp](https://habrahabr.ru/post/338436/)
2. [Класс полигональной сетки Mesh](https://habrahabr.ru/post/338436/)
3. [Класс 3D-модели](https://habrahabr.ru/post/338998/)
**Часть 4. Продвинутые возможности OpenGL**
1. [Тест глубины](https://habrahabr.ru/post/342610/)
2. [Тест трафарета](https://habrahabr.ru/post/344238/)
3. [Смешивание цветов](https://habrahabr.ru/post/343096/)
4. [Отсечение граней](https://habrahabr.ru/post/346964/)
5. [Кадровый буфер](https://habrahabr.ru/post/347354/)
6. [Кубические карты](https://habrahabr.ru/post/347750/)
7. [Продвинутая работа с данными](https://habrahabr.ru/post/350008/)
8. [Продвинутый GLSL](https://habrahabr.ru/post/350156/)
9. [Геометричечкий шейдер](https://habrahabr.ru/post/350782/)
10. [Инстансинг](https://habrahabr.ru/post/352962/)
11. [Сглаживание](https://habrahabr.ru/post/351706/)
**Часть 5. Продвинутое освещение**
1. [Продвинутое освещение. Модель Блинна-Фонга.](https://habrahabr.ru/post/353054/)
2. [Гамма-коррекция](https://habrahabr.ru/post/353632/)
3. [Карты теней](https://habrahabr.ru/post/353956/)
4. [Всенаправленные карты теней](https://habr.com/post/354208/)
5. [Normal Mapping](https://habr.com/post/415579/)
6. [Parallax Mapping](https://habr.com/post/416163/)
7. [HDR](https://habr.com/post/420409/)
8. [Bloom](https://habr.com/post/420375/)
9. [Отложенный рендеринг](https://habr.com/post/420565/)
10. [SSAO](https://habr.com/post/421385/)
**Часть 6. PBR**
1. Теория
2. [Аналитические источники освещения](https://habr.com/post/424453/)
3. [IBL. Диффузная облученность.](https://habr.com/post/426987/)
4. [IBL. Зеркальная облученность.](https://habr.com/post/429744/)
Тем не менее, PBR все еще остается приближением реальности (базирующемся на законах физики), поэтому он называется физически-корректным рендерингом, а не физическим рендерингом. Чтобы модель освещения могла называться физически-корректной она должна удовлетворять 3-м условиям (не волнуйтесь, мы скоро до них доберемся):
* Основываться на модели отражающих микрограней
* Подчиняться закону сохранения энергии
* Использовать двулучевую функцию отражательной способности (англ. Bidirectional reflectance distribution function — BRDF)
В данной серии туториалов мы сосредоточимся на подходе PBR, первоначально разработанном в Disney и адаптированным для реал-тайм визуализации компанией Epic Games. Их подход, базирующийся на *металл-диэлектрическом рабочем процессе* (англ. metallic workflow, *перевода лучше не нашел — прим. ред.*), неплохо документирован, широко принят во многих популярных движках и выглядит потрясающе. В конце этого раздела мы получим нечто похожее на это:
Имейте ввиду, что статьи в данном разделе довольно продвинуты, поэтому рекомендуется иметь хорошее представление об OpenGL и шейдерном освещении. Вот некоторые знания, которые вам понадобятся для изучения данного раздела: [буфер кадра](https://habrahabr.ru/post/347354/), [кубические карты](https://habrahabr.ru/post/347750/), [гамма-коррекция](https://habrahabr.ru/post/353632/), [HDR](https://habr.com/post/420409/) и [карты нормалей](https://habr.com/post/415579/). Также мы немного углубимся в математику, но я обещаю сделать все возможное чтобы объяснить все как можно понятнее.
### Модель отражающих микрограней
Все PBR-техники основываются на теории микрограней. Эта теория гласит что каждая поверхность при сильном увеличении может быть представлена как набор микроскопических зеркал, называемых **микрогранями**. Ввиду шероховатости поверхности эти микро-зеркала могут быть ориентированы в разных направлениях:
Чем более шероховата поверхность, тем более хаотично ориентированы ее микрограни. Результатом такого расположения этих маленьких зеркал является то ( в частности когда речь заходит о зеркальных бликах и отражениях), что падающие лучи света рассеиваются в разных направлениях на шероховатых поверхностях, что приводит к более широкому зеркальному блику. И наоборот: на гладких поверхностях падающие лучи вероятнее отразятся в одном направлении, что даст меньший и более резкий блик:
На микроскопическом уровне не бывает абсолютно гладких поверхностей, но учитывая то что микрограни достаточно малы и мы не можем провести различие между ними в рамках нашего пиксельного пространства, мы статистически аппроксимируем шероховатость поверхности вводя коэффициент **шероховатости**. С помощью этого коэффициента мы можем посчитать долю микрограней, ориентированных в направлении некоторого вектора . Этот вектор  ничто иное как медианный вектор, лежащий посередине между направлением падающего света  и направлением наблюдателя . Мы говорили о нем ранее, в уроке посвященном [продвинутому освещению](https://habrahabr.ru/post/353054/), где определили его как отношение суммы векторов  и  к длине полученного вектора:
Чем больше микрограней ориентировано в направлении медианного вектора, тем более резким и ярким будет зеркальный блик. Благодаря коэффициенту шероховатости, который лежит в пределах между 0 и 1, мы можем статистически аппроксимировать ориентацию микрограней:
Как видно, более высокое значение коэффициента шероховатости дает пятно зеркального блика большего размера, по сравнению с небольшим и резким пятном на гладких поверхностях.
### Сохранение энергии.
Использование приближения с учетом микрограней уже несет в себе некую форму сохранения энергии: энергия отраженного света никогда не превысит энергии падающего (если поверхность не светится сама по себе). Глядя на изображение выше мы видим, что с увеличением шероховатости поверхности пятно отраженного света увеличивается, но в то же время его яркость снижается. Если бы интенсивность отраженного света была одинаковой для всех пикселей независимо от размера пятна, то более шероховатые поверхности излучали бы гораздо больше энергии, что нарушило бы закон сохранения энергии. Поэтому зеркальные отражения более яркие на гладких поверхностях и тусклые на шероховатых.
Для того чтобы энергия сохранялась мы должны провести четкое разделение между диффузной и зеркальной компонентами. В тот момент когда луч света достигает поверхности, он разделяется на *отраженную* и *преломленную* составляющие. Отраженная составляющая — это свет, отраженный напрямую, и не проникающий внутрь поверхности, мы знаем его как зеркальную компоненту света. Преломленная составляющая представляет собой свет, который проникает внутрь поверхности и поглощается ей — он известен нам как диффузная компонента света.
Но есть некоторые нюансы связанные с поглощением света — оно не происходит мгновенно, как только свет касается поверхности. Из курса физики мы знаем, что свет может быть описан как пучок фотонов, обладающих энергией, который движется прямолинейно пока не потеряет всю энергию в результате столкновения с препятствиями. Каждый материал состоит из микрочастиц, которые могут взаимодействовать с лучом света, как показано на рисунке ниже. Эти частицы поглощают часть или всю энергии света при каждом столкновении, преобразуя ее в тепло.
В общем случае поглощается не вся энергия, и свет продолжает рассеиваться в (преимущественно) случайных направлениях, где опять сталкивается с другими частицами до тех пор его пока энергия не иссякнет, или он снова не покинет поверхность. Таким образом поверхность начинает заново испускать световые лучи, делая вклад в виде наблюдаемого (диффузного) цвета поверхности. Применяя PBR мы делаем упрощенное предположение, что весь преломленный свет поглощается и рассеивается на небольшой области воздействия, игнорируя эффект от рассеянного света, который покидает поверхность на расстоянии от это области. Особые шейдерные техники, которые учитывают это, известные как техники *подповерхностного рассеяния*, значительно повышают визуальное качество материалов вроде кожи, мрамора, воска, но дороги в плане производительности.
Дополнительные тонкости появляются при преломлении и отражении света на *металлических* поверхностях. Металлические поверхности иначе взаимодействуют со светом, нежели *неметаллические* (т.е. диэлектрики). Они подчиняются тем же законам преломления и отражения, за одним исключением: весь преломленный свет поглощается поверхностью без рассеивания, остается только зеркально-отраженный свет; другими словами металлические поверхности не имеют диффузного цвета. По причине этого очевидного различия между металлами и диэлектриками они будут по-разному обрабатываться в конвейере PBR в который мы углубимся далее по ходу статьи.
Это различие между отраженным и преломленным светом приводит нас к еще одному наблюдению относительно сохранения энергии: их величины взаимоисключающие. Энергия отраженного света не может быть поглощена материалом. Поэтому энергия, поглощенная поверхностью в виде преломленного света -это оставшаяся энергия после учета отраженной.
Мы используем данное соотношение, вычислив сперва отраженную часть как процент энергии падающих лучей, отраженных поверхностью, а затем долю преломленного света непосредственно из отраженной, как:
```
float kS = calculateSpecularComponent(...); // отраженная/зеркальная часть
float kD = 1.0 - kS; // преломленная/диффузная часть
```
Таким образом мы узнаем значения и отраженной и преломленной части благодаря закону сохранения энергии. При таком подходе ни преломленная (диффузная), ни отраженная часть не будет превышать 1.0, гарантируя, что суммарная их энергия не превысит значение энергии падающего света, чего мы не могли учесть в предыдущих уроках.
### Уравнение отражения
Вышесказанное подводит нас к так называемому [уравнению рендеринга](https://en.wikipedia.org/wiki/Rendering_equation): сложному уравнению, придуманному очень умными ребятами, и на сегодняшний день являющемуся лучшей моделью для имитации освещения. PBR строго следует более специфической версии этого уравнения, известной как **уравнение отражения**. Чтобы хорошо понимать PBR важно сперва иметь полное понимание уравнения отражения:
Поначалу оно выглядит пугающе, но мы будем разбирать его постепенно, по частям, и вы увидите как потихоньку оно начнет обретать смысл. Чтобы понять это уравнение нам придется немного углубиться в радиометрию. **Радиометрия** — это наука об измерении электромагнитного излучения (в том числе видимого света). Существует несколько радиометрических величин, которые мы можем использовать для измерения освещения, но мы будем использовать только одну, относящуюся к уравнению отражения, известную как Энергетическая яркость (англ. radiance) и обозначенную здесь буквой L. ЭЯ используется для количественной оценки величины или силы света, приходящего с определенного направления. ЭЯ, в свою очередь, является комбинацией нескольких физических величин, и, чтобы нам было легче представить ее себе, сосредоточимся на каждой из них в отдельности.
#### Поток излучения ( англ. radiant flux)
Поток излучения () это мощность переносимой светом энергии, измеряемая в ваттах. Общая энергия света складывается из множества слагаемых для разных длин волн, каждой из которых соответствует свой цвет спектра. Энергия, испускаемая источником света, в таком случае, может быть представлена как функция от всех этих длин волн. Длины волн от 390нм до 700нм составляют видимую часть спектра, то есть излучение в этом диапазоне может быть воспринято человеческим глазом. На изображении ниже вы можете видеть значения энергий для различных длин волн составляющих дневной свет:
Поток излучения соответствует площади под графиком этой функции от всех длин волн. Непосредственное использование длин волн света в качестве входных данных в компьютерной графике является непрактичным, поэтому мы прибегаем к упрощенному представлению потока излучения, используя вместо функции от всех длин волн триплет цветов, известный как RGB (или как мы обычно его называем — цвет освещения). Такое представление ведет к некоторой потере информации, но в целом это незначительно отразится на итоговой картине.
#### Телесный угол (англ. solid angle)
**Телесный угол**, обозначаемый как  дает нам размер или площадь фигуры, спроецированной на единичную сферу. Вы можете представить его как направление, имеющее объем:
Представьте себе, что вы находитесь в центре сферы и смотрите в направлении фигуры. Размер полученного силуэта и будет телесным углом.
#### Сила излучения (англ. radiance intensity)
Сила излучения измеряет количество потока излучения, приходящегося на телесный угол, или силу источника света, приходящуюся на площадь единичной сферы, определенную телесным углом. Например, для всенаправленного источника света, который одинаково излучает по всем направлениям, сила излучения означает энергию света, приходящуюся на определенную площадь (телесный угол):
Уравнение, описывающее силу излучения выглядит так:
, где I это поток излучения Ф, приходящийся на телесный угол
Зная поток излучения, силу и телесный угол мы можем описать уравнение энергетической яркости которое описывает полную наблюдаемую энергию на площади А, ограниченную телесным углом O для света силой 
Энергетическая яркость — это радиометрическая величина количества света в области, которая зависит от угла падающего света  ( угол между направлением света и нормалью к поверхности) через : свет слабее когда он излучается вдоль поверхности и сильнее всего когда он перпендикулярен ей. Это похоже на наши вычисления для диффузного света в туториале по [основам освещения](https://habrahabr.ru/post/333932/) так как  ничто иное как скалярное произведение между направлением света и вектором нормали к поверхности:
```
float cosTheta = dot(lightDir, N);
```
Уравнение энергетической яркости весьма полезно для нас, поскольку оно содержит в себе большинство интересующих нас физических величин. Если мы будем считать, что телесный угол ω и площадь A бесконечно малы, мы можем использовать ЭЯ для измерения потока одного луча света, приходящегося на одну точку пространства. Это позволит нам вычислить ЭЯ отдельного светового луча, воздействующего на отдельную точку (фрагмент); мы фактически переводим телесный угол  в вектор направления  и  в точку . Таким образом, мы можем напрямую использовать ЭЯ в наших шейдерах для расчета вклада отдельного луча света для каждого фрагмента.
На самом деле, когда речь идет об ЭЯ, нас обычно интересует весь входящий свет, приходящийся на точку p, который является суммой всей ЭЯ, и известен как облучённость (англ. irradiance). Зная ЭЯ и облучённость мы можем вернуться к уравнению отражения:
Теперь мы знаем, что  в уравнении рендеринга представляет собой ЭЯ для некоторой точки поверхности p и некоторого бесконечно малого телесного угла входящего света , который можно рассматривать как входящий вектор направления . Помните, что энергия умножается на  — угла между направлением падения света и нормалью поверхности, что выражено в уравнении отражения произведением . Уравнение отражения вычисляет сумму отраженной ЭЯ  точки  в направлении , которое является исходящим направлением к наблюдателю. Или иначе:  измеряет отраженную облучённость точки , если смотреть из .
Поскольку уравнение отражения основано на облучённости, которая является суммой всего входящего излучения, мы измеряем свет не только одного входящего светового направления, а со всех входящих направлений света в пределах полусферы , с центром в точке . Ее можно описать как половину сферы, ориентированной вдоль нормали поверхности :
Чтобы вычислить сумму всех значений внутри области, или, в случае полусферы, объема, мы проинтегрируем уравнение по всем входящим направлениям  в пределах полусферы . Поскольку нет аналитического решения как для уравнения рендера, так и для уравнения отражения, мы будем решать интеграл численно. Это означает что мы получим результаты для небольших дискретных шагов уравнения отражения по полусфере  и усредним их по размеру шага. Это называется **суммой Римана**, которую мы можем грубо представить следующим кодом:
```
int steps = 100;
float sum = 0.0f;
vec3 P = ...;
vec3 Wo = ...;
vec3 N = ...;
float dW = 1.0f / steps;
for(int i = 0; i < steps; ++i)
{
vec3 Wi = getNextIncomingLightDir(i);
sum += Fr(P, Wi, Wo) * L(P, Wi) * dot(N, Wi) * dW;
}
```
dW для каждого дискретного шага можно рассматривать как  в уравнении отражения. Математически  является дифференциалом, по которому мы вычисляем интеграл, и хотя он и не то же самое что dW в коде (поскольку это дискретный шаг суммы Римана), мы можем считать его таковым для простоты вычислений. Имейте в виду, что использование дискретных шагов всегда даст нам приближенную сумму, а не точное значение интеграла. Внимательный читатель заметит, что мы можем повысить точность суммы Римана, увеличив количество шагов.
Уравнение отражения суммирует излучение всех входящих световых направлений  по полусфере , которое достигает точки  и возвращает сумму отраженного света  в направлении зрителя. Входящее излучение может исходить от источников света, с которыми мы уже знакомы, или с карт окружения, определяющих ЭЯ каждого входящего направления, о чем мы поговорим в туториале IBL.
Теперь единственным неизвестным слева является символ , известный как функция **BRDF** или **двулучевая функция отражательной способности**, которая масштабирует (или взвешивает) значение входящего излучения на основе свойств материала поверхности.
### BRDF
BRDF является функцией, которая принимает на вход направление падающего света , направление на наблюдателя , нормаль к поверхности  и параметр , который представляет собой шероховатость поверхности. BRDF аппроксимирует, насколько каждый отдельный световой луч  вносит вклад в конечный отраженный свет непрозрачной поверхности с учетом свойств ее материала. Например, если поверхность совершенно гладкая (почти как зеркало), функция BRDF вернет 0.0 для всех входящих световых лучей , за исключением одного, имеющего тот же угол (после отражения), что и луч , для которого функция вернет 1.0.
BRDF аппроксимирует отражающие и преломляющие свойства материала на основе ранее упомянутой теории микрограней. Для того, чтобы BRDF была физически правдоподобной, она должна подчиняться закону сохранения энергии, т. е. суммарная энергия отраженного света никогда не должна превышать энергии падающего света. Технически, модель Блинна-Фонга считается BRDF, принимающим те же самые  и  на вход. Однако модель Блинна-Фонга не считается физически-корректной, поскольку она не гарантирует соблюдения закона сохранения энергии. Существует несколько физически-корректных BRDF для аппроксимации реакции поверхности на освещение. Тем не менее, почти все графические конвейеры реального времени используют BRDF, известную как **BRDF Кука-Торренса** (Cook-Torrance).
BRDF Кука-Торренса содержит как диффузную, так и зеркальную часть:
здесь  — преломленная доля входящей световой энергии,  — отраженная. Левая часть BRDF содержит диффузную часть уравнения, обозначенную здесь как . Это, так называемое Ламбертово рассеяние. Оно аналогично тому, что мы использовали для диффузного освещения, и является постоянным:
где  — альбедо или цвет поверхности (диффузная текстура поверхности). Деление на  нужно, чтобы нормировать рассеянный свет, поскольку ранее обозначенный интеграл, содержащий BRDF, умножается на  (мы доберемся до этого в туториале IBL).
> Вы можете быть удивлены тем, как это Ламбертово рассеяние похоже на выражение для диффузного освещения, которое мы использовали раньше: цвет поверхности, умноженный на скалярное произведение между нормалью поверхности и направлением света. Скалярное произведение все еще присутствует, но выведено из BRDF, поскольку мы имеем  в интеграле .
Существуют различные уравнения для диффузной части BRDF, которые выглядят более реалистичными, однако они дороже в плане производительности. К тому же, как заключили в Epic Games: Ламбертового рассеяния вполне достаточно для большинства целей рендеринга в реальном времени.
Зеркальная часть BRDF Кука-Торренса немного усовершенствована и описывается как:
Она состоит из трех функций и коэффициента нормирования в знаменателе. Каждая из букв D, F и G представляет собой определенный тип функции, которая аппроксимирует определенную часть отражающих свойств поверхности. Они известны как функция нормального распределения(normal **D**istribution function, NDF), уравнение Френеля (**F**resnel equation) и Функция геометрии(**G**eometry function):
* Функция нормального распределения: аппроксимирует количество микрограней поверхности, ориентированных по медианному вектору, основываясь на шероховатости поверхности; это основная функция, аппроксимирующая микрограни.
* Функция геометрии: описывает свойство самозатенения микрограней. Когда поверхность довольно шероховатая, одни микрограни поверхности могут перекрывать другие, тем самым уменьшая количество света, отражаемого поверхностью.
* Уравнение Френеля: описывает коэффициент поверхностного отражения при разных углах.
Каждая из этих функций является приближением их физического эквивалента, и для них существуют различные реализации, направленные на более точное приближение к лежащей в их основе физической модели; некоторые дают более реалистичные результаты, другие более эффективны с точки зрения производительности. Брайан Карис из Epic Games провел много исследований по разным типам приближений, подробнее с которыми вы можете ознакомиться [здесь](http://graphicrants.blogspot.nl/2013/08/specular-brdf-reference.html). Мы будем использовать те же функции, что и в Unreal Engine 4 от Epic Games, а именно: *Trowbridge-Reitz GGX* для D, приближение *Френеля-Шлика* для F и *Smith's Schlick-GGX* для G.
### Функция нормального распределения
Функция нормального распределения D статистически аппроксимирует относительную площадь поверхности микрограней, точно ориентированных по медианному вектору . Существует множество NDF определяющих статистическую аппроксимацию общего выравнивания микрограней с учетом некоторого параметра шероховатости. Мы будем использовать одну, известную как Trowbridge-Reitz GGX:
здесь  — это медианный вектор,  — значение шероховатости поверхности. Если мы выберем  как медианный вектор между нормалью к поверхности и направлением света, то изменяя параметр шероховатости, получим следующую картину:
Когда шероховатость мала (т.е. поверхность гладкая), микрограни ориентированные в направлении медианного вектора концентрируются в небольшом радиусе. Благодаря этой высокой концентрации NDF дает очень яркое пятно. На шероховатой же поверхности, где микрограни ориентированы в более случайных направлениях, вы обнаружите гораздо большее количество микрограней, ориентированных в направлении медианного вектора , но расположенных в большем радиусе, что делает цвет пятна более серым.
В коде GLSL функция нормального распределения Trowbridge-Reitz GGX будет выглядеть примерно так:
```
float DistributionGGX(vec3 N, vec3 H, float a)
{
float a2 = a*a;
float NdotH = max(dot(N, H), 0.0);
float NdotH2 = NdotH*NdotH;
float nom = a2;
float denom = (NdotH2 * (a2 - 1.0) + 1.0);
denom = PI * denom * denom;
return nom / denom;
}
```
### Функция геометрии
Функция геометрии статистически аппроксимирует относительную площадь поверхности, где ее микроскопические неровности перекрывают друг друга, что не дает проникать световым лучам.
Как и в случае с NDF, функция геометрии принимает на вход коэффициент шероховатости поверхности, что в данном случае означает следующее: более шероховатые поверхности будут иметь более высокую вероятность затенения микрограней. Функция геометрии, которую мы будем использовать, представляет собой комбинацию приближения GGX и Шлика-Бекмана (Schlick-Beckmann), и известна как Schlick-GGX:
Здесь  является переобозначением  в зависимости от того, используем ли мы функцию геометрии для прямого освещения или освещения IBL:
Обратите внимание, что значение  может отличаться в зависимости от того, как ваш движок переводит шероховатость в . В следующих уроках мы подробно обсудим, как и где это переназначение становится актуальным.
Чтобы эффективно аппроксимировать геометрию, нам необходимо учитывать как направление обзора (перекрытие геометрии), так и вектор направления света (самозатенение геометрии). Мы можем учитывать оба случая с помощью *метода Смита*:
Использование метода Смита с Schlick-GGX в качестве дает следующую картинку при различной шероховатости R:
Функция геометрии представляет собой множитель между [0.0, 1.0], где белый (или 1.0) означает отсутствие затенения микрограней, а черный (или 0.0) означает полное затенение микрограней.
В GLSL функция геометрии преобразуется в следующий код:
```
float GeometrySchlickGGX(float NdotV, float k)
{
float nom = NdotV;
float denom = NdotV * (1.0 - k) + k;
return nom / denom;
}
float GeometrySmith(vec3 N, vec3 V, vec3 L, float k)
{
float NdotV = max(dot(N, V), 0.0);
float NdotL = max(dot(N, L), 0.0);
float ggx1 = GeometrySchlickGGX(NdotV, k);
float ggx2 = GeometrySchlickGGX(NdotL, k);
return ggx1 * ggx2;
}
```
### Уравнение Френеля
Уравнение Френеля описывает отношение отраженного и преломленного света, которое зависит от угла, под который мы смотрим на поверхность. Когда свет попадает на поверхность, уравнение Френеля дает нам процент отраженного света на основании угла, под которым мы видим эту поверхность. Из этого соотношения отражения и закона сохранения энергии мы можем непосредственно получить преломленную часть света, которая будет равна оставшейся энергии.
Каждая поверхность или материал имеет уровень *базовой отражательной способности*, наблюдаемый при взгляде на поверхность прямо, но если смотреть на поверхность под углом, [все](http://filmicworlds.com/blog/everything-has-fresnel/) отражения становятся более заметными. Вы можете проверить это самостоятельно, взглянув на ваш, вероятно, деревянный или металлический стол сначала перпендикулярно, а затем под углом близким к 90 градусам. Вы увидите, что отражения становятся намного более заметными. Все поверхности, теоретически, полностью отражают свет, если смотреть на них под идеальным углом в 90 градусов. Этот эффект получил имя Френеля и описывается **уравнением Френеля**.
Уравнение Френеля является довольно сложным, но, к счастью, его можно упростить с помощью **приближения Френеля-Шлика**:
 представляет базовую отражательную способность поверхности, которую мы вычисляем используя нечто, называемое показателями преломления или **IOR** (indices of refraction), и, как вы можете видеть на поверхности сферы, чем ближе направление обзора к границам видимой сферы (при этом угол между направлением обзора и медианным вектором достигает 90 градусов ), тем сильнее эффект Френеля и, следовательно, отражения:
Существует несколько тонкостей, связанных с уравнением Френеля. Первая заключается в том, что приближение Френеля-Шлика действительно только для *диэлектриков* или неметаллических поверхностей. Для поверхностей проводников (металлов), вычисление базовой отражательной способности с использованием показателей преломления будет неверным, и нам нужно использовать другое уравнение Френеля для проводников. Поскольку это неудобно, мы используем предварительно вычисленные значения для поверхностей при нормальном падении () (с углом 0 градусов, как если бы мы смотрели прямо на поверхность) и интерполируем это значение на основе угла обзора в соответствии с приближением Френеля-Шлика, так что мы можем использовать одно и то же уравнение как для металлов, так и для неметаллов.
Отклик поверхности при нормальном падении или базовая отражательная способность может быть найдена в больших базах данных вроде [этой](http://refractiveindex.info/). Некоторые распространенные значения, перечисленные ниже, взяты из примечаний к курсу Нати Хоффмана:
Интересное наблюдение: для всех диэлектрических поверхностей базовая отражательная способность никогда не поднимается выше 0.17, что является скорее исключением, нежели правилом, тогда как для проводников базовая отражательная способность расположена значительно выше и (в основном) лежит в диапазоне от 0.5 до 1.0. Кроме того, для проводников или металлических поверхностей базовая отражательная способность “подкрашивается”, поэтому  представлен как триплет RGB (отражательная способность при нормальном падении может меняться в зависимости от длины волны).
Эти специфические признаки металлических поверхностей по сравнению с диэлектрическими породили нечто, называемое metallic workflow: когда мы создаем материалы поверхностей с дополнительным параметром, известным как металличность (metalness), который описывает, является поверхность металлической или нет.
> Теоретически металличность поверхности принимает только два значения: это либо металл, либо нет; поверхность не может быть и тем, и другим. Тем не менее, большинство конвейеров рендера позволяют настраивать металличность поверхности линейно между 0.0 и 1.0. Это происходит главным образом из-за отсутствия в текстуре материала достаточной точности для создания поверхности, например, с небольшими частицами пыли и песка, царапинами на поверхности металла. Изменяя значение металличности вокруг этих мелких неметаллических частиц и царапин, мы получаем визуально более приятные результаты.
>
>
Предварительно вычисляя  как для диэлектриков, так и для металлов, мы можем использовать одно и то же приближение Френеля-Шлика для обоих типов поверхностей, но нам нужно подкрашивать базовую отражательную способность, если у нас есть металлическая поверхность. Обычно мы делаем это следующим образом:
```
vec3 F0 = vec3(0.04);
F0 = mix(F0, surfaceColor.rgb, metalness);
```
Мы определили базовую отражательную способность, приблизительно одинаковую для большинства диэлектрических поверхностей. Это еще одно приближение, поскольку  усредняется по большинству распространенных диэлектриков. Базовая отражательная способность 0.04 сохраняется для большинства диэлектриков и дает физически правдоподобные результаты без необходимости задания дополнительного параметра поверхности. Поэтому, в зависимости от типа поверхности, мы либо берем базовую отражательную способность диэлектрика, либо считаем F0 заданную цветом поверхности. Поскольку металлические поверхности поглощают весь преломленный свет, они не имеют диффузных отражений, и мы можем непосредственно использовать диффузную текстуру поверхности в качестве базовой отражательной способности.
Переведем приближение Френеля-Шлика в код:
```
vec3 fresnelSchlick(float cosTheta, vec3 F0)
{
return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0);
}
```
где cosTheta есть результат скалярного произведения между вектором нормали поверхности и направлением обзора.
### Уравнение отражения Кука-Торренса
Зная все компоненты BRDF Кука-Торренса мы можем включить ее в окончательное уравнение отражения:
Однако это уравнение не полностью верно математически. Вероятно, вы помните, что уравнение Френеля F представляет собой коэффициент количества света отраженного поверхностью. То есть фактически это наш коэффициент , что означает, что зеркальная часть уравнения отражения уже содержит . Учитывая это, наше окончательное уравнение отражения запишется так:
В этом уравнении теперь полностью описывается физическая модель рендеринга, которую обычно мы называем физически корректным рендерингом или PBR. Не волнуйтесь, если вы еще не полностью поняли, как нам нужно оформить всю обсуждаемую математику в виде кода. В следующих уроках мы рассмотрим как использовать уравнение отражения, чтобы получить гораздо более физически правдоподобные результаты в нашем рендеринге, и все кусочки понемногу соберутся в единое целое.
### Создание материалов для PBR
Теперь, зная основную математическую модель PBR, мы завершаем обсуждение описанием того, как художники обычно задают физические свойства поверхности, которые мы можем напрямую передать в уравнения PBR. Каждый из параметров поверхности, которые нам нужны для конвейера PBR, может быть определен или смоделирован текстурами. Использование текстур дает нам пофрагментный контроль над тем, как каждая конкретная точка поверхности должна реагировать на свет: является ли она металлической, шероховатой или гладкой или как данная поверхность реагирует на разные длины волн света.
Ниже вы увидите список текстур, которые часто можно встретить в конвейере PBR, а также результат их применения:
**Альбедо**: текстура альбедо определяет для каждого текселя цвет поверхности или базовую отражательную способность, если этот тексель металлический. Это во многом напоминает диффузные текстуры что мы использовали раньше, но вся информация об освещении убирается из текстуры. Диффузные текстуры часто имеют небольшие тени или затемненные трещины внутри изображения, что не нужно в текстуре альбедо; она должна содержать только цвет поверхности.
**Нормали**: текстура карты нормалей, точно такая же, какую мы использовали ранее в туториале по [картам нормалей](https://habr.com/post/415579/). Карта нормалей позволяет нам задать для каждого фрагмента свою нормаль, дабы создать иллюзию, что поверхность более выпуклая.
**Металличность**: карта металличности определяет является тексель металлическим или нет. В зависимости от того, как настроен PBR-движок, художники могут задавать металличность как оттенками серого, так и только двумя цветами: черным и белым.
**Шероховатость**: карта шероховатости указывает, насколько шероховатая поверхность находится в основе текселя. Выбранное из текстуры значение шероховатости определяет статистическую ориентацию микрограней поверхности. На более шероховатой поверхности получаются более широкие и размытые отражения, тогда как на гладкой поверхность они сфокусированные и четкие. Некоторые PBR-движки используют карты гладкости вместо карты шероховатости, которые некоторые художники находят более интуитивно понятными, но эти значения переводятся в шероховатость (1.0 — гладкость) в момент выборки.
**AO (ambient occlusion)**: карты фонового затенения или AO определяют дополнительный коэффициент затенения поверхности и окружающей геометрии. Если у нас есть кирпичная поверхность, например, текстура альбедо не должна иметь никакой информации о затенении внутри щелей кирпича. Карта AO как раз определяет эти затемненные грани, за которые свету труднее проникнуть. Учитывая АО в конце этапа освещения мы можем значительно повысить визуальное качество сцены. Карты АО для мешей и поверхности либо генерируется вручную, либо предварительно вычисляется в программах 3D-моделирования.
Художники устанавливают и настраивают входные значения для каждого текселя и могут основывать свои текстуры на физических свойствах поверхности реальных материалов. Это одно из самых больших преимуществ конвейера PBR, так как эти физические свойства поверхности остаются неизменными от условий окружающей среды или освещения, что облегчает жизнь художникам в получении правдоподобных результатов. Поверхности, созданные в конвейере PBR, могут быть легко использованы в различных PBR-движках, и будут выглядеть корректно независимо от среды, в которой они находятся, что в результате выглядит намного более естественно.
#### Материалы по теме
* [Background: Physics and Math of Shading by Naty Hoffmann:](http://blog.selfshadow.com/publications/s2013-shading-course/hoffman/s2013_pbs_physics_math_notes.pdf) очень много теории, чтобы уместиться в рамках одной статьи, поэтому теория здесь едва затрагивает основы; если вы хотите больше узнать о физике света и о том как она связана с теорией PBR, этот ресурс must-read для вас.
* [Real shading in Unreal Engine 4](http://blog.selfshadow.com/publications/s2013-shading-course/karis/s2013_pbs_epic_notes_v2.pdf): обсуждение модели PBR, принятой Epic Games в Unreal Engine 4. PBR, о котором мы говорим в этих туториалах, основана на этой модели.
* [Marmoset: PBR Theory](https://www.marmoset.co/toolbag/learn/pbr-theory): введение в PBR. В основном предназначено для художников, но, тем не менее, стоит прочесть.
* [Coding Labs: Physically based rendering](http://www.codinglabs.net/article_physically_based_rendering.aspx): основы уравнения рендеринга и то, как оно связано к PBR.
* [Coding Labs: Physically Based Rendering — Cook–Torrance](http://www.codinglabs.net/article_physically_based_rendering_cook_torrance.aspx): основные положения BRDF Кука-Торренса
* [Wolfire Games — Physically based rendering](http://blog.wolfire.com/2015/10/Physically-based-rendering): введение в PBR от Lukas Orsvärn.
* [[SH17C] Physically Based Shading](https://www.shadertoy.com/view/4sSfzK): отличный интерактивный shadertoy (предупреждение: может долго грузиться) от Krzysztof Narkowi, демонстрирует взаимодействие света с материалом PBR. | https://habr.com/ru/post/426123/ | null | ru | null |
# У нас проблемы с промисами
*Разрешите представить вам перевод статьи Нолана Лоусона «[У нас проблемы с промисами](http://pouchdb.com/2015/05/18/we-have-a-problem-with-promises.html)», одной из лучших по теме из тех, что мне доводилось читать.*
### У нас проблемы с промисами
Дорогие JavaScript разработчики, настал момент признать это — у нас проблемы с промисами.
Нет, не с самими промисами. Их реализация по [спецификации A+](https://promisesaplus.com) превосходна. Основная проблема, которая сама предстала передо мной за годы наблюдений за тем, как многие программисты борются с богатыми на промисы API, заключается в следующем:
— Многие из нас используют промисы без действительного их понимания.
Если вы мне не верите, решите такую задачку:
**Вопрос: В чем разница между этими четырьмя вариантами использования промисов?**
```
doSomething().then(function () {
return doSomethingElse();
});
doSomething().then(function () {
doSomethingElse();
});
doSomething().then(doSomethingElse());
doSomething().then(doSomethingElse);
```
Если вы знаете ответ, то разрешите вас поздравить — по части промисов вы ниндзя. Пожалуй, дальше этот пост вам можно не читать.
Остальным 99,99% из вас я спешу сказать, чтобы вы не расстраивались, вы в хорошей компании. Никто из тех, кто ответил на [мой твит](https://twitter.com/nolanlawson/status/578948854411878400), не смог решить задачу. Даже я был очень удивлен ответом на 3-й вопрос. Да-да, несмотря на то, что это я его задал!
Ответ на задачу приведен в самом конце статьи, но сначала я хотел бы объяснить, почему промисы в первом приближении такие коварные, и почему многие из нас, новички и эксперты, попадаются в их ловушки. Также я хочу предложить вам свое решение, один необычный трюк, который поможет лучше понять промисы. И, разумеется, я верю, что после моего объяснения они уже не покажутся вам такими сложными.
Прежде, чем начать, давайте обозначим некоторые моменты.
### Почему промисы?
Если вы читаете статьи о промисах, то часто будете встречать отсылки на «[пирамиду зла](https://medium.com/@wavded/managing-node-js-callback-hell-1fe03ba8baf)» («pyramide of doom» в ориг.), образованную ужасным кодом на колбэках, который растягивает страницу направо за экран.
Промисы действительно решают эту проблему, но это нечто большее, чем просто уменьшение отступов. Как объясняется в замечательной беседе «[Спасение из ада колбэков](http://www.youtube.com/watch?v=hf1T_AONQJU)», настоящая их проблема в том, что они лишают нас возможности использовать инструкции **return** и **throw**. Вместо этого логика наших программ основана на использовании побочных эффектов, когда одна функция вызывает другую.
Также колбэки делают что-то действительно зловещее, они лишают нас стека, того, что в языках программирования принимается как должное. Писать код без стека — это все равно, что вести автомобиль без педали тормоза. Вы не представляете, насколько она важна до тех пор, пока она вам действительно не понадобится и ее не окажется на месте.
Весь смысл промисов в том, чтобы вернуть нам основы языка, потерянные в момент нашего перехода на асинхронность: **return**, **throw** и стек. Но вы должны знать, как правильно использовать промисы, чтобы подняться в этом на более высокий уровень.
Ошибки новичков
---------------
Кто-то пытается объяснить промисы [в виде мультика](http://andyshora.com/promises-angularjs-explained-as-cartoon.html) или, говоря словами: *«О! Это штука, которую вы можете создать и передавать всюду, а она собой символизирует какое-то значение, получаемое и возвращаемое асинхронно»*.
Я не нахожу такое объяснение достаточно полезным. Для меня промисы — это всегда часть структуры кода, его потока выполнения.
Небольшое отступление: термин «промисы» для разных людей несет в себе разный смысл. В этой статье я буду рассказывать об [официальной спецификации](https://promisesaplus.com), доступной в современных браузерах как **window.Promise**. Для тех браузеров, которые не имеют **window.Promise**, есть хороший полифил с нахальным названием [Lie](https://github.com/calvinmetcalf/lie) (ложь), содержащий минимальную реализацию спецификации.
### Ошибка новичка №1 — «пирамида зла» из промисов
Глядя, как люди используют PouchDB, API которого сильно завязано на промисах, я вижу немало плохих паттернов их использования. Вот наиболее распространенный пример:
```
remotedb.allDocs({
include_docs: true,
attachments: true
}).then(function (result) {
var docs = result.rows;
docs.forEach(function(element) {
localdb.put(element.doc).then(function(response) {
alert("Pulled doc with id " + element.doc._id + " and added to local db.");
}).catch(function (err) {
if (err.status == 409) {
localdb.get(element.doc._id).then(function (resp) {
localdb.remove(resp._id, resp._rev).then(function (resp) {
// и так далее…
```
Да, получается, что мы можем использовать промисы так, будто это колбэки, и да, это все равно, что стрелять из пушки по воробьям.
Если вы думаете, что подобные ошибки совершают только абсолютные новички, я вас удивлю — код [примера выше](https://github.com/blackberry/BB10-WebWorks-Community-Samples/blob/d6ee75fe23a10d2d3a036013b6b1a0c07a542099/pdbtest/www/js/index.js) взят из [официального блога разработчиков BlackBerry](http://devblog.blackberry.com/2015/05/connecting-to-couchbase-with-pouchdb/)! От старой привычки использовать колбэки избавиться трудно.
Вот вариант получше:
```
remotedb.allDocs(...)
.then(function (resultOfAllDocs) {
return localdb.put(...);
})
.then(function (resultOfPut) {
return localdb.get(...);
})
.then(function (resultOfGet) {
return localdb.put(...);
})
.catch(function (err) {
console.log(err);
});
```
В примере выше использовались составные промисы («composing promises» в ориг.) — одна из сильнейших сторон промисов. Каждая последующая функция будет вызвана, когда предыдущий промис «зарезолвится», и вызвана она будет с результатом работы предыдущего промиса. Подробности будут ниже.
### Ошибка новичка №2 — как мне использовать forEach() с промисами?
Это тот момент, когда понимание промисов большинством людей начинает сдавать. Они хорошо знакомы с итераторами **forEach**, **for** или **while**, но не имеют ни малейшего представления, как сочетать их с промисами. Тогда рождается что-то подобное:
```
// Я хочу применить remove() ко всем документам
db.allDocs({include_docs: true})
.then(function (result) {
result.rows.forEach(function (row) {
// Метод remove возвращает promise
db.remove(row.doc);
});
})
.then(function () {
// А здесь я наивно уверен, что все документы уже удалены!
});
```
Что не так с этим кодом? Проблема в том, что первая функция возвращает **undefined**, а значит вторая не ждет окончания выполнения **db.remove()** для всех документов. На самом деле она вообще ничего не ждет и выполнится, когда будет удалено любое число документов, а может и ни одного.
Это очень коварная ошибка, потому что поначалу вы можете ее даже не заметить, особенно, если документы будут удаляться достаточно быстро для обновления интерфейса. Бага может всплывать только в редких случаях, не во всех браузерах, а значит, выявить и устранить ее будет практически невозможно.
Подводя итог, скажу, что конструкции типа **forEach**, **for** и **while** *«не те дроны, что вы ищете»*. Вам нужен **Promise.all()**:
```
db.allDocs({include_docs: true})
.then(function (result) {
var arrayOfPromises = result.rows.map(function (row) {
return db.remove(row.doc);
});
return Promise.all(arrayOfPromises);
})
.then(function (arrayOfResults) {
// Вот теперь все документы точно удалены!
});
```
Что здесь происходит? **Promise.all()** принимает в качестве аргумента массив промисов и возвращает новый промис, который «зарезолвится», только когда все документы будут удалены. Это асинхронный эквивалент цикла **for**.
Также промис из **Promise.all()** передаст в следующую функцию массив результатов, что может быть очень удобно, если вы, например, не удаляете документы, а получаете данные сразу из нескольких источников. Если хотя бы один промис из массива, переданного в **Promise.all()** «зареджектится», то и результирующий промис перейдет в состояние **rejected**.
### Ошибка новичка №3 — забываем добавлять .catch()
Это еще одна распространенная ошибка — блаженно верить, что ваши промисы никогда не вернут ошибку. Многие разработчики просто забывают добавлять **catch()** куда-либо в своем коде.
К сожалению, часто это означает, что ошибки будут «проглочены». Вы даже никогда не узнаете, что они были — особая боль при отладке приложения.
Чтобы избежать этого неприятного сценария, я взял за правило, которое затем переросло в привычку, всегда добавлять в конец моей цепочки промисов метод **catch()**:
```
somePromise().then(function () {
return anotherPromise();
})
.then(function () {
return yetAnotherPromise();
})
// простое и полезное окончание цепочки промисов:
.catch(console.log.bind(console));
```
Даже если вы гарантированно, стопроцентно не ожидаете каких-либо ошибок, добавление **catch()** будет разумным решением. Потом, если вдруг ваше предположение насчет ошибок не оправдается, вы скажете себе спасибо.
### Ошибка новичка №4 — использование «deferred»
Такую ошибку я вижу постоянно и не хочу даже повторять название этого объекта, опасаясь, что он, подобно [Битлджусу](https://afisha.mail.ru/cinema/movies/625126_bitldzhus/) из одноименного фильма, только того и ждет, чтобы увеличить число случаев своего использования.
Вкратце, в своем развитии промисы прошли долгую историю. У JavaScript сообщества ушло много времени на то, чтобы реализовать их правильно. Поначалу jQuery и Angular повсеместно использовали паттерн deferred-объектов, который впоследствии был заменен на спецификацию промисов ES6, в основе которой лежали «хорошие» библиотеки Q, When, RSVP, Bluebird, Lie и другие.
В общем, если вы вдруг написали это слово в своем коде (я не повторю его в третий раз!), знайте — вы что-то делаете не так. Ниже рецепт, как этого избежать.
Большинство «промисных» библиотек дают вам возможность импортировать промисы из других библиотек. Например, модуль **$q** из Angular позволяет вам обернуть не-$q промисы при помощи **$q.when()**. То есть пользователи Angular могут оборачивать промисы из PouchDB так:
```
// это все, что нужно:
$q.when(db.put(doc)).then(/* ... */);
```
Другой путь — использование [паттерна раскрытия конструктора](https://blog.domenic.me/the-revealing-constructor-pattern/) («revealing constructor pattern» в ориг.). Он удобен для оборачивания API, не использующего промисы. Например, чтобы обернуть основанное на колбэках API Node.js, вы можете сделать следующее:
```
new Promise(function (resolve, reject) {
fs.readFile('myfile.txt', function (err, file) {
if (err) {
return reject(err);
}
resolve(file);
});
}).then(/* ... */)
```
Готово! Мы расправились с ужасным defer… Ах, чуть не произнес в третий раз! :)
### Ошибка новичка №5 — использование внешних функций вместо возвращения результата
Что не так с этим кодом?
```
somePromise().then(function () {
someOtherPromise();
})
.then(function () {
// Ох, я надеюсь someOtherPromise «зарезолвился»…
// Осторожно, спойлер: нет, не «зарезолвился».
});
```
Хорошо, сейчас идеальный момент для того, чтобы поговорить обо всем том, что вы вообще должны знать о промисах.
Серьезно, это тот самый трюк, поняв который, вы сами сможете избежать всех тех ошибок, о которых мы говорили. Вы готовы?
Как я уже упоминал, магия промисов в том, что они возвращают нам драгоценные **return** и **throw**. Но что это означает на практике?
Каждый промис предоставляет вам метод **then()** (а еще **catch()**, который на практике просто «сахар» для **then(null, …)**). И вот мы внутри функции **then()**:
```
somePromise().then(function () {
// Вау, мы внутри функции then()!
});
```
Что мы можем тут сделать? Три вещи:
1. Вернуть (**return**) другой промис
2. Вернуть (**return**) синхронное значение (или **undefined**)
3. Выдать (**throw**) синхронную ошибку
Вот и все, весь трюк. Поймете его — поймете промисы. Давайте теперь разберем подробно каждый из пунктов.
#### 1. Вернуть другой промис
Это частый паттерн, который вы могли видеть во всевозможной литературе о промисах, а также в примере с составными промисами выше:
```
getUserByName('nolan').then(function (user) {
// Функция getUserAccountById возвращает promise,
// результат которого попадет в следующий then
return getUserAccountById(user.id);
})
.then(function (userAccount) {
// Я знаю все о пользователе!
});
```
Обратите внимание, что я именно возвращаю второй промис, использую **return**. Использование здесь **return** — это ключевой момент. Если бы я просто вызвал **getUserAccountById**, то да, был бы запрос за данными пользователя, был бы получен результат, который нигде бы не пригодился — следующий **then** получил бы **undefined** вместо желанного **userAccount**.
#### 2. Вернуть синхронное значение (или undefined)
Возвращение **undefined** в качестве результата — частая ошибка. А вот возвращение какого-либо синхронного значения — отличный способ преобразовать синхронный код в цепочку промисов. Допустим, у нас в памяти есть кэш данных о пользователях. Мы можем:
```
getUserByName('nolan').then(function (user) {
if (inMemoryCache[user.id]) {
// Данные этого пользователя уже есть,
// возвращаем сразу
return inMemoryCache[user.id];
}
// А вот про этого пока не знаем,
// вернем промис запроса
return getUserAccountById(user.id);
})
.then(function (userAccount) {
// Я знаю все о пользователе!
});
```
Разве не круто? Второй функции в цепочке не важно, откуда взялись данные, из кэша или как результат запроса, а первая вольна вернуть или синхронное значение сразу, или асинхронный промис, который уже в свою очередь вернет синхронное значение.
К сожалению, если вы не использовали **return**, то функция все равно вернет значение, но им будет уже не результат вызова вложенной функции, а бесполезный **undefined**, возвращаемый в таких случаях по-умолчанию.
Для себя я ввел правило, которое затем переросло в привычку — всегда использовать **return** внутри then или выдавать ошибку при помощи **throw**. Я рекомендую вам поступать так же.
#### 3. Выдавать синхронную ошибку
Вот мы и подошли к **throw**. Здесь промисы начинают сиять еще ярче. Предположим, мы хотим выдать (**throw**) синхронную ошибку, если пользователь не авторизован. Это просто:
```
getUserByName('nolan').then(function (user) {
if (user.isLoggedOut()) {
// Пользователь вышел — выдаем ошибку!
throw new Error('user logged out!');
}
if (inMemoryCache[user.id]) {
// Данные этого пользователя уже есть,
// возвращаем сразу
return inMemoryCache[user.id];
}
// А вот про этого пока не знаем,
// вернем промис запроса
return getUserAccountById(user.id);
})
.then(function (userAccount) {
// Я знаю все о пользователе!
})
.catch(function (err) {
// Упс, ошибка, но мы к ней готовы!
});
```
Наш **catch()** получит синхронную ошибку, если пользователь не авторизован, или асинхронную, если любой из промисов выше перейдет в состояние **rejected**. И снова, функции в **catch** без разницы, была ошибка синхронной или асинхронной.
Это особенно удобно для отлавливания ошибок во время разработки. Например, формирование объекта из строки при помощи **JSON.parse()** где-либо внутри **then()** может выдать ошибку, если **json** невалидный. С колбэками она будет «проглочена», но при помощи метода **catch()** мы без труда сможем ее обработать.
Продвинутые ошибки
------------------
Хорошо, теперь, когда вы выучили главный трюк промисов, давайте поговорим о крайних случаях. Потому что крайние случаи есть всегда.
Эту категорию ошибок я называю «продвинутые», потому что встречал их только в коде хорошо знакомых с промисами программистов. Обсудить подобные ошибки мы должны для того, чтобы разобрать задачку, которую я опубликовал в самом начале статьи.
### Продвинутая ошибка №1 — не знаем о Promise.resolve()
Я уже показывал выше, насколько удобны промисы при оборачивании синхронной логики в асинхронный код. Вероятно, вы могли замечать за собой что-то похожее:
```
new Promise(function (resolve, reject) {
resolve(someSynchronousValue);
}).then(/* ... */);
```
Имейте в виду, вы можете написать то же самое гораздо короче:
```
Promise.resolve(someSynchronousValue).then(/* ... */);
```
Также такой подход очень удобен для отлавливания любых синхронных ошибок. Он настолько удобен, что я использую его почти во всех методах API, возвращающих промисы:
```
function somePromiseAPI() {
return Promise.resolve()
.then(function () {
doSomethingThatMayThrow();
return 'foo';
})
.then(/* ... */);
}
```
Просто запомните, любой код, который может выдать синхронную ошибку — потенциальная проблема при отладке из-за «проглоченных» ошибок. Но если вы обернете его в **Promise.resolve()**, то можете быть уверены, что поймаете ее при помощи **catch()**.
Еще есть **Promise.reject()**. Его можно использовать для возвращения промиса в статусе **rejected**:
```
Promise.reject(new Error(‘Какая-то ужасная ошибка’));
```
### Продвинутая ошибка №2 — catch() не одно и то же с then(null, …)
Чуть выше я упоминал, что **catch()** — это просто «сахар». Два примера ниже эквивалентны:
```
somePromise().catch(function (err) {
// Обрабатываем ошибку
});
somePromise().then(null, function (err) {
// Обрабатываем ошибку
});
```
Однако, примеры ниже уже не «равны»:
```
somePromise().then(function () {
return someOtherPromise();
})
.catch(function (err) {
// Обработка ошибка
});
somePromise().then(function () {
return someOtherPromise();
}, function (err) {
// Обработка ошибки
});
```
Если вы задумались, почему примеры выше «не равны», посмотрите внимательно, что произойдет, если в первой функции возникнет ошибка:
```
somePromise().then(function () {
throw new Error('oh noes');
})
.catch(function (err) {
// Ошибка поймана! :)
});
somePromise().then(function () {
throw new Error('oh noes');
}, function (err) {
// Ошибка? Какая ошибка? O_o
});
```
Получается, что, если вы используете формат **then(resolveHandler, rejectHandler)**, то **rejectHandler** по факту не может поймать ошибку, возникшую внутри функции **resolveHandler**.
Зная эту особенность, для себя я ввел правило никогда не использовать вторую функцию в методе **then()**, а взамен всегда добавлять обработку ошибок ниже в виде **catch()**. Исключение у меня только одно — асинхронные тесты в [Mocha](http://mochajs.org), в случаях, когда я намеренно жду ошибку:
```
it('should throw an error', function () {
return doSomethingThatThrows().then(function () {
throw new Error('I expected an error!');
}, function (err) {
should.exist(err);
});
});
```
К слову, [Mocha](http://mochajs.org) и [Chai](http://chaijs.com) — отличная комбинация для тестирования основанного на промисах API.
### Продвинутая ошибка №3 — промисы против фабрик промисов
Допустим, вы хотите выполнить серию промисов один за другим, последовательно. Вы хотите что-то вроде **Promise.all()**, но такой, чтобы **не** выполнял промисы параллельно.
Сгоряча вы можете написать что-то подобное:
```
function executeSequentially(promises) {
var result = Promise.resolve();
promises.forEach(function (promise) {
result = result.then(promise);
});
return result;
}
```
К сожалению, пример выше не будет работать так, как задумывалось. Промисы из списка, переданного в **executeSequentially()**, все равно начнут выполняться параллельно.
Причина в том, что по спецификации промис начинает выполнять заложенную в него логику сразу после создания. Он не будет ждать. Таким образом, не сами промисы, а массив фабрик промисов — это то, что действительно нужно передать в **executeSequentially**:
```
function executeSequentially(promiseFactories) {
var result = Promise.resolve();
promiseFactories.forEach(function (promiseFactory) {
result = result.then(promiseFactory);
});
return result;
}
```
Я знаю, вы сейчас думаете: *«Кто, черт возьми, этот Java программист, и почему он рассказывает нам о фабриках?»*. На самом деле фабрика — это простая функция, возвращающая промис:
```
function myPromiseFactory() {
return somethingThatCreatesAPromise();
}
```
Почему этот пример будет работать? А потому, что наша фабрика не создаст промис до тех пор, пока до него не дойдет очередь. Она работает именно как **resolveHandler** для **then()**.
Посмотрите внимательно на функцию **executeSequentially()** и мысленно замените ссылку на **promiseFactory** ее содержимым — сейчас над вашей головой должна радостно вспыхнуть лампочка :)
### Продвинутая ошибка №4 — что, если я хочу результат двух промисов?
Часто бывает, что один промис зависит от другого, а нам на выходе нужны результаты обоих. Например:
```
getUserByName('nolan').then(function (user) {
return getUserAccountById(user.id);
})
.then(function (userAccount) {
// Стойте, мне еще и объект «user» нужен!
});
```
Желая оставаться хорошими JavaScript разработчиками, мы возможно захотим вынести на более высокий уровень видимости переменную **user**, дабы не создавать «пирамиду зла».
```
var user;
getUserByName('nolan').then(function (result) {
user = result;
return getUserAccountById(user.id);
})
.then(function (userAccount) {
// Хорошо, теперь есть и «user», и «userAccount»
});
```
Это работает, но лично я считаю, что код «попахивает». Мое решение — отодвинуть в сторону предубеждения и сделать осознанный шаг в сторону «пирамиды»:
```
getUserByName('nolan').then(function (user) {
return getUserAccountById(user.id)
.then(function (userAccount) {
// Хорошо, теперь есть и «user», и «userAccount»
});
});
```
… по крайней мере, временный шаг. Если же вы почувствуете, что отступы увеличиваются и пирамида начинает угрожающе расти, сделайте то, что JavaScript разработчики делали испокон веков — создайте функцию и используйте ее по имени.
```
function onGetUserAndUserAccount(user, userAccount) {
return doSomething(user, userAccount);
}
function onGetUser(user) {
return getUserAccountById(user.id)
.then(function (userAccount) {
return onGetUserAndUserAccount(user, userAccount);
});
}
getUserByName('nolan')
.then(onGetUser)
.then(function () {
// К этому моменту функция doSomething() выполнилась,
// а отступы не выросли — пирамидой и не пахнет
});
```
По мере того, как код будет усложняться, вы обратите внимание, что все большая его часть преобразовывается в именованные функции, а сама логика приложения начинает приобретать вид, приносящий эстетическое удовольствие:
```
putYourRightFootIn()
.then(putYourRightFootOut)
.then(putYourRightFootIn)
.then(shakeItAllAbout);
```
Вот для чего нам промисы.
### Продвинутая ошибка №5 — «проваливание» сквозь промисы
Наконец, именно на эту ошибку я намекал, предлагая вам решить задачку в начале статьи. Это очень редкий случай. Возможно, он никогда не появится в вашем коде. Повстречав его, я определенно удивился.
Как вы думаете, что выведет в консоль этот код?
```
Promise.resolve('foo')
.then(Promise.resolve('bar'))
.then(function (result) {
console.log(result);
});
```
Если вы думаете, что это будет bar, вы ошиблись. В консоли появится foo!
Причина в том, что, когда вы передаете в **then()** что-то отличное от функции (например, промис), это интерпретируется как **then(null)** и в следующий по цепочке промис «проваливается» результат предыдущего. Проверьте сами:
```
Promise.resolve('foo')
.then(null)
.then(function (result) {
console.log(result);
});
```
Добавьте сколько угодно **then(null)**, результат останется прежним — в консоли вы увидите foo.
Данный пример возвращает нас к выбору между промисами и фабриками промисов. Мы разбирали его выше. Если коротко, вы можете передавать прямо в **then()** промис, но результат будет совсем не тем, что вы ожидали. Метод **then()** ожидает функцию. Чтобы ожидания сбылись, нужно переписать пример как-то так:
```
Promise.resolve('foo')
.then(function () {
return Promise.resolve('bar');
})
.then(function (result) {
console.log(result);
});
```
В консоли вы увидите bar, как и ожидали.
Запоминаем: в метод **then()** передаем только функции.
Решение задачи
--------------
Теперь, когда мы о промисах знаем все или, по крайней мере, близки к этому, мы должны решить задачу, которую я опубликовал выше.
Вот ответы на все пазлы с визуализацией для лучшего понимания.
#### Пазл №1
```
doSomething().then(function () {
return doSomethingElse();
})
.then(finalHandler);
```
Ответ:
```
doSomething
|-----------------|
doSomethingElse(undefined)
|------------------|
finalHandler(resultOfDoSomethingElse)
|------------------|
```
#### Пазл №2
```
doSomething().then(function () {
doSomethingElse();
})
.then(finalHandler);
```
Ответ:
```
doSomething
|-----------------|
doSomethingElse(undefined)
|------------------|
finalHandler(undefined)
|------------------|
```
#### Пазл №3
```
doSomething().then(doSomethingElse())
.then(finalHandler);
```
Ответ:
```
doSomething
|-----------------|
doSomethingElse(undefined)
|---------------------------------|
finalHandler(resultOfDoSomething)
|------------------|
```
#### Пазл №4
```
doSomething().then(doSomethingElse)
.then(finalHandler);
```
Ответ:
```
doSomething
|-----------------|
doSomethingElse(resultOfDoSomething)
|------------------|
finalHandler(resultOfDoSomethingElse)
|------------------|
```
Если вы не поняли объяснения, то я советую вам перечитать статью еще раз, или самостоятельно написать функции **doSomething()** и **doSomethingElse()**, и поэкспериментировать с ними в браузере. Подразумевается, что эти функции возвращают промисы с какими-то результирующими данными.
Также обратите внимание на мой [список полезных заготовок](https://gist.github.com/nolanlawson/6ce81186421d2fa109a4).
Заключительное слово о промисах
-------------------------------
Промисы очень хороши. Если вы до сих пор используете колбэки, я настойчиво рекомендую вам переключиться на промисы. Ваш код станет меньше, элегантнее, а значит, более простым для понимания.
Если вы мне не верите, держите пруф-линк — [рефакторинг PounchDB модуля map/reduce с заменой колбэков на промисы](https://github.com/pouchdb/mapreduce/commit/dfe44b0ab3da9d213640a1010b34bb27327da4c9). Результат: 290 добавленных строк, 555 удаленных. По-случайности, автором всех этих прежних жутких колбэков был… я. Так что это стало для меня первым из освоенных преимуществ промисов.
Я уже говорил, промисы великолепны. Это правда, что они лучше колбэков. Тем не менее, это все равно, что выбирать между пинком в живот и ударом в зубы. Да, что-то из этого лучше, но еще лучше избежать обоих вариантов. Промисы все еще трудны для понимания, и можно попасть в ситуацию, когда результат работы кода намного отличается от задуманного. Даже опытные разработчики могут попасть в коварную ловушку. Основная проблема в том, что промисы, хоть и реализуют паттерны, схожие с синхронным кодом, на деле совсем не равны им.
Ждем async/await
----------------
В своей статье «[Укрощение асинхронного чудовища с ES7](http://pouchdb.com/2015/03/05/taming-the-async-beast-with-es7.html)» я упоминал **async/await** и то, как они глубже интегрировали промисы в язык. Вместо написания псевдо-синхронного кода (с фейковым методом **catch()**, который как из **try/catch**, но не совсем, ES7 позволит нам использовать настоящие **try/catch/return**.
Это огромное благо для JavaScript, как для языка, потому что анти-паттерны использования промисов по-прежнему будут возникать, пока наши инструменты не будут сообщать нам о сделанных ошибках.
В качестве примера из истории JavaScript, я думаю, что [JSLint](http://jslint.com) и [JSHint](http://jshint.com) сделали для сообщества гораздо больше, чем «[Хорошие стороны JavaScript](http://www.amazon.com/dp/0596517742/ref=cm_sw_su_dp)», хоть в целом суть у них похожа. Разница в том, что в первом случае вам говорят о конкретной ошибке, которую вы сделали в определенной строке, а во втором вы читаете большую книгу о том, какие ошибки делают другие разработчики.
Красота **async/await** в основном в том, что ваши ошибки проявят себя сразу при синтаксическом анализе в интерпретаторе JS, а не когда-то возможно где-то во время исполнения кода. До тех же пор полезным будет представление о возможностях промисов, о том, как их использовать в ES5 и ES6.
Как и книга «Хорошие стороны JavaScript», эта статья имеет малый эффект. Вероятно однажды вы сможете дать на нее ссылку своему коллеге, который найдет в себе силы честно признать:
— У меня проблемы с промисами! | https://habr.com/ru/post/269465/ | null | ru | null |
# Strategy Design Pattern
Всем привет, друзья. Меня зовут **Alex**, я профессиональный разработчик и создатель программных продуктов в веб индустрии. Много лет изучаю языки, делюсь опытом с другими.
Сегодня хочу с вами поговорить про шаблон проектирования **Стратегия (Strategy).** Постараюсь донести до вас принципы и суть шаблона без воды, и покажу как его применять на практике.
В чем суть?
-----------
**Design patter Strategy** или **шаблон проектирования Стратегия** относится к поведенческим шаблонам проектирования. Его задача - выделить схожие алгоритмы, решающие конкретную задачу. Реализация алгоритмов выносится в отдельные классы и предоставляется возможность выбирать алгоритмы во время выполнения программы.
Шаблон дает возможность в процессе выполнения выбрать стратегию (алгоритм, инструмент, подход) решения задачи.
В чем проблема?
---------------
Рассмотрим задачи, при решении которых можно применять такой подход.
Представьте, что перед вами стоит задача написать веб-портал по поиску недвижимости. MVP ([Minimum Viable Product](https://ru.wikipedia.org/wiki/%D0%9C%D0%B8%D0%BD%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE_%D0%B6%D0%B8%D0%B7%D0%BD%D0%B5%D1%81%D0%BF%D0%BE%D1%81%D0%BE%D0%B1%D0%BD%D1%8B%D0%B9_%D0%BF%D1%80%D0%BE%D0%B4%D1%83%D0%BA%D1%82)) или минимально работающий продукт был спроектирован и приоритизирован вашей командой Product Manager’ов и на портале должен появиться функционал для покупателей квартир. То есть целевые пользователи вашего продукта в первую очередь - это те, кто ищет себе новое жилье для покупки. Одной из самых востребованных функций должна быть возможность:
* Выбрать область на карте, где покупатель желает приобрести жилье
* И указать ценовой диапазон цен на квартиры для фильтрации.
Первая версия вашего портала отлично справилась с поставленной задачей и пользователи могли без проблем искать, сужая свой поиск квартир по ценовом диапазону и выбранной географической области на карте. Ну и конечно вы хорошо постарались, как разработчик и все правильно сделали на ваш взгляд с точки зрения архитектуры кода, реализовали классы, которые ищет квартиры на продажу в вашей базе.
Но тут приходят к вам Product Manager'ы и говорят, что нужно добавить возможность искать и отображать недвижимость, которая сдается в аренду. У нас появляется еще один тип пользователя - арендаторы. Для арендаторов не так важно показывать фильтры по цене, им важно состояние квартиры, поэтому нужно отображать фотографии арендуемых квартир.
Следующей версией вашего продукта была значительная доработка текущей архитектуры и добавление нового функционала, чтобы можно было в зависимости от роли пользователя искать разные типы недвижимости и отображать разные элементы интерфейса - для покупателей фильтры по цене и географическое расположение, для арендаторов фотографии квартир.
Конечно на этом все не закончилось. В ближайших планах добавить функционал работы юридических лиц, функционал оплаты и бронирования квартир сразу на сайте. Дальше-больше - добавить возможность просматривать историю недвижимости, запрашивать пакет документов для сделки и связь с владельцами, оформление кредита и так далее.
Если функционал поиска и фильтрации с квартирами на продажу было довольно легко реализовать, то любые новые изменения вызывали много вопросов и головную боль по архитектуре. Пришлось очень многое менять в коде. Вы понимали, что любое изменение алгоритмов выдачи нужных квартир и элементов для отображения затрагивает основные базовые классы, в которых реализован весь функционал фильтрации. Основной функционал поиска квартир изначально был реализован в одном классе, при добавлении нового функционала этот класс разрастался, вы добавляли новые условия, новые ветвления, новые методы и функции.
Изменение такого класса, даже в случае исправление багов, сильно повышает риск сделать новые ошибки. Над данным функционалом работала целая команда разработчиков, любые изменения в итоге проходили долгую обкатку и тестирование, а изменения, добавляемые другими программистами в базовые классы, создавала новые проблемы и конфликты, релизы затягивались. Вы столкнулись со следующими проблемами:
* Основной алгоритм поиска квартир был реализован в одном супер-классе
* Алгоритм выбора и отображения элементов интерфейса был реализован в одном супер-классе
* Изменения в этих классах, сделанные разными программистами, приводили к конфликтам и необходимости регрессивного тестирования
* Релизы продукта затягивались, время на разработку нового функционала увеличилась в несколько раз
* Больше времени стало уходить на разработку, тестирование, появилось множество багов.
Супер-класс с единым методом реализации алгоритма.Какое решение?
--------------
В данном примере мы имеем несколько алгоритмов для одной функции:
* Поиск квартир с продажей
* Поиск квартир в аренду
* Отображение или нет различных наборов фильтров
* Отображение различных элементов интерфейса - фотографии, кнопки бронирования, кнопки обратной связи и т.д.
Шаблон проектирования **Стратегия** - решает такую задачу. Он предлагает выделить семейство похожих алгоритмов, вынести их в отдельные классы. Это позволит без проблем изменять нужный алгоритм, расширять его, сводя к минимум конфликты разработки, зависимости от других классов и функционала. Вместо того, чтобы реализовывать алгоритм в едином классе, наш класс будет работать с объектами классов-стратегиями через объект-контекста и в нужным момент делегировать работу нужному объекту. Для смены алгоритма достаточно в нужным момент подставить в контекст нужный объект-стратегию.
Чтобы работа нашего класса была одинаковой для разного поведения, у объектов-стратегии должен быть общий интерфейс. Используя такой интерфейс вы делаете независимым наш класс-контекста от классов-стратегий.
Диаграмма классов шаблона StrategyВозвращаясь к нашему примеру с порталом по поиску недвижимости, мы должны вынести алгоритмы поиска недвижимости на продажу и аренду в отдельные классы-стратегии, где реализовать конкретные алгоритмы по поиску разных типов объектов. Аналогичное можно проделать и с классами работы с элементами интерфейса для различных видов пользователей.
В классах-стратегиях, реализующих поиск объектов недвижимости, будет определен только один метод `doSearch(filters)`, принимающий в качестве аргумента фильтры, по которым будет совершен поиск конкретных объектов с использованием конкретного алгоритма.
Несмотря на то, что каждый класс-стратегия реализует поиск по своему алгоритму, с применением необходимых фильтров (продажа, аренда, загородный дом, жилая, не жилая и т.д.), не исключено, кстати, что они будут работать с разными базами - все это для веб-интерфейса, который отображает список найденных объектов, не имеет никакого значения. После того, как пользователь выбрал интересующий его тип недвижимости в фильтрах на сайте, будет происходить запрос в контроллер на backend, с экшеном получения данных по входящим фильтрам и типам пользователя.
Задача контроллера определить класс-стратегию и запросить у класса-контекста данные для отображения, передав ему известный набор фильтров. Класс-контекст в этой схеме - это класс, которые реализует метод поиска квартир по заданным фильтрам. На диаграмме классов выше мы видим, что класс контекста определяет метод `getData`, и принимает аргументы `filters`. У него должен быть конструктор, принимающий активный в данный момент объект-стратегии и сеттер `setStrategy`, устанавливающий активную стратегию. Такой метод пригодится для случая, когда пользователь меняет тип искомого объекта, например, он ищет недвижимость на продажу и хочет снять квартиру.
Пример реализации
-----------------
Ниже рассмотрим пример, как решается описанная задача на языке *GOlang*. Первое что сделаем - определим интерфейс с методом `doSearch`:
Strategy.goДанный метод определяет общее поведение для конкретных алгоритмов, реализующих разные стратегии. Метод может принимать различные аргументы, позволяющие реализовать ветвления в ваших алгоритмах. В примера я передаю пользовательские фильтры с типом `Map`.
Для реализации конкретных алгоритмов создаем два файла. В каждом файле определяется свой определяемый тип с базовым типом `struct`, реализующие интерфейс `Strategy`. Соответственно, в методы, определяемые интерфейсом для каждого алгоритма, будут передаваться пользовательские фильтры. Реализации выглядит следующим образом:
FirstAlgorithm.goSecondAlgorithm.goПосмотрим на нашу диаграмму классов. Нам осталось реализовать класс-контекста и клиентский код вызова конкретных алгоритмов в нужным момент. Как это сделать? Для создания слоя класса-контекста реализуем исходник, реализующий:
* определяемый тип в базовым типом `struct`
* функцию `initStrategy`, инициализирующий стратегию по-умолчанию и пользовательские фильтры
* метод типа `struct setStrategy`, устанавливающий активную стратегию
* и функция `getData`, вызывающий конкретную стратегию и возвращаемый данные для показа пользователю.
Context.goПоследний шаг - посмотрим на клиентский код. Сначала инициализируется стратегия по-умолчанию, получаем данные из этой стратегии. Затем выставляем новую активную стратегию и повторно вызываем функцию получения данных `getData`. Как видим, каждый раз вызывается одна и та же функция файла-контекста (или класса-контекста в диаграмме классов) для получения данных рендеринга, отображаемых в дальнейшем пользователю. Для простоты я вывожу отладочную информацию в консоль, чтобы убедиться, что работают разные алгоритмы при вызовах. Вот код:
Client.goВот вывод такого подхода:
`First implements strategy map[role:1]`
`Second implements strategy map[role:2]`
Как видите, мы можем управлять вызовом разных алгоритмов в зависимости от контекста и пользовательских фильтров. Алгоритмы могут создавать ветвления в зависимости от входных фильтров и других параметров, переданных из клиентского кода в методы, реализующие конкретные алгоритмы. Вот такой интересный пример.
Объектно-ориентированный подход можно посмотреть. например, в этом [курсе](https://www.udemy.com/course/design-patterns-cj/?referralCode=2F11FCD4981B4F368F2F). Там показан пример на PHP.
Когда применять?
----------------
Напоследок поговорим когда применяется шаблон **Strategy**?
1. У вас есть множество похожих реализаций отличающихся незначительным поведением. Можно вынести отличающее поведение в классы-стратегии, а повторяющий код свести к единому классу-контекста.
2. Ваш алгоритм реализован в супер-классе с множественными условными операторами. Выделите блоки условных операторов в отдельные классы-стратегии, а управление вызовов нужных доверьте классу-контекста.
3. Конкретные стратегии позволяют инкапсулировать алгоритмы в своих конкретных классах. Используйте этот подход для снижения зависимостей от других классов.
4. В зависимости от ситуации вы можете менять стратегию выполнения задачи в процессе выполнения программы. Например, в зависимости от скорости интернета использовать разные стратегии-поведения, возвращающие разный набор данных для отображения страницы.
Подведем итог
-------------
Друзья, мы познакомились с поведенческим шаблоном проектирования **Strategy**. Шаблон используется для выделения схожих алгоритмов, решающих конкретную задачу. Посмотрели с вами реализацию на языке *GOlang*, ознакомились в возможностями подхода и разобрали когда его лучше применять.
Рад был с вами пообщаться, [**Alex Versus**](https://www.facebook.com/groups/201365194945690%20). Успехов! | https://habr.com/ru/post/552278/ | null | ru | null |
# Ubiquitous Language и Bounded Context в DDD
[Domain-Driven Design: Tackling Complexity in the Heart of Software](http://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215) Эванса — лучшая книга о проектировании действительно больших enterprise-приложений, что я читал. Видимо это мнение разделяют многие другие разработчики и проектировщики, потому что Entity и ValueObject, Repository и Specification встречаются почти в каждой большой кодовой базе. Но вот незадача, Ubiquitous Language (единый язык) и Bounded Context (контекст предметной области) в чужом коде я не видел ни разу. И здесь зарыта очень большая собака.
Зачем нужен единый язык?
------------------------
Порой, в нашей профессии, сформулировать требование к продукту бывает сложнее, чем реализовать его. Разные предметные области сложны по своему. В перевозках вы столкнетесь с концепцией овербукинга, в продажах со «специальными предложениями», в трейдинге — со «стоп-лосс трейлинг ордерами».
Единый язык — это базовая концепция борьбы со сложностью. Если предметная область итак требует изучения, то давайте не будем делать вещи еще сложнее и заставлять людей разбираться еще и в **вашей модели предметной области**. Будем называть вещи одинаково как в спецификации, так и в коде. Пример ниже наглядно иллюстрирует использование этой концепции:
*Единый язык on*
```
var ticket = cashdesk.Sale(seat, count); // Это может понять даже не технический специалист
```
*Единый язык off*
```
ticket.State = TicketState.Sold; // А это нет
ticketRepository.Update(ticket);
```
Проблемы с отсутствием единой терминологии я ощутил на собственной шкуре. Команда разрабатывала систему для продажи билетов на мероприятия онлайн. Новая версия продукта была призвана заменить старую, расширить функционал и исправить ошибки проектирования первой версии. Один из крупных косяков первой системы состоял в допущении, что можно продать только один билет на место. Но оказалось, что существуют «танцевальный партер» и «столик на 5 человек», которые удобно представлять одним местом в зале.
Так у программистов появилось абстрактное понятие «продаваемое место», связывающее место в зале, с количеством билетов, которое можно продать на это место. Для обычных залов с рядами и местами оно было равно единице, а для танцевального партера — ограничивалось вместимостью зала.
Заметили как сложно воспринимается предыдущий абзац?
С технической точки зрения проблема была решена идеально, но каждому следующему программисту приходилось объяснять, что такое продаваемое место, чем отличается от квоты и почему в UI это называется билет. В итоге эта путаница вылилась в очень неудачный промах при оценке сложности спринта и спринт был провален.
Зачем нужны контексты?
----------------------
#### Проблема №1
К сожалению, преимущества единого языка мы не получаем бесплатно. Единый язык требует кропотливого анализа требований и консультаций с экспертами предметной области. Зачастую, так называемые эксперты озвучивают противоположные точки зрения о бизнес-процессах и терминах. Разрабатывая приложения в рамках «единого языка» вы инвестируете много времени в создание внутренней базы знаний клиента. Безусловно это хорошо. Проблема в том, что почти наверняка эта работа не заложена в бюджет на разработку приложения. Разработка по всем канонам DDD и с применением единого языка — дорогое и не быстрое удовольствие.
#### Проблема №2
«Единый язык» на самом деле не является «единым» для всего приложения и живет только в рамках контекста. И Эванс прямо об этом пишет. К сожалению, в книге сей факт формируется мягко, скорее как рекомендация, а не правило. Я бы набрал параграф красным КАПСОМ и поместил в рамку. Попытка создания единой модели предметной области обречена на провал. Один и тот же термин может значить разные вещи в разных контекстах. Я могу сходу назвать несколько примеров из разных предметных областей, но все они требуют специального объяснения, поэтому ограничусь синтетическим примером: салат рекурсивный — помидоры, огурцы, салат. Ну вы поняли…
#### Проблема №3
Никому не нужна модель предметной области целиком. Она скорее всего слишком сложна даже для крутых стратегов и аналитиков. Эти ребята попросят представить им данные в совершенно ином, понятном им, виде и разрезе. Контексты реализуют принцип «разделяй и властвуй», что помогает быстрее обучать пользователей и подключать новых членов в команду разработки.
#### В качестве бонуса
Bounded Context — это реализация принципа слабой связанности на более высоком уровне — на уровне подсистемы (модуля). Такая сегментация позволит вам более гибко управлять разработкой, вплоть до исключения или переписывания с нуля целых модулей, возможно, что даже с полной заменой команды и/или технологического стека модуля. Если вы игнорируете Bounded Context и расширяете и расширяете вашу модель домена, рано или поздно это закончится тем, что стоимость (как по времени, так и по деньгам) любого изменения системы будет стремиться к бесконечности. | https://habr.com/ru/post/232881/ | null | ru | null |
# Получение root на роутере Tenda Nova MW6
Началось всё с того, что польстившись на распродажу и новые buzz words — я приобрел wifi mesh систему, дабы покрыть все уголки загородного дома и прилегающего участка. Все бы ничего, но одна проблема раздражала. А с учетом того, что я сел на больничный на несколько дней — довела меня до root доступа к данному роутеру.
Проблема
========
Ради интереса, приобрел два набора по три кубика [Tenda Nova MW6](https://www.tendacn.com/ru/product/mw6.html) — система для организации wifi mesh для чайников. С возможностью ethernet backhaul, т.е. соединения некоторых блоков друг с другом по проводам, ибо данная коробочка является чуть-ли не самой дешевой wifi mesh (дешевле, по-моему, только их же MW3) и она не имеет третьего выделенного радиотракта для внутренней коммуникации между блоками (как у некоторых дорогих коллег — Netgear Orbi).
В целом, огромной нужды не было, но пара роутеров под OpenWrt не покрывали всех нужных мест.
**Кто такой mesh, и зачем он нужен**Mesh — это топология построения сетей, характеризующаяся высокой отказоустойчивостью и динамичностью.
Не буду вдаваться в подробности, так как многие в курсе, а кто нет — можно начать со [статьи про Ячеистую топологию на wikipedia](https://ru.wikipedia.org/wiki/%DF%F7%E5%E8%F1%F2%E0%FF_%F2%EE%EF%EE%EB%EE%E3%E8%FF).
Основная задача "домашней" wifi mesh сети — это покрыть большую площадь стабильным беспроводным сигналом с бесшовным роумингом.
Бесшовный роуминг можно и на access points и на домашних роутерах включить (например с openwrt — путем замены wpad-mini на wpad и включению 802.11r). А стабильный сигнал на большой площади от пары точек не получить — то пусто, то густо — при этом сильно засоряешь эфир, если повышаешь мощность. Нужно больше точек — несколько точек 5G будет намного эффективнее. Но на обычных access points/routers ты еще будешь думать, как провод к ним подвести, а mesh на то и mesh, чтобы сама себя поддерживать и налаживать связи как при наличии, так и без наличия провода (backhaul).
Вообщем, технология для удобства жизни. Это хорошо.
Завелась система с первого раза, сама настроилась, всё окей. Поиграв с их фичами в приложении (а классической веб-мордочки не предусмотрено, теперь всё только через приложения для телефона и китайские облака...) решил перевести в сеть в режим моста, ибо есть разные устройства уже настроенные как надо и Главный роутер много чего делает.
Сутки всё работало хорошо, потом начал замечать, что то к одному хосту, то к другому нет доступа. В админке OpenWrt в списке выделенных адресов — пара хостов, остальных нет. Сканирую сеть — хосты на месте, только адреса у них не те, что были зафиксированы. Начинаю подозревать — сканирую "главный кубик" MW6 — так и есть, на нем крутится DHCP сервер.
**sudo nmap -sU -p 67 --script=dhcp-discover 192.168.5.111**
```
Starting Nmap 7.60 ( https://nmap.org ) at 2019-07-18 20:04 MSK
Nmap scan report for _gateway (192.168.5.111)
Host is up (0.0027s latency).
PORT STATE SERVICE
67/udp open dhcps
| dhcp-discover:
| DHCP Message Type: DHCPACK
| Server Identifier: 192.168.5.111
| IP Address Lease Time: 23h30m42s
| Subnet Mask: 255.255.255.0
| Broadcast Address: 192.168.5.255
| Router: 192.168.5.1
| Domain Name Server: 192.168.5.1
|_ Domain Name: tendawifi.com
MAC Address: 04:95:E6:1A:96:E0 (Tenda Technology,Ltd.Dongguan branch)
Nmap done: 1 IP address (1 host up) scanned in 0.75 seconds
```
Поддержка у Tenda только де-юро. Де-факто никто ни на что не отвечает. Русская поддержка в контакте хоть и отвечает, но абсолютно не адекватна и не умеет слушать клиентов.
Беглый гуглинг подсказал, что на всякий случай надо бы на Главном роутере поставить `dhcp authoritative='1'`, но это не помогло. И тут я начал думать, как отключить DHCP сервер на этих кубиках. Выделил один кубик для игр, сбросил его настройки и — понеслась.
Сетевые сервисы
===============
Несколько портов открыто, сильно не копал, просто `nmap` . Подозреваю, что есть и бэкдоры для китайских облаков, но пока их не искал. С ходу ничего полезного не видно. А не с ходу — после подключения к консоли по UART захотел сбросить настройки кубика и выяснил, что после 3 секунд нажатия на reset — запускается telnet сервер.
**Вид из LAN**
```
PORT STATE SERVICE
23/tcp open telnet
5500/tcp open hotline
9000/tcp open cslistener
```
**Вид из WAN**
```
PORT STATE SERVICE
1723/tcp closed pptp
```
Зайдем-ка в telnet
------------------
Ну тут не сильно нам удача улыбалась — всякие стандартные логины/пароли по-перебирал — не подошли. Пробовал root/admin/support/user и пароли из "интернетов" — password, root, toor, admin, support, tenda, 1234, 12345678 и т.д. Пароль от wifi сети тоже пробовал.
Железяки
========
Кубик открывается легко и непринужденно, шурупы, как обычно, под ножками. Скрытых шурупов нет. Внутри ~~собаки~~ кубика — пустота. Пара плат и пара микро антенн. Ничего интересного, как и везде в 99% случаев.
Повезло с UART — единственный коннектор оказался им. Флэшка прямо по середине. На другой стороне платы ничего нет, кроме радиатора.
UART
----
Разъем J4. Распиновка, начиная с первой ноги: VCC (3.3), TX, RX, GND. Первый нога — которая ближе всего к флешке. Настройки UART тоже угадались с первой попытки — 115200, 8n1.
**А вот и долгожданный bootlog. Только для ценителей многих сотен строк.**
```
Booting...
init_ram
00000202 M init ddr ok
DRAM Type: DDR2
DRAM frequency: 533MHz
DRAM Size: 128MB
JEDEC id 684017, EXT id 0x6840
found BH25Q64
flash vendor: BOHONG
BH25Q64, size=8MB, erasesize=64KB, max_speed_hz=55000000Hz
auto_mode=0 addr_width=3 erase_opcode=0x000000d8
=>CPU Wake-up interrupt happen! GISR=89000004
---Realtek RTL8197F boot code at 2018.04.20-10:17+0800 v3.4.11B.9 (999MHz)
Mac addr:04-95-e6-1a-96-e0
lan_wan_isolation Initing...
config: lan port mask is 0x000000f7
config: wan port mask is 0x000000e8
lan_wan_isolation Initing has been completed.
lan_wan_isolation Initing...
config: lan port mask is 0x000000f7
config: wan port mask is 0x000000e8
lan_wan_isolation Initing has been completed.
wait for upgrage
port[0] link:down
port[1] link:down
port[2] link:down
port[3] link:down
port[4] link:down
irq:0x00008080
Jump to image start=0x80a00000...
decompressing kernel:
Uncompressing Linux... done, booting the kernel.
done decompressing kernel.
start address: 0x80466860
Linux version 3.10.90 (root@linux-bkb8) (gcc version 4.4.7 (Realtek MSDK-4.4.7 Build 2001) ) #4 Mon Jul 2 10:57:35 CST 2018
CPU revision is: 00019385 (MIPS 24Kc)
Determined physical RAM map:
memory: 08000000 @ 00000000 (usable)
Zone ranges:
Normal [mem 0x00000000-0x07ffffff]
Movable zone start for each node
Early memory node ranges
node 0: [mem 0x00000000-0x07ffffff]
Primary instruction cache 64kB, VIPT, 4-way, linesize 32 bytes.
Primary data cache 32kB, 4-way, PIPT, no aliases, linesize 32 bytes
Built 1 zonelists in Zone order, mobility grouping on. Total pages: 8176
Kernel command line: console=ttyS0,115200
PID hash table entries: 512 (order: -3, 2048 bytes)
Dentry cache hash table entries: 16384 (order: 2, 65536 bytes)
Inode-cache hash table entries: 8192 (order: 1, 32768 bytes)
Writing ErrCtl register=00029693
Readback ErrCtl register=00029693
Memory: 103744k/131072k available (4526k kernel code, 27328k reserved, 2031k data, 224k init, 0k highmem)
SLUB: HWalign=32, Order=0-3, MinObjects=0, CPUs=1, Nodes=1
NR_IRQS:192
Realtek GPIO IRQ init
Calibrating delay loop... 666.41 BogoMIPS (lpj=3332096)
pid_max: default: 32768 minimum: 301
Mount-cache hash table entries: 2048
NET: Registered protocol family 16
<<<<>>>>
Do MDIO\_RESET
40MHz
Find PCIE Port, Device:Vender ID=b82210ec
Realtek GPIO controller driver init
INFO: registering sheipa spi device
bio: create slab at 0
INFO: sheipa spi driver register
INFO: sheipa spi probe
\*\*\*spi max freq:100000000
Switching to clocksource MIPS
NET: Registered protocol family 2
TCP established hash table entries: 2048 (order: 0, 16384 bytes)
TCP bind hash table entries: 2048 (order: -1, 8192 bytes)
TCP: Hash tables configured (established 2048 bind 2048)
TCP: reno registered
UDP hash table entries: 1024 (order: 0, 16384 bytes)
UDP-Lite hash table entries: 1024 (order: 0, 16384 bytes)
NET: Registered protocol family 1
squashfs: version 4.0 (2009/01/31) Phillip Lougher
jffs2: version 2.2. (NAND) 2001-2006 Red Hat, Inc.
msgmni has been set to 202
Block layer SCSI generic (bsg) driver version 0.4 loaded (major 254)
io scheduler noop registered (default)
Serial: 8250/16550 driver, 1 ports, IRQ sharing disabled
serial8250: ttyS0 at MMIO 0x18147000 (irq = 17) is a 16550A
console [ttyS0] enabled
Realtek GPIO to I2C Driver Init...
mfi\_ioctl\_init:565,dev=253,MINOR=0
loop: module loaded
m25p80 spi0.0: change speed to 15000000Hz, div 7
JEDEC id 684017
m25p80 spi0.0: found BH25Q64, expected m25p80
flash vendor: BOHONG
m25p80 spi0.0: BH25Q64 (8192 Kbytes) (55000000 Hz)
m25p80 spi0.0: change speed to 55000000Hz, div 2
Kernel code size:0x1f8012
9 rtkxxpart partitions found on MTD device m25p80
Creating 9 MTD partitions on "m25p80":
0x000000000000-0x000000800000 : "ALL"
0x000000000000-0x000000020000 : "Bootloader"
0x000000020000-0x000000030000 : "CFG"
0x000000030000-0x0000005c0000 : "KernelFS"
0x000000228012-0x0000005c0000 : "RootFS"
0x0000005c0000-0x0000005d0000 : "CFM"
0x0000005d0000-0x0000005e0000 : "CFM\_BACKUP"
0x0000005e0000-0x0000007f0000 : "LOG"
0x0000007f0000-0x000000800000 : "ENV"
PPP generic driver version 2.4.2
PPP MPPE Compression module registered
NET: Registered protocol family 24
PPTP driver version 0.8.5
Realtek WLAN driver - version 1.7 (2015-10-30)(SVN:exported)
Adaptivity function - version 9.3.4
Do MDIO\_RESET
40MHz
Find PCIE Port, Device:Vender ID=b82210ec
found 8822B !!!
halmac\_check\_platform\_api ==========>
12089M
HALMAC\_MAJOR\_VER = 0
HALMAC\_PROTOTYPE\_VER = 0
HALMAC\_MINOR\_VER = 0
halmac\_init\_adapter\_88xx ==========>
halmac\_init\_adapter Succss
IS\_RTL8822B\_SERIES value8 = a
MACHAL\_version\_init
#######################################################
SKB\_BUF\_SIZE=8432 MAX\_SKB\_NUM=1024
#######################################################
MACHAL\_version\_init
RFE TYPE =5
#######################################################
SKB\_BUF\_SIZE=3032 MAX\_SKB\_NUM=400
#######################################################
RFE TYPE =5
RFE TYPE =5
RFE TYPE =5
RFE TYPE =5
--- link\_loop\_init ---
mesh\_extend\_init over...
--- hybrid\_steering\_init ---
u32 classifier
nf\_conntrack version 0.5.0 (1621 buckets, 6484 max)
[BM CORE ][init\_online\_ip ,1053] INFO: online ip data hash table created, size = 199
[BM CORE ][init\_online\_ip\_procfs,647 ] INFO: online\_ip proc file created
ipip: IPv4 over IPv4 tunneling driver
gre: GRE over IPv4 demultiplexor driver
ip\_gre: GRE over IPv4 tunneling driver
ip\_tables: (C) 2000-2006 Netfilter Core Team
TCP: cubic registered
NET: Registered protocol family 17
l2tp\_core: L2TP core driver, V2.0
l2tp\_ppp: PPPoL2TP kernel driver, V2.0
8021q: 802.1Q VLAN Support v1.8
Realtek FastPath:v1.03
Probing RTL819X NIC-kenel stack size order[0]...
link\_send\_msg\_timer\_func:lan\_dev = NULL
[Rtl83xx Ethernet Driver][RTL83XX\_vlan\_set][901]: failed!(0x3)
eth0 added. vid=9 Member port 0x2...
eth1 added. vid=8 Member port 0x8...
[peth0] added, mapping to [eth1]...
VFS: Mounted root (squashfs filesystem) readonly on device 31:4.
Freeing unused kernel memory: 224K (80668000 - 806a0000)
mkdir: can't create directory '/var/run': File exists
[BM CORE ][bm\_init ,857 ] INFO: bm\_init success
[BM CORE ][bm\_u2k\_info\_init,1149] INFO: bm\_u2k\_info\_init success
[MAC FILTER ][mf\_init ,683 ] INFO: bm\_mac\_filter init success
\*TBQ\* tbq\_token\_ctrl size: 40
\*TBQ\* tbq\_user size: 68
\*TBQ\* tbq\_user\_sched size: 2192
\*TBQ\* tbq\_bucket size: 56
\*TBQ\* tbq\_bucket\_sched size: 1796
\*TBQ\* tbq\_flow\_track size: 228
\*TBQ\* tbq\_user\_track size: 4412
\*TBQ\* tbq\_backlog size: 24
\*TBQ\* tbq\_flow\_backlog size: 36
\*TBQ\* nos\_flow\_track size: 12
\*TBQ\* nos\_user\_track size: 28
\*TBQ\* nf\_conn size: 624
\*TBQ\* sk\_buff size: 232
\*TBQ\* TBQ\_BACKLOG\_PACKETS\_MAX: 1000000
\*TBQ\* TBQ\_LATENCY\_SHIFT\_MAX: 10
\*TBQ\* TBQ\_DISABLE\_TIMEOUT\_MAX: 60
\*TBQ\* HZ: 100
\*TBQ\* init\_user\_tbq\_hash\_table ok
\*TBQ\* nos\_tbq\_init() OK
Give root password for system maintenance
(or type Control-D for normal startup):argv[0] = cfmd
cfmd
cfms\_apmib\_init:line(475)
Read hw setting header failed!
flash\_mib\_compress\_write DEFAULT\_SETTING DONE, \_\_[flash.c-6988]
flash\_mib\_compress\_write CURRENT\_SETTING DONE, \_\_[flash.c-7057]
DEFAULT\_SETTING hecksum\_ok
CURRENT\_SETTING hecksum\_ok
\_\_[flash.c-7211]setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
setMIB end...
argv[0] = timer
timer
argv[0] = logserver
logserver
argv[0] = netctrl
netctrl
prod\_change\_root\_passwd(83)
link\_send\_msg\_timer\_func:lan\_dev = NULL
insmod: can't insert '/lib/modules/phy\_check.ko': File exists
/bin/sh: can't create /proc/sw\_nat: Permission denied
src/common\_hal.c hal\_init\_bridge
device eth0 entered promiscuous mode
br0: port 1(eth0) entered listening state
br0: port 1(eth0) entered listening state
netctrl\_main.c,netctrl\_init\_vlan\_ports,1207,: Set br0 to 04:95:e6:1a:96:e0.
Sun May 1 00:00:00 UTC 2011
argv[0] = device\_list
device\_list
argv[0] = tendaupload
tendaupload
argv[0] = sh
argv[1] = /usr/bin/mesh\_op.sh
sh
######## STARTING PROGRAM #########
######## RECEIVING DATA #########
RTNETLINK answers: Operation not supported
check timer start success
RTNETLINK answers: No such file or directory
[MAC FILTER ][mf\_apply ,232 ] INFO: g\_mac\_filter\_enable = disable, mf\_default\_action = accept
[MAC FILTER ][mf\_apply ,232 ] INFO: g\_mac\_filter\_enable = disable, mf\_default\_action = accept
Init gsbmac dev success.
The ARP attack defence is init v1 successful
Interface doesn't accept private ioctl...
td\_ssid\_hide (8BDC): Operation not permitted
Interface doesn't accept private ioctl...
td\_ssid\_hide (8BDC): Operation not permitted
open /dev/gsbmac failure.
open /dev/gsbmac failure.
br0: port 1(eth0) entered learning state
Kernel:Init attack fence dev success.
the ddos ip attack defnence init successful
SET\_LAN\_PARAM\_DATA k\_data:
lan ip:3232236801
lan mask:4294967040
lan submask:3232236800
lan interface:br0
lan http port:0
set the proceee ture
SET\_IPOP\_FENCE\_ATTACK\_DATA k\_data:
ip options:32512
SET\_BAD\_PKT\_FENCE\_ATTACK\_DATA k\_data:
bad pkt:248
SET\_DDOS\_FENCE\_ATTACK\_DATA k\_data:
status:7
tcp threshold:1500
udp threshold:1500
icmp threshold:1500
ready\_\_\_djc\_\_\_close\_\_\_\_guest\_\_\_\_wifi\_close\_guest(4617)
djc\_\_\_close\_\_\_\_guest\_\_\_\_wifi\_close\_guest(4623)
config changed,CRC:old[3cbf4591],new[3d7bd411]
mib\_nvram\_cfm\_commit 1608: write mibvalue success
write config to flash......ok
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
/bin/sh: wlanapp.sh: not found
device wlan1 entered promiscuous mode
WlanSupportAbility = 0x3
available channels[US]: 1 2 3 4 5 6 7 8 9 10 11
br0: topology change detected, propagating
br\_topology\_change\_detection, clear br0 fdb ...
br\_topology\_change\_detection, clear shortcut cache...
br0: port 1(eth0) entered forwarding state
MDID is null !!, set default MDID
[ODM\_software\_init]
[97F] Bonding Type 97FS, PKG1
[97F] RFE type 5 PHY paratemters: GPA1+GLNA1
clock 40MHz
load efuse ok
rom\_progress: 0x200006f
rom\_progress: 0x400006f
[GetHwReg88XX][PHY\_REG\_PG\_8197Fmp\_Type5] size
[GetHwReg88XX][PHY\_REG\_PG\_8197Fmp\_Type5]
[GetHwReg88XX][rtl8197Ffw]
[GetHwReg88XX][rtl8197Ffw size]
[97F] Default BB Swing=20
mesh\_passphrase\_update, before encrypt
65 39 66 66 34 64 32 66 62 65 37 38 30 30 36 30
mesh\_passphrase\_update, after encrypt
64 34 38 dd 13 2c 3b ad 7b d1 93 8e 8c a8 be 34
br0: port 2(wlan1) entered listening state
br0: port 2(wlan1) entered listening state
device wlan-msh entered promiscuous mode
br0: port 3(wlan-msh) entered listening state
br0: port 3(wlan-msh) entered listening state
wifi\_config\_service:4505
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
sysconf wlanapp start wlan0 wlan1 wlan0-va0 wlan1-va0
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
Init Wlan application...
FT Daemon v1.0 (Jul 2 2018 10:59:15)
Receive Pathsel daemon pid:1365
[ATM] atm\_swq\_en on
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
/bin/sh: wlanapp.sh: not found
!!! adjust 5G 2ndoffset for 8812 !!!
br0: port 2(wlan1) entered learning state
br0: port 3(wlan-msh) entered disabled state
device wlan0 entered promiscuous mode
WlanSupportAbility = 0x3
available channels[US]: 36 40 44 48 149 153 157 161 165
MDID is null !!, set default MDID
[hard\_code\_8822\_mibs] +++
MAX\_RX\_BUF\_LEN = 8000
[ODM\_software\_init]
clock 40MHz
InitPON OK!!!
load efuse ok
rom\_progress: 0x200006f
rom\_progress: 0x400006f
InitMAC Page0
Init Download FW OK
halmac\_init\_mac\_cfg OK
halmac\_cfg\_rx\_aggregation OK
halmac\_init\_mac\_cfg OK
[GetHwReg88XX][size PHY\_REG\_PG\_8822Bmp\_Type6]
[GetHwReg88XX][PHY\_REG\_PG\_8822Bmp\_Type6]
RL6302\_MAC\_PHY\_Parameter\_v018\_20140708
[set\_8822\_trx\_regs] +++
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
8822 efuse content 0x3D7 = 0xf4
8822 efuse content 0x3D8 = 0xf5
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
mesh\_passphrase\_update, before encrypt
65 39 66 66 34 64 32 66 62 65 37 38 30 30 36 30
mesh\_passphrase\_update, after encrypt
64 34 38 dd 13 2c 3b ad 7b d1 93 8e 8c a8 be 34
br0: port 4(wlan0) entered listening state
br0: port 4(wlan0) entered listening state
br0: port 3(wlan-msh) entered listening state
br0: port 3(wlan-msh) entered listening state
wifi\_config\_service:4505
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
sysconf wlanapp start wlan0 wlan1 wlan0-va0 wlan1-va0
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
FT Daemon v1.0 (Jul 2 2018 10:59:15)
Init Wlan application...
Receive Pathsel daemon pid:1502
==Set ssid close
==Set ssid close
br0: topology change detected, propagating
br\_topology\_change\_detection, clear br0 fdb ...
br\_topology\_change\_detection, clear shortcut cache...
br0: port 2(wlan1) entered forwarding state
[ATM] atm\_swq\_en on
wifi\_config\_service:4505
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
sysconf wlanapp start wlan0 wlan1 wlan0-va0 wlan1-va0
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
FT Daemon v1.0 (Jul 2 2018 10:59:15)
Init Wlan application...
Receive Pathsel daemon pid:1538
/bin/sh: et: not found
/bin/sh: et: not found
/bin/sh: et: not found
/bin/sh: et: not found
hw\_nat\_config 113: #####################flags = 1
hw\_nat\_config 131: ##########enable = 1
hw\_nat\_config 152: set /proc/hw\_nat to 0
cat /proc/hw\_nat
0
steering\_proc\_band\_steering\_mode\_write, local band steering mode Prefer-5GHz
check timer start success
argv[0] = pann
pann
argv[0] = gpio\_ctrl
gpio\_ctrl
argv[0] = mesh\_status\_check
mesh\_status\_check
argv[0] = network\_check
network\_check
User set flags:1
=== set mesh\_local.registerd = registered(2)
br0: port 4(wlan0) entered learning state
Phy[0] down
Phy[1] down
Phy[2] down
Phy[3] down
Phy[4] down
br0: port 3(wlan-msh) entered learning state
[arainc][multiWAN is not exit]netctrl\_phy\_link\_status\_change(1381)
ifconfig: SIOCSIFFLAGS: Cannot assign requested address
[netctrl\_lan\_services\_ctrl][354] dhcpcd\_lan is already exit!
argv[0] = redis-server
argv[1] = /etc\_ro/redis.conf
redis-server
argv[0] = cmdsrv
argv[1] = -l
argv[2] = tcp://0.0.0.0:12598
argv[3] = -R
argv[4] = tcp://127.0.0.1:6379
cmdsrv
argv[0] = confsrv
confsrv
[get\_ip\_sg][313]ip : 192.168.11.1
[get\_ip\_sg][313]ip : 192.168.5.1
[1586] 01 May 00:00:11.607 \* Max number of open files set to 10032
[1586] 01 May 00:00:11.608 # Warning: 32 bit instance detected but no memory limit set. Setting 3 GB maxmemory limit with 'noeviction' policy now.
iptables: Bad rule (does a matching rule exist in that chain?).
iptables: Bad rule (does a matching rule exist in that chain?).
[dhcps\_handle][784]pCurrentCfg is NULL, NewCfgEnable = 1
\_.\_
\_.-``\_\_ ''-.\_
\_.-`` `. `\_. ''-.\_ Redis 2.6.17 (00000000/0) 32 bit
.-`` .-```. ```\/ \_.,\_ ''-.\_
( ' , .-` | `, ) Running in stand alone mode
|`-.\_`-...-` \_\_...-.``-.\_|'` \_.-'| Port: 6379
| `-.\_ `.\_ / \_.-' | PID: 1586
`-.\_ `-.\_ `-./ \_.-' \_.-'
|`-.\_`-.\_ `-.\_\_.-' \_.-'\_.-'|
| `-.\_`-.\_ \_.-'\_.-' | http://redis.io
`-.\_ `-.\_`-.\_\_.-'\_.-' \_.-'
|`-.\_`-.\_ `-.\_\_.-' \_.-'\_.-'|
| `-.\_`-.\_ \_.-'\_.-' |
`-.\_ `-.\_`-.\_\_.-'\_.-' \_.-'
`-.\_ `-.\_\_.-' \_.-'
`-.\_ \_.-'
`-.\_\_.-'
[1586] 01 May 00:00:11.803 # Server started, Redis version 2.6.17
[1586] 01 May 00:00:11.803 # WARNING overcommit\_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit\_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit\_memory=1' for this to take effect.
[1586] 01 May 00:00:11.803 \* The server is now ready to accept connections on port 6379
[1586] 01 May 00:00:11.803 \* The server is now ready to accept connections at /tmp/redis.sock
Init features[arainc][mpp]mesh\_device\_features\_init(2704)
[dhcps\_save\_config][641]dhcps\_save\_config end
argv[0] = dhcps
argv[1] = -C
argv[2] = /etc/dhcps.conf
argv[3] = -l
argv[4] = /etc/dhcps.leases
argv[5] = -x
argv[6] = /etc/dhcps.pid
argv[7] = -k
dhcps
br0: topology change detected, propagating
br\_topology\_change\_detection, clear br0 fdb ...
br\_topology\_change\_detection, clear shortcut cache...
br0: port 4(wlan0) entered forwarding state
br0: port 1(eth0) entered disabled state
Send SIGUSR2 signal from kernel to pathsel, skip for test by Jack
br0: topology change detected, propagating
br\_topology\_change\_detection, clear br0 fdb ...
br\_topology\_change\_detection, clear shortcut cache...
br0: port 3(wlan-msh) entered forwarding state
Phy[3] up
br0: port 1(eth0) entered listening state
br0: port 1(eth0) entered listening state
2011-05-01 00:00:12 [INFO ][uc\_api\_lib.c,2028][uc\_api\_lib\_init ] Successfully initialized the api library...
sched\_boot\_set\_cfg[62] rand\_num :584
upgrade\_shced\_timeout start upgrade\_sched\_reboot\_init\_srv(2593)
[set\_mib 3371]hex format
odm[set\_mib 4037]set odm,val=0x1e
[set\_mib 3371]hex format
odm[set\_mib 4037]set odm,val=0x1e
iptables: No chain/target/match by that name.
iptables v1.4.4: Couldn't find target `dmz\_forward\_pre'
Try `iptables -h' or 'iptables --help' for more information.
iptables: No chain/target/match by that name.
iptables v1.4.4: Couldn't find target `dmz\_forward\_post'
Try `iptables -h' or 'iptables --help' for more information.
iptables: No chain/target/match by that name.
iptables: No chain/target/match by that name.
iptables: Index of insertion too big.
iptables: No chain/target/match by that name.
iptables: No chain/target/match by that name.
iptables v1.4.4: Couldn't find target `port\_forward\_pre'
Try `iptables -h' or 'iptables --help' for more information.
iptables v1.4.4: Couldn't find target `port\_forward\_post'
Try `iptables -h' or 'iptables --help' for more information.
iptables: No chain/target/match by that name.
iptables: No chain/target/match by that name.
iptables: No chain/target/match by that name.
iptables v1.4.4: Couldn't find target `web\_wanadmin'
Try `iptables -h' or 'iptables --help' for more information.
iptables: No chain/target/match by that name.
[device\_list\_cmd\_sub][1385][luminais] invalid param.
iptables: No chain/target/match by that name.
iptables v1.4.4: Couldn't find target `web\_wanadmin'
Try `iptables -h' or 'iptables --help' for more information.
iptables: No chain/target/match by that name.
iptables: No chain/target/match by that name.
iptables v1.4.4: Couldn't find target `MINIUPNPD'
Try `iptables -h' or 'iptables --help' for more information.
iptables: No chain/target/match by that name.
miniupnpd.c,871,ver=1.0,osname=Nova,osver=1.0,osurl=http://www.tendacn.com/,manuft=Tenda,descri=Nova
br0: port 1(eth0) entered learning state
change\_opmode: wan\_prev\_link\_flag=1, lan\_prev\_link\_flag=0
br0: port 1(eth0) entered disabled state
device eth0 left promiscuous mode
br0: port 1(eth0) entered disabled state
brctl: bridge br0: Invalid argument
set\_hw\_nat 158: set /proc/hw\_nat to 1
/proc/hw\_nat now is 1
[Rtl83xx Ethernet Driver][RTL83XX\_vlan\_set][901]: failed!(0x3)
RTNETLINK answers: No such file or directory
argv[0] = ucloud
argv[1] = -l
argv[2] = 4
ucloud
killall: telnet\_ate\_monitor: no process killed
Phy[3] down
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c,1938][ucloud\_event\_accept2 ] accept ucloud session 16
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c,1952][ucloud\_event\_accept2 ] traversal notify info
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_CLOUD\_INFO\_MESH\_NODE\_A[14] in module: M\_CLOUD\_INFO[8]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_CLOUD\_INFO\_DEV\_UPLOAD\_STATU[20] in module: M\_CLOUD\_INFO[8]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_CLOUD\_INFO\_DEV\_UPLOAD\_DEVIC[18] in module: M\_CLOUD\_INFO[8]...
2011-05-01 00:00:16 =Set ssid open
m[INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_CL==Set ssid open
OUD\_INFO\_DEV\_MARK\_LIST\_A[21] in module: M\_CLOUD\_INFO[8]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_CLOUD\_INFO\_DEV\_CONFIG\_TIME\_[23] in module: M\_CLOUD\_INFO[8]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_CLOUD\_INFO\_DEV\_CONFIG\_A[25] in module: M\_CLOUD\_INFO[8]...
enable cloud info OK
init\_device\_attr\_desc(2680)
get\_mesh\_info(2614)
get\_mesh\_info(2650)
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_CLOUD\_INFO\_MESH\_SET[11] in module: M\_CLOUD\_INFO[8]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_CLOUD\_INFO\_CHECK\_MEMORY[0] in module: M\_CLOUD\_INFO[8]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_CLOUD\_INFO\_BEGIN\_UPGRADE[4] in module: M\_CLOUD\_INFO[8]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c,1955][ucloud\_event\_accept2 ] Init Modules
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: MESH\_WAN\_SET[1] in module: MESH\_WAN[18]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: MESH\_WAN\_GET[2] in module: MESH\_WAN[18]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_WAN\_DETECT[3] in module: M\_MESH\_WAN[18]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_WAN\_STATUS[0] in module: M\_MESH\_WAN[18]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_WAN\_DIAG[4] in module: M\_MESH\_WAN[18]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_WAN\_LINEUP\_GET[7] in module: M\_MESH\_WAN[18]...
2011-05-01 Receive Pathsel daemon pid:2004
00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_WAN\_TRAFFIC[8] in module: M\_MESH\_WAN[18]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_WLAN\_GET[1] in module: M\_MESH\_WLAN[19]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_WLAN\_SET[0] in module: M\_MESH\_WLAN[19]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_WLAN\_GET[3] in module: M\_MESH\_WLAN[19]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_WLAN\_SET[2] in module: M\_MESH\_WLAN[19]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_WLAN\_ROAMING\_GET[4] in module: M\_MESH\_WLAN[19]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_WLAN\_ROAMING\_SET[5] in module: M\_MESH\_WLAN[19]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_BASIC\_SUILT[0] in module: M\_MESH\_BASIC[16]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_BASIC\_TZ\_SET[1] in module: M\_MESH\_BASIC[16]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_BASIC\_TIME\_SET[2] in module: M\_MESH\_BASIC[16]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_BASIC\_LANG\_SET[3] in module: M\_MESH\_BASIC[16]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_BASIC\_FAST\_DONE[4] in module: M\_MESH\_BASIC[16]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_BASIC\_GET\_MESH\_ID[5] in module: M\_MESH\_BASIC[16]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_BASIC\_UPLOAD\_LOG[6] in module: M\_MESH\_BASIC[16]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_NODE\_BROWS[0] in module: M\_MESH\_NODE[17]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_NODE\_ADD[1] in module: M\_MESH\_NODE[17]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_NODE\_DEL[2] in module: M\_MESH\_NODE[17]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_NODE\_SET\_LOCATION[3] in module: M\_MESH\_NODE[17]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_NODE\_SET\_LED[4] in module: M\_MESH\_NODE[17]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_NODE\_QUERY\_RSLT[5] in module: M\_MESH\_NODE[17]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_NODE\_MULTI\_UPGRADE\_STA[6] in module: M\_MESH\_NODE[17]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_NODE\_MANUAL\_ADD[7] in module: M\_MESH\_NODE[17]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_HOSTS\_GET[0] in module: M\_MESH\_HOSTS[20]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_HOSTS\_MARK[1] in module: M\_MESH\_HOSTS[20]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_HOSTS\_GET\_REMARK[2] in module: M\_MESH\_HOSTS[20]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_MF\_GET[0] in module: M\_MESH\_MACFILTER[21]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_MF\_SET[1] in module: M\_MESH\_MACFILTER[21]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_FAMILY\_GET\_TMGRP[0] in module: M\_MESH\_FAMILY[22]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_FAMILY\_SET\_TMGRP[1] in module: M\_MESH\_FAMILY[22]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_FAMILY\_GET\_USRGRP[2] in module: M\_MESH\_FAMILY[22]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_FAMILY\_SET\_USRGRP[3] in module: M\_MESH\_FAMILY[22]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_FAMILY\_GET\_FMLYGRP[4] in module: M\_MESH\_FAMILY[22]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_FAMILY\_SET\_FMLYGRP[5] in module: M\_MESH\_FAMILY[22]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_ADV\_PORTFWD\_GET[0] in module: M\_MESH\_ADVANCE[23]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_ADV\_PORTFWD\_SET[1] in module: M\_MESH\_ADVANCE[23]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_ADV\_UPNP\_GET[2] in module: M\_MESH\_ADVANCE[23]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_ADV\_UPNP\_SET[3] in module: M\_MESH\_ADVANCE[23]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_ADV\_MAINT\_GET[4] in module: M\_MESH\_ADVANCE[23]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_ADV\_MAINT\_SET[5] in module: M\_MESH\_ADVANCE[23]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_ADV\_DHCPS\_GET[6] in module: M\_MESH\_ADVANCE[23]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_ADV\_DHCPS\_SET[7] in module: M\_MESH\_ADVANCE[23]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_ADV\_QOS\_GET[8] in module: M\_MESH\_ADVANCE[23]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_ADV\_QOS\_SET[9] in module: M\_MESH\_ADVANCE[23]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_ADV\_DEV\_ASSISTANT\_GET[10] in module: M\_MESH\_ADVANCE[23]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_ADV\_DEV\_ASSISTANT\_SET[11] in module: M\_MESH\_ADVANCE[23]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_ADV\_SHAREDACC\_GET[12] in module: M\_MESH\_ADVANCE[23]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_ADV\_HIGH\_DEVICE\_GET[15] in module: M\_MESH\_ADVANCE[23]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_ADV\_HIGH\_DEVICE\_SET[16] in module: M\_MESH\_ADVANCE[23]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_CLOUD\_VERSION\_Q[24] in module: M\_CLOUD[3]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_CLOUD\_INFO\_CLEAR\_ACC\_ACK[9] in module: M\_CLOUD\_INFO[8]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_CLOUD\_INFO\_ACCOUNT\_INFO\_A[16] in module: M\_CLOUD\_INFO[8]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_MNGMT\_GET\_STA[0] in module: M\_MESH\_AUTH[24]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_MESH\_MNGMT\_LOGIN[1] in module: M\_MESH\_AUTH[24]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_SYS\_BASIC\_INFO\_GET[0] in module: M\_SYS[1]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_CATEGORY\_MESH[1] in module: M\_CATEGORY[15]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_COMMON\_SUCCESS[0] in module: M\_COMMON[0]...
2011-05-01 00:00:16 [INFO ][uc\_api\_lib.c, 344][uc\_api\_lib\_cmd\_register] Successfully registered command: CMD\_COMMON\_FAILURE[1] in module: M\_COMMON[0]...
argv[0] = sntp
argv[1] = 1
argv[2] = 10800
argv[3] = 43200
sntp
main,297,sntp\_en =1,tz\_offset\_sec=10800,checktime=43200
wifi\_config\_service:4505
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
sysconf wlanapp start wlan0 wlan1 wlan0-va0 wlan1-va0
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
Init Wlan application...
FT Daemon v1.0 (Jul 2 2018 10:59:15)
change\_opmode: sleep 1s for NIC restart.
change\_opmode: sleep 2s for NIC restart.
wifi\_config\_service:4505
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
sysconf wlanapp start wlan0 wlan1 wlan0-va0 wlan1-va0
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
FT Daemon v1.0 (Jul 2 2018 10:59:15)
Init Wlan application...
Receive Pathsel daemon pid:2078
[arainc][multiWAN is not exit]netctrl\_phy\_link\_status\_change(1381)
change\_opmode: sleep 3s for NIC restart.
device eth0 entered promiscuous mode
br0: port 1(eth0) entered listening state
br0: port 1(eth0) entered listening state
[arainc][multiWAN is not exit]netctrl\_phy\_link\_status\_change(1381)
change\_opmode: sleep 1s for port reverted.
###fd failed to recv packet!###
##### NO SERVER FOUND! #####
br0: port 1(eth0) entered learning state
br0: port 2(wlan1) entered disabled state
change\_opmode: sleep 2s for port reverted.
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
ifconfig: SIOCGIFFLAGS: No such device
/bin/sh: wlanapp.sh: not found
br0: port 3(wlan-msh) entered disabled state
WlanSupportAbility = 0x3
available channels[US]: 1 2 3 4 5 6 7 8 9 10 11
[ODM\_software\_init]
[97F] Bonding Type 97FS, PKG1
[97F] RFE type 5 PHY paratemters: GPA1+GLNA1
clock 40MHz
load efuse ok
rom\_progress: 0x200006f
rom\_progress: 0x400006f
[GetHwReg88XX][PHY\_REG\_PG\_8197Fmp\_Type5] size
[GetHwReg88XX][PHY\_REG\_PG\_8197Fmp\_Type5]
[GetHwReg88XX][rtl8197Ffw]
[GetHwReg88XX][rtl8197Ffw size]
[97F] Default BB Swing=20
mesh\_passphrase\_update, before encrypt
65 39 66 66 34 64 32 66 62 65 37 38 30 30 36 30
mesh\_passphrase\_update, after encrypt
64 34 38 dd 13 2c 3b ad 7b d1 93 8e 8c a8 be 34
br0: port 2(wlan1) entered listening state
br0: port 2(wlan1) entered listening state
br0: port 3(wlan-msh) entered listening state
br0: port 3(wlan-msh) entered listening state
wifi\_config\_service:4505
change\_opmode: sleep 3s for port reverted.
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
sysconf wlanapp start wlan0 wlan1 wlan0-va0 wlan1-va0
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
open /proc/gpio: Permission denied
Init Wlan application...
FT Daemon v1.0 (Jul 2 2018 10:59:15)
Receive Pathsel daemon pid:2394
[ATM] atm\_swq\_en on
br0: topology change detected, propagating
br\_topology\_change\_detection, clear br0 fdb ...
br\_topology\_change\_detection, clear shortcut cache...
br0: port 1(eth0) entered forwarding state
change\_opmode: sleep 4s for port reverted.
br0: port 2(wlan1) entered learning state
br0: port 3(wlan-msh) entered learning state
change\_opmode: sleep 5s for port reverted.
change\_opmode: sleep 6s for port reverted.
br0: topology change detected, propagating
br\_topology\_change\_detection, clear br0 fdb ...
br\_topology\_change\_detection, clear shortcut cache...
br0: port 2(wlan1) entered forwarding state
Send SIGUSR2 signal from kernel to pathsel, skip for test by Jack
br0: topology change detected, propagating
br\_topology\_change\_detection, clear br0 fdb ...
br\_topology\_change\_detection, clear shortcut cache...
br0: port 3(wlan-msh) entered forwarding state
change\_opmode: sleep 7s for port reverted.
change\_opmode: sleep 8s for port reverted.
change\_opmode: sleep 9s for port reverted.
change\_opmode: sleep 10s for port reverted.
change\_opmode: sleep 11s for port reverted.
Phy[3] up
[arainc][multiWAN is not exit]netctrl\_phy\_link\_status\_change(1381)
change\_opmode: sleep 12s for port reverted.
change\_opmode: NIC restart finished.(WAN:1,LAN:0)
src/prod\_common\_rtl\_fn\_delete: failed del route from rtl865x!
hal.c,add\_local\_route\_to\_switch,179: config (192.168.5.0,255.255.255.0,br0) to the Realtek ASIC L3 Routing Table
[hw\_nat\_msg\_handle][245]var->op 3
[set\_hw\_nat\_by\_guest\_network][76]guest network is close!
eth1 has been deleted from br0!
hw\_nat\_config 113: #####################flags = 1
hw\_nat\_config 131: ##########enable = 1
hw\_nat\_config 152: set /proc/hw\_nat to 0
cat /proc/hw\_nat
wandial\_handle(231)
0
[arainc][ctrl\_op = 1]netctrl\_moudle\_multiwan\_handle(22)
argv[0] = multiWAN
multiWAN
multiWAN -> multiwan\_bad\_sig\_entry [18]...ct = 9
open:: No such file or directory
multiWAN -> multiwan\_bad\_sig\_entry [18]...ct = 8
iptables: No chain/target/match by that name.
multiWAN -> multiwan\_bad\_sig\_entry [18]...ct = 7
iptables: No chain/target/match by that name.
multiWAN -> multiwan\_bad\_sig\_entry [18]...ct = 6
multiWAN -> multiwan\_bad\_sig\_entry [18]...ct = 5
multiWAN -> multiwan\_bad\_sig\_entry [18]...ct = 4
multiWAN -> multiwan\_bad\_sig\_entry [18]...ct = 3
iptables: No chain/target/match by that name.
multiWAN -> multiwan\_bad\_sig\_entry [18]...ct = 2
multiWAN -> multiwan\_bad\_sig\_entry [18]...ct = 1
multiWAN -> multiwan\_bad\_sig\_entry [18]...ct = 0
iptables: No chain/target/match by that name.
iptables: No chain/target/match by that name.
argv[0] = dhcpcd\_wan1
argv[1] = -c
argv[2] = /etc/wan1.ini
argv[3] = -m
argv[4] = 1
argv[5] = eth1
argv[6] = -h
argv[7] = NOVA-0495e61a96e0
argv[8] = -x
argv[9] = /etc/dhcpc-wan-up1.sh
dhcpcd\_wan1
program\_name = dhcpcd\_lan
killall: dhcpcd\_lan: no process killed
[multiwan\_msg\_handle][2849]recv\_info->SendPid = 7, recv\_info->SendMid = 7, recv\_info->RecvPid = 5, recv\_info->RecvMid = 5
ganda\_debug--[igmp\_start]107 IGMP UP!!!
iptables: Bad rule (does a matching rule exist in that chain?).
iptables: Bad rule (does a matching rule exist in that chain?).
\*TBQ\* disabling tbq ...
\*TBQ\* tbq enqueue handlers is disabled
igmpproxy, Version 0.1 beta2, Build 170904
Copyright 2005 by Johnny Egeland
\*TBQ\* tbq backlog is cleared
Distributed unde\*TBQ\* tbq disabled
r the GNU GENERAL PUBLIC LICENSE, Version 2 - check GPL.txt
update\_hwnat\_setting 383:/proc/hw\_nat now is 0
route: SIOCDELRT: No such process
[multiwan\_set\_route\_single\_wan][1308][luminais] add\_default\_route\_success
[getAllWanDns][125]wan1.manual.dns.en = 0
[getAllWanDns][187]dns\_buf = -s 192.168.3.1
argv[0] = dnrd
argv[1] = -t
argv[2] = 3
argv[3] = -M
argv[4] = 600
argv[5] = --cache=off
argv[6] = -b
argv[7] = -R
argv[8] = /etc/dnrd
argv[9] = -r
argv[10] = 3
argv[11] = -s
argv[12] = 192.168.3.1
dnrd
[lan\_wan\_ip\_conflict\_check][707][luminais] wan : 192.168.3.140/255.255.255.0
Notice: caching turned off
[lan\_wan\_ip\_conflict\_check][722][luminais] br0 : 192.168.5.1/255.255.255.0
[multiwan\_msg\_handle][2849]recv\_info->SendPid = 4, recv\_info->SendMid = 4, recv\_info->RecvPid = 5, recv\_info->RecvMid = 5
open /dev/flow failed:: No such file or directory
iptables: No chain/target/match by that name.
iptables v1.4.4: Couldn't find target `icmp\_access'
Try `iptables -h' or 'iptables --help' for more information.
\*TBQ\* tbq is not running
\*TBQ\* config size: 278
\*TBQ\* Operation not set
\*TBQ\* wanid=ffffffff set
\*TBQ\* config.Rules[n].IpIncluded not set
\*TBQ\* config.Rules[n].UserIncluded not set
\*TBQ\* config.Rules[n].AppIncluded not set
\*TBQ\* MaxBacklogPackets set to: 9999
\*TBQ\* reloading tbq ...
\*TBQ\* tbq reloaded
\*TBQ\* ------------- TBQ CONFIG (rule count: 1) -------------
\*TBQ\* ~~~~~~~~~ TBQ RULE [UI-GLOBAL] ~~~~~~~~~
\*TBQ\* global out tokens\_per\_jiffy: 1280000
\*TBQ\* user out tokens\_per\_jiffy: 1280000
\*TBQ\* global in tokens\_per\_jiffy: 1280000
\*TBQ\* user in tokens\_per\_jiffy: 1280000
\*TBQ\* max\_backlog\_packets: 9999
\*TBQ\* latency\_shift: 7
\*TBQ\* disable\_timeout: 2
\*TBQ\* ------------------------------------------
\*TBQ\* tbq enabled
killall: xl2tpd-server: no process killed
iptables: No chain/target/match by that name.
iptables: Chain already exists.
iptables: Chain already exists.
iptables: No chain/target/match by that name.
iptables v1.4.4: Couldn't find target `web\_wanadmin'
Try `iptables -h' or 'iptables --help' for more information.
iptables: No chain/target/match by that name.
iptables: No chain/target/match by that name.
iptables v1.4.4: Couldn't find target `web\_wanadmin'
Try `iptables -h' or 'iptables --help' for more information.
iptables: No chain/target/match by that name.
miniupnpd.c,871,ver=1.0,osname=Nova,osver=1.0,osurl=http://www.tendacn.com/,manuft=Tenda,descri=Nova
[hw\_nat\_msg\_handle][245]var->op 2
[set\_hw\_nat\_by\_guest\_network][76]guest network is close!
hw\_nat\_config 113: #####################flags = 0
hw\_nat\_config 131: ##########enable = 0
[fill\_cloud\_info\_device\_lists\_rate][2600][luminais] NULL == g\_ip\_info
cat /proc/hw\_nat
[mib\_load\_manage][472][luminais] GetBasicInfo [0]
0
[mib\_save\_manage][532][luminais] AccoutACK [0]
dev\_mark\_list\_a(72)
[dev\_mark\_list\_a][75]
[upload\_local\_diff\_remark\_to\_cloud][2270][luminais] all client remark same with cloud.
[mesh\_node\_a][242]
[cloud\_mesh\_node\_handle][3977]
[save\_mesh\_node\_group\_conf][387][kg] groupsn = 181285920113001948
not need to write flash,crc:[3d7bd411]
commit cfm failed or not need write flash
not need to write flash,crc:[3d7bd411]
commit cfm failed or not need write flash
s\_time :1562925999991
config\_time :1562925999991 local\_time:1562925999991
telnet\_ate\_monitor\_recv(166)
telnet\_ate\_monitor\_recv(166)
[hw\_nat\_msg\_handle][245]var->op 1
[set\_hw\_nat\_by\_guest\_network][76]guest network is close!
hw\_nat\_config 113: #####################flags = 1
hw\_nat\_config 131: ##########enable = 0
cat /proc/hw\_nat
0
Normal startupGive root password for system maintenance
(or type Control-D for normal startup):
```
Консоль приглашает зайти, но без пароля рута не пускает.
Flash
-----
Китайская на 146% SPI flash BOHONG BH25Q64 на 8 Мб. [Datasheet](http://www.hhzealcore.com/upload/201807/02/201807021644551022.pdf)
Прошивка, то бишь firmware
==========================
Прошивку скачать с просторов интернета не удалось. Приложение на телефоне само скачивает прошивки из китайского Tenda облака, причем по своему протоколу, как выяснилось позже. Мои кубики имеют последнюю прошивку, по-этому вынюхать, откуда скачивается прошивка, не удалось.
Давайте просто снимем дамп с флешки
-----------------------------------
Сначала попробовал надеть сверху на чип клещи и считать прошивку — но, как и ожидалось, у меня этого не получилось, т.к. запитывая флешку, запустился процессор и пошло поехало. Резать дорожки не хотелось, поэтому решил выпаять. Огородив окрестности ~~Онежского озера~~ окаянного отпрыска китайской промышленности каптоновым скотчем — подогрел феном и выпаял зверушку по-македонски — двумя паяльниками. Ну и хочется динамичности в процессе смены прошивок — подпаял хвостики для кроватки.
Чем бы снять дамп?
------------------
Флешки я читаю раз в пять лет, надобности нет, а соответственно — и программаторов для них. В закромах нашел платку FTDI FT2232H, которой я пользовался для отладки ESP32 через JTAG + OpenOCD. Оказалось, она много чего умеет. В том числе и SPI в режиме мастера. Нагуглил на нее даташит и записал распиновку при подключении к первому каналу (порту):
| FT2232H | Function | Нога на флешке |
| --- | --- | --- |
| ADBUS0 | SCK | 6 |
| ADBUS1 | MOSI | 5 |
| ADBUS2 | MISO | 2 |
| ADBUS3 | CS | 1 |
Оставшиеся ножки флешки 4 — GND, 8, 3 и 7 — VCC 3.3v.
### Flashrom
Параллельно поиску железяк в закромах нагуглил [flashrom](https://flashrom.org) — популярная утилитка для работы с флешками.
Запускаем...
```
$ flashrom -p ft2232_spi:type=2232H,port=A
```
… и, вообщем, смотрим в книгу — видим фигу.
**$ flashrom v0.9.9-r1954 on Linux 4.18.0-25-generic (x86\_64)**
```
flashrom is free software, get the source code at https://flashrom.org
Calibrating delay loop... OK.
Found Generic flash chip "unknown SPI chip (RDID)" (0 kB, SPI) on ft2232_spi.
===
This flash part has status NOT WORKING for operations: PROBE READ ERASE WRITE
The test status of this chip may have been updated in the latest development
version of flashrom. If you are running the latest development version,
please email a report to flashrom@flashrom.org if any of the above operations
work correctly for you with this flash chip. Please include the flashrom log
file for all operations you tested (see the man page for details), and mention
which mainboard or programmer you tested in the subject line.
Thanks for your help!
No operations were specified.
```
К сожалению, флешка чересчур китайская, софтинка её понимать отказалась, а может ли она работать в каком-то "стандартном" или "generic" режиме я не понял.
### Ардуины спешат на помощь. Ну и esp8266 с ними.
Опять пошел гуглить. Нагуглил древнюю поделку [доброго человека с сайта Технохрень](http://skproj.ru/programmator-spi-flash-svoimi-rukami/). Комплект из скетча для ардуины и приложения на .NET.
Поразмыслив, что для ардуины придется городить согласование уровней 3.3в и 5в — взял из закромов платку NodeMCU на `esp8266`. Она на 3.3в.
Скетч запустился без проблем, правда я никак не мог флешку прочитать — после пары научных тыков преподключил флешку ко второму SPI порту, который называется HSPI и выведен на ноги `GPIO 12..14` согласно [официальной документации](https://nodemcu.readthedocs.io/en/master/modules/spi/).
* **NB** Надо сказать, что `flashrom` еще умеет работать с программатором `serprog`, в который собственно можно превратить любую 8-битную AVRку, включая ардуины. Но, к сожалению, быстрый гуглинг порта для esp8266 не дал результатов.
### Дайте нормальную флешку!
Вообщем, чтобы не париться с китайской флешкой, в небезызвестном своими ценовыми политиками магазине имени двух бурундуков приобрел за огромные деньги в 110 рублей (2 USD) нормальную флешку Winbond W25Q64FV. Куда тут же залил считанный дамп и воткнул в кубик.
```
$ flashrom -p ft2232_spi:type=2232H,port=A -w all.bin
```
Tenda флешку подхватила и запустилась, как ни в чем не бывало. (Хотя, по-моему, она разок перезагрузилась, переписав что-то в конфиге/облаке. Не заметил что именно).
А ну-ка, давай-ка
-----------------
В прошивке что-то есть. По крайней мере, binwalk нашел всякого. Как я понял — достаточно стандартно для таких железяк.
Попробуем раскопать, что-нибудь исправить и закопать обратно.
**$ binwalk all.bin**
```
DECIMAL HEXADECIMAL DESCRIPTION
--------------------------------------------------------------------------------
35096 0x8918 CRC32 polynomial table, little endian
36192 0x8D60 gzip compressed data, maximum compression, from Unix, last modified: 2018-04-20 02:17:42
206872 0x32818 LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 6890804 bytes
2261010 0x228012 Squashfs filesystem, little endian, version 4.0, compression:xz, size: 3071844 bytes, 378 inodes, blocksize: 131072 bytes, created: 1902-05-30 15:13:04
6160384 0x5E0000 JFFS2 filesystem, little endian
```
Сразу распаковывать не стал. Еще первый раз в bootlog-е видел, что мелькала разбивка флешки на разделы — сначала разбил командой `dd` на соответствующие куски, а потом уже играл с `binwalk`.
**bootlog : mtd partitions**
```
flash vendor: BOHONG
m25p80 spi0.0: BH25Q64 (8192 Kbytes) (55000000 Hz)
m25p80 spi0.0: change speed to 55000000Hz, div 2
Kernel code size:0x1f8012
9 rtkxxpart partitions found on MTD device m25p80
Creating 9 MTD partitions on "m25p80":
0x000000000000-0x000000800000 : "ALL"
0x000000000000-0x000000020000 : "Bootloader"
0x000000020000-0x000000030000 : "CFG"
0x000000030000-0x0000005c0000 : "KernelFS"
0x000000228012-0x0000005c0000 : "RootFS"
0x0000005c0000-0x0000005d0000 : "CFM"
0x0000005d0000-0x0000005e0000 : "CFM_BACKUP"
0x0000005e0000-0x0000007f0000 : "LOG"
0x0000007f0000-0x000000800000 : "ENV"
```
Пример вырезания RootFS из файла прошивки `all.bin`:
```
$ dd if=all.bin of=RootFS.bin bs=1 skip=$((0x228012)) count=$((0x5c0000-0x228012))
```
Я не специалист, но мне кажется странным, что согласно разметке раздел RootFS находится внутри KernelFS.
Кроме того, устройство ядра для меня загадка, поэтому его трогать не стал.
Весь процесс загрузки, как я понял, почти прямолинеен:
* сначала процессор отображает флешку к себе в память,
* запускает bootloader,
* bootloader делает магию с настройками DDR, потом проверяет, не хочет ли кто-то по TFTP загрузить новую прошивку,
* после чего он грузит уже ядро.
RootFS
------
Распаковать файловую систему элементарно — `unsquashfs RootFS.bin`. В результате работы появляется папка `squashfs-root` с деревом папок/файлов.
* Тут уже есть, что посмотреть! — подумал я.
cat `/etc_ro/passwd`
```
root:$1$nalENqL8$jnRFwb1x5S.ygN.3nwTbG1:0:0:root:/:/bin/sh
```
cat `/etc_ro/shadow`
```
root:$1$OVhtCyFa$7tISyKW1KGssHAQj1vI3i1:14319::::::
```
cat `/etc_ro/inittab`
```
::sysinit:/etc_ro/init.d/rcS
ttyS0::respawn:/sbin/sulogin
::ctrlaltdel:/bin/umount -a -r
::shutdown:/usr/sbin/usb led_off
```
**В `/etc\_ro/fstab` ничего интересного.**
```
proc /proc proc defaults 0 0
#none /var ramfs defaults 0 0
none /tmp ramfs defaults 0 0
mdev /dev ramfs defaults 0 0
none /sys sysfs defaults 0 0
```
**Впрочем, ничего интересного я не нашел и в `/etc\_ro/init.d/rcS`.**
```
#! /bin/sh
PATH=/sbin:/bin:/usr/sbin:/usr/bin/
export PATH
mount -t ramfs none /var/
mkdir -p /var/etc
mkdir -p /var/media
mkdir -p /var/webroot
mkdir -p /var/etc/iproute
mkdir -p /var/run
mkdir -p /var/debug
cp -rf /etc_ro/* /etc/
cp -rf /webroot_ro/* /webroot/
mkdir -p /var/etc/upan
mount -a
mount -t ramfs /dev
mkdir /dev/pts
mount -t devpts devpts /dev/pts
mount -t tmpfs none /var/etc/upan -o size=2M
mdev -s
mkdir /var/run
echo 1 > /proc/sys/vm/panic_on_oom
echo 1 > /proc/sys/kernel/panic_on_oops
echo '/sbin/mdev' > /proc/sys/kernel/hotplug
#echo 'sd[a-z][0-9] 0:0 0660 @/usr/sbin/autoUsb.sh $MDEV' >> /etc/mdev.conf
#echo 'sd[a-z] 0:0 0660 $/usr/sbin/DelUsb.sh $MDEV' >> /etc/mdev.conf
#echo 'lp[0-9] 0:0 0660 */usr/sbin/IppPrint.sh'>> /etc/mdev.conf
#wds rule start
echo 'wds*.* 0:0 0660 */etc/wds.sh $ACTION $INTERFACE' > /etc/mdev.conf
#wsd rule end
echo 'sd[a-z][0-9] 0:0 0660 @/usr/sbin/usb_up.sh $MDEV $DEVPATH' >> /etc/mdev.conf
echo '-sd[a-z] 0:0 0660 $/usr/sbin/usb_down.sh $MDEV $DEVPATH'>> /etc/mdev.conf
echo 'sd[a-z] 0:0 0660 @/usr/sbin/usb_up.sh $MDEV $DEVPATH'>> /etc/mdev.conf
echo '.* 0:0 0660 */usr/sbin/IppPrint.sh $ACTION $INTERFACE'>> /etc/mdev.conf
mkdir -p /var/ppp
insmod /lib/modules/dhcp_options.ko
#insmod /lib/modules/gpio.ko
insmod /lib/modules/phy_check.ko
#insmod /lib/modules/fastnat.ko
insmod /lib/modules/bm.ko
#insmod /lib/modules/ai.ko
insmod /lib/modules/mac_filter.ko
#insmod /lib/modules/ip_mac_bind.ko
#insmod /lib/modules/privilege_ip.ko
insmod /lib/modules/nos.ko
#insmod /lib/modules/url_filter.ko
#insmod /lib/modules/loadbalance.ko
#insmod /lib/modules/app_filter.ko
#insmod /lib/modules/port_filter.ko
#insmod /lib/modules/arp_fence.ko
#insmod /lib/modules/ddos_ip_fence.ko
#/etc/gpio_conf
echo "enable 0 interval 0" >/proc/watchdog_cmd
chmod +x /etc/mdev.conf
mkdir -p /tmp/log
mkdir -p /tmp/log/crash
mkdir -p /tmp/log_print
ln -sf /proc/port1 /var/port1
ln -sf /proc/port3 /var/port0
echo 'kern.* /tmp/log/kernel.log' >> /etc/syslog.conf
echo '*.* /tmp/log_print/message.txt' >> /etc/syslog.conf
klogd -n &
syslogd -f /var/etc/syslog.conf -s 50 &
monitor &
sh /usr/bin/ugw_watchdog.sh 2>/tmp/log_print/ugw_watchdog.log&
#sh /usr/bin/mesh_op.sh > /dev/null &
```
Юзеров не много, ttyS0 можно было бы и не на `/sbin/sulogin` натравливать, а на `/bin/login -f root` или `/bin/sh`.
Вторая наивная попытка войти
============================
Попробуем поправить `/etc_ro/inittab`. Заменил `ttyS0::respawn:/sbin/sulogin` на `ttyS0::respawn:/bin/login -f root`.
Запаковал обратно squashfs с помощью `mksquashfs` — файл стал в 1.5 раза больше и перестал влезать в раздел. Заметил, что оригинальный файл был пожат алгоритмом `xz`, а утилита по-умолчанию использует `lzma`. Переделал файл с нужным алгоритмом компресии — все стало ок. Подсмотрев в содержимое оригинального дампа раздела RootFS добил свой новый файл до размера раздела байтом `0xff`. С помощью `dd` скопировал новый раздел на место старого. Записал всё на флешку. Потираю ручки, включаю кубик...
**Booting...**
```
init_ram
00000202 M init ddr ok
DRAM Type: DDR2
DRAM frequency: 533MHz
DRAM Size: 128MB
JEDEC id EF4017, EXT id 0x0000
found w25q64
flash vendor: Winbond
w25q64, size=8MB, erasesize=64KB, max_speed_hz=29000000Hz
auto_mode=0 addr_width=3 erase_opcode=0x000000d8
=>CPU Wake-up interrupt happen! GISR=89000004
---Realtek RTL8197F boot code at 2018.04.20-10:17+0800 v3.4.11B.9 (999MHz)
Mac addr:04-95-e6-1a-96-e0
lan_wan_isolation Initing...
config: lan port mask is 0x000000f7
config: wan port mask is 0x000000e8
lan_wan_isolation Initing has been completed.
lan_wan_isolation Initing...
config: lan port mask is 0x000000f7
config: wan port mask is 0x000000e8
lan_wan_isolation Initing has been completed.
wait for upgrage
port[0] link:down
port[1] link:down
port[2] link:down
port[3] link:down
port[4] link:down
irq:0x00008080
rootfs checksum error at 00228012!
```
**Какой мощный фейл!** Как я вообще мог не подумать про CRC.
Смотрю еще раз `binwalk` — bootloader не UBoot, гуглинг подсказывает, что RealTek — ребята скрытные. В общем доступе описания нет, кроме того, под каждый девайс свои сигнатуры призывают делать, чтобы неповадно реверсить было… Эх.
Для UBoot и ряда других случаев может помочь древний заброшенный проект [firmware-mod-kit](https://code.google.com/archive/p/firmware-mod-kit/), либо есть гордый потомок — наикрутейший [Firmware Analysis Toolkit](https://github.com/attify/firmware-analysis-toolkit)
Погуглил по темным закоулкам интернета — нашел относительно свежий RealTek SDK года 2015-го. Архив на 600 Мб. Одним глазом поглядел на процесс построения финального образа прошивки и расчет CRC — плюнул и закрыл. Пока что жалко мозг. И время. Может быть потом как-нибудь.
Еще попыточка
=============
Конечно же, я с первого раза заметил, что при загрузке кубик выдает подозрительную надпись в логе:
```
argv[0] = netctrl
netctrl
prod_change_root_passwd(83)
```
Запускается процесс `netctrl` и меняет пароль.
Ну давайте поиграем. Вспомнил, как 20 лет назад писал софт по ZX Spectrum на ассемблере и ломал игрушки, чтобы жизней было побольше и бесконечные патроны.
Больше к ассемблеру не притрагивался, не считая того факта, что на 3-4 года позже благодаря ему я попал на первую работу. Фиксал ~~KDE под FreeBSD~~ драйвера для виндовского setup-загрузчика.
Берем IDA PRO в долг у приятеля.
Куда же посмотреть сначала?
---------------------------
Наверное надо найти, где же выводится данная надпись. Ищем текст `prod_change_root_passwd` по файлам — в результатах много исполняемых файлов, включая тот самый `/bin/netctrl`, а также одна библиотека `/lib/libcommonprod.so`. Нам повезло — судя по всему и функция и текст вывода на экран совпадают, а сама реализация — в файле библиотеки.
Вспомнила бабка первый поцелуй
------------------------------
Запускаем IDA PRO, который я вижу первый раз в жизни. Как и MIPS ассемблер.
Открываем `/bin/netctrl`. Система сразу любезно открыла нам функцию `main`. Ничего не понятно, но, судя по всему, вначале очищаются буферы и инициализируются локальные переменные. А потом, скорее всего, из конфига считывается параметр `sys.role` и на основе его значения программа либо засыпает, либо… вызывает внешнюю функцию с тем самым подозрительным названием. Параметров вроде никаких нет. Как я понял, параметры передаются в регистрах $a0..$a3.
Открываем `/lib/libcommonprod.so`, а в нем — искомую функцию. Она тоже начинает работу с зачистки буферов, потом считывает параметры из конфига и… **О, БОЖЕ!** берет пароль от wifi, кодирует его в base64 и меняет на это пароль рута.
А-а-лилуйя!
-----------
Вообщем, при каждой загрузке пароль рута устанавливается в `base64(пароль от wifi)`. После сброса настроек — см. пароль на стикере на самом роутере.
```
Normal startupGive root password for system maintenance
(or type Control-D for normal startup):
System Maintenance Mode
~ #
~ # uname -a
Linux NOVA-xxxxxxxxxxxx 3.10.90 #4 Mon Jul 2 10:57:35 CST 2018 mips GNU/Linux
```
Мы внутри
---------
Вообщем, сильно много интересного внутри нет. Всё разделы r/o, по-этому все в RootFS и текстовых конфигах на отдельном разделе.
**~ # cat /proc/cpuinfo**
```
system type : RTL8197F
machine : Unknown
processor : 0
cpu model : MIPS 24Kc V8.5
BogoMIPS : 666.41
wait instruction : yes
microsecond timers : yes
tlb_entries : 64
extra interrupt vector : yes
hardware watchpoint : yes, count: 4, address/irw mask: [0x0ffc, 0x0ffc, 0x0ffb, 0x0ffb]
isa : mips1 mips2 mips32r2
ASEs implemented : mips16
shadow register sets : 4
kscratch registers : 0
core : 1
VCED exceptions : not available
VCEI exceptions : not available
```
**~ # ls -l /sys/class/gpio/**
```
total 0
--w------- 1 root root 16384 Jan 1 1970 export
lrwxrwxrwx 1 root root 0 Jan 1 1970 gpio18 -> ../../devices/virtual/gpio/gpio18
lrwxrwxrwx 1 root root 0 Jan 1 1970 gpio19 -> ../../devices/virtual/gpio/gpio19
lrwxrwxrwx 1 root root 0 Jan 1 1970 gpio58 -> ../../devices/virtual/gpio/gpio58
lrwxrwxrwx 1 root root 0 Jan 1 1970 gpiochip0 -> ../../devices/virtual/gpio/gpiochip0
--w------- 1 root root 16384 Jan 1 1970 unexport
```
**~ # ls -l /sys/devices/platform/**
```
total 0
drwxr-xr-x 2 root root 0 Jul 18 21:12 alarmtimer
drwxr-xr-x 2 root root 0 Jul 18 21:12 rtl819x_8367r_i2c_pin.1
drwxr-xr-x 2 root root 0 Jul 18 21:12 rtl819x_8367r_i2c_pin.2
drwxr-xr-x 2 root root 0 Jul 18 21:12 rtl819x_8367r_reset_pin.0
drwxr-xr-x 2 root root 0 Jul 18 21:12 rtl819x_btn.0
drwxr-xr-x 2 root root 0 Jul 18 21:12 rtl819x_led.0
drwxr-xr-x 2 root root 0 Jul 18 21:12 rtl819x_led.1
drwxr-xr-x 2 root root 0 Jul 18 21:12 rtl819x_led.2
drwxr-xr-x 3 root root 0 Jan 1 1970 serial8250
drwxr-xr-x 3 root root 0 Jan 1 1970 spi-sheipa.0
-rw-r--r-- 1 root root 16384 Jul 18 21:12 uevent
```
**~ # ps**
```
PID USER TIME COMMAND
1 root 0:01 init
2 root 0:00 [kthreadd]
3 root 0:40 [ksoftirqd/0]
4 root 0:00 [kworker/0:0]
5 root 0:00 [kworker/0:0H]
6 root 0:01 [kworker/u2:0]
7 root 0:00 [khelper]
8 root 0:00 [kworker/u2:1]
75 root 0:00 [writeback]
78 root 0:00 [bioset]
79 root 0:00 [crypto]
81 root 0:00 [kblockd]
84 root 0:01 [spi0]
102 root 0:00 [kworker/0:1]
106 root 0:00 [kswapd0]
154 root 0:00 [fsnotify_mark]
708 root 0:00 [mtdblock0]
713 root 0:00 [mtdblock1]
718 root 0:00 [mtdblock2]
723 root 0:00 [mtdblock3]
728 root 0:00 [mtdblock4]
733 root 0:00 [mtdblock5]
738 root 0:00 [mtdblock6]
743 root 0:00 [mtdblock7]
748 root 0:00 [mtdblock8]
802 root 0:00 [deferwq]
860 root 0:03 klogd -n
862 root 0:00 monitor
863 root 1:55 sh /usr/bin/ugw_watchdog.sh
869 root 0:00 syslogd -f /var/etc/syslog.conf -s 50
914 root 0:15 cfmd
1030 root 0:00 [jffs2_gcd_mtd7]
1032 root 0:11 timer
1033 root 0:00 logserver
1034 root 0:14 netctrl
1069 root 0:01 device_list
1071 root 3:20 sh /usr/bin/mesh_op.sh
1530 root 0:10 pann
1531 root 0:00 gpio_ctrl
1532 root 0:00 mesh_status_check
1534 root 0:19 network_check
1570 root 0:00 redis-server /etc_ro/redis.conf
1571 root 0:01 cmdsrv -l tcp://0.0.0.0:12598 -R tcp://127.0.0.1:6379
1572 root 0:00 [kworker/0:1H]
1573 root 0:05 confsrv
1599 root 0:01 dhcps -C /etc/dhcps.conf -l /etc/dhcps.leases -x /etc/dhc
1931 root 0:00 ucloud -l 4
1962 root 0:00 sntp 1 28800 43200
2370 root 0:00 ftd -br br0 -w wlan0 wlan1 -pid /var/run/ft.pid -c /tmp/f
2375 root 0:00 pathsel -i wlan-msh -P -t 9
2387 root 0:00 multiWAN
2488 root 0:00 dhcpcd_wan1 -c /etc/wan1.ini -m 1 eth1 -h NOVA-0495e61a96
2567 root 0:00 dnrd -t 3 -M 600 --cache=off -b -R /etc/dnrd -r 3 -s 192.
2955 root 0:00 miniupnpd -f /etc/miniupnpd.config -w
2991 root 0:00 igmpproxy
10388 root 0:00 -sh
12125 root 0:00 sleep 5
12155 root 0:00 sleep 1
12156 root 0:00 ps
```
Access granted, root
====================
Собственно, рутовый доступ получен. Позитивные эмоции получены. Приятно же иметь доступ ко всему, чем владеешь. А то эта эпоха всё позакрывать и выдавать черные ящики с сюрпризами мне очень не нравится.
А что дальше?
=============
А дальше хочется вернуться к изначальной проблеме — прибить DHCP сервер. Это для начала.
Для этого надо будет изучить процессы загрузки, скрипты. Всё это осложняется пока что отсутствием возможности перепаковать образ прошивки — надо копать RSDK.
Кроме того, достаточно интересно пощупать на наличие китайских бэкдоров. Ну и, если прошивку не удасться перепаковать, поковырять cloud протокол, чтобы таки получить доступ снаружи.
Но, в любом случае, я получил массу удовольствия в процессе раскопок.
Ссылки
======
1. Все файлы, логи и пр. доступны у меня в репозитории на <https://github.com/latonita/tenda-reverse>
2. [Tenda Mesh3-18 (Nova MW6 2018) on wikidevi.com](https://wikidevi.com/wiki/Tenda_Mesh3-18_(Nova_MW6_2018))
3. [SPI Flash programmer by SKProj на сайте Технохрень](http://skproj.ru/programmator-spi-flash-svoimi-rukami/)
4. [flashrom homepage](https://flashrom.org/Flashrom)
5. [firmware-mod-kit (давно заброшен)](https://code.google.com/archive/p/firmware-mod-kit/)
6. Достаточно интересный проект по эмуляции и анализу linux-based firmware — [firmadyne](https://github.com/firmadyne/firmadyne)
7. Кладезь для анализа и автоматической перепаковки — [Firmware Analysis Toolkit](https://github.com/attify/firmware-analysis-toolkit) | https://habr.com/ru/post/460591/ | null | ru | null |
# .Net: Затраты на многопоточность
Недавно получил простую задачу: написать windows-сервис для обработки пользовательских запросов. Вопрос про то, какие эти запросы и по какому протоколу работает сервис, выходит за рамки этой статьи. Более интересным мне показался другой фактор, многопоточную ли делать обработку запросов. С одной стороны — последовательное выполнение тормозит процес обработки информации. С другой стороны могут быть не оправданы затраты на создание и запуск потока.
Итак, исходные данные: 20 простейших запросов в секунду (1200 запросов в минуту) в пиковое время. Тестовый «сервер»: Celeron, 3ГЦ, 1Гб (свободно 70%).
### Однопоточная система
Сначала напишем класс-базу для однопоточного выполнения запросов.
> `1. using System;
> 2. using System.Diagnostics;
> 3. using System.Threading;
> 4.
> 5. namespace TestConsoleApplication
> 6. {
> 7.
> 8. class mockClass
> 9. {
> 10. private readonly Int32 incriment\_speed;
> 11. private Int32 inc;
> 12.
> 13. public mockClass(int incriment\_speed)
> 14. {
> 15. this.incriment\_speed = incriment\_speed;
> 16. inc = 0;
> 17. }
> 18.
> 19. public Int32 incriment()
> 20. {
> 21. Thread.Sleep(incriment\_speed);
> 22. return inc++;
> 23. }
> 24.
> 25. public Int32 getIncriment()
> 26. {
> 27. return inc;
> 28. }
> 29.
> 30. }
> 31.
> 32. class TestConsoleApplication
> 33. {
> 34.
> 35. static void Main(string[] args)
> 36. {
> 37. if (args.Length<1) return;
> 38.
> 39. Int32 mockSpeed = 0;
> 40. if (!Int32.TryParse(args[0], out mockSpeed)) return;
> 41. var mock = new mockClass(mockSpeed);
> 42.
> 43. int beginTick = Environment.TickCount;
> 44. for (int j = 0; j < 1200; j++)
> 45. {
> 46. mock.incriment();
> 47. }
> 48. int endTick = Environment.TickCount;
> 49.
> 50. var performance = new PerformanceCounter("Process", "Private Bytes", Process.GetCurrentProcess().ProcessName);
> 51. Console.WriteLine(mock.getIncriment());
> 52. Console.WriteLine("tick: {0}", endTick - beginTick);
> 53. Console.WriteLine("memory: {0:N0}K", (performance.RawValue/1024));
> 54. Console.ReadLine();
> 55. }
> 56. }
> 57. }
> \* This source code was highlighted with Source Code Highlighter.`
Запустим программу с несколькими параметрами задержки выполнения запроса: 2, 5, 10
| | | |
| --- | --- | --- |
| 2 | 5 | 10 |
| tick | memory | tick | memory | tick | memory |
| 3688 | 10 792K | 7281 | 10 780K | 13125 | 10 792K |
Как видим память практически не страдает, а время примерно равно (mockSpeed+1)\*1200. Дополнительную миллисекунду спишем на накладные расходы.
### Многопоточная система
Перепишем программу для работы с многопоточностью, оптимизируем ее и сверим результаты:
> `1. using System;
> 2. using System.Diagnostics;
> 3. using System.Threading;
> 4.
> 5. namespace TestConsoleApplication
> 6. {
> 7.
> 8. class mockClass
> 9. {
> 10. private readonly Int32 incriment\_speed;
> 11. private Int32 inc;
> 12.
> 13. public mockClass(int incriment\_speed)
> 14. {
> 15. this.incriment\_speed = incriment\_speed;
> 16. inc = 0;
> 17. }
> 18.
> 19. public Int32 incriment()
> 20. {
> 21. Thread.Sleep(incriment\_speed);
> 22. return inc++;
> 23. }
> 24.
> 25. public Int32 getIncriment()
> 26. {
> 27. return inc;
> 28. }
> 29.
> 30. }
> 31.
> 32. class TestConsoleApplication
> 33. {
> 34. private static mockClass mock = null;
> 35.
> 36. static void threadmethod()
> 37. {
> 38. lock (mock)
> 39. {
> 40. mock.incriment();
> 41. }
> 42. }
> 43.
> 44. static void Main(string[] args)
> 45. {
> 46. if (args.Length<1) return;
> 47.
> 48. Int32 mockSpeed = 0;
> 49. if (!Int32.TryParse(args[0], out mockSpeed)) return;
> 50. mock = new mockClass(mockSpeed);
> 51.
> 52. var performance = new PerformanceCounter("Process", "Private Bytes", Process.GetCurrentProcess().ProcessName);
> 53. long performance\_RawValue = 0;
> 54. int beginTick = Environment.TickCount;
> 55. lock (mock)
> 56. {
> 57. for (int j = 0; j < 1200; j++)
> 58. {
> 59. var trd = new Thread(threadmethod, 65536); //выделяем 1 страницу под стек
> 60. trd.Start();
> 61. }
> 62. performance\_RawValue = performance.RawValue;
> 63. }
> 64. int end1Tick = Environment.TickCount;
> 65. while(mock.getIncriment()<1200)
> 66. {
> 67. Thread.Sleep(2);
> 68. }
> 69. int end2Tick = Environment.TickCount;
> 70.
> 71. Console.WriteLine("starttick: {0}", end1Tick - beginTick);
> 72. Console.WriteLine("alltick: {0}", end2Tick - beginTick);
> 73. Console.WriteLine("memory: {0:N0}K", (performance\_RawValue / 1024));
> 74. Console.ReadLine();
> 75. }
> 76. }
> 77. }
> \* This source code was highlighted with Source Code Highlighter.`
| | | | |
| --- | --- | --- | --- |
| - | 2 | 5 | 10 |
| - | start tick | all tick | memory | start tick | all tick | memory | start tick | all tick | memory |
| Однопоточная | - | 3688 | 10 792K | - | 7281 | 10 780K | - | 13125 | 10 792K |
| Многопоточная | 656 | 4234 | 323 508K | 625 | 7719 | 323 508K | 750 | 13735 | 323 508K |
При тестировании производительности многопоточности появилась новая величина время запуска процессов. Именно на эту величину вырастает общая продолжительность выполнения программы. Примерный запуск процесса равен 0,5миллисекундам. Также мы видим, значительно выросший объем используемой памяти, которая расходуется на стек запускаемых потоков.
### Итоги
Выделим все сравниваемые величины в таблицу.
| | | |
| --- | --- | --- |
| - | Однопоточная | Многопоточная |
| Общее время | Общее время основного потока зависит от времени выполнения всех запросов | Время работы основного потока зависит только от количества запросов |
| Общее процессорное время | Низкие паразитные нагрузки | Паразитные нагрузки в 2 раза выше |
| Память | Невысокие запросы к памяти, независящие от количества запросов | На каждый запрос расходуется не менее 256Кб памяти на стек потока |
Вот такая «студенческая лабораторная работа» вышла при изучении такого вопроса. Прошу не кидать камни :) | https://habr.com/ru/post/58931/ | null | ru | null |
# Пять простых шагов для понимания JSON Web Tokens (JWT)
Представляю вам мой довольно вольный перевод статьи [5 Easy Steps to Understanding JSON Web Tokens (JWT)](https://medium.com/vandium-software/5-easy-steps-to-understanding-json-web-tokens-jwt-1164c0adfcec). В этой статье будет рассказано о том, что из себя представляют *JSON Web Tokens (JWT)* и с чем их едят. То есть какую роль они играют в проверке подлинности пользователя и обеспечении безопасности данных приложения.
Для начала рассмотрим формальное определение.
> `JSON Web Token (JWT)` — это *JSON* объект, который определен в открытом стандарте [RFC 7519](https://tools.ietf.org/html/rfc7519). Он считается одним из безопасных способов передачи информации между двумя участниками. Для его создания необходимо определить заголовок (header) с общей информацией по токену, полезные данные (payload), такие как id пользователя, его роль и т.д. и подписи (signature).
>
> Кстати, правильно *JWT* произносится как `/dʒɒt/`
Простыми словами, *JWT* — это лишь строка в следующем формате `header.payload.signature`.
Предположим, что мы хотим зарегистрироваться на сайте. В нашем случае есть три участника — пользователь `user`, сервер приложения `application server` и сервер аутентификации `authentication server`. Сервер аутентификации будет обеспечивать пользователя токеном, с помощью которого он позднее сможет взаимодействовать с приложением.
Приложение использует *JWT* для проверки аутентификации пользователя следующим образом:
1. Сперва пользователь заходит на сервер аутентификации с помощью аутентификационного ключа (это может быть пара *логин/пароль*, либо *Facebook* ключ, либо *Google* ключ, либо ключ от другой учетки).
2. Затем сервер аутентификации создает *JWT* и отправляет его пользователю.
3. Когда пользователь делает запрос к API приложения, он добавляет к нему полученный ранее *JWT*.
4. Когда пользователь делает API запрос, приложение может проверить по переданному с запросом *JWT* является ли пользователь тем, за кого себя выдает. В этой схеме сервер приложения сконфигурирован так, что сможет проверить, является ли входящий *JWT* именно тем, что был создан сервером аутентификации (процесс проверки будет объяснен позже более детально).
Структура JWT
-------------
*JWT* состоит из трех частей: заголовок `header`, полезные данные `payload` и подпись `signature`. Давайте пройдемся по каждой из них.
### Шаг 1. Создаем HEADER
Хедер *JWT* содержит информацию о том, как должна вычисляться *JWT* подпись. Хедер — это тоже *JSON* объект, который выглядит следующим образом:
```
header = { "alg": "HS256", "typ": "JWT"}
```
Поле `typ` не говорит нам ничего нового, только то, что это *JSON Web Token*. Интереснее здесь будет поле `alg`, которое определяет алгоритм хеширования. Он будет использоваться при создании подписи. `HS256` — не что иное, как `HMAC-SHA256`, для его вычисления нужен лишь один секретный ключ (более подробно об этом в шаге 3). Еще может использоваться другой алгоритм `RS256` — в отличие от предыдущего, он является ассиметричным и создает два ключа: публичный и приватный. С помощью приватного ключа создается подпись, а с помощью публичного только лишь проверяется подлинность подписи, поэтому нам не нужно беспокоиться о его безопасности.
### Шаг 2. Создаем PAYLOAD
**Payload** — это полезные данные, которые хранятся внутри *JWT*. Эти данные также называют *JWT-claims* (заявки). В примере, который рассматриваем мы, сервер аутентификации создает *JWT* с информацией об *id* пользователя — **userId**.
```
payload = { "userId": "b08f86af-35da-48f2-8fab-cef3904660bd" }
```
Мы положили только одну *заявку* (claim) в *payload*. Вы можете положить столько *заявок*, сколько захотите. Существует список стандартных *заявок* для *JWT* payload — вот некоторые из них:
* *iss* (issuer) — определяет приложение, из которого отправляется токен.
* *sub* (subject) — определяет тему токена.
* *exp* (expiration time) — время жизни токена.
Эти поля могут быть полезными при создании *JWT*, но они не являются обязательными. Если хотите знать весь список доступных полей для *JWT*, можете заглянуть в [Wiki](https://en.wikipedia.org/wiki/JSON_Web_Token#Standard_fields). Но стоит помнить, что чем больше передается информации, тем больший получится в итоге сам *JWT*. Обычно с этим не бывает проблем, но все-таки это может негативно сказаться на производительности и вызвать задержки во взаимодействии с сервером.
### Шаг 3. Создаем SIGNATURE
Подпись вычисляется с использование следующего псевдо-кода:
```
const SECRET_KEY = 'cAtwa1kkEy'
const unsignedToken = base64urlEncode(header) + '.' + base64urlEncode(payload)
const signature = HMAC-SHA256(unsignedToken, SECRET_KEY)
```
Алгоритм **base64url** кодирует хедер и payload, созданные на *1* и *2* шаге. Алгоритм соединяет закодированные строки через точку. Затем полученная строка хешируется алгоритмом, заданным в хедере на основе нашего секретного ключа.
```
// header eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9
// payload eyJ1c2VySWQiOiJiMDhmODZhZi0zNWRhLTQ4ZjItOGZhYi1jZWYzOTA0NjYwYmQifQ
// signature -xN_h82PHVTCMA9vdoHrcZxH-x5mb11y1537t3rGzcM
```
### Шаг 4. Теперь объединим все три JWT компонента вместе
Теперь, когда у нас есть все три составляющих, мы можем создать наш *JWT*. Это довольно просто, мы соединяем все полученные элементы в строку через точку.
```
const token = encodeBase64Url(header) + '.' + encodeBase64Url(payload) + '.' + encodeBase64Url(signature)
// JWT Token
// eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VySWQiOiJiMDhmODZhZi0zNWRhLTQ4ZjItOGZhYi1jZWYzOTA0NjYwYmQifQ.-xN_h82PHVTCMA9vdoHrcZxH-x5mb11y1537t3rGzcM
```
Вы можете попробовать создать свой собственный *JWT* на сайте [jwt.io](https://jwt.io/).
Вернемся к нашему примеру. Теперь сервер аутентификации может слать пользователю *JWT*.
### Как JWT защищает наши данные?
Очень важно понимать, что использование *JWT* **НЕ** скрывает и не маскирует данные автоматически. Причина, почему *JWT* используются — это проверка, что отправленные данные были действительно отправлены авторизованным источником. Как было продемонстрировано выше, данные внутри *JWT* закодированы и подписаны, обратите внимание, это не одно и тоже, что зашифрованы. Цель кодирования данных — преобразование структуры. Подписанные данные позволяют получателю данных проверить аутентификацию источника данных. Таким образом закодирование и подпись данных не защищает их. С другой стороны, главная цель шифрования — это защита данных от неавторизованного доступа. Для более детального объяснения различия между кодированием и шифрованием, а также о том, как работает хеширование, смотрите [эту статью](https://danielmiessler.com/study/encoding-encryption-hashing-obfuscation/#encoding). Поскольку *JWT* только лишь закодирована и подписана, и поскольку *JWT* не зашифрована, *JWT* не гарантирует никакой безопасности для чувствительных *(sensitive)* данных.
### Шаг 5. Проверка JWT
В нашем простом примере из 3 участников мы используем *JWT*, который подписан с помощью `HS256` алгоритма и только сервер аутентификации и сервер приложения знают секретный ключ. Сервер приложения получает секретный ключ от сервера аутентификации во время установки аутентификационных процессов. Поскольку приложение знает секретный ключ, когда пользователь делает API-запрос с приложенным к нему токеном, приложение может выполнить тот же алгоритм подписывания к *JWT*, что в шаге *3*. Приложение может потом проверить эту подпись, сравнивая ее со своей собственной, вычисленной хешированием. Если подписи совпадают, значит *JWT* валидный, т.е. пришел от проверенного источника. Если подписи не совпадают, значит что-то пошло не так — возможно, это является признаком потенциальной атаки. Таким образом, проверяя *JWT*, приложение добавляет доверительный слой *(a layer of trust)* между собой и пользователем.
В заключение
------------
Мы прошлись по тому, что такое *JWT*, как они создаются и как валидируются, каким образом они могут быть использованы для установления доверительных отношений между пользователем и приложением. Но это лишь кусочек пазла большой темы авторизации и обеспечения защиты вашего приложения. Мы рассмотрели лишь основы, но без них невозможно двигаться дальше.
Что дальше?
-----------
Подумаем о безопасности и добавим `Refresh Token`. Смотрите следующую мою [статью на эту тему](https://habr.com/ru/post/466929/).
Полезные ссылки
---------------
1. [5 Easy Steps to Understanding JSON Web Tokens (JWT)](https://medium.com/vandium-software/5-easy-steps-to-understanding-json-web-tokens-jwt-1164c0adfcec)
2. [Securing React Redux Apps With JWT Tokens](https://medium.com/@rajaraodv/securing-react-redux-apps-with-jwt-tokens-fcfe81356ea0)
3. [Зачем нужен Refresh Token, если есть Access Token?](https://habrahabr.ru/company/Voximplant/blog/323160/) | https://habr.com/ru/post/340146/ | null | ru | null |
# EDC-устройство для сисадмина: Linux в кармане
У каждого админа, пожалуй, был случай, когда что-то внезапно ломается, а ты где-нибудь в дороге: едешь на машине, садишься на поезд или, банально, сидишь где-то на скамейке в парке и срываться и куда-то нестись желания нет ни малейшего. А чинить надо. Или, как минимум, оценить масштабы пришедшего белого пушного зверька.
Понятно, что можно обойтись смартфоном или планшетом, особенно если нужно только зайти по ssh. Но пользоваться в таких случаях тачскрином, как по мне, — это боль и страдания.
Можно приобрести внешнюю клавиатуру, держатель или подставку для планшета, но я считаю, что проще уж тогда носить с собой полноценный ноутбук. Места займет примерно столько же.
Немножко воспоминаний и рассуждений
-----------------------------------
Кому лень читать, можно сразу перейти к [практической части.](#pract)
В свое время, когда андроидов и айфонов еще не существовало, для подобных вещей я использовал «интернет-планшет» Nokia N810. Аппарат габаритами с современный смартфон, имеющий при этом qwerty-клавиатуру да еще и с полноценным линуксом на борту. Ssh, vnc, rdesktop — да не вопрос! Плюс, активно пользовался CAS Maxima, когда нужно было что-то по-быстрому обсчитать и показать результат.
[](https://habrastorage.org/webt/-8/8g/ra/-88graoej88bm1lbg5cdb07fbzu.jpeg)
[](https://habrastorage.org/webt/4v/iv/0c/4viv0cfs4ptdx7pzn4cxlmarzoc.png)
Но время шло, стали появляться андроид-сматрфоны. Вот оно, думал я: практически полноценный же линукс, при этом, нет нужды носить с собой еще один девайс, чтобы раздавать Интернет. Стал присматривать аппарат с qwerty, который заменил бы мне старую-добрую n810, к тому времени уже изрядно подуставшую (шлейф экрана, два раза замененный аккумулятор, клавиатура, побитый корпус). Выбор пал на Motorola Milestone.
Вот оно, поделие, рядом с моим старым-добрым Palm V и N810:
[](https://habrastorage.org/webt/md/qt/br/mdqtbrtv50ahpudci4on5kzufrw.jpeg)
Надо сказать, что изделие доверия не оправдало. Клавиатура оказалась полным разочарованием. Даже не из-за раскладки, а из-за крайне низкого качества изготовления: после полугода использования, она начала отслаиваться и болтаться.
Шифрованный загрузчик добавлял своих гвоздей в гроб: невозможность использовать кастомное ядро со всеми вытекающими, debian chroot из-за особенностей питания жрал батарейку как не в себя, но все равно, худо-бедно изделие решало возложенные на него задачи.
Худо-бедно потому, что продолжало использоваться уже после истечения периода запланированного устаревания, определенного производителем, когда были выпущены несколько более свежих моделек ( отличающихся, разве-что чуть измененной раскладкой и большим количеством оперативки) и при этом дико глючило и тормозило.
Окей, как ssh-терминал сойдет и смартфон (сожрет, конечно, какое-то количество ваших нервных клеток). Но бывают случаи, что надо прицепиться к какой-нибудь железке консольным кабелем, или снять tcpdump'ом неизветсный IP устройства, дабы что-то с ним можно было сделать.
Просто феерично, когда из-за наличия COM-порта на док-станции, человек тащит с собой здоровенную 17" HP-шную дуру с доком и полуторакилограммовым блоком питания, а потом еще и висит со всем этим добром на стремянке перед стойкой.
В последнее время, я использовал 12" ThinkPad x220 с usb2com переходником. Но все чаще и чаще стал оставлять ноут дома, пока однажды (в очередной раз) не случилось "$username, все сломалось!", а при себе только смартфон на андроиде.
Вот она, рыба моей мечты (на самом деле, нет)
---------------------------------------------
И наткнулся я, однажды, на изделие под названием GPD Pocket. Полноценный ноутбук в форм-факторе пересмартфона или недопланшета. 7", qwerty-клавиатура, приличный запас автономности — ух, надо брать. Заказал, получил, распаковал.
Для сравнения с х220 и n810:
[](https://habrastorage.org/webt/cj/ai/z7/cjaiz7fsy1obufao2a9a74gbofy.jpeg)
Характеристики расписывать не буду, кому надо — найдет в Интернете, тем более, был тут недавно приторный обзор от гирбеста. Просто приведу выхлоп lshw и lspci:
lshw:
**Скрытый текст**
```
описание: Настольный компьютер
продукт: Default string (Default string)
производитель: Default string
версия: Default string
серийный №: Default string
разрядность: 64 bits
возможности: smbios-3.0 dmi-3.0 vsyscall32
конфигурация: boot=normal chassis=desktop family=Default string sku=Default string uuid=00020003-0004-0005-0006-000700080009
*-core
описание: Материнская плата
продукт: Default string
производитель: AMI Corporation
физический ID: 0
версия: Default string
серийный №: Default string
слот: Default string
*-firmware
описание: BIOS
производитель: American Megatrends Inc.
физический ID: 0
версия: 5.11
date: 08/07/2017
размер: 64KiB
capacity: 4032KiB
возможности: pci upgrade shadowing cdboot bootselect socketedrom edd int13floppy1200 int13floppy720 int13floppy2880 int5printscreen int14serial int17printer acpi usb biosbootspecification uefi
*-memory
описание: Системная память
физический ID: 28
слот: Системная плата или материнская плата
размер: 8GiB
*-bank:0
описание: DIMM DDR3 1066 MHz (0,9 ns)
продукт: 00000000
производитель: Hynix Semiconductor
физический ID: 0
серийный №: 00000000
слот: A1_DIMM0
размер: 4GiB
разрядность: 8 bits
частота: 1066MHz (0.9ns)
*-bank:1
описание: DIMM DDR3 1066 MHz (0,9 ns)
продукт: 00000000
производитель: Hynix Semiconductor
физический ID: 1
серийный №: 00000000
слот: A1_DIMM1
размер: 4GiB
разрядность: 8 bits
частота: 1066MHz (0.9ns)
*-cache:0
описание: L1 кэш
физический ID: 32
слот: CPU Internal L1
размер: 224KiB
capacity: 224KiB
возможности: internal write-back
конфигурация: level=1
*-cache:1
описание: L2 кэш
физический ID: 33
слот: CPU Internal L2
размер: 2MiB
capacity: 2MiB
возможности: internal write-back unified
конфигурация: level=2
*-cpu
описание: ЦПУ
продукт: Intel(R) Atom(TM) x7-Z8750 CPU @ 1.60GHz
производитель: Intel Corp.
физический ID: 34
сведения о шине: cpu@0
версия: Intel(R) Atom(TM) x7-Z8750 CPU @ 1.60GHz
слот: SOCKET 0
размер: 889MHz
capacity: 2560MHz
разрядность: 64 bits
частота: 80MHz
возможности: x86-64 fpu fpu_exception wp vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx rdtscp constant_tsc arch_perfmon pebs bts rep_good nopl xtopology tsc_reliable nonstop_tsc cpuid aperfmperf tsc_known_freq pni pclmulqdq dtes64 monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr pdcm sse4_1 sse4_2 movbe popcnt tsc_deadline_timer aes rdrand lahf_lm 3dnowprefetch epb pti tpr_shadow vnmi flexpriority ept vpid tsc_adjust smep erms dtherm ida arat cpufreq
конфигурация: cores=4 enabledcores=4 threads=4
*-pci
описание: Host bridge
продукт: Intel Corporation
производитель: Intel Corporation
физический ID: 100
сведения о шине: pci@0000:00:00.0
версия: 34
разрядность: 32 bits
частота: 33MHz
конфигурация: driver=iosf_mbi_pci
ресурсы: IRQ:0
*-display
описание: VGA compatible controller
продукт: Intel Corporation
производитель: Intel Corporation
физический ID: 2
сведения о шине: pci@0000:00:02.0
версия: 34
разрядность: 64 bits
частота: 33MHz
возможности: pm msi vga_controller bus_master cap_list rom
конфигурация: driver=i915 latency=0
ресурсы: IRQ:123 память:a0000000-a0ffffff память:80000000-9fffffff ioport:f000(размер=64) память:c0000-dffff
*-generic:0
описание: Signal processing controller
продукт: Intel Corporation
производитель: Intel Corporation
физический ID: b
сведения о шине: pci@0000:00:0b.0
версия: 34
разрядность: 64 bits
частота: 33MHz
возможности: msi pm cap_list
конфигурация: driver=proc_thermal latency=0
ресурсы: IRQ:129 память:a1a3b000-a1a3bfff
*-usb
описание: USB controller
продукт: Intel Corporation
производитель: Intel Corporation
физический ID: 14
сведения о шине: pci@0000:00:14.0
версия: 34
разрядность: 64 bits
частота: 33MHz
возможности: pm msi xhci bus_master cap_list
конфигурация: driver=xhci_hcd latency=0
ресурсы: IRQ:121 память:a1a00000-a1a0ffff
*-usbhost:0
продукт: xHCI Host Controller
производитель: Linux 4.15.0-rc7-stockmind-gpdpocket xhci-hcd
физический ID: 0
сведения о шине: usb@1
логическое имя: usb1
версия: 4.15
возможности: usb-2.00
конфигурация: driver=hub slots=7 speed=480Mbit/s
*-usb:0
описание: Клавиатура
продукт: Gaming Keyboard
производитель: SINO WEALTH
физический ID: 2
сведения о шине: usb@1:2
версия: 1.00
возможности: usb-1.10
конфигурация: driver=usbhid maxpower=100mA speed=1Mbit/s
*-usb:1
описание: Типовой USB-накопитель
продукт: BCM2045A0
производитель: Broadcom Corp
физический ID: 3
сведения о шине: usb@1:3
версия: 1.12
серийный №: B0F1ECED56A9
возможности: usb-2.00
конфигурация: driver=btusb maxpower=100mA speed=12Mbit/s
*-usbhost:1
продукт: xHCI Host Controller
производитель: Linux 4.15.0-rc7-stockmind-gpdpocket xhci-hcd
физический ID: 1
сведения о шине: usb@2
логическое имя: usb2
версия: 4.15
возможности: usb-3.00
конфигурация: driver=hub slots=6 speed=5000Mbit/s
*-generic:1
описание: Encryption controller
продукт: Intel Corporation
производитель: Intel Corporation
физический ID: 1a
сведения о шине: pci@0000:00:1a.0
версия: 34
разрядность: 32 bits
частота: 33MHz
возможности: pm msi bus_master cap_list
конфигурация: driver=mei_txe latency=0
ресурсы: IRQ:130 память:a1900000-a19fffff память:a1800000-a18fffff
*-pci
описание: PCI bridge
продукт: Intel Corporation
производитель: Intel Corporation
физический ID: 1c
сведения о шине: pci@0000:00:1c.0
версия: 34
разрядность: 32 bits
частота: 33MHz
возможности: pci pciexpress msi pm normal_decode bus_master cap_list
конфигурация: driver=pcieport
ресурсы: IRQ:117 память:a1000000-a14fffff
*-network
описание: Беспроводной интерфейс
продукт: BCM4356 802.11ac Wireless Network Adapter
производитель: Broadcom Corporation
физический ID: 0
сведения о шине: pci@0000:01:00.0
логическое имя: wlp1s0
версия: 02
серийный №: b0:f1:ec:ed:56:a8
разрядность: 64 bits
частота: 33MHz
возможности: pm msi pciexpress bus_master cap_list ethernet physical wireless
конфигурация: broadcast=yes driver=brcmfmac driverversion=7.35.180.119 firmware=01-1a5c4016 ip=192.168.1.142 latency=0 multicast=yes wireless=IEEE 802.11
ресурсы: IRQ:125 память:a1400000-a1407fff память:a1000000-a13fffff
*-isa
описание: ISA bridge
продукт: Intel Corporation
производитель: Intel Corporation
физический ID: 1f
сведения о шине: pci@0000:00:1f.0
версия: 34
разрядность: 32 bits
частота: 33MHz
возможности: isa bus_master cap_list
конфигурация: driver=lpc_ich latency=0
ресурсы: IRQ:0
```
lspci:
**Скрытый текст**
```
00:00.0 Host bridge: Intel Corporation Device 2280 (rev 34)
00:02.0 VGA compatible controller: Intel Corporation Device 22b0 (rev 34)
00:0b.0 Signal processing controller: Intel Corporation Device 22dc (rev 34)
00:14.0 USB controller: Intel Corporation Device 22b5 (rev 34)
00:1a.0 Encryption controller: Intel Corporation Device 2298 (rev 34)
00:1c.0 PCI bridge: Intel Corporation Device 22c8 (rev 34)
00:1f.0 ISA bridge: Intel Corporation Device 229c (rev 34)
01:00.0 Network controller: Broadcom Corporation BCM4356 802.11ac Wireless Network Adapter (rev 02)
```
Качество сборки хорошее, ничего не люфтит, не скрипит, не прогибается. Корпус алюминиевый и вообще, девайс производит впечатление эдакого монолитного блока. Это плюс.
Но минусов тоже хватает. Глянцевый экран. Нет, он не просто глянцевый — это буквально зеркало. То есть, свое отражение будете наблюдать в условиях любой, отличной от нуля, освещенности. В комплекте была защитная пленка, но она проблему не решила.
Второе — это клавиатура. То, что она есть — это замечательно.
[](https://habrastorage.org/webt/no/hu/xe/nohuxemjkis3fap8dpqkfmlaarq.jpeg)
А вот то, как реализована — это стыд и ужас. Попытка закоса под макбук, с этими здоровенными промежутками между кнопками — ну зачем? Ведь целевая аудитория, вроде бы, не гламурные кисы — те просто возьмут очередной айпед или макбук. Не будь этих несчастных промежутков, размер клавиш можно было сделать больше.
Кнопочка Fn имеет весьма скудный слой: это 2 кнопки регулировки яркости, F1-F12 и Insert. Зачем нужен верхний ряд? Его можно было реализовать отдельным слоем.
Особенную боль и страдание у пользователей Vim вызывает двоеточие, вынесенное в нижний ряд, рядом с ctrl.
Ладно, все плохо, будем лечить, благо есть кое-какие способы (об этом ниже).
Ах да, здесь есть трекпоинт. Что мне, как пользователю ThinkPad'ов со стажем, греет душу. Только вот одно но: трекпоинт расположен совершенно не в том месте и для того, чтобы им воспользоваться, придется выгибать большой палец. Это, к сожалению, неизлечимо. Но за пару дополнительных колпачков красного цвета в комплекте, конечно, спасибо.
Трекпоинт здорового человека:
Трекпоинт курильщика:
Установка и настройка Linux на GPD Pocket
-----------------------------------------
Понятно, что «окна», а «окна10» особенно, мне на данном устройстве не то, что ни к чему, а просто противопоказаны.
Из-за особенностей девайса, таких как ориентация экрана (он повернут набок), просто взять и установить любимый Debian без плясок с бубном не получится.
[](https://habrastorage.org/webt/xi/ii/lt/xiiilte6cy_w9warlsrkazbnl3y.jpeg)
В принципе, на официальном сайте есть официальный же образ Ubuntu LTS 16.04 (что мне кажется неплохой альтернативой стабильному Debian'у), но ознакомившись с обсуждениями в Интернете, было решено использовать проект [GPD Pocket Ubuntu Respin](https://github.com/stockmind/gpd-pocket-ubuntu-respin)
Подчеркну, в общем-то, очевидную вещь, что для использования годится только образ, построенный на Ubuntu и скормить скрипту, например, Debian, не выйдет:
```
$./build.sh debian-9.3.0-amd64-netinst.iso
Display setting: Xorg-Standard
Looking for kernel image...
Extracting kernel files...
Archive: gpdpocket-20180115-kernel-files.zip
inflating: linux-headers-4.15.0-rc7-stockmind-gpdpocket_4.15.0-rc7-stockmind-gpdpocket-1_amd64.deb
inflating: linux-image-4.15.0-rc7-stockmind-gpdpocket_4.15.0-rc7-stockmind-gpdpocket-1_amd64.deb
inflating: linux-libc-dev_4.15.0-rc7-stockmind-gpdpocket-1_amd64.deb
./isorespin.sh: 'debian-9.3.0-amd64-netinst.iso' must be an Ubuntu (or Ubuntu flavour), Linux Mint, neon, elementary, BackBox or Peppermint desktop ISO.
```
На выходе получаем файл linuxium-xubuntu-16.04-desktop-amd64.iso, который и записываем на флешку:
```
#dd if=linuxium-xubuntu-16.04-desktop-amd64.iso of=/dev/sdX
```
Грузимся с нее, выставив загрузочным устройством, зайдя в настройки UEFI кнопкой Delete при загрузке.
Процедура установки тривиальна, детально распысывать смысла не вижу. Отмечу только, что лучше ее производить из Live-режима, так экран не будет повернут набок.
Использую полнодисковое шифрование, на случай, если устройство вдруг будет потеряно или украдено. Так, по крайней мере, все ваши ssh-ключи (да-да, я знаю про защиту их паролем и ssh-agent) и логины на Интернет-ресурсах останутся в целости. Потому, ставлю на LVM поверх LUKS, чего и вам желаю.
Исправляем кривулины
--------------------
### Сон и гибернация
Неплохо бы иметь возможность бросить ноут в сумку и забыть про него до того момента, пока не понадобится. Благо, размеры и масса позволяют. Неплохо бы еще не запускать, каждый раз, нужные приложения вручную, а просто продолжить работу с того места, где остановились.
Режим сна, вроде как, работает «из-коробки». Реализован он штатными средствами, то бишь через systemctl suspend. Однако, опытным путем, было установлено, что энергопотребление в таком режиме не сильно уступает потреблению в простое. Судя по всему, аппарат просто гасит экран, сетевые интерфейсы и отключает кулер. В итоге, высадит аккумулятор в ноль суток за двое.
Нужна гибернация. Штатная systemctl hibernate оказалась неработоспособной: состояние дампится в своп, но восстановиться при загрузке не может.
Вспомнил, что есть такой проект — [Userspace Software Suspend](http://suspend.sourceforge.net/) и в репозитарии есть его пакеты.
```
#apt install hibernate
```
Проверяем:
```
#hibernate-disk
```
Вуаля, работает! Система сдампилась и отключилась. После ввода пароля LUKS, восстановилась. Но накрылись звук и wifi, яркость подсветки экрана сбросилась на максимум. Будем допиливать.
### Доустанавливаем нужное
Прежде чем перейти к настройке ACPI, потребуется поставить несколько утилит.
Так за регулировку яркости экрана отвечает xbacklight.
```
#apt install xbacklight
```
В ноуте не жесткий диск, а флэш-накопитель, потому убивать его свопом мне не хочется. Есть такая штука [ZRam](https://ru.wikipedia.org/wiki/ZRam), вот ее и будем использовать. Сейчас с этим все просто, прописывать простыни в rc.local не требуется, и нужно, всего-навсего, сделать следующее:
```
#apt install zram-config
#sudo systemctl enable zram-config.service
```
Скрипт сам подсчитает нужное количество памяти и сделает swapon.
Как верно напомнили в комментариях, ресурс флеша подъедает не только своп, но и запись логов. Поэтому, /tmp и /var/log вынесем в ram на tmpfs. Для этого допишем в /etc/fstab две строчки:
```
tmpfs /tmp tmpfs nodev,nosuid,size=256M 0 0
tmpfs /var/log tmpfs nodev,nosuid,size=512M 0 0
```
### Допиливаем acpi
В первую очередь, отключаем systemg'шные обработчики. Так как делает оно все своими средствами, а они неработоспособны. Девиз — делаем все, но делаем плохо. Например, обрабатывать подключение адаптера питания или наушников, нажатия клавиш и тому подобного оно так и не научилось.
**Он съел acpid и все еще голоден! (4Mb)**
/etc/systemd/logind.conf
```
HandlePowerKey=ignore
HandleLidSwitch=ignore
```
```
#systemctl restart systemd-logind.service
```
За обработку acpi-событий отвечает демон acpid, конфиг-файлы которого хранятся, внезапно, в /etc/acpi.
Отправлять ноут в гибернацию будем по нажатию кнопки включения. Для этого отредактируем следующие файлы (если их нет, надо создать):
/etc/acpi/events/powerbtn
```
event=button[ /]power
action=/etc/acpi/hibernate.sh
```
/etc/acpi/hibernate.sh (с комментариями)
**Скрытый текст**
```
#!/bin/bash
#отключаю свой скрипт блокировки экрана, так как при загрузке будет запрошен пароль LUKS
mv /home/user/bin/lock /home/user/bin/nolock
#убиваем пшшш-аудио
killall -9 pulseaudio
#отключае zram и активируем swap
systemctl stop zram-config.service
swapon /dev/xubuntu-vg/swap_1
#сохраняем состояние подсветки экрана
DISPLAY=:0.0 su user -c "xbacklight >/tmp/xbl"
#отмонтируем сетевые файловые системы
umount -alt nfs4
umount -alt cifs
#усыпляем wpa_supplicant
/sbin/wpa_cli suspend
hibernate-disk
sleep 2
#восстанавливаем статус подсветки
DISPLAY=:0.0 su user -c "xbacklight -set `cat /tmp/xbl`"
#восстанавливаем wpa_supplicant
/sbin/wpa_cli resume
#перезагружаем модули alsa, иначе звука не будет. пшш-аудио при вызове восстановится самостоятельно
/sbin/alsa force-reload
#звуковая система ноута оставляет желать лучшего. было замечено, что при больших значениях канала DAC1, из динамиков и наушников идет дикий перегруз до хрипоты и дребезжания
amixer -c 1 set 'DAC1' 90%
#убиваем блокировщик экрана на случай, если гибернация была запущена при залоченном экране
killall i3lock
#восстанавливаем возможность запуска блокировщика
mv /home/user/bin/nolock /home/user/bin/lock
#восстанавливаем zram
systemctl start zram-config.service
#отключаем своп на карту
swapoff /dev/xubuntu-vg/swap_1
```
Автоматическую гибернацию при низком заряде реализовать не просто, а очень просто:
```
#apt install acpi
```
/etc/acpi/ifbatlowgotosleep.sh
```
#!/bin/bash
level=`/usr/bin/acpi -b|sed '/unava/d'|awk -F\ '{ print $4 }'|sed -e 's/,//' -e's/%//'`
if [ "$level" -lt "10" ]
then
/etc/acpi/hibernate.sh
fi
```
Скрипт проверяет состояние заряда. Если меньше 10%, то выполняет приведенный выше скрипт гибернации.
Периодичное выполнение задается через crontab:
```
$sudo crontab -e
*/3 * * * * /etc/acpi/ifbatlowgotosleep.sh 2>/dev/null
```
В моем случае, опрос батарейки выполняется каждые 3 минуты.
Режим сна (systemctl suspend), как упоминалось выше, довольно бесполезен. Потому, не вижу смысла активировать его при закрытии крышки. Тем более, может возникнуть желание, скажем, послушать музыку с закрытого ноута, находящегося в кармане (не зря же он «pocket»).
Поэтому, просто гасим экран при закрытии и включаем при открытии.
Удаляем /etc/acpi/lidbtn.
Создаем и редактируем:
/etc/acpi/events/lidclose:
```
event=button/lid LID close
action=/etc/acpi/lidclose.sh
```
/etc/acpi/events/lidopen:
```
event=button/lid LID open
action=/etc/acpi/lidopen.sh
```
/etc/acpi/lidopen.sh
```
DISPLAY=:0.0 su user -c "xrandr --output DSI1 --off"
```
/etc/acpi/lidclose.sh
```
DISPLAY=:0.0 su user -c "xrandr --output DSI1 --auto --rotate right --dpi 200"
```
Значение DPI выставьте по вкусу, а user — это незамысловатое имя моей учетной записи (поменяйте на свою).
### Настраваем клавиши управления звуком и яркостью
Делаем это через все те же acpi-события.
/etc/acpi/events/voldown
```
event=button[ /]volumedown
action=/etc/acpi/volume-down.sh
```
/etc/acpi/events/volup
```
event=button[ /]volumeup
action=/etc/acpi/volume-up.sh
```
/etc/acpi/events/mute
```
event=button[ /]mute
action=/etc/acpi/volume-toggle.sh
```
Скрипты:
/etc/acpi/volume-toggle.sh
```
amixer -c 1 set 'Speaker Channel' toggle
amixer -c 1 set 'Headphone Channel' toggle
```
/etc/acpi/volume-up.sh
```
amixer -c 1 set 'Headphone' 5%+
amixer -c 1 set 'Speaker' 5%+
```
/etc/acpi/volume-down.sh
```
amixer -c 1 set 'Headphone' 5%-
amixer -c 1 set 'Speaker' 5%-
```
Аналогично и для яркости:
/etc/acpi/events/bdown
```
event=button[ /]brightnessdown
action=/etc/acpi/bdown.sh
```
/etc/acpi/events/bup
```
event=button[ /]brightnessup
action=/etc/acpi/bup.sh
```
/etc/acpi/bup.sh
```
DISPLAY=:0.0 su user -c "xbacklight -inc 5%"
```
/etc/acpi/bdown.sh
```
DISPLAY=:0.0 su user -c "xbacklight -dec 5%"
```
Напомню, user — имя моей учетки. Впишите свою.
### Наушники
Говн^WСвоеобразный чип Realtek ALC5645 не умеет самостоятельно отключать динамики при подключении наушников. Придется научить систему делать это самостоятельно.
В respin есть такой вот скрипт:
**Скрытый текст**
```
#!/bin/bash
set -e -u
if [ "$1" = "jack/headphone" -a "$2" = "HEADPHONE" ]; then
case "$3" in
plug)
sink="[Out] Headphones"
;;
*)
sink="[Out] Speaker"
;;
esac
for userdir in /run/user/*; do
uid="$(basename $userdir)"
user="$(id -un $uid)"
if [ -f "$userdir/pulse/pid" ]; then
su "$user" -c "pacmd set-sink-port alsa_output.platform-cht-bsw-rt5645.HiFi__hw_chtrt5645__sink $sink"
fi
done
fi
```
Но он не работает. Пытается делать переключение через управление синками пшшш-аудио, но у него не получается. Потому, что:
```
$sudo su
#su user -c "pacmd set-sink-port alsa_output.platform-cht-bsw-rt5645.HiFi__hw_chtrt5645__sink '[Out] Speaker'"
Нет запущенного демона PulseAudio, либо он не запущен в качестве сеансового демона.
```
Разгадка проста: когда процесс пшшш-аудио еще не вызван клиентом, связываться pacmd не с чем. Можно, конечно, добавить строчку запуска этого самого в rc.local, xinitrc или вовсе написать отдельный systemg юнит, но я посчитал, что лучше выстругать собственный костыль, чем ремонтировать чужие. И написал свой скрипт, гораздо менее монстроузный и замудренный, я считаю.
/etc/acpi/headphone-jack.sh
```
#!/bin/bash
set -e -u
if [ "$3" = "plug" ]; then
amixer -c 1 set 'Speaker Channel' mute >/dev/null
amixer -c 1 set 'Headphone Channel' unmute >/dev/null
else
amixer -c 1 set 'Speaker Channel' unmute >/dev/null
amixer -c 1 set 'Headphone Channel' mute >/dev/null
fi
```
### Лечим раскладку и прочие мелочи
Как уже упоминал, раскладка меня бесит. Кнопка delete там, где должен быть backslash и bar, двоеточие в нижнем ряду, непонятно для чего вынесенная клавиша menu, tab там, где в нормальных клавиатурах находится escape…
Детально, с разбором, расписывать не буду, просто приведу свой ~/.xmodmaprc и опишу как это все делается.
Для начала, нам нужно отловить кейкод. Делается это с помощью программы xev (#apt install xev, да). Запускаем, нажимаем нужную клавишу и получаем вывод вроде:
```
KeyPress event, serial 33, synthetic NO, window 0x3200001,
root 0x2c0, subw 0x0, time 187713326, (979,493), root:(982,1078),
state 0x0, keycode 119 (keysym 0xffff, Delete), same_screen YES,
XLookupString gives 1 bytes: (7f) ""
XmbLookupString gives 1 bytes: (7f) ""
XFilterEvent returns: False
```
Нам нужно значение «keycode 119».
Далее, открываем ~/.xmodmaprc и прописываем туда
```
keycode 119 = backslash bar backslash bar
```
И вносим выполнение «xmodmap ~/.xmodmaprc» в свой xinitrc или что там у вас вызывается при старте вашего любимого DE или WM.
Мой ~/.xmodmaprc:
**Скрытый текст**
```
pointer = 1 2 3 4 5
remove Lock = Caps_Lock
remove Control = Control_L
keycode 0x42 = Control_L
keycode 135 = Alt_R
keycode 0x25 = Super_R
keycode 133 = Super_R
add Control = Control_L
keycode 113 = Left
keycode 111 = Up
keycode 114 = Right
keycode 116 = Down
keycode 110 = Home
keycode 115 = End
keycode 108 = ISO_Next_Group
keycode 136 = ISO_First_Group
keycode 49 = asciitilde grave asciitilde grave
keycode 119 = backslash bar backslash bar
keycode 51 = Delete
keycode 48 = colon semicolon Cyrillic_zhe Cyrillic_ZHE
keycode 47 = apostrophe quotedbl Cyrillic_e Cyrillic_E
keycode 130 = XF86Explorer
keycode 121 = XF86AudioMute
keycode 198 = XF86AudioMicMute
keycode 122 = XF86AudioLowerVolume
keycode 123 = XF86AudioRaiseVolume
keycode 37 = Tab
clear mod5
add mod5 = XF86Explorer
keycode 166 = Prior
keycode 167 = Next
```
Там используются такие сомнительные, для большинства пользователей, вещи, как перенос ctrl на caps-lock, tab на ctrl\_l, alt\_gr на menu и переключение раскладки по старому положению altgr.
Еще я использую xcape для эмуляции нажатия escape при однократном нажатии на ctrl\_l. Вызывается так:
```
xcape -t 1000 -e "Control_L=Escape"
```
Так как предпочитаю темные темы оформления, которые более комфортны (имею мнение, хрен оспоришь) в условиях слабой освещенности, но зачастую приходится работать при ярком дневном свете, есть небольшой финт: цвета изображения можно инвертировать. Для этого понадобирся программа xcalib:
```
#apt install xcalib
```
Инвертируем:
```
$xcalib -i -a
```
Можно забиндить на любой удобный хоткей средствами оконного менеджера. У меня висит на Super\_L+Backspace.
Итог
----
Впечатления от девайса больше положительные, чем отрицательные. О потраченных деньгах не жалею. Аппарат не занимает много места в сумке, помещается в карман карго-штанов и смок-подобной куртки.
[](https://habrastorage.org/webt/zj/3w/je/zj3wjeu1c1_mn702hcmwpfesn4e.jpeg)
От батарейки работает долго, для пробы прокрутил три полуторачасовых фильма при включеном wifi, разрядил где-то наполовину. Заряжается от павербанка с usb-a через переходник a-c.
Все повстречавшиеся софтовые кривулины успешно подлечены.
Очень жаль, что нет порта rj45, но надеюсь, решится заказанным переходником с usb. Отсутствие мобильной связи и камеры, нынче, в условиях тотальной слежки, считаю скорее плюсом. | https://habr.com/ru/post/409945/ | null | ru | null |
# Какова оптимальная длина пароля?
Конечно, чем больше, тем лучше. И с помощью менеджера паролей можно очень легко генерировать и автоматически заполнять пароли любой длины. Но нужно ли делать пароли длиной в сотни символов, или есть какой-то эмпирический разумный минимум?
Вот интерфейс типичного [генератора паролей](https://1password.com/password-generator/):
*Обратите внимание на ползунок Length: здесь он может менять длину пароля от 8 до 100 символов, а в других инструментах — гораздо больше. Какое же значение оптимально для паролей?*
### Хороший пароль — это всё, что у вас есть, когда вас взламывают
Чтобы понять, что такое хороший пароль, посмотрим, что происходит в стане врага!
Когда вы создаёте аккаунт, сервис сохраняет пароль в одном из многочисленных форматов. Сервис может положить пароль прямо в базу данных (в виде простого текста) или **сгенерировать из него хэш с помощью одного из многочисленных алгоритмов**. Самые популярные:
* MD5
* SHA-1
* Bcrypt
* Scrypt
* Argon2
Преимущество **хранения хэшей вместо самих паролей заключается в том, что паролей в БД нет**. И это правильно, потому что вам нужно только доказать, что вы знаете свой пароль, но сам он не имеет значения. Когда вы логинитесь, введённый пароль хэшируется с помощью того же алгоритма, и если результат совпадает с записанным в базе значением, то вы доказали, что знаете пароль. А если базу взломают, то восстановить пароли не удастся.
*Хранение хэшей.*
### Взлом пароля
*Взлом пароля* — это когда злоумышленник пытается обратить вспять хэш-функцию и восстановить пароль из хэша. В случае с хорошим алгоритмом хэширования сделать это невозможно. Но ничто не мешает злоумышленнику пробовать вводить разные значения в надежде получить такой же хэш. Если совпадение произойдёт, значит, пароль восстановлен из хэша.
*Взлом пароля.*
И **здесь важен выбор хорошего алгоритма**. SHA-1 разрабатывался с учётом быстрого хэширования, это облегчает жизнь взломщикам. Bcrypt, Scrypt и Argon2 разрабатывались с учётом высоких вычислительных затрат, чтобы как можно больше замедлить взлом, особенно на специально выделенных машинах. И это очень важный аспект.
Если ориентироваться только на скорость, то пароль SHA-1, который невозможно взломать, выглядит так: `0OVTrv62y2dLJahXjd4FVg81`.
А безопасный пароль, созданный с помощью правильно сконфигурированного Argon2, выглядит так: `Pa$$w0Rd1992`.
Как видите, выбор правильного алгоритма хэширования превращает слабый пароль в не поддающийся взлому.
И не забывайте, что **это зависит только от реализации сервиса, в котором вы регистрируетесь**. И **вы не можете узнать** качество реализации. Спросить можно, но вам либо не ответят, либо отпишутся, что «мы серьёзно подходим к безопасности».
Думаете, в компаниях серьёзно относятся к безопасности и используют хорошие алгоритмы хэширования? Посмотрите на [список](https://haveibeenpwned.com/PwnedWebsites) взломанных баз данных, особенно на использованные в них хэши. **Во многих случаях применялся MD5, чаще всего — SHA-1, и кое-где использовали bcrypt. Некоторые хранили пароли в виде простого текста**. Такова реальность, которую нужно учитывать.
Причём мы знаем лишь, какие хэши использовались во взломанных базах, и высока вероятность, что компании, применявшие слабые алгоритмы, не смогли защитить и свою инфраструктуру. Взгляните на список, уверен, вы найдёте знакомые названия. То, что компания выглядит большой и респектабельной, ещё не означает, что всё делает правильно.
### Пароль выбираете вы
**Что вы можете сделать как пользователь?** Если пароли хранятся в виде простого текста, тогда ничего не поделаешь. Когда базу украдут, сложность вашего пароля не будет иметь значения.
При правильно сконфигурированных алгоритмах сложность вашего пароля тоже не важна, он может быть `12345` или `asdf`.
Однако **в промежуточных случаях**, особенно при использовании SHA-1, **сложность пароля имеет значение**. Функции хэширования в целом не предназначены для паролей, но если вы используете **сложный пароль, то это компенсирует недостатки алгоритмов.**
*Зависит от конфигурации. У этих алгоритмов есть различные компоненты, влияющие на защищённость, и при правильной конфигурации они способны предотвратить взлом.*
Вывод: с сильным паролем вы защищены от большего количества взломов, чем со слабым паролем. А поскольку вы не знаете, насколько защищено хранилище паролей, вы не можете знать, насколько будет «достаточно безопасно» для этого сервиса. Так что предполагайте худшее, когда ваш выбор пароля ещё имеет значение.
### Уникальности пароля недостаточно
Ладно, но с какой стати вам думать о том, чтобы использовать менеджер паролей и генерировать уникальный пароль для каждого сайта? В этом случае вы неуязвимы для [credential stuffing](https://owasp.org/www-community/attacks/Credential_stuffing) — когда известная пара почтового ящика и пароля проверяется на разных сервисах в надежде, что человек использовал эти данные в разных местах. Это серьёзная угроза, потому что повторное использование паролей одна из главных проблем безопасности. От этого вас защитит генерирование уникального пароля для каждого сайта.
*Credential stuffing.*
А если базу украдут и всё её содержимое станет известно хакерам, то зачем вам *всё ещё* защищать свой пароль?
Дело в том, что вы не знаете, взломана ли база, и продолжаете пользоваться сервисом. Тогда хакеры получат доступ ко всей вашей будущей активности на этом сайте. Позднее вы можете добавить данные банковской карты, и они об этом узнают. А **сильный пароль означает, что хакеры не смогут войти под вашим аккаунтом** и не смогут скомпрометировать ваши будущие действия.
*Использование сервиса после взлома.*
### Как оценить силу пароля с помощью энтропии
Сила пароля характеризуется энтропией — числовым представлением количества случайности, которая содержится в пароле. Поскольку речь идёт о больших числах, то вместо `1 099 511 627 776 (2^40)` нам проще сказать «40 бит энтропии». И поскольку взлом пароля — это перебор вариантов, то чем их больше, тем больше времени нужно затратить на взлом.
Для случайных символов, сгенерированных менеджером паролей, энтропия считается по формуле: `log2(<количество разных символов> ^ <длина>)`.
С длиной понятно, а что такое количество разных символов? Оно зависит от классов символов, входящих в пароль.
Например, пароль из 10 случайных строчных и прописных букв имеет `log2(52 ^ 10) = 57` бит энтропии.
Чтобы вычислить удельную энтропию (её количество в одном символе заданного класса), можно использовать уравнение `log2(n ^ m) = m * log2(n)`. Получаем: `<длина> * log2(<количество разных символов>)`, где вторая часть является удельной энтропией. Пересчитаем по этой формуле предыдущую таблицу:
Для вычисления силы пароля нужно взять классы символов, которые входят в пароль, взять значения энтропии для этих классов и умножить на длину. Для приведённого выше примера пароля из 10 строчных и прописных букв мы получили `5.7 * 10 = 57 бит`. Но если увеличить длину до 14, то энтропия скакнёт до 79,8 бит. А если оставить 10 символов, но добавить класс специальных символов, то общая энтропия будет равна 64 бит.
Приведённое уравнение позволяет быстро вычислить энтропию пароля, но тут есть подвох. **Формула верна лишь в том случае, если символы не зависят друг от друга**. А это относится только к сгенерированным паролям. Сочетание `H8QavhV2gu` удовлетворяет этому критерию и имеет 57 бит энтропии.
Но если использовать более лёгкие для запоминания пароли вроде `Pa$$word11`, то энтропия у них будет гораздо ниже при том же количестве символов. Взломщику не придётся перебирать все возможные комбинации, достаточно лишь перебрать слова из словаря с некоторыми изменениями.
Таким образом, **все вычисления с умножением длины на удельную энтропию верны только для сгенерированных паролей**.
### Руководство по энтропии
Чем больше в пароле энтропии, тем сложнее его взломать. Но сколько энтропии будет достаточно? В целом, около 16 символов будет за глаза, у такого пароля 95—102 бита энтропии, в зависимости от классов символов. А какой минимальный порог? 80 бит? 60? Или даже 102 бита слишком мало?
Есть алгоритм, который по скорости соперничает с плохим алгоритмом хэширования, но зато изучен гораздо лучше: это AES.
Он используется во всех правительственных и военных организациях, а значит его стойкости вполне достаточно. И работает быстро. Так что если AES-ключ с определённым количеством энтропии нельзя взломать, то это пойдёт на пользу паролю с плохим (но не взломанным) хэшем.
Национальный институт стандартов и технологий определил размеры ключей, которые будут достаточны в обозримом будущем. Там [рекомендуют](https://www.keylength.com/en/4/) использовать **AES-128** в период «2019—2030 и позже». Как понятно из названия, речь идёт о 128 битах энтропии.
В другой [рекомендации](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar2.pdf) советуют делать ключи размером не меньше 112 бит:
> Для обеспечения криптографической стойкости для нужд Федерального правительства сегодня требуется не меньше 112 бит (например, для шифрования или подписи данных).
Чтобы получить 128 бит энтропии с использованием прописных и строчных букв, а также чисел, нужен пароль длиной `22 символа ((5.95 * 22 = 131 бит)`.
### Другие соображения
**Почему бы не использовать специальные символы?** Я стараюсь их не применять, потому что они ломают границы слова. То есть для выбора спецсимвола нужно три клика вместо двух, и это может привести к ошибке, если я случайно не вставлю в поле оставшуюся часть пароля.
А если использовать только буквы и цифры, то при двойном клике выделится весь пароль.
**Что делать, если есть ограничение по длине?** На некоторых сайтах длина пароля не может достигать 22 символов. Иногда пароли могут быть только очень короткими, например, не больше 5 цифр. Тогда остаётся только использовать пароль максимально возможной длины.
Также есть рекомендации для сайтов по работе с паролями, и ограничение длины явно противоречит этим рекомендациям. Вот что [говорит](https://pages.nist.gov/800-63-3/sp800-63b.html) Национальный институт стандартов и технологий:
> Нужно поддерживать пароли длиной хотя бы до 64 символов. Поощряйте пользователей делать удобные для запоминания секреты любой длины, с использованием любых символов (в том числе пробелов), что будет способствовать запоминанию.
И помните, что степень защиты паролей на сайтах варьируется от ужасной до превосходной, и они не скажут вам, каково реальное положение вещей. Если максимально допустимая длина пароля невелика, то [создаётся впечатление](https://www.troyhunt.com/banks-arbitrary-password-restrictions-and-why-they-dont-matter/), что такой сайт находится на плохой части шкалы.
### Заключение
Пароли должны быть сильными, даже если вы не используете одни и те же сочетания в разных местах. Сила пароля измеряется энтропией, и нужно стремиться к значению в 128 бит. Для этого достаточно паролей длиной 22 символа, состоящих из прописных и строчных букв, а также цифр.
Это защитит вас в том случае, если сервис взломают и применялся слабый, но не взломанный алгоритм хэширования. | https://habr.com/ru/post/515064/ | null | ru | null |
# Обзор примера применения обучения с подкреплением с использованием TensorFlow
Всем привет!
Я думаю, что многие слышали о [Google DeepMind](http://deepmind.com/). О том как они обучают программы играть в игры Atari лучше человека. Сегодня я хочу представить вам статью о том, как сделать нечто подобное. Данная статья — это обзор идеи и кода [примера](https://github.com/nivwusquorum/tensorflow-deepq) применения [Q-learning](https://ru.wikipedia.org/wiki/Q-%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5), являющегося частным случаем обучения с подкреплением. Пример основан на [статье сотрудников Google DeepMind](https://www.cs.toronto.edu/~vmnih/docs/dqn.pdf).
#### Игра
В примере рассматривается игра Karpathy game. Она изображена на КПДВ. Суть ее заключается в следующем: необходимо управлять желтым шариком таким образом, чтобы «есть» зеленые шарики и не есть красные и оранжевые. За оранжевые дается больший штраф, чем за красные. У желтого шарика имеются радиально расходящиеся отрезки ответственные за зрение (в программе они называются eye). С помощью такого отрезка программа чувствует тип ближайшего объекта в направлении отрезка, его скорость и удаление. Типом объекта может быть цвет шарика или стена. Набор входных данных получается следующим: данные с каждого глаза и собственная скорость. Выходные данные — это команды управления желтым шариком. По сути — это ускорения по четырем направлениям: вверх, влево, вниз, вправо.
#### Идея
В эту игру играет [многослойный перцептрон](https://ru.wikipedia.org/wiki/%D0%9C%D0%BD%D0%BE%D0%B3%D0%BE%D1%81%D0%BB%D0%BE%D0%B9%D0%BD%D1%8B%D0%B9_%D0%BF%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD_%D0%A0%D1%83%D0%BC%D0%B5%D0%BB%D1%8C%D1%85%D0%B0%D1%80%D1%82%D0%B0). На входе у него описанные выше входные данные. На выходе полезность каждого из возможных действий. Перцептрон обучается методом обратного распространения ошибки. А конкретно используется метод RMSProp. Особенность его в том, что он использует для оптимизации сразу пачку примеров, но это не единственная его особенность. Чтобы узнать больше о методе можете посмотреть [эти слайды](http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf). Они рассказывают не только о RMSProp. Ничего лучше я пока не нашел. Ошибка выхода нейронной сети вычисляется с помощью того самого [Q-learning](https://ru.wikipedia.org/wiki/Q-%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5).
#### TensorFlow
Почти все это можно более менее легко закодить не углубляясь в написание собственных реализаций алгоритмов, благодаря недавно увидевшей свет [библиотеке TensorFlow](https://www.tensorflow.org/). Программирование с использованием этой библиотеки сводится к описанию графа вычислений, требуемых для получения результата. Затем этот граф отправляется в сессию TensorFlow, где и производятся сами вычисления. RMSProp взят целиком из TensorFlow. Нейронная сеть реализована на матрицах оттуда же. Q-learning реализован также на обычных операциях TensorFlow.
#### Код
Теперь давайте посмотрим в наиболее интересные места кода примера.
**models.py - многослойный перцептрон**
```
import math
import tensorflow as tf
from .utils import base_name
# Для начала посмотрите ниже класс MLP
# Один слой перцептрона
class Layer(object):
# input_sizes - массив количеств входов, почему массив см конструктор MLP ниже
# output_size - количество выходов
# scope - строчка, переменные в TensorFlow можно организовывать в скоупы
# для удобного переиспользования (см https://www.tensorflow.org/versions/master/how_tos/variable_scope/index.html)
def __init__(self, input_sizes, output_size, scope):
"""Cretes a neural network layer."""
if type(input_sizes) != list:
input_sizes = [input_sizes]
self.input_sizes = input_sizes
self.output_size = output_size
self.scope = scope or "Layer"
# входим в скоуп
with tf.variable_scope(self.scope):
# массив нейронов
self.Ws = []
for input_idx, input_size in enumerate(input_sizes):
# идентификатор нейрона
W_name = "W_%d" % (input_idx,)
# инициализатор весов нейрона - равномерное распределение
W_initializer = tf.random_uniform_initializer(
-1.0 / math.sqrt(input_size), 1.0 / math.sqrt(input_size))
# создание нейрона - как матрицы input_size x output_size
W_var = tf.get_variable(W_name, (input_size, output_size), initializer=W_initializer)
self.Ws.append(W_var)
# создание вектора свободных членов слоя
# этот вектор будет прибавлен к выходам нейронов слоя
self.b = tf.get_variable("b", (output_size,), initializer=tf.constant_initializer(0))
# использование слоя нейронов
# xs - вектор входных значений
# возвращает вектор выходных значений
def __call__(self, xs):
if type(xs) != list:
xs = [xs]
assert len(xs) == len(self.Ws), \
"Expected %d input vectors, got %d" % (len(self.Ws), len(xs))
with tf.variable_scope(self.scope):
# рассчет выходных значений
# так как каждый нейрон - матрица
# то вектор выходных значений - это сумма
# умножений матриц-нейронов на входной вектор + вектор свободных членов
return sum([tf.matmul(x, W) for x, W in zip(xs, self.Ws)]) + self.b
# возвращает список параметров слоя
# это нужно для работы алгоритма обратного распространения ошибки
def variables(self):
return [self.b] + self.Ws
def copy(self, scope=None):
scope = scope or self.scope + "_copy"
with tf.variable_scope(scope) as sc:
for v in self.variables():
tf.get_variable(base_name(v), v.get_shape(),
initializer=lambda x,dtype=tf.float32: v.initialized_value())
sc.reuse_variables()
return Layer(self.input_sizes, self.output_size, scope=sc)
# Многослойный перцептрон
class MLP(object):
# input_sizes - массив размеров входных слоев, не знаю зачем,
# но здесь реализована поддержка нескольких входных слоев,
# выглядит это как один входной слой разделенный на части,
# по факту эта возможность не используется, то есть входной слой один
# hiddens - массив размеров скрытых слоев, по факту
# используется 2 скрытых слоя по 100 нейронов
# и выходной слой - 4 нейрона, что интересно, не делать ничего
# нейросеть не может, такого варианта у нее нет
# nonlinearities - массив передаточных функций нейронов слоев, про передаточные функции см [Искусственный нейрон](https://ru.wikipedia.org/wiki/%D0%98%D1%81%D0%BA%D1%83%D1%81%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9_%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD)
# scope - строчка, переменные в TensorFlow можно организовывать в скоупы
# для удобного переиспользования
# given_layers - можно передать уже созданные слои
def __init__(self, input_sizes, hiddens, nonlinearities, scope=None, given_layers=None):
self.input_sizes = input_sizes
self.hiddens = hiddens
self.input_nonlinearity, self.layer_nonlinearities = nonlinearities[0], nonlinearities[1:]
self.scope = scope or "MLP"
assert len(hiddens) == len(nonlinearities), \
"Number of hiddens must be equal to number of nonlinearities"
with tf.variable_scope(self.scope):
if given_layers is not None:
# использовать переданные слои
self.input_layer = given_layers[0]
self.layers = given_layers[1:]
else:
# создать слои
# создание входного слоя
self.input_layer = Layer(input_sizes, hiddens[0], scope="input_layer")
self.layers = []
# создать скрытые слои
for l_idx, (h_from, h_to) in enumerate(zip(hiddens[:-1], hiddens[1:])):
self.layers.append(Layer(h_from, h_to, scope="hidden_layer_%d" % (l_idx,)))
# использование нейросети
# xs - вектор входных значений
# возвращается выход выходного слоя
def __call__(self, xs):
if type(xs) != list:
xs = [xs]
with tf.variable_scope(self.scope):
# применение входного слоя к вектору входных значений
hidden = self.input_nonlinearity(self.input_layer(xs))
for layer, nonlinearity in zip(self.layers, self.layer_nonlinearities):
# применение скрытых слоев в выходам предидущих слоев
hidden = nonlinearity(layer(hidden))
return hidden
# список параметров всей нейронной сети от входного слоя к выходному
def variables(self):
res = self.input_layer.variables()
for layer in self.layers:
res.extend(layer.variables())
return res
def copy(self, scope=None):
scope = scope or self.scope + "_copy"
nonlinearities = [self.input_nonlinearity] + self.layer_nonlinearities
given_layers = [self.input_layer.copy()] + [layer.copy() for layer in self.layers]
return MLP(self.input_sizes, self.hiddens, nonlinearities, scope=scope,
given_layers=given_layers)
```
**discrete\_deepq.py - реализация Q-learning**
```
import numpy as np
import random
import tensorflow as tf
from collections import deque
class DiscreteDeepQ(object):
# Описание параметров ниже
def __init__(self, observation_size,
num_actions,
observation_to_actions,
optimizer,
session,
random_action_probability=0.05,
exploration_period=1000,
store_every_nth=5,
train_every_nth=5,
minibatch_size=32,
discount_rate=0.95,
max_experience=30000,
target_network_update_rate=0.01,
summary_writer=None):
# Этот большой комментарий я просто переведу ниже
"""Initialized the Deepq object.
Based on:
https://www.cs.toronto.edu/~vmnih/docs/dqn.pdf
Parameters
-------
observation_size : int
length of the vector passed as observation
num_actions : int
number of actions that the model can execute
observation_to_actions: dali model
model that implements activate function
that can take in observation vector or a batch
and returns scores (of unbounded values) for each
action for each observation.
input shape: [batch_size, observation_size]
output shape: [batch_size, num_actions]
optimizer: tf.solver.*
optimizer for prediction error
session: tf.Session
session on which to execute the computation
random_action_probability: float (0 to 1)
exploration_period: int
probability of choosing a random
action (epsilon form paper) annealed linearly
from 1 to random_action_probability over
exploration_period
store_every_nth: int
to further decorrelate samples do not all
transitions, but rather every nth transition.
For example if store_every_nth is 5, then
only 20% of all the transitions is stored.
train_every_nth: int
normally training_step is invoked every
time action is executed. Depending on the
setup that might be too often. When this
variable is set set to n, then only every
n-th time training_step is called will
the training procedure actually be executed.
minibatch_size: int
number of state,action,reward,newstate
tuples considered during experience reply
dicount_rate: float (0 to 1)
how much we care about future rewards.
max_experience: int
maximum size of the reply buffer
target_network_update_rate: float
how much to update target network after each
iteration. Let's call target_network_update_rate
alpha, target network T, and network N. Every
time N gets updated we execute:
T = (1-alpha)*T + alpha*N
summary_writer: tf.train.SummaryWriter
writer to log metrics
"""
"""Инициализация Deepq
Основано на:
https://www.cs.toronto.edu/~vmnih/docs/dqn.pdf
Параметры
-------
observation_size : int
длина вектора входных данных (этот вектор
будем называть наблюдением или состоянием)
num_actions : int
количество возможных действий или же
длина вектора выходных данных нейросети
observation_to_actions: dali model
модель (в нашем случае нейросеть),
которая принимает наблюдение или набор наблюдений
и возвращает оценку очками каждого действия или
набор оценок для каждого действия каждого из наблюдений
входной размер: матрица [batch_size, observation_size]
выходной размер: матрица [batch_size, num_actions]
optimizer: tf.solver.*
алгоритм рассчета обратого распространения ошибки
в нашем случае будет использоваться RMSProp
session: tf.Session
сессия TensorFlow в которой будут производится вычисления
random_action_probability: float (0 to 1)
вероятность случайного действия,
для обогощения опыта нейросети и улучшения качесва управления
с определенной вероятностью выполняется случайное действие, а не
действие выданное нейросетью
exploration_period: int
период поискового поведения в итерациях,
в течении которого вероятность выполнения случайного
действия падает от 1 до random_action_probability
store_every_nth: int
параметр нужен чтобы сохранять не все обучающие примеры
а только определенную часть из них.
Сохранение происходит один раз в указаное в параметре
количество обучающих примеров
train_every_nth: int
обычно training_step (шаг обучения)
запускается после каждого действия.
Иногда получается так, что это слишком часто.
Эта переменная указывает сколько шагов
пропустить перед тем как запускать шаг обучения
minibatch_size: int
размер набора обучающих примеров который
используется на одном шаге обучения
алгоритмом RMSProp.
Обучающий пример включает в себя
состояние, предпринятое действие, награду и
новое состояние
dicount_rate: float (0 to 1)
параметр Q-learning
насколько сильно влияет будущая награда при
расчете пользы действия
max_experience: int
максимальное количество сохраненных
обучающих примеров
target_network_update_rate: float
параметр скорости обучения нейросети,
здесь используется 2 нейросети
T - target_q_network
она используется для расчета вклада будущей пользы и
N - q_network
она испольщуется для выбора действия,
также эта сеть подвергается обучению
методом обратного распространения ошибки.
Сеть T с определенной скоростью стремится к сети N.
Каждый раз при обучении N,
Т модифицируется следующим образом:
alpha = target_network_update_rate
T = (1-alpha)*T + alpha*N
summary_writer: tf.train.SummaryWriter
запись логов
"""
# memorize arguments
self.observation_size = observation_size
self.num_actions = num_actions
self.q_network = observation_to_actions
self.optimizer = optimizer
self.s = session
self.random_action_probability = random_action_probability
self.exploration_period = exploration_period
self.store_every_nth = store_every_nth
self.train_every_nth = train_every_nth
self.minibatch_size = minibatch_size
self.discount_rate = tf.constant(discount_rate)
self.max_experience = max_experience
self.target_network_update_rate = \
tf.constant(target_network_update_rate)
# deepq state
self.actions_executed_so_far = 0
self.experience = deque()
self.iteration = 0
self.summary_writer = summary_writer
self.number_of_times_store_called = 0
self.number_of_times_train_called = 0
self.create_variables()
# расчет вероятности случайного действия
# с учетом уменьшения с итерациями
# (линейный отжиг)
def linear_annealing(self, n, total, p_initial, p_final):
"""Linear annealing between p_initial and p_final
over total steps - computes value at step n"""
if n >= total:
return p_final
else:
return p_initial - (n * (p_initial - p_final)) / (total)
# создание графов TensorFlow для
# для расчета управляющего действия
# и реализации Q-learning
def create_variables(self):
# создание нейросети T копированием из исходной нейросети N
self.target_q_network = self.q_network.copy(scope="target_network")
# расчет управляющего действия
# FOR REGULAR ACTION SCORE COMPUTATION
with tf.name_scope("taking_action"):
# входные данные вектора состояния
self.observation = tf.placeholder(tf.float32, (None, self.observation_size), name="observation")
# расчитать очки оценки полезности каждого действия
self.action_scores = tf.identity(self.q_network(self.observation), name="action_scores")
tf.histogram_summary("action_scores", self.action_scores)
# взять действие с максимальным количеством очков
self.predicted_actions = tf.argmax(self.action_scores, dimension=1, name="predicted_actions")
# расчет будущей пользы
with tf.name_scope("estimating_future_rewards"):
# FOR PREDICTING TARGET FUTURE REWARDS
# входной параметр - будущие состояния
self.next_observation = tf.placeholder(tf.float32, (None, self.observation_size), name="next_observation")
# входной параметр - маски будущих состояний
self.next_observation_mask = tf.placeholder(tf.float32, (None,), name="next_observation_mask")
# оценки полезности
self.next_action_scores = tf.stop_gradient(self.target_q_network(self.next_observation))
tf.histogram_summary("target_action_scores", self.next_action_scores)
# входной параметр - награды
self.rewards = tf.placeholder(tf.float32, (None,), name="rewards")
# взять максимальные оценки полезностей действий
target_values = tf.reduce_max(self.next_action_scores, reduction_indices=[1,]) * self.next_observation_mask
# r + DF * MAX(Q,s) см статью о Q-learning в википедии
self.future_rewards = self.rewards + self.discount_rate * target_values
# обученте сети N
with tf.name_scope("q_value_precition"):
# FOR PREDICTION ERROR
# входной параметр маски действий в наборе обучающих примеров
self.action_mask = tf.placeholder(tf.float32, (None, self.num_actions), name="action_mask")
# расчет полезностей действий набора обучающих примеров
self.masked_action_scores = tf.reduce_sum(self.action_scores * self.action_mask, reduction_indices=[1,])
# разности текущих полезностей и будущих
# - (r + DF * MAX(Q,s) — Q[s',a'])
temp_diff = self.masked_action_scores - self.future_rewards
# ключевой момент обучения сети
# RMSProp минимизирует среднее от вышеуказанных разностей
self.prediction_error = tf.reduce_mean(tf.square(temp_diff))
# работа RMSProp, первый шаг - вычисление градиентов
gradients = self.optimizer.compute_gradients(self.prediction_error)
for i, (grad, var) in enumerate(gradients):
if grad is not None:
gradients[i] = (tf.clip_by_norm(grad, 5), var)
# Add histograms for gradients.
for grad, var in gradients:
tf.histogram_summary(var.name, var)
if grad:
tf.histogram_summary(var.name + '/gradients', grad)
# второй шаг - оптимизация параметров нейросети
self.train_op = self.optimizer.apply_gradients(gradients)
# то самое место где настраивается сеть T
# T = (1-alpha)*T + alpha*N
# UPDATE TARGET NETWORK
with tf.name_scope("target_network_update"):
self.target_network_update = []
for v_source, v_target in zip(self.q_network.variables(), self.target_q_network.variables()):
# this is equivalent to target = (1-alpha) * target + alpha * source
update_op = v_target.assign_sub(self.target_network_update_rate * (v_target - v_source))
self.target_network_update.append(update_op)
self.target_network_update = tf.group(*self.target_network_update)
# summaries
tf.scalar_summary("prediction_error", self.prediction_error)
self.summarize = tf.merge_all_summaries()
self.no_op1 = tf.no_op()
# управление
def action(self, observation):
"""Given observation returns the action that should be chosen using
DeepQ learning strategy. Does not backprop."""
assert len(observation.shape) == 1, \
"Action is performed based on single observation."
self.actions_executed_so_far += 1
# расчет вероятности случайного действия
exploration_p = self.linear_annealing(self.actions_executed_so_far,
self.exploration_period,
1.0,
self.random_action_probability)
if random.random() < exploration_p:
# случайное действие
return random.randint(0, self.num_actions - 1)
else:
# действие выбранное нейросетью
return self.s.run(self.predicted_actions, {self.observation: observation[np.newaxis,:]})[0]
# сохранение обучающего примера
# обучающий примеры берутся из действий нейросети
# во время управления
def store(self, observation, action, reward, newobservation):
"""Store experience, where starting with observation and
execution action, we arrived at the newobservation and got thetarget_network_update
reward reward
If newstate is None, the state/action pair is assumed to be terminal
"""
if self.number_of_times_store_called % self.store_every_nth == 0:
self.experience.append((observation, action, reward, newobservation))
if len(self.experience) > self.max_experience:
self.experience.popleft()
self.number_of_times_store_called += 1
# шаг обучения
def training_step(self):
"""Pick a self.minibatch_size exeperiences from reply buffer
and backpropage the value function.
"""
if self.number_of_times_train_called % self.train_every_nth == 0:
if len(self.experience) < self.minibatch_size:
return
# из всего сохраненного опыта случайно выбираем
# пачку из minibatch_size обучающих примеров
# sample experience.
samples = random.sample(range(len(self.experience)), self.minibatch_size)
samples = [self.experience[i] for i in samples]
# представляем обучающие примеры
# в нужном виде
# bach states
states = np.empty((len(samples), self.observation_size))
newstates = np.empty((len(samples), self.observation_size))
action_mask = np.zeros((len(samples), self.num_actions))
newstates_mask = np.empty((len(samples),))
rewards = np.empty((len(samples),))
for i, (state, action, reward, newstate) in enumerate(samples):
states[i] = state
action_mask[i] = 0
action_mask[i][action] = 1
rewards[i] = reward
if newstate is not None:
newstates[i] = newstate
newstates_mask[i] = 1
else:
newstates[i] = 0
newstates_mask[i] = 0
calculate_summaries = self.iteration % 100 == 0 and \
self.summary_writer is not None
# запускаем вычисления
# сначала считаем ошибку сети
# потом запускаем оптимизацию сети
# далее собираем статистику (необязательный шаг
# нужный для построения графиков обучения)
cost, _, summary_str = self.s.run([
self.prediction_error,
self.train_op,
self.summarize if calculate_summaries else self.no_op1,
], {
self.observation: states,
self.next_observation: newstates,
self.next_observation_mask: newstates_mask,
self.action_mask: action_mask,
self.rewards: rewards,
})
# подстраиваем нейросеть Т
self.s.run(self.target_network_update)
if calculate_summaries:
self.summary_writer.add_summary(summary_str, self.iteration)
self.iteration += 1
self.number_of_times_train_called += 1
```
**karpathy\_game.py - игра, в которую играет нейросеть**
```
import math
import matplotlib.pyplot as plt
import numpy as np
import random
import time
from collections import defaultdict
from euclid import Circle, Point2, Vector2, LineSegment2
import tf_rl.utils.svg as svg
# Игровой объект
# это шарик определенного цвета
# данный класс рассчитывает перемещение
# столкновения и занимается отрисовкой
class GameObject(object):
def __init__(self, position, speed, obj_type, settings):
"""Esentially represents circles of different kinds, which have
position and speed."""
self.settings = settings
self.radius = self.settings["object_radius"]
self.obj_type = obj_type
self.position = position
self.speed = speed
self.bounciness = 1.0
def wall_collisions(self):
"""Update speed upon collision with the wall."""
world_size = self.settings["world_size"]
for dim in range(2):
if self.position[dim] - self.radius <= 0 and self.speed[dim] < 0:
self.speed[dim] = - self.speed[dim] * self.bounciness
elif self.position[dim] + self.radius + 1 >= world_size[dim] and self.speed[dim] > 0:
self.speed[dim] = - self.speed[dim] * self.bounciness
def move(self, dt):
"""Move as if dt seconds passed"""
self.position += dt * self.speed
self.position = Point2(*self.position)
def step(self, dt):
"""Move and bounce of walls."""
self.wall_collisions()
self.move(dt)
def as_circle(self):
return Circle(self.position, float(self.radius))
def draw(self):
"""Return svg object for this item."""
color = self.settings["colors"][self.obj_type]
return svg.Circle(self.position + Point2(10, 10), self.radius, color=color)
# Игра. Здесь все довольно просто
# Сначала, в соответствии с настройками,
# создаются стенки и объект, которым управляет
# алгоритм. Здесь я не буду комментировать
# все, так как тут^ в принципе, по коду понятно,
# что происходит, ниже откомментирую функцию
# observe, так как она имеет непосредственное
# отношение к входным данным алгоритма
class KarpathyGame(object):
def __init__(self, settings):
"""Initiallize game simulator with settings"""
self.settings = settings
self.size = self.settings["world_size"]
self.walls = [LineSegment2(Point2(0,0), Point2(0,self.size[1])),
LineSegment2(Point2(0,self.size[1]), Point2(self.size[0], self.size[1])),
LineSegment2(Point2(self.size[0], self.size[1]), Point2(self.size[0], 0)),
LineSegment2(Point2(self.size[0], 0), Point2(0,0))]
self.hero = GameObject(Point2(*self.settings["hero_initial_position"]),
Vector2(*self.settings["hero_initial_speed"]),
"hero",
self.settings)
if not self.settings["hero_bounces_off_walls"]:
self.hero.bounciness = 0.0
self.objects = []
for obj_type, number in settings["num_objects"].items():
for _ in range(number):
self.spawn_object(obj_type)
self.observation_lines = self.generate_observation_lines()
self.object_reward = 0
self.collected_rewards = []
# Каждый радиальный отрезок видит объект или стенку
# и два числа представляющих собой скорость объекта
# every observation_line sees one of objects or wall and
# two numbers representing speed of the object (if applicable)
self.eye_observation_size = len(self.settings["objects"]) + 3
# и, в конце, к состоянию добавляются
# два числа - скорость управляемого объекта
# additionally there are two numbers representing agents own speed.
self.observation_size = self.eye_observation_size * len(self.observation_lines) + 2
self.last_observation = np.zeros(self.observation_size)
self.directions = [Vector2(*d) for d in [[1,0], [0,1], [-1,0],[0,-1]]]
self.num_actions = len(self.directions)
self.objects_eaten = defaultdict(lambda: 0)
def perform_action(self, action_id):
"""Change speed to one of hero vectors"""
assert 0 <= action_id < self.num_actions
self.hero.speed *= 0.8
self.hero.speed += self.directions[action_id] * self.settings["delta_v"]
def spawn_object(self, obj_type):
"""Spawn object of a given type and add it to the objects array"""
radius = self.settings["object_radius"]
position = np.random.uniform([radius, radius], np.array(self.size) - radius)
position = Point2(float(position[0]), float(position[1]))
max_speed = np.array(self.settings["maximum_speed"])
speed = np.random.uniform(-max_speed, max_speed).astype(float)
speed = Vector2(float(speed[0]), float(speed[1]))
self.objects.append(GameObject(position, speed, obj_type, self.settings))
def step(self, dt):
"""Simulate all the objects for a given ammount of time.
Also resolve collisions with the hero"""
for obj in self.objects + [self.hero] :
obj.step(dt)
self.resolve_collisions()
def squared_distance(self, p1, p2):
return (p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2
def resolve_collisions(self):
"""If hero touches, hero eats. Also reward gets updated."""
collision_distance = 2 * self.settings["object_radius"]
collision_distance2 = collision_distance ** 2
to_remove = []
for obj in self.objects:
if self.squared_distance(self.hero.position, obj.position) < collision_distance2:
to_remove.append(obj)
for obj in to_remove:
self.objects.remove(obj)
self.objects_eaten[obj.obj_type] += 1
self.object_reward += self.settings["object_reward"][obj.obj_type]
self.spawn_object(obj.obj_type)
def inside_walls(self, point):
"""Check if the point is inside the walls"""
EPS = 1e-4
return (EPS <= point[0] < self.size[0] - EPS and
EPS <= point[1] < self.size[1] - EPS)
# возвращает вектор состояния
def observe(self):
"""Return observation vector. For all the observation directions it returns representation
of the closest object to the hero - might be nothing, another object or a wall.
Representation of observation for all the directions will be concatenated.
"""
num_obj_types = len(self.settings["objects"]) + 1 # and wall
max_speed_x, max_speed_y = self.settings["maximum_speed"]
# расстояние видимости
observable_distance = self.settings["observation_line_length"]
# получение всех объектов в зоне видимости
relevant_objects = [obj for obj in self.objects
if obj.position.distance(self.hero.position) < observable_distance]
# сортировка объектов по расстоянию
# сначала ближние
# objects sorted from closest to furthest
relevant_objects.sort(key=lambda x: x.position.distance(self.hero.position))
observation = np.zeros(self.observation_size)
observation_offset = 0
# начинаем перебирать отрезки зрения
for i, observation_line in enumerate(self.observation_lines):
# shift to hero position
observation_line = LineSegment2(self.hero.position + Vector2(*observation_line.p1),
self.hero.position + Vector2(*observation_line.p2))
observed_object = None
# проверяем видим ли мы стену
# if end of observation line is outside of walls, we see the wall.
if not self.inside_walls(observation_line.p2):
observed_object = "**wall**"
# перебираем объекты в зоне видимости
for obj in relevant_objects:
if observation_line.distance(obj.position) < self.settings["object_radius"]:
# нашли объект
observed_object = obj
break
# параметры найденного объекта
# тип, скорость и расстояние до него
object_type_id = None
speed_x, speed_y = 0, 0
proximity = 0
if observed_object == "**wall**": # wall seen
# видим стену
object_type_id = num_obj_types - 1
# в примере стена всегда обладает
# нулевой скоростью, я подумал,
# что лучше, все таки, использовать
# ее относительную скорость
# в результате
# качество управление улучшилось
# a wall has fairly low speed...
# speed_x, speed_y = 0, 0
# I think relative speed is better than absolute
speed_x, speed_y = tuple (-self.hero.speed)
# best candidate is intersection between
# observation_line and a wall, that's
# closest to the hero
best_candidate = None
for wall in self.walls:
candidate = observation_line.intersect(wall)
if candidate is not None:
if (best_candidate is None or
best_candidate.distance(self.hero.position) >
candidate.distance(self.hero.position)):
best_candidate = candidate
if best_candidate is None:
# assume it is due to rounding errors
# and wall is barely touching observation line
proximity = observable_distance
else:
proximity = best_candidate.distance(self.hero.position)
elif observed_object is not None: # agent seen
# видим объект
# тип объекта
object_type_id = self.settings["objects"].index(observed_object.obj_type)
# здесь я тоже использовал скорость относительно
# управляемого объекта
speed_x, speed_y = tuple(observed_object.speed - self.hero.speed)
intersection_segment = obj.as_circle().intersect(observation_line)
assert intersection_segment is not None
# вычисление расстояние до объекта
try:
proximity = min(intersection_segment.p1.distance(self.hero.position),
intersection_segment.p2.distance(self.hero.position))
except AttributeError:
proximity = observable_distance
for object_type_idx_loop in range(num_obj_types):
# здесь 1.0 означает отсутствие в поле видимости
# объекта заданного типа
observation[observation_offset + object_type_idx_loop] = 1.0
if object_type_id is not None:
# если объект найден то в ячейке типа объекта
# задается расстояние меньше от 0.0 до 1.0
# расстояние меряется относительно длины отрезка
observation[observation_offset + object_type_id] = proximity / observable_distance
# скорость найденного объекта
observation[observation_offset + num_obj_types] = speed_x / max_speed_x
observation[observation_offset + num_obj_types + 1] = speed_y / max_speed_y
assert num_obj_types + 2 == self.eye_observation_size
observation_offset += self.eye_observation_size
# после заполнения данных со всех отрезков
# добавляется скорость управляемого объекта
observation[observation_offset] = self.hero.speed[0] / max_speed_x
observation[observation_offset + 1] = self.hero.speed[1] / max_speed_y
assert observation_offset + 2 == self.observation_size
self.last_observation = observation
return observation
def distance_to_walls(self):
"""Returns distance of a hero to walls"""
res = float('inf')
for wall in self.walls:
res = min(res, self.hero.position.distance(wall))
return res - self.settings["object_radius"]
def collect_reward(self):
"""Return accumulated object eating score + current distance to walls score"""
wall_reward = self.settings["wall_distance_penalty"] * \
np.exp(-self.distance_to_walls() / self.settings["tolerable_distance_to_wall"])
assert wall_reward < 1e-3, "You are rewarding hero for being close to the wall!"
total_reward = wall_reward + self.object_reward
self.object_reward = 0
self.collected_rewards.append(total_reward)
return total_reward
def plot_reward(self, smoothing = 30):
"""Plot evolution of reward over time."""
plottable = self.collected_rewards[:]
while len(plottable) > 1000:
for i in range(0, len(plottable) - 1, 2):
plottable[i//2] = (plottable[i] + plottable[i+1]) / 2
plottable = plottable[:(len(plottable) // 2)]
x = []
for i in range(smoothing, len(plottable)):
chunk = plottable[i-smoothing:i]
x.append(sum(chunk) / len(chunk))
plt.plot(list(range(len(x))), x)
def generate_observation_lines(self):
"""Generate observation segments in settings["num_observation_lines"] directions"""
result = []
start = Point2(0.0, 0.0)
end = Point2(self.settings["observation_line_length"],
self.settings["observation_line_length"])
for angle in np.linspace(0, 2*np.pi, self.settings["num_observation_lines"], endpoint=False):
rotation = Point2(math.cos(angle), math.sin(angle))
current_start = Point2(start[0] * rotation[0], start[1] * rotation[1])
current_end = Point2(end[0] * rotation[0], end[1] * rotation[1])
result.append( LineSegment2(current_start, current_end))
return result
def _repr_html_(self):
return self.to_html()
def to_html(self, stats=[]):
"""Return svg representation of the simulator"""
stats = stats[:]
recent_reward = self.collected_rewards[-100:] + [0]
objects_eaten_str = ', '.join(["%s: %s" % (o,c) for o,c in self.objects_eaten.items()])
stats.extend([
"nearest wall = %.1f" % (self.distance_to_walls(),),
"reward = %.1f" % (sum(recent_reward)/len(recent_reward),),
"objects eaten => %s" % (objects_eaten_str,),
])
scene = svg.Scene((self.size[0] + 20, self.size[1] + 20 + 20 * len(stats)))
scene.add(svg.Rectangle((10, 10), self.size))
num_obj_types = len(self.settings["objects"]) + 1 # and wall
observation_offset = 0;
for line in self.observation_lines:
# getting color of the line
linecolor = 'black';
linewidth = '1px';
for object_type_idx_loop in range(num_obj_types):
if self.last_observation[observation_offset + object_type_idx_loop] < 1.0:
if object_type_idx_loop < num_obj_types - 1:
linecolor = self.settings["colors"][self.settings["objects"][object_type_idx_loop]];
linewidth = '3px';
observation_offset += self.eye_observation_size
scene.add(svg.Line(line.p1 + self.hero.position + Point2(10,10),
line.p2 + self.hero.position + Point2(10,10),
color = linecolor,
stroke = linecolor,
stroke_width = linewidth))
for obj in self.objects + [self.hero] :
scene.add(obj.draw())
offset = self.size[1] + 15
for txt in stats:
scene.add(svg.Text((10, offset + 20), txt, 15))
offset += 20
return scene
```
Если вы захотите посмотреть как все это работает вам будет необходим [IPython Notebook](http://ipython.org/notebook.html). Так как все это собирается воедино в сценарии для него. Сценарий находится по адресу notebooks/karpathy\_game.ipynb.
#### Результат
Пока писал статью, запустил на несколько часов обучение. Ниже видео: как у меня в итоге обучилась сетка за довольно небольшое время.
#### Куда двигаться дальше
Дальше я планирую попробовать внедрить этот метод в свой [виртуальный квадрокоптер](http://habrahabr.ru/post/271337/). Сначала хочу попробовать сделать стабилизацию. Потом, если получится, попробую сделать чтобы оно летало, но там уже, скорее всего, понадобится сверточная сеть вместо многослойного перцептрона.
Пример заботливо выложен на гитхаб пользователем [nivwusquorum](https://github.com/nivwusquorum), за что хочется выразить ему огромное человеческое спасибо. | https://habr.com/ru/post/274597/ | null | ru | null |
# Модули Laurent и Умный дом (часть 2). Arduino и AMS
Это вторая статья из цикла о интеграции модулей Laurent (Лоран) компании [KernelChip](http://www.kernelchip.ru/) в системы домашней автоматизации и в этой части речь пойдёт об интеграции этих модулей с экосистемой Ардуино. В [первой части](http://geektimes.ru/post/262892/) цикла речь шла об интеграции с популярной системой домашней автоматизации MajorDoMo, а в третьей части вы узнаете как управлять этими модулями из скетчей на языке программирования Processing, прямо с рабочего стола вашего компьютера.
Ардуино наше всё
----------------
Куда же без Ардуино? Не буду здесь долго расписывать достоинства этой платформы, её популярность говорит сама за себя, поэтому давайте сразу приступим к техническим деталям реализации взаимодействия Ардуино и модулей Лоран. И по пути не забудем систему [Arduino Mega Server](http://hi-lab.ru/arduino-mega-server), как очень интересное производное от экосистемы Arduino.
Железо
------
Для управления модулями по сети подойдёт, например, распространённая плата Arduino Uno или не менее популярная плата Arduino Mega в комплекте с платой сетевого интерфейса Ethernet Shield, собранной на основе чипа W5100. Все примеры в этой статье даются для такого сочетания и были протестированы на практике. Всё работает надёжно и без каких-либо проблем.
*Ethernet Shield на основе чипа W5100*
То есть вам остаётся только взять скетч и залить его на свою плату Uno или Mega, предварительно немного изменив его под свои задачи.
Управляем модулями из скетчей
-----------------------------
В первой части цикла я уже рассказывал о принципах управления модулями Laurent по сети, для тех, кто не читал первую часть, кратко повторю здесь теорию.
Обмен информацией с модулями осуществляется по сети и для начала работы с ними нужно установить TCP/IP соединение на 2424 порту. Как только соединение установлено, можно посылать текстовые команды (т. н. КЕ команды) которые и управляют модулем. На сайте компании [KernelChip](http://www.kernelchip.ru/) есть подробная документация и, в том числе, доступное описание КЕ команд.
Теперь давайте попробуем перевести это теоретическое «техзадание» на простой язык скетчей Ардуино.
Скетч
-----
Я здесь не буду объяснять, как установить и настроить среду программирования Ардуино, предполагается, что вы уже это сделали и умеете писать простейшие скетчи. Итак, для начала нам нужно подключить необходимые библиотеки SPI.h и Ethernet.h для управления шиной и собственно Ethernet модулем.
```
#include
#include
```
Затем нужно задать сетевые настройки для Ethernet модуля и модуля Laurent, которым мы будем управлять. Обратите внимание, что MAC адреса и IP адреса должны быть уникальны, а LAURENT\_PORT должен иметь значение 2424 и никакое другое.
```
byte SELF_MAC[] = {0x00, 0x2A, 0xF5, 0x12, 0x67, 0xEE};
byte SELF_IP[] = {192, 168, 2, 20};
byte LAURENT_IP[] = {192, 168, 2, 19};
int LAURENT_PORT = 2424;
```
Нам ещё понадобится буфер для хранения сетевых команд, он выбран размером 200 байт с некоторым запасом, если у вас есть проблемы с нехваткой оперативной памяти, то вы можете его сократить, например, до 100 байт или даже меньше.
```
char buf[200];
```
И последний штрих, это Ethernet клиент для модуля Laurent. Теперь все операции с модулем мы будем проводить с использованием объекта lclient.
```
EthernetClient lclient;
```
Всё, теперь давайте рассмотрим функцию, посылающую команды модулю Laurent.
```
void sendLaurentRequest() {
if (lclient.connect(LAURENT_IP, LAURENT_PORT)) {
Serial.print("Command: ");
Serial.println(buf);
lclient.println(buf);
delay(100);
Serial.print("Answer: ");
while(lclient.available() != 0) {
char c = lclient.read();
Serial.print(c);
}
delay(500);
lclient.stop();
} else {
Serial.println("Error sending command");
}
}
```
Если установлено соединение с модулем Laurent на 2424 порту, то содержимое буфера посылается модулю и дублируется в Serial для визуального контроля. Затем ожидается 100 миллисекунд и принимается ответ модуля. После этого опять пауза и связь с модулем разрывается. Если соединения с модулем по какой-либо причине установить не удалось, то выводится сообщение об ошибке.
Теперь разберём инициализацию. Инициализация Ethernet производится простой функцией
```
void ethernetInit() {
Ethernet.begin(SELF_MAC, SELF_IP);
}
```
А инициализация модуля Laurent производится функцией laurentInit(), работу которой мы сейчас подробно разберём. Она довольно большая и вам нужно хорошенько в ней разобраться потому, что именно на основе кода этой функции вы сможете строить свои собственные запросы к модулям Laurent.
```
void laurentInit() {
Serial.println("Start modul Laurent Init...");
Serial.print("Connect to Laurent... ");
if (lclient.connect(LAURENT_IP, LAURENT_PORT)) {
Serial.println("OK");
lclient.stop();
// Send test command
Serial.println("Selftest...");
sprintf(buf, "$KE");
sendLaurentRequest();
// Send password (default: "Laurent")
Serial.println("Set password...");
sprintf(buf, "$KE,PSW,SET,Laurent");
sendLaurentRequest();
} else {
Serial.println("failed");
}
delay(500);
// останавливаем выдачу DATA
sprintf(buf, "$KE,DAT,OFF");
sendLaurentRequest();
delay(100);
// выключаем реле
sprintf(buf, "$KE,REL,2,0");
sendLaurentRequest();
Serial.println("Modul Laurent Init done");
}
```
Вначале выводится сообщение об инициализации и производится попытка соединиться с модулем Laurent. Если это не удаётся, то выводится сообщение об ошибке, а если соединиться с модулем происходит успешно, то посылается команда на самодиагностику, на которую исправный модуль должен ответить «#OK».
Далее посылается команда на ввод пароля (в данном случае это пароль по умолчанию). И ожидается 500 миллисекунд.
Далее вводятся две дополнительные команды — одна из них останавливает выдачу данных модулем (если она идёт), а вторая выключает реле №2, которое мы используем в своих экспериментах. Другими словами, эти команды приводят модуль в некое начальное состояние.
Вот распечатка процесса инициализации на которой видны все команды и все ответы модуля:
```
Start modul Laurent Init...
Connect to Laurent... OK
Selftest...
Command: $KE
Answer: #OK
Set password...
Command: $KE,PSW,SET,Laurent
Answer: #PSW,SET,OK
Command: $KE,DAT,OFF
Answer: #DAT,OK
Command: $KE,REL,2,0
Answer: #REL,OK
Modul Laurent Init done
```
Теперь код стандартной функции setup(). Инициализируются все подсистемы, в том числе последовательный порт на стандартной скорости обмена 9600.
```
void setup() {
Serial.begin(9600);
ethernetInit();
laurentInit();
}
```
Итак, мы инициализировали модуль и можем управлять им так, как нам нужно: посылать команды, читать ответы, строить логику управления с учётом выдаваемых модулем Laurent данных.
Рассмотрим, для примера, простейшую задачу — зажигать и гасить через равные промежутки времени свет лампы, подключённой ко второму реле модуля Laurent.
```
void loop() {
// включаем реле
sprintf(buf, "$KE,REL,2,1");
sendLaurentRequest();
delay(3000);
// выключаем реле
sprintf(buf, "$KE,REL,2,0");
sendLaurentRequest();
delay(3000);
}
```
Функция loop() это бесконечный цикл и лампа, повинуясь нашим командам, будет беспрерывно зажигаться и гаснуть через каждые 3 секунды. Это, естественно, просто пример, на самом деле логика работы может быть любой и тут всё зависит от ваших потребностей. И конечно, посылать можно не только команды на включение или отключение нагрузок, но и любые другие, поддерживаемые модулем. С полным перечнем команд и их описанием вы можете ознакомиться в документации к модулям Laurent.
Вы можете взять этот скетч и интегрировать его в собственные проекты, таким образом добавив в них поддержку управления модулями Лоран. Или наоборот, взять за основу этот скетч и постепенно наращивать его функциональность. Предела для совершенства нет. Вот полный текст скетча.
**Полный код скетча**#include
#include
byte SELF\_MAC[] = {0x00, 0x2A, 0xF5, 0x12, 0x67, 0xEE};
byte SELF\_IP[] = {192, 168, 2, 20};
byte LAURENT\_IP[] = {192, 168, 2, 19};
int LAURENT\_PORT = 2424;
char buf[200];
EthernetClient lclient;
void ethernetInit() {
Ethernet.begin(SELF\_MAC, SELF\_IP);
}
void laurentInit() {
Serial.println(«Start modul Laurent Init...»);
Serial.print(«Connect to Laurent… „);
if (lclient.connect(LAURENT\_IP, LAURENT\_PORT)) {
Serial.println(“OK»);
lclient.stop();
// Send test command
Serial.println(«Selftest...»);
sprintf(buf, "$KE");
sendLaurentRequest();
// Send password (default: «Laurent»)
Serial.println(«Set password...»);
sprintf(buf, "$KE,PSW,SET,Laurent");
sendLaurentRequest();
} else {
Serial.println(«failed»);
}
delay(500);
// останавливаем выдачу DATA
sprintf(buf, "$KE,DAT,OFF");
sendLaurentRequest();
delay(100);
// выключаем реле
sprintf(buf, "$KE,REL,2,0");
sendLaurentRequest();
Serial.println(«Modul Laurent Init done»);
} // laurentInit
void sendLaurentRequest() {
if (lclient.connect(LAURENT\_IP, LAURENT\_PORT)) {
Serial.print(«Command: „);
Serial.println(buf);
lclient.println(buf);
delay(100);
Serial.print(“Answer: „);
while(lclient.available() != 0) {
char c = lclient.read();
Serial.print©;
}
delay(500);
lclient.stop();
} else {
Serial.println(“Error sending command»);
}
} // sendLaurentRequest
void setup() {
Serial.begin(9600);
ethernetInit();
laurentInit();
}
void loop() {
// включаем реле
sprintf(buf, "$KE,REL,2,1");
sendLaurentRequest();
delay(3000);
// выключаем реле
sprintf(buf, "$KE,REL,2,0");
sendLaurentRequest();
delay(3000);
}
Arduino Mega Server
-------------------
[Arduino Mega Server](http://hi-lab.ru/arduino-mega-server) (AMS) это мощная система для Arduino Mega (теперь уже и для Arduino DUE и, вскоре, для других 32-битных платформ M0 (Zero) и Genuino 101), которая содержит код «на все случаи жизни» и плюс ещё встроенный сервер и удобный веб-интерфейс. AMS поддерживает модули Laurent прямо «из коробки» и вам ничего не нужно добавлять, кроме пользовательской логики.
AMS имеет модульную структуру и включение и отключение модулей производится простым комментированием строки в скетче, например,
```
#define LAURENT_FEATURE
```
или
```
//#define LAURENT_FEATURE
```
Если строка закомментирована, то модуль не компилируется и не участвует в работе, что видно на индикаторах модулей в шапке сайта. Или наоборот, откомпилированный и работающий модуль индицируется синим цветом. В данном случае модуль управления «Лоранами» LRT не работает.
*Индикаторы работы модулей*
Работа с ответами модуля Laurent
--------------------------------
Теперь давайте добавим возможность не просто показывать ответы модуля, но и работать с ними, например, анализировать их или выводить на веб-странички Arduino Mega Server. Для этого нам понадобится новая строковая переменная и константа, которая определяет длину строки, которую мы отводим под ответы модулей Laurent. В тестовом примере она равна 25 символам, но вы можете её увеличить, если ответы не будут умещаться в это значение. Нужно только помнить, что оперативная память микроконтроллера это ценный ресурс и её нужно экономить. Добавляем такие строки в стандартный модуль laurent.ino из поставки AMS:
```
byte MAX_LEN_LREQUEST = 25;
String lrequest = String(MAX_LEN_LREQUEST);
```
Нам также нужно изменить код функции, которая осуществляет запросы (добавленные изменения выделены стрелками).
```
void sendLaurentRequest() {
if (lclient.connect(LAURENT_IP, LAURENT_PORT)) {
Serialprint("Command: ");
Serial.println(buf);
lclient.println(buf);
delay(100);
Serialprint("Answer: ");
// -------------------->
lrequest = "";
// -------------------->
while(lclient.available() != 0) {
char c = lclient.read();
Serial.print(c);
// -------------------->
if (lrequest.length() < MAX_LEN_LREQUEST) {
lrequest += (c);
}
// -------------------->
}
delay(500);
lclient.stop();
} else {
Serialprint("Error sending command\n");
}
}
```
Таким образом, мы научились получать ответы Лоранов в переменную lrequest и теперь можем делать с ней всё, что посчитаем нужным. Дальше я покажу, как вывести результаты запросов прямо в dash-панель в шапке сайта AMS.
Небольшое примечание. В этом примере используется функция Serialprint вместо стандартной Serial.print потому, что она более экономно расходует оперативную память. И её легко можно переделать в стандартную, просто поставив точку между двумя словами.
Выведение ответа модуля в шапку сайта
-------------------------------------
И последний пример. Давайте выведем ответы модулей Лоран в шапку сайта Arduino Mega Server. Для этого нам нужно добавить запрос в главный цикл loop() скетча AMS. Открываем файл arduino\_mega\_server.ino и перед функцией cyclosInSecWork() вводим такой код:
```
#ifdef LAURENT_FEATURE
if (cycle30s) {
sprintf(buf, "$KE");
sendLaurentRequest();
}
#endif
```
Этот код будет каждые тридцать секунд запрашивать состояние здоровья модуля Laurent. Естественно, это только пример, на этом месте может быть любой запрос и любой код. Таким образом, в переменной lrequest мы имеем ответ о состоянии модуля и можем теперь вывести его в шапку сайта. Для этого открываем модуль server\_ajax.ino и в самом конце, в коде функции responseDash(EthernetClient cl), перед строкой cl.println(""); добавляем такой код:
```
#ifdef LAURENT_FEATURE
sendTagString("laurent", "", lrequest, cl);
#endif
```
Этот код, собственно, и посылает ответы модуля на веб-страничку. Осталось сделать две вещи: первая — добавить код на языке JavaScript, который будет «ловить» наши данные и вторая — код HTML на самой страничке AMS, где и будут выводиться ответы модуля.
Итак, открываем файл scripts.js и в функции getDashData() перед закрывающей скобкой } //if (this.responseXML != null) вводим код, который будет принимать наши посылки.
```
// Laurent
try {
var laurent = this.responseXML.getElementsByTagName('laurent')[0].childNodes[0].nodeValue;
} catch (err) {
laurent = "-";
}
document.getElementById("laurent").innerHTML = laurent;
```
Осталось только немного поправить файл dash.htm из стандартной поставки AMS и добавить в него код, который будет выводить информацию на экран. Сразу после строки, содержащей class=«online-device» вводим нашу новую строку с кодом:
```
Laurent: ...
```
Вот и всё. Мы вывели ответы модуля Laurent в шапку сайта Arduino Mega Server. И вот результат наших стараний. Состояние модуля наглядно видно в панели AMS и оно обновляется каждые 30 секунд, так что, если с модулем что-то случится, то вы узнаете об этом максимум через 30 секунд.
Заключение
----------
Как видите, в управлении модулями Лоран при помощи Ардуино и Arduino Mega Server нет ничего сложного и если у вас уже есть такие модули или вы планируете добавить их в свою систему Умного дома, то эта статья поможет вам сделать это легко и просто.
А в следующей статье из цикла вы узнаете как управлять «Лоранами» прямо с экрана своего компьютера и как сделать процесс обучения детей программированию интерактивным и более интересным.
**Дополнение**. Открыт канал на Youtube и вот [промо ролик](http://www.youtube.com/watch?v=jmu0MkIlywU) Arduino Mega Server, который демонстрирует работу с реальной системой. | https://habr.com/ru/post/387205/ | null | ru | null |
# Возможно, вам не нужен Kubernetes
*Девушка на скутере. Иллюстрация [freepik](https://www.freepik.com/free-photos-vectors/car), логотип Nomad от [HashiCorp](https://www.nomadproject.io/)*
Kubernetes — это 300-килограммовая горилла для оркестровки контейнеров. Она работает в некоторых самых крупных контейнерных системах в мире, но дорого обходится.
Особенно дорого для небольших команд, которым придётся потратить много времени на поддержку и крутую кривую обучения. Для нашей команды из четырёх человек это слишком много накладных расходов. Поэтому мы стали искать альтернативы — и влюбились в [Nomad](https://www.nomadproject.io/).
Чего хочется
============
Наша команда поддерживает ряд типичных сервисов для мониторинга и анализа производительности: конечные точки API для метрик, написанных на Go, экспорт Prometheus, парсеры логов, такие как Logstash и [Gollum](https://github.com/trivago/gollum), а также базы данных, такие как InfluxDB или Elasticsearch. Каждая из этих служб работает в собственном контейнере. Нам нужна простая система, чтобы поддерживать всё это в рабочем состоянии.
Мы начали со списка требований для оркестровки контейнеров:
* Запуск набора сервисов на многих машинах.
* Обзор запущенных служб.
* Связи между службами.
* Автоматический перезапуск, если сервис падает.
* Обслуживание инфраструктуры небольшой командой.
Кроме того, следующие вещи будут приятными, но не обязательными дополнениями:
* Пометка машин по их возможностям (например, пометка машин с быстрыми дисками для тяжёлых сервисов ввода-вывода).
* Возможность запуска служб независимо от оркестратора (например, во время разработки).
* Общее место для обмена конфигурациями и секретами.
* Конечная точка для метрик и логов.
Почему Kubernetes нам не подходит
=================================
При создании прототипа с Kubernetes мы заметили, что стали добавлять всё более сложные слои логики, на которую безоговорочно полагались.
В качестве примера, Kubernetes поддерживает встроенные конфигурации сервисов через [ConfigMaps](https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/). Вы можете быстро запутаться, особенно при слиянии нескольких файлов конфигурации или добавлении дополнительных служб в pod. Kubernetes (или [helm](https://helm.sh/) в данном случае) позволяет внедрять динамически внешние конфигурации для разделения интересов. Но это приводит к жёсткой скрытой связи между вашим проектом и Kubernetes. Впрочем, Helm и ConfigMaps являются дополнительными опциями, поэтому вам не обязательно их использовать. Вы можете просто скопировать конфигурацию в образ Docker. Тем не менее, заманчиво пойти по этому пути и построить ненужные абстракции, о чём потом можете пожалеть.
Кроме того, экосистема Kubernetes быстро развивается. Требуется много времени и энергии, чтобы оставаться в курсе лучших практик и новейших инструментов. Kubectl, minikube, kubeadm, helm, tiller, kops, oc — список продолжается и продолжается. В начале работы необходимы не все эти инструменты, но вы не знаете, что понадобится, поэтому нужно быть в курсе всего. Из-за этого кривая обучения довольно крутая.
Когда использовать Kubernetes
=============================
У нас в компании многие используют Kubernetes и вполне довольны этим. Эти инстансы управляются Google или Amazon, у которых хватает ресурсов на поддержку.
Kubernetes поставляется с [удивительными функциями](https://jvns.ca/blog/2017/08/05/how-kubernetes-certificates-work/), которые делают более управляемой масштабную оркестровку контейнеров:
* Детализированное [управление правами](https://kubernetes.io/docs/reference/access-authn-authz/authorization/).
* [Кастомные контроллеры](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#custom-controllers) добавляют логику в кластер. Это просто программы, которые разговаривают с Kubernetes API.
* [Автомасштабирование](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/)! Kubernetes умеет масштабировать сервисы по требованию, используя сервисные метрики и не требуя ручного вмешательства.
Вопрос в том, действительно ли вам нужны все эти функции. Не получится только полагаться на абстракции; [вам придётся узнать, что происходит под капотом](https://jvns.ca/blog/2017/08/05/how-kubernetes-certificates-work/).
Наша команда предоставляет большинство сервисов удалённо (из-за тесной связи с основной инфраструктурой), поэтому мы не хотели поднимать собственный кластер Kubernetes. Мы хотели просто предоставлять сервисы.
Батареи не включены
===================
Nomad — это 20% оркестровки, которые дают 80% необходимого. Всё, что он делает, это управляет деплоями. Nomad заботится о деплоях, перезапускает контейнеры в случае ошибок… и это всё.
Весь смысл Nomad в том, что он делает *минимум*: никакого детализированного управления правами или [расширенных сетевых политик](https://kubernetes.io/docs/concepts/services-networking/network-policies/), так специально задумано. Эти компоненты предоставляются со стороны или не предоставляются вовсе.
Думаю, что Nomad нашёл идеальный компромисс между простотой использования и полезностью. Он хорош для небольших, независимых сервисов. Если нужно больше контроля, то придётся поднять их самостоятельно или использовать другой подход. Nomad — это *просто* оркестратор.
Самое лучшее в Nomad — то, что его легко *заменить*. Привязка к вендору практически отсутствует, поскольку его функции легко интегрируются в любую другую систему, управляющую сервисами. Он работает просто как обычный бинарник на каждой машине в кластере, вот и всё!
Экосистема Nomad из слабо связанных компонентов
===============================================
Реальная сила Nomad в его экосистеме. Он очень хорошо интегрируется с другими — полностью необязательными — продуктами, такими как [Consul](https://www.consul.io/) (хранилище ключ-значение) или [Vault](https://www.vaultproject.io/) (обработка секретов). Внутри файла Nomad есть разделы для извлечения данных из этих служб:
```
template {
data = <
```
Здесь мы читаем ключ `service/geo-api/log-verbosity` из Consul и в процессе работы представляем его переменной окружения `LOG_LEVEL`. Мы также представляем ключ `secret/geo-api-key` из Vault как `API_KEY`. Просто, но мощно!
Благодаря своей простоте Nomad легко расширяется с помощью других сервисов через API. Например, поддерживаются теги для заданий. Мы помечаем все службы с метриками тегом `trv-metrics`. Таким образом, Prometheus легко находит эти службы через Consul и периодически проверят конечную точку `/metrics` на предмет новых данных. То же самое можно сделать, например, для логов, используя [Loki](https://grafana.com/loki).
Есть много других примеров расширяемости:
* Запуск задания Jenkins с помощью хука, а Consul отслеживает повторный деплой задания Nomad при изменениях конфигурации службы.
* Ceph добавляет в Nomad распределённую файловую систему.
* [fabio](https://github.com/fabiolb/fabio) для балансировки нагрузки.
Всё это позволяет [органично развивать инфраструктуру](https://tech.trivago.com/2019/01/25/nomad-our-experiences-and-best-practices/) без особой привязки к вендору.
Честное предупреждение
======================
Ни одна система не совершенна. Не советую сразу внедрять в продакшн самые новые функции. Конечно, есть ошибки и отсутствующие функции, но то же самое относится к Kubernetes.
По сравнению с Kubernetes, сообщество Nomad не так велико. У Kubernetes уже около 75 000 коммитов и 2000 контрибуторов, в то время как у Nomad около 14 000 коммитов и 300 контрибуторов. Nomad будет трудно удержаться и не отставать по скорости от Kubernetes, но, возможно, это и не нужно! Это более специализированная система, а меньшее сообщество также означает, что ваш пулл-реквест скорее заметят и примут, по сравнению с Kubernetes.
Резюме
======
Вывод: не используйте Kubernetes только потому, что так делают все. Тщательно оцените свои требования и проверьте, какой инструмент выгоднее.
Если планируете развернуть массу однородных служб на крупномасштабной инфраструктуре, то Kubernetes — хороший вариант. Просто помните о дополнительной сложности и эксплуатационных расходах. Некоторых затрат можно избежать, используя управляемую среду Kubernetes, такую как [Google Kubernetes Engine](https://cloud.google.com/kubernetes-engine/) или [Amazon EKS](https://aws.amazon.com/eks/).
Если просто ищете надёжный оркестратор, простой в поддержке и расширяемый, почему бы не попробовать Nomad? Возможно, вы удивитесь, как далеко это вас заведёт.
Если Kubernetes сравнить с машиной, Nomad будет скутером. Иногда вам нужно одно, а иногда другое. Оба имеют право на существование. | https://habr.com/ru/post/445030/ | null | ru | null |
# Визуализация статических и динамических сетей на R, часть 1
Очень многие системы и явления представимы в виде сетей, т.е. набора объектов и связей между ними. Сеть — не только абстракция, но и наглядный инструмент визуализации данных. Можно отобразить важность того или иного объекта, вес каждой связи, указать ключевые группы элементов, выделить их и подчеркнуть связи между ними. Главная задача визуализации — подать ключевую информацию о свойствах системы или явления максимально легким для восприятия способом. В идеальном случае анализ системы и визуализацию его результатов можно сделать в рамках одного инструмента. R с его обширным набором пакетов позволяет это.
#### Введение: визуализация сетей
Главное при проектировании визуализации сети — цель, которую нужно достичь. Какие структурные свойства мы хотели бы выделить?
Карты сетей — далеко не единственный инструмент визуализации графов — в некоторых случаях более предпочтительны другие форматы представления сетей, даже простые графики ключевых свойств.
В картах сетей, как и в других форматах визуализации, есть несколько ключевых настроек, влияющих на конечный результат. Главные — цвет, размер, форма и взаимное расположение.
Современные представления графов оптимизируют исходя из требований производительности и эстетических соображений. В частности, нужно минимизировать наложение и пересечение ребер, установить одинаковую длину ребер в графе.
#### Формат данных, размер и подготовка
В этом руководстве мы в основном будем работать с двумя небольшими массивами данных. Оба содержат информацию о средствах массовой информации. Один содержит сеть гиперссылок и упоминаний в новостных ресурсах. Другой — сеть ссылок между объектами и потребителями массовой информации. Хотя данных в примерах немного, многие идеи сгенерированных визуализаций можно распространить на средние и большие сети. По этой же причине мы редко будем использовать визуальные средства, например, форму символов-вершин: их практически невозможно различить в больших графах. Более того, при отображении очень больших сетей можно даже скрыть ребра, поскольку нужно сосредоточиться на выявлении и отображении групп вершин. Вообще говоря, размер сетей, которые можно визуализировать с помощью R, ограничен только объемом оперативной памяти вашей машины. Но следует подчеркнуть, что во многих случаях визуализация больших сетей в виде гигантского помпона куда менее полезна, чем графики с ключевыми свойствами графа.
В этом руководстве используются несколько ключевых пакетов, которые нужно установить, прежде чем продолжить. Будут упомянуты еще несколько библиотек, но они необязательны, и их можно пропустить. Будут использованы следующие основные библиотеки — [igraph](http://igraph.org/) (поддерживается [Габором Царди](http://gaborcsardi.org/) и [Тамасом Непушем](http://hal.elte.hu/~nepusz/)), [sna](http://cran.r-project.org/web/packages/sna/), [network](http://cran.r-project.org/web/packages/network/) (поддерживается [Картером Баттсом](http://erzuli.ss.uci.edu/~buttsc/) и [командой Statnet](http://statnet.org/)) и [ndtv](http://cran.r-project.org/web/packages/ndtv/) (поддерживается [Скаем Бендер-деМолль](http://skyeome.net/wordpress/)).
```
install.packages("igraph")
install.packages("network")
install.packages("sna")
install.packages("ndtv")
```
#### Набор данных 1: список ребер
Первый набор данных, с которым предстоит работать, состоит из двух файлов: «Media-Example-NODES.csv» и «Media-Example-EDGES.csv» (скачать можно [здесь](http://www.kateto.net/wordpress/wp-content/uploads/2015/06/Polnet2015.zip)).
```
nodes <- read.csv("Dataset1-Media-Example-NODES.csv", header=T, as.is=T)
links <- read.csv("Dataset1-Media-Example-EDGES.csv", header=T, as.is=T)
```
Исследуем данные:
```
head(nodes)
head(links)
nrow(nodes); length(unique(nodes$id))
nrow(links); nrow(unique(links[,c("from", "to")]))
```
Обратите внимание, что ребер больше, чем уникальных комбинаций «from»-«to». Это значит, что в данных есть случаи, когда между двумя вершинами более одной связи. Мы свернем все ребра одного типа между двумя узлами, просуммировав их веса с помощью функции `aggregate()` по «from», «to» и «type»:
```
links <- aggregate(links[,3], links[,-3], sum)
links <- links[order(links$from, links$to),]
colnames(links)[4] <- "weight"
rownames(links) <- NULL
```
#### Набор данных 2: матрица
```
nodes2 <- read.csv("Dataset2-Media-User-Example-NODES.csv", header=T, as.is=T)
links2 <- read.csv("Dataset2-Media-User-Example-EDGES.csv", header=T, row.names=1)
```
Исследуем данные:
```
head(nodes2)
head(links2)
```
Можно убедиться, что links2 — матрица сопряжения для двусторонней сети:
```
links2 <- as.matrix(links2)
dim(links2)
dim(nodes2)
```
#### Визуализация сетей: первые шаги с *igraph*
Начнем с превращения исходных данных в сеть [igraph](http://igraph.org/). Для этого используем функцию igraph graph.data.frame, которая принимает на вход два блока данных: d и vertices.
* **d** описывает ребра сети. В первых двух колонках содержатся идентификаторы начальной и конечной вершины для каждого ребра. В следующих колонках находятся параметры ребра (вес, тип, метка, другое).
* **vertices** начинается с колонки идентификаторов вершин. Все следующие колонки интерпретируются как параметры вершины.
```
library(igraph)
net <- graph.data.frame(links, nodes, directed=T)
net
```
```
## IGRAPH DNW- 17 49 --
## + attr: name (v/c), media (v/c), media.type (v/n), type.label
## (v/c), audience.size (v/n), type (e/c), weight (e/n)
```
Описание объекта igraph начинается с четырех букв:
1. D или U — для направленного или ненаправленного графа соответственно.
2. N — для именованного графа (где у узлов есть атрибут `name`).
3. W — для взвешенного графа (где у связей есть атрибут `weight`).
4. B — для двустороннего графа (где у узлов есть атрибут `type`).
Следующие два числа (17 49) указывают количество вершин и ребер в графе. В описании также приводятся свойства вершин и ребер, например:
* `(g/c)` — свойство-строка на уровне графа
* `(v/c)` — свойство-строка на уровне вершины
* `(e/n)` — свойство-число на уровне ребра
Также легко получить доступ к вершинам, ребрам и их атрибутам:
```
E(net) # Ребра объекта "net"
V(net) # Вершины объекта "net"
E(net)$type # Свойство ребра "type"
V(net)$media # Свойство вершины "media"
# Можно работать с матрицей сети и напрямую:
net[1,]
net[5,7]
```
Теперь, когда есть сеть igraph, можно сделать первую попытку ее построить.
```
plot(net) # некрасивая картинка!
```
Получилось не слишком красиво. Давайте начнем улучшать картинку, убрав циклы в графе.
```
net <- simplify(net, remove.multiple = F, remove.loops = T)
```
Вы можете отметить, что можно было использовать `simplify`, чтобы свернуть несколько ребер в одно, суммируя их веса с помощью команды типа `simplify(net, edge.attr.comb=list(Weight="sum","ignore"))`. Проблема в том, что при совмещении не учитывается тип ребра (в наших данных «hyperlinks» — ссылки и «mentions» — упоминания).
Давайте также уменьшим размер стрелок и уберем метки (установив их в `NA`):
```
plot(net, edge.arrow.size=.4,vertex.label=NA)
```
В части 2: шрифты и цвета в графиках R. | https://habr.com/ru/post/262079/ | null | ru | null |
# Мега-Учебник Flask, Часть XIII: I18n и L10n (издание 2018)
### *Miguel Grinberg*
---
 [Туда](https://habrahabr.ru/post/349604/) [Сюда](https://habrahabr.ru/post/350626/) 
Это тринадцатая часть серии Мега-Учебник Flask, в которой я расскажу вам, как реализовать поддержку нескольких языков для вашего приложения. В рамках этой работы вы также узнаете о создании собственных расширений CLI для flask.
Для справки ниже приведен список статей этой серии.
**Оглавление**
* [**Глава 1: Привет, мир!**](https://habrahabr.ru/post/346306/)
* [**Глава 2: Шаблоны**](https://habrahabr.ru/post/346340/)
* [**Глава 3: Веб-формы**](https://habrahabr.ru/post/346342/)
* [**Глава 4: База данных**](https://habrahabr.ru/post/346344/)
* [**Глава 5: Пользовательские логины**](https://habrahabr.ru/post/346346/)
* [**Глава 6: Страница профиля и аватары**](https://habrahabr.ru/post/346348/)
* [**Глава 7: Обработка ошибок**](https://habrahabr.ru/post/346880/)
* [**Глава 8: Подписчики, контакты и друзья**](https://habrahabr.ru/post/347450/)
* [**Глава 9: Разбивка на страницы**](https://habrahabr.ru/post/347926/)
* [**Глава 10: Поддержка электронной почты**](https://habrahabr.ru/post/348566/)
* [**Глава 11: Реконструкция**](https://habrahabr.ru/post/349060/)
* [**Глава 12: Дата и время**](https://habrahabr.ru/post/349604/)
* [**Глава 13: I18n и L10n**](https://habrahabr.ru/post/350148/)(Эта статья)
* [**Глава 14: Ajax**](https://habrahabr.ru/post/350626/)
* [**Глава 15: Улучшение структуры приложения**](https://habrahabr.ru/post/351218/)
* [**Глава 16: Полнотекстовый поиск**](https://habrahabr.ru/post/351900/)
* [**Глава 17: Развертывание в Linux**](https://habrahabr.ru/post/352266/)
* [**Глава 18: Развертывание на Heroku**](https://habrahabr.ru/post/352830/)
* [**Глава 19: Развертывание на Docker контейнерах**](https://habrahabr.ru/post/353234/)
* [**Глава 20: Магия JavaScript**](https://habrahabr.ru/post/353804/)
* [**Глава 21: Уведомления пользователей**](https://habrahabr.ru/post/354322/)
* [**Глава 22: Фоновые задачи**](https://habrahabr.ru/post/354752/)
* [**Глава 23: Интерфейсы прикладного программирования (API)**](https://habr.com/ru/post/358152/)
*Примечание 1: Если вы ищете старые версии данного курса, это [здесь](https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world-legacy "здесь").*
*Примечание 2: Если вдруг Вы захотели бы выступить в поддержку моей(Мигеля) работы, или просто не имеете терпения дожидаться статьи неделю, я (Мигель Гринберг)предлагаю полную версию данного руководства(на английском языке) в виде электронной книги или видео. Для получения более подробной информации посетите [learn.miguelgrinberg.com](http://learn.miguelgrinberg.com "learn.miguelgrinberg.com").*
Эта глава посвящена интернационализации и локализации, сокращенно I18n и L10n. Чтобы сделать приложение доступным для людей, не владеющих английским языком, будет реализован процесс перевода, который, с помощью сервисов-переводчиков языка, позволит мне предложить пользователям язык-приложения на выбор.
*Ссылки GitHub для этой главы:* [Browse](https://github.com/miguelgrinberg/microblog/tree/v0.13), [Zip](https://github.com/miguelgrinberg/microblog/archive/v0.13.zip), [Diff](https://github.com/miguelgrinberg/microblog/compare/v0.12...v0.13).
Введение в Flask-Babel
----------------------
Как вы, наверное, уже догадались, существует расширение Flask, которое упрощает работу с переводами. Расширение называется [Flask-Babel](https://pythonhosted.org/Flask-Babel/) и устанавливается с помощью pip:
```
(venv) $ pip install flask-babel
```
Flask-Babel инициализируется, как и большинство других расширений Flask:
> *`app/__init__.py`*: Инициализация Flask-Babel.
```
# ...
from flask_babel import Babel
app = Flask(__name__)
# ...
babel = Babel(app)
```
В качестве примера, я расскажу вам, как перевести приложение на испанский язык, поскольку я, случается, говорю на этом языке. Я мог бы также работать с переводчиками, которые знают другие языки и поддерживают их. Чтобы отслеживать список поддерживаемых языков, следует добавить переменную конфигурации:
> *config.py*: Список поддерживаемых языков.
```
class Config(object):
# ...
LANGUAGES = ['en', 'es']
```
Я использую двухбуквенные коды языков для этого приложения, но если вам нужно быть более конкретным, можно добавить код страны. Например, вы можете использовать `en-US`, `en-GB` и `en-CA` для поддержки английского с разными диалектами США, Великобритания или Канада.
Экземпляр `Babel` предоставляет декоратор `localeselector`. Декорированная функция вызывается для каждого запроса, чтобы выбрать перевод языка для использования:
> *`app/__init__.py`*: Выбор предпочтительного языка.
```
from flask import request
# ...
@babel.localeselector
def get_locale():
return request.accept_languages.best_match(app.config['LANGUAGES'])
```
Здесь я использую атрибут объекта Flask `request`, называемый `accept_languages`. Этот объект обеспечивает интерфейс высокого уровня для работы с заголовком [Accept-Language](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Language), отправляемым клиентами с запросом. Этот заголовок указывает язык клиента и языковые предпочтения в виде средневзвешенного списка. Содержимое этого заголовка можно настроить на странице настроек браузера, при этом по умолчанию обычно импортируются из языковых настроек в операционной системе компьютера. Большинство людей даже не знают, что такая настройка существует, но это полезно, поскольку пользователи могут предоставить список предпочтительных языков, каждый из которых имеет вес. Если вам интересно, вот пример сложного заголовка `Accept-Languages`:
```
Accept-Language: da, en-gb;q=0.8, en;q=0.7
```
Видим, что Датский (`da`) является предпочтительным языком (значение веса по умолчанию 1,0), а затем Британский английский (`en-gb`) с весом 0,8, и в качестве последнего варианта Общий Английский (`en`) с весом 0,7.
Чтобы выбрать лучший язык, вам нужно сравнить список языков, запрашиваемых клиентом, с языками, которые поддерживает приложение, и, используя предоставленные клиентом веса, найти лучший язык. Возможно вам кажется эта логика слишком сложной, но все это инкапсулируется в метод `best_match()`, который принимает список языков, предлагаемых приложением в качестве аргумента и возвращает лучший выбор.
Маркировка текстов для перевода в исходном коде Python
------------------------------------------------------
Рано обрадовались. Теперь о грустном. Обычный рабочий процесс при создании приложения на нескольких языках заключается в разметке всех текстов, требующие перевода в исходном коде. После того, как тексты будут помечены, Flask-Babel будет сканировать все файлы и извлекать эти тексты в отдельный файл перевода, используя инструмент [gettext](https://www.gnu.org/software/gettext/). К сожалению, это утомительная задача, которая должна быть выполнена для перевода.
Я собираюсь показать вам несколько примеров этой маркировки, но получить полный набор изменений вы можете из [пакета](https://github.com/miguelgrinberg/microblog/tree/v0.13) для этой главы или репозитория GitHub.
Способ, которым тексты помечены для перевода, заключается в обертывании их в вызов функции, которая вызывается как соглашение `_()`, просто подчеркивание. Простейшими случаями являются те, где литеральные строки появляются в исходном коде. Ниже приведен пример оператора flash()`:
```
from flask_babel import _
# ...
flash(_('Your post is now live!'))
```
Идея заключается в том, что функция `_()` переносит текст на базовый язык (в данном случае английский). Она будет использовать лучший по ее мнению язык, выбранный функцией `get_locale`, декорированной функцией `localeselector`, чтобы найти правильный перевод для данного клиента. Затем функция `_()` вернет переведенный текст, который в этом случае станет аргументом для `flash()`.
К сожалению, не все случаи так просты. Рассмотрим этот другой вызов `flash()` из приложения:
```
flash('User {} not found.'.format(username))
```
Этот текст имеет динамический компонент, который вставлен в середине статического текста. Функция `_()` имеет синтаксис, поддерживающий этот тип текстов, но основанный на старом синтаксисе подстановки строк:
```
flash(_('User %(username)s not found.', username=username))
```
Есть еще более трудный случай. Некоторые строковые литералы назначаются вне запроса, как правило, когда приложение запускается, поэтому в то время, когда эти тексты оцениваются, нет способа узнать, какой язык использовать. Примером этого являются метки, связанные с полями формы. Единственное решение для обработки этих текстов — найти способ отложить оценку строки до ее использования, которая будет находиться под фактическим запросом. Flask-Babel предоставляет версию (*lazy evaluation*) отложенного вычисления `_()`, которая называется `lazy_gettext()`:
```
from flask_babel import lazy_gettext as _l
class LoginForm(FlaskForm):
username = StringField(_l('Username'), validators=[DataRequired()])
# ...
```
Здесь я импортирую альтернативную функцию перевода и переименовываю ее в `_l ()`, так что она была схожа по названию с оригинальной `_()`. Эта новая функция переносит текст в специальный объект, содержащий метод перевода, который состоится позже, в момент использования строки.
Расширение Flask-Login высвечивает сообщение при каждой переадресации пользователя на страницу входа. Это сообщение написано на английском языке и формируется в умолчаниях самого расширения. Чтобы убедиться, что это сообщение также переведено, я собираюсь переопределить сообщение по умолчанию и предоставить другой вариант декорированный функцией `_l()` для отложенного вызова:
```
login = LoginManager(app)
login.login_view = 'login'
login.login_message = _l('Please log in to access this page.')
```
Разметка текстов для перевода в шаблонах
----------------------------------------
В предыдущем разделе вы видели, как разметить переводимые тексты в исходном коде модулей Python, но это только часть процесса, так как файлы шаблонов также содержат текст. Функция `_()` также доступна в шаблонах, поэтому процесс сильно похож. Например, рассмотрим этот фрагмент HTML из *404.html*:
```
File Not Found
==============
```
Версия с поддержкой перевода:
```
{{ \_('File Not Found') }}
==========================
```
Обратите внимание, что здесь, помимо обертывания текста с помощью `_()`, необходимо добавить `{{...}}`, чтобы заставить `_()` вычислять вместо того, чтобы считаться литералом в шаблоне.
Для более сложных фраз, содержащих динамические компоненты, можно использовать аргументы:
```
{{ \_('Hi, %(username)s!', username=current\_user.username) }}
==============================================================
```
В файле *`_post.html`* есть особенно сложный случай, который заставил меня разбираться:
```
{% set user_link %}
[{{ post.author.username }}]({{ url_for('user', username=post.author.username) }})
{% endset %}
{{ _('%(username)s said %(when)s',
username=user_link, when=moment(post.timestamp).fromNow()) }}
```
Проблема здесь заключается в том, что я хотел, чтобы имя пользователя было ссылкой, указывающей на страницу профиля пользователя, а не только именем, так что мне пришлось создать промежуточную переменную под названием `user_link` с помощью `set` и `endset` директивы шаблонов, а затем передать это как аргумент функции перевода.
Как я уже упоминал выше, вы можете [скачать](https://github.com/miguelgrinberg/microblog/tree/v0.13) версию приложения со всеми переводимыми текстами в исходном коде Python и шаблонах.
Извлечение текста для перевода
------------------------------
После того, как у вас есть приложение со всеми `_()` и`_l()` на своих местах, вы можете использовать команду `pybabel`, чтобы извлечь их в файл *a.pot*, что означает *[portable object template](https://ru.wikipedia.org/wiki/Gettext)*. Это текстовый файл, содержащий все тексты, которые были помечены как нуждающиеся в переводе. Цель этого файла состоит в том, чтобы служить шаблоном для создания файлов перевода на любой другой язык.
Для процесса извлечения требуется небольшой файл конфигурации, который сообщает `pybabel`, какие файлы следует сканировать для переводимых текстов. Ниже вы можете увидеть *babel.cfg*, который я создал для этого приложения:
> *babel.cfg*: PyBabel configuration file.
```
[python: app/**.py]
[jinja2: app/templates/**.html]
extensions=jinja2.ext.autoescape,jinja2.ext.with_
```
Первые две строки определяют имена файлов шаблонов Python и Jinja2 соответственно. Третья строка определяет два расширения, предоставляемые движком шаблонов Jinja2, которые помогают Flask-Babel правильно анализировать файлы шаблонов.
Чтобы извлечь все тексты в *.pot* файл, вы можете использовать следующую команду:
```
(venv) $ pybabel extract -F babel.cfg -k _l -o messages.pot .
```
Команда `pybabel extract` считывает файл конфигурации, указанный в параметре `-F`, а затем сканирует все файлы *py* и *html* в каталогах, соответствующих настроенным источникам, начиная с каталога, указанного в команде (текущий каталог или `.` в этом случае.) По умолчанию, `pybabel` будем искать `_()` как текстовый маркер, но я также использовал *lazy* вариант, который я импортировал как `_l()`, так что мне нужно сказать об этом инструменту поиска опцией `-k` `_l`. Параметр `-o` указывает имя выходного файла.
Должен отметить, что *messages.pot* не является файлом, который должен быть включен в проект. Это файл, который можно легко регенерировать в любое время, просто выполнив команду выше снова. Таким образом, нет необходимости передавать этот файл в систему управления версиями.
Создание Language Catalog
-------------------------
Следующим шагом в процессе является создание перевода для каждого языка, который будет поддерживаться в дополнение к базовому, который в данном случае английский. Я сказал, что собираюсь начать с добавления испанского языка (код языка `es`), так что команда, которая делает это:
```
(venv) $ pybabel init -i messages.pot -d app/translations -l es
creating catalog app/translations/es/LC_MESSAGES/messages.po based on messages.pot
```
Команда `pybabel init` принимает файл `messages.pot` в качестве входных данных и создает новый каталог для определенного языка, указанного в параметре `-l` в каталог, указанный в параметре `-d`. Я буду сохранять все переводы в директории *app/translations*, потому что там Flask-Babel будет искать файлы перевода по умолчанию. Команда создаст подкаталог `es` внутри этого каталога для данных на испанском. В частности, там появится новый файл с названием *app/translations/es/LC\_MESSAGES/messages.po*. То есть там, где переводы должны быть сделаны.
Если вы хотите поддержать другие языки, то повторите вышеуказанную команду с каждым из кодов языка. Таким образом, что бы каждый язык получил свой собственный репозитарий с файлом *messages.po*.
Этот *messages.po*-файл, созданный в каждом языковом репозитории, использует формат, который является стандартом де-факто для языковых переводов, Формат, используемый утилитой [gettext](http://www.gnu.org/software/gettext/). Вот несколько строк начала испанского messages.po:
```
# Spanish translations for PROJECT.
# Copyright (C) 2017 ORGANIZATION
# This file is distributed under the same license as the PROJECT project.
# FIRST AUTHOR , 2017.
#
msgid ""
msgstr ""
"Project-Id-Version: PROJECT VERSION\n"
"Report-Msgid-Bugs-To: EMAIL@ADDRESS\n"
"POT-Creation-Date: 2017-09-29 23:23-0700\n"
"PO-Revision-Date: 2017-09-29 23:25-0700\n"
"Last-Translator: FULL NAME \n"
"Language: es\n"
"Language-Team: es \n"
"Plural-Forms: nplurals=2; plural=(n != 1)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.5.1\n"
#: app/email.py:21
msgid "[Microblog] Reset Your Password"
msgstr ""
#: app/forms.py:12 app/forms.py:19 app/forms.py:50
msgid "Username"
msgstr ""
#: app/forms.py:13 app/forms.py:21 app/forms.py:43
msgid "Password"
msgstr ""
```
Если пропустить заголовок, то видно, что ниже приведен список строк, которые были извлечены из вызовов `_()` и `_l()`. Для каждого текста вы получаете ссылку на расположение текста в приложении. Затем строка `msgid` содержит текст на базовом языке, а следующая строка `msgstr` содержит пустую строку. Эти пустые строки должны быть отредактированы, чтобы иметь текст на целевом языке.
Есть [много приложений](https://localise.biz/free/poeditor), которые работают с переводом `.po`-файлов. Если вы чувствуете себя комфортно при редактировании текстового файла, то этого достаточно, но если вы работаете с большим проектом, то может быть рекомендовано работать со специализированным редактором. Наиболее популярным приложением для перевода является `poedit` с открытым исходным кодом, который доступен для всех основных операционных систем. Если вы знакомы с `VIM`, то `po.vim` плагин дает некоторые ключевые отображения, которые делают работу с этими файлами проще.
Ниже вы можете увидеть часть испанской версии *messages.po* после того, как я добавил перевод:
```
#: app/email.py:21
msgid "[Microblog] Reset Your Password"
msgstr "[Microblog] Nueva Contraseña"
#: app/forms.py:12 app/forms.py:19 app/forms.py:50
msgid "Username"
msgstr "Nombre de usuario"
#: app/forms.py:13 app/forms.py:21 app/forms.py:43
msgid "Password"
msgstr "Contraseña"
```
[Пакет загрузки](https://github.com/miguelgrinberg/microblog/tree/v0.13) для этой главы также содержит этот файл, так что вам не придется беспокоиться об этой части приложения.
Файл *messages.po* -это своего рода файл-источник для переводов. Если вы хотите начать использовать эти переведенные тексты, то файл должен быть скомпилирован в формат, который эффективен для использования приложением во время выполнения. Чтобы собрать все переводы для приложения, вы можете использовать команду компиляции `pybabel compile` следующим образом:
```
(venv) $ pybabel compile -d app/translations
compiling catalog app/translations/es/LC_MESSAGES/messages.po to
app/translations/es/LC_MESSAGES/messages.mo
```
Эта операция добавляет файл *messages.mo* рядом с *messages.po* в каждом языковом репозитории. Файл *.mo* — это файл, который Flask-Babel будет использовать для загрузки переводов в приложение.
После создания *messages.mo* для испанского или любых других языков, добавленных в проект, эти языки готовы к использованию в приложении. Если вы хотите увидеть, как выглядит приложение на испанском языке, Вы можете изменить конфигурацию языка в веб-браузере, чтобы испанский язык был предпочтительным языком. Для Chrome это расширенная часть в настройках:
Если вы предпочитаете не изменять настройки браузера, другой альтернативой является принудительное использование языка, заставляя функцию `localeselector` всегда возвращать один и тот же. Для испанского это выглядит так:
> *`app/__init__.py`*: Выбор испанского ( директивно).
```
@babel.localeselector
def get_locale():
# return request.accept_languages.best_match(app.config['LANGUAGES'])
return 'es'
```
Запуск приложения в браузере, настроенном на испанский язык, или в случае принудительного присвоения значения `es` функции `localeselector`, заставит все тексты появляться на испанском языке в приложении.
Обновление переводов
--------------------
Одна из распространенных ситуаций при работе с переводами заключается в том, что вы можете начать использовать файл перевода, даже если он неполный. Это совершенно нормально, можно компилировать неполные файлы *messages.po*. В этом случае будут использоваться po-файлы и любые доступные переводы, а отсутствующие будут использовать базовый язык. Затем можно продолжить работу над переводами и выполнить компиляцию для обновления *messages.mo*.
Другой распространенный случай возникает, если вы пропустили некоторые тексты при добавлении `_()` обертки. В этом случае вы увидите, что те тексты, которые вы пропустили, останутся на английском языке, потому что Flask-Babel ничего о них не знает. В этом случае необходимо добавить `_()` или `_l()` обертки при обнаружении текстов, которые не имеют их, а затем выполнить процедуру обновления, которая включает в себя два шага:
```
(venv) $ pybabel extract -F babel.cfg -k _l -o messages.pot .
(venv) $ pybabel update -i messages.pot -d app/translations
```
Команда `extract` идентична той, которую я описывал ранее, но теперь она будет генерировать новую версию *messages.pot* со всеми предыдущими текстами плюс что-нибудь новое, которое вы недавно обернули с помощью `_()` или `_l()`. Вызов обновления принимает новый файл *messages.pot* и объединяет его во все файлы *messages.po*, связанные с проектом. Это будет интеллектуальное слияние, в котором любые существующие тексты будут оставлены в покое, в то время как будут затронуты только записи, которые были добавлены или удалены в *messages.pot*.
После обновления *messages.po* вы можете продолжить и перевести все новые тесты, а затем скомпилировать сообщения еще раз, чтобы сделать их доступными для приложения.
Перевод дат и времени
---------------------
Теперь у меня есть полный испанский перевод для всех текстов в коде Python и шаблонах. Но если вы запустите приложение на испанском языке и будете хорошим наблюдателем, то вы заметите, что есть еще несколько мест, которые остались на английском языке. Я имею в виду временные метки, созданные Flask-Moment и moment.js, которые, очевидно, не были включены в перевод, потому что ни один из текстов, созданных этими пакетами, не является частью исходного кода или шаблона приложения.
moment.js поддерживает локализацию и интернационализацию, поэтому все, что мне нужно сделать, это настроить правильный язык. Flask-Babel возвращает выбранный язык и локаль для такого случая с помощью функции `get_locale()`, поэтому я собираюсь добавить локаль в объект `g`, чтобы получить доступ к нему из базового шаблона:
> *`app/routes.py`*: Сохраняем выбранный язык в flask.g.
```
# ...
from flask import g
from flask_babel import get_locale
# ...
@app.before_request
def before_request():
# ...
g.locale = str(get_locale())
```
Функция `get_locale()` из Flask-Babel возвращает объект, но я просто хочу иметь код языка, который может быть получен путем преобразования объекта в строку. Теперь, когда у меня есть `g.locale`, я могу получить к нему доступ из базового шаблона, чтобы настроить *moment.js* с правильным языком:
> *app/templates/base.html*: Устанавливаем языковой стандарт для moment.js.
```
...
{% block scripts %}
{{ super() }}
{{ moment.include_moment() }}
{{ moment.lang(g.locale) }}
{% endblock %}
```
И теперь все даты и время должны появляться на том же языке, что и текст. Ниже вы можете увидеть, как приложение выглядит на испанском языке:
На этом этапе все тексты, кроме тех, которые были предоставлены пользователем в сообщениях блога или описаниях профиля, должны быть переведены на другие языки.
Усовершенствования для командной строки
---------------------------------------
Вы, вероятно, согласитесь со мной, что команды `pybabel` слегка длинны и их трудно запомнить. Я собираюсь использовать эту возможность, чтобы показать вам, как вы можете создавать пользовательские команды, интегрированные с командой flask. До сих пор вы видели использование `flask run`, `flask shell`, и несколько `flask db` суб-команды в Flask-Migrate. На самом деле легко добавить специфичные для приложения команды в flask. Итак, теперь я собираюсь создать несколько простых команд, которые запускают команды `pybabel` со всеми аргументами, которые специфичны для этого приложения. Команды, которые я собираюсь добавить:
* `flask translate init LANG` добавить новый язык
* `flask translate update` обновить все языковые репозитории
* `flask translate compile` для компиляции всех языковых репозиториев
`babel export` не будет командой, потому что генерация файла *messages.pot* всегда является предварительным условием для выполнения команд `init` или `update`. Поэтому реализация этих команд будет генерировать файл шаблона перевода как временный файл.
Flask полагается на [Click](http://click.pocoo.org/5/) для всех своих операций с командной строкой. Команды, такие как `translate`, которые являются корнем для нескольких подкоманд, создаются с помощью декоратора `app.cli.group()`. Я собираюсь поместить эти команды в новый модуль под названием *app/cli.py*:
> *app/cli.py*: Перевести группу команд.
```
from app import app
@app.cli.group()
def translate():
"""Translation and localization commands."""
pass
```
Имя команды происходит от имени декорированной функции, а справочное сообщение поступает из docstring. Поскольку это родительская команда, которая существует только для обеспечения базы для подкоманд, самой функции ничего не нужно делать.
`Update` -обновление и `compile` -компиляцию легко реализовать, поскольку они не принимают никаких аргументов:
> *app/cli.py*: Обновление и компиляция вложенных команд.
```
import os
# ...
@translate.command()
def update():
"""Update all languages."""
if os.system('pybabel extract -F babel.cfg -k _l -o messages.pot .'):
raise RuntimeError('extract command failed')
if os.system('pybabel update -i messages.pot -d app/translations'):
raise RuntimeError('update command failed')
os.remove('messages.pot')
@translate.command()
def compile():
"""Compile all languages."""
if os.system('pybabel compile -d app/translations'):
raise RuntimeError('compile command failed')
```
Обратите внимание, что декоратор из этих функций является производным от родительской функции `translate`. Это может показаться запутанным, так как `translate()` — это функция, но это стандартный способ, которым Click создает группы команд. Так же, как и в функции `translate()`, *docstrings* -строки документации для этих функций используются в качестве сообщения справки в выводе *--help*.
Возможно вы заметили, что во всех командах, которые я запускаю есть проверка возвращаемого значения на ноль. Это означает, что команда выполнена и не вернула никакой ошибки. Если в команде ошибка, то я поднимаю `RuntimeError`, что приводит к остановке скрипта. Функция `update()` объединяет шаги извлечения и обновления в одной команде, и если все прошло успешно, она удаляет файл *messages.pot* после завершения обновления, так как этот файл может быть легко регенерирован при необходимости еще раз.
Команда `init` принимает новый код языка в качестве аргумента. Вот реализация:
> *app/cli.py*: **Init** — sub-команда инициализации.
```
import click
@translate.command()
@click.argument('lang')
def init(lang):
"""Initialize a new language."""
if os.system('pybabel extract -F babel.cfg -k _l -o messages.pot .'):
raise RuntimeError('extract command failed')
if os.system(
'pybabel init -i messages.pot -d app/translations -l ' + lang):
raise RuntimeError('init command failed')
os.remove('messages.pot')
```
Эта команда использует декоратор `@click.argument` для определения кода языка. Click передает значение, указанное в команде функции обработчика в качестве аргумента, а затем я включаю аргумент в команду `init`.
Последним шагом для включения этих команд является их импорт, чтобы команды регистрировались. Я решил сделать это в файле *microblog.py* в каталоге верхнего уровня:
> *microblog.py*: Регистрация команд командной строки.
```
from app import cli
```
Здесь единственное, что мне нужно сделать, это импортировать новый модуль *cli.py*, нет никакой необходимости делать что-либо с ним, так как импорт вызывает декораторы команды для запуска и регистрации команды.
В этот момент, запуск `flask --help` передаст команду `translate` в качестве опции. И `flask translate --help` отобразит вывод трех суб-команд, которые я определил:
```
(venv) $ flask translate --help
Usage: flask translate [OPTIONS] COMMAND [ARGS]...
Translation and localization commands.
Options:
--help Show this message and exit.
Commands:
compile Compile all languages.
init Initialize a new language.
update Update all languages.
```
Так что теперь, рабочий процесс гораздо проще и нет необходимости помнить длинные и сложные команды. Чтобы добавить новый язык, используйте:
```
(venv) $ flask translate init
```
Обновить все языки после внесения изменений в маркеры `_()` и `_l()` :
```
(venv) $ flask translate update
```
И компилировать все языки после обновления файлов перевода:
```
(venv) $ flask translate compile
```
 [Туда](https://habrahabr.ru/post/349604/) [Сюда](https://habrahabr.ru/post/350626/)  | https://habr.com/ru/post/350148/ | null | ru | null |
# Обработка Excel файлов с использованием Python
По работе пришлось столкнуться с задачей обработки xls файлов средствами python. Немного по гуглив, я натолкнулся на несколько библиотек, с помощью которых можно работать с файлами excel.
Библиотеки:
— xlrd – дает возможность читать файлы Excel
— xlwt – создание и заполнение файлов Excel
— xlutils – набор утилит для расширения возможности предыдущих двух библиотек
— pyExcelerator – также дает возможность работать с файлами Excel, но давно не обновлялась.
Для своей задачи я использовал первые три библиотеки.
Задача была разбита на несколько частей: чтение файла с расширением xls; создание нового и заполнение его; создание копии файла на основе входного файла; удаление необходимых строк в выходном файле.
#### Чтение входного файла
Эта задача не отличается высокой сложностью. Документация и примеры, идущие в комплекте с xlrd, помогли быстро решить ее.
Пример кода:
> `**import** **xlrd**
>
> rb = xlrd.open_workbook('d:/final.xls',formatting_info=True)
>
> sheet = rb.sheet_by_index(0)
>
> **for** rownum **in** range(sheet.nrows):
>
> row = sheet.row_values(rownum)
>
> **for** c_el **in** row:
>
> **print** c_el`
#### Создание нового файла и заполнение его
Эта задача оказалась не сложнее предыдущей. Документация и примеры помогли.
Пример кода:
> `**import** **xlwt**
>
> **from** **datetime** **import** datetime
>
>
>
> font0 = xlwt.Font()
>
> font0.name = 'Times New Roman'
>
> font0.colour_index = 2
>
> font0.bold = True
>
>
>
> style0 = xlwt.XFStyle()
>
> style0.font = font0
>
>
>
> style1 = xlwt.XFStyle()
>
> style1.num_format_str = 'D-MMM-YY'
>
>
>
> wb = xlwt.Workbook()
>
> ws = wb.add_sheet('A Test Sheet')
>
>
>
> ws.write(0, 0, 'Test', style0)
>
> ws.write(1, 0, datetime.now(), style1)
>
> ws.write(2, 0, 1)
>
> ws.write(2, 1, 1)
>
> ws.write(2, 2, xlwt.Formula("A3+B3"))
>
>
>
> wb.save('example.xls')`
#### Создание копии файла на основе входного файла
Эта задача может решаться двумя путями. Вариант первый: открываем на чтение входной файл, создаем новый файл и по циклу переписываем все данные с одного файла в другой. Такое решение не сложно реализовать, поэтому пример кода выкладывать нет смысла. Вариант второй: воспользоваться библиотекой xlutils. В данной библиотеке есть много чего интересного и полезного, но для нашей задачи будет интересен именно *xlutils.copy*.
И так, пример кода по созданию файла на основании входного с использованием xlutils.copy:
> `**import** **xlrd**
>
> **import** **xlwt**
>
> **from** **xlutils.copy** **import** copy
>
>
>
> rb = open_workbook('final.xls',on_demand=True,formatting_info=True)
>
> wb = copy(rb)
>
> wb.save("final\_complete.xls")`
Вот такой вот небольшой код получился. Для того чтобы он работал, обязательно должен стоять флаг **on\_demand=True**. Благодаря использованию флага **formatting\_info** выходной файл получается с такими же стилями оформления, как и входной. Для моей задачи это оказалась нужная опция.
#### Удаление строк по заданному условию
Для решения данной задачи было решено использовать фильтр. Один из вариантов — это переписывание из одного файла в другой, исключая те варианты, которые не выполняют заданное условие. Но тут есть одна загвоздка, если необходимо сохранить стиль оформление документа, то этот подход не подойдет (Если конечно вы заранее не знаете стиль оформления и можете задать его программно). Решение поставленной задачи было достигнуто посредством использования xlutils.filter. Задача: оставить в выходном Excel файле только те записи, которые содержатся в передаваемом списке.
Код, который решает данную задачу:
> `**from** **xlutils.filter** **import** GlobReader,BaseFilter,DirectoryWriter,process
>
>
>
> myfile='final2.xls'
>
> mydir='d:/'
>
>
>
> **class** **MyFilter**(BaseFilter):
>
>
>
> goodlist = None
>
>
>
> **def** \_\_init\_\_(self,elist):
>
> self.goodlist = goodlist
>
> self.wtw = 0
>
> self.wtc = 0
>
>
>
>
>
> **def** workbook(self, rdbook, wtbook_name):
>
> self.next.workbook(rdbook, 'filtered\_'+wtbook_name)
>
>
>
> **def** row(self, rdrowx, wtrowx):
>
> **pass**
>
>
>
> **def** cell(self, rdrowx, rdcolx, wtrowx, wtcolx):
>
> value = self.rdsheet.cell(rdrowx,rdcolx).value
>
> **if** value **in** self.goodlist:
>
> self.wtc=self.wtc+1
>
> self.next.row(rdrowx,wtrowx)
>
> **else**:
>
> **return**
>
> self.next.cell(rdrowx,rdcolx,self.wtc,wtcolx)
>
>
>
>
>
> data = """somedata1
>
> somedata2
>
> somedata3
>
> somedata4
>
> somedata5
>
> """
>
>
>
> goodlist = data.split("**\n**")
>
>
>
> process(GlobReader(os.path.join(mydir,myfile)),MyFilter(goodlist),DirectoryWriter(mydir))`
#### Заключение
Используя набор из трех библиотек, поставленные задачи были решены. Было замечено следующее: при наличии во входном Excel файле графических элементов (картинки и т.д) в выходной файл они не переносятся. Возможно изучив эти библиотеки можно будет решить и эту часть задачи.
#### Ссылки
[sourceforge.net/projects/pyexcelerator](http://sourceforge.net/projects/pyexcelerator/)
[www.python-excel.org](http://www.python-excel.org/) — на три первых библиотеки.
[groups.google.com/group/python-excel](http://groups.google.com/group/python-excel) — группа, в которой обсуждают использование библиотек xlrd, xlwt и xlutils.
~~P.S. Думаю было бы неплохо перенести данный пост в тематический блог.~~ | https://habr.com/ru/post/99923/ | null | ru | null |
# Умные погодные приложения с Flink SQL
Иногда требуется получать, маршрутизировать, преобразовывать, запрашивать и анализировать все данные о погоде в Соединенных Штатах - по мере появления этих данных. С FLaNK это довольно тривиальный процесс.
От Kafka до Kudu, для любой схемы и любого типа данных, без написания кода – потребуется всего два шага.
Вот эти схемы: их можно создавать, рекдактировать и сравнивать. Schema Registry поддерживает Swagger API, поэтому не будет проблем с настройкой CI/CD & DevOps пайплайнов:
Проверка данных по схеме с вашим уровнем допуска. Если вы хотите, чтобы были разрешены дополнительные поля, то вы это получите.
Далее эти данные готовы к анализу, например в BI инструменте Cloudera DataViz.
Быстро анализируйте свои данные в Apache Kudu с помощью Apache Hue и Apache Impala.
Давайте возьмем данные всех метеостанций США, даже если они представляют собой заархивированный каталог с множеством файлов XML.
NiFi флоу состоит из следующих процессоров:
1. **GenerateFlowFile -**иморт переодических обновлений о погоде от NOAA
2. **InvokeHTTP -**загрузка данных о погоде в ZIP архив
3. **CompressContent -**дкомпрессия ZIP
4. **UnpackContent -**экстракт файлов из ZIP архива
5. **\*RouteOnAttribute -**фильтрация только по аэропортам (${filename:startsWith('K')}). **опционально**.
6. **\*QueryRecord** - XMLReader в JsonRecordSetWriter. **Query**: SELECT \* FROM FLOWFILE WHERE NOT location LIKE '%Unknown%'. Нужно для удаления неидентифицированных локаций. **опционально**.
7. Экспорт в хранилище. Можно использовать PutKudu, PutORC, PutHDFS, PutHiveStreaming, PutHbaseRecord, PutDatabaseRecord, PublishKafkaRecord2\* или другие процессоры.
Все процессы можно легко автоматизировать в NiFi**.**
С помощью реестра схем доступны все данные вашей темы - даже в формате Avro.
Пример сообщения в Json:
`[ {`
`"credit" : "NOAA's National Weather Service",`
`"credit_URL" : "http://weather.gov/",`
`"image" : {`
`"url" : "http://weather.gov/images/xml_logo.gif",`
`"title" : "NOAA's National Weather Service",`
`"link" : "http://weather.gov"`
`},`
`"suggested_pickup" : "15 minutes after the hour",`
`"suggested_pickup_period" : 60,`
`"location" : "Stanley Municipal Airport, ND",`
`"station_id" : "K08D",`
`"latitude" : 48.3008,`
`"longitude" : -102.4064,`
`"observation_time" : "Last Updated on Jul 10 2020, 9:55 am CDT",`
`"observation_time_rfc822" : "Fri, 10 Jul 2020 09:55:00 -0500",`
`"weather" : "Fair",`
`"temperature_string" : "66.0 F (19.0 C)",`
`"temp_f" : 66.0,`
`"temp_c" : 19.0,`
`"relative_humidity" : 83,`
`"wind_string" : "South at 6.9 MPH (6 KT)",`
`"wind_dir" : "South",`
`"wind_degrees" : 180,`
`"wind_mph" : 6.9,`
`"wind_kt" : 6,`
`"pressure_in" : 30.03,`
`"dewpoint_string" : "60.8 F (16.0 C)",`
`"dewpoint_f" : 60.8,`
`"dewpoint_c" : 16.0,`
`"visibility_mi" : 10.0,`
`"icon_url_base" : "http://forecast.weather.gov/images/wtf/small/",`
`"two_day_history_url" : "http://www.weather.gov/data/obhistory/K08D.html",`
`"icon_url_name" : "skc.png",`
`"ob_url" : "http://www.weather.gov/data/METAR/K08D.1.txt",`
`"disclaimer_url" : "http://weather.gov/disclaimer.html",`
`"copyright_url" : "http://weather.gov/disclaimer.html",`
`"privacy_policy_url" : "http://weather.gov/notice.html"`
`} ]`
---
**Код**
Готовый скрипт: [**https://github.com/tspannhw/ApacheConAtHome2020/blob/main/scripts/setup.sh**](https://github.com/tspannhw/ApacheConAtHome2020/blob/main/scripts/setup.sh)
NiFi флоу:
[**https://github.com/tspannhw/ClouderaFlowManagementWorkshop/tree/main/flows**](https://github.com/tspannhw/ClouderaFlowManagementWorkshop/tree/main/flows)
**SQL**
| | |
| --- | --- |
| | INSERT INTO weathernj |
| | SELECT `location`, station\_id,latitude,longitude,observation\_time,weather, |
| | temperature\_string, temp\_f,temp\_c,relative\_humidity,wind\_string,wind\_dir,wind\_degrees,wind\_mph, |
| | wind\_kt, pressure\_in,dewpoint\_string,dewpoint\_f,dewpoint\_c |
| | FROM weather |
| | WHERE |
| | `location` is not null and `location` <> 'null' and trim(`location`) <> '' and `location` like '%NJ'; |
**Kafka Insert**
[**https://github.com/tspannhw/ApacheConAtHome2020/blob/main/flinksql/weathernj.sql**](https://github.com/tspannhw/ApacheConAtHome2020/blob/main/flinksql/weathernj.sql)
**Схемы**
[**https://github.com/tspannhw/ApacheConAtHome2020/blob/main/schemas/weathernj.avsc**](https://github.com/tspannhw/ApacheConAtHome2020/blob/main/schemas/weathernj.avsc)
[**https://github.com/tspannhw/ApacheConAtHome2020/blob/main/schemas/weather.avsc**](https://github.com/tspannhw/ApacheConAtHome2020/blob/main/schemas/weather.avsc)
**Пример вывода результата в Slack**
Location Cincinnati/Northern Kentucky International Airport, KY Station KCVG
Temperature: 49.0 F (9.4 C)
Humdity: 83
Wind East at 3.5 MPH (3 KT)
Overcast
Dewpoint 44.1 F (6.7 C)Observed at Tue, 27 Oct 2020 11:52:00 -0400---- tracking info ---- UUID: 2cb6bd67-148c-497d-badf-dfffb4906b89
Kafka offset: 0
Kafka Timestamp: 1603818351260
========================================================= | https://habr.com/ru/post/547050/ | null | ru | null |
# OAuth аутентификация в приложении Flask
Эта статья является бонусом к новому циклу статей [Flask Mega-Tutorial (2018)](https://habrahabr.ru/post/346346/).
Автор тот же Мигель Гринберг. Статья не новая, но не утратила своей актуальности.
[blog.miguelgrinberg.com](http://blog.miguelgrinberg.com "blog.miguelgrinberg.com")
Технологии OAuth уже больше 10 лет, и 99% процентов интернет-аудитории имеет аккаунт минимум на одном из ресурсов, поддерживающих OAuth. Кнопка «Войти через» есть почти на каждом ресурсе? Разберемся как это делается с применением микрофреймворка Flask.
Многие веб-сайты предоставляют пользователям возможность упрощенной регистрации в "один клик", используя стороннюю службу аутентификации, с использованием учетной записи пользователя, в каком либо из известных социальных сервисов. В моем старом курсе [Flask Mega-Tutorial](https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-v-user-logins-legacy) я показал вам, как использовать один из этих протоколов, называемый *OpenID*, ( который ныне почил с миром *прим. переводчика*).
В этой статье я хочу дать вам введение в протокол [OAuth](http://oauth.net/), который в наши дни заменил *OpenID* как предпочтительный сторонний механизм аутентификации. Я также покажу вам полное приложение *Flask*, которое реализует функции *Sign In with Facebook* и *Sign In with Twitter*. С этими двумя реализациями в качестве примера вам будет легко добавить любые другие провайдеры *OAuth*, которые могут вам понадобиться.
> *Прим. переводчика:* Еще пара ссылок о том как устроен OAuth [здесь](https://habrahabr.ru/post/145988/), [здесь](https://habrahabr.ru/company/mailru/blog/115163/)
Краткое введение в OAuth
------------------------
Лучший способ представить *OAuth* — перечислить список событий, которые происходят во время входа:
* **Обработка отправки формы.** Пользователь переходит на домашнюю страницу приложения, например *<http://www.example.com>*, и нажимает кнопку *"Sign In with Facebook"*, которая ссылается на маршрут приложения, например *<http://www.example.com/authorize/facebook>*.
* **Fetch Request Token (внутренний запрос).** Сервер получает запрос и отвечает перенаправлением на URL авторизации *OAuth Facebook*. Все провайдеры OAuth должны документировать URL-адрес для перенаправления пользователя.
+ В запросе передается *Consumer key* — «логин приложения», а сам запрос подписывается при помощи *Consumer secret* — «пароля приложения», что защищает его от подделки.
+ В ответ Provider генерирует и возвращает «заполненный мусором» токен, который называется Request Token.
* **Redirect to Authorization (через редирект в браузере).** Теперь пользователю предлагается войти в систему Facebook (если уже не вошел в систему). Затем предоставляется запрос об обмене информацией, когда пользователю необходимо предоставить разрешение Facebook для совместного использования запрошенной информации с исходным приложением. Все это делается на веб-сайте Facebook и является частной транзакцией между Facebook и пользователем, приложение не участвует.
* **Fetch Access Token (внутренний запрос).** После того, как пользователь принимает запрос на обмен информацией, Facebook перенаправляет обратно в приложение по предварительно настроенному URL-адресу обратного вызова, например *<http://www.example.com/callback/facebook>*. Строка запроса URL-адреса переадресации включает в себя код авторизации, который приложение может использовать для доступа к API Facebook от имени пользователя.
* **Call API (внутренний запрос).** Приложение использует API Facebook для получения информации о пользователе. Особый интерес представляет собой уникальный идентификатор пользователя ( *Shared Secret* ), который может использоваться для регистрации пользователя в базе данных приложения после регистрации пользователя для входа в систему.
Обмен между приложением и сторонней службой не является тривиальным, но для пользователя это чрезвычайно просто, поскольку все, что нужно пользователю, — это войти на сайт третьей стороны и дать разрешение на обмен информацией с помощью приложения.
В настоящее время используются две версии протокола OAuth, как в соответствии с описанным выше общим процессом, так и с некоторыми различиями в реализации. *OAuth 1.0a*, используемый Twitter, является самым сложным из двух. *OAuth 2*, используемый Facebook, представляет собой несовместимую пересмотренную версию протокола, которая устраняет большую часть сложности версии 1.0a, полагаясь на защищенный HTTP для шифрования.
Регистрация у провайдеров OAuth
-------------------------------
Прежде чем приложение сможет использовать стороннего поставщика OAuth, его необходимо зарегистрировать. Для Facebook и Twitter это делается на своих соответствующих сайтах разработчиков с созданием "app", которое представляет приложение для пользователей этих сайтов.
Создать приложение для Facebook вы можете здесь <https://developer.facebook.com>.
Жмем "НАЧАТЬ" и NEXT. По ходу заполняем различную информацию о себе.
Выбираем "Вход через Facebook"
Из списка возможных приложнеий выберите тип "WWW/Website".
Укажите URL-адрес приложения, который в случае его запуска на вашем компьютере будет `http://localhost:5000`.
Пример аутентификации OAuth
---------------------------
В следующих разделах я собираюсь описать относительно простое приложение Flask, которое реализует аутентификацию Facebook и Twitter.
Я покажу вам важные части приложения в статье, но полное приложение доступно в этом репозитории **GitHub**: <https://github.com/miguelgrinberg/flask-oauth-example>. В конце этой статьи я покажу вам инструкции по ее запуску.
User Model
----------
Пользователи в примере приложения хранятся в базе данных SQLAlchemy. Приложение использует расширение [Flask-SQLAlchemy](https://pythonhosted.org/Flask-SQLAlchemy/) для работы с базой данных и расширение [Flask-Login](https://flask-login.readthedocs.org/en/latest/) для отслеживания зарегистрированных пользователей.
```
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.login import LoginManager, UserMixin
db = SQLAlchemy(app)
lm = LoginManager(app)
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
social_id = db.Column(db.String(64), nullable=False, unique=True)
nickname = db.Column(db.String(64), nullable=False)
email = db.Column(db.String(64), nullable=True)
@lm.user_loader
def load_user(id):
return User.query.get(int(id))
```
В базе данных есть отдельная таблица для пользователей *users*, которая в дополнение к `id`, который является основным ключом, содержит три столбца:
* `social_id`: строка, которая определяет уникальный идентификатор из сторонней службы аутентификации, используемой для входа в систему.
* `nickname`: псевдоним для пользователя. Должен быть определен для всех пользователей и не обязательно должен быть уникальным.
* `email`: адрес электронной почты пользователя. Этот столбец не является обязательным.
Класс User наследуется от `UserMixin` из Flask-Login, который дает ему методы, требуемые этим расширением. Функция обратного вызова `user_loader`, также требуемая Flask-Login, загружает пользователя по его первичному ключу.
Реализация OAuth
----------------
Для Python существует несколько клиентских пакетов OAuth. В этом примере я решил использовать [Rauth](https://rauth.readthedocs.io/en/latest/). Однако, даже при использовании пакета OAuth существует множество аспектов проверки подлинности провайдерами, что затрудняет задачу.
Прежде всего, существуют две версии протокола OAuth, которые широко используются. Но даже среди провайдеров, использующих одну и ту же версию OAuth, есть много деталей, которые не являются частью спецификации и должны выполняться в соответствии с собственной документацией.
По этой причине я решил реализовать слой абстракции поверх Rauth, так что приложение Flask может быть написано в общем виде. Ниже представлен простой базовый класс, в котором будут написаны конкретные реализации провайдера:
```
class OAuthSignIn(object):
providers = None
def __init__(self, provider_name):
self.provider_name = provider_name
credentials = current_app.config['OAUTH_CREDENTIALS'][provider_name]
self.consumer_id = credentials['id']
self.consumer_secret = credentials['secret']
def authorize(self):
pass
def callback(self):
pass
def get_callback_url(self):
return url_for('oauth_callback', provider=self.provider_name,
_external=True)
@classmethod
def get_provider(self, provider_name):
if self.providers is None:
self.providers = {}
for provider_class in self.__subclasses__():
provider = provider_class()
self.providers[provider.provider_name] = provider
return self.providers[provider_name]
class FacebookSignIn(OAuthSignIn):
pass
class TwitterSignIn(OAuthSignIn):
pass
```
Базовый класс `OAuthSignIn` определяет структуру, которой должны следовать подклассы, реализующие услуги каждого провайдера. Конструктор инициализирует имя провайдера, а также идентификатор приложения и секретный код, назначенные им, и полученные из конфигурации. Ниже приведен пример конфигурации приложения (конечно, вам нужно будет заменить эти коды своим собственным):
```
app.config['OAUTH_CREDENTIALS'] = {
'facebook': {
'id': '470154729788964',
'secret': '010cc08bd4f51e34f3f3e684fbdea8a7'
},
'twitter': {
'id': '3RzWQclolxWZIMq5LJqzRZPTl',
'secret': 'm9TEd58DSEtRrZHpz2EjrV9AhsBRxKMo8m3kuIZj3zLwzwIimt'
}
}
```
На верхнем уровне есть два важных события, поддерживаемых этим классом, которые являются общими для всех провайдеров OAuth:
* Инициирование процесса аутентификации. Для этого приложение должно перенаправить на веб-сайт провайдера, чтобы позволить пользователю аутентифицироваться там. Это представлено методом`authorize()`.
* Как только аутентификация завершена, провайдер перенаправляет обратно приложение. Это обрабатывается методом `callback()`. Поскольку у провайдера нет прямого доступа к внутренним методам приложения, он будет перенаправляться на URL-адрес, который его вызовет. URL-адрес, который поставщик должен перенаправить, возвращается методом `get_callback_url()` и создается с использованием имени провайдера, так что каждый провайдер`` получает свой выделенный маршрут.
Метод `get_provider()` используется для поиска правильного экземпляра `OAuthSignIn` с именем поставщика. Этот метод использует интроспекцию для поиска всех подклассов `OAuthSignIn`, а затем сохраняет экземпляр каждого в словаре.
Аутентификация OAuth с помощью Rauth
------------------------------------
Rauth представляет провайдеры OAuth с объектом класса `OAuth1Service` или `OAuth2Service`, в зависимости от версии используемого протокола. Я создаю объект этого класса в подклассе `OAuthSignIn` каждого провайдера. Реализации для Facebook и Twitter показаны ниже:
```
class FacebookSignIn(OAuthSignIn):
def __init__(self):
super(FacebookSignIn, self).__init__('facebook')
self.service = OAuth2Service(
name='facebook',
client_id=self.consumer_id,
client_secret=self.consumer_secret,
authorize_url='https://graph.facebook.com/oauth/authorize',
access_token_url='https://graph.facebook.com/oauth/access_token',
base_url='https://graph.facebook.com/'
)
class TwitterSignIn(OAuthSignIn):
def __init__(self):
super(TwitterSignIn, self).__init__('twitter')
self.service = OAuth1Service(
name='twitter',
consumer_key=self.consumer_id,
consumer_secret=self.consumer_secret,
request_token_url='https://api.twitter.com/oauth/request_token',
authorize_url='https://api.twitter.com/oauth/authorize',
access_token_url='https://api.twitter.com/oauth/access_token',
base_url='https://api.twitter.com/1.1/'
)
```
Для Facebook, который реализует OAuth 2, используется класс `OAuth2Service`. Объект службы инициализируется именем службы и несколькими аргументами, специфичными для OAuth. Аргументами `client_id` и `client_secret` являются те, которые назначены приложению на сайте разработчика Facebook. `Authorize_url` и `access_token_url` — это URL-адреса, определенные Facebook для приложений, к которым необходимо подключиться во время процесса аутентификации. Наконец, `base_url` задает URL-адрес префикса для любых вызовов API Facebook после завершения проверки подлинности.
Twitter реализует OAuth 1.0a, поэтому используется класс `OAuth1Service`. В OAuth 1.0a идентификационные и секретные коды называются `consumer_key` и `consumer_secret`, но в остальном идентичны по функциональности аналогам OAuth 2. Протокол OAuth 1 требует, чтобы провайдеры отображали три URL вместо двух, есть дополнительный запрос `request_token_url`. Аргументы `name` и `base_url` идентичны аргументам, используемым в службах OAuth 2. Следует отметить, что Twitter предлагает два параметра для параметра `authorize_url`. URL, показанный выше, `https://api.twitter.com/oauth/authorize`, является самым безопасным, так как он представит пользователю окно, в котором нужно будет разрешить приложению получать доступ к Twitter каждый раз. Изменение этого URL-адреса на `https://api.twitter.com/oauth/authenticate` заставит Twitter запрашивать разрешение только в первый раз, а затем тихо разрешит доступ до тех пор, пока пользователь не выйдет из Twitter.
Обратите внимание, что нет стандартизации для точки входа URL-адресов, провайдеры OAuth определяют их по своему усмотрению. Чтобы добавить нового поставщика OAuth, вам нужно будет получить эти URL-адреса из его документации.
Фаза авторизации OAuth
----------------------
Когда пользователь нажимает ссылку «Вход в систему с ...» для инициирования аутентификации OAuth, вызов следует по такому маршруту:
```
@app.route('/authorize/')
def oauth\_authorize(provider):
if not current\_user.is\_anonymous():
return redirect(url\_for('index'))
oauth = OAuthSignIn.get\_provider(provider)
return oauth.authorize()
```
Этот маршрут сначала гарантирует, что пользователь не вошел в систему, а затем просто получает подкласс `OAuthSignIn`, соответствующий данному поставщику, и вызывает его метод `authorize()`, чтобы инициировать процесс. Ниже показана реализация `authorize()` для Facebook и Twitter:
```
class FacebookSignIn(OAuthSignIn):
# ...
def authorize(self):
return redirect(self.service.get_authorize_url(
scope='email',
response_type='code',
redirect_uri=self.get_callback_url())
)
class TwitterSignIn(OAuthSignIn):
# ...
def authorize(self):
request_token = self.service.get_request_token(
params={'oauth_callback': self.get_callback_url()}
)
session['request_token'] = request_token
return redirect(self.service.get_authorize_url(request_token[0]))
```
Для провайдеров OAuth 2, таких как Facebook, реализация просто выдает перенаправление на URL-адрес, созданный объектом службы `rauth`. Область действия зависит от Поставщика, в этом конкретном случае я прошу, чтобы Facebook предоставил электронную почту пользователя. В response\_type='code' аргумент говорит oauth-провайдеру, что приложение представляет собой веб-приложение (есть и другие возможные значения для различных процессов аутентификации). Наконец, аргумент redirect\_uri назначает маршрут приложения, который должен вызвать поставщик после завершения проверки подлинности.
Поставщики OAuth 1.0 a используют несколько более сложный процесс, который включает получение маркера запроса от поставщика, который представляет собой список из двух элементов, первый из которых затем используется в качестве аргумента в перенаправлении. Весь маркер запроса сохраняется в пользовательском сеансе, так как он будет снова необходим в обратном вызове.
Фаза обратного вызова Callback OAuth
------------------------------------
Поставщик OAuth перенаправляет обратно в приложение после аутентификации пользователя и дает разрешение на обмен информацией. Маршрут, который обрабатывает этот обратный вызов, показан ниже:
```
@app.route('/callback/')
def oauth\_callback(provider):
if not current\_user.is\_anonymous():
return redirect(url\_for('index'))
oauth = OAuthSignIn.get\_provider(provider)
social\_id, username, email = oauth.callback()
if social\_id is None:
flash('Authentication failed.')
return redirect(url\_for('index'))
user = User.query.filter\_by(social\_id=social\_id).first()
if not user:
user = User(social\_id=social\_id, nickname=username, email=email)
db.session.add(user)
db.session.commit()
login\_user(user, True)
return redirect(url\_for('index'))
```
Этот маршрут создает экземпляр класса поставщика `OAuthSignIn` и вызывает его метод `callback()`. Этот метод имеет функцию завершения аутентификации с провайдером и получения информации о пользователе. Возвращаемое значение представляет собой кортеж с тремя значениями, уникальный идентификатор (называемый `social_id`, чтобы отличать его от первичного ключа `id`), псевдоним пользователя и адрес электронной почты пользователя. Идентификатор и псевдоним являются обязательными, но в этом примере приложения я сделал электронное письмо необязательным, так как Twitter никогда не делится этой информацией с приложениями.
Пользователь просматривается в базе данных по полю `social_id`, и если не найден, новый пользователь добавляется в базу данных с информацией, полученной от провайдера, эффективно регистрируя новых пользователей автоматически. Затем пользователь регистрируется с помощью функции `login_user()` в Flask-Login и, наконец, перенаправляется на домашнюю страницу.
Реализация метода `callback()` для провайдеров OAuth для Facebook и Twitter показана ниже:
```
class FacebookSignIn(OAuthSignIn):
# ...
def callback(self):
def decode_json(payload):
return json.loads(payload.decode('utf-8'))
if 'code' not in request.args:
return None, None, None
oauth_session = self.service.get_auth_session(
data={'code': request.args['code'],
'grant_type': 'authorization_code',
'redirect_uri': self.get_callback_url()},
decoder=decode_json
)
me = oauth_session.get('me').json()
return (
'facebook$' + me['id'],
me.get('email').split('@')[0], # Facebook does not provide
# username, so the email's user
# is used instead
me.get('email')
)
class TwitterSignIn(OAuthSignIn):
# ...
def callback(self):
request_token = session.pop('request_token')
if 'oauth_verifier' not in request.args:
return None, None, None
oauth_session = self.service.get_auth_session(
request_token[0],
request_token[1],
data={'oauth_verifier': request.args['oauth_verifier']}
)
me = oauth_session.get('account/verify_credentials.json').json()
social_id = 'twitter$' + str(me.get('id'))
username = me.get('screen_name')
return social_id, username, None # Twitter does not provide email
```
В методе `callback()` передается токен проверки, который приложение может использовать для связи с API-интерфейсом провайдера. В случае OAuth 2 это происходит как аргумент `code`, тогда как для OAuth 1.0a это `oauth_verifier`, оба заданные в строке запроса.
Этот код используется для получения `oauth_session` из объекта службы *rauth*.
Обратите внимание, что в последних версиях API Facebook токен сеанса возвращается в формате JSON. Формат по умолчанию, ожидаемый rauth для этого токена, должен указываться в строке запроса. По этой причине, необходимо добавить аргумент `decoder`, который декодирует содержимое JSON. В Python 2 достаточно передать `json.loads`, но в Python 3 нам нужен дополнительный шаг, потому что полезная нагрузка возвращается как *байты*, которые json-парсер не понимает. Преобразование из байтов в строку выполняется во внутренней функции decode\_json.
Объект `oauth_session` может использоваться для предоставления API-запросов поставщику. Здесь он используется для запроса информации о пользователе, которая должна предоставляться определенным провайдером. Facebook предоставляет идентификатор пользователя и адрес электронной почты, но не дает имен пользователей, поэтому имя пользователя для приложения создается из левой части адреса электронной почты. Twitter предоставляет идентификатор и имя пользователя, но не поддерживает электронную почту, поэтому электронное письмо возвращается как `None`.
Данные, полученные от провайдера, окончательно возвращаются в виде трехэлементного кортежа для функции просмотра. Обратите внимание, что в обоих случаях значение `id` от провайдера добавляется с `«facebook $»` или `«twitter $»` до его возврата, чтобы сделать его уникальным для всех поставщиков. Поскольку это то, что приложение будет хранить как `social_id` в базе данных, необходимо сделать это, чтобы два поставщика, которые назначили один и тот же `id` двум различным пользователям, не конфликтовали в базе данных приложения.
Вывод
-----
Как я уже упоминал выше, пример приложения позволяет любому пользователю регистрироваться и входить в систему с помощью учетной записи Facebook или Twitter. Приложение демонстрирует, как регистрировать пользователей без необходимости вводить какую-либо информацию, все, что им нужно сделать, это войти в систему с провайдером и разрешить совместное использование информации.
Если вы хотите попробовать этот пример, вам необходимо выполнить некоторые подготовительные шаги:
Клонировать или загрузить репозиторий проекта: <https://github.com/miguelgrinberg/flask-oauth-example>
Создать виртуальную среду и установите пакеты по списку в файле *requirements.txt* (вы можете использовать Python 2.7 или 3.4).
Зарегистрируйте «приложение» с помощью Facebook и Twitter,
как описано выше.
Отредактируйте *app.py* с идентификатором и секретными кодами ваших приложений Facebook и Twitter.
После выполнения этих инструкций вы можете запустить приложение с помощью *python app.py*, а затем запустить <http://localhost>: 5000 в своем браузере.
Надеюсь, что эта статья полезна в демистификации OAuth.
Если у вас есть вопросы, напишите их ниже.
Miguel | https://habr.com/ru/post/346918/ | null | ru | null |
# Как не создать с нуля криптовалюту за 3 года
В этой статье я опишу то, как я один написал криптовалюту с нуля, какие интересные технологии я оттуда вынес, с каким опытом ушел и что произошло потом. Это не туториал, а просто описание происходящих событий, но, если будет желание — могу написать пару статей на тему что и почему, хотя не уверен что это кому-нибудь нужно. В конце статьи будут выводы, к которым я пришел после 3х лет создания.
Всем привет, давно тут ничего не писал. Прошлый мой пост про бота на прологе был более-менее удачным и понравился публике. Так как я люблю вписываться во всякого рода странные затеи – захотелось что-то сделать.
### Немного истории
Итак, в 2017 году летом я начал читать про блокчейн и криптовалюты, а так, как изучать у меня лучше всего получается именно на практике – решил написать свою криптовалюту. На самом деле цель была не просто в изучении, все началось с одной простой мысли – блокчейн – реестр, а значит – база данных. Почему тогда в блокчейне хранят только финансовые данные – почему бы не хранить произвольные?
С этими мыслями я начал изучение блокчейна биткоина, и полностью повторил его на nodejs со своими выкладками (и естественно велосипедами) за 4 месяца. К октябрю 2017 года у меня был рабочий проект с очень кривым кодом, который тяжело было поддерживать, буквально в ноябре я написал еще SPV клиент и добавил поддержку легких клиентов в сеть, кроме того переделал майнинг пул (единственная часть, которую не делал с нуля, а просто взял готовый и доработал), создал и оформил обзорщик блоков, который общался с локальной нодой через rpc методы.
Иии… случились события, от меня не зависящие, отложившие дальнейшую разработку (и возможно запуск) на неопределенный срок (до 19го года как позже выяснилось). Напомню, что где-то осенью-зимой 17го года криптовалюта вдруг решила сходить на максимумы своих цен.
Факт того, что у меня была рабочая криптовалюта с определенной идеей и инфраструктурой и я пропустил момент, когда все, абсолютно все криптовалюты показывали свои максимумы и можно было запустить любую криптовалюту (даже какой-нибудь токен, обеспеченный кирпичами) — добавил немного разочарования в мои светлые замыслы, но я не отчаялся.
В тот момент я не мог продолжить разработку, но было время изучить топ 10 криптовалют, поэтому сделал телеграм канал, в котором произвел анализ основных криптовалют, входивших на тот момент в топ 10 с технической стороны. Кстати, если хабраюзеры захотят — могу «портировать» эти статьи сюда.
Этот анализ в дальнейшем, когда я таки вернулся к разработке — позволили мне улучшить модель и более детально продумать архитектуру будущей криптовалюты. В 2019 году я вернулся к разработке и начал с нуля. Более детально продумал будущую архитектуру, избавился от перекрестных ссылок в коде, удалил лишние модули, перевел часть модулей в отдельные npm пакеты и собрал криптовалюту вот совсем недавно.
### Детали
Сразу скажу, что это не проект, а просто набор бесполезного кода, поэтому надеюсь, что меня не забанят за ссылки на гитхаб и указание названий.
#### Криптовалюта
После первого относительно удачного опыта я осмелел и решил, что следующий проект должен быть красивее в плане кода, чем первый прототип. Кроме того, я решил делать систему модульной, в виде фреймворка, чтобы иметь возможность подключать и отключать модули при необходимости.
Вообще, написать криптовалюту в техническом плане — не такая трудная задача, если кратко:
* выстраиваете базу данных для блоков и индексации
* организуете протокол обмена сообщениями между нодами
* определяете формат сериализации данных и алгоритм подписания транзакций
* определяетесь с консенсусом и настраиваете правила добавления и валидации
* rpc сервер по усмотрению
* а далее настраиваете консольного клиента и пытаетесь запустить, сгенерировав генезис блок и настроив валидаторов
* спустя тонну исправленных ошибок и неточностей — у вас рабочая криптовалюта, поздравляю
После этого идет этап добавления функций, которых нет в основе. Например у меня это datascript, основа проекта.
#### Datascript
Проект, который я написал за 4 месяца называлась orwell и является форком bitcoin в большей мере, но так же предполагает, что каждая транзакция кроме финансовой информации содержит дополнительные данные в HEX формате, которые (если транзакция валидна и попала в блок) — транслируются в специализированную VM, которая дешифрует эти данные и транслирует их в обычную базу данных. Эту VM я назвал orwelldb, а формат — datascript, пример дешифровки:
Hex:
`ef01fd4f01190b6578616d706c6564617461fd3f0154fd3b011f000f0fa1067e45f40003f1096f776e65725f6b65798230343233633635653064373364626161386537393435633965663135626338366533643864396638636364323636626366323362623032646336333432386636623239343766336164643731636536333962653739646561333933313237613061336661623136613339306630326537363966633135373561333535333130323461f30a70726976696c6567657301f1008230346231363165656566623739363163366637306137643338666434373764616633333437643231346561663365313639643964316434336232346437323338383665343063643962633563633232393638333635656531663962653635333932303539383630643735656432356136303836653830666462653138336565613364f20b7772697465536372697074fdb815`
```
[
{
"dataset": "exampledata",
"operator": "create",
"content": {
"owner_key": "0423c65e0d73dbaa8e7945c9ef15bc86e3d8d9f8ccd266bcf23bb02dc63428f6b2947f3add71ce639be79dea393127a0a3fab16a390f02e769fc1575a35531024a",
"privileges": [
"04b161eeefb7961c6f70a7d38fd477daf3347d214eaf3e169d9d1d43b24d723886e40cd9bc5cc22968365ee1f9be65392059860d75ed25a6086e80fdbe183eea3d"
],
"writeScript": 5560
},
"canRead": true,
"success": true
}
]
```
Расскажу немного про содержимое.
Датаскрипт содержит массив обращений к определенной базе и её датасетам, в данном случае в транзакции описано создание нового датасета (т.е. таблицы, если идет речь о реляционных базах данных), это следует из содержимого поля «operator». Кроме create там еще может быть «write» и «settings» — добавление (или изменение) данных и обновление параметров датасета соответственно. «content» это как раз те данные, которые записываются в датасет. В данном случае мы создаем таблицу, поэтому контент идентичен тому, что прописывается при operator=settings — настройки таблицы.
Чтобы описать что именно там написано, надо обратиться к концепции датаскрипта.
Продемонстирую диаграмму из 2017 года, созданную для этих целей:
Датаскрипт по аналогии с bitcoin и его lock и unlock скриптами содержит read и writeScript, первый определяет кто может читать сообщение, а второй — кто может писать в определенный датасет. Скрипты являются стек-ориентированными языками. Readscript прописывается в самом сообщении и указывает на того, кто может прочитать сообщение. Реализуется это при помощи шифрования. При указании шифрования — прочитать может только тот, у кого есть необходимый ключ в keystore, иначе — любой желающий. Сообщения с оператором create/settings никогда не должны быть зашифрованы.
Пример открытого readScript (читать может любой желающий):
```
DATA_HEXJSON + jsonhexbytes
где DATA_HEXJSON = 0x54
```
Зашифрованный:
```
DATA_HEXJSONENCRYPTED + var_str(encrypted data) + PUSHDATA_DBREADPRIVATEKEY + uint8(encryption) + OP_DECRYPT + OP_HASH256 + DATA_HASH + char[32](hash) + OP_EQUAL
```
в сыром виде:
```
0x53 + var_str + 0x56 + (0x1 or 0x2) + 0x57 + 0x59 + 0x58 + char[32] + 0x87
```
Тест расшифровки данных с проверкой хеша от расшифрованных данных.
> Если кому-то интересно, более подробно я описал всё в документации к протоколу: [github: datascript docs](https://github.com/gettocat/orwell/blob/master/docs/datascript.md).
>
>
>
> А вот указанный в коде jsonhex — это моя реализация перевода json в бинарный формат. Казалось бы, можно было оставить обычный json, но хотелось единообразия, поэтому разработал отдельный протокол. Если хотите прочитать и про него — вот документация: [github: bitowl](https://github.com/gettocat/bitowl).
Writescript же — прописывается в настройках датасета, в примере это 0x5560. В данном случае там написано:
```
PUSHDATA_DBWRITEPUBLICKEY OP_CHECKDBPRIVILEGES
```
Т.е. отправить публичный ключ отправителя сообщения на стек — и проверить список привилегий для этого датасета. Если этот ключ есть в списке привилегий (или отправитель create сообщения, или owner\_key) — тогда он может писать. Кроме того, если writescript пустой — это значит ALL, т.е. писать в данный датасет может любой желающий.
Для operator=settings всё выглядит так же, меняются только настройки внутри content. Для write — content содержит собственно данные.
#### Немного про блокчейн
А как же указывается база данных, спросите вы? В моем случае я сделал хак — если транзакция содержит датаскрипт содержимое — первый выход данной транзакции всегда нулевой, и на него посылается данный датаскрипт, т.е. каждый адрес в сети является базой данных.
Эта модель позволяет хранить данные внутри самого блокчейна, что дает некоторую гибкость, но при этом добавляет проблем с хранением, ведь блокчейн биткоина разросся уже почти до 500 гигабайт, и это только на финансовых данных. Если добавить сюда еще и произвольные — получится избыточно. Поэтому хранение ограничилось лишь всякими ключами и связями для авторизации. И к слову, валидация всех правил происходит на уровне VM при создании, но необходимо синхронизировать её с блокчейном.
Например, сделал пару системных датасетов в системной базе данных: domain, masternode, token, dapp, тем самым можно создавать домены для каждого адреса/базы данных и оперировать не набором непонятных символов, а удобным ником (к примеру), кроме того, домены, по задумке могут использоваться в dapps (о которых напишу позже).
Что касается dataset token и masternode — в первом хранятся пользовательские токены, которые каждый участник может создать, а masternode хранит список публичных ключей участников, которые являются валидаторами сети. Тут необходимо небольшое отступление.
#### Consensus
Основа блокчейна — это консенсус, т.е. договоренность между нодами, некоторый набор правил, которые действуют в сети и все их исполняют чтобы сеть была работоспособной. Например — в биткоине действует консенсус Proof of Work, или майнинг, о котором, я уверен, писали тут множество раз. Суть консенсуса сводится к проверке новых блоков, публикуемых участниками сети. В биткоине участники сети в случайном порядке публикуют блоки — кто первый найдет, того и награда. В своей сети изначально делал так же, но позже решил, что это не рационально, так как хватит одного майнера из биткоина, чтобы нарушить работу моей сети и применить атаку 51%. Поэтому спустя какое-то время я реализовал модуль консенсуса [consensusjs](https://github.com/gettocat/consensusjs), который описал несколько разных консенсусов: centralized, PoW, PoS (PoW+PoS), static dpow, static dos, dynamic dpos. На последнем я и остановился.
Dynamic delegate pos (ddpos) предполагает, что в самом начале если определенное число делегатов (валидаторов) список которых сортируется по рейтингу и количеству монет в пользовании — и создается раунд, в течении которого каждый валидатор из списка публикует блок в строгом порядке. Когда раунд заканчивается рассчитывается новый, при этом каждый участник сети имеет возможность самостоятельно рассчитать текущий раунд и следующий раунд на основе открытых данных из сети.
Собственно для этого и необходима таблица masternode, в ней мы храним всех, кто изъявил желание быть валидатором, и их текущий рейтинг. В начале каждого раунда мы производим сортировку этой таблицы, и создаем раунд с получившимися N валидаторами. В случае же, если число валидаторов меньше N — создаем раунд с стандартными валидаторами сети, описанными в конфиг файле (их публичные ключи).
#### democracy
Концепция голосований внутри сети придумана и реализована в старой версии криптовалюты, она позволяет получать усредненные данные из сети от всех проголосовавших нод. В новой версии я реализовал отдельный модуль, но не успел его встроить. Предполагалось, что с помощью democracy можно было бы менять параметры сети путем честного голосования, а так же уменьшать размер хранимого блокчейна путем смещения генезис блока (генезис блок становится больше, путем размещения в нем старых UTXO и данных), но позволило бы синхронизировать не миллион блоков, а всего лишь последние 1000, к примеру. Кроме того, голосования бы могли управлять форками и изменениями в сети, а так же решать организационные вопросы, связанные с сетью. Правда внедрить этот модуль, как я писал выше — не успел, но задумка осталась.
#### dApps
Концепцию dapps была придумана чуть погодя после пика bitcoin в начале 18го. Тогда была идея сделать её через регистрацию приложения (публичного ключа) в блокчейне, регистрацию воркеров (публичных ключей) в системные таблицы, связь воркеров с приложением и уже воркеры бы работали в своем, изолированном блокчейне. В этой концепции есть еще viewer, т.е. часть приложения с интерфейсом для общения с клиентом, в качестве viewer может выступать как браузер, так и отдельное приложение. Позже от этой идеи я отказался, так как довольно долго реализовывать и сделал несколько проще.
Вы так же можете зарегистрировать dApp в блокчейне, связать его с доменом, а участник, зная домен, который связан с публичным ключом приложения — взаимодействовать с этим приложением. При обращении к домену, прозрачный dns сервер в клиенте сети считывает запрос пользователя, шифрует его с помощью ecdh шифрования, так, что прочитать содержимое сможет только участник с публичным ключом приложения и отправляет в сеть. Приложение получает этот запрос, отправляет его на endpoint, указанный в конфиге для этого приложения, и возвращает результат в сеть, так же зашифрованным.
> Кстати, забавный факт: так как ноды общение между собой шифруют с помощью ecdh шифрования и dApp отправляет и принимает данные зашифровано — в моменты пересылок между нодами часть сообщения зашифрована два раза.
При таком методе получается зашифрованная сеть, где каждый участник может создавать сайты (и не только), а контролировать трафик становится проще, так как каждый участник содержит свой публичный ключ, которым он «просматривает сайт», ip адреса при этом вырезаются из запросов и ответов, делая сеть анонимной. Тем самым изначально есть авторизация, а так же возможно посмотреть баланс пользователя, баланс токенов (связанных с сайтом, например) и совершать процесс оплаты не уходя с сайта и из сети. Единственным минусом на момент тестов была производительность — в таком виде сайты грузятся в 10 раз медленнее, так как пересылаются по децентрализованной сети. **Описанный выше механизм это всего лишь концепт, но уже наполовину реализованный.**.
Под спойлер запихнул ссылку на код, который это реализует (гитхаб):
**Сырой код dapp**
<https://github.com/gettocat/friday/blob/master/node/modules/dapps/index.js>
### С чего бы я начал сейчас
И в конце хочу написать пару приемов, которые бы я применил, если бы пришлось всё начинать с начала с текущими знаниями.
Модульная архитектура — определенно только да, чтобы каждый модуль был минимально связан со всеми остальными и мог быть заменен в случае, например, изменения консенсуса
Изоляция модулей — по сути продолжение предыдущего пункта, уже конкретно про функциональные модули, а не логические. Например — в моем коде консенсус реализован отдельным модулем consensusjs, что позволяет вдоль и поперек протестировать его перед внедрением в рабочий проект, тоже самое касается так называемых примитивов (формат транзакций, блоков и их сериализация/десериализация), тем самым можно протестировать функционал конкретного модуля до внедрения его в основной код.
Тесты — покрывать тестами каждый модуль — основа хорошего самочувствия в процессе запуска и нормального сна ночью (проверено на себе).
Версии во всем — так как криптовалюты являются замкнутой системой — необходимо заранее продумать о том, что будет дальше — как вы это будете поддерживать. Необходимо продумать модель обновления функционала от версии к версии у всех участников, при этом чтобы не страдали те, кто еще не обновился, так как в обратном случае может произойти не намеренный форк основной сети. В моем модуле consensusjs была реализован функционал определения форков и допустимых версий блоков, но в основной код я это еще не внес.
### Итоги
Как я и обещал, в конце статьи подведу некоторые итоги. Данный пост можно считать точкой в истории с самодельной криптовалютой. С одной стороны я понимал, что это не для продакшена, необходим более чуткий контроль кода, покрытие тестами и прочие штуки из продакшн проектов, а так же больше, чем один программист. И финансы-финансы-финансы. Без этого никуда. У меня же, всего этого нет, и не было, поэтому мне просто было интересно попробовать, изучить технологию и понять стоит ли это того или нет. Это того стоило. Могу сказать, что после проделанной работы я лучше стал разбираться во многих аспектах программирования, технологий (очень продвинулся в работе с байт последовательностями, например) и определенно изучил блокчейн и технологии в основе него.
Например я точно знаю, что эфириум использует схожую концепцию с данными у транзакции и виртуальной машиной, обрабатывающей эти данные, только эфириум использует данные как функции (если по-простому) и обращения к ним (не считая создания контрактов). Я точно знаю, что внутренние скрипты биткоина (стековый язык) — довольно сильная штука, Сатоши подразумевал создание смарт-контрактов именно на их основе задолго до того, как появилось понятие «смарт-контракт», но использование этих скриптов урезано в биткоине, так как возможно появление неизвестных ранее багов.
Если говорить о технологиях, которые мне пришлись по душе после моего 3х летнего исследования — определенно это консенсус, т.е. договоренность между участниками сети и общие правила валидации сообщений. Фильтр блума — довольно интересная штука, позволяющая не раскрывая подробностей — посылать другому участнику фильтр, по которому он фильтрует отправляемые данные. Тем самым — вы получаете данные, не раскрывая какие именно данные вам нужны. «Дерево Меркла» как структура хранения данных, основа легких нод в bitcoin и деревьев состояний (там их три) ethereum. PoW — такая простая, но при этом такая элегантная задумка, «все дружно ищем число меньше чем общее средняя сложность за последние N блоков, высчитываемое обычным отношением».
Что же касается минусов — их тоже предостаточно. Первый из них — трудозатратность. Со временем я выгорел к этой идее, хоть она меня и захватывала около 3х лет. Например сейчас криптовалюта вроде как даже запущена, и казалось бы, уже ничего не держит чтобы запустить её, но после 5 тысяч блоков образовался странный баг с тем, что по какой-то причине отсчет блоков начинается с нуля (видимо как-то рушатся индексы), искать который пока нет не времени, ни желания.
Возможно когда-нибудь я вернусь к этой идее или схожей с ней (или основанной на ней). Если у вас есть желание — вы можете изучить код или сделать форк проекта friday на моем github, весь код под MIT лицензией. Определенно точно не перестану работать в этом направлении, ведь децентрализованные технологии это очень интересно, хоть и довольно трудозатратно. Жду в ЛС если есть какие-либо вопросы/предложения или уточнения. Помогу разобраться если вдруг нужно. Ниже организую опрос — стоит ли что-либо еще писать по этой теме здесь, хотя рейтинг сам все расставит на места. | https://habr.com/ru/post/505330/ | null | ru | null |
# Padding Oracle Attack: криптография по-прежнему пугает
### Эту уязвимость чинят уже пятнадцать лет
В хабрапереводе текста четырёхгодовалой давности [«Padding Oracle Attack или почему криптография пугает»](https://habrahabr.ru/post/247527/) была подробно описана атака на [режим шифрования CBC](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B6%D0%B8%D0%BC_%D1%81%D1%86%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B1%D0%BB%D0%BE%D0%BA%D0%BE%D0%B2_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D1%82%D0%B5%D0%BA%D1%81%D1%82%D0%B0). В этом режиме каждый очередной блок открытого текста xor-ится с предыдущим блоком шифротекста: в результате каждый блок шифротекста зависит от каждого блока открытого текста, который был обработан к тому моменту.
[](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B9%D0%BB:EncryptCBC.png)
Чтобы пропустить исходное сообщение (произвольной длины) через CBC-шифр, к нему дописывается [MAC](https://en.wikipedia.org/wiki/Hash-based_message_authentication_code) (хеш для проверки целостности, обычно 20-байтный SHA-1) и затем padding, чтобы дополнить открытый текст до целого числа блоков (обычно 16-байтных):
Padding («набивка») состоит из одинаковых байтов, на единицу меньших своей длины: `(0)` или `(1,1)` или `(2,2,2)` или т.п.
Таким образом, получатель шифротекста должен 1. расшифровать все его блоки;
2. прочитать последний байт последнего блока, чтобы определить длину набивки и, соответственно, позицию MAC в открытом тексте;
3. проверить корректность набивки и MAC.
В 2002 г. французский криптограф Серж Воденэ обнаружил в CBC уязвимость к атакам типа «padding oracle»: если перехватить шифротекст (посредством MitM-атаки), изменять последний байт предпоследнего блока, отправлять изменённый шифротекст на сервер, и следить за его ответом — то по разнице между ответами «некорректная набивка» и «некорректный MAC» можно будет за 256 запросов определить последний байт исходного открытого текста. Тогда MitM начинает изменять предпоследний байт предпоследнего блока, и за 256 запросов определяет предпоследний байт открытого текста, и т.д. — по 256 запросов для расшифровки каждого байта.
Практически эту уязвимость можно (было) использовать для воровства HTTPS-кук: злоумышленник направляет пользователя на свою страницу, на которой скрипт от имени пользователя будет один за другим слать HTTPS-запросы на интересующий злоумышленника сервер. Браузер пользователя будет вставлять его куки для этого сервера в каждый запрос, а MitM-сервер, управляемый злоумышленником, будет перехватывать сообщения между пользователем и HTTPS-сервером, менять в них по одному байту в предпоследнем блоке, и следить за реакцией сервера. На расшифровку всех кук таким образом уйдёт меньше минуты.
Казалось бы, для защиты от атаки Воденэ достаточно, чтобы сервер возвращал один и тот же код ошибки при некорректной набивке и при некорректном MAC; но эти два случая всё равно [удастся различить](https://crypto.stanford.edu/~dabo/papers/ssl-timing.pdf) по времени до ответа сервера: расчёт и проверка MAC занимают ощутимо больше времени, чем просто проверка набивки в последнем блоке.
Раз не должно быть разницы, набивка или MAC не прошли проверку — то может показаться, что содержимое набивки вообще незачем проверять: если открытый текст не завершается последовательностью из одинаковых байтов, то он заведомо некорректный, так что и MAC с подавляющей вероятностью не совпадёт. Но если злоумышленник подберёт такой размер шифротекста, чтобы последний блок целиком был занят набивкой, и на MitM-сервере будет заменять его на любой предыдущий блок из того же шифротекста — то сервер сообщит об ошибке только в том случае, если последний байт подставленного блока не расшифруется в (длину\_блока–1). Получается такой же «padding oracle», только в профиль. Эта атака получила название [POODLE](https://habrahabr.ru/company/mailru/blog/241113/). Современные реализации SSL/TLS обязательно проверяют содержимое набивки, и если оно некорректно — то считают набивку отсутствующей, и отправляют на проверку MAC весь результат CBC-расшифровки целиком. В принципе, клиентам это позволяет не пересылать лишний блок, целиком состоящий из набивки, когда открытый текст (вместе с MAC) изначально состоит из целого числа блоков, и при этом не оканчивается на последовательность одинаковых байтов.
После этих исправлений уязвимости «padding oracle» считались устранёнными, пока в 2013 г. пара британских исследователей не изобрели атаку [«Lucky 13»](https://en.wikipedia.org/wiki/Lucky_Thirteen_attack), в основе которой лежит тот факт, что время расчёта MAC зависит от длины хешируемой строки. Поскольку SHA-1 обрабатывает строку 64-байтными блоками, то злоумышленник может испробовать в качестве двух последних байтов предпоследнего CBC-блока все возможные двухбайтные комбинации, и скачок во времени отклика сервера будет означать переход между 55-байтной хешируемой строкой (один блок SHA-1; в конец хешируемой строки добавляется девятибайтный «трейлер») и 56-байтной (два блока), т.е. между двухбайтной набивкой и однобайтной:
Перехватив и изменив HTTPS-запрос 65536 раз, замеряя каждый раз время отклика сервера, в «стерильных» лабораторных условиях можно восстановить последние два байта открытого текста. На практике же на накопление достаточной статистики для восстановления двух байтов потребуется не одна сотня повторений этой серии из 65536 запросов. Таким образом, атака «Lucky 13» представляла скорее теоретическую опасность.
> *Своё название эта атака получила из-за того, что размер заголовка, хешируемого перед «полезной нагрузкой», ограничил перебор вариантов набивки двухбайтными последовательностями. Будь этот заголовок 14-байтным или длинее, скачок во времени отклика сервера пришёлся бы на более короткие куски открытого текста, и перебирать бы приходилось в сотни раз больше вариантов набивки. С другой стороны, будь этот заголовок 11-байтным, скачок бы пришёлся на переход между 8 и 9 блоками открытого текста, и атака была бы совершенно невозможна. Ну а самое счастливое число — конечно же, 12: с такой длиной заголовка для атаки было бы достаточно перебирать значения последнего байта самого по себе, как и в атаке Воденэ.*
Для защиты от «Lucky 13» разработчики OpenSSL приложили [недюжинную смекалку](https://www.imperialviolet.org/2013/02/04/luckythirteen.html): по сути, во всём коде проверки MAC и набивки нельзя использовать ветвления — иначе время проверки для разных входных данных будет разным! Опуская подробности реализации SHA-1 без ветвления по числу обрабатываемых блоков, сосредоточимся на последнем шаге проверки: сравнение вычисленного значения MAC с фактически записанным в открытом тексте. Чтобы избежать ветвлений, код проверяет весь открытый текст байт за байтом, объединяя по AND разницу между ожидаемым и фактическим значением с «маской MAC» и с «маской набивки», и объединяя по OR результаты проверок всех байтов:
Изображённый 32-байтный открытый текст состоит из шестибайтного сообщения, 20 байтов MAC, и шести байтов набивки. Набивка не может быть длиннее 12 байтов (при пустом сообщении), но в любом случае код должен высчитать MAC и проверить все байты сообщения, прежде чем вернуть код ошибки.
Ну-ка, а что этот код будет делать, если последним байтом открытого текста будет «12» — заведомо невозможная длина набивки?
MAC будет вычисляться для сообщения длины -1!
Не важно, каким получится результат — он заведомо бессмысленный; важнее, что маска проверки MAC «сдвинулась» на один байт за начало сообщения — т.е. от получившегося мусорного значения проверяться будут только 19 байтов.
А что, если сдвинуть маску MAC целиком за начало сообщения?
Теперь на проверку MAC можно не обращать внимания: всё равно все байты разницы будут про-and-ены с нулевой маской! Единственная оставшаяся преграда — проверка содержимого набивки. Все её байты должны быть равны последнему, т.е. 31:
Таким образом злоумышленник может проверять, будет ли открытый текст целиком состоять из байтов со значением (длина\_шифротекста–1): в этом случае OpenSSL сочтёт шифротекст корректным, и сервер вернёт ошибку более высокого уровня (например, ошибку HTTP).
Как использовать такой «оракул»? Теперь MitM-сервер должен действовать намного изощрённее, чем при атаке Воденэ. Предположим, скрипт злоумышленника отправил на HTTPS-сервер POST-запрос, оканчивающийся на 31 байт со значением 31. MitM-сервер перехватит шифротекст, возьмёт от него *только два последних блока*, а в качестве вектора инициализации возьмёт третий с конца блок шифротекста — и будет в нём при каждом запросе менять первый байт:
Из 256 попыток с разными значениями первого байта IV, 255 приведут к ошибке «некорректный MAC или набивка», и одна попытка приведёт к другой ошибке — так мы сможем восстановить 32-ой с конца байт POST-запроса!
Увеличим в POST-запросе длину пути на один байт, а тело запроса укоротим на байт — тогда нам будет известен 31-ый с конца байт запроса. Теперь изменим второй байт IV так, чтобы вторым байтом открытого текста опять получилось 31. Снова будем менять первый байт IV, и снова сможем восстановить 32-ой с конца байт запроса!
Сдвигая таким образом «просвечиваемый байт», MitM сможет расшифровать последние 16 байтов в POST-заголовке, и, если повезёт, HTTPS-куки окажутся среди этих 16 байтов. Скорость расшифровки получается та же самая, что и в оригинальной атаке Воденэ: до 256 запросов на каждый восстанавливаемый байт. Получается, что попутно с защитой от «Lucky 13» в OpenSSL внесли уязвимость, которая намного серьёзнее, чем сама «Lucky 13»!
> *Техническое замечание: даже если POST-запрос оканчивается на последовательность из байтов 31, перед CBC-шифрованием он будет дополнен MAC и набивкой, так что в описанном виде атака не сработает. Подготовительный этап атаки — варьируя запрашиваемый путь, подобрать такую длину POST-запроса, чтобы MAC и настоящая набивка заняли последние два CBC-блока целиком; затем в ходе атаки эти последние два блока будут отбрасываться, а использоваться будут блоки от пятого до третьего с конца. Наладив такую координацию действий между скриптом, генерирующим HTTPS-запросы, и MitM-сервером, злоумышленник может обеспечить, что результат CBC-расшифровки будет оканчиваться на 31 байт со значением 31.*
Подводя итоги: на протяжении 15 лет с обнаружения первого «padding oracle», за каждой попыткой устранения таких «оракулов» следовало обнаружение (или даже нечаянное создание!) новых. Интересно, сколько времени пройдёт до обнаружениия следующего «padding oracle» в TLS с использованием CBC-шифров? | https://habr.com/ru/post/338072/ | null | ru | null |
# Диалог выбора файлов на Wt
По работе пришлось сделать несколько своих компонентов на Wt: визард, диалог выбора каталогов и файлов на устройстве. Решил выложить на [GitHub](https://github.com/RPG-18/WtComponents), может кому-нибудь понадобится. Под катом будет простой диалог выбора файлов на Wt+Boost.
Wt виджет-ориентированный фреймворк, который по API похож на Qt. То что Wt «похож» на Qt, но не Qt!
#### **Модель данных**
В основе абстрактная модель [Wt::WAbstractItemModel](http://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WAbstractItemModel.html)(почти как [QAbstractItemModel](http://doc.qt.io/qt-5/qabstractitemmodel.html)):
```
class FileSystemModel: public Wt::WAbstractItemModel
{
public:
enum Roles
{
Name = Wt::UserRole + 1, Path = Wt::UserRole
};
FileSystemModel(Wt::WObject* parent = nullptr);
bool isFile(const Wt::WModelIndex& index) const;
bool isDir(const Wt::WModelIndex& index) const;
virtual int columnCount(const Wt::WModelIndex& parent =
Wt::WModelIndex()) const;
virtual int rowCount(const Wt::WModelIndex& parent =
Wt::WModelIndex()) const;
virtual Wt::WModelIndex parent(const Wt::WModelIndex& index) const;
virtual boost::any data(const Wt::WModelIndex& index, int role =
Wt::DisplayRole) const;
virtual Wt::WModelIndex index(int row, int column,
const Wt::WModelIndex& parent = Wt::WModelIndex()) const;
virtual boost::any headerData(int section, Orientation orientation =
Horizontal, int role = DisplayRole) const;
private:
std::unique_ptr m\_impl;
};
```
При реализации древовидной модели удобно иметь само дерево. Элемент дерева представлен структурой **TreeNode**:
```
struct TreeNode
{
enum Type
{
File, Directory
};
std::string filename;
std::string path;
TreeNode* parent;
std::vector children;
Type type;
bool childrenLoaded;
TreeNode(TreeNode\* prnt = nullptr) :
parent(prnt),
type(Directory),
childrenLoaded(false)
{
if (parent)
{
parent->children.push\_back(this);
}
}
~TreeNode()
{
parent = nullptr;
for (TreeNode\* child : children)
{
delete child;
}
children.clear();
}
size\_t loadChildren()
{
if (childrenLoaded)
{
return children.size();
}
boost::filesystem::path p(path);
childrenLoaded = true;
size\_t count = 0;
try
{
for (directory\_iterator iter(p), end; iter != end; ++iter)
{
auto itm = new TreeNode(this);
itm->filename = iter->path().filename().string();
itm->path = iter->path().string();
itm->type =
is\_directory(iter->path()) ?
TreeNode::Directory : TreeNode::File;
++count;
}
std::sort(children.begin(), children.end(),
[](const TreeNode\* a, const TreeNode\* b)
{
return a->filenamefilename;
});
return count;
} catch (const filesystem\_error&)
{
return 0;
}
}
};
```
Метод **loadChildren** осуществляет чтение файловой системы и подгрузку узлов. Узлы будут подгружаться по требованию, а именно тогда, когда у модели запросят *rowCount*. Корень дерева создается в конструкторе *FileSystemModelPrivate*:
```
struct FileSystemModelPrivate
{
FileSystemModelPrivate() :
root(new TreeNode)
{
root->filename = "/";
root->path = "/";
}
std::unique_ptr root;
};
```
В Wt так же как и в Qt есть метод [createIndex](http://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WAbstractItemModel.html#ac837a73fe423255035ffb076946de122) создающий модельный индекс(WModelIndex) и позволяющий передавать указатель на *TreeNode*.
Остальной код очень прост:
```
FileSystemModel::FileSystemModel(WObject* parent) :
WAbstractItemModel(parent),
m_impl(new FileSystemModelPrivate)
{
}
int FileSystemModel::columnCount(const WModelIndex& parent) const
{
return 1;
}
int FileSystemModel::rowCount(const WModelIndex& parent) const
{
if (parent.isValid())
{
TreeNode* node = static_cast(parent.internalPointer());
if (node == nullptr || node->type == TreeNode::File)
{
return 0;
}
return node->childrenLoaded ?
node->children.size() : node->loadChildren();
}
else
{
//Unix root '/'
return 1;
}
return 0;
}
WModelIndex FileSystemModel::parent(const WModelIndex& index) const
{
if (!index.isValid())
{
return WModelIndex();
}
auto node = static\_cast(index.internalPointer());
if (node->parent == nullptr)
{
return WModelIndex();
}
if (node->parent->parent == nullptr)
{
return createIndex(0, 0, m\_impl->root.get());
}
const auto grand = node->parent->parent;
const auto parent = node->parent;
const auto res = std::lower\_bound(grand->children.cbegin(),
grand->children.cend(), parent);
const size\_t row = std::distance(grand->children.cbegin(), res);
return createIndex(row, 0, parent);
}
boost::any FileSystemModel::data(const WModelIndex &index, int role) const
{
if (!index.isValid())
{
return boost::any();
}
auto node = static\_cast(index.internalPointer());
if (node == nullptr)
{
return boost::any();
}
switch (role)
{
case DisplayRole:
{
return node->filename;
}
case Path:
{
return node->path;
}
case DecorationRole:
{
try
{
return FILE\_SYSTEM\_ICONS.at(node->type);
} catch (...)
{
return boost::any();
}
}
break;
default:
return boost::any();
}
}
WModelIndex FileSystemModel::index(int row, int column,
const Wt::WModelIndex& parent) const
{
if (!parent.isValid())
{
return createIndex(0, 0, m\_impl->root.get());
}
TreeNode\* pNode = static\_cast(parent.internalPointer());
if (pNode == nullptr)
{
return WModelIndex();
}
return createIndex(row, column, pNode->children[row]);
}
boost::any FileSystemModel::headerData(int section, Orientation orientation,
int role) const
{
if (role == DisplayRole && orientation == Horizontal)
{
return "File name";
}
return boost::any();
}
```
#### **Диалог выбора файлов**
Диалог выбора файлов наследуется от [Wt::WDialog](http://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WDialog.html) и имеет интерфейс:
```
class FileDialog: public Wt::WDialog
{
public:
FileDialog(WObject* parent = nullptr);
virtual void accept();
Wt::WStringList selected() const;
private:
Wt::WTreeView* m_view;
FileSystemModel* m_fs;
};
```
Класс FileDialog содержит в себе нашу модель и древовидное представление [Wt::WTreeView](http://www.webtoolkit.eu/wt/doc/reference/html/classWt_1_1WTreeView.html).
Рассмотрим конструктор:
```
FileDialog::FileDialog(WObject* parent) :
WDialog(parent),
m_view(new WTreeView()),
m_fs(new FileSystemModel(this))
{
setWindowTitle("Selecting files and directories");
auto cancel = new WPushButton("Cancel", footer());
cancel->clicked().connect(this, &WDialog::reject);
m_view->setModel(m_fs);
m_view->setSelectionBehavior(SelectItems);
m_view->setSelectionMode(ExtendedSelection);
auto select = new WPushButton("Select", footer());
select->clicked().connect(this, &FileDialog::accept);
m_view->setSortingEnabled(false);
m_view->setHeaderHeight(0);
m_view->expandToDepth(1);
auto layout = new WVBoxLayout;
layout->addWidget(m_view);
contents()->setLayout(layout);
resize(600, 500);
}
```
Внутри тела конструктора создаются две кнопки, которые размещаются в нижнем колонтитуле, вертикальный layout, который размещается на месте содержимого. Вертикальный layout нужен для выставления размеров *WTreeView*, иначе представление может выйти за пределы диалогового окна.
Конструкция
```
cancel->clicked().connect(this, &WDialog::reject);
```
это механизм сигнал/слотов на базе **Boost.Signals2**(или Boost.Signals, зависит от версии Boost). Два оставшихся методов тривиальны
```
void FileDialog::accept()
{
const auto indxs = m_view->selectedIndexes();
if (indxs.size() > 0)
{
WDialog::accept();
}
}
Wt::WStringList FileDialog::selected() const
{
WStringList list;
const auto indxs = m_view->selectedIndexes();
for (auto indx : indxs)
{
const WString pt = boost::any_cast(
indx.data(FileSystemModel::Path));
list << pt;
}
return list;
}
``` | https://habr.com/ru/post/275453/ | null | ru | null |
# Unsafe.AsSpan: Span<T> как замена указателям?
`C#` — невероятно гибкий язык. На нем можно писать не только бэкэнд или десктопные приложения. Я использую `C#` для работы, в том числе, и с научными данными, которые накладывают определенные требования на инструменты, доступные в языке. Хотя `netcore` захватывает повестку дня (учитывая, что после `netstandard2.0` [большинство](https://devblogs.microsoft.com/dotnet/update-on-net-core-3-0-and-net-framework-4-8/) фич как языков, так и рантайма, не бэк-портируются в `netframework`), я продолжаю работать и с легаси-проектами.
В этой статье я рассматриваю одно неочевидное (но, наверное, желаемое?) применение `Span` и отличие реализации `Span` в `netframework` и `netcore` из-за особенностей `clr`.
**Дисклеймер 1**Фрагменты кода в данной статье ни в коем случае не предназначены для использования в реальных проектах.
Предлагаемое решение (надуманной?) проблемы — это, скорее, proof-of-concept.
В любом случае, реализуя подобное в своем проекте, вы делаете это на свой страх и риск.
**Дисклеймер 2**Я абсолютно уверен, что где-то, в каком-то случае это **обязательно** выстрелит кому-то в колено.
Обход типобезопасности в `C#` вряд ли приводит к чему-то хорошему.
По очевидным причинам, я не тестировал данный код во всех возможных ситуациях, однако предварительные результаты выглядят многообещающими.
А зачем мне вообще `Span`?
==========================
Спэн позволяет работать с массивами `unmanaged`-типов в более удобной форме, уменьшая количество необходимых аллокаций. Несмотря на тот факт, что поддержка спэнов в `BCL` `netframework` практически полностью отсутствует, несколько инструментов можно получить, используя `System.Memory`, `System.Buffers` и `System.Runtime.CompilerServices.Unsafe`.
Использование спэнов в моем легаси-проекте ограничено, однако я нашел им неочевидное применение, попутно наплевав на безопасность типов.
Что же это за применение? В своем проекте я работаю с данными, получаемыми с научного инструмента. Это изображения, которые, в общем случае представляют собой массив `T[]`, где `T` это один из `unmanaged` примитивных типов, например `Int32` (он же `int`). Для корректной сериализации этих изображений на диск, мне необходимо поддерживать невероятно неудобный [легаси-формат](https://en.wikipedia.org/wiki/FITS), который был предложен в [1981-м](http://adsabs.harvard.edu/abs/1981A&AS...44..363W), и с тех пор слабо поменялся. Главная проблема этого формата — он [BigEndian](https://en.wikipedia.org/wiki/Endianess). Таким образом, чтобы записать (или прочитать) несжатый массив `T[]`, нужно поменять endianess каждого элемента. Тривиальная задача.
Какие можно предложить очевидные решения?
1. Итерируем по массиву `T[]`, вызываем `BitConverter.GetBytes(T)`, разворачиваем эти несколько байт, копируем в целевой массив.
2. Итерируем по массиву `T[]`, выполняем махинации вида `new byte[] {(byte)((x & 0xFF00) >> 8), (byte)(x & 0x00FF)};` (должно работать на двухбайтовых типах), пишем в целевой массив.
3. \* Но ведь `T[]` это массив? Элементы находятся подряд, да? Значит можно пойти во все тяжкие, например `Buffer.BlockCopy(intArray, 0, byteArray, 0, intArray.Length * sizeof(int));`. Метод копирует массив в массив игнорируя проверку типов. Нужно лишь не промахнуться с границами и аллокацией. Перемешиваем байты уже в результате.
4. \* Говорят, что `C#` это [`(C++)++`](https://www.computerworld.com.au/article/261958/a-z_programming_languages_c_/?pp=2). Поэтому включаем `/unsafe`, вооружаемся `fixed(int* p = &intArr[0]) byte* bPtr = (byte*)p;` и вот уже можно бегать по байтовому представлению исходного массива, на лету менять endianess и писать блоками на диск (добавив `stackalloc byte[]` или `ArrayPool.Shared` для промежуточного буфера), не выделяя память на целый новый массив байт.
Казалось бы, **4** пункт позволяет решить все проблемы, но явное использование `unsafe`-контекста и работа с указателями — это как-то совсем не то. Тут нам на помощь и приходит `Span`.
`Span`
======
`Span` технически должен предоставлять инструменты для работы с участками памяти практически как работа через указатели, при этом исключая необходимость "закреплять" массив в памяти. Такой `GC`-aware указатель с границами массива. Все отлично и безопасно.
Одно лишь но — несмотря на богатство `System.Runtime.CompilerServices.Unsafe`, `Span` гвоздями прибит к типу `T`. Учитывая, что спэн это, по сути, указатель1 + длина, а что если вытащить этот ваш указатель, преобразовать его к другому типу, пересчитать длину и сделать новый спэн? Благо у нас есть `public Span(void\* pointer, int length)`.
Напишем простой тест:
```
[Test]
public void Test()
{
void Flip(Span span) {/\* тут вращаем endianess \*/}
Span x = new [] {123};
Span y = DangerousCast(x);
Assert.AreEqual(123, x[0]);
Flip(y);
Assert.AreNotEqual(123, x[0]);
Flip(y);
Assert.AreEqual(123, x[0]);
}
```
Более продвинутые чем я разработчики должны сразу сообразить, что здесь не так. Провалится ли тест? Ответ, как это обычно бывает, — **зависит**.
В данном случае зависит в первую очередь от рантайма. На `netcore` тест *должен* работать, а на `netframework` — как получится.
Интересно, что, если убрать часть эссертов, тест начинает корректно работать в 100% случаев.
Давайте разбираться.
1 Я *ошибался*.
Правильный ответ: зависит
=========================
Почему же результат — *зависит*?
Уберем все лишнее и напишем вот такой вот код:
```
private static void Main() => Check();
private static void Check()
{
Span x = new[] {999, 123, 11, -100};
Span y = As(ref x);
Console.WriteLine(@"FRAMEWORK\_NAME");
Write(ref x);
Write(ref y);
Console.WriteLine();
Write(ref x, "Span [0]");
Write(ref y, "Span[0]");
Console.WriteLine();
Write(ref Offset(ref x[0], 1), "Span [0] offset by size\_t");
Write(ref Offset(ref y[0], 1), "Span[0] offset by size\_t");
Console.WriteLine();
GC.Collect(0, GCCollectionMode.Forced, true, true);
Write(ref x, "Span [0] after GC");
Write(ref y, "Span[0] after GC");
Console.WriteLine();
Write(ref x);
Write(ref y);
}
```
Метод `Write` принимает спэн типа `T`, считает адрес первого элемента, и считывает через этот указатель один элемент типа `U`. Иными словами, `Write(ref x)` выведет адрес в памяти + число 999.
Обычный `Write` печатает массив.
Теперь про метод `As<,>`:
```
private static unsafe Span As(ref Span span)
where T : unmanaged
where U : unmanaged
{
fixed(T\* ptr = span)
return new Span(ptr,
span.Length \* Unsafe.SizeOf() / Unsafe.SizeOf());
}
```
Сейчас синтаксис `C#` поддерживает такую запись `fixed`-стэйтмента через неявный вызов метода `Span.GetPinnableReference()`.
Запустим этот метод на `netframework4.8` в `x64` режиме. Смотрим, что получается:
```
LEGACY
[ 999, 123, 11, -100 ]
[ 231, 3, 0, 0, 123, 0, 0, 0, 11, 0, 0, 0, 156, 255, 255, 255 ]
0x|00|00|02|8C|00|00|2F|B0 999 Span [0]
0x|00|00|02|8C|00|00|2F|B0 999 Span[0]
0x|00|00|02|8C|00|00|2F|B8 11 Span [0] offset by size\_t
0x|00|00|02|8C|00|00|2F|B8 11 Span[0] offset by size\_t
0x|00|00|02|8C|00|00|2B|18 999 Span [0] after GC
0x|00|00|02|8C|00|00|2F|B0 6750318 Span[0] after GC
[ 999, 123, 11, -100 ]
[ 110, 0, 103, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
```
Изначально оба спэна (несмотря на разный тип) ведут себя идентично, а `Span`, по сути, представляет byte-view исходного массива. То, что нужно.
Окей, попробуем сдвинуть начало спэна на размер одного `IntPtr` (или `2 X int` на `x64`) и прочитать. Получаем третий элемент массива и корректный адрес. А потом соберем мусор...
```
GC.Collect(0, GCCollectionMode.Forced, true, true);
```
Последний флаг в этом методе просит `GC` уплотнить кучу. После вызова `GC.Collect` `GC` перемещает исходный локальный массив. `Span` отражает эти изменения, а вот наш `Span` продолжает указывать на старый адрес, где теперь непонятно что. Отличный способ прострелить себе все колени сразу!
Теперь посмотрим на результат точно такого же фрагмента кода, вызванного на `netcore3.0.100-preview8`.
```
CORE
[ 999, 123, 11, -100 ]
[ 231, 3, 0, 0, 123, 0, 0, 0, 11, 0, 0, 0, 156, 255, 255, 255 ]
0x|00|00|01|F2|8F|BD|C6|90 999 Span [0]
0x|00|00|01|F2|8F|BD|C6|90 999 Span[0]
0x|00|00|01|F2|8F|BD|C6|98 11 Span [0] offset by size\_t
0x|00|00|01|F2|8F|BD|C6|98 11 Span[0] offset by size\_t
0x|00|00|01|F2|8F|BD|BF|38 999 Span [0] after GC
0x|00|00|01|F2|8F|BD|BF|38 999 Span[0] after GC
[ 999, 123, 11, -100 ]
[ 231, 3, 0, 0, 123, 0, 0, 0, 11, 0, 0, 0, 156, 255, 255, 255 ]
```
Все работает, и работает *стабильно*, насколько я смог убедиться. После уплотнения, оба спэна меняют свой указатель. Отлично! Но как теперь заставить работать это в легаси-проекте?
JIT intrinsic
=============
Я абсолютно забыл, что поддержка спэнов реализована в `netcore` через [интринсик](https://github.com/dotnet/corefx/blob/53edc76f126940875d6ea11ede1f6a00e4a4ce5b/src/Common/src/CoreLib/System/ByReference.cs#L23). Иными словами, `netcore` умеет создавать внутренние указатели даже на фрагмент массива и корректно обновлять ссылки, когда `GC` его шевелит. В `netframework` же `nuget`-реализация спэна — это костыль. По сути, у нас есть два разных спэна: один создается из массива и отслеживает свои ссылки, второй — из указателя и понятия не имеет, на что он указывает. После перемещения исходного массива, спэн-указатель продолжает указывать туда, куда указывал указатель, переданный в его конструктор. Для сравнения, это *примерная* реализация спэна в `netcore`:
```
readonly ref struct Span where T : unmanaged
{
private readonly ByReference \_pointer; // Внутри - магия интринсика
private readonly int \_length;
}
```
и в `netframework`:
```
readonly ref struct Span where T : unmanaged
{
private readonly Pinnable \_pinnable;
private readonly IntPtr \_byteOffset;
private readonly int \_length;
}
```
`_pinnable` содержит ссылку на массив, если таковой был передан в конструктор, `_byteOffset` содержит сдвиг (даже спэн по всему массиву имеет некий ненулевой сдвиг, связанный с тем, как массив представлен в памяти, *наверное*). Если в конструктор передать указатель `void*`, его просто преобразуют в абсолютный `_byteOffset`. Спэн будет прибит намертво к участку памяти, а все инстанс методы изобилуют условиями типа `if(_pinnable is null) {/* верни по указателю */} else {/* посчитай сдвиг от _pinnable */}`. Что делать в такой ситуации?
Как делать не стоит, но я все же сделал
=======================================
Этот раздел посвящен различным реализациям, поддерживаемым `netframework`, которые позволяют осуществить каст `Span -> Span`, сохраняя все нужные ссылки.
**Предупреждаю: это зона ненормального программирования с, возможно, фундаментальными ошибками и Undefined Behavior в конце**
Метод 1: Наивный
----------------
Как показал пример, преобразование указателей не даст нужного результата на `netframework`. Нам нужно значение `_pinnable`. Окей, расчехлим рефлексию, вытащим приватные поля (очень плохо и не всегда возможно), запишем в новый спэн, порадуемся. Есть только одна *ма-аленькая* проблема: спэн это `ref struct`, он не может быть ни аргументом дженерика, ни упакованным в `object`. Стандартные методы рефлексии потребуют, так или иначе, запихать спэн в ссылочный тип. Простого способа (еще и учитывая рефлексию по приватным полям) я не нашел.
Метод 2: We need to go deeper
-----------------------------
Все уже было сделано до меня ([[1]](https://habr.com/en/post/423657/), [[2]](https://habr.com/en/post/358872/), [[3]](https://www.youtube.com/watch?v=hGxXt4AyWnU)). Спэн — структура, вне зависимости от `T` три поля занимают одинаковое количество памяти (*на одной архитектуре*). А что если `[FieldOffset(0)]`? Сказано — сделано.
```
[StructLayout(LayoutKind.Explicit)]
ref struct Exchange
where T : unmanaged
where U : unmanaged
{
[FieldOffset(0)]
public Span Span\_1;
[FieldOffset(0)]
public Span Span\_2;
}
```
Но при запуске программы (а точнее при попытке использовать тип) нас встречает `TypeLoadException` — дженерик не может быть `LayoutKind.Explicit`. Окей, не беда, пойдем по сложному пути:
```
[StructLayout(LayoutKind.Explicit)]
public ref struct Exchange
{
[FieldOffset(0)]
public Span ByteSpan;
[FieldOffset(0)]
public Span SByteSpan;
[FieldOffset(0)]
public Span UShortSpan;
[FieldOffset(0)]
public Span ShortSpan;
[FieldOffset(0)]
public Span UIntSpan;
[FieldOffset(0)]
public Span IntSpan;
[FieldOffset(0)]
public Span ULongSpan;
[FieldOffset(0)]
public Span LongSpan;
[FieldOffset(0)]
public Span FloatSpan;
[FieldOffset(0)]
public Span DoubleSpan;
[FieldOffset(0)]
public Span CharSpan;
}
```
Теперь можно сделать так:
```
private static Span As2(Span span)
{
var exchange = new Exchange()
{
IntSpan = span
};
return exchange.ByteSpan;
}
```
Метод работает с одной лишь проблемой — поле `_length` копируется как есть, поэтому при касте `int` -> `byte` длина байт-спэна в 4 раза меньше реального массива.
Не проблема:
```
[StructLayout(LayoutKind.Sequential)]
public ref struct Raw
{
public object Pinnable;
public IntPtr Pointer;
public int Length;
}
[StructLayout(LayoutKind.Explicit)]
public ref struct Exchange
{
/* */
[FieldOffset(0)]
public Raw RawView;
}
```
Теперь через `RawView` можно получить доступ к каждому отдельному полю спэна.
```
private static Span As2(Span span)
{
var exchange = new Exchange()
{
IntSpan = span
};
var exchange2 = new Exchange()
{
RawView = new Raw()
{
Pinnable = exchange.RawView.Pinnable,
Pointer = exchange.RawView.Pointer,
Length = exchange.RawView.Length \* sizeof / sizeof
}
};
return exchange2.ByteSpan;
}
```
И это работает **так, как надо**, если игнорировать применение грязных трюков. Минус — дженерик версию конвертера создать нельзя, придется довольствоваться предопределенными типами.
Метод 3: Безумный
-----------------
Как и любой нормальный программист, я люблю автоматизировать вещи. Необходимость написания конвертеров для любой пары `unmanaged` типов меня не радовала. Какое решение можно предложить? Правильно, заставить `CLR` написать код *за вас*.
Как этого добиться? Есть разные способы, есть [статьи](https://habr.com/en/post/358872/). Если коротко, процесс выглядит так:
Создаем билдер сборки -> создаем билдер модуля -> строим тип -> {Поля, Методы, и т.д.} -> на выходе получаем инстанс типа `Type`.
Чтобы точно понять, как должен выглядеть тип (ведь это `ref struct`), используем любой инструмент типа `ildasm`. В моем случае это был **dotPeek**.
Создание type builder выглядит примерно так:
```
var typeBuilder = _mBuilder.DefineType($"Generated_{typeof(T).Name}",
TypeAttributes.Public
| TypeAttributes.Sealed
| TypeAttributes.ExplicitLayout // <- Вот это важно
| TypeAttributes.AnsiClass
| TypeAttributes.BeforeFieldInit, typeof(ValueType));
```
Теперь — поля. Так как напрямую скопировать `Span` в `Span` из-за разницы длин мы не можем, нам нужно на каждый каст создавать по два типа вида
```
[StructLayout(LayoutKind.Explicit)]
ref struct Generated_Int32
{
[FieldOffset(0)]
public Span Span;
[FieldOffset(0)]
public Raw Raw;
}
```
Здесь `Raw` мы можем объявить руками и переиспользовать. Не забываем про `IsByRefLikeAttribute`. С полями все просто:
```
var spanField = typeBuilder.DefineField("Span", typeof(Span), FieldAttributes.Private);
spanField.SetOffset(0);
var rawField = typeBuilder.DefineField("Raw", typeof(Raw), FieldAttributes.Private);
rawField.SetOffset(0);
```
На этом все, простейший тип готов. Теперь кэшируем сборку, модуль. Кастомные типы кэшируем, например, в словарь (`T -> Generated_{nameof(T)}`). Создаем обертку, которая по двум типам `TIn` и `TOut` генерирует два типа-хэлпера и выполняет нужные операции над спэнами. Есть одно но. Как и в случае с рефлексией, использовать ее на спэнах (или на других `ref struct`) практически невозможно. *Либо я не нашел простого решения*. Как же быть?
Delegates to the rescue
-----------------------
Методы рефлексии выглядят обычно примерно так:
```
object Invoke(this MethodInfo mi, object @this, object[] otherArgs)
```
Они не несут в себе информацию о типах, поэтому если боксинг (= упаковка) для вас приемлемы — проблем нет.
В нашем случае, `@this` и `otherArgs` должны содержать в себе `ref struct`, что мне обойти не удалось.
Однако есть способ проще. Давайте представим что у типа есть геттер и сеттер методы (не свойства, а вручную созданные простейшие методы).
Например:
```
void Generated_Int32.SetSpan(Span span) => this.Span = span;
```
В дополнение к методу мы можем объявить тип делегата (явно в коде):
```
delegate void SpanSetterDelegate(Span span) where T : unmanaged;
```
На такое нам приходится идти, потому что стандартный экшен должен был бы иметь сигнатуру `Action>`, но спэны нельзя использовать как дженерик-аргументы. `SpanSetterDelegate`, однако, абсолютно валидный делегат.
Создадим себе нужные делегаты. Для этого нужно провести стандартные манипуляции:
```
var mi = type.GetMethod("Method_Name"); // Предполагая, что наш метод public & instance
var spanSetter = (SpanSetterDelegate) mi.CreateDelegate(typeof(SpanSetterDelegate), @this);
```
Теперь `spanSetter` можно использовать как, например, `spanSetter(Span.Empty);`. Что до `@this`2, то это инстанс нашего динамического типа, созданный, разумеется, через `Activator.CreateInstance(type)`, ведь у структуры есть дефолтный конструктор без аргументов.
Итак, последний рубеж — нам нужно динамически сгенерировать методы.
2 Можно обратить внимание, что здесь происходит что-то не то — `Activator.CreateInstance()` упаковывает `ref struct`-инстанс. См. конец следующего раздела.
Знакомьтесь, `Reflection.Emit`
------------------------------
Я думаю, что методы можно было бы сгенерировать, используя `Expression`, т.к. тела наших тривиальных геттеров/сеттеров состоят из буквально пары выражений. Я же выбрал другой, более прямолинейный подход.
Если посмотреть на **IL**-код тривиального геттера, то можно увидеть что-то типа (`Debug`, `X86`, `netframework4.8`)
```
nop
ldarg.0
ldfld /* что-то */
stloc.0
br.s /* адрес */
ldloc.0
ret
```
Здесь куча мест для остановки и отладки.
В релизной же версии остается только самое важное:
```
ldarg.0
ldfld /* что-то */
ret
```
Нулевым аргументом инстанс-метода является… `this`. Таким образом, в **IL** написано следующее:
1) Загрузи `this`
2) Загрузи значение поля
3) Верни
Просто, да? В `Reflection.Emit` есть специальная перегрузка, принимающая, кроме оп-кода, еще и параметр-дескриптор поля. Как раз такой, как мы получали ранее, например `spanField`.
```
var getSpan = type.DefineMethod("GetSpan",
MethodAttributes.Public
| MethodAttributes.HideBySig,
CallingConventions.Standard,
typeof(Span), Array.Empty());
gen = getSpan.GetILGenerator();
gen.Emit(OpCodes.Ldarg\_0);
gen.Emit(OpCodes.Ldfld, spanField);
gen.Emit(OpCodes.Ret);
```
Для сеттера немного сложнее, нужно загрузить на стэк `this`, загрузить первый аргумент функции, затем вызвать инструкцию записи в поле и вернуть ничего:
```
ldarg.0
ldarg.1
stfld /* идентификатор поля */
ret
```
Проделав такую процедуру и для поля `Raw`, объявив нужные делегаты (или использовав стандартные), получаем динамический тип и четыре метода-аксессора, из которых сгенерированы корректные дженерик-делегаты.
Пишем класс-обертку, который по двум дженерик-параметрам (`TIn`, `TOut`) получает инстансы типа `Type`, ссылающиеся на соответствующие (закэширвоанные) динамические типы, после чего, создает по одному объекту каждого типа, и генерирует четыре дженерик-делегата, а именно
1. `void SetSpan(Span span)` чтобы записать исходный спэн в структуру
2. `Raw GetRaw()` чтобы считать содержимое спэна как `Raw`-структуру
3. `void SetRaw(Raw raw)` чтобы записать модифицированную `Raw` структуру во второй объект
4. `Span GetSpan()` чтобы вернуть спэн желаемого типа с корректно выставленными и пересчитанными полями.
Интересно что инстансы динамических типов нужно создать один раз. При создании делегата ссылка на эти объекты передается как параметр `@this`. **Здесь происходит нарушение правил. `Activator.CreateInstance` возвращает `object`. По всей видимости связано это с тем, что сам по себе динамический тип не получился `ref`-like (**`type.IsByRef`~~Like~~ `== false`**), однако `ref`-like поля создать удалось. Видимо, такое ограничение присутствует в языке, но `CLR` это переваривает. Возможно, именно здесь будут простреливаться колени в случае нестандартного использования.** 3
Итак, получаем инстанс дженерик типа, содержащий в себе четыре делегата и две неявные ссылки на инстансы динамических классов. Делегаты и структуры можно переиспользовать при выполнении одинаковых кастов подряд. Для пущего быстродействия, снова кэшируем (уже тип-конвертер) по паре `(TIn, TOut) -> Generator`.
Штрих последний: приводим типы, `Span -> Span`
----------------------------------------------
```
public Span Cast(Span span)
{
// Быстрый путь если спэн пуст
if (span.IsEmpty)
return Span.Empty;
// Caller ответственен за то, чтобы размеры спэнов совпадали в байтах
if (span.Length \* Unsafe.SizeOf() % Unsafe.SizeOf() != 0)
throw new InvalidOperationException();
// Загружаем спэн в первую структуру
// Span \_input.Span = span;
\_spanSetter(span);
// Считываем Raw
// Raw raw = \_input.Raw;
var raw = \_rawGetter();
var newRaw = new Raw()
{
Pinnable = raw.Pinnable, // Вточности тот же Pinnable
Pointer = raw.Pointer, // Идентичный сдвиг
Length = raw.Length \* Unsafe.SizeOf() / Unsafe.SizeOf() // Новая длина
};
// Загружаем новый Raw во вторую структуру
// Raw \_output.Raw = newRaw;
\_rawSetter(newRaw);
// Вытаскиваем спэн нужного типа
// Span \_output.Span
return \_spanGetter();
}
```
Вывод
=====
Иногда — ради спортивного интереса — можно обойти некоторые ограничения языка и реализовать нестандартный функционал. Разумеется, на свой страх и риск. Стоит отметить, что динамический метод позволяет полностью отказаться от указателей и `unsafe / fixed` контекста, что может быть бонусом. Очевидным минусом является необходимость рефлексии и генерации типов.
Для тех, кто дочитал до конца.
==============================
**Результаты наивного бенчмарка**А насколько это все быстро?
Я сравнил скорость кастов в глупом сценарии, который не отражает реальное/потенциальное использование таких кастов и спэнов, но хотя бы дает представление о скорости.
1. `Cast_Explicit` использует преобразование через явно декларируемый тип, как в *Методе 2*. Каждый каст требует аллокации двух небольших структур и доступов к полям;
2. `Cast_IL` реализует *Метод 3*, но каждый раз заново создает экземпляр `Generator`, что приводит к постоянным поискам по словарям, после того как первый проход генерирует все типы;
3. `Cast_IL_Cached` кэширует непосредственно инстанс конвертера `Generator`, из-за чего в среднем оказывается быстрее, т.к. весь каст сводится к вызовам четырех делегатов;
4. `Buffer` достигает аналогичного функционала, копируя побайтово исходный массив в массив байтов, после чего выполняя аналогичный пэйлоад. Целевой массив байтов всегда переиспользуется.
В качестве пэйлоада — подсчет суммы байтов в байтовом представлении части массива `int[N]` размера порядка `N/2` со случайным сдвигом.
Из таблицы следует, что копирование данных в соседний массив оказывается быстрее, чем пляски со спэнами. Каст спэнов с помощью кэшированного конвертера не сильно отстает от жадной реализации через копирование, выигрывая у двух других реализаций за счет отсутствия аллокаций и поиска по словарям. В общем и целом, если первый вызов каста однозначно будет долгим за счет рефлексии, последующие вызовы преобразования из и в уже известные типы происходят довольно быстро. Таким образом, можно *почти* *эффективно* *немножечко нарушая правила игры* модифицировать байтовое представление элементов `unmanaged` типа без *этих ваших указателей*.
```
BenchmarkDotNet=v0.11.5, OS=Windows 10.0.18362
Intel Core i7-2700K CPU 3.50GHz (Sandy Bridge), 1 CPU, 8 logical and 4 physical cores
[Host] : .NET Framework 4.7.2 (CLR 4.0.30319.42000), 32bit LegacyJIT-v4.8.3815.0
Clr : .NET Framework 4.7.2 (CLR 4.0.30319.42000), 32bit LegacyJIT-v4.8.3815.0
Job=Clr Runtime=Clr InvocationCount=1
UnrollFactor=1
```
| Method | N | Mean | Error | StdDev | Median | Ratio | RatioSD |
| --- | --- | --- | --- | --- | --- | --- | --- |
| **Cast\_Explicit** | **100** | **362.2 ns** | **18.0967 ns** | **52.7888 ns** | **400.0 ns** | **1.00** | **0.00** |
| Cast\_IL | 100 | 1,237.9 ns | 28.5954 ns | 67.4027 ns | 1,200.0 ns | 3.47 | 0.51 |
| Cast\_IL\_Cached | 100 | 522.8 ns | 25.2640 ns | 71.2576 ns | 500.0 ns | 1.46 | 0.27 |
| Buffer | 100 | 300.0 ns | 0.0000 ns | 0.0000 ns | 300.0 ns | 0.78 | 0.11 |
| | | | | | | | |
| **Cast\_Explicit** | **1000** | **2,628.6 ns** | **54.0688 ns** | **64.3650 ns** | **2,600.0 ns** | **1.00** | **0.00** |
| Cast\_IL | 1000 | 3,216.7 ns | 49.8568 ns | 38.9249 ns | 3,200.0 ns | 1.21 | 0.03 |
| Cast\_IL\_Cached | 1000 | 2,484.6 ns | 44.9717 ns | 37.5534 ns | 2,500.0 ns | 0.94 | 0.02 |
| Buffer | 1000 | 2,055.6 ns | 43.9695 ns | 73.4631 ns | 2,000.0 ns | 0.78 | 0.03 |
| | | | | | | | |
| **Cast\_Explicit** | **1000000** | **2,515,157.1 ns** | **11,809.8538 ns** | **10,469.1278 ns** | **2,516,050.0 ns** | **1.00** | **0.00** |
| Cast\_IL | 1000000 | 2,263,826.7 ns | 23,724.4930 ns | 22,191.9054 ns | 2,262,000.0 ns | 0.90 | 0.01 |
| Cast\_IL\_Cached | 1000000 | 2,265,186.7 ns | 19,505.5913 ns | 18,245.5422 ns | 2,266,300.0 ns | 0.90 | 0.01 |
| Buffer | 1000000 | 1,959,547.8 ns | 39,175.7435 ns | 49,544.7719 ns | 1,959,200.0 ns | 0.78 | 0.02 |
| | | | | | | | |
| **Cast\_Explicit** | **100000000** | **255,751,392.9 ns** | **2,595,107.7066 ns** | **2,300,495.3873 ns** | **255,298,950.0 ns** | **1.00** | **0.00** |
| Cast\_IL | 100000000 | 228,709,457.1 ns | 527,430.9293 ns | 467,553.7809 ns | 228,864,100.0 ns | 0.89 | 0.01 |
| Cast\_IL\_Cached | 100000000 | 227,966,553.8 ns | 355,027.3545 ns | 296,463.9203 ns | 227,903,600.0 ns | 0.89 | 0.01 |
| Buffer | 100000000 | 213,216,776.9 ns | 1,198,565.1142 ns | 1,000,856.1536 ns | 213,517,800.0 ns | 0.83 | 0.01 |
**Acknowledgements**Спасибо [**JetBrains**](https://www.jetbrains.com/) (у вас классный офис в СПБ :-)) и команде [**R#**](https://www.jetbrains.com/resharper/) за отличные инструменты **VS** и standalone-приложение **dotPeek**, а также за студенческую лицензию. Спасибо `BenchmarkDotNet` за BenchmarkDotNet, youtube-каналам [**NDC Conferences**](https://www.youtube.com/channel/UCNPwMPudMEw-gnAT4zh_UZg) и [**DotNext**](https://www.youtube.com/channel/UCNPwMPudMEw-gnAT4zh_UZg) за доступ к докладам, и вам, за то что потратили время и прочитали до конца.
P.S.
====
**Работа над ошибками**3 Уже после написания статьи я осознал проблему с тем, что динамический тип оказался не `ref`, и что это не совсем то, что было обещано. Решение~~м~~ этой проблемы (и проблемы упаковки спэна) может быть следующим. Учитывая все ограничения `ref` structs, можно генерировать вместо аксессоров статические методы вида
```
static Raw Generated_Int32.GetRaw(Span span)
{
var inst = new Generated\_Int32()
{
Span = span
};
return inst.Raw;
}
```
Это все еще валидный код, который можно записать через `Reflection.Emit`. Здесь потребуется уже целая локальная переменная, но нам *должен* помочь `ILGenerator.DeclareLocal`. Добавив в пару метод
```
static Span Generated\_Int32.GetSpan(Raw raw);
```
и пару делегатов
```
delegate Raw GetRaw(Span span) where T : unmanaged;
delegate Span GetSpan(Raw raw) where T : unmanaged;
```
можно, *я полагаю*, добиться корректно работающего кода в случае `ref` — структур. Т.к. статические методы не требуют инстансов, генерация делегатов будет выглядеть как
```
var getter = type.GetMethod(@"GetRaw", BindingFlags.Static | BindingFlags.Public).CreateDelegate(typeof(GetRaw), null) as GetRaw;
```
а вызов — как
```
Raw raw = getter(Span.Empty);
Raw newRaw = convert(raw);
Span = setter(newRaw);
```
*UPD01: Борьба с очепятками* | https://habr.com/ru/post/465077/ | null | ru | null |
# Surf Studio: машинное обучение в production
*Представляем гостевой пост от компании Surf Studio ([Certified Google Developer Agency](https://developers.google.com/agency/directory/)).*
Привет, Хабр. Меня зовут Александр Ольферук ([@olferuk](https://habrahabr.ru/users/olferuk/)), я занимаюсь машинным обучением в [Surf](http://surfstudio.ru/). С 2011 года мы разрабатываем мобильные приложения для крупного бизнеса, а теперь готовим к релизу B2B-продукт с TensorFlow. Спасибо коллегам из Google за возможность рассказать немного о нашем опыте.
В современном машинном обучении много энтузиастов, но критически не хватает профессионалов. В нашей команде я вживую наблюдал превращение таких энтузиастов в специалистов с боевым опытом. Разрабатывая первый для нас коммерческий продукт, связанный с машинным обучением, команда столкнулась с кучей нюансов. Всеми любимые соревнования на Kaggle оказались очень далеки от решения задач реального бизнеса. Сейчас хочу поделиться опытом, показать примеры и рассказать немного о том, через что мы прошли.
### Задача
Задача нашей системы — предсказывать оптимальную наценку на товары розничной сети, имея трехлетнюю историю продаж. Цель — сделать бизнес клиента более прибыльным, конечно же. Данные агрегированы по неделям: известны технические характеристики товаров, сколько единиц товара было продано, в скольких магазинах товар есть в наличии, цены закупки и розницы, а также прибыль, полученная в итоге. Это сырые данные, на продажи влияет еще множество факторов. Все остальные признаки, начиная от инфляции и цен на сырье, и заканчивая погодой, мы собрали самостоятельно. Перед нами был каталог с более чем 20 000 товаров. Из-за различия в их типах мы пришли к построению не одной, а сразу семейства моделей. Каждая из них тренируется на истории о товарах, с точки зрения продаж ведущих себя одинаково.
В соревнованиях по машинному обучению величина для предсказания обычно определена заранее. В реальном же бизнес-проекте мы вправе выбирать ее самостоятельно. Что лучше: пытаться предсказать прибыль, наценку, или, может, количество продаваемых товаров? Отталкиваемся от того, что мы можем предсказать эффективно, и что позволит клиенту зарабатывать больше денег.
Ось X здесь — время, разбитое по неделям. Y — нормированная величина, включающая прибыль (синяя линия) и количества продаж (оранжевая линия) Поскольку они почти совпадают, в нашей задаче мы можем опираться или на любую из них.
Есть и другое, не менее важное отличие. Реальный мир не так совершенен, как искусственные модели. Если в соревнованиях единственным важным критерием является точность, то в реальном бизнес-проекте жизненно-важно соблюсти хрупкий баланс между точностью и здравым смыслом.
### Как начать проект?
Первым делом нужно выбрать подходящую метрику. Она должна не только отражать точность решения, но и соответствовать логике предметной области. Очевидно, что при выборе наценки для товара для максимизации прибыли, бессмысленно выбирать ее нулевой или крайне большой. Это невыгодно либо покупателю, либо магазину. А значит решение нужно искать в доверительном интервале, основываясь на разумных ценовых пределах для конкретного товара, а также на его старой цене.
Про кросс-валидацию сказано уже много, [описано множество техник](http://scikit-learn.org/stable/modules/cross_validation.html). Наша же задача связана с историческими данными, то есть меняющимися во времени. Поэтому разбивать выборку на случайные фолды нельзя, можно лишь предсказывать будущие значения уровня прибыли, обучаясь на прошлом.
Однако не все данные одинаково полезны. Как я уже говорил, при построении моделей мы учитываем реальную жизнь. Аномальные данные могут исказить общую картину и существенно сказаться на эффективности модели. Поэтому данные, собранные в период кризиса конца 2015 — начала 2016, мы решили не учитывать.
### Pipeline
После выбора метрики и кросс-валидации усилия команды должны быть брошены на то, чтобы как можно раньше реализовать end-to-end структуру.
Структура на схеме постоянна и не должна меняться с развитием проекта. На первых порах лучше ограничить очистку данных хотя бы борьбой с отсутствующими значениями: для большинства классификаторов критично отсутствие NaN-значений в данных. Отложить следует также трансформацию признаков и добавление новых.
После этого нужно выбрать baseline-модель, например решающий лес. Используйте ее для формирования первой отчетности. Ответьте на два вопроса: «Что хотел бы видеть заказчик?», «Какого рода результаты будут понятны и полезны экспертам предметной области?». Отчеты и необходимые графики формируйте исходя из ответов на эти вопросы. В ходе дальнейшей разработки стоит возвращаться к этому шагу, заново отвечать, сохранять ответы, анализировать прогресс.
Мы же на практике получили систему с формируемой отчетностью достаточно поздно. Поэтому наглядно посмотреть положительную динамику в развитии модели весьма затруднительно.
В роли архитектуры для решения подобных задач себя отлично зарекомендовали пайплайны — абстракции, представляющие цепочку преобразований или композицию функций.
В изначальной реализации каждый из этапов в этой цепочке — трансформер, принимающий на вход объект класса **ndarray** (является numpy-объектом).
Мы решили улучшить это решение. На каждом этапе хотелось получать новый Pandas dataframe. В таком случае классификаторы получат из финальной таблицы все необходимые для обучения признаки, а визуализации упростится, ведь все поясняющие метки под рукой.
От таких библиотек, как [sklearn-pandas](https://github.com/paulgb/sklearn-pandas) или [luigi](https://github.com/spotify/luigi), мы отказались. Фактически мы написали собственный велосипед. Это небольшой и очень сырой хелпер, который мы сделали исключительно для себя. В ближайшее время причешем, но пользоваться можно [уже сейчас](https://github.com/surfstudio/Bacchus). Мы постарались сделать прозрачный и емкий интерфейс с учетом перечисленных выше особенностей.
Вот несколько примеров-этапов из нашего пайплайна.
Добавляем цены на металл, а также цены с лагом в 1 и 2 месяца:
```
('add_metal', DFFeatureUnion([
('metal', DFPipeline([
('load_metal', MetalAppender()),
('metal_lag', Lagger([4, 8]))
]))
]))
```
И еще один:
```
('lags', Lagger(columns_strategies={
'Z': { 'lags': [1, 2], 'groupby': 'name' },
'X': { 'lags': [1], 'groupby': 'name' },
'Y': { 'lags': [1], 'groupby': 'name' },
'markup': { 'lags': [1], 'groupby': 'name' }
}))
```
Здесь логика несколько сложнее, чем просто сдвинуть колонку оператором **shift** из коробки Pandas. Мы должны учесть, что каждый из признаков сдвигается только для конкретного товара, а не во всей таблице разом. Для того, чтобы решить эту проблему, и был создан класс **Lagger**.
### Модель разработки
Дальнейшее развитие проекта идет по спиралевидной модели разработки. Если у вас есть новые идеи: подключение новых признаков или другой способ обработки имеющихся — проверяйте. С выстроенной архитектурой проверка каждой вашей гипотезы будет выглядеть так:
1. Модифицируем пайплайн обработки данных, вносим необходимые изменения;
2. переучиваем estimator, подбираем оптимальные гиперпараметры;
3. вычисляем новый score для полученного классификатора;
4. визуализируем результаты, формируем отчетность, сравниваем, делаем выводы.
Небольшое уточнение по третьему пункту. Стоит обратить внимание не на абсолютные значения метрики, а только на ее изменение. Мало того: нельзя доверять этой разнице, если в масштабах вашей выборки все укладывается в рамки случайного отклонения.
Есть хорошие гайдлайны по организации проекта. Можете ознакомиться с [этим](https://blog.godatadriven.com/how-to-start-a-data-science-project-in-python) и [этим](https://drivendata.github.io/cookiecutter-data-science), например.
Если открыть папку проекта, то вот, что мы увидим внутри:
```
project/
├── data/ <- исходные предоставленные клиентом данные
├── cache/ <- pickle-файлы со всякой всячиной
├── notebooks/ <- тетрадки
├── scripts/ <- *.py-скрипты с протестированным кодом
├── logs/ <- логи
├── out/ <- все обработанные данные, в том числе:
└─ reports/ <- отчеты, в нашем случае xls-файлы
└─ plots/ <- графики, в нашем случае сделанные в plotly
├── requirements <- список всех зависимостей проекта
└── README.md
```
Как разделить таски между членами команды, чтобы работать, не мешая друг другу? Мы пришли к такой схеме: в рабочей директории есть набор Jupyter-тетрадок, Python-скрипты и сами данные: кэш, отчеты, графики. Каждый работает в отдельной тетрадке. Думаю, не нужно говорить, что тетрадь должна быть хорошо прокомментирована, а все вычисления в них воспроизводимы.
Сколько нужно таких тетрадок и насколько большими они должны быть? Из нашего опыта — отдельная тетрадь для каждого эксперимента. Пример: «Проверка необходимости внедрения доверительного интервала для предсказаний». Это включает в себя как необходимый код логики, так и визуализацию. Опять же, хорошо и посмотреть, что [советуют другие](https://svds.com/jupyter-notebook-best-practices-for-data-science/).
Как только эксперимент завершен и гипотеза проверена — все необходимые функции тестируются и отправляются в Python-скрипты. Если эксперимент себя оправдал, конечно.
### Визуализируй это
Прежде чем подавать данные на вход в классификатор и оценивать результат, следует разобраться, с чем же имеем дело. Вот, какие инструменты нам помогли нам в работе:
• Для **визуализации отсутствующих значений** пользовались библиотекой [MissingNo](https://github.com/ResidentMario/missingno).
• Для того, чтобы **оценить характер распределения признака**, мы пользовались гистограммами: violin plot (его предоставляет, например, библиотека seaborn), box plot. Зачем это нужно?
* Характер распределения подсказывает, как поступить с отсутствующим значением: для скошенных вполне подойдет заполнение модой, но в случае нормального распределения следует воспользоваться матожиданием.
* Скошенные данные данные нужно обрабатывать соответственно. Например, использование логарифмирования или нахождение корня N-й степени делает распределение признака более похожим на нормальное. Обычно это помогает увеличить точность.
• Для **оценки важности признака** использовали factor plot.
• Для **оценки попарной корреляции** признаков использовали correlation matrix и scatterplot matrix. Цель — найти сильно коррелированные признаки и исключить схожие, если такие имеются. Явно значимой пользы для классификатора они не несут, лишь увеличивают дисперсию предсказаний.
Вот как мы проверили влияние инфляции. На графике синим показано изменение уровня розничной цены на товар во времени. Однако стоит лишь вычесть инфляцию (оранжевые точки), становится видно, что розничная цена колеблется в районе определенного уровня (если считать все в ценах января 2014 года, то есть нулевой недели). Значит, мы правильно учли влияние внешнеэкономического фактора.
### Переезжаем в облака с Google
Итак, у нас построен пайплайн, делающий все необходимое: от загрузки и обработки данных до формирования финального предсказания. Теперь следует задуматься о том, как сделать модели точнее.
Для этого мы можем:
* выбирать лучшие признаки;
* добавлять новые;
* искать лучшие гиперпараметры моделей.
Если же требуется модифицировать готовый пайплайн, например, изменить MinMaxScaler на StandardScaler — придется обработать данные и настраивать параметры моделей заново. Много ли у вас данных или мало, на домашних и рабочих компьютерах пробегать десятки циклов grid search для поиска лучших гиперпараметров — удел терпеливых. Это очень долго. Очень.
У нас решение созрело сразу: переезжаем в [Google Cloud](https://cloud.google.com/compute/). От [DataLab](https://cloud.google.com/datalab/) нам, однако, пришлось отказаться: поддерживается только Python версии 2.7. В рамках задачи нам не требовалась богатая инфраструктура, нам нужна была очень мощная виртуальная машина, а [JupyterHub](https://github.com/jupyterhub/jupyterhub) мы можем развернуть и сами.
На удаленной машине создали несколько директорий: общую и отдельные для каждого члена команды. Это позволило каждому не только работать в общей среде, но и при желании организовать собственный git flow в отдельном разделе. Безопасности ради все ходили исключительно по https, ssh-сертификат тоже сделали.
Из интересного: скрипты Google для старта виртуальных машин написаны на Python 3.5 и не хотели дружить с нашим Python 3.6. К счастью, все оказалось решаемо.
Стоила ли игра свеч? Безусловно! Чтобы перебрать все гиперпараметры для пайплайна простым рабочим компьютерам требовалась пара дней. В облаке Google все оказалось гораздо быстрее. Уходишь с работы домой? Пришел утром и все уже готово.
### Что в итоге?
Из ERP-системы клиента (1С, SAP, Oracle и другие) по требованию можно выгружать исторические данные о продажах. Группа товаров, для которой нужно сформировать прогнозы, обозначена отдельно. Добавляем дополнительные данные, собранные из открытых источников.
Так как оптимальные параметры модели найдены и закэшированы, остается немного: обучить модель, и с ее помощью генерировать новые отчеты. В отчетах для клиента собирается как агрегированная статистика по имеющимся данным, так и прогнозы: по компании, по категориям товаров, по отдельным товарам.
Клиент может корректировать ценовую политику на основе полученных прогнозов.
### А/B-тест по-хардкору
Чтобы показать бизнесу, что умные машины могут не только распознавать картинки с арбузами и писать забавные стихи, нужны результаты. Пока в индустрии широко известных результатов нет, все будут с большим опасением смотреть на подобные решения.
Нам очень повезло с клиентом. Они поверили в новую для них технологию и дали нам важный шанс — провести хардкорнейший A/B-тест. Нашему коду доверили формировать рекомендации по ценам на все товары сети в целом регионе. Итоговые данные сравним с данными по регионам, где цены формируются по старинке. Если все будет хорошо — будем гордиться тем, что немножко изменили мир, сделали свой скромный вклад в индустрию и проникновение машинного обучения в бизнес. Скрестите за нас пальцы?
### В завершении
Помните, что простые решения часто оказываются лучшими, а лучший код — чистый.
Чистите зубы дважды в день.
Перечитайте МакКонелла.
Кроссфит и ставки на спорт не стоят потраченного времени.
Проводите больше времени с семьей.
*Удачи, счастья, здоровья!* | https://habr.com/ru/post/325896/ | null | ru | null |
# Сказ о том, как я Home Assistant настраивал
**Home Assistant** — это популярная система умного дома, которая автоматизирует привычные бытовые процессы и работает на YAML файлах. В этой статье я расскажу, как настроить Home Assistant (далее HA), и что конкретно я использую в повседневной жизни. Это поможет вам избежать ошибок и быстрее продвинуться в изучении HA.
На Хабре уже есть статьи о HA ([раз](https://habr.com/ru/post/471822/), [два](https://habr.com/ru/post/321606/), [три](https://habr.com/ru/post/543446/)), но здесь я хочу рассказать об установке и настройке системы от начала до конца. От первого запуска сервера до полноценно работающей системы, которую потом можно улучшать и дорабатывать для себя.
Основной единицей в HA является интеграция — логика, которая описывает взаимодействие с умным устройством или внешним сервисом. Большая часть полезной нагрузки HA ориентировано на связку: умное устройство + интеграция или внешнее API + интеграция.
*Набор моих интеграций*
Железо, участвующее в статье:
* Микроконтроллер [Esp8266](https://aliexpress.ru/item/32665100123.html?spm=a2g0o.productlist.0.0.43163fc7ZK8xC3&algo_pvid=52d218aa-7ab6-46a3-9eaf-14b080448fc9&algo_expid=52d218aa-7ab6-46a3-9eaf-14b080448fc9-0&btsid=0b8b034116139167895853798ec510&ws_ab_test=searchweb0_0,searchweb201602_,searchweb201603_&sku_id=66676497214), а также датчик температуры и влажности [DHT11](https://aliexpress.ru/item/32769460765.html?spm=a2g0o.productlist.0.0.1d7e4078uAIhTE&algo_pvid=d9617464-94ad-4efd-a296-d8e16a586bfa&algo_expid=d9617464-94ad-4efd-a296-d8e16a586bfa-0&btsid=0b8b034116139168331753995ec510&ws_ab_test=searchweb0_0,searchweb201602_,searchweb201603_&sku_id=10000000314521195);
* Лампа [Xiaomi Desk Lamp](https://aliexpress.ru/item/33031924114.html?spm=a2g0o.productlist.0.0.4dd5114daeT33Y&algo_pvid=fe52d4f3-87aa-4c9a-9740-908f9b97cde3&algo_expid=fe52d4f3-87aa-4c9a-9740-908f9b97cde3-3&btsid=0b8b035616141748681421680ee460&ws_ab_test=searchweb0_0,searchweb201602_,searchweb201603_);
* [Raspberry Pi 4B](https://aliexpress.ru/item/4000054878108.html?spm=a2g0s.12269583.0.0.54fc3d2cfkvA15) в 2GB версии, как сервер для HA (в дальнейшем буду ее называть малинкой);
* [Xiaomi Router 4A](https://aliexpress.ru/item/33032437060.html?spm=a2g0o.productlist.0.0.30dd66a0B47SWv&algo_pvid=2e35927c-dea6-4808-b549-6a0832aa4b3a&algo_expid=2e35927c-dea6-4808-b549-6a0832aa4b3a-1&btsid=0b8b035616141750516702744ee460&ws_ab_test=searchweb0_0,searchweb201602_,searchweb201603_) .
Сервисы, которые будем использовать:
* OpenWeatherMap для получения погоды, температуры, влажности на улице и других метеопараметров;
* Telegram для создания системы уведомлений;
* Google drive для создания бекапов;
* SpeedTest для замеров скорости;
* А также OpenUV для замеров ультрафиолетового излучения и др.
Установка
=========
Установка HA предельно проста:
1. Записать образ HA на SD карточку (подробная инструкция с ссылками на скачивание для разных версий Raspberry Pi [тут](https://www.home-assistant.io/installation/raspberrypi)).
2. Подключить питание и Ethernet к малинке
3. Подождать несколько минут, пока система развернется в локальной сети на `:8123`.
Также можно установить на уже имеющуюся систему с помощью Docker-compose:
```
version: '3'
services:
homeassistant:
container_name: homeassistant
image: homeassistant/raspberrypi4-homeassistant:stable
volumes:
- /PATH_TO_YOUR_CONFIG:/config
- /etc/localtime:/etc/localtime:ro
restart: unless-stopped
network_mode: host
```
А теперь разберем несколько сценариев использования.
Отслеживание устройств
======================
Начнем с отслеживания устройств, с помощью которого мы можем фиксировать вход и выход носителей из дома.
Я предлагаю 2 способа отслеживания:
* с помощью роутера (у меня в наличии Xiaomi Router Mi4A),
* с помощью GPS.
В системе доступно много [производителей](https://www.home-assistant.io/integrations/#presence-detection) роутеров. Для старых и не перечисленных в списке моделей можно использовать nmap (более подробно [тут](https://ivan.bessarabov.ru/blog/home-assistant-nmap-device-tracking)).
Если установить на телефон официальное приложение, HA по умолчанию создаст интеграцию, и в системе появится дополнительное устройство, которое можно отследить.
С помощью Xiaomi Router Mi4A
----------------------------
Плюсы
* Не требует никаких действий на устройстве, отслеживает всех в локальной сети.
Минусы
* Если устройство не подключено к домашней сети, то устройство пропадает в пустоту, и на картах мы его не увидим.
* Иногда может сработать триггер выхода/входа из зоны, когда фактически девайс не покидает зону (можно попробовать решить расширением зоны).
С помощью GPS
-------------
Плюсы
* Точность работы сравнима с GPS трекером в телефоне.
* О телефоне можно узнать: процент заряда аккумулятора, заряжается устройство или нет, а также показатель состояния аккумулятора.
* Можно контролировать устройства (пользователей) не только на вход домой, но и на вход в любую из кастомных зон.
Минусы
* Активно тратит заряд.
* Требует подключение Интернета.
* Для точного трекинга необходимо настроить SSL, чтобы телефон мог отправлять данные о местоположении из вне локальной сети.
* Требует дополнительных прав доступа к GPS, возможна утечка данных третьей стороне в будущем.
* На бюджетных телефонах, которые имеют свойство неожиданно менять местоположение GPS, возможны проблемы с выпадением из зоны.
Создание системы отслеживания через роутер
==========================================
Трекинг через локальную сеть роутера требует настройки, в отличие от GPS отслеживания. Два вида трекинга можно комбинировать для повышения точности. Ниже можно заметить, что в моем случае отслеживание через роутер работает лучше, чем через GPS. Зеленая зона значит, что телефон внутри зоны, красная — вне зоны.
Результаты работы отслеживания (сверху — роутер, снизу — GPS)
**Редактирование конфигурационных файлов через VSCode**
Можно подключиться через плагин SSH в VS Code, но получить доступ к проводнику в данный момент мне было удобнее. Поэтому, добавим сетевое расположение.
Нажмем обзор, найдем каталог config (мы в основном будем редактировать его) и выберем его как сетевую папку.
Дальше мы можем перейти в созданную папку и открыть ее через редактор.
**router\_device\_tracker.yaml**
```
platform: xiaomi
host: 192.168.31.1
password: !secret xiaomi_router_password
configuration.yaml
device_tracker: !include configs/router_device_tracker.yaml
```
После перезагрузки HA мы можем увидеть, что у нас появился новый глобальный объект device\_tracker и наши устройства в нем.
*Трекинг устройств через роутер*
Освещение
=========
Теперь, когда мы умеем отслеживать пользователя, мы можем включать и выключать определенные лампочки с учетом информации о его местоположении.
Для этого необходимо произвести действие по определенному событию. В этом нам помогут [автоматизации](https://www.home-assistant.io/docs/automation/basics/).
**automation/phone\_tracker**
```
- alias: Entering home
trigger:
platform: state
to: home
entity_id: device_tracker.mi9lite
action:
- service: light.turn_on
data:
entity_id: light.midesklamp1s_f86f
brightness: 35
color_temp: 350
- alias: Leaving home
trigger:
platform: state
to: not_home
entity_id: device_tracker.mi9lite
action:
- service: light.turn_off
entity_id: light.midesklamp1s_f86f
```
Теперь импортируем в наш основной файл весь каталог automation — так нам будет удобнее при написании следующих автоматизаций.
**configuration.yaml**
```
automation: !include_dir_merge_list automation
```
Пример работы:
<https://www.youtube.com/watch?v=Sii4rBtXYVw>
Для того, чтобы получить адаптивное освещение в зависимости от времени суток, нужно настроить цветовую температуру. Это удобно сделать внутри блока switch. Тут важно понимать, что пока данный switch включен, изменить параметры температуры будет невозможно (через `interval` минус `время_с_прошлого_обновления` лампа примет старые параметры).
[Здесь](https://www.home-assistant.io/integrations/flux/) вы найдете больше про динамическую цветовую температуру (flux в терминологии HA). А если вам интересна тема адаптивного освещения, на Хабре есть [отличная статья](https://habr.com/ru/post/529082/) по этому поводу.
**configuration.yaml**
```
switch:
- platform: flux
lights:
- light.midesklamp1s_f86f
name: Fluxer
start_time: '9:00'
stop_time: '0:00'
start_colortemp: 5000
sunset_colortemp: 3200
stop_colortemp: 2800
brightness: 25.5
disable_brightness_adjust: true # яркость будет константой
mode: mired # для не rgb ламп
transition: 30
interval: 30```
# Погода
По умолчанию в HA уже присутствует интеграция с погодным API от [Meteorologisk institutt](https://www.home-assistant.io/integrations/met/) (Норвежский метеорологический институт), но мы можем легко создать другую прямо через UI.
## Создание новой интеграции OpenWeatherMap
Переходим в config / Integration на UI , нажимаем на Add integration, и выбираем из списка OpenWeatherMap.
Вводим api_key, полученный на их сайте и нажимаем Submit. В итоге получим 19 сущностей, которые можем использовать для своих целей в автоматизациях.
*Сущности OWM (на скриншот попали не все 19)*
Таким же образом через UI можно создать интеграции к другим сервисам вроде SpeedTest, или OpenUV.
# Уведомления
Для настройки уведомлений можно использовать стандартные оповещения HA, отображаемые в боковом меню, уведомления на конкретных устройствах (нужно установленное приложение на девайсе), а также оповещения в сторонние сервисы.
*persistent_notification*
Альтернативный способ уведомлений - это уведомления в сторонние сервисы, например Telegram. Для начала нужно создать бота, получить его api_key (при создании отправят ключ) и chat_id, который можно найти в ответе внутри `result.chat.id` после запроса на https://api.telegram.org/bot{api_key}/getUpdates .
Такое иногда случается по разным причинам.
В таких случаях подходит другой способ получения chat_id - написать @getmyid_bot боту и скопировать себе user ID.
Простейшая настройка Telegram бота:
```
Для того, чтобы не разглашать всем секретные данные, создадим еще `secrets.yaml`. Туда мы сложим все данные, которые не должны попасть в публичный доступ. Для использования переменных из этого файла используем !secret.
Пример секретов:
**secrets.yaml**
```
telegram_api: %api_key%
telegram_chat_id: %chat_id%
```
**configuration.yaml**
```
telegram_bot: !include notification/telegram_bot.yaml
```
В итоге у нас имеется Telegram бот, готовый к отправке сообщений.
Утренние (или нет) погодные оповещения
======================================
Теперь, когда у нас есть настроенный сервис уведомлений и погодная интеграция, мы можем сделать утренние оповещения о погоде.
Создаем новый файл автоматизации, и начинаем писать логику.
Пишем переменную, которая будет отвечать за срабатывание оповещений только по будням. Если он true — то в выходные оповещений не будет.
**input\_boolean.yaml**
```
alarmweekday:
name: Weekdays Only
initial: off
icon: mdi:calendar
```
И подключаем в основном конфиг файле.
**configuration.yaml**
```
input_boolean: !include input_boolean.yaml
```
**automation/morning\_alarm.yaml**
```
- alias: 'Wake Me Up'
trigger:
platform: time
at: input_datetime.weather_notification
condition:
condition: or
conditions:
- condition: and
conditions:
- condition: state
entity_id: input_boolean.alarmweekday # оповещение в выходные
state: 'on'
- condition: time
weekday:
- mon
- tue
- wed
- thu
- fri
- condition: and
conditions:
- condition: state
entity_id: input_boolean.alarmweekday
state: 'off'
action:
service: telegram_bot.send_message
data: # тут
message: "{% if now().strftime('%H')|int < 7 %}
Доброй ночи,
{% elif now().strftime('%H')|int < 12 %}
Доброе утро,
{% elif now().strftime('%H')|int < 18 %}
Хорошего дня,
{% else %}
Хорошего вечера,
{% endif %}
сейчас на улице {{states('sensor.openweathermap_temperature')}}°C. "
```
Пример работы:
<https://www.youtube.com/watch?v=vSmSbSd_f-Q>
Добавим blueprints
==================
Теперь небольшое лирическое отступление в виде рассказа о написании blueprints на примере уведомлений.
В данном случае я бы перевел blueprints не как чертежи, а как шаблоны или заготовки. Их удобнее использовать, если нужно написать несколько похожих автоматизаций, а основную логику оставить нетронутой.
Например, можно упростить создание уведомлений о начинающихся осадках.
**blueprints/precipitation\_start.yaml**
```
blueprint:
name: Fallout start notification
domain: automation
input: # аргументы шаблона
precipitation:
name: Precipitation level
selector:
entity:
domain: sensor # только для ui, поможет создать автоматизацию, предоставляя только сенсоры в выпадающем списке
message_start:
name: Telegram message
default: "No message"
trigger: # условия срабатывания
- platform: numeric_state
entity_id: !input precipitation
above: 0.9
for:
minutes: "{{ states('input_number.minimum_time_for_stable_value')|int }}"
action:
- service: telegram_bot.send_message
data:
message: !input message_start
```
“for” — это время, в котором должен оставаться выбранный параметр, чтобы сработал триггер на превышение уровня осадков.
**input\_number.yaml**
```
minimum_time_for_stable_value:
name: Minimum time for stable value
initial: 1
min: 0
max: 59
step: 1
```
Теперь, когда есть blueprint, мы можем написать автоматизацию с меньшим количеством логики.
Создадим уведомления о начале осадков.
**automation/rain\_start.yaml**
```
- alias: 'Rainy is started'
use_blueprint:
path: homeassistant/fallout_start_notification.yaml
input:
precipitation: sensor.openweathermap_rain
message_start: "Похоже, дождь начинается. Уже накапало {{states('sensor.openweathermap_rain')}}мм."
automation/snow_start.yaml
- alias: 'Snow is started'
use_blueprint:
path: homeassistant/fallout_start_notification.yaml
input:
precipitation: sensor.openweathermap_snow
message_start: "Пошел снежок. Уже навалило {{states('sensor.openweathermap_snow')}}мм."
```
Мы смогли вынести часть функциональности в отдельный файл. В подобных случаях, когда со временем появляется похожий код, можно выносить часть логики в отдельный файл.
Для большей полезности можно изменить шаблон и поменять action на повышение яркости для света в доме или закрытие штор.
Бэкапы
======
В бэкап попадает весь каталог `/config`, а также все установленные расширения. С любого бекапа можно восстановить состояние системы на момент его создания.
Можно настроить создание резервных копий в Google Drive:
1. Скопировать ссылку <https://github.com/sabeechen/hassio-google-drive-backup> и зайти в HA (также можно прочитать подробную инструкцию в ReadMe репозитория по ссылке)
2. Добавить ссылку как кастомный репозиторий в Supervisor'е через UI.
3. Открыть его (Open Web UI) и следовать инструкциям по аутентификации с Google Drive
После этих манипуляций мы получаем регулярное создание бекапов, важность которых сложно переоценить.
**Интерфейс бекапов**
ESP
===
*NodeMCU*
Так как умного градусника у меня нет, а температуру измерять хочется, воспользуемся ESP8266.
Сначала установим интеграцию [ESPHome](https://esphome.io/guides/getting_started_hassio.html) из официального списка интеграций.
Для каждого микроконтроллера, используемого в системе, требуется создать файл с подобным содержанием.
`esphome/home_params.yaml`
Проинициализируем контроллер.
```
esphome:
name: home_params
platform: ESP8266
board: nodemcuv2
logger:
api:
ota:
```
Подключимся к WiFi
```
wifi:
ssid: !secret xiaomi_router_ssid
password: !secret xiaomi_router_password
```
[По умолчанию](https://esphome.io/guides/faq.html#how-do-i-use-my-home-assistant-secrets-yaml) используются секреты только от ESPHome. А для того, чтобы подгрузить секреты из HA, можно создать отдельный файл, где мы заинклудим эти секреты.
**esphome/secrets.yaml**
```
!include ../secrets.yaml
```
Теперь подключим data pin (обычно это средняя нога) термометра к D2 порту, дадим на него питание и землю. Потом создаём сам термометр (DHT11) и две переменные, которые будем отслеживать в HA.
```
sensor:
- platform: dht
model: DHT11
pin: D2
temperature:
name: "Living Room Temperature"
humidity:
name: "Living Room Humidity"
update_interval: 60s
```
Дальше нужно скомпилировать прошивку и загрузить на контроллер. Если он подключен напрямую к Raspberry Pi, то мы увидим его на /dev/ttyUSB0 и сможем загрузить прошивку в первый раз. Все последующие обновления можно загружать по воздуху. А если в списке устройства не видно, то можно скачать прошивку и воспользоваться [ESPHome-Flasher.](https://esphome.io/guides/faq.html#esphome-flasher)
Загружаем прошивку.
Если все заработало, то в Developer Tools мы увидим созданные переменные.
**Developer Tools**
Немного оптимизации
===================
По умолчанию в HA используется SQLite, и сброс данных на диск происходит часто (каждую секунду). Это может привести в скором времени к выходу из строя SD карточки на малинке (если сервер стоит на ней). Чтобы продлить срок службы карточки, скажем HA, что нужно записывать на диск раз в `commit_interval` и исключить некоторые сущности, которые мы не хотим отслеживать на длинном временном промежутке (или вообще не хотим отслеживать).
**configs/recorder.yaml**
```
commit_interval: 1500
purge_keep_days: 7
exclude:
domains:
- updater
- automation
entity_globs:
- sensor.miwifi_router*
entities:
- sensor.date
- sensor.date_time
- sensor.time
- sensor.openweathermap_forecast_time
```
**configuration.yaml**
```
recorder: !include configs/recorder.yaml
```
Если мы хотим использовать СУБД, отличную от SQLite, то можно сделать один из следующих пунктов на выбор:
1. Установить соответствующий аддон для перехода на MariaDB.
2. Использовать существующую реляционную базу данных на удаленной машине, если указать строку для подключения в параметр `db_url`.
Отслеживание системных параметров
=================================
Чтобы отслеживать остаток свободной памяти, загруженность процессора или скорость Интернет соединения, мы можем добавить мониторинг показателей системы.
**sensors/system\_monitor.yaml**
```
- platform: systemmonitor
resources:
- type: disk_use_percent
arg: /
- type: memory_free
- type: memory_use_percent
- type: processor_use
- type: processor_temperature
- type: disk_free
arg: /
```
При желании можем создать автоматизацию, которая при критических показателях будет отправлять уведомление о необходимости принятия мер.
Также мы можем посмотреть Uptime сервера.
**sensors/uptime.yaml**
```
- platform: uptime
name: Time Online
```
**configuration.yaml**
```
sensor: !include_dir_merge_list sensors
```
**Вариант представления на UI**
Заключение
==========
Плюсы HA
* Простая установка и настройка, не требующая знания программирования.
* Большое коммьюнити — вопросов на форуме много, ответов тоже хватает.
* Огромное количество готовых интеграций со сторонними сервисами — скорее всего не придется писать свою интеграцию руками.
Минусы HA
* Достаточно сложно отлаживать систему. Если action можно запустить программно в обход триггера, то триггер тестировать уже сложнее.
В итоге мы создали несложную систему умного дома, которую каждый может расширить покупкой новых устройств или написанием своих продуманных и продвинутых автоматизаций. По [этой](https://github.com/Sapfir0/home-assistant) ссылке можно найти полную версию моих автоматизаций дома.
*Главный экран*
Что дальше? Можно добавить [HACS](https://hacs.xyz/docs/installation/installation) (сборник UI компонентов и даже целых интеграций от коммьюнити, пригодится при использовании Яндекс Станции) и установить несколько UI элементов. Можно интегрировать умную колонку или телевизор и включать их по определенному условию. Вариантов апгрейда бесконечное множество.
Успехов в автоматизации!
Литература
==========
* [Документация HA](https://www.home-assistant.io/docs/) | https://habr.com/ru/post/546072/ | null | ru | null |
# Установка Jenkins и Bonobo Git Server под ОС Windows для сборки Android приложений
Добрый день. ~~Не имея времени копаться в Linux~~Столкнувшись с пробелами в информации при поиске по сети инструкций по установке и настройке под ОС Windows сервера непрерывной сборки Jenkins для приложений Android, Git сервера и их интеграции решил поделиться информацией о том, что у меня получилось.
#### Дистрибутивы
* В роли ОС у нас будет выступать Windows Server 2012 R2 Standard x64
* [Jenkins](https://jenkins.io/content/thank-you-downloading-windows-installer) для Windows есть в отдельном msi
* [Bonobo Git Server](https://bonobogitserver.com/)
* [JDK](http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html)
* [ASP.NET MVC 4](https://www.asp.net/mvc/mvc4)
* [Android SDK tools](https://developer.android.com/studio/index.html) в самом низу странички, не среду а только SDK
* [Git for Windows x64](https://git-scm.com/download/win)
#### Последние приготовления
Можете с самого начала установить JDK, Git for Windows и Android SDK Tools с настройками по дефолту.
#### Bonobo Git Server
Простой и лёгкий git сервер под собой требует установки IIS и ASP.MVC что включает MS SQL Server Express 2008
##### IIS Server
Тут ничего необычного, добавляем роль Web Server (IIS):
**IIS**
Главное на следущей форме не пропустить добавить ASP.NET 4.5 в Feature:
**Feature**
##### ASP.NET MVC4
Запускаем дистрибутив:
**ASP.NET MVC4 Install**
Попутно установится MS SQL Server 2008 Express и нас спросят пароль для УЗ sa. Надеюсь без надобности она более не потребуется:
**MS SQL Server installation**
После установки MVC нужно по новой пройтись в настройки серверных ролей (не features, а раньше) и добавить web-серверу поддержку ASP.NET4.5. До установки ASP.NET MVC 4 этого подраздела (Application Development) в компонентах IIS не было!
**Server Roles - IIS - Web Server - Application Development - ASP.NET 4.5**
##### Bonobo Git Server
Всё, теперь можно перейти к непосредственно развёртыванию git сервера. Разархивируем содержимое дистрибутива в wwwroot IIS-сервера и даём права УЗ IIS\_IUSERS на модификацию каталога App\_Data:
**IIS wwwroot и права УЗ IIS\_IUSERS на каталог App\_Data**
Запускаем IIS Manager и конвертируем в приложение BonoboGitServer:
**IIS Manager Convert to Application**
Если всё пошло так как надо справа в IIS Manager в Action жмём Browse: \*:80(http) и попадаем (если вы не изменили имя и порт) на localhost/BonoboGitServer:
**Bonobo Git Server login page**
Логин и пароль для первого входа admin/admin. У сервера не так много настроек (во всяком случае через web-интерфейс), можно например поменять язык интерфейса:
**Bonobo Language**
и создать новых пользователей, например developer и jenkins. Под первым мы будем работать сами, второй нужен будущему серверу сборок.
**Новый пользователь Bonobo Git Server**
Создадим новый репозиторий и дадим права на него разработчику и сборщику (УЗ jenkins, на скрине нет, но он там должен быть если делать всё по порядку...)
**Новый репозиторий**
Пример странички репозитория с заветным адресом .git. Т.к. я заходил на сервер из браузера на этой же машине в адресе у меня фигурирует localhost, но у вас может быть нормальное DNS-имя сервера или IP.
**Адрес репозитория**
Можно создать какой-нибудь проект в Android Studio указать в качестве удалённой ветки адрес нашего репозитория. Всю эту *локальную* часть я пропущу.
**Удалённый репозиторий доступен**
#### Jenkins
Jenkins устанавливается из msi и особо ни о чём не спрашивает, в конце установки автоматически открывается страничка с адресом где нам нужно скопировать из файла initialAdminPassword и вставить пароль:
**Unlock Jenkins**
В дальнейшем пароль УЗ admin тоже можно поменять.
Пришла пора установить необходимые плагины и настроить сервер. Переходим в Manage Jenkins — Manage Plugins — Avaliable и отмечаем:
* JDK Parameter Plugin
* Git plugin
* Android Emulator Plugin
* Gradle plugin
**Jenkins plugins**
После перезапуска Jenkins необходимо перейти в раздел Manage Jenkins — Configure System и прописать путь к Android SDK в двух местах:
**ANDROID\_HOME в Environment variables**
И в самом низу этой же странички в Android SDK root:
**Android SDK root**
Если данного параметра не появилось что-то не то с Android Emulator Plugin, возможно он просто не установился.
Далее перейти на страничку конфигурации Manage Jenkins — Global Tool Configuration проверить и при необходимости указать пути к компонентам:
**Global Tool Configuration**С JDK всё прсто:
Git можно не трогать, если в переменной path указан путь к исполняемому файлу git и он доступен в командной строке то и Jenkins сможет его использовать:
А Gradle пусть скачается автоматически. В принципе такой же фокус можно было бы сделать с JDK но при установке Android SDK требует зарегистрированной в системе JDK, а куда Jenkins скачивает JDK я не раскопал.
Кажется всё?
#### Создание задачи на автоматическую сборку
В основном боковом меню Jenkins жмём New Item, придумываем название задачи с типом «Freestyle project» и жмём ок, попадаем в конфигурацию задачи. Не забываем поставить галочку Discard old builds а то наш сервер вскоре заполнится успешными билдами всех версий:
**General**
В разделе Source Code Management указываем URL репозитория git нашего проекта. Забегая вперёд, не заводим и не подставляем никакие учётные данные для доступа к репозиторию:
**Source Code Management**
Будем собирать ветку master. Также можно настроить автоматическую сборку, в частности опрос репозитория ежеминутно и старт сборки в случае обнаружения новых коммитов. Отмечаем Poll SCM и пишем \* \* \* \* \*:
**Build triggers**
В разделе build нажимаем Add build step и настраиваем сборку Gradle. Gradle version должен быть доступен тот, что мы указали в Global Tools Configurations. Пишем простой Task — «clean build». Это задачи, доступные нам в gradlew.bat tasks в корне проекта. Вы можете вызывать тут и другие задачи сборщика, в т.ч. с ключами.
**Gradle**
Также добавляем одно Post-build Action — будем сохранять наши APK-шники — приложения Android. Так и пишем:
```
**\*apk:
```
**Post-build Action**
#### Сборка
Сохраняем и запускам сборку и видим что-то подобное, висим 10 минут и не можем достучатся в репозиторий:
```
git.exe fetch --tags --progress http://localhost/Hello.git +refs/heads/*:refs/remotes/origin/*
```
Мы же никак не авторизовались в репозитории git! Добавление пары Login/Password в хранилище Jenkins (там где мы оставили -none- в Source Code Management) не сработало, как бы я не пробовал. Надо попробовать поискать другие пути.
Командная строка запускается от имени УЗ сеанса, Jenkins от имени System и ничего об этом не знает, в хранилище Credential Manager похоже что тоже не случится. Т.е. это не поможет:
**Credential Manager**
Дополнительный поиск по сети дал несколько советов:
* Перенос ssh-ключей из УЗ сеанса в system, которые я так и не смог найти;
* Второй способ (Авторизация git), который сработал.
##### Авторизация git
Для этого нам потребуется PsExec.exe из набора утилит [PsTools](https://technet.microsoft.com/ru-ru/sysinternals/pstools.aspx). С её помощью мы можем запустить cmd.exe из под System. Запускаем cmd.exe с повышенными правами и выполняем:
```
PsExec.exe -i -s cmd.exe
```
В новой консоли всё что нужно сделать это постучатся в нужный нам репозиторий, например попробовать в командной строке склонировать его. будут запрошены учётные данные:
**Git**
С помощью которых Jenkins сможет обращаться к данному репозиторию. Это та самая УЗ, которую мы создавали при настройках Bonobo Git Server наряду с developer'ом. Если в дальнейшем потребуется изменить данные учётные данные придётся пройти процедуру повторно.
##### Нехватка компонентов и акцептов лицензий на компоненты Android SDK
Может случится так что в SDK будут отсутствовать какие-нибудь модули и консоль сборки выдавать сообщения подобного характера:
```
A problem occurred configuring project ':app'. You have not accepted the license agreements of the following SDK components: [Android SDK Platform 24, Android SDK Build-Tools 24.0.1].
```
В таком случае вам надо запустить с повышенными правами SDK Manager и установить недостающие компоненты:
**Android SDK Manager**
Всё, после всех шаманств сборка прошла успешно!
**Successful build!**
Можете разводить команду Android-разработчиков.
**P.S.** Можно ещё более автоматизировать процесс, с помощью соответсвующего плагина настроить автоматичекую публикацию apk'шника в Google Play Store но об этом я напишу может быть в другой раз, если там будут какие-нибудь трудности. | https://habr.com/ru/post/313564/ | null | ru | null |
# Защищаем трафик при помощи Comodo TrustConnect и DNSCrypt
Раньше я не уделял должного внимания шифрованию, так как данные передаваемые в общественных местах не имели большой важности, но сегодня я увидел в этом и оборотную сторону медали. В институте, как обычно, на паре информатики, студенты сидели вконтакте, хабре и других ресурсах и ничего не предвещало опасности. Все были в неведении того, что творилось по ту сторону сети. А творился там WireShark, любезно показывающий преподавателю адреса посещаемых страничек, шпор и соответственно индекс «внимания» студентов. В этот момент я понял — нам угрожает опасность не сдать сессию.
Тогда я решил найти способ скрыть действия в сети.
#### Поиск решения
Ранее я использовал TOR, но его скорость оказалась мала, да и не доверял я ему что он скроет все запросы по всем портам. Тогда я начал, в который раз, искать бесплатный VPN. И тут откуда не возьмись [статья про Comodo TrustConnect](http://habrahabr.ru/post/141483/)(т.к. моя статья является её логическим продолжением, сначала прочтите её). Я начал радостно устанавливать пакеты и регистрироваться, правда меня смутила фраза про заблокированные порты, но ожидалось, что хотя бы HTTP будет работать сносно. Бесплатный сыр в мышеловке показал свое истинное лицо. Запускаю VPN, а страницы не открываются — DNS не проходит.
#### Гугл в помощь
Вооружившись гуглом спустя час находим, что DNS просто блокируется и его надо перенаправлять.
Кратко опишу настройку VPN под Linux (подробная есть на сайте после регистрации): ставим openvpn, после чего просто копируем ca.crt и free\_client.conf из инструкции на сайте в /etc/openvpn.
Далее можно создать файл файл pass, написать на первой строчке логин, на второй пароль.(но лучше не хранить все в открытом виде)
Потом запускаем
`sudo openvpn --config /etc/openvpn/free_client.conf --auth-user-pass /etc/openvpn/pass`
Хорошо, добавляем в /etc/openvpn/free\_client.conf:
`route <наш DNS> 255.255.255.255 net_gateway`
И о чудо, все работает!
Вот только в tcpdump видно как посылаются DNS запросы и светится посещенный сайт!
#### Шифруем DNS
К моему счастью спустя 10 минут был найден DNSCrypt от OpenDNS. Под Archlinux было достаточно поставить пакет dnscrypt-proxy из aur и запустить. В логе выдает адрес через который идут запросы. Чтобы работало вписываем вместо DNS в конфиге free\_client.conf этот адрес. Например в моем случае
`route 208.67.220.220 255.255.255.255 net_gateway`
Все, после этого весь трафик идет через VPN, а DNS запросы идут через DNSCrypt. В tcpdump адреса не светятся. Красота. | https://habr.com/ru/post/141825/ | null | ru | null |
# Что происходит, когда вы отправляете SMS
Это третья статья в цикле [full-stack dev](https://scottbot.net/tag/full-stack-dev/) о секретной жизни данных. Она посвящена сложному и длинному маршруту SMS: набор, сохранение, отправка, получение и отображение. Добавлю немного истории и контекст, чтобы разбавить перечень протоколов. Хотя текст довольно технический, всё довольно легко понять.
Первые две части цикла:
* [Cetus](https://scottbot.net/cetus/), о распространении ошибок в предках электронных таблиц XVII века
* [«Вниз по кроличьей норе»](https://scottbot.net/down-the-rabbit-hole/), о безумно сложном поиске источника одного набора данных
Итак, начнём…
Нога непроизвольно дёрнулась от вибрации: это телефон или просто показалось? — и беглый взгляд обнаружил мигающий синий огонёк. «Люблю тебя» — от жены. Я тут же пошёл вниз пожелать ей спокойной ночи, потому что знаю разницу между посланием и *посланием*. Это немного похоже на шифрование или стеганографию: любой видит текст, но только я могу декодировать скрытые данные.
Мой перевод — всего лишь одно звено в удивительно длинной цепи событий, которые необходимы для отправки и расшифровки сообщения («спустись вниз и пожелай спокойной ночи») менее чем за пять секунд на расстояние около 10 метров.
Видимо, сообщение зародилось где-то в мозге моей жены и превратилось в движения пальцев, но эта передача сигнала — тема другой статьи. Наш разговор начинается с момента, когда её большой палец коснулся полупрозрачного экрана, и заканчивается, когда свет упал на мою сетчатку.
Зазеркалье
==========
С каждым прикосновением от экрана в руку стекает небольшой электрический заряд. Поскольку ток легко течёт по человеческому телу, датчики на телефоне регистрируют изменение напряжения в том месте, где палец прикоснулся к экрану. При этом происходят случайные колебания напряжения в остальной части экрана, поэтому алгоритм определяет максимальные колебания напряжения и предполагает, что именно в этом месте человек хотел нажать пальцем.
*Рис. 0. Ёмкостный датчик прикосновения*
Итак, она нажимает по экрану, набирая по одной букве.
`I-пробел-l-o-v-e-пробел-y-o-u.`
Она не пользуется свайпом (но почему-то всё равно печатает быстрее меня). Телефон надёжно регистрирует координаты (x,y) каждого нажатия и проверяет координаты каждой клавиши на экране. Это сложнее, чем вы думаете; иногда палец соскальзывает, но каким-то образом телефон понимает, что это не жест, а просто смазанное нажатие.
Глубоко в металлических кишках устройства алгоритм проверяет, что каждый раз изменение напряжения покрывает больше, чем определённое количество пикселей, которое называется *touch slop*. Если площадь небольшая, телефон регистрирует нажатие клавиши, а не свайп.
*Рис. 1. Код Android для обнаружения touch slop. Обратите внимание, что разработчики знали пол моей жены*
Она заканчивает сообщение, жалкие 10 символов из разрешённых 160.
160 символов — тщательно выверенное число. Если верить легенде, в 1984 году немецкий телефонный инженер Фридхельм Хиллебранд сел за пишущую машинку и написал столько случайных предложений, сколько ему пришло в голову. Затем его команда изучила почтовые карточки и сообщения по телетайпу — и обнаружила, что большинство из них не превышает 160 символов. «Эврика!» — видимо, закричали они по-немецки, прежде чем зафиксировать лимит символов в текстовых сообщениях на следующие три с лишним десятилетия.
Ограничения по символам и легенды
=================================
Легенды редко рассказывают всю историю целиком, и SMS не исключение. Хиллебранд и его команда надеялись передать сообщения по дополнительному каналу, который телефоны уже использовали для обмена информацией с базовой станцией.
Сигнальная система SS7 представляет собой набор протоколов, используемых сотовыми телефонами, чтобы оставаться в постоянном контакте с базовой станцией; им нужно постоянное соединение, чтобы получать вызов и передавать своё местоположение, проверять голосовую почту и т. д. При разработке протокола в 1980 году ввели жёсткий лимит в 279 байт информации. Если Хиллебранд хотел получать текстовые сообщения по протоколу SS7, то должен был вписаться в это ограничение.
Обычно 279 байт равно 279 символам. В байте 8 бит, а в общих кодировках один символ соответствует одному байту.
А
`0100 0001`
B
`0100 0010`
С
`0100 0011`
и так далее.
К сожалению, для передачи сообщения по протоколу SS7 нельзя просто отправить 2232 нуля и единицы (279 байт по 8 бит) радиосигналом с одного телефона на другой. В это сообщение нужно включить номера отправителя и получателя, а также служебное сообщение для базовой станции «Эй, это сообщение, а не звонок, не отправляй сигнал вызова!»
К тому времени, когда Хиллебранд с коллегами сумели запихать все необходимые биты контекста в 279-байтовый сигнал, у них осталось только 140 байт или 1120 бит.
Но что, если кодировать символ только в 7 битах? Тогда можно втиснуть в каждое сообщение 160 (1120 / 7 = 160) символов, но такое сокращение требует жертв: меньше возможных символов.
Восьмибитная кодировка допускает 256 возможных символов: одно место занимает строчная ‘a’, одно — прописная ‘A’, свои места у пробела и символа ‘@’, разрыва строки и так далее, до 256. Чтобы ужать алфавит до семи бит, необходимо удалить некоторые символы: символ 1/2 (½), символ градуса (°), символ числа пи (π) и так далее. Но предположив, что люди никогда не используют эти символы в тексте (плохое предположение, конечно), Гиллебранд с коллегами сумели поместить 160 символов в 140 байт. В свою очередь, этот объём точно уместился в 279 байт сигнала SS7: именно то количество символов, какое раньше определили как идеальную длину сообщения.
*Рис. 2. Набор символов GSM-7*
И вот жена набирает «Люблю тебя», а телефон преобразует буквы в 7-битную схему кодирования, которая называется GSM-7.
“I” (пересечении четвёртого столбца и девятой строки в таблице):
`49`
Пробел (пересечение второго столбца и нулевой строки):
`20`
“l” =
`6C`
“o” =
`6F`
и так далее по очереди.
В общем, её послание превращается в такую последовательность:
`49 20 6C 6F 76 65 20 79 6F 75`
(всего 10 байт). Каждый двухсимвольный код, называемый шестнадцатеричным кодом (hex), представляет собой один восьмибитный фрагмент, а всё вместе звучит как «Люблю тебя».
Но на самом деле сообщение не так хранится в телефоне. Он должен преобразовать 8-битный текст в 7-битный код. В результате [преобразования](http://web.archive.org/web/20081017024616/http://www.dreamfabric.com:80/sms/hello.html) сообщение начинает изменяется до такого:
`49 10 FB 6D 2F 83 F2 EF 3A`
(9 байт) в её телефоне.
Когда жена, наконец, заканчивает свое сообщение (это занимает всего несколько секунд), она нажимает «Отправить» — и множество крошечных ангелов получают закодированное сообщение, трепещут своими невидимыми крыльями на 10 метров до моего кабинета и аккуратно переносят его в мой телефон. Процесс не очень лёгкий, вот почему мой телефон слегка вибрирует при доставке.
Так называемые «инженеры связи» расскажут вам другую историю, и для полноты картины я перескажу её, но на вашем месте я бы не слишком доверял этим людям.
SIM-to-Send
===========
Инженер скажет, что когда телефон воспринимает изменение напряжения по координатам на экране, которые совпадают с координатами размещения графического элемента с кнопкой «Отправить», то он отправляет кодированное сообщение на SIM-карту, а в процессе передачи добавляет различные контекстные данные. Когда сообщение достигает SIM-карты моей жены, то там уже не 140, а 176 байт (текст + контекст).
Дополнительные 36 байт используются для кодирования другой информации, как показано ниже.
*Рис. 3. Здесь байты называются октетами (8 бит). Подсчёт всех даёт 174 октета (10+1+1+12+1+1+7+1+140). Остальные два байта зарезервированы для учёта SIM-карт*
Первые десять байт зарезервированы для телефонного номера (SCA) SMS-центра (SMSC), который отвечает за приём, хранение, пересылку и доставку текстовых сообщений. По сути, это коммутатор: телефон жены посылает сигнал на местную вышку сотовой связи, которая отсылает текстовое сообщение на SMSC. Центр SMS, который в нашем случае управляется AT&T, направляет текст на ближайшую к моему телефону базовую станцию. Поскольку я сижу в трёх комнатах от жены, сообщение возвращается на ту же базовую станцию, а затем на мой телефон.
*Рис. 4. Сотовая сеть SMS*
Следующий байт (PDU-type) кодирует базовую информацию о том, как телефон должен интерпретировать сообщение: было ли оно успешно отправлено, нужно ли сообщение о доставке и (важно) является ли оно одиночным текстом или частью цепочки связанных сообщений.
Байт после PDU-type является ссылкой на сообщение (MR). Это число от 1 до 255, по сути, используется как краткосрочный ID, чтобы телефон и оператор распознавали сообщение. В сообщении от жены установлен номер 0, потому что в её телефоне собственная система идентификации сообщений, независимая от этого конкретного файла.
Следующие двенадцать байт зарезервированы для номера телефона получателя, который называется адресом назначения (DA). За исключением 7-битной кодировки текста, которая помогает втиснуть 160 букв в 140 символов, кодировка номера телефона — самая глупая и запутанная вещь в этом SMS. Она называется обратная запись нибблов (reverse nibble notation) и преобразует каждую цифру в ниббл, то есть полубайт, и меняет их местами (Всё поняли? Полбайта — это ниббл, хахахахаха, но никто не смеется, это же инженеры).
Мой номер 1-352-537-8376 в телефоне жены регистрируется как:
3125358773f6
1-3 превращается в
`31`
52 превращается в
`25`
53 превращается в
`35`
7-8 превращается в
`87`
37 превращается в
`73`
И последняя 6 превращается в…
`f6`
Какого хрена взялась эта шестёрка? Ну, она означает конец номера, но по какой-то ужасной причине (опять же, обратная нотация) это один символ перед последней цифрой.
Это как [«поросячья латынь»](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D1%80%D0%BE%D1%81%D1%8F%D1%87%D1%8C%D1%8F_%D0%BB%D0%B0%D1%82%D1%8B%D0%BD%D1%8C), только для чисел.
`Усу посопаса бысыласа сособасакаса, осон есеёсё люсюбисил. Осонаса съеселаса кусусосок мясясаса, осон есеёсё усубисил.`
Но я не издеваюсь.
[UPD: Шон Гис [указал](https://twitter.com/seangies/status/1085302529917763585), что обратная запись нибблов является неизбежным артефактом представления 4-битных чисел от младшего к старшему (little-endian) 8-битными фрагментами. Это не отменяет приведённое выше описание, но добавляет некоторый контекст для понимающих и делает решение более разумным].
Байт идентификатора протокола (PID) сейчас, по большому счёту, потраченное впустую место. Он принимает около 40 возможных значений и сообщает провайдеру, как направить сообщение. Значение
`22`
означает, что жена отправляет «Люблю тебя» на факс, а значение
`24`
значит, что она каким-то образом отправляет его на голосовую линию. Поскольку это сообщение в виде SMS на телефон, PID установлен на
`0`
(Как и любой другой текст, отправляемый в современном мире).
*Рис. 5. Возможные значения PID*
Следующий байт является схемой кодирования данных (DCS, [см. документацию](https://www.etsi.org/deliver/etsi_ts/123000_123099/123038/10.00.00_60/ts_123038v100000p.pdf)), которая сообщает оператору и телефону адресата, какая использовалась схема кодирования символов. Жена отправляла текст в GSM-7, но легко представить, что текст могли набрать кириллицей, иероглифами или сложными математическими уравнениями (ладно, может это и не легко представить, но каждый имеет право на мечту, верно?).
В тексте жены байт DCS установлен на
`0`
что соответствует 7-битному алфавиту, но значение можно изменить на 8- или 16-битный алфавит, хотя так останется гораздо меньше места для символов. Кстати, именно поэтому ваши эмодзи сокращают доступное количество символов.
В байте DCS есть ещё небольшой флаг, который говорит телефону, нужно ли самоуничтожать сообщение после отправки, как в фильме «Миссия невыполнима», так что это очень круто.
Период действия (VP) занимает до семи байт и даёт нам возможность познакомиться с другим аспектом, как в реальности работает система переадчи SMS. Взгляните ещё раз на рисунок 4 вверху. Всё в порядке, я подожду.
Итак, когда жена, наконец, нажимает кнопку «Отправить», текст отправляется в SMS-центр (SMSC), который затем направляет сообщение мне. Я сижу на втором этаже, и мой телефон включен, поэтому я получаю сообщение через несколько секунд, но что если телефон выключен? Конечно, тогда он не может принять сообщение, поэтому SMSC должен *что-то* сделать с текстом.
Если SMSC не может найти мой телефон, то сообщение от жены будет просто прыгать в системе, пока мой телефон не подключится — и тогда SMS-центр немедленно отправит текст. Мне нравится представлять, как SMSC постоянно проверяет каждый телефон в сети, чтобы проверить, это мой телефон или нет: как щенок, ожидающий хозяина у двери принюхивается к каждому прохожему: это запах моего человека? Нет. Может, *это* запах моего человека? Нет. Это запах моего человека? ДАДАПРЫГАТЬУРА!!!
Байты периода действия (VP) говорят системе, сколько времени щенок будет ждать, прежде чем ему надоест и он найдёт новый дом. Это либо метка времени, либо промежуток, и она по сути говорит: «Если вы не нашли телефон получателя в ближайшие дни, просто не беспокойтесь об отправке сообщения». По умолчанию срок действия SMS составляет 10 080 минут, так что если телефон не подключится к сети в течение семи дней, то никогда не получит это SMS.
Поскольку в SMS часто остаётся много пустого места, несколько битов посвящены тому, чтобы телефон и оператор точно знали, какие байты не используются. SIM-карта жены ожидает 176-байтовое SMS, но она написала очень короткое сообщение, так что если SIM-карта получит лишь 45 байт, то может запутаться и предположить некий сбой. Байт длины пользовательских данных (UDL) решает эту проблему: он точно указывает, сколько байт в текстовом сообщении.
В случае “I love you” UDL укажет, что в сообщении 9 байт. Вы могли бы ожидать, что значение будет 10 байт, по одному байту для каждого из десяти символов:
`I-spacebar-l-o-v-e-spacebar-y-o-u`
но поскольку каждый символ состоит из семи бит, а не из восьми (полный байт), можно сбросить дополнительный байт при переводе: 7 бит \* 10 символов = 70 бит, делим на 8 (количество битов в байте) = 8,75 байт, округлённых до 9 байт.
Мы подошли к последней части SMS: это само сообщение или UD (пользовательские данные). Сообщение может занять до 140 байт, хотя, как я только что упомянул, «Люблю тебя» займёт жалкие 9. Удивительно, сколько упаковано в эти 9 байт: не только сообщение (предполагаемая любовь моей жены ко мне, которую уже достаточно сложно сжать в нули и единицы), но и сам смысл (нужно спуститься вниз и пожелать ей спокойной ночи). Вот эти байты:
`49 10 FB 6D 2F 83 F2 EF 3A`
В целом, вот такое сообщение сохраняется на SIM-карте моей жены:
SCA[1-10]-PDU[1]-MR[1]-DA[1-12]-DCS[1]-VP[0, 1, or 7]-UDL[1]-UD[0-140]
`00 - 11 - 00 - 07 31 25 35 87 73 F6 - ?? 00 ?? - ?? - 09 - 49 10 FB 6D 2F 83 F2 EF 3A`
(Примечание: чтобы получить полное сообщение, нужно ещё немного покопаться. Увы, здесь видна только *часть* сообщения из-за неотображаемых символов, знаки вопроса)
Волны в эфире
=============
Теперь SMS должно каким-то образом начать свой трудный путь от SIM-карты до ближайшей базовой станции. Для этого телефон жены должен преобразовать строку из 176 в 279 байт для сигнального протокола SS7, преобразовать эти цифровые байты в аналоговый радиосигнал, а затем отправить сигналы в эфир с частотой где-то между 800 и 2000 МГц. Это означает, что между пиками волн расстояние от 15 до 37 см.
*Рис. 6. Длина волны*
Для эффективной передачи и приёма сигналов антенна должна быть не меньше половины длины волны. Если волны сотовой связи от 15 до 37 см, то антенны должны иметь размер примерно 7−19 см. Теперь остановитесь и подумайте о средней высоте мобильного телефона, и почему она никогда не уменьшается.
Через определённую цифровую гимнастику, объяснение которой займёт слишком много времени, внезапно телефон моей жены выстреливает 279-байтовый информационный пакет с текстом «Люблю тебя» со скоростью света во всех направлениях, который в конечном итоге угасает и растворяется в радиошуме примерно через 50 километров.
Задолго до этого сигнал попадает на базовую станцию AT&T HSPA ID199694204 LAC21767. Эта базовая приёмопередающая станция (BTS) находится примерно в пяти кварталах от моей любимой пекарни La Gourmandine в Хейзелвуде, и хотя я нашёл её координаты с помощью Android-приложения OpenSignal, антенна хорошо спрятана от посторонних глаз.
Здесь самое удивительное, что BTS вообще принимает этот сигнал, учитывая всё остальное. Мало того, что моя жена отправляет «Люблю тебя» в тысячном участке диапазона электромагнитного спектра, но десятки тысяч других людей в радиусе 50 километров в это время говорят по телефону или пишут сообщения. Вдобавок, в эфире за наше внимание спорит множество радио- и телесигналов, наряду с видимым светом, которые отражается в разные стороны, это лишь малая часть электромагнитных волн, которые, похоже, должны мешать работе BTS.
Как красноречиво выразился Ричард Фейнман в 1983 году, вышка сотовой связи словно маленький слепой жук, лежащий в воде на краю бассейна: только по высоте и направлению волн он определяет, кто и где плавает.
*Фейнман обсуждает волны*
Отчасти из-за сложной интерференции сигналов каждая базовая станция приёмопередатчика обычно не может обрабатывать более 200 активных пользователей (голос или данные) одновременно. Итак, «Люблю тебя» пингует местную базовую станцию примерно в полумиле отсюда, а затем кричит в пустоту во всех направлениях, пока не исчезает в общем шуме.
Коммутация
==========
Учитывая все обстоятельства, мне очень повезло. Если бы мы с женой обслуживались у разных операторов сотовой связи или были в разных городах, маршрут её сообщения стал бы гораздо длиннее.
Сообщение SS7 размером 279 байт приходит на местную BTS рядом с пекарней. Оттуда поступает в контроллер базовой станции (BSC), который является мозгом не только нашей, но и нескольких других местных антенн. BSC перебрасывает текст в центр коммутации мобильной связи AT&T города Питтсбург (MSC), который полагается на SCA текстового сообщения (помните адрес сервисного центра, встроенный в каждое SMS? вот где это нужно), чтобы получить сообщение в соответствующем SMS-центре (SMSC).
Эту тарабарщину легче понять с помощью диаграммы на рисунке 7; я только что описал шаги 1 и 3. Если бы жена была у другого оператора, мы бы перешли к шагам 4−7, потому что именно там мобильные операторы разговаривают друг с другом. SMS должно поступить от SMSC к глобальному коммутатору, а затем потенциально будет прыгать по всему миру, прежде чем найти путь к моему телефону.
*Рис. 7. Маршрутизация SMS по сети GSM*
Но она тоже сидит на AT&T, и наши телефоны подключены к одной и той же соте, поэтому после третьего шага 279-байтовый пакет любви просто разворачивается и возвращается через тот же SMS-центр, через ту же базовую станцию, но теперь на мой телефон вместо её. Путешествие в несколько десятков километров в мгновение ока.
Sent-to-SIM
===========
Бззззз. Карман завибрировал. Уведомление даёт понять, что SMS прибыло на карту nano-SIM, микросхему размером с мизинец. Как Бильбо Бэггинс или любой хороший искатель приключений, оно немного изменилось по пути туда и обратно.
*Рис. 8. Полученное сообщение отличается от отправленного (рис. 3)*
На рисунке 8 показана структура полученного сообщения «Люблю тебя». Сравнивая рисунки 3 и 8, мы видим несколько различий. SCA (номер SMS-центра), PDU (некоторое механическое наведение порядка), PID («с телефона на телефон», а не «с телефона на факс»), DCS (схема кодировки), UDL (длина сообщения) и UD (само сообщение) остались без изменений, а вот VP (срок действия), MR (идентификационный номер сообщений) и DA (мой номер телефона) отсутствуют.
Вместо них на телефоне появились два новых информационных блока: OA (исходный номер телефона жены) и SCTS (отметка времени SMS-центра. то есть когда жена отправила сообщение).
Номер телефона моей жены хранится в той же раздражающей обратной нотации (типа дислексии, только у компьютеров), в которой мой номер сохранялся на её телефоне, а метка времени в том же формате, что и дата истечения срока действия, сохранённая на её телефоне.
Эти две замены совершенно логичны. Её телефон должен был связаться со мной в определённое время по определённому адресу, а теперь мне нужно знать, кто отправил сообщение и когда. Без обратного адреса я бы не понял, кто именно отправил это сообщение, так что его интерпретация могла бы сильно измениться.
Яркий свет экрана
=================
Как любой компьютер переводит поток байтов в серию координат (x,y) для пикселей определённых цветов, телефон получает команду вывести на экран
`49 10 FB 6D 2F 83 F2 EF 3A`
чтобы я увидел на экране текст «Люблю тебя» в чёрно-белых светящихся точках. Это интересный процесс, но он не особенно уникален для смартфонов, так что придётся искать в другом месте. Сосредоточимся на том, как эти инструкции превращаются в световые точки.
Дружелюбные маркетологи в Samsung называют мой экран Super AMOLED (Active Matrix Organic Light-Emitting Diode) — активная матрица на органических светодиодах, что как-то избыточно и не особенно информативно, поэтому проигнорируем расшифровку аббревиатуры как ещё один отвлекающий фактор и погрузимся прямо в технологию.
На каждом из 83 квадратных сантиметров экрана в моём телефоне помещается около 50 000 крошечных пикселей. Чтобы такое количество поместилось, каждый пиксель должен быть шириной около 45 мкм (микрометров): тоньше, чем человеческий волос. Четыре миллиона световых элементов на площади размером с ладонь.
Но вы уже знаете, как работают экраны. Вы знаете, что каждая точка света, как христианский Бог или мушкетёры (минус д'Артаньян) — это всегда «три в одном». Красный, зелёный и синий образуют белый свет одного пикселя. Если изменять яркость каждого канала, то можно получить любой цвет RGB. А поскольку 4 × 3 = 12, то это 12 миллионов крошечных источников света, невинно дремлющих за моим чёрным зеркалом, ожидающих, когда я нажму кнопку питания, чтобы прочитать сообщение от жены.
*Рис. 9. Субпиксельный массив OLED-дисплея Samsung*
Как следует из аббревиатуры, каждый пиксель представляет собой органический светодиод. Это непонятный технический жаргон для простого электрического бутерброда:
*Рис. 10. Электрический бутерброд*
Изучать предназначение каждого слоя необязательно, важно только знать, что катод (отрицательно заряженная пластина) располагается под слоем органических молекул (просто некие молекулы с углеродом), а сверху накрывается анодом (положительно заряженной пластиной).
Когда телефон хочет включить экран, он посылает электроны от катода к аноду. Молекулы в середине получают заряд и начинают излучать видимый свет — фотоны, вверх через прозрачный анод, экран в мои открытые глаза.
Поскольку каждый пиксель — это три световые точки (красная, зелёная и синяя), на самом деле на пиксель приходится три бутерброда. Они все по существу одинаковы, за исключением органической молекулы: поли-пара-фенилен для синего света, политиофен для красного и поли-пара-фенилен-винилен для зелёного. Поскольку каждый из них немного отличается, то они светятся разными цветами при пропускании тока.
(Забавный факт: синие субпиксели выгорают намного быстрее из-за процесса под названием «экситон-поляронная аннигиляция», что звучит действительно захватывающе, не так ли?)
Все четыре миллиона пикселей расположены на индексной матрице. Индекс работает на компьютере почти так же, как оглавление в книге: когда телефон хочет, чтобы определённый пиксель излучил определенный цвет, он ищет этот пиксель в индексе, а затем отправляет сигнал по найденному адресу. *Да будет свет, и стал свет.*
(Ещё один забавный факт: теперь вы знаете, что значит «активная матрица на органических светодиодах» AMOLED, хоть вы и не спрашивали).
Операционная система телефона интерпретирует текстовое сообщение от жены, определяет форму каждой буквы и сопоставляет эти фигуры с индексной матрицей. Она посылает правильные электрические импульсы на экран Super AMOLED, чтобы отобразить эти три маленьких слова, которые преодолели такое расстояние и победили всех врагов на своём пути.
Тут очень странно, что мои глаза никогда не видят буквы в ярком свете светодиодов: текст появляется чёрно-белым. Телефон создает иллюзию текста через негативное пространство, заливая экран белым, устанавливая все красные, зелёные и синие пиксели на максимальную яркость, а затем отключив те, где должны быть буквы. Его сложность оскорбительно обыденна.
*Рис. 11. Негативное пространство*
Засвечивая всё, *кроме* самого текстового сообщения от моей жены и позволяя читать в промежутках между светом, телефон кратко излагает ложь, лежащую в основе современной информационной эпохи: что коммуникации — это *просто*. Скорость и видимая простота скрывают кучу посредников.
И это не только технические посредники. Сообщение от жены не дошло бы до меня, если бы я вовремя не оплатил телефонный счет, если бы не маленькая армия рабочих, которая за кулисами обслуживает финансовые системы. Технические специалисты поддерживают в рабочем состоянии сотовые вышки, до которых они добираются через сеть дорог, частично субсидируемых федеральными налогами, собранными с сотен миллионов американцев в 50 штатах. Поскольку много транзакций ещё происходит по почте, если почтовая система завтра рухнет, то телефонному сервису тоже будет больно. Детали обоих наших телефонов собрали измученные рабочие на заводах в Южной Америке и Азии, а вымотанные программисты, арендующие дорогие комнатушки в Кремниевой долине, написали код, который гарантирует постоянную связь для наших телефонов.
Всё это скрывается за 10 буквами. Текст, который, будем честны, значит гораздо больше, чем в нём написано. Мой мозг подсознательно анализирует годы общения с женой, чтобы расшифровать сообщение на телефоне, но между ней и мной всё равно целые заросли социотехнического посредничества — бульон из людей, событий и деталей, которые никогда не распутать.
Последствия
===========
И вот я здесь, в кабинете, поздним воскресным вечером. «Люблю тебя», — написала жена из спальни внизу, а через несколько секунд сообщение пришло на мой телефон в десяти метрах. Я понимаю, что это значит: пришло время пожелать ей спокойной ночи и, возможно, завершить эту статью. Я пишу последние слова, теперь немного более осведомлённый о сложном наслоении километров, сигналов, десятилетий истории и человеческого пота, которые потребовались, чтобы моя жена не кричала мне, что, чёрт побери, уже время отдохнуть. | https://habr.com/ru/post/437510/ | null | ru | null |
# Как мы переходили с InboxSDK на Gmail.js
Для разработки своего решения для поддержки клиентов мы выбрали сервис Gmail, так как это один из самых популярных почтовых клиентов. А для расширения его возможностей — готовую библиотеку InboxSDK. На момент разработки она обладала нужным нам функционалом, и такое решение помогло нам быстро выйти на рынок с первой версией продукта и набрать пользовательскую базу. С другой стороны, InboxSDK — закрытая библиотека от стороннего разработчика и она обладала недостатками, которые в дальнейшем надо было решать.
### Почему мы выбрали InboxSDK?
[Deskun](https://deskun.com/?utm_source=habrahabr&utm_medium=blog&utm_campaign=article_7&utm_content=1) реализован в виде расширения для Google Chrome и Яндекс.Браузера. Оно полностью функционирует на базе почтового сервиса Gmail. С нашей стороны требовалось выбрать библиотеку, которая могла бы расширить функционал почты и работать с её клиентской частью. Мы остановились на InboxSDK (ISDK).
Ключевая особенность Gmail, за которую его так любят пользователи, – это автоматическая группировка писем по диалогам. На внутреннем уровне (на серверах Gmail) каждое письмо имеет собственный идентификатор и идентификатор диалога, которому оно принадлежит. Но проблема в том, что в веб-клиенте глобальные ID сообщений не содержатся в коде страницы нигде, а глобальные ID диалогов содержатся только в хэше URL открытого диалога. Вместо этого HTML-элементы каждого сообщения и диалога отмечены локальными ID вида «:a5, :b6 и т.д.», получаемыми основным (достаточно большим и обфусцированным) скриптом Gmail. Так как локальные ID меняются от страницы к странице и от сессии к сессии, то для нормальной работы расширений, имеющих дело с почтой Gmail, необходимо оперативно устанавливать связь между локальными и глобальными ID. Этим и занимается библиотека InboxSDK, в которой, помимо функций для получения идентификаторов писем, черновиков и диалогов, доступны и возможности по улучшению пользовательского интерфейса.
Несмотря на то, что ISDK содержит в себе большое количество различных методов для работы с Gmail, у этой библиотеки есть одна неприятная особенность — ее разработкой занимается компания Streak, которая, в свою очередь, предоставляет собственную CRM-систему внутри Gmail. То есть является косвенным конкурентом Deskun.
### Проблемы InboxSDK
Развивать собственный закрытый проект на основе другого закрытого проекта по меньшей мере неправильно. Особенно, если эти проекты похожи и вам всегда могут закрыть доступ к API просто потому, что вы конкуренты. Даже если такого не произойдёт, то вы минимум не имеете никакого контроля над изменениями и доступностью. Разработчики библиотеки не спешат помогать в написании сторонних сервисов на основе своей библиотеки, а ченджлоги новых ревизий не несут никакой полезной информации. Даже сайт InboxSDK практически не обновляется с момента запуска. А уж про исправление багов по запросу пользователей или добавление возможностей, которые не касаются потребностей самой Streak, можно забыть. В первую очередь Steak делает библиотеку для себя.
**Первая проблема**. Для работы библиотеки используется привязка к каким-то определенным и стабильным (стабильным — которые не меняются при переключении вида, смены состояния и т.п.) классам. Например, в некоторых случаях эмулируются нажатия клавиш на сфокусированных элементах. И любое изменение интерфейса Gmail может нарушить работу самой библиотеки и сторонних разработок на основе InboxSDK.
**Вторая проблема**. Так как библиотека подключается удаленно при помощи загрузчика, то возможны перебои и в доставке контента по сети CDN. Некоторое время мы пытались понять что идет не так, а потом выяснили, что библиотека, на основе которой работает наш плагин, просто не загружается у некоторых пользователей. В какой-то момент оказалось, что уже 10% наших клиентов не могли работать с сервисом. Если возникали проблемы с загрузкой InboxSDK, то прекращалась работа всех платформ, построенных на этой библиотеке. Важно понимать, что проблема может иметь точечный характер, и далеко не всегда может зависеть от хостинга. И с нашей стороны исправить источник проблемы может быть совершенно невозможно и оставалось только ждать.
**Третья проблема**. InboxSDK не является открытой библиотекой. К публично объявленным функциям относится максимум треть из всех доступных. Это примерно 400 Кб упакованного кода, который вынужден парситься буквально сразу после парсинга основных скриптов Gmail. Время загрузки mail.google.com на медленных машинах — критично.
**Четвертая проблема**. Изменения в библиотеку вносятся не просто регулярно, а несколько раз в неделю. К сожалению, большинство этих изменений не содержат багфиксы и не добавляют новые возможности, а направлены на нужды основного разработчика Streak. Была ситуация, когда из-за одного обновления произошел конфликт с кодом в клиентской части нашего плагина. В декабре для InboxSDK вышла новая минорная (теневая, без ченджлога) версия, в которой была изменена функция вставки получателей. Она была реализована таким образом, что после добавления адресатов стоял триггер на сохранение черновика. Само сохранение было сделано довольно интересным способом — это была просто симуляция нажатия определенной клавиши по полю ввода. До всех изменений нажатие было реализовано по «Enter», а вот именно в том изменении они начали нажимать символ с кодом «190» (¾). У нас же в тикетах при открытии формы ответа автоматически подставляются получатели этого тикета. Таким образом, получился конфликт: во время ответа в тикете в поле получателей подставлялся символ ¾.
### Переход с InboxSDK на gmail.js
В итоге мы постепенно решили перейти на что-то более открытое, и библиотека Gmail.js (GJS) стала фундаментом для будущего решения. В отличие от InboxSDK, библиотека Gmail.js полностью открыта. Ее развитие зависит от сообщества и функционал может развиваться очень хорошими темпами.
При переходе мы столкнулись с двумя основными проблемами:
**Во-первых**, для функционирования библиотеки Gmail.js необходим доступ к объекту window страницы, в котором Gmail хранит некоторую техническую информацию. Расширение же в своей «песочнице» имеет доступ только к DOM страницы, но не к ее окружению.
**Во-вторых**, для того, чтобы полностью исключить изменения клиентской части плагина, необходима не просто обертка, но нужно еще дописать функции, которых нет в самой библиотеке.
Для первой проблемы нет какого-то идеального решения. Все они связаны с какими-то неудобствами – реализация через добавление своего скрипта непосредственно на страницу сайта `script` с postMessage, Custom Event или записью напрямую в DOM.
Мы решили реализовать мост, который, используя GJS, сообщает об определенных событиях непосредственно плагину. В текущей реализации через технологию инжекта в страницу внедряется библиотека GJS и наш мост. Таким образом GJS работает в нужном окружении. Для всех расширений браузер Google Chrome предоставляет некоторый набор методов для работы с ним самим. Соответственно, если делать расширение через прямой инжект (как библиотеку GJS), то она потеряет все возможности работы с API-расширений, поэтому может потеряться очень важный и нужный функционал.
Для решения второй проблемы необходимо было проанализировать поведение не только InboxSDK, но и саму работу клиентской части Gmail. Сейчас в нашем расширении есть места в коде, которые завязаны на атрибутах и классах инбокса: в некоторых случаях они дополнительно расширяли возможности библиотеки, а в некоторых они исправляли какие-то ошибки инбокса. Следовательно, чтобы не нарушить работу клиентской части плагина, необходимо было таким же образом добавлять нужные классы и атрибуты, добавлять их на определенные элементы, по определенным событиям и при определенных условиях. Уже ранее упоминалось, что нет какого-либо API для работы с клиентской частью Gmail. А ведь там хранится очень много нужной информации. Например, настройки пользователя, список доступных почтовых псевдонимов, набор включенных экспериментальных возможностей и прочая важная техническая информация.
### Итог
Нам удалось совершить переход с одной библиотеки на другую, не изменяя при этом логику и код в клиентской части плагина. Конечное решение представляет собой не просто использование библиотеки GJS, скорее мы создали свою собственную библиотеку-гибрид ISDK и GJS. Фундаментом послужила Gmail.js, но функционально наша разработка похожа на InboxSDK. Если сообществу Хабрахабр будет интересно, и будет много просьб поделиться нашим кодом, то мы приведем его в порядок и выложим.
### [Deskun](https://deskun.com/?utm_source=habrahabr&utm_medium=blog&utm_campaign=article_7&utm_content=2) | https://habr.com/ru/post/335874/ | null | ru | null |
# Одним махом 100 миллионов убивахом. Или lock-free распределитель памяти
#### Постановка задачи
Один из алгоритмов, который я реализовывал, имел интересные особенности при работе с памятью:
* Могло выделяться огромное количество, до десятков и сотен миллионов небольших объектов одного типа.
* Объекты представляли собой POD- типы.
**POD**A Plain Old Data Structure in C++ is an aggregate class that contains only PODS as members, has no user-defined destructor, no user-defined copy assignment operator, and no nonstatic members of pointer-to-member type.
* Заранее было неизвестно какое количество объектов понадобится, могло так случится, что потребуется сотня, а может и сто миллионов.
* Объекты никогда не удаляются по одному, в какой-то момент они становятся не нужны все сразу.
* Алгоритм хорошо распараллеливается, по этому выделением объектов занимается одновременно несколько потоков, по количеству ядер процессора(ов).
Использование в таких условиях стандартного new – delete приводит к очень большим потерям времени на удаление объектов. Если без отладчика удаление происходило хотя бы за несколько секунд, то в присутствии отладчика освобождение памяти замедляется примерно в 100(!) раз, и отладка проекта становится просто невозможной. Кроме того из-за большого количества выделенных объектов достаточно ощутимым становился перерасход памяти на внутренние данные распределителя памяти.
Для решения задачи выделения огромного количества объектов одного типа, и их пакетного удаления, был сделан lock-free контейнер MassAllocator. Код компилируется Visual Studio 2012. Полный код проекта выложен на [github](https://github.com/drbasic/MassAllocator).
#### Дополнительные особенности
В моем случае объекты могли ссылаться друг на друга, и для экономии памяти был придуман небольшой хак: вместо указателя сохраняется номер объекта, а сам объект получается запросом к хранилищу. Количество объектов гарантированно меньше четырех миллиардов, поэтому использовался 32 битный индекс вместо 64 битного указателя, что дает экономию 4 байта. Так мне удалось примерно на 12 % снизить потребление памяти.
Приятным бонусом оказалось, что к хранилищу легко можно сделать итераторы, чтобы применять алгоритмы стандартной библиотеки, например std::sort.
#### Реализация
Идея заключается в последовательном выделении элементов блоками. Стандартным malloc выделяется блок памяти, который логически представляется в виде массива элементов. На каждый запрос пользователя о выделении элемента ему возвращается указатель на следующий элемент массива, и счетчик выделенных элементов инкрементируется. Когда все элементы из массива будут выделены, запрашивается следующий блок памяти, и т.д. Освобождение памяти происходит очень быстро, всего лишь происходит освобождение всех выделенных блоков, без каких-либо вызовов деструкторов для элементов.
Все блоки имеют одинаковый размер, таким образом получается очень легко обратится к элементу по сквозному номеру:
```
template
typename MassAllocator::reference MassAllocator::operator[](size\_type index)
{
size\_t indexOfBlock = index / elementsInBlockCount\_;
size\_t indexInBlock = index % elementsInBlockCount\_;
return blocks\_[indexOfBlock][indexInBlock];
}
```
#### Выделение нового элемента
Итак, все элементы последовательно располагаются в блоках. Распределение нового элемента выглядит очень просто: нужно увеличить счетчик выделенных элементов, убедится, что место в текущем блоке, из которого ведется распределение элементов, не кончилось, и если потребуется, то выделить новый блок. Конечно же, счетчик, инкрементируемый из разных потоков, должен быть реализован через атомарную переменную std::atomic, а сам алгоритм должен быть lock-free!
Атомарный счетчик последовательно выдает индексы, и все замечательно до тех пор, пока в блоке есть место. Но вот блок заканчивается, и необходимо выделить новый. Выделять блок должен какой-то один поток, а остальные на это время должны приостановиться и возобновить работу после выделения блока. С помощью одного атомарного счетчика мне удалось реализовать такую логику с одним допущением: время выделения блока памяти должно быть достаточно мало, чтобы оставшиеся потоки не смогли переполнить 32 битный счетчик в холостом цикле ожидания. Для синхронизации доступа использована 64 битная атомарная переменная, которая логически разделена на 2 части: младшие 32 бита — это счетчик элемента внутри блока, а старшие 32 бита — это счетчик выделенных блоков памяти. Счетчик объявляется как:
```
std::atomic curAtomicIndex\_
```
В каждом блоке памяти распределяется одинаковое количество элементов, например 100000. После инкрементирования счетчика может возникнуть три различных ситуации для счетчика элемента в блоке:
* Было получено число от 1 до 99999. Это ситуация означает, что места в блоке хватает, и мы зарезервировали элемент с полученным номером.
* Был получен индекс, совпадающий с размером блока – 100000. Означает что потоку «повезло», и именно на нем закончился блок. В этом случае требуется выделить новый блок памяти, забрать из него нулевой элемент себе, инкрементировать старший счетчик блоков, установить младший счетчик на первый свободный элемент – 1, и записать новое значение в атомарную переменную.
* Был получен индекс с номером больше чем размер блока. Это означает что, в данный момент какой-то из потоков производит выделение памяти, а мы вынуждены ждать, пока он не выставит младший счетчик в значение 1. В этом случае торопиться не стоит, и можно отдавать процессорное время другим потокам вызовом
```
std::this_thread::yield();
```
Сначала я пытался сделать реализацию на двух 32битных счетчиках, но в этом случае возникает эффект гонки. Например, первым делается запрос индекса в блоке, а затем номер блока.
```
// так делать нельзя!
uint32_t itemIndex = atomicIndex++;
uint32_t blockIndx = atomicBlock.load();
```
Может случиться так, что поток получил валидный индекс элемента itemIndex, но до момента получения индекса блока blockIndx планировщик потоков усыпил его, а за время сна другим потоком был выделен новый блок, тогда по пробуждении поток получит индекс не того блока, где был зарезервирован элемент. По этому, и индекс элемента, и индекс блока должны получаться атомарно либо в критической секции, либо через одну атомарную переменную.
Код выделения элемента имеет особенность в том, что одновременно с указателем на выделенный элемент может возвращаться индекс этого элемента, а обращение к верхней и нижней части 64 битного целого организуется через union, а не битовую арифметику.
```
template
typename MassAllocator::pointer MassAllocator::createElement(size\_type \*returningIndex)
{
//Делаем union для доступа к старшим и младшим 32 битам 64 битного целого
union {
uint64\_t index;
struct HiLoParts {
uint32\_t itemIndex;
uint32\_t blockIndx;
} parts;
};
//получаем новый полный индекс
index = curAtomicIndex\_++;
//если индекс элемента в блоке входит в допустимые пределы, то мы быстренько возвращаем индекс и указатель выделенного элемента
if(parts.itemIndex < elementsInBlockCount\_)
{
if (returningIndex != nullptr)
\*returningIndex = parts.blockIndx \* elementsInBlockCount\_ + parts.itemIndex;
return &(blocks\_[parts.blockIndx][parts.itemIndex]);
}
if (parts.itemIndex == elementsInBlockCount\_)
{
//на нас закончился блок и именно нашему потоку нужно выделить еще один блок памяти
auto bufferSize = elementsInBlockCount\_ \* sizeof(T);
T\* buffer = (T\*)malloc(bufferSize);
memset(buffer, 0, bufferSize);
blocks\_.push\_back(buffer);
//мы забираем себе нулевой элемент в блоке
parts.blockIndx = (unsigned int)(blocks\_.size() - 1);
parts.itemIndex = 0;
if (returningIndex != nullptr)
\*returningIndex = parts.blockIndx \* elementsInBlockCount\_ + parts.itemIndex;
//устанавливаем счетчик на первый элемент в блоке
setIndex(parts.blockIndx, 1);
return &(blocks\_[parts.blockIndx][parts.itemIndex]);
}
//ждем, пока другой поток производит выделение нового блока
while(true)
{
//получаем новый полный индекс
index = curAtomicIndex\_++;
if (parts.itemIndex == 0xffffffff)
//мы крутили цикл ожидания настолько долго, что произошло переполнение
throw std::string("Atomic index overflow");
if (parts.itemIndex >= elementsInBlockCount\_)
{
//блок еще не выделен, продолжаем ожидание
std::this\_thread::yield();
continue;
}
//блок был выделен другим потоком, мы захватили валидный индекс элемента из нового блока
if (returningIndex != nullptr)
\*returningIndex = parts.blockIndx \* elementsInBlockCount\_ + parts.itemIndex;
return &(blocks\_[parts.blockIndx][parts.itemIndex]);
}
}
```
#### Производительность
Под платформу x64 выделение 80 миллионов элементов в 8 потоках с помощью MassAllocator выполняется на i5 2500K примерно за 2000 мс, освобождение за 70 мс. Выделение с помощью new происходит примерно за 1350 мс, а вот удаление через delete выполняется за целых 17400 мс! Под отладчиком, даже если проект собран в релизной конфигурации, я так ни разу и не смог дождаться завершения теста.
Для тестирования на платформе x86 пришлось уменьшить количество выделяемых объектов вдвое, так как new-delete имеет большие накладные расходы и адресного пространства не хватает для 80 миллионов объектов. 40 миллионов объектов выделяются MassAllocator’ом за 2400 мс, освобождаются за 35 мс, тогда как new выполняет свою работу за 750 мс, а delete за 6430 мс.
Как и ожидалось, профилирование показывает узкое место – инкрементирование атомарного счетчика, особенно под x86. Каких-то радикальных идей по ускорению этого фрагмента у меня пока нет.
#### Заключение
Lock-free алгоритмы это новая область для меня, потому буду рад выслушать соображения относительно корректности алгоритма и/или предложения по ускорению кода.
#### Update1
Как показало профилирование, основное время тратится на атомарный инкремент 64 битного счетчика curAtomicIndex\_. В x64 это транслируется в одну ассемблерную команду `lock xadd QWORD PTR`, в режиме x86 транслируется в целую поэму
```
$again$158:
; 2424 : again:
; 2425 : mov ecx, edx;
mov ecx, edx
; 2426 : mov ebx, eax;
mov ebx, eax
; 2427 : add ebx, dword ptr _Value;
add ebx, DWORD PTR $T7[ebp]
; 2428 : adc ecx, dword ptr _Value[4];
adc ecx, DWORD PTR $T7[ebp+4]
; 2429 : lock cmpxchg8b [esi];
lock cmpxchg8b QWORD PTR [esi]
; 2430 : jnz again;
jne SHORT $again$158
```
По этому выделение элемнта в 64битном режиме происходит значительно быстрее.
Освобождение памяти происходит быстро и в x64 и в x86.
В качестве альтернативы можно было бы использовать `boost::object_pool`, который подходит по идеологии, но он не многопоточен и может работать с несколькими потоками.
На замену new-delete можно попробовать `boost::fast_pool_allocator`, он показывает лучшую скорость чем new-delete, и в 32 битном режиме даже идет наравне в общем зачете (выделение + освобождение) с MassAlloc за счет более быстрого выделения.
По эффективности использования памяти все альтернативы уступают MassAlloc, так в 32 битном режиме ни у new-delete, ни у boost::fast\_pool\_allocator не хватает адресного пространства для размещения 80 миллионов объектов, тогда как MassAllocator потребляет всего 1570 МБ. | https://habr.com/ru/post/182722/ | null | ru | null |
# Вред макросов для C++ кода
Язык C++ открывает обширные возможности для того, чтобы обходиться без макросов. Так давайте попробуем использовать макросы как можно реже!
Сразу оговорюсь, что я не являюсь фанатиком и не призываю отказываться от макросов из идеалистических соображений. Например, когда речь заходит о ручной генерации однотипного кода, я могу признать пользу от макросов и смириться с ними. Например, я спокойно отношусь к макросам в старых программах, написанных с использованием MFC. Нет смысла воевать с чем-то вроде этого:
```
BEGIN_MESSAGE_MAP(efcDialog, EFCDIALOG_PARENT )
//{{AFX_MSG_MAP(efcDialog)
ON_WM_CREATE()
ON_WM_DESTROY()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
```
Существуют такие макросы, да и ладно. Они действительно были созданы для упрощения программирования.
Я говорю о других макросах, с помощью которых пытаются избежать реализации полноценной функции или стараются сократить размер функции. Рассмотрим несколько мотивов избегать таких макросов.
*Примечание. Этот текст писался как гостевой пост для блога «Simplify C++». Русский вариант статьи решил опубликовать здесь. Собственно, пишу это примечание для того, чтобы избежать вопрос от невнимательных читателей, почему статья не помечена как «перевод» :). А вот, собственно, гостевой пост на английском языке: "[*Macro Evil in C++ Code*](https://arne-mertz.de/2019/03/macro-evil/)".*
Первое: код с макросами притягивает к себе баги
-----------------------------------------------
Я не знаю, как объяснить причины этого явления с философской точки зрения, но это так. Более того, баги, связанные с макросами, часто очень сложно заметить, проводя code review.
Такие случаи я неоднократно описывал в своих статьях. Например, подмена функции *isspace* вот таким макросом:
```
#define isspace(c) ((c)==' ' || (c) == '\t')
```
Программист, использовавший *isspace*, полагал, что использует настоящую функцию, которая считает пробельными символами не только пробелы и табы, но также и LF, CR и т.д. В результате получается, что одно из условий всегда истинно и код работает не так, как предполагалось. Эта ошибка из Midnight Commander описана [здесь](https://www.viva64.com/ru/b/0610/).
Или как вам вот такое сокращение написания функции *std::printf*?
```
#define sprintf std::printf
```
Думаю, читатель догадывается, что это был весьма неудачный макрос. Найден он был, кстати, в проекте StarEngine. Подробнее об этом можно прочитать [здесь](https://www.viva64.com/ru/b/0535/).
Можно возразить, что в этих ошибках виноваты программисты, а не макросы. Это так. Естественно, в ошибках всегда виноваты программисты :).
Важно, что макросы провоцируют ошибки. Получается, что макросы нужно использовать с повышенной аккуратностью или вообще не использовать.
Я могу долго приводить примеры дефектов, связанных с использованием макросов, и эта милая заметка превратится в увесистый многостраничный документ. Этого я, конечно, делать не буду, но ещё пару случаев для убедительности покажу.
Библиотека ATL [предоставляет](https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2013/87zae4a3(v=vs.120)) для конвертации строк такие макросы, как A2W, T2W и так далее. Однако мало кто знает, что эти макросы очень опасно использовать внутри циклов. Внутри макроса происходит вызов функции [*alloca*](http://man7.org/linux/man-pages/man3/alloca.3.html), которая на каждой итерации цикла будет вновь и вновь выделять память на стеке. Программа может делать вид, что корректно работает. Стоит только программе начать обрабатывать длинные строки или увеличится количество итераций в цикле, так стек может взять и закончиться в самый неожиданный момент. Подробнее про это можно прочитать в этой [мини-книге](https://www.viva64.com/ru/b/0391/) (см. главу «Не вызывайте функцию alloca() внутри циклов»).
Макросы, такие как A2W, прячут зло. Они выглядят, как функции, но, на самом деле, имеют побочные эффекты, которые сложно заметить.
Не могу я пройти и мимо подобных попыток сокращать код с помощью макросов:
```
void initialize_sanitizer_builtins (void)
{
....
#define DEF_SANITIZER_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
decl = add_builtin_function ("__builtin_" NAME, TYPE, ENUM, \
BUILT_IN_NORMAL, NAME, NULL_TREE); \
set_call_expr_flags (decl, ATTRS); \
set_builtin_decl (ENUM, decl, true);
#include "sanitizer.def"
if ((flag_sanitize & SANITIZE_OBJECT_SIZE)
&& !builtin_decl_implicit_p (BUILT_IN_OBJECT_SIZE))
DEF_SANITIZER_BUILTIN (BUILT_IN_OBJECT_SIZE, "object_size",
BT_FN_SIZE_CONST_PTR_INT,
ATTR_PURE_NOTHROW_LEAF_LIST)
....
}
```
Только первая строка макроса относится к оператору *if*. Остальные строки будут выполняться независимо от условия. Можно сказать, что эта ошибка из мира C, так как она была найдена мною с помощью диагностики [V640](https://www.viva64.com/ru/examples/v640/) внутри компилятора GCC. Код GCC написан в основном на C, а в этом языке без макросов обходиться тяжело. Однако согласитесь, что этот не тот случай. Здесь вполне можно было сделать настоящую функцию.
Второе: усложняется чтение кода
-------------------------------
Если вы сталкивались с проектом, который весь пестрит макросами, состоящими из других макросов, то вы понимаете, какой это ад — разбираться в подобном проекте. Если не сталкивались, то поверьте на слово, это грустно. В качестве примера тяжёлого для восприятия кода могу привести уже упомянутый ранее компилятор GCC.
По легенде, компания Apple вложилась в развитие проекта LLVM как альтернативного варианта GCC по причине слишком большой сложности кода GCC из-за этих самых макросов. Где я читал про это, я не помню, поэтому proof-ов не будет.
Третье: писать макросы сложно
-----------------------------
Легко написать плохой макрос. Я их повсюду встречаю с соответствующими последствиями. А вот написать хороший и надёжный макрос часто сложнее, чем написать аналогичную функцию.
Написать хороший макрос сложно по той причине, что в отличие от функции его нельзя рассматривать как самостоятельную сущность. Требуется сразу рассматривать макрос в контексте всех возможных вариантов его использования, иначе очень легко огрести проблему вида:
```
#define MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
m = MIN(ArrayA[i++], ArrayB[j++]);
```
Конечно, для таких случаев давно придуманы обходные трюки и макрос можно реализовать безопасно:
```
#define MAX(a,b) \
({ __typeof__ (a) _a = (a); \
__typeof__ (b) _b = (b); \
_a > _b ? _a : _b; })
```
Только вопрос, а нужно ли нам всё это в C++? Нет, в C++ есть шаблоны и другие способы построить эффективный код. Так почему я продолжаю встречать подобные макросы в C++ программах?
Четвёртое: усложняется отладка
------------------------------
Есть мнение, что отладка — это для слабаков :). Это, конечно, интересно обсудить, но с практической точки зрения отладка полезна и помогает находить ошибки. Макросы усложняют этот процесс и однозначно замедляют поиск ошибок.
Пятое: ложные срабатывания статических анализаторов
---------------------------------------------------
Очень многие макросы в силу специфики своего устройства порождают множественные ложные срабатывания статических анализаторов кода. Могу смело утверждать, что большинство ложных срабатывания при проверке C и C++ кода связано именно с макросами.
Беда с макросами в том, что анализаторы просто не могут отличить корректный хитрый код от ошибочного кода. В [статье](https://www.viva64.com/ru/b/0552/) про проверку Chromium описан один из таких макросов.
Что делать?
-----------
Давайте не использовать макросы в C++ программах без крайней на то необходимости!
C++ предоставляет богатый инструментарий, такой как шаблонные функции, автоматический вывод типов (auto, decltype), constexpr functions.
Почти всегда вместо макроса можно написать обыкновенную функцию. Часто этого не делают по причине обыкновенной лени. Эта лень вредна, и с ней надо бороться. Небольшое дополнительное время, потраченное на написание полноценной функции, окупится с лихвой. Код будет проще читать и сопровождать. Уменьшится вероятность отстрелить себе ногу, а компиляторы и статические анализаторы будут выдавать меньше ложных срабатываний.
Кто-то может возразить, что код с функцией менее эффективен. Это тоже только «отмазка».
Компиляторы сейчас отлично инлайнят код, даже если вы не написали ключевое слово *inline*.
Если же речь идёт о вычислении выражений на этапе компиляции, то и здесь макросы не нужны и даже вредны. Для тех же целей намного лучше и безопаснее использовать *constexpr*.
Поясню на примере. Перед вами классическая ошибка в макросе, который я [позаимствовал](https://www.viva64.com/ru/b/0377/) из кода FreeBSD Kernel.
```
#define ICB2400_VPOPT_WRITE_SIZE 20
#define ICB2400_VPINFO_PORT_OFF(chan) \
(ICB2400_VPINFO_OFF + \
sizeof (isp_icb_2400_vpinfo_t) + \
(chan * ICB2400_VPOPT_WRITE_SIZE)) // <=
static void
isp_fibre_init_2400(ispsoftc_t *isp)
{
....
if (ISP_CAP_VP0(isp))
off += ICB2400_VPINFO_PORT_OFF(chan);
else
off += ICB2400_VPINFO_PORT_OFF(chan - 1); // <=
....
}
```
Аргумент *chan* используется в макросе без обёртывания в круглые скобки. В результате, на константу *ICB2400\_VPOPT\_WRITE\_SIZE* умножается не выражение *(chan — 1)*, а только единица.
Ошибка не появилась бы, если вместо макроса была написана обыкновенная функция.
```
size_t ICB2400_VPINFO_PORT_OFF(size_t chan)
{
return ICB2400_VPINFO_OFF
+ sizeof(isp_icb_2400_vpinfo_t)
+ chan * ICB2400_VPOPT_WRITE_SIZE;
}
```
С большой вероятностью современный C и C++ компилятор самостоятельно выполнит подстановку (*inlining*) функции, и код будет столь же эффективен, как и в случае макроса.
При этом код стал более читаемым, а также избавленным от ошибки.
Если известно, что входным значением всегда является константа, то можно добавить [constexpr](https://en.cppreference.com/w/cpp/language/constexpr) и быть уверенным, что все вычисления произойдут на этапе компиляции. Представим, что это язык C++ и что *chan* — это всегда некая константа. Тогда функцию *ICB2400\_VPINFO\_PORT\_OFF* полезно объявить так:
```
constexpr size_t ICB2400_VPINFO_PORT_OFF(size_t chan)
{
return ICB2400_VPINFO_OFF
+ sizeof(isp_icb_2400_vpinfo_t)
+ chan * ICB2400_VPOPT_WRITE_SIZE;
}
```
Profit!
Надеюсь, мне удалось вас убедить. Желаю удачи и поменьше макросов в коде! | https://habr.com/ru/post/444612/ | null | ru | null |
# Вышел React v16.0
Это перевод поста Эндрю Кларка о выходе столь ожидаемой версии React. Оригинальный пост в [блоге React](https://facebook.github.io/react/blog/2017/09/26/react-v16.0.html).
Мы с удовольствием сообщаем о выходе React v16.0! Среди изменений некоторые давно ожидаемые нововведения, например [**фрагменты**](#new-render-return-types-fragments-and-strings), [**обработка ошибок (error boundaries)**](#better-error-handling), [**порталы**](#portals), поддержка [**произвольных DOM-атрибутов**](#support-for-custom-dom-attributes), улучшения в [**серверном рендере**](#better-server-side-rendering), и [**уменьшенный размер файла**](#reduced-file-size).
### Новые типы для рендера: фрагменты и строки
Теперь вы можете вернуть массив элементов из `render`-метода компонента. Как и с другими массивами, вам надо добавлять ключ к каждому элементу, чтобы реакт не ругнулся варнингом:
```
render() {
// Нет необходимости оборачивать в дополнительный элемент!
return [
// Не забудьте добавить ключи :)
- Первый элемент
,
- Второй элемент
,
- Третий элемент
,
];
}
```
В будущем мы, вероятно, добавим специальный синтакс для вывода фрагментов, который не будет требовать явного указания ключей.
Мы добавили поддержку и для возврата строк:
```
render() {
return 'Мама, смотри, нет лишних спанов!';
}
```
[Полный список поддерживаемых типов](https://facebook.github.io/react/docs/react-component.html#render).
### Улучшенная обработка ошибок
Ранее ошибки рендера во время исполнения могли полностью сломать ваше приложение, и описание ошибок часто было малоинформативным, а выход из такой ситуации был только в перезагрузке страницы. Для решения этой проблемы React 16 использует более надёжный подход. По-умолчанию, если ошибка появилась внутри рендера компонента или в lifecycle-методе, всё дерево компонентов отмонтируется от корневого узла. Это позволяет избежать отображения неправильных данных. Тем не менее, это не очень дружелюбный для пользователей вариант.
Вместо отмонтирования всего приложения при каждой ошибке, вы можете использовать *error boundaries*. Это специальные компоненты, которые перехватывают ошибки в своём поддереве и позволяют вывести резервный UI. Воспринимайте их как try-catch операторы, но для React-компонентов.
Для дальнейшей информации проверьте наш [недавний пост про обработку ошибок в React 16](https://facebook.github.io/react/blog/2017/07/26/error-handling-in-react-16.html).
### Порталы
Порталы дают удобный способ рендера дочерних компонентов в DOM-узел, который находится за пределами дерева родительского компонента.
```
render() {
// React не создаёт новый див. Он рендерит дочерние элементы в domNode.
// domNode - это любой валидный DOM-узел,
// вне зависимости от его расположения в DOM-дереве.
return ReactDOM.createPortal(
this.props.children,
domNode,
);
}
```
Полный пример находится в [документации по порталам](https://facebook.github.io/react/docs/portals.html).
### Улучшенный серверный рендеринг
React 16 содержит полностью переписанный серверный рендерер, и он действительно быстрый. Он поддерживает **стриминг**, так что вы можете быстрее начинать отправлять байты клиенту. И благодаря [новой стратегии сборки](#reduced-file-size), которая убирает из кода обращения к `process.env` (хотите верьте, хотите — нет, но чтение `process.env` в Node очень медленное!), вам больше не надо бандлить React для получения хорошей производительности серверного рендеринга.
Ключевой разработчик Саша Айкин написал замечательную статью, рассказывающую об [улучшениях SSR в React 16](https://medium.com/@aickin/whats-new-with-server-side-rendering-in-react-16-9b0d78585d67). Согласно Сашиным бенчмаркам, серверный рендеринг в React 16 примерно **в 3 раза быстрее**, чем в React 15. При сравнении с рендером в React 15 c убранным из кода `process.env` получается ускорение в 2.4 раза в Node 4, около 3-х раз в Node 6 и аж в 3.8 раза в Node 8.4. А если вы сравните с React 15 без компиляции (без убранного `process.env`), React 16 оказывается на порядок быстрее в последней версии Node! (Как Саша указал, к этим синтетическим бенчмаркам надо относиться осторожно, так как они могут не отображать производительность реальных приложений).
Более того, React 16 лучше в восстановлении отрендеренного на сервере HTML, когда последний приходит в браузер. Больше не требуется начальный рендер, используемый для проверки результатов с сервера. Вместо этого он будет пытаться переиспользовать как можно больше существующего DOM. Больше не будут использоваться контрольные суммы! В целом мы не рекомендуем рендерить на клиенте отличающийся от сервера контент, но это может быть полезно в некоторых сценариях (например вывод меток времени).
Больше в [документации по ReactDOMServer](https://facebook.github.io/react/docs/react-dom-server.html).
### Поддержка произвольных DOM-атрибутов
Вместо игнорирования неизвестных HTML и SVG атрибутов, теперь React будет просто [передавать их в DOM](https://facebook.github.io/react/blog/2017/09/08/dom-attributes-in-react-16.html). Вдобавок это позволяет нам отказаться от длиннющих списков разрешённых атрибутов, что уменьшает размер бандла.
### Уменьшенный размер файла
Несмотря на все эти нововведения, React 16 **меньше**, чем React 15.6.1!
* `react` весит 5.3 kb (2.2 kb gzipped), по сравнению с 20.7 kb (6.9 kb gzipped) ранее.
* `react-dom` весит 103.7 kb (32.6 kb gzipped), по сравнению с 141 kb (42.9 kb gzipped) ранее.
* `react` + `react-dom` вместе 109 kb (34.8 kb gzipped), по сравнению 161.7 kb (49.8 kb gzipped) ранее.
В общей сложности размер уменьшился на 32% по сравнению с прошлой версией (30% после gzip-сжатия).
На уменьшение размера частично влияют изменения в сборке. React теперь использует [Rollup](https://rollupjs.org/) для создания "плоских" бандлов (*по-видимому Эндрю Кларк тут имел ввиду "scope hoisting", что давно было в Rollup, но в Webpack появилось только в третьей версии*) всех поддерживаемых форматов, что привело к выигрышу и в размере и в скорости работы. Также плоский формат бандла приводит к тому, что воздействие React на бандл приложения остаётся одинаковым, независимо от того, как вы доставляете свой код конечным пользователям, напр. используя Webpack, Browserify, уже собранные UMD-модули или любой другой способ.
### MIT лицензия
[Если вы вдруг пропустили](https://code.facebook.com/posts/300798627056246/relicensing-react-jest-flow-and-immutable-js/), React 16 теперь доступен под MIT лицензией. А для тех, кто не может обновиться немедленно, мы выложили версию React 15.6.2 под MIT.
### Новая архитектура ядра
React 16 — это первая версия React, построенная на основе новой архитектуры, называемой Fiber. Вы можете почитать всё об этом проекте в [инженерном блоге Facebook](https://code.facebook.com/posts/1716776591680069/react-16-a-look-inside-an-api-compatible-rewrite-of-our-frontend-ui-library/). (Спойлер: мы полностью переписали React!)
Fiber затрагивает большинство новых фич в React 16, такие как error boundaries или фрагменты. Через несколько релизов вы увидите несколько новых фич, так как мы будем постепенно раскрывать потенциал React.
Наверно наиболее впечатляющее нововведение, над которым мы работаем — это **асинхронный рендеринг**, позволяющий компонентам использовать кооперативную многозадачность в рамках рендера через периодическую передачу управления браузеру. Итог — с асинхронным рендерингом приложения более отзывчивы, так как React не блокирует главный поток.
[Следующее демо](https://build-mbfootjxoo.now.sh/) даёт нам взглянуть на суть проблемы, решаемую асинхронным рендерингом (подсказка: обратите внимание на крутящийся черный квадрат).
> Ever wonder what "async rendering" means? Here's a demo of how to coordinate an async React tree with non-React work <https://t.co/3snoahB3uV> [pic.twitter.com/egQ988gBjR](https://t.co/egQ988gBjR)
>
>
>
> — Andrew Clark (@acdlite) [September 18, 2017](https://twitter.com/acdlite/status/909926793536094209)
Мы думаем, что асинхронный рендеринг — очень важная вещь, двигающая React в будущее. Чтобы сделать переход на v16.0 как можно более безболезненным, мы пока не включили какие-либо асинхронные фичи, но мы рады выкатить их в ближайшие месяцы. Следите за обновлениями!
Установка
---------
React v16.0.0 доступен в npm репозитории.
Для установки React 16 используя Yarn:
```
yarn add react@^16.0.0 react-dom@^16.0.0
```
Для установки React 16 используя npm:
```
npm install --save react@^16.0.0 react-dom@^16.0.0
```
Мы также предоставляем UMD-вариант, выложенный на CDN:
```
```
Ссылка на документацию по [детальным инструкциям по установке](https://facebook.github.io/react/docs/installation.html).
Переход со старой версии
------------------------
Хотя React 16 включает значительные внутренние изменения, в случае обновления вы можете относится к этому релизу как к любому обычному мажорному релизу React. Мы используем React 16 в Facebook и Messenger.com с начала этого года, мы выкатили несколько бета-версий и релиз кандидатов, чтобы максимально исключить возможные проблемы. Если не учитывать некоторые нюансы, то **ваше приложение должно работать с 16-й версией, если с 15.6 оно работало без каких-либо варнингов**.
### Устаревшие методы
Восстановление отрендеренного на сервере кода теперь имеет явное API. Для восстановления HTML вам надо использовать [`ReactDOM.hydrate`](https://facebook.github.io/react/docs/react-dom.html#hydrate) вместо `ReactDOM.render`. Продолжайте использовать `ReactDOM.render`, если вы рендерите только на клиентской стороне.
### React Addons
Как ранее было объявлено, мы [прекращаем поддержку React Addons](https://facebook.github.io/react/blog/2017/04/07/react-v15.5.0.html#discontinuing-support-for-react-addons). Мы ожидаем, что последняя версия каждого дополнения (кроме`react-addons-perf`; см. ниже) будет работоспособна в ближайшем будущем, но мы не будем публиковать новых обновлений.
По ссылке есть ранее опубликованные [предложения по миграции](https://facebook.github.io/react/blog/2017/04/07/react-v15.5.0.html#discontinuing-support-for-react-addons).
А `react-addons-perf` вообще не будет работать в React 16. Скорее всего мы выпустим новую версию этого инструмента в будущем. А пока вы можете использовать [браузерные инструменты для измерения производительности](https://facebook.github.io/react/docs/optimizing-performance.html#profiling-components-with-the-chrome-performance-tab).
### Несовместимые изменения
React 16 включает несколько небольших изменений без обратной совместимости. Они влияют на редко используемые сценарии и затронут малую часть приложений.
* React 15 имел ограниченную и недокументированную поддержку error boundaries через использование `unstable_handleError`. Этот метод теперь переименован в `componentDidCatch`. Вы можете использовать codemod для [автоматической миграции на новое API](https://github.com/reactjs/react-codemod#error-boundaries).
* `ReactDOM.render` и `ReactDOM.unstable_renderIntoContainer` теперь возвращают null, если вызваны из lifecycle-метода. Вместо этого теперь используйте [порталы](https://github.com/facebook/react/issues/10309#issuecomment-318433235) или [ссылки](https://github.com/facebook/react/issues/10309#issuecomment-318434635).
* `setState`:
+ Вызов `setState` с null больше не будет вызывать реконсиляцию. Это позволит определять в коллбеке надо ли вызывать перерендер.
+ Вызов `setState` напрямую в рендере всегда вызывает реконсиляцию, чего раньше не было. Независимо от того, вам однозначно не надо вызывать setState из метода рендера.
+ Коллбек `setState`'а (второй аргумент) теперь вызывается немедленно после `componentDidMount` / `componentDidUpdate`, вместо того чтобы ждать полного рендера дерева компонентов.
* При замене на , `B.componentWillMount` будет вызываться всегда перед `A.componentWillUnmount`. Ранее `A.componentWillUnmount` мог вызываться раньше в некоторых случаях.
* Ранее изменение ссылки на компонент вызывало всегда обнуление ссылки перед вызовом рендера. Теперь мы изменяем ссылку позднее, когда применяем изменения к DOM.
* Небезопасно вызывать рендер контейнера, если содержимое было изменено в обход React. Ранее это работало в некоторых случаях, но никогда не поддерживалось. Мы не вызываем варнинг в этом случае. Вместо этого вы сами должны чистить дерево вашего компонента используя `ReactDOM.unmountComponentAtNode`. [Посмотрите на этот пример](https://github.com/facebook/react/issues/10294#issuecomment-318820987).
* Lifecycle-метод `componentDidUpdate` больше не получает параметр `prevContext`. (см.[#8631](https://github.com/facebook/react/issues/8631))
* Shallow рендерер больше не вызывает `componentDidUpdate`, т.к. ссылки на DOM недоступны. Это изменение делает его консистентным с методом `componentDidMount` (который тоже не вызывался в предыдущих версиях).
* Shallow рендерер больше не имеет метода `unstable_batchedUpdates`.
### Сборка
* Теперь недоступны `react/lib/*` и `react-dom/lib/*`. Даже для CommonJS окружений, React и ReactDOM теперь собраны в отдельные файлы (“flat bundles”). Если ваш проект ранее зависел от недокументированных внутренних возможностей React'а и они больше не работают, дайте нам об этом знать в новом тикете, а мы постараемся придумать способ миграции для вас.
* Больше нет билда `react-with-addons.js`. Все аддоны из этого билда уже опубликованы по отдельность в npm и имеют однофайловые браузерные версии, если они нужны вам.
* Методы и возможности, помеченные устаревшими в 15.x, теперь убраны из основного пакета. `React.createClass` теперь доступен как `create-react-class`, `React.PropTypes` как `prop-types`, `React.DOM` как `react-dom-factories`, `react-addons-test-utils` как `react-dom/test-utils`, а shallow рендерер как `react-test-renderer/shallow`. См. посты в блоге [15.5.0](https://facebook.github.io/react/blog/2017/04/07/react-v15.5.0.html) и [15.6.0](https://facebook.github.io/react/blog/2017/06/13/react-v15.6.0.html) для инструкций по миграции кода и автоматических кодемодов.
* Имя и путь до однофайловых браузерных билдов изменились для подчёркивания различий между разработческими и боевыми билдами. Например:
+ `react/dist/react.js` → `react/umd/react.development.js`
+ `react/dist/react.min.js` → `react/umd/react.production.min.js`
+ `react-dom/dist/react-dom.js` → `react-dom/umd/react-dom.development.js`
+ `react-dom/dist/react-dom.min`.js → `react-dom/umd/react-dom.production.min.js`
Требования к JavaScript-окружению:
----------------------------------
React 16 зависит от коллекций [Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) и [Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set). Если вы поддерживаете старые браузеры и устройства, в которых нет этого нативно (напр. IE < 11), используйте полифилы, такие как [core-js](https://github.com/zloirock/core-js) или [babel-polyfill](https://babeljs.io/docs/usage/polyfill/).
Окружение с полифилами для React 16 используя core-js для поддержки старых браузеров может выглядеть как-то так:
```
import 'core-js/es6/map';
import 'core-js/es6/set';
import React from 'react';
import ReactDOM from 'react-dom';
ReactDOM.render(
Hello, world!
=============
,
document.getElementById('root')
);
```
React также требует `requestAnimationFrame` (даже в тестовых средах). Простая заглушка для тестовых окружений может выглядеть так:
```
global.requestAnimationFrame = function(callback) {
setTimeout(callback, 0);
};
```
Благодарности
-------------
Как обычно, этот релиз был бы невозможен без наших контрибьюторов-волонтёров (open source contributors). Спасибо всем, кто заводил баги, открывал пулл-реквесты, отвечал в тикетах, писал документацию.
Отдельное спасибо нашим корневым контрибьюторам, особенно за их героические усилия в последние несколько недель пререлизного цикла: [Brandon Dail](https://twitter.com/aweary), [Jason Quense](https://twitter.com/monasticpanic), [Nathan Hunzaker](https://twitter.com/natehunzaker), и [Sasha Aickin](https://twitter.com/xander76). | https://habr.com/ru/post/338932/ | null | ru | null |
# Friendly Open Space JS: Рендеринг на стороне клиента и создание враппера
### «Friendly Open Space» — очень молодой фреймворк, но бегать уже умеет :-)
В данной статье по освоению «Friendly Open Space», мы освоим рендеринг шаблона в браузере и запуск приложения на локальной файловой БД.
Ядро фреймворка поддерживает два типа сборки шаблона на клиенте:
1. Рендеринг полностью выполняется на стороне клиента
2. Выполняется запрос на рендеринг шаблона серверу, с последующим выводом его в окне браузера.
Первый режим имеет одну особенность, данные необходимые для отрисовки шаблона запрашиваются у сервера, т.е. клиент выполняет FSQL запросы. Особой опасности в этом нет, если вы используете ограничение доступа и модуль fosAccess, но есть возможность выгрузки сырых данных копипастерами. Однако, такой подход существенно снимает нагрузку на сервер.
Второй тип рендеринга уже лишен данной особенности. Клиент отправляет параметры шаблона и принимает уже от сервера HTML. Да, нагрузка на сервер конечно возрастет, но зато такой метод больше подходит для открытых интернет решений.
### Подготовка приложения и его настройка
И так, перед нами стоит задача создать одностраничное приложение, которое будет рендерить 2-а шаблона (окошки) на стороне клиента. В виду достаточно простой задачи мы обойдемся без базы данных MySQL и проекций, поэтому всю работу FSQL мы направим в файл, т.е. будем использовать БД на файле для работы внутренних механизмов фреймворка. Ну, приступим.
Создадим каталоги:
templates — директория шаблонов
css — директория css файлов
fos — скачиваем последнюю beta [friendlyopenspace.site/ru/download](https://friendlyopenspace.site/ru/download)
Разместим надоедающий favicon.ico в корневом каталоге приложения: [favicon.ico](https://friendlyopenspace.site/sites/default/files/favicon.ico)
Так же сразу разместим файлы стилей в каталоге css: [window.css](https://friendlyopenspace.site/sites/default/files/window.css) и [styles.css](https://friendlyopenspace.site/sites/default/files/styles.css)
Далее, создаем файл самого приложения application.js:
```
var fos = require("./fos/fos");
fos.module({
name: "application.js",
dependencies: [
"fos:NServer/Application.js",
],
module: function(application) {
application.setSettings({
port: 3001,
packages: [],
dynamicLoading: true,
clientRenderingMode: "client",
dataClient: {
defaultConnection: "default",
connections: {
default: {
type: "file",
file: "data.fosdb"
}
},
},
onInitialize: function(a_event) {
if (!a_event.error) {
application.run();
} else {
console.error(a_event.error);
}
}
});
application.getRouter().add([
{
route: "",
controller: "fos:NServer/NControllers/Tmpl.js",
source: "templates/page.tmpl",
},
{
route: "/css/*",
controller: "fos:NServer/NControllers/File.js",
source: "css",
},
{
route: "/templates/*",
controller: "fos:NServer/NControllers/File.js",
source: "templates",
},
{
route: "favicon.ico",
controller: "fos:NServer/NControllers/File.js",
source: "favicon.ico",
},
]);
application.initialize();
}
});
```
Теперь давайте разберемся с содержимым файла application.js
Мы отключили все пакеты, за их ненадобностью (параметр packages метода setSettings):
```
...
application.setSettings({
port: 3001,
packages: [],
dynamicLoading: true,
clientRenderingMode: "client",
...
```
Новый для нас параметр приложения clientRenderingMode, отвечает за тип рендеринга на клиенте и имеет два значения:
«client» — рендеринг выполняется полностью средствами браузера. Клиент самостоятельно подгружает зависимости и выполняет FSQL запросы к серверу, после чего собирает сам HTML
«server» — клиент выполняет запрос к серверу на рендеринг шаблона и получает в качестве ответа готовый HTML
```
...
packages: [],
dynamicLoading: true,
clientRenderingMode: "client",
dataClient: {
defaultConnection: "default",
...
```
И последнее для нас новшество — это подключение базы данных на файле. Фреймворк не может полноценно работать без возможности обработки конфигурационных переменных, которые имеют табличную структуру. Поэтому, взамен MYSQL мы будем использовать обычный файл.
```
...
defaultConnection: "default",
connections: {
default: {
type: "file",
file: "data.fosdb"
}
},
},
...
```
Как видно из вышеприведенной выдержки, в этом случае тип базы данных (параметр type) равен «file», а единственный параметр соединения file должен содержать путь к файлу данных. Если файл отсутствует, приложение самостоятельно его создаст.
### Создание шаблона страницы
Теперь пришло время создать файл шаблона страницы приложения templates/page.tmpl, который у нас прописан в корневом маршруте URL.
```
//~OPTIONS
{
args:{
fosInclude: ["css/styles.css"],
}
}
//~BLOCK main default
%{{ render.renderHTMLHeader(); }}%
function onClientSideRendering(a\_event){
a\_event.preventDefault();
fos.application.render({
template: "templates/window.tmpl",
owner: document.body,
args: { title: "Client side rendering", context: "Simple example of client side rendering" },
onResult: function(a\_error, a\_template){
}
});
}
function onServerSideRendering(a\_event){
a\_event.preventDefault();
fos.application.render({
template: "templates/window.tmpl",
owner: document.body,
renderMode: "server",
args: { title: "Server side rendering", context: "Simple example of server side rendering" },
onResult: function(a\_error, a\_template){
}
});
}
Client Side Rendering
Client side rendering
Server side rendering
```
Шаблон страницы имеет две ссылки «Client side rendering» & «Server side rendering». При нажатии на которые будут отображаться окна, которых пока нет. Но есть код их вызова. И так давайте разберемся с кодом шаблона.
При нажатии на ссылку «Client side rendering» мы вызываем функцию onClientSideRendering(), которая выполняет рендеринг шаблона «templates/window.tmpl». Полностью на стороне клиента, т.к. в настройках приложения параметр clientRenderingMode был установлен в значение «client». Не смотря на то, что это значение по умолчанию :-).
```
function onClientSideRendering(a_event){
a_event.preventDefault();
fos.application.render({
template: "templates/window.tmpl",
owner: document.body,
args: { title: "Client side rendering", context: "Simple example of client side rendering" },
onResult: function(a_error, a_template){
}
});
}
```
Собственно метод render и выполняет рендеринг нашего окна и помещает его в тело страницы, как указано в свойстве аргумента owner. В шаблон окна мы передаем 2-а аргумента: title & context, собственно то, что будет отображаться в выводимом окошке. Более подробную информацию о методе см. [fos::NClient::Application::render](https://friendlyopenspace.site/api/classfos_1_1_n_client_1_1_application.html#ae877b95477709233cbf3690448dbf585)
Вторая ссылка вызывает функцию onServerSideRendering(), которая аналогично рендерит тот же шаблон, но на стороне сервера, а клиент получает уже готовый HTML. Данный режим задается в свойстве аргумента renderMode метода render значением «server».
```
function onServerSideRendering(a_event){
a_event.preventDefault();
fos.application.render({
template: "templates/window.tmpl",
owner: document.body,
renderMode: "server",
args: { title: "Server side rendering", context: "Simple example of server side rendering" },
onResult: function(a_error, a_template){
}
});
}
```
### Создание шаблона всплывающего окна и написание враппера шаблона
Сам шаблон всплывающего окошка очень прост. Создайте файл templates/window.tmpl. Ниже приведено его содержимое.
```
//~OPTIONS
{
args:{
fosWrapper: true,
fosClass: "window",
fosInclude: ["css/window.css"],
title: "",
context: "",
}
}
//~BLOCK main default
x
${{args.title}}$
${{args.context}}$
```
Здесь для вас есть два новых параметра fosWrapper и fosClass.
Начнем с fosWrapper. Если данный флаг установлен в true, то HTML шаблон помещается в контейнер span и для него создается объект обертки fos::NRender::Wrapper.
Запустите приложение, перейдите по адресу [localhost](http://localhost):3001 и выполните клик по ссылке «Client side rendering». Всплывающие окошко и есть наш шаблон. Всплытие окна реализовано полностью средствами css (файл css/window.css) — это я просто упомянул, что бы вы не искали скрытый JS :-).
Откройте DevTools браузера (Ctrl+Alt+i), перейдите на вкладку Elements и рассмотрите структуру нашего окошка.
Синей линией на рисунке помечен наш оберточный контейнер span c которым связан объект fos::NRender::Wrapper.
Следующий системный аргумент шаблона — fosClass. Он просто добавляет CSS класс к span контейнеру враппера.
И так, все сделано хорошо, но если мы попробуем закрыть наше всплывающие окошко, то ничего у нас из этого не выйдет. Да, операцию закрытия мы еще не писали!
Как мы говорили ранее, если системный аргумент fosWrapper равен true, то для шаблона создается объект враппера fos::NRender::Wrapper. Он предоставляет штатный интерфейс взаимодействия с шаблоном на клиенте. Что бы переопределить штатный враппер для шаблона достаточно создать модуль с именем соответствующему следующему формату [НАИМЕНОВАНИЕ\_ШАБЛОНА].wrapper.js, при этом модуль должен быть унаследован от класса fos::NRender::Wrapper.
Теперь создадим файл врапера для шаблона templates/window.tmpl. Новый класс должен будет закрывать наше всплывающие окошко, при нажатии на символ «x».
Файл templates/window.wrapper.js:
```
fos.module({
name: "templates/window.wrapper.js",
dependencies: ["fos:NRender/Wrapper.js"],
module: function(Wrapper){
return function(a_initializeOptions) {
var self = this;
Wrapper.call(this, a_initializeOptions);
var parentAttach = this._attach;
this._attach = function(a_cb) {
parentAttach.call(this, function(){
fos.addDomListener(fos.select(self.getDomElement(), "[name=close]")[0], "click", function(){
self.getDomElement().classList.add("window-hide");
setTimeout(function() { self.destroy(); }, 2000);
});
a_cb();
});
}
}
}
});
```
Разберем содержимое нашего модуля. Сначала мы подключаем базовый класс fos::NRender::Wrapper и наследуемся от него через методом call.
```
fos.module({
name: "templates/window.wrapper.js",
dependencies: ["fos:NRender/Wrapper.js"],
module: function(Wrapper){
return function(a_initializeOptions) {
var self = this;
Wrapper.call(this, a_initializeOptions);
...
```
После переопределяем метод fos::NRender::Wrapper::\_attach, который вызывается при связывании шаблона с объектом. В данном методе мы будем подключать событие нажатия на ссылку закрытия окна. Переопределение выполняется просто объявлением метода, но в начале мы должны сохранить ссылку на родительскую реализацию. Метод имеет «асинхронную природу», поэтому реализацию наших действий мы помещаем в функцию обратного вызова родительской реализации.
```
...
var parentAttach = this._attach;
this._attach = function(a_cb) {
parentAttach.call(this, function(){
fos.addDomListener(fos.select(self.getDomElement(), "[name=close]")[0], "click", function(){
self.getDomElement().classList.add("window-hide");
setTimeout(function() { self.destroy(); }, 2000);
});
a_cb();
});
}
...
```
Подключение к событию нажатия на символ «x» мы выполняем вызовом fos::addDomListener, который не сбрасывает подключенные события при смене родителя DOM элемента.
В обработчике события мы и выполняем закрытие окна. Вначале красиво убираем окошко с экрана, добавлением CSS класса «window-hide». После завершения анимации вызываем метод fos::NRender::Wrapper::destroy, который удаляет шаблон и объект враппера.
ВСЁ ПРИЛОЖЕНИЕ НАПИСАНО, ЗАПУСКАЕМ И РАДУЕМСЯ!!!
```
node application.js
```
[Официальный сайт разработки](https://friendlyopenspace.site)
[Ссылка на пример](https://friendlyopenspace.site/ru/node/71) | https://habr.com/ru/post/473154/ | null | ru | null |
# В Kubernetes 1.21 отключили вывод managed fields для kubectl get
Сегодня наши инженеры заметили, казалось бы, незначительное [изменение](https://github.com/kubernetes/kubernetes/pull/96878) в [Kubernetes 1.21](https://kubernetes.io/docs/setup/release/notes/)… но оно порадовало столь многих внутри компании, что сразу было решено написать про него для более широкой аудитории.
В выводе команды `kubectl get`, которая используется для поиска и просмотра ресурсов Kubernetes, теперь по умолчанию не будут показываться поля `managedFields`. Чтобы включить вывод этих полей, пользователю требуется добавить к команде флаг `--show-managed-fields`.
Это долгожданное изменение [активно обсуждалось](https://github.com/kubernetes/kubernetes/issues/90066). Главная проблема с managed fields в том, что они очень объемны и не очень полезны. Например, в выводе команды `kubectl get deployment -oyaml` поля managedFields могут занимать сотни строк, хотя эта информация нужна скорее для специфических задач.
Поэтому не стало большим удивлением увидеть на GitHub радостные комментарии к этому pull request'у:
«Это замечательно. Я ненавижу managed fields».Зачем нужны managed fields
--------------------------
Эти поля появились вместе с релизом фичи [server-side apply](https://kubernetes.io/blog/2020/04/01/kubernetes-1.18-feature-server-side-apply-beta-2/) (в [Kubernetes 1.18](https://habr.com/ru/company/flant/blog/493284/)), которая призвана решить проблемы использования `kubectl apply` для декларативного управления ресурсами K8s. Server-side apply отслеживает изменения в полях объектов и записывает метаданные в `managedFields`. При этом записываются любые изменения, даже незначительные — отсюда и такой объем. Подробнее о механизме управления полями можно почитать в [документации по Server-side apply](https://kubernetes.io/docs/reference/using-api/server-side-apply/#field-management).
Предложение убрать `managedFields` по умолчанию из вывода `kubectl get` появилось еще год назад, и у него нашлось много сторонников. Противники этой идеи хоть и согласились с тем, что вывод объемный, но настаивали, что информация всё-таки может быть полезна. Поведение по умолчанию, принятое для K8s 1.21, доказывает, что эта польза актуальна для меньшинства. | https://habr.com/ru/post/556324/ | null | ru | null |
# Чистый код для TypeScript — Часть 1
Наткнувшись на материал по принципам чистый код для [TypeScript](https://github.com/labs42io/clean-code-typescript) и прочитав его решил взяться за его перевод. Здесь я хочу поделиться с вами некоторыми выдержками из этого перевода, так как некоторые моменты чистого кода для TypeScript повторяют такие же принципы для JavaScript, я их здесь описывать не буду, если будет интересно перевод для JS уже публиковался на хабре(@[BoryaMogila](https://habr.com/users/BoryaMogila/)) или же можете ознакомится с ними в [первоисточнике](https://github.com/ryanmcdermott/clean-code-javascript).
Для начала давайте же разберемся что такое, эти принципы чистого кода. Но дать четкого определения чистого кода к сожалению вряд ли получится. Отчасти это все зависит от людей, так например приходишь в музей рассматриваешь картину и думаешь что за уродство, но тут же подходит другой человек и говорит, какое великолепие. Да у нас есть какие определенные, общие черты мира, где мы можем сказать, что то или иное красиво, но дать всему этому определение мы точно не сможем. Так и здесь это всего лишь какие то небольшие критерии этой красоты, соблюдение которых выбирает сам, так как. это не те правила которые высечены в граните. Это просто рекомендации.
Переменные
==========
Используйте enum для документирования
-------------------------------------
Enam'ы могут помочь документированию вашего кода. Например когда мы обеспокоены тем, что наши переменные отличаются от значений.
**Плохо:**
```
const GENRE = {
ROMANTIC: 'romantic',
DRAMA: 'drama',
COMEDY: 'comedy',
DOCUMENTARY: 'documentary',
}
projector.configureFilm(GENRE.COMEDY);
class Projector {
// delactation of Projector
configureFilm(genre) {
switch (genre) {
case GENRE.ROMANTIC:
// some logic to be executed
}
}
}
```
**Хорошо:**
```
enum GENRE {
ROMANTIC,
DRAMA,
COMEDY,
DOCUMENTARY,
}
projector.configureFilm(GENRE.COMEDY);
class Projector {
// delactation of Projector
configureFilm(genre) {
switch (genre) {
case GENRE.ROMANTIC:
// some logic to be executed
}
}
}
```
Функции
=======
Избегайте проверки типов
------------------------
TypeScript является надмножеством синтаксиса JavaScript и добавляют дополнительные статические проверки типов для языка. Всегда предпочитайте указывать типы переменных, параметров и возвращаемых значений, чтобы использовать всю мощь TypeScript. Это делает будущий рефакторинг более легким.
**Плохо:**
```
function travelToTexas(vehicle: Bicycle | Car) {
if (vehicle instanceof Bicycle) {
vehicle.pedal(currentLocation, new Location('texas'));
} else if (vehicle instanceof Car) {
vehicle.drive(currentLocation, new Location('texas'));
}
}
```
**Хорошо:**
```
type Vehicle = Bicycle | Car;
function travelToTexas(vehicle: Vehicle) {
vehicle.move(currentLocation, new Location('texas'));
}
```
Используйте итераторы и генераторы
----------------------------------
Используйте генераторы и итераторы при работе с коллекциями данных, которые используются как поток.
Есть несколько причин для этого:
* отделяет вызываемый объект от реализации генератора в том смысле, что вызываемый объект решает сколько элементов
иметь для доступа
* ленивое выполнение, элементы передаются по требованию
* встроенная поддержка итерации элементов с использованием синтаксиса `for-of`
* итераторы позволяют реализовать оптимизированные паттерны итераторов
**Плохо:**
```
function fibonacci(n: number): number[] {
if (n === 1) return [0];
if (n === 2) return [0, 1];
const items: number[] = [0, 1];
while (items.length < n) {
items.push(items[items.length - 2] + items[items.length - 1]);
}
return items;
}
function print(n: number) {
fibonacci(n).forEach(fib => console.log(fib));
}
// Print first 10 Fibonacci numbers.
print(10);
```
**Хорошо:**
```
// Generates an infinite stream of Fibonacci numbers.
// The generator doesn't keep the array of all numbers.
function* fibonacci(): IterableIterator {
let [a, b] = [0, 1];
while (true) {
yield a;
[a, b] = [b, a + b];
}
}
function print(n: number) {
let i = 0;
for (const fib of fibonacci()) {
if (i++ === n) break;
console.log(fib);
}
}
// Print first 10 Fibonacci numbers.
print(10);
```
Существуют библиотеки, которые позволяют работать с итераторами так же, как и с собственными массивами, путем цепочки методов, таких как `map`, `slice`, `forEach` и др. Смотрите [itiriri](https://www.npmjs.com/package/itiriri) пример продвинутой манипуляции с итераторами (или [itiriri-async](https://www.npmjs.com/package/itiriri-async) для манипуляции с асинхронными итераторами).
```
import itiriri from 'itiriri';
function* fibonacci(): IterableIterator {
let [a, b] = [0, 1];
while (true) {
yield a;
[a, b] = [b, a + b];
}
}
itiriri(fibonacci())
.take(10)
.forEach(fib => console.log(fib));
```
Объекты и структуры данных
==========================
Используйте геттеры и сеттеры
-----------------------------
TypeScript поддерживает синтаксис геттеров и сеттеров. Использовать геттеры и сеттеры для доступа к данным объекта гораздо лучше, чем напрямую обращаться к его свойствам. "Почему?" спросите вы. Вот список причин:
* Если вы хотите реализовать больше, чем просто доступ к свойству, вам нужно поменять реализацию в одном месте, а не по всему коду
* Валидацию легко реализовать на уровне реализации `set`
* Инкапсуляция внутреннего состояния
* Легко добавить логирование и обработку ошибок на уровне геттеров и сеттеров
* Вы можете лениво подгружать свойства вашего объекта, например, с сервера
**Плохо:**
```
type BankAccount = {
balance: number;
// ...
}
const value = 100;
const account: BankAccount = {
balance: 0,
// ...
};
if (value < 0) {
throw new Error('Cannot set negative balance.');
}
account.balance = value;
```
**Хорошо:**
```
class BankAccount {
private accountBalance: number = 0;
get balance(): number {
return this.accountBalance;
}
set balance(value: number) {
if (value < 0) {
throw new Error('Cannot set negative balance.');
}
this.accountBalance = value;
}
// ...
}
// Теперь `BankAccount` инкапсулирует логику проверки.
// Если однажды спецификации изменятся, и нам понадобится дополнительное правило проверки,
// нам придется изменить только реализацию `сеттера`,
// оставив весь зависимый код без изменений.
const account = new BankAccount();
account.balance = 100;
```
Создавайте объекты с приватными/защищенными полями
--------------------------------------------------
TypeScript поддерживает `public` *(по умолчанию)*, `protected` и `private` средства доступа к свойствам класса.
**Плохо:**
```
class Circle {
radius: number;
constructor(radius: number) {
this.radius = radius;
}
perimeter() {
return 2 * Math.PI * this.radius;
}
surface() {
return Math.PI * this.radius * this.radius;
}
}
```
**Хорошо:**
```
class Circle {
constructor(private readonly radius: number) {
}
perimeter() {
return 2 * Math.PI * this.radius;
}
surface() {
return Math.PI * this.radius * this.radius;
}
}
```
Уважаемые читатели, а какими принципами вы пользуетесь при использовании TypeScript?
Продолжение:
[Вторая часть](https://habr.com/ru/post/485068/)
[Третья часть](https://habr.com/ru/post/487136/)
[Полный перевод](https://github.com/Real001/clean-code-typescript) | https://habr.com/ru/post/484402/ | null | ru | null |
# Вышел GitLab 11.2: предпросмотр в Web IDE и импорт проектов под Android
Мы с воодушевлением представляем вам новые возможности версии 11.2, которые помогут вам быстрее стартовать и выпускать новые версии. В этот раз мы запускаем улучшения для Web IDE, поддержку импорта манифестов Андроид-проектов и настраиваемые шаблоны проектов.
Предпросмотр изменений в Web IDE
--------------------------------
Web IDE позволяет быстрее и проще вносить изменения в проекты благодаря улучшенному редактору кода с подготовкой коммитов (staging) прямо из браузера. В GitLab 11.2 мы сделали всё для того, чтобы вы сразу видели эффект от изменений кода и даже могли проводить дебаг до коммита. Теперь можно [запустить предпросмотр JavaScript веб-приложения в Web IDE](#obrabotka-koda-na-storone-polzovatelya-v-web-ide), для просмотра ваших изменений в реальном времени, рядом с кодом для пользовательской стороны.
Кроме того, с 11.2 вы можете переименовывать и удалять файлы, а также менять ветки, оставаясь в Web IDE.
Импорт Андроид-проектов
-----------------------
Раньше импорт проектов со сложной многоуровневой структурой был скучной и трудоёмкой задачей. С нашей новой фичей, [поддержкой XML манифестов](#podderzhka-importa-android-proektov), вы сможете импортировать большие проекты с множеством репозиториев сразу одним пакетом, включая код операционной системы Android из [Android Open Source Project (AOSP)](https://source.android.com).
Упростили развертывание GitLab в облаке
---------------------------------------
[Helm Chart для развертывания GitLab в облаке вышел в общий доступ](#helm-chart-dlya-razvertyvaniya-gitlab-v-oblake-vyshel-v-obschiy-dostup) (general availability, GA). Это поможет вам быстрее разворачивать GitLab на Kubernetes. Helm chart представляет более нативную облачную архитектуру с контейнером для каждого компонента GitLab и не требует общего хранилища. В результате повышается гибкость, масштабируемость и производительность GitLab на Kubernetes. Вместе с GitLab деплоится [GitLab Runner](https://docs.gitlab.com/runner/), что упрощает старт с GitLab CI/CD.
И даже больше!
--------------
Ещё несколько дополнений помогут вам и вашей команде более эффективно управлять проектами. Начиная с GitLab 11.2 администраторы инстансов GitLab могут настраивать **[общие для инстанса шаблоны проектов](#nastraivaemye-shablony-proektov-dlya-vashego-instansa-gitlab)**, что даст возможность пользователям начинать новые проекты быстрее, благодаря автоматизации повторяющихся задач.
В то же время такие фичи, как **[сгруппированные по майлстоунам списки задач](#sgruppirovannye-po-maylstounam-spiski-na-doske-zadach)**, **[суммарные веса](#summarnyy-ves-spiska-na-doske-zadach)** для списков на доске задач, **[групповые майлстоуны в панели майлстоунов](#gruppovye-maylstouny-na-paneli-maylstounov)** и **[todo для эпиков](#todo-dlya-epikov)** упрощают управление работой.
Каждый может внести свой вклад
------------------------------
Многие из этих изменений были внесены огромным сообществом GitLab. Мы с нетерпением ждём от вас обратную связь и улучшения для этих новых фич. Вместе мы классная команда!
Дайте нам знать, что вы думаете, в комментариях [к статье в блоге](https://about.gitlab.com/2018/08/22/gitlab-11-2-released/) — и на Хабре тоже. Чего вы ждёте от этого релиза? Над чем нам стоит продолжать работу?
Спасибо за то, что являетесь частью GitLab!
[Приглашаем на наши встречи](https://about.gitlab.com/events/)
[MVP](https://about.gitlab.com/mvp/) этого месяца — [JX Terry](https://gitlab.com/jxterry)
------------------------------------------------------------------------------------------
Спасибо JX Terry за реализацию новой опции для пользователей — возможности [сделать свою страницу профиля приватной](#privatnye-profili)!
Основные новые фичи релиза GitLab 11.2
--------------------------------------
Обработка кода на стороне пользователя в Web IDE
------------------------------------------------
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
Работать над веб-приложениями намного проще и быстрее, когда вы видите ваши изменения сразу. Современные JavaScript-фреймворки поддерживают предпросмотр в реальном времени (live preview), избавляя от необходимости перезапускать сервера и обновлять страницу браузера. Но раньше у вас не было возможности увидеть изменения перед коммитом при редактировании веб-приложения через Web IDE.
Начиная с GitLab 11.2, вы можете просматривать ваши JavaScript приложения в Web IDE и видеть изменения в реальном времени. Это позволяет тестировать фикс перед коммитом, экспериментировать с изменениями или даже вносить изменения в проекты с открытым исходным кодом, не клонируя их на свою машину.
Обработка на пользовательской стороне сделана с помощью [CodeSandbox](https://codesandbox.io). Она может быть включена администратором для ваших инстансов GitLab и уже работает для всех проектов на GitLab.com. В этом году мы также добавим [обработку на стороне сервера](https://gitlab.com/gitlab-org/gitlab-ee/issues/4013) с помощью GitLab CI, что даст вам возможность тестировать и просматривать приложения на Ruby и не только!
[Документация по обработке кода на стороне пользователя](https://docs.gitlab.com/ee/user/project/web_ide/#client-side-evaluation) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/47268).
Настраиваемые шаблоны проектов для вашего инстанса GitLab
---------------------------------------------------------
PREMIUM, ULTIMATE
В современных быстрорастущих средах разработки перейти от идеи к новому проекту — всё ещё утомительная задача. Огромное количество шаблонного кода и административные задачи мешают скорее начать работу.
В этом релизе мы дали организациям возможность управлять собственными шаблонами проектов. Администратор инстанса GitLab может выбрать группу проектов из вашего инстанса, которая будет источником таких шаблонов. Все проекты непосредственно из этой группы (но не из подгрупп) будут доступны как шаблоны при создании нового проекта.
Вся информация о репозитории и базе данных проекта-шаблона будет скопирована в ваш новый проект, включая репозитории проекта и вики, задачи, настройки проекта и другое.
[Документация по настраиваемым шаблонам проектов](https://docs.gitlab.com/ee/user/admin_area/custom_project_templates.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/6860).
Личные статусы в профиле
------------------------
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
Сотрудничество — главный принцип для работы с GitLab. При использовании GitLab каждый день с коллегами и сообществом будет удобно рассказывать о том, чем вы сейчас занимаетесь и какая у вас сейчас загрузка.
С релизом GitLab 11.2 в вашем личном профиле стали доступны статусы! В настройках профиля теперь вы можете добавить статус из сообщения и эмодзи. Статус будет отображаться на вашей страничке, а также в комментариях и заголовках об авторе, показывая ваш текущий статус всем, кто работает с вами.
Спасибо [Luke Niedermyer](https://gitlab.com/niedermyer) за эту инициативу!
[Документация по статусам](https://docs.gitlab.com/ee/user/profile/#current-status) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/35463).
Улучшенный поиск в панели навигации
-----------------------------------
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
Когда проекты и группы разрастаются, их становится всё сложнее найти, так что GitLab требуется мощный поиск. В этом релизе мы делаем шаг навстречу более понятному, удобному и простому поиску.
В 11.2 мы улучшили его, убрав ограничение по поиску в текущих группе и проекте. Вместо того, чтобы ограничивать поиск проектом или группой, в которых вы находитесь, теперь GitLab позволяет вам искать сразу по всему инстансу с любой страницы.
Теперь мы показываем иконки групп и проектов в результатах, и расширили панель поиска и результаты выдачи, что сделало поиск проще и удобнее.
[Документация по поиску](https://docs.gitlab.com/ee/user/search/#shortcut) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/36409).
Поддержка импорта Андроид-проектов
----------------------------------
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
Раньше импорт проектов со сложной многоуровневой структурой был скучной и трудоёмкой задачей.
В этом релизе мы представляем поддержку файлов манифеста для импорта проектов. XML-файл манифеста содержит информацию о том, какие репозитории должны быть подключены к проекту, что позволяет вам импортировать большие структуры за один раз.
При создании проекта во вкладке "Import project" появилась новая опция "Manifest file" как источник для импорта вашего проекта. Кроме того, теперь вы можете выбирать из списка отдельные проекты, если не хотите импортировать всю структуру.
К примеру, это улучшение даёт возможность импортировать код из [Android Open Source Project (AOSP)](https://source.android.com). Также вы можете импортировать другие проекты, файлы манифеста которых подходят под наши [требования к формату](https://docs.gitlab.com/ee/user/project/import/manifest.html#manifest-format).
[Документация по импорту манифестов](https://docs.gitlab.com/ee/user/project/import/manifest.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/28811).
Сгруппированные по майлстоунам списки на доске задач
----------------------------------------------------
PREMIUM, ULTIMATE, SILVER, GOLD
Доски задач изначально были разработаны для того, чтобы отслеживать рабочие процессы со списками, основанными на метках. В релизе GitLab 11.0, мы представили [списки исполнителей](https://docs.gitlab.com/ee/user/project/issue_board.html#assignee-lists), чтобы команды могли видеть, на кого какие задачи назначены и было проще их переназначать.
В этом релизе мы представляем третий тип списка — список задач майлстоуна. В этом списке появятся все задачи, которые принадлежат этому майлстоуну. Теперь вы сможете просматривать на одной доске списки задач разных майлстоунов, а также быстро перемещать задачи между майлстоунами. В этом релизе также появился [суммарный вес задач в списке](#summarnyy-ves-spiska-na-doske-zadach), что вместе с группировкой по майлстоунам поможет командам балансировать суммарные веса задач между майлстоунами и не брать слишком мало или слишком много задач.
Мы обновили API, так что теперь вы можете добавлять и удалять списки любого из трёх типов на конкретной доске.
[Документация по списку задач майлстоуна](https://docs.gitlab.com/ee/user/project/issue_board.html#milestone-lists) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/6469).
Другие улучшения в GitLab 11.2
------------------------------
### Todo для эпиков
ULTIMATE, GOLD
Список todo (to do, «сделать») — удобный встроенный инструмент для повышения личной производительности. Когда вы упомянуты в задаче или мерж-реквесте с помощью @, вы получаете сообщение на почту и пункт в списке todo в GitLab. Этот пункт потом можно отметить как выполненный. Есть и много других событий, которые создают todo.
С этим релизом мы добавляем todo в эпики. Они будут работать так же, как в задачах и мерж-реквестах. Когда вас упоминают в эпике с помощью @, ваш список todo пополняется напоминанием об этом. Когда вы просматриваете эпик, вы можете самостоятельно создать todo из боковой панели, как это уже работает с задачами и мерж-реквестами.
Также мы обновили API, чтобы вы имели доступ к уже созданным todo от эпиков и могли создавать новые.
[Документация по todo](https://docs.gitlab.com/ee/workflow/todos.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/5481).
### Суммарный вес списка на доске задач
STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD
До этого релиза мы уже показывали количество задач для каждого списка на доске задач. Когда вы много планируете и отслеживаете прогресс на доске задач, удобно смотреть, как много задач находится в конкретной стадии рабочего процесса или назначены на человека в списке исполнителей.
С этим релизом мы расширяем эту концепцию и показываем рядом с количеством задач их суммарный вес для каждого списка. Если вы переместите задачу в другой список, чтобы компенсировать слишком низкий или высокий вес, сумма сразу пересчитается. Для этого вам даже не придётся обновлять доску.
[Документация по суммарному весу задач](https://docs.gitlab.com/ee/user/project/issue_board.html#sum-of-issue-weights) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/3772).
### Групповые майлстоуны на панели майлстоунов
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
Майлстоуны в GitLab удобны для отслеживания работы в итерации или спринте. В частности, майлстоуны уровня группы позволяют отслеживать в одном месте задачи из разных проектов.
Начиная с этого релиза, мы показываем групповые майлстоуны на панели майлстоунов. Это означает, что теперь пользователи смогут видеть в одном месте все майлстоуны, к которым они имеют доступ — и уровня проекта, и уровня группы.
[Документация по майлстоунам](https://docs.gitlab.com/ee/user/project/milestones/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/35748).
### Поиск по списку меток проекта
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
Метки в GitLab — гибкая фича, которая позволяет систематизировать задачи, мерж-реквесты и эпики. Команды используют их для разных целей и часто в проектах бывает по многу страниц меток. Когда нужно поменять название, цвет или описание метки, приходится пролистывать много страниц, чтобы найти нужную.
В этом релизе мы упростили эту задачу, добавив поиск по меткам прямо на страницу списка меток проекта. Можно искать по названию и по описанию метки. Так что если вы знаете название или хотя бы о чём эта метка, вы сможете быстро найти её по ключевым словам в поле поиска.
[Документация по меткам](https://docs.gitlab.com/ee/user/project/labels.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/34837).
### Все графики выполнения работ доступны в профилях GitLab Starter и Bronze
STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD
График выполнения работ (burndown chart) — полезная визуализация для команд, позволяющая отслеживать как выполняется работа по майлстоуну. Этот график помогает команде заранее оценить риск срыва сроков и принять меры, не дожидаясь конца майлстоуна.
Ранее график выполнения работ для страницы группового майлстоуна был доступен только в профилях GitLab Premium и Silver. Теперь мы добавляем эту возможность также в профили GitLab Starter и Bronze, позволяя большему количеству пользователей использовать её при работе с группами. График выполнения работ для майлстоунов проекта уже был доступен для профилей Starter и Bronze, так что теперь всё стало ещё проще.
[Документация по графикам выполнения работ](https://docs.gitlab.com/ee/user/project/milestones/burndown_charts.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/6251).
### Оповещения для настраиваемых метрик
ULTIMATE, GOLD
GitLab содержит встроенный инструмент для мониторинга производительности, что даёт инженерам простой и беспроблемный способ отслеживания основных параметров, таких как пропускная способность, уровень ошибок и потребление ресурсов. С одной стороны, необходимо видеть эти метрики когда потребуется, но если есть проблемы, важно сразу узнать и отреагировать на них.
В GitLab 11.2 можно создавать оповещения для настраиваемых метрик в несколько кликов через панель метрик. Пользователи могут задать желаемый порог, и, когда он будет превышен на протяжении 5 минут, будут отправлены сообщения на почту владельцам и тем, кто ведёт проект. Поддержка встроенных в GitLab метрик появится в [будущем релизе](https://gitlab.com/gitlab-org/gitlab-ee/issues/6948).
[Документация по настройке оповещений для метрик](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#setting-up-alerts-for-prometheus-metrics) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/5158).
### Множественные идентификаторы переходов Jira при закрытии тикетов из GitLab
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
Многие команды, использующие GitLab, также пользуются Jira в качестве трекера. В GitLab уже есть интеграция с Jira, которая позволяет GitLab автоматически закрывать тикет Jira при слиянии мерж-реквеста в GitLab. Для этого необходимо было указать идентификатор перехода (transition ID) Jira в настройках GitLab, указав, как вы хотите закрывать тикеты Jira. Но это также означало, что вы ограничены только одним типом перехода в Jira.
С этого релиза мы стали поддерживать несколько идентификаторов перехода в Jira. Это означает, что если ваш проект Jira настроен таким образом, что там есть несколько способов закрыть тикет, то теперь GitLab сможет распознать все эти способы (если вы укажете их в настройках проекта GitLab), так что слияние мерж-реквеста GitLab будет закрывать тикет Jira, независимо от его состояния.
Спасибо [lilinzhe](https://gitlab.com/slayercat) за эту фичу!
[Документация по интеграции GitLab с Jira](https://docs.gitlab.com/ee/user/project/integrations/jira.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/43602).
### Helm Chart для развертывания GitLab в облаке вышел в общий доступ
CORE, STARTER, PREMIUM, ULTIMATE
Мы с радостью объявляем, что [Helm](https://helm.sh) chart для облачного GitLab теперь общедоступен (GA). Этот Helm chart представляет более нативную облачную архитектуру с контейнером для каждого компонента GitLab и не требует общего хранилища. В результате повышается гибкость, масштабируемость и производительность GitLab на Kubernetes. Вместе с GitLab деплоится [GitLab Runner](https://docs.gitlab.com/runner/), что упрощает старт с GitLab CI/CD.
Helm chart `gitlab` — лучший способ развернуть GitLab на [Kubernetes](https://kubernetes.io/). [Попробуйте](https://docs.gitlab.com/ee/install/kubernetes/gitlab_chart.html) и
[сообщите нам](https://gitlab.com/charts/gitlab/issues), что вы думаете!
[Документация по GitLab Helm Chart](https://docs.gitlab.com/ee/install/kubernetes/gitlab_chart.html) и [оригинальный тикет (эпик)](https://gitlab.com/groups/charts/-/epics/15).
### Импортер из Bitbucket Server
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
GitLab уже давно импортирует проекты из Bitbucket Cloud с аутентификацией OAuth. Теперь это работает и с Bitbucket Server.
С GitLab 11.2 теперь можно импортировать свои проекты с Bitbucket Server в GitLab с минимальными усилиями. Укажите URL сервера и ваши учетные данные. Затем GitLab покажет список всех ваших репозиториев на Bitbucket Server, сразу готовых к импорту.
[Документация по импорту с Bitbucket Server в GitLab](https://docs.gitlab.com/ee/user/project/import/bitbucket_server.html), [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/25393) и [мерж-реквест](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/20164).
### Приватные профили
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
Страница профиля пользователя на GitLab показывает активность, вклад в разработку и личные проекты. Посетители профиля видят подробно только те действия, на которые у них есть разрешение, — например комментарии к публичным репозиториям, — но некоторые пользователи могут предпочесть не раскрывать всю эту информацию.
В GitLab 11.2 мы добавляем возможность скрывать информацию об активности в вашем профиле. Теперь вы можете сами решать, какой информацией вы готовы делиться с сообществом.
Спасибо [JX Terry](https://gitlab.com/jxterry) за эту фичу, сделавшую его [MVP месяца](#mvphttpsaboutgitlabcommvp-etogo-mesyaca--jx-terryhttpsgitlabcomjxterry)!
[Документация по приватным профилям](https://docs.gitlab.com/ee/user/profile/#private-profile) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/38604).
### Разрешение и запрещение лицензий
ULTIMATE, GOLD
Управление лицензиями (License Management) автоматически определяет лицензии на программное обеспечение, которые вы вносите вместе с кодом и его зависимостями.
Раньше GitLab только сообщал вам обо всех лицензиях,
но не позволял определять, какие из них разрешены в вашем продакшн-коде.
Начиная с GitLab 11.2, вы можете определить, должна ли какая-либо лицензия быть одобрена (approve) или занесена в черный список (blacklist) для вашего приложения, как только соответствующий код появится в мерж-реквесте. Виджет мерж-реквеста показывает все лицензии, которых ещё нет в коде целевой ветки, и позволяет определить, надо ли их заблокировать или разрешить в будущем.
[Документация по управлению лицензиями](https://docs.gitlab.com/ee/user/project/merge_requests/license_management.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/5488).
### Отчеты об управлении лицензиями на уровне конвейера
ULTIMATE, GOLD
Когда в кодовую базу внесены новые изменения, пользователи могут заинтересоваться, что изменилось в наборе лицензий, применяемых к их приложению.
GitLab 11.2 выводит отчет об управлении лицензиями на уровень конвейера, так что пользователи могут напрямую проверить свою ветку `master` и текущий список лицензий.
[Документация по управлению лицензиями на уровне конвейера](https://docs.gitlab.com/ee/user/project/merge_requests/license_management.html#license-management-report-under-pipelines) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/5491).
### ID проекта виден на странице обзора проекта
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
Проекты GitLab при создании получают уникальный автоматически сгенерированный идентификатор. Эта информация доступна в общих настройках проекта и через API.
В этом релизе мы добавили идентификатор проекта на страницу обзора проекта, чтобы даже пользователи без прав доступа `Maintainer` также могли его видеть.
Спасибо [Tuğçe Nur Taş](https://gitlab.com/nuritnt) за эту фичу!
[Документация по проектам](https://docs.gitlab.com/ee/user/project/), [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/46342) и [мерж-реквест](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/20305).
### Скачивание отдельных файлов из репозитория
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
При просмотре репозитория проекта в GitLab часто бывает нужно загрузить один файл. До сих пор для этого надо было открыть в интерфейсе GitLab просмотр файла в новой вкладке браузера, и уже оттуда сохранить его.
В релизе GitLab 11.2 в интерфейсе просмотра файлов появилась кнопка «Скачать» («Download»), доступная для каждого отдельного файла репозитория. Это облегчает загрузку отдельных файлов из приложения.
Спасибо [Kia Mei Somabes](https://gitlab.com/kia1) за эту фичу!
[Документация по работе с репозиториями](https://docs.gitlab.com/ee/user/project/repository/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/23705).
### Интеграция Google Hangouts
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
Приложения для чатов вместе с GitLab помогают командам общаться и работать. В этом релизе мы рады использовать щедрый вклад Владимира Куковского в интеграцию Google Hangouts в GitLab. Когда эта фича настроена как служба проекта, можно получать сообщения о различных событиях GitLab в виде уведомлений в Hangouts.
Спасибо [Владимиру Куковскому](https://gitlab.com/enzinia) за эту фичу!
[Документация по чату Hangouts](https://docs.gitlab.com/ee/user/project/integrations/hangouts_chat.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/43756).
### Поддержка доступа к Git SSH через сертификаты
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
В крупных организациях бывает так, что ключи SSH выдаются только на временной основе и быстро устаревают. Альтернативный подход, доступный с GitLab 11.2, заключается в использовании сертификатов OpenSSH, которые включают всю информацию о пользователе в сертификате. Это избавляет пользователей от необходимости генерировать и загружать ключи SSH.
Спасибо [Ævar Arnfjörð Bjarmason](https://gitlab.com/avar) за эту фичу!
[Документация по сертификатам SSH](https://docs.gitlab.com/ee/administration/operations/ssh_certificates.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/34572).
### Аналитика уровня инстанса доступна для всех
CORE, STARTER, PREMIUM, ULTIMATE
Аналитика — важный инструмент для понимания активности пользователей вашего инстанса GitLab. Ранее две из функций аналитики — ConvDev Index и Cohorts — были видны только администраторам.
Поскольку эти функции предоставляют полезную (и анонимизированную) информацию об использовании GitLab, мы делаем их видимыми по умолчанию для всех пользователей, в новом разделе «Статистика инстанса» в верхней панели навигации. Видимость этого раздела настраивается и может быть установлена «только для администратора».
Введение статистики на уровне инстансов — наш первый шаг к демократизации аналитики в GitLab. Мы будем рады представить ещё больше возможностей в этом разделе в будущем.
[Документация по аналитике инстанса](https://docs.gitlab.com/ee/user/instance_statistics) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/41416).
### Настраиваемая боковая панель Wiki
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
При использовании Wiki в проекте GitLab для расширенной документации на правой боковой панели по умолчанию отображается многоуровневое оглавление, отражающее вашу Wiki-структуру. Однако бывает, что вы хотите предоставить дополнительный контент, расширяя набор автоматически перечисленных страниц.
В GitLab 11.2 мы добавили возможность использования вашей собственной боковой панели вместо автоматически сгенерированного оглавления. Добавляя wiki-страницу `_sidebar`, разработчики получают полную свободу для настройки индивидуальной боковой панели Wiki на основе [GitLab Flavored Markdown](https://docs.gitlab.com/ee/user/markdown.html#gitlab-flavored-markdown-gfm).
Спасибо [jsooter](https://gitlab.com/jsooter) за эту фичу!
[Документация по настройке боковой панели](https://docs.gitlab.com/ee/user/project/wiki/#customizing-sidebar) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/14995).
### Надежное создание образов Docker с помощью kaniko
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
Исторически сложилось так, что создание образов Docker в контейнерном окружении требовало компромиссов: приходилось использовать такие методы, как [Docker внутри Docker](https://blog.docker.com/2013/09/docker-can-now-run-within-docker/) в [привилегированных контейнерах](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities). Эти решения часто небезопасны и медленны.
[kaniko](https://cloudplatform.googleblog.com/2018/04/introducing-kaniko-Build-container-images-in-Kubernetes-and-Google-Container-Builder-even-without-root-access.html) — это новый инструмент, разработанный Google, который способен безопасно создавать образ в непривилегированном контейнере. GitLab 11.2 и Runner 11.2 теперь [совместимы](https://gitlab.com/gitlab-org/gitlab-ce/issues/45512) с kaniko, что позволяет использовать его с [GitLab CI/CD](https://docs.gitlab.com/ee/ci/) и с интегрированным [реестром](https://docs.gitlab.com/ee/user/project/container_registry.html).
[Документация по использованию kaniko](https://docs.gitlab.com/ee/ci/docker/using_kaniko.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/45512).
### Удаление и переименование файлов в Web IDE
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
Web IDE — это самый удобный способ добавления и редактирования файлов в интерфейсе GitLab; в этом релизе мы добавили возможность удалить или переименовать любой файл, не выходя из Web IDE.
[Документация по Web IDE](https://docs.gitlab.com/ee/user/project/web_ide/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/44845).
### Переключение веток в Web IDE
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
В GitLab 11.2 теперь вы можете переключиться на любую ветку текущего репозитория, не покидая Web IDE. Улучшенный переключатель веток и мерж-реквестов позволяет искать в списке веток текущего репозитория.
[Документация по переключению веток репозитория](https://docs.gitlab.com/ee/user/project/web_ide/#switching-branches) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/46165).
### Резюме тестов JUnit в виджете мерж-реквеста
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
Часто бывает, что конвейер содержит тест, который проверяет самый новый код. Если тесты заканчиваются неудачно, весь конвейер также завершается неудачно и уведомляет пользователя. Но пользователи хотят больше подробностей про неудачные тесты.
С выпуска 11.2 можно видеть результаты тестов в формате JUnit прямо в виджете мерж-реквеста.
[Документация по отчётам JUnit](https://docs.gitlab.com/ee/ci/junit_test_reports.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/45318).
### API зеркалирования через HTTP pull
STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD
Зеркалирование через HTTP pull теперь доступно через API проектов. Зеркалирование с помощью pull позволяет легко обновлять форки и реплики, независимо от того, находятся ли репозитории на одном сервере.
[Документация по редактированию проектов](https://docs.gitlab.com/ee/api/projects.html#edit-project) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ee/issues/1499).
### Встроенные шаблоны проектов теперь используют Dockerfile
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
Наши встроенные шаблоны проектов теперь создаются с использованием Dockerfile вместо herokuish. Для некоторых конфигураций это приведёт к ускорению сборки и считается лучшей практикой, которую мы хотим продемонстрировать в наших шаблонах.
[Документация по созданию проектов](https://docs.gitlab.com/ee/gitlab-basics/create-project.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/48268).
### Взаимная SSL-авторизация для Helm Tiller
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
Чтобы повысить безопасность интегрированных с GitLab кластеров Kubernetes, мы должны обеспечить защищенность Helm Tiller, так что только управляющий им инстанс GitLab мог бы развёртывать приложения в его пространстве имён.
Начиная с GitLab 11.2, все новые приложения Helm Tiller, которые развертываются на кластерах Kubernetes через интеграцию Kubernetes с GitLab, будут заблокированы/ограничены использованием взаимной аутентификации SSL. Это означает, что никакие другие клиенты за пределами вашего инстанса GitLab не смогут развертывать приложения, что делает ваш кластер более безопасным. Кроме того, начиная с этого выпуска, мы будем использовать Helm Tiller версии 2.7.2.
[Документация по конфигурации и инициализации приложений Helm Tiller](https://docs.gitlab.com/ee/install/kubernetes/preparation/tiller.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/48098).
### Возможность вручную остановить окружение
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
Некоторые окружения (CI/CD environments) используются один раз (и вряд ли будут повторно использоваться). Одним из ярких примеров являются [приложения для ревью (Review Apps)](https://docs.gitlab.com/ee/ci/review_apps/), где новое окружение динамически создается в каждой ветке. До сих пор можно было остановить окружение, только если оно было определено в [`.gitlab-ci.yml`](https://docs.gitlab.com/ee/ci/yaml/README.html#environment-on_stop). С GitLab 11.2 теперь можно вручную «остановить» (“stop”) окружение на странице Environments.
[Документация по остановке окружений](https://docs.gitlab.com/ee/ci/environments.html#stopping-an-environment) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/25388).
### GitLab Runner 11.2
CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD
Сегодня мы выпускаем GitLab Runner 11.2! GitLab Runner — проект с открытым исходным кодом, который используется для запуска ваших работ CI/CD и отправки результатов обратно в GitLab.
##### Самые важные изменения:
* [`Добавлен формат артефакт` и поддержка нескольких артефактов на задание](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/923)
* [Исправлена поддержка значений переменных, содержащих Unicode, при использовании Windows и PowerShell](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/960)
* [Установлен User-Agent при вызове API Kubernetes](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/977)
* [Добавлена оболочка BusyBox](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/900)
Список всех изменений можно найти в [CHANGELOG](https://gitlab.com/gitlab-org/gitlab-runner/blob/v11.2.0/CHANGELOG.md) GitLab Runner.
[Документация по GitLab Runner](https://docs.gitlab.com/runner).
---
Подробные release notes и инструкции по обновлению/установке можно прочитать в оригинальном англоязычном посте: [GitLab 11.2 released with live preview in the Web IDE and Android project import](https://about.gitlab.com/2018/08/22/gitlab-11-2-released/).
Над переводом с английского работали [cattidourden](https://habr.com/users/cattidourden/), [ainoneko](https://habr.com/users/ainoneko/), [rishavant](https://habr.com/users/rishavant/) и [nick\_volynkin](https://habr.com/users/nick_volynkin/). | https://habr.com/ru/post/422473/ | null | ru | null |
# Чистый AutoML для “грязных” данных: как и зачем автоматизировать предобработку таблиц в машинном обучении
Или “Мне бы такую работу, чтобы поменьше работы.”:)
В данном посте хотелось бы затронуть такую очень известную и много где описанную тему как предобработка табличных данных в Data Science. Вы можете задать вопрос: “А зачем нам это нужно, ничего нового то тут не скажешь?”. Действительно, что может быть банальнее обработки табличных данных для моделей машинного обучения. Но мы постараемся собрать как можно больше информации в одном ультимативном, если так угодно, гайде, и подадим его через призму автоматического машинного обучения (AutoML).
Дисклеймер: все описанные нами ниже подходы не являются единственно верными. Мы использовали их при развитии нашего open-source AutoML фреймворка [FEDOT](https://github.com/nccr-itmo/FEDOT), у которого безусловно есть свои особенности как в архитектуре, так и в парадигме разработки. Несмотря на то, что мы реализовали довольно объемный блок предобработки изолированно от основной архитектуры проекта, он определенно пропитан духом ядра библиотеки. Приступаем!
### Пролог (“Я не чувствую своих признаков. - У тебя их нет!”)
Сначала стоит прояснить (на всякий пожарный), что подразумевается под предобработкой табличных данных в Data Science. Это набор операций, который позволяет трансформировать данные таким образом, чтобы модели машинного обучения могли на таких данных корректно обучаться. В широком смысле в предобработку входит исходная очистка данных (удаление нечитаемых ячеек и столбцов и т.д.), устранение пропусков, кодировка категориальных значений, нормализация данных, удаление выбросов. Ниже в этом посте мы будем понимать под предобработкой только первые три блока. Если хотите подробнее почитать про предобработку табличных данных и какой она бывает, то можете начать с [Предварительная обработка данных](https://habr.com/ru/post/511132/) и продолжить c [Data Preprocessing: Concepts](https://towardsdatascience.com/data-preprocessing-concepts-fa946d11c825).
Итак, потребность для внедрения блока предобработки таблиц (получившегося в итоге довольно большим), в AutoML-фреймворк возникла у нас с командой совсем не сразу. Поначалу нам было достаточно минимальной функциональности: заполнить пропуски, обработать категориальные признаки, нормализовать - передать на вход модели. Однако в течение последних нескольких месяцев у нас появилась задача запустить наш фреймворк на большом количестве датасетов из OpenML, kaggle и прочих источников (например, с ресурса “Departamento de ciencia de computadores”). И только тогда мы поняли насколько в тепличных условиях мы растили фреймворк до этого - алгоритм не смог запуститься больше чем на половине датасетов. Для запуска мы брали 46 табличных наборов данных, большая часть из которых предназначалась для решения задачи классификации. С этого момента начинается наш путь.
Рисунок 1. Обычно приходится играть с тем, что справа (мем)Немного про набор данных: размеры таблиц изменялись от совсем маленьких (748 строк на 5 столбцов для “blood-transfusion-service-center”) до довольно больших (4.9 млн строк на 42 столбца для “KDDCup99\_full”). Общее количество элементов (умножение количества строк на количество столбцов) изменялось от нескольких тысяч до нескольких сотен миллионов. Всё это нам нужно было для возможности проверить адекватность работы алгоритмов на разных размерах данных (Рисунок 2).
Рисунок 2. Размеры табличных данных для экспериментов (не мем)Помимо проблем с наличием пропусков и большого количества категориальных признаков, данные имеют одну неприятную особенность - в одном столбце могут быть намешаны несколько типов данных, например float и string. Далее мы напишем к каким неприятностям такое соседство привело, а пока просто резюмируем - у датасетов есть некоторые особенности, которые не позволяют запустить на данных модели машинного обучения как есть, без серьёзной предобработки.
Ссылки на наборы датасетов, которые использовались в экспериментах* AutoML Benchmark OpenML - <https://www.openml.org/search?q=tags.tag%3Astudy_218&type=data&table=1&size=39>
* 4 таблицы OpenML big size (> 1 million samples): AirlinesCodrnaAdult, Click\_prediction\_small, KDDCup99\_full, sf-police-incidents - <https://www.openml.org/search?type=data>
* <https://www.dcc.fc.up.pt/~ltorgo/Regression/pole.html>
* <https://www.dcc.fc.up.pt/~ltorgo/Regression/delta_ailerons.html>
* <https://www.dcc.fc.up.pt/~ltorgo/Regression/cal_housing.html>
* <https://www.kaggle.com/adityadesai13/used-car-dataset-ford-and-mercedes/tasks?taskId=1258>
### Исследование (“Наши люди AutoML без предобработки не запускают”)
Перед тем как начать писать собственные костыли, мы решили посмотреть как подобную проблему решали наши коллеги из других команд. Оговоримся сразу, что рассматривать будем наиболее критические изменения в данных, преобразования в духе “трансформация одномерного target массива в вектор-столбец” подразумевается, что производится при необходимости в любой сколько-нибудь крупной AutoML библиотеке.
Начнём с фреймворка [H2O, где эксплуатируется следующая структура](https://www.automl.org/wp-content/uploads/2020/07/AutoML_2020_paper_61.pdf). Предобработка предшествует запуску AutoML алгоритма. В препроцессинге классический джентльменский набор: автоматическое определение типов, кодирование категориальных признаков при помощи OneHotEncoding’a, заполнение пропусков и нормализация при необходимости. Также имеется возможность опциональной предобработки для некоторых моделей - например не для всяких требуется нормализация и т.д. Немного интересных фактов: H2O версии 3.28.1.2 успешно запустился на 24 датасетах из 46.
Популярный академический фреймворк TPOT не является в полной мере “end-to-end” решением, в отличие от H2O. Поэтому большую долю предобработки библиотека оставляет на стороне пользователя, концентрируясь на [оптимизации пайплайна](https://towardsdatascience.com/tpot-pipelines-optimization-with-genetic-algorithms-56ec44ef6ede). Тем не менее в структуре TPOT есть методы, отвечающие за усвоение входных данных. В частности, в препроцессоре происходит проверка на наличие пропусков, есть различные стандартизаторы и нормализаторы. Разделение на категориальные и вещественные признаки происходит на основе количества уникальных значений в столбце. В отличие от H2O опциональной предобработки не предусмотрено - препроцессинг выступает единым блоком предшествующим запуску эволюционного алгоритма для поиска модели. Пусть предобработка не является сильной стороной данного фреймворка, он широко известен и довольно надежен. Хотя вычистить исходный датасет всё же рекомендуется перед подачей данных. Например, фреймворк не переваривает наличие строковых типов данных в массивах.
В фреймворке LightAutoML также присутствует стандартная предобработка: заполнение пропусков, обработка категориальных признаков и обработка типов. Типы в терминах фреймворка называются “ролями”, где для каждой “роли” (численный или категориальный тип) предусмотрен свой способ предобработки. Численные признаки проходят процедуру масштабирования. Запуску моделей предшествует несколько ступеней обработки: выбор подходящих признаков и генерация новых. В первом как раз сосредоточен весь арсенал препроцессинга. Препроцессинг обязателен для моделей, но может варьироваться.
В фреймворке AutoGluon реализована двухуровневая [предобработка](https://arxiv.org/pdf/2003.06505.pdf): моделе-независимая и моделе-специфичная. Данное разделение во первых позволяет избежать лишних вычислений, если они не требуются, а во вторых позволяет сохранить гибкость. Помимо классических операций вроде нормализации, заполнения пропусков и кодирования категорий в фреймворке есть блок переработки datetime индексов в численные признаки. В наших экспериментах AutoGluon показал себя как наиболее надёжный из фреймворков.
Исходя из проведенного мини-обзора можно заключить, что наиболее распространенной схемой предобработки является “гибкая” версия. Набор преобразований для входных данных определяются исходя из структуры моделей, для которых производится предобработка.
P.S. Краткий обзор здесь естественно не затрагивает особенностей технических реализаций и более того, может потерять актуальность потому что фреймворки постоянно модифицируются. Также легко можно упустить некоторые детали, когда не занимаешься разработкой инструмента, а только делаешь его обзор. В связи с этим будем признательны, если найдёте несоответствия и предложите что-либо добавить в описание методов предобработки тех или иных инструментов.
### Реализация (“Надежная, как швейцарские часы”)
Устранение проблем проходило итеративно, таблица за таблицей мы пробовали запустить библиотеку, и если что-то шло не так, - занимались улучшениями. Решено было реализовать предобработку отдельным блоком перед подачей данных в пайплайн.
Рассмотрим предобработку на примере вот такой таблички. Пусть мы решаем задачу бинарной классификации и таблица хранится в csv файле:
Таблица 1. Пример таблицы с признаками для решения задачи бинарной классификацииКакие особенности можно выделить у этой таблицы с признаками:
* В признаке 1 присутствуют значения плюс минус бесконечность;
* В признаке 2 слишком много пропущенных значений;
* В признаке 3 присутствует пропуск. Также отметим, что признак принимает только два возможных значения: 1 и 10;
* В признаке 4 имеется три категории, однако из-за наличия отступов в строках количество категорий может быть определено как 5;
* Признак 5 бинарный категориальный и имеет пропуск;
* Признак 6 содержит в себе типы данных float и string;
* Целевая переменная содержит пропуски. При этом представлена в виде сырых меток, представляющих собой строки.
Начинаем двигаться слева направо. Сначала заменим все значения плюс минус бесконечность в признаке 1 на nan. Далее удалим признак 2, потому что он содержит слишком много пропущенных значений (порог у нас в фреймворке задан как 90% объектов).
Таблица 2. Преобразование невалидных значений (плюс и минус бесконечность) в NaN, удаление признака с большим процентом пропусковПосле удалим объект из обучающей выборки, значение целевой переменной для которого неизвестно - id 2.
Таблица 3. Удаление строк с неизвестными значениями для целевой переменнойПосле этого применим LabelEncoder, чтобы перевести метки ‘> 10’ и ‘<= 10’ в 0 и 1 соответственно. Устраним отступы в строках в признаке 4.
Таблица 4. Энкодинг целевой переменной и удаление отступовНебольшое лирическое отступление. Реализация OneHotEncoding’а в sklearn (а у нас в AutoML мы под капотом используем именно такую реализацию) поддерживает обработку бинарных категориальных признаков и обработку новых категорий, которых операция предобработки не видела во время обучения в тренировочной выборке. Первое значит, что если в таблице имеется категориальный бинарный признак, то его не будут увеличивать путём раздувания до нескольких столбцов. Второе значит, что если в тренировочной выборке были категории, например, “средний” и “маленький”, а в тестовой выборке “большой”, то алгоритм сможет продолжить работу без ошибки. Проблема только в том, что одновременно две этих опции не работают: нужно выбрать, либо одно, либо другое. Мы решили, что для нас важнее, чтобы фреймворк не проседал при обработке новых категорий.
Поэтому бинарные категориальные признаки (количество уникальных категорий в которых не больше двух) следует обрабатывать отдельно. Так и поступаем с признаком 5, - конвертируем значения в “1” и “0”.
Таблица 5. Энкодинг бинарных категориальных признаковНаконец, признак 6. Для него критически важным оказывается результат работы системы определения типов, которая также была реализована как часть предобработки. Она работает абсолютно одинаково для всех столбцов. Но сначала обозначим проблему: в признаке с float значениями есть знак ‘?’, и когда вы такой датафрейм загрузите к себе, то обнаружите, что pandas заботливо перевёл все числа в строки. Звучит не так страшно, однако если количество уникальных значений в признаке велико, а для энкодинга используется One Hot Encoding, то вас удивит размер получившейся после преобразования таблицы.
К решению. При помощи map мы просматриваем каждый элемент столбца и определяем из каких типов данных состоит столбец и в каких элементах какие типы расположены. В случае с этим столбцом выясняется, что количество уникальных значений намного больше, чем должно быть в категориальном признаке (может конкретно в этом фрагменте это и не так, но будь таблица чуть побольше, то это сразу стало бы заметно). Тогда алгоритм пытается привести столбец к типу float и попутно помечает все значения, которые в этот тип привести не может как nan. Таковым оказывается знак “?” в строке 4 (Таблица 6).
Проходимся так по каждому столбцу, по каждой ячейке. Поэтому когда предобработка закончена, мы имеем сводную информацию о каждом столбце в таблице - в дальнейшем знания о типах применяются в различных моделях и алгоритмах обработки данных.
Таблица 6. Обработка столбцов со смешанными типами данных. Замена знака “?” на пропущенное значение.Итак, несмотря на то, что много всего уже было сделано, в данных всё ещё есть пропуски и категориальные признаки. И да, так и задумано. Теперь переходим ко второму, дополнительному этапу предобработки, который позволяет признаки закодировать и устранить пропуски.
### Еще бóльшая реализация (“Я требую продолжения банкета!”)
После того как данные прошли предварительную обязательную обработку, запускается сердце AutoML - эволюционный алгоритм. Именно этот “движок” генерирует множество пайплайнов, и в каждый из них подаётся первично предобработанные данные. Как помните, данные прошли только самую грубую очистку и всё ещё содержат пропуски и строковые типы данных. Поэтому для каждой сгенерированной модели применяется своя предобработка.
Главная задача дополнительной обработки табличек - не позволить модели во время выполнения упасть с ошибкой. Рассмотрим на примере заполнения пропусков. Если алгоритм “понимает”, что если пропуски не заполнить, то пайплайн не сможет обучиться, то применяется стратегия заполнения пропусков по умолчанию. Если же в структуре пайплайна есть модели, способные данные с пропусками усвоить, то таблица пройдёт далее нетронутой. Тогда возникает вопрос: “Так почему же не предобработать данные сразу, заполнить пропуски и применить энкодер? Надежней же.”. Дело в том, что способов заполнения пропусков существует довольно много, равно как и способов энкодинга много [больше двух](https://towardsdatascience.com/beyond-one-hot-17-ways-of-transforming-categorical-features-into-numeric-features-57f54f199ea4). Поэтому ограничивать пространство поиска только одним способом не хочется - AutoML алгоритм сам разберётся как ему лучше преобразовать данные, чтобы получить самую точную модель.
Похожим образом рассуждает эксперт при построении модели - преобразования определяются из специфики решаемой задачи и особенностей набора данных: например, заполнение пропусков медианным значением, средним, или введение индикаторных переменных. При необходимости эксперт всегда может отказаться от включения в модель неподходящего метода предобработки и ограничиться только преобразованиями по умолчанию.
Анализ структуры пайплайна осуществляется на основе последовательного обхода графа от каждого начального узла (те, что слева) до корневого (тот, что всегда единственный и расположен на схеме справа) (Рисунок 3). Операции при этом разделяются по тегам на те, которые:
* могут переработать данные и устранить проблему (наличие пропусков например);
* могут данные пропустить через себя, но при этом не устраняют источник ошибки;
* при проведении операций над данными вызывают ошибку.
Рисунок 3. Анализ структуры композитной модели для применения дополнительной предобработки на примере наличия пропусков в табличных данныхНа рисунке показаны различные конфигурации пайплайнов. Если композитный пайплайн содержит в своей структуре операции, позволяющие усвоить данные с пропусками и категориальными признаками, то предобработка не проводится. В ином случае применяется со стратегиями по умолчанию.
Описанный выше подход позволяет сохранить гибкость при формировании решения. Алгоритм автоматической идентификации структуры композитной модели может находить оптимальные сочетания методов предобработки и конфигурации моделей. В процессе поиска решения операции предобработки могут заменяться на аналогичные. При этом, если модели будет достаточно для удовлетворительной ошибки прогноза производить предобработку по умолчанию, то композитная модель будет строиться только на основе моделей.
Представим, что в структуре пайплайна никаких операций предобработки не имеется и у алгоритма стоит необходимость заполнить пропуски и закодировать категориальные значения по умолчанию. Сначала разберёмся с пропусками: они присутствуют в признаках 1, 3, 5 и 6. Для столбцов 1 и 6 применяется самая обычная стратегия заполнения пропусков средним значением. Интереснее со столбцами 3 и 5, - столбцы содержат числовые значения, однако количество уникальных значений, которые могут принимать показатели в этих столбцах, не превышает двух. А много ли вы знаете числовых признаков, которые принимают всего два значения? - Не давая на размышление 15 сек, предположим, - признак скорее всего обозначает присутствие или отсутствие чего-либо у объекта. Объект либо имеет, например, хвост, либо не имеет. Полутонов вводить тут не стоит. Поэтому в таких столбцах заполним значения мажоритарным классом. В случае, если количество категорий равно (это в действительности случается исчезающе редко), то для бинарного признака пропуски заполняются всё таки средним значением.
Таблица 7. Заполнение пропусков в таблице по умолчанию (восстановленные значения показаны зелёным)С категориями проще - стратегией кодировки по умолчанию является OneHotEncoding (Таблица 8).
Таблица 8. Преобразование категориальных признаков### Развязка (“Честно говоря, моя дорогая, мне наплевать”)
Попробуем повторить все те навороты, которые мы реализовали в ходе разработки блока предобработки в AutoML фреймворке.
Итак, предобработка разделяется на два уровня: обязательная и дополнительная. Первая производится всегда и везде, вторая - только в том случае, если в структуре пайплайна нет моделей, позволяющих усвоить данные так, чтобы при попытке обучить пайплайн не возникала бы ошибка.
В обязательную входит:
1. Замена значений плюс минус бесконечность в признаках и целевом столбце на nan
2. Удаление признаков, число пропущенных значений в которых превышает 90%
3. Удаление объектов из таблицы, для которых неизвестно значение целевой переменной (nan в target)
4. Перевод меток в целевом столбце из строкового формата в целочисленный
5. Устранение отступов в строковых объектах в признаках
6. Усвоение столбцов с разными типами данных, заключающееся в детекции столбцов со смешанными типами и их приведение к мажоритарному, какому-либо возможному или удаление столбца из таблицы.
Дополнительная:
1. Анализ структуры пайплайна на наличие операций заполнения пропусков - заполнение пропусков при необходимости;
2. Анализ структуры пайплайна на наличие операций кодирования категориальных значений - применение энкодинга при необходимости
Все приведенные выше модфикации позволяют фреймворку запускаться на рассмотренных датасетах (даже на самых страшных) именно с фразой из названия раздела.
Позволю себе и читателю здесь немного остановиться и поразмышлять. Всё что было описано выше это сложная техническая задача (без шуток). Но интересна ли она исследователю или заказчику? - скорее всего нет. Всю эту возню с данными обычно хочется проскочить как можно быстрее и перейти к разработке модели, ведь именно это самая захватывающая часть. Только представьте, сколько кода потребовалось бы написать, чтобы предобрабатывать данные таким образом. Так не лучше ли отдать всю предобработку на сторону AutoML алгоритмов?
Пример предобработки при помощи AutoMLЗаметим, что иногда самим хочется построить модель, а не отдавать AutoML алгоритму самую интересную часть. Тогда поручить всю предобработку можно написав следующие строки кода для FEDOT:
```
import numpy as np
from fedot.core.data.data import InputData
from fedot.core.pipelines.node import PrimaryNode
from fedot.core.pipelines.pipeline import Pipeline
from fedot.core.repository.dataset_types import DataTypesEnum
from fedot.core.repository.tasks import Task, TaskTypesEnum
train_input = InputData(idx=np.arange(0, len(features)), features=features, target=target, task=Task(TaskTypesEnum.classification), data_type=DataTypesEnum.table)
pipeline = Pipeline(PrimaryNode('scaling'))
pipeline.fit(train_input)
preprocessed_output = pipeline.predict(train_input)
transformed_data = preprocessed_output.predict
```
Пайплайн автоматически запустит обработчик данных, и на выходе вы получите предобработанные стандартизированные данные, которые можно использовать как основу для ваших экспериментов. Предобработка будет проведена, естественно, по умолчанию, но, учитывая какие могут быть данные, уже это может существенно сэкономить время при разработке модели.
### Эпилог. Эксперимент (“Тебя запустют, а ты досчитай!”)
Поскольку запускать фреймворк на всех таблицах дело небыстрое, мы подготовили небольшой игрушечный датасет в репозитории [automl-crash-test](https://github.com/ITMO-NSS-team/automl-crash-test). Таблица для решения задачи классификации совсем небольшая, но представляет собой собирательный образ всего того плохого, с чем мы столкнулись во время запусков на всех 46 датасетах.
Если захотите запустить свой любимый фреймворк на этих данных - welcome. Пройти такой краш-тест на самом деле не так то просто как кажется. А выбить хороший скор (ROC AUC 1.0) - результат просто отличный. Набрать ROC AUC 1.0 на тестовой выборке для данной таблицы возможно только корректно предобработав хотя бы некоторые столбцы, отбросив все ненужные и оставив нужные.
Ниже приведен пример запуска фреймворка FEDOT (версия 0.5.2) на этих данных. Результат выполнения программы для нас самый заветный - никаких ошибок не возникло и мы смогли получить финальное решение. Также весь код и зависимости для запуска есть в репозитории.
```
from fedot.api.main import Fedot
from sklearn.metrics import classification_report, roc_auc_score
from data.data import get_train_data, get_test_data
train_features, train_target = get_train_data()
test_features, test_target = get_test_data()
# Task selection, initialisation of the framework
fedot_model = Fedot(problem='classification', timeout=timeout)
# Fit model
obtained_pipeline = fedot_model.fit(features=train_features, target=train_target)
obtained_pipeline.show()
# Make predictions
predict = fedot_model.predict(test_features)
predict_probs = fedot_model.predict_proba(test_features)
```
Финальная метрика на тестовой части - 1.0 ROC AUC.
### Заключение (“Вы привлекательны, я чертовски привлекателен… Чего время терять?”)
Как можно заметить, все вышеперечисленные внедренные в AutoML преобразования не являются новейшими технологиями. Однако их удачное сочетание позволяет добиться запуска моделей машинного обучения даже в тех случаях, когда табличные данные представляют собой самый настоящий “garbage in”.
Естественно, что все описания стоит рассматривать через призму разработки AutoML инструмента, который в нашей парадигме должен работать надежно там, где junior Data Scientist быстро и надёжно работать не сможет (или сможет, но не очень надежно или не очень быстро). И, возможно, если такая предобработка подошла для наших моделей, она сможет подойти и вам для ваших.
Полезные ссылки:
* [Репозиторий open-source AutoML фреймворка FEDOT](https://github.com/nccr-itmo/FEDOT)
* [Канал NSS Lab](https://t.me/NSS_group) — анонсы наших новых статей и выступлений, посвященных AI/ML
* [Репозиторий с "грязными" таблицами automl-crash-test](https://github.com/ITMO-NSS-team/automl-crash-test)
В выступлении со своеобразным гайдом по предобработке табличных данных участвовали: [Сарафанов Михаил](https://github.com/Dreamlone) и команда [NSS lab](https://itmo-nss-team.github.io/) | https://habr.com/ru/post/657525/ | null | ru | null |
# Никто не умеет обрабатывать ошибки
Из одной книги в другую, из статьи в статью кочует мнение о том, что выражение
```
try {
//do something
}
catch(Exception ex) {
}
```
является плохой практикой. Возврат кодов – также плохая практика. Но становится ли нам, программистам, жить легче с этими знаниями и так уж ли они неоспоримы? И самый забавный вопрос – кто-нибудь в мире умеет грамотно обрабатывать ошибки, возникающие по ходу работы приложения? (под этим я понимаю обработку только тех ошибок, которые имеет смысл обрабатывать и вывод сообщений об ошибках, которые соответствуют действительно произошедшей, которые не вводят пользователя в замешательство, а в идеале и предлагают решение возникшей проблемы).
Целью данной статьи не является «разнос» существующих концепций, за незнанием автором лучшего подхода. Целью статьи является заострение проблемы обработки исключений и признание того факта, что недостаточно просто делать отписки в стиле «не делайте `catch(Exception)`» или «бросайте всегда исключения наверх – авось, там, наверху разберутся». Это ничем не помогает. На русском языке на эту тему так вообще мало чего написано (да и кто доверяет русскоязычным авторам? Шутка, но в каждой шутке есть доля шутки). Статья предназначена также для не умудрённых опытом разработчиков, чтобы читатель осознал то, что мучаются обработкой ошибок абсолютно все, включая «сильнейших мира сего», а также начал понимать проблему на немного более глубоком уровне.
Для начала хотелось бы представить мой перевод двух статей:
1. [Проблемы с проверяемыми исключениями. Беседа с Андерсом Хейлсбергом. Часть 2.](http://www.artima.com/intv/handcuffs.html) 18 августа 2003.
2. [Жизнь с непроверяемыми исключениями.](http://ericlippert.com/2014/03/03/living-with-unchecked-exceptions/) 3 марта 2014.
Хотелось бы также упомянуть, что в целях краткости я не переводил абсолютно всё из этих статей. Это вырезки, которые являются наиболее важными с точки зрения заданной темы. Текст от себя я буду обрамлять следующим образом: **Spock speech** текст **end of Spock speech**
#### Проблемы с проверяемыми исключениями.
**Bruce Eckel**: C# не имеет механизма проверяемых исключений. Каким образом принималось решение о том включать или нет механизм проверяемых исключений в C#?
**Anders Hejlsberg**: Я вижу две проблемы с проверяемыми исключениями: масштабируемость и версионируемость.
**Bruce Eckel**: Раньше я думал, что проверяемые исключения — это круто.
**Anders Hejlsberg**: Именно. Честно говоря, при поверхностном рассмотрении, они действительно выглядят хорошо и кажется, что с этой идеей всё нормально. Я абсолютно согласен с тем, что механизм исключений это отличная фича. Просто конкретная реализация может быть проблематичной. Если реализовать этот механизм так, как он был реализован в Java, то, я думаю, вы просто размениваете один набор проблем на другой. В результате для меня неясно становится ли жизнь хоть сколько-нибудь легче. Мы просто делаем жизнь другой.
**Bruce Eckel**: Были ли в команде разработчиков C# разногласия относительно проверяемых исключений?
**Anders Hejlsberg**: Нет, я думаю, что в нашей команде проектировщиков языка в большей степени царило согласие. C# молчалив по отношению к проверяемым исключениям. Если однажды лучшее решение будет найдено – и поверьте мне, мы продолжаем думать о данной проблеме – мы сможем вернуться и прикрутить, что нужно. Я убеждённый сторонник того, что если вам нечего сказать такого, что продвинет искусство вперёд, то лучше промолчать и придерживаться нейтральной позиции, а не пытаться создать свой фреймворк.
**Bruce Eckel**: Разработчики, практикующие экстремальное программирование говорят «делай наиболее просто, чтобы работало».
**Anders Hejlsberg**: Да, Эйнштейн сказал «делай наиболее просто, но не проще простого». Полагаю, что проверяемые исключения это наручники для программистов. Можно наблюдать программистов, которые берутся использовать какой-нибудь новый API, декларирующий множество потенциально пробрасываемых исключений и можно увидеть насколько засорённым становится их код. В результате вы осознаёте, что проверяемые исключения им ничем не помогают.
**Bill Venners**: Вы упоминали масштабируемость и версионируемость относительно проверяемых исключений. Не могли бы вы пояснить, что вы имели ввиду под двумя проблемами, связанными с этими понятиями?
**Anders Hejlsberg**: Начнём с версионирования, потому что тут проблемы легко увидеть. Скажем я создаю метод `foo`, который декларирует проброс исключений A, B и C. Во второй версии метода я хочу добавить пару фишек и теперь метод `foo` может выкинуть также исключение D. Добавление нового исключения является несовместимым изменением, потому что существующие пользователи этого метода почти 100% не будут ловить это исключение.
Добавление нового исключения ломает клиентский код. Это как добавление метода в интерфейс.
**Bill Venners**: Но не ломаете ли вы клиентский код в любом случае, даже если в языке отсутствуют проверяемые исключения?
**Anders Hejlsberg**: Нет, потому что в большом количестве случаев людям «по-барабану». Они не собираются ловить какие-либо из этих исключений. На нижнем уровне, вокруг цикла сообщений находится обработчик исключений. Этот обработчик просто выводит окошко о том, что что-то пошло не так. Программисты защищают свой код, покрывая его повсюду конструкциями `try\finally`, так что они просто уклоняются от обработки исключения, именно исключение они обрабатывать и не собирались.
**Bill Venners**: В общем, вы считаете, что в наиболее распространённом случае пользователи предпочитают обработчик на вершине стека, явной обработке исключений?
**Anders Hejlsberg**: Забавно, что люди думают, что наиболее важной частью взаимоотношений с исключениями является их обработка. Это как раз не так важно. В хорошо написанном приложении отношение конструкций `try\finally` к `try\catch` примерно 10 к 1.
**Bill Venners**: Так что же в результате?
**Anders Hejlsberg**: В результате, вы защищаете себя от исключений, а не обрабатываете их. Обработку исключений вы реализуете где-то в другом месте. Естественно, что в любом типе событийно-ориентированного приложения, как в случае с любым современным UI-приложением, вы реализуете обработку исключений вокруг цикла сообщений и просто здесь их и обрабатываете. Но по ходу программы вы защищаете себя, освобождая выделенные ресурсы, которые были захвачены и так далее. Вы подчищаете за собой так, что вы всегда находитесь в непротиворечивом состоянии. Вы не хотите писать программу, которая в сотне разных мест обрабатывает исключения и выбрасывает окна с сообщениями об ошибках.
Обработка исключений должна быть централизованной и вы должны просто защищать себя в то время как исключения распространяются до обработчика.
**Spock speech**
Проблема с масштабируемостью не меняет смысла обработки исключений так, как было предложено Андерсом Хейлсбергом, поэтому перевод выкладывать с точки зрения данной темы не целесообразно (кому интересно – могут пройти и посмотреть, но в целом всё сводится к тому, что при росте программы, количество выбрасываемых исключений растёт и никто не сможет их все обрабатывать, особенно методы, которые могут пробросить десяток-другой различных типов исключений, ваши обработчики превратятся в адские портянки `try\catch` и код станет невозможно поддерживать).
Совсем недавно, 3 марта 2014 года Эрик Липперт в своём блоге также поднял тему обработки исключений в C#.
Обсуждение он разбил на две части: в первой части он задал несколько вопросов, а во второй части агрегировал ответы и сделал резюме.
Итак, вопросы, которые задал читателям своего блога Эрик:
**end of Spock speech**
#### Жизнь с непроверяемыми исключениями
* Имели ли ваши программы баги, которые вы исправили, добавив обработку исключения, о возможности выброса которого вы даже не подозревали?
* Когда вы пишете новый код, который вызывает методы, которые вы не разрабатывали, то каким образом вы догадываетесь о том, какие исключения могут быть выброшены? Существуют ли типы исключений, которые, по вашему мнению, должны быть всегда обработаны в независимости от того, какой метод их выбрасывает? Например, верно ли то, что любой метод, выбрасывающий `IOException` должен быть всегда завёрнут в `try-catch`?
**Spock speech**
Был ещё задан 3-й вопрос, но вопрос не очень интересный и ответы на него также особого интереса не представляют, поэтому соответствующие части будут опущены.
**end of Spock speech**
Основной вывод по комментариям читателей: исключения привносят небольшой беспорядок в C#. Семантика языка и организация (или недостаток организации) иерархии исключений делает сложным узнать то, какие исключения нужно ловить и какие следует пропустить. Множество читателей оставили множество отличных комментариев, но один из них произвёл на меня наиболее сильное впечатление:
> Я думаю, что вся концепция «обработки» исключений слегка напоминает игру для дураков. Я, наверное, могу посчитать на пальцах одной руки количество случаев, когда я был действительно в состоянии обработать специфический тип исключения и сделать в обработчике что-то интеллектуальное. В 99% случаев ты должен ловить или всё или ничего. Когда выбрасывается исключение любого типа, восстановите стабильное состояние и затем либо продолжайте, либо прерывайте исполнение программы.
Это грубо, но, я думаю, справедливо.
Этот комментарий предполагает Покемон-обработку – поймай их всех! ([gotta catch ‘em all](http://bulbapedia.bulbagarden.net/wiki/Catch_rate)) – вот решение проблемы. Я был удивлён тем, что почти треть комментаторов выразили поддержку использования `catch(Exception)`, ведь исторически это описывалось как плохая практика компанией Микрософт. C#, как я обычно говорю, спроектирован быть «кабинкой успеха» ([«pit of success»](http://english.stackexchange.com/questions/77535/what-does-falling-into-the-pit-of-success-mean)), где то, что является наиболее простым, является и наиболее правильным. Эта замечательная цель, похоже, в данном случае не была достигнута. Если `catch(Exception)` это и наименее верный путь и наиболее простой, то это потому что правильный путь слишком тяжёл.
Подавляющее большинство комментаторов написали, что правили баги, причиной которых было отсутствие `catch` для конкретных типов исключений, хотя такие случаи у разных людей случались с разной периодичность: «от 1 до 2 раз», «изредка», до «часто».
Треть сказали, что они использовали MSDN и другие формы документации (включая XML-комментарии) в целях определения типов исключений, которые следовало бы ловить. MSDN и хвалили и критиковали; какие-то части MSDN написаны отлично, другие написаны так, что ничего не понятно. Третью часть документации всесторонне изкритиковали, такой документации никто не верит.
Четверть сказали, что использовали что-то вроде метода проб и ошибок – отладка, тестирование, чтение логов, получения краш-дампов для того, чтобы выяснить какие исключения следует ловить.
Опять же, разочарование было резюмировано следующим комментарием:
> Каждый `try/catch` блок это упражнение в разочаровании, потому что ты думаешь, что ловишь нужный тип исключения до тех пор, пока всё не сломается в эксплуатации.
>
> Достаточно много комментаторов заметили, что система обработки исключений предполагает наиболее важной информацией сам тип исключения, однако одного типа недостаточно для того, чтобы произвести правильную обработку исключения.
**Spock speech**
Внезапно! Почти всё, что сказано либо прямо, либо косвенно противоречит The Best Practice!
Подкину ещё проблему: что, если вам нужно в цикле вызывать код, который всё время выбрасывает исключения в случае, если что-то не так? Старая непроизводительная машина (а их есть у нас в России великое множество) «сдохнет». Тут придут на помощь (если вы владелец вызываемого метода) коды возвратов или экземпляры классов, которые содержат в себе нужную информацию. Ой, оказывается коды возвратов не мертвы, как ожидалось.
А от `catch(Exception)` вам никуда не деться: вам придётся повсюду, а не только на уровне цикла сообщений делать `catch(Exception)`, если только вы не считаете, что в вашей конкретной ситуации пусть себе исключения летают через всю систему (чем дальше летят, тем больше жрут ресурсов).
Остаётся одна загвоздка с `catch(Exception)`: мы можем поймать `StackOverflow` или `OutOfMemory` и даже глазом не повести, что приведёт к печальным последствиям, за которые можно заплатить миллионами рублей (или долларов), если вы не пишете Hello, World!
Для «решения» (намеренно взял в кавычки, поскольку едва ли существующие решения проблем с обработкой ошибок кого-либо полностью удовлетворяют, или приближаются хотя бы близко к полному удовлетворению) означенной проблемы подойдёт фильтрование. Кстати говоря, несмотря на то, что в MSDN фильтрация исключений признаётся не лучшей практикой, сама часть Enterprise Framework ответственная за обработку исключений базируется на фильтровании, которое настраивается через соответствующие политики, сюрприз!
Вот простой статический класс, упрощающий обработку исключений:
```
public static class Exceptions {
private static readonly List fatalExceptions = new List {
typeof (OutOfMemoryException),
typeof (StackOverflowException),
//Ещё типы исключений, который по вашему мнению всегда являются фатальными
};
public static string FullMessage(this Exception ex) {
var builder = new StringBuilder();
while (ex != null) {
builder.AppendFormat("{0}{1}", ex, Environment.NewLine);
ex = ex.InnerException;
}
return builder.ToString();
}
public static void TryFilterCatch(Action tryAction, Func isRecoverPossible, Action handlerAction) {
try {
tryAction();
} catch (Exception ex) {
if (!isRecoverPossible(ex)) throw;
handlerAction();
}
}
public static void TryFilterCatch(Action tryAction, Func isRecoverPossible, Action handlerAction) {
try {
tryAction();
} catch (Exception ex) {
if (!isRecoverPossible(ex))
throw;
handlerAction(ex);
}
}
public static bool NotFatal(this Exception ex) {
return fatalExceptions.All(curFatal => ex.GetType() != curFatal);
}
public static bool IsFatal(this Exception ex) {
return !NotFatal(ex);
}
}
```
Примеры использования:
```
Exceptions.TryFilterCatch(host.Close, Exceptions.NotFatal,
ex => logger.Error("Исключение при закрытии хоста сервиса.", ex));
private bool TryGetTpmProcess(out Process process) {
process = null;
try {
process = Process.GetProcessById(App.TpmProcessId.GetValueOrDefault());
return true;
} catch (Exception ex) {
if (ex.IsFatal())
throw;
return false;
}
}
```
Метод `TryFilterCatch` позволяет «портянки» преобразовывать в краткую запись. Методы расширения также оказываются удобными в использовании. Способ с `TryFilterCatch` подсмотрел [здесь.](http://smellegantcode.wordpress.com/2009/02/26/fatal-exceptions-and-why-vb-net-has-a-purpose/)
Кратким резюме всех моих изысканий по данном вопросу является следующий вывод: все мы пользуемся меньшим из зол, но зло выбираем в любом случае, поскольку никто не знает как избавиться ото зла или сократить его до минимума. Под необходимым злом я имею ввиду концепцию непроверяемых исключений, которые являются дефолтовым способом уведомления всех и вся о том, что что-то пошло не так в C# (да и в Java тоже с того момента, как все поняли, что проверяемые исключения ничего не дают).
Так что, не верьте в «утверждения вылитые в граните», смотрите в оба и не позволяйте исключениям убивать ваше приложение.
**end of Spock speech** | https://habr.com/ru/post/221723/ | null | ru | null |
# Первые шаги в BI-аналитике. Роль Data Engineering
Добрый день, уважаемые читатели! Материал носит теоретический характер и адресован исключительно начинающим аналитикам, которые впервые столкнулись с BI-аналитикой.
Что традиционно понимается под этим понятием? Если говорить простым языком, то это комплексная система (как и, например, бюджетирование) по сбору, обработке и анализу данных, представляющая конечные результаты в виде графиков, диаграмм, таблиц.
Это требует слаженной работы сразу нескольких специалистов. Дата-инженер отвечает за хранилища и ETL/ELT-процессы, аналитик данных помогает в заполнении базы данных, аналитик BI разрабатывает управленческие панели, бизнес-аналитик упрощает коммуникации с заказчиками отчетов. Но такой вариант возможен, только если фирма готова оплачивать работу команды. В большинстве случаев небольшие компании для минимизации затрат делают ставку на одного человека, который зачастую вообще не обладает широким кругозором в области BI, а имеет лишь шапочное знакомство с платформой для отчетов.
В таком случае происходит следующее: сбор, обработка и анализ данных происходит силами единственного инструмента – самой BI-платформой. При этом данные предварительно никак не очищаются, не проходят компоновки. Забор информации идет из первичных источников без участия промежуточного хранилища. Результаты такого подхода можно легко лицезреть на тематических форумах. Если постараться обобщить все вопросы касательно BI-инструментов, то в топ-3 попадут, наверное, следующие: как загрузить в систему плохо структурированные данные, как по ним рассчитать требуемые метрики, что делать, если отчет работает очень медленно. Что удивительно, на этих форумах вы практически не найдете обсуждений ETL-инструментов, описания опыта применения хранилищ данных, лучших практик программирования и запросов SQL. Более того, я неоднократно сталкивался с тем, что опытные BI-аналитики не очень лестно отзывались о применении R/Python/Scala, мотивируя это тем, что все проблемы можно решить только силами BI-платформы. Вместе с тем всем понятно, что грамотный дата инжиниринг позволяет закрывать массу проблем при построении BI-отчетности.
Дальнейший разговор предлагаю построить в форме разбора упрощенных блок-схем. Я сознательно не буду называть конкретные программы, а лишь укажу их класс. Во-первых, это не имеет принципиального значения для раскрытия темы, а, во-вторых, упоминание инструментов сразу приводит к ненужным спорам в комментариях.
**«Data – BI»** Самый простой вариант. Именно с него начинается прототипирование управленческих панелей. В роли источника данных часто выступает отдельный (-ые) статичный файл (csv, txt, xlsx и т. д.).
Плюсы. Самый быстрый способ построения отчетности. Идеально подходит, для ситуационной аналитики или когда результат нужен был еще вчера. Не требует применения вспомогательных инструментов, следовательно, не нужно тратить ресурсы на их поддержание. Аналитик BI не обязан иметь компетенции в области дата инжиниринга или программирования.
Минусы. Далеко не изо всех источников можно забрать информацию напрямую (пример, прикладные решения на платформе 1С). Если массивы плохо структурированы, то это потребует много дополнительных шагов по их обработке. Качество данных никак не проверяется (проблема дубликатов, пустых строк, некорректного написания значений и т. д.). При большом количестве строк заметно замедляется работа самой BI-платформы, вплоть до полной невозможности перестраивать графики и диаграммы. Нет возможности составить расписание на обновление исходников.
**«Data – DB – BI»** Вариант похож на предыдущий за тем исключением, что первоначальный массив напрямую заливается в базу в неизмененным виде, а уже к ней идет подключение. База данных может быть как развернута локальна, запущена в контейнере, так и представлена облачным хранилищем.
Плюсы. Есть возможность агрегировать разрозненные, однотипные файлы. Нагрузку по хранению информации теперь несет хранилище. Есть возможность задействовать всю мощь языка запросов SQL (или его диалекта), чтобы отфильтровать или агрегировать сырые строки перед их передачей в BI-инструмент. Уменьшается размер файла с управленческими панелями.
Минусы. Нет контроля над первичными данными, поэтому в хранилище заливается большое количество ненужной информации. Качество загружаемых датасетов никак не контролируется. Добавление данных в базу осуществляется в ручном режиме. Аналитик должен на базовом уровне знать SQL.
**«Data – ETL – DB – BI»** Частичная автоматизация. В качестве ETL-инструмента может выступать как программный продукт с графическим интерфейсом, так и код написанный на R/Python/Scala и т. д. Все данные проходят предварительный предпроцессинг. Структура наполняемых таблиц прописывается заранее.
Плюсы. Возможность загружать только хорошо структурированную информацию, которая прошла предварительную верификацию. Экономия места в базе данных. Снижается количество доработок на BI-платформе.
Минусы. Аналитик должен уверенно владеть ETL-инструментом и языком запросов SQL. Процесс разработки и тестирования скриптов требует времени. Если источников информации много, то затрудняется синхронизация получения информации.
Для иллюстрации этого варианта я решил написать простейшие скрипты. В рамках «игрушечного» примера я использую SQLite. Это позволит прикрепить базу данных к публикации, чтобы каждый желающий мог попрактиковаться в написании скриптов ([архив](https://github.com/GrishenkovP/publications/tree/master/Habr/first_steps_in_bi)). Датасет для разбора это E-Commerce Data с сайта Kaggle.
```
# импорт библиотек
import pandas as pd
# опции отображения
pd.set_option('display.max_columns', 10)
pd.set_option('display.expand_frame_repr', False)
path_dataset = 'dataset/ecommerce_data.csv'
# Предварительная обработка датасета
def func_main(path_dataset: str):
# Считываем датасет
df = pd.read_csv(path_dataset, sep=',')
# Приводим названия столбцов датасета к нижнему регистру
list_col = list(map(str.lower, df.columns))
df.columns = list_col
# Избавляемся от времени и трансформируем строку-дату в правильный формат
df['invoicedate'] = df['invoicedate'].apply(lambda x: x.split(' ')[0])
df['invoicedate'] = pd.to_datetime(df['invoicedate'], format='%m/%d/%Y')
# Рассчитываем сумму покупки по каждому товару
df['amount'] = df['quantity'] * df['unitprice']
# Удаляем ненужные для дальнейшего анализа столбцы
df_result = df.drop(['invoiceno', 'quantity', 'unitprice', 'customerid'], axis=1)
# Задаем порядок вывода столбцов для визуального контроля результата
df_result = df_result[['invoicedate', 'country', 'stockcode', 'description', 'amount']]
return df_result
# Таблица Продажи
def func_sale():
tbl = func_main(path_dataset)
df_sale = tbl.groupby(['invoicedate', 'country', 'stockcode'])['amount'].sum().reset_index()
return df_sale
# Таблица Страны
def func_country():
tbl = func_main(path_dataset)
df_country = pd.DataFrame(sorted(pd.unique(tbl['country'])), columns=['country'])
return df_country
# Таблица Товары
def func_product():
tbl = func_main(path_dataset)
df_product = tbl[['stockcode','description']].\
drop_duplicates(subset=['stockcode'], keep='first').reset_index(drop=True)
return df_product
```
В коде сочетается Extract и Transform. Считываем датасет, парсим столбец с датами. Рассчитываем сумму покупки по каждой строке и удаляем ненужные для дальнейшего анализа колонки. Так как датафрейм записывается в базу данных не монолитом, а разбивается на таблицы, то готовим три вспомогательные функции.
```
# импорт библиотек
import pandas as pd
import sqlite3 as sq
from etl1 import func_country,func_product,func_sale
con = sq.connect('sale.db')
cur = con.cursor()
## Таблица Страны
# cur.executescript('''DROP TABLE IF EXISTS country;
# CREATE TABLE IF NOT EXISTS country (
# country_id INTEGER PRIMARY KEY AUTOINCREMENT,
# country TEXT NOT NULL UNIQUE);''')
# func_country().to_sql('country',con,index=False,if_exists='append')
## Таблица Товары
# cur.executescript('''DROP TABLE IF EXISTS product;
# CREATE TABLE IF NOT EXISTS product (
# product_id INTEGER PRIMARY KEY AUTOINCREMENT,
# stockcode TEXT NOT NULL UNIQUE,
# description TEXT);''')
# func_product().to_sql('product',con,index=False,if_exists='append')
## Таблица Продажи (основная)
# cur.executescript('''DROP TABLE IF EXISTS sale;
# CREATE TABLE IF NOT EXISTS sale (
# sale_id INTEGER PRIMARY KEY AUTOINCREMENT,
# invoicedate TEXT NOT NULL,
# country_id INTEGER NOT NULL,
# product_id INTEGER NOT NULL,
# amount REAL NOT NULL,
# FOREIGN KEY(country_id) REFERENCES country(country_id),
# FOREIGN KEY(product_id) REFERENCES product(product_id));''')
## Таблица Продажи (временная)
# cur.executescript('''DROP TABLE IF EXISTS sale_data_lake;
# CREATE TABLE IF NOT EXISTS sale_data_lake (
# sale_id INTEGER PRIMARY KEY AUTOINCREMENT,
# invoicedate TEXT NOT NULL,
# country TEXT NOT NULL,
# stockcode TEXT NOT NULL,
# amount REAL NOT NULL);''')
# func_sale().to_sql('sale_data_lake',con,index=False,if_exists='append')
## Перегружаем данные из вспомогательной таблицы (sale_data_lake) в основную (sale)
# cur.executescript('''INSERT INTO sale (invoicedate, country_id, product_id, amount)
# SELECT sdl.invoicedate, c.country_id, pr.product_id, sdl.amount
# FROM sale_data_lake as sdl LEFT JOIN country as c ON sdl.country = c.country
# LEFT JOIN product as pr ON sdl.stockcode = pr.stockcode
# ''')
## Очищаем вспомогательную таблицу
# cur.executescript('''DELETE FROM sale_data_lake''')
def select(sql):
return pd.read_sql(sql,con)
sql = '''select *
from (select s.invoicedate,
c.country,
pr.description,
round(s.amount,1) as amount
from sale as s left join country as c on s.country_id = c.country_id
left join product as pr on s.product_id = pr.product_id)'''
print(select(sql))
cur.close()
con.close()
```
На следующем этапе (Load) мы создаем четыре таблицы. Две из них будут справочниками. Одна содержать сгруппированную информацию по продажам. Нам также потребуется вспомогательная таблица, в которую мы запишем строки с продажами до момента замены текстовых значений на числовые ид. На последнем шаге очистим ее от всех значений.
В заключении нам остается лишь выполнить тестовый запрос SQL, чтобы проверить корректность всех операций. Если все сделано правильно, запускаем BI-платформу.
Так как BI-инструмент не может из коробки напрямую подключиться к SQLite напишем простейший скрипт на Python.
```
import pandas as pd
import sqlite3 as sq
con = sq.connect('C:/Users/Pavel/PycharmProjects/test/sale.db')
cur = con.cursor()
def select(sql):
return pd.read_sql(sql,con)
sql = '''select *
from (select s.invoicedate,
c.country,
pr.description,
replace(round(s.amount,1),'.',',') as amount
from sale as s left join country as c on s.country_id = c.country_id
left join product as pr on s.product_id = pr.product_id)'''
tbl = select(sql)
print(tbl)
```
После загрузки данных в систему и проверки корректности распознанных форматов можно приступать к непосредственному построению дашборда.
**«Data – Workflow management platform + ETL – DB – BI»** Полная автоматизация. Оркестратор скриптов берет на себя контроль за своевременным выполнением всех вспомогательных процессов в системе.
Плюсы. Возможность оптимально настроить время сбора данных из разрозненных источников. Можно мониторить ошибки и перезапускать упавшие задачи.
Минусы. Усложнение инфраструктуры. Рост требований к квалификации аналитика BI. Необходимо осваивать дополнительные инструменты или языки программирования.
**«Data – Workflow management platform + ELT – Data Lake – Workflow management platform + ETL – DB – BI»** Самый сложный вариант, где информация проходит двухступенчатый конвейер: сначала это неструктурированные данные (Data Lake), а затем уже хранилище (DB), где информация отсортирована и преобразована к требуемому виду.
Плюсы. Возможность разнести во времени сбор информации и ее обработку. Если на этапе проектирования таблиц учтены не все требования, возможно обращение за дополнительными данными в Data Lake.
Минусы. Аналогичны предыдущему варианту. Если выбранная платформа Data Lake – платная, как следствие рост расходов на аналитику компании.
Краткие выводы.
* Построение BI-аналитики без даты инжиниринга возможно лишь на старте.
* Если аналитик BI работает в единственном числе и система постоянно усложняется, то он обязан подменять собой сразу несколько специалистов.
* Понимание базовых принципов построения хранилищ данных, уверенное владение SQL, программирование на каком-либо языке и, конечно, дизайнерские навыки вот далеко не полный перечень требований к сотруднику, которому делегируется проектировать управленческие панели.
На этом все. Всем здоровья, удачи и профессиональных успехов! | https://habr.com/ru/post/555388/ | null | ru | null |
# Как стать Zend PHP 5 Certified Engineer
Свершилось, ура! Теперь [я](http://www.zend.com/store/education/certification/yellow-pages.php#show-ClientCandidateID=ZEND010589) имею почетный статус ZCE :)
Поэтому хотел бы поделиться своим опытом подготовки к сертификации, ну и заодно провести небольшой ликбез на тему [сертификации по PHP.](http://www.zend.com/en/services/certification/php-5-certification/)
Сертификацию проводит компания [Zend](http://zend.com), эта компания стояла у истоков разработки ядра PHP, и до сих пор продолжает активно продвигать и поддерживать новые технологии в этой области.
С ростом популярности PHP, возникла такая проблема — разработчиков много, но кто из них действительно профи? Разобрать не так-то просто, поэтому было решено создать промышленный стандарт сертификации.
Для такой непростой задачи собрали [лидеров сообщества разработчиков PHP](http://www.zend.com/en/services/certification/php-5-certification/education-advisory-board), и те в свою очередь наколбасили первую версию теста по PHP4, чуть позже его заменил тест по PHP5. Который я собственно и сдавал.
Тут небольшая ремарочка. На западе, в частности в штатах, сертифицированный специалист ценится гораздо больше не сертифицированного, у нас же в России, наличие бумажки подтверждающей твой статус, это скорее плюс, но не обязательное условие.
Возникает вопрос, зачем тогда вообще нужна сертификация?
Лично для меня это был некий challenge, испытание, вызов которой я решил устроить самому себе. Стало интересно смогу пройти или не смогу, да и вообще — оценить свой уровень знаний/опыта/умений это полезно. Ну и статус ZCE тоже не лишним будет :-)
Сказано — сделано. Зарегистрировался на сайте, там же приобрёл [Certification Bundle](http://www.zend.com/en/store/php-certification/zend-php5-certification-bundle), это что-то типа набора «всё в одном», стоит 165$ включает в себя право на сертификацию, 10 пробных тестов и [Certification Guide](http://www.zend.com/en/store/php-certification/study-guide). На сайте [PEARSON VUE](http://vue.com/zend) выбрал свой региональный центр тестирования, назначил дату и время экзамена. Региональные центры тестирования от **PEARSON VUE** есть почти в каждом более-менее крупном городе, так что с этим проблем не должно возникнуть.
Теперь по подробнее о формате тестов. Пробные тесты (как и сама сертификация) на английском. 70 вопросов, на всё про все даётся 90 минут. Кажется что мало, но по факту этого хватает. Много вопросов прямо скажем «с подковырочкой», где запятую пропустят, а где скобочку, поэтому надо быть очень внимательным. Особо запомнились вопросы на знание функций, все основные (и немало экзотических) функции для работы со строками, массивами нужно знать, без этого никак. И уж конечно понимать разницу между **print()** и **echo()** :-)
На время придётся прирости к мануалу.
Для примера — что выведет этот скрипт?
`php<br/
echo '3' + '0.5' , print('2') + 1;
?>`
Естественно нужно «шарить» в базах данных, SQL. Разбираться с тонкостями использования новых возможностей PHP5 в этой области просто **the must**. На экзамене в лёгкую может попасться вопрос по поводу PDO, MySQLi, SQLite, транзакции, prepared statements, это должно быть как «отче наш» ,-)
Вопросы могут быть как «открытые» так «закрытые». На «Открытые» нужно отвечать в специальном поле ввода. На «Закрытые» предлагается обычно 4 варианта ответа, из них нужно выбрать указанное число верных.
Такую насущную тему как париснг XML документов тоже стороной не обошли (SimpleXML, DOM, SAX). Что касается SOAP, REST, XML-RPC, здесь по крайней мере нужно знать чем одно отличается от другого, практика желательна.
Особо «порадовало» обилие вопросов на тему потоков (streams) и сетевого программирования, раньше как-то обходил этот раздел стороной, теперь пришлось подтянуть.
Знаете чем отличается XSS от CSRF? Ну если нет, то тогда милости просим почитать спец литературу :-) Это на сертификации будет. Надо быть готовым объяснить все ньюансы применения функций **htmlentities**,**htmlspecialchars** и **strip\_tags** и т.д. и т.п. Короче секъюрности уделено не последнее место.
Само собой знание ООП и шаблонов проектирования на экзамене пригодиться, ведь в PHP5 значительно улучшили работу с объектами.
Естественно, даже если человек долгое время работает с PHP, он может и не подозревать о многих его возможностях. Поэтому чтение литературы обязательно, увы, всё самое лучшее на английском.
Постараюсь накидать необходимый перечень книг и ресурсов:
* **PHP Architects's Zend PHP 5 Certification Study Guide 2nd edition.**
* **The Zend PHP Certification Practice Test Book**
* PHPArchitect's Guide to PHP Design Patterns
* Pro PHP XML and Web Services by Robert Richards
* PHP and MySQL Web Development. Fourth Edition.
Вобщем знать нужно многое, желательно глубоко. Время вспомнить поговорку: «Тяжело в учении — легко в бою.» :-)
Вроде всё рассмотрел. Остается добавить, что сертификация по PHP это отличный шанс улучшить и привести в порядок свои знания, так что дерзайте! Каждый получает то, к чему стремиться.
UPD:
С момента опубликования, ко мне на хаброящик поступало множество вопросов, ответы на них заслуживают отдельной статьи )
Поэтому продолжение читайте на [brainreactor.ru](http://brainreactor.ru/2009/06/kak-stat-zend-php-5-certified-engineer/#more-49). Планируется цикл статей посвященных PHP сертификацци. | https://habr.com/ru/post/61215/ | null | ru | null |
# PHPixie 3.0 ORM или новый взгяд на ActiveRecord
 Уже закончен долгообещанная третья версия [PHPixie](http://phpixie.com) ORM компонента. Он теперь полностью независим от фреймворка и может спокойно использоваться сам по себе. В связи с этим, пока продолжается работа над другими компонентами и пишется документация, разработчики составили [небольшой туториал](https://github.com/PHPixie/ORM/blob/master/examples/quickstart.php) для того чтобы можно было уже начать работу с ОРМ. Ниже я предоставлю его перевод и добавлю несколько вещей от себя, но сначала давайте посмотрим чем полезным порадует нас эта версия:
* Большинство ORM используют Model классы, которые используются как для выполнения запросов так и для репрезентации самых записей в базе данных. Например так делают Kohana и Laravel. PHPixie разделила модель на Repository, Entity и Query, каждая из которых имеет строго свое предназначение.
* Кроме SQL баз данных (SQLite, PostgreSQL, MySQL) полностью поддерживается также Mongo. Вы сможете связать отношениями модели с SQL баз данных с моделями хранящимися в коллекциях Mongo.
* Чтобы поддерживать связи между разными базами ( например между таблицами в разных базах в MySQL ) много ORM используют отдельные запросы вместо join-ов и субзапросов. PHPixie же использует субзапросы всегда где это возможно.
* Поддержка встроенных сущностей в Mongo
* [На 97% покрыта юнит тестами](http://phpixie.com/coverage/orm/ORM/index.html) ( планируется 100% до конца этой недели), и еще на 75% функционалными тестами.
* Эффективное использование Query позволяет уменьшить число запросов к базе. Например вам надо связать все топики автора с какими-то тегами. В большинстве ОРМ вам придется сначала найти топики, потом теги и тогда связать их ( 3 запроса к БД ). PHPixie позволяет сделать это за один запрос. Кстати пример этого есть в туториале снизу
Надеюсь я смог вас заинтересовать, теперь посмотрим на пример с ссылки вверху в переводе:
```
php
require_once('vendor/autoload.php');
$config = new \PHPixie\Config();
//Инициализация компонента базы данных
$database = new \PHPixie\Database($config-dataStorage(array(
'default' => array(
'driver' => 'pdo',
'connection' => 'sqlite::memory:'
)
)));
//И самой ОРМ
$orm = new \PHPixie\ORM($database, $config->dataStorage(array(
'relationships' => array(
array(
//У феи может быть много цветов
'type' => 'oneToMany',
'owner' => 'fairy',
'items' => 'flower'
)
)
)));
//Создание табличек
$connection = $database->get('default');
$connection->execute('
CREATE TABLE fairies (
id INTEGER PRIMARY KEY,
name VARCHAR(255)
)
');
$connection->execute('
CREATE TABLE flowers (
id INTEGER PRIMARY KEY,
name VARCHAR(255),
fairy_id INTEGER
)
');
//Моделей больше не существует
//Их заменяют Repositories, Entities и Query
/*
Мы все ненавидим когда сущности также являются запросами:
$fairy->name = 'Trixie';
$fairy->save();
$fairy->where('name', 'Stella')->find();
*/
//Репозитории создаются автоматически для существующих табличек
$fairyRepository = $orm->get('fairy');
$flowerRepository = $orm->get('flower');
//Это все была инициализация
//А теперь приступим
//Создадим несколько фей
$trixie = $fairyRepository->create();
$trixie->name = 'Trixie';
$trixie->save();
//Версия покороче
$fairyRepository
->create(array('name' => 'Stella'))
->save();
//А еще нам понадобятся цветки
foreach(array('Red', 'Yellow', 'Green', 'Purple') as $name) {
$flowerRepository
->create(array('name' => $name))
->save();
}
//А теперь создадим Query
//аналог WHERE `id` > 1 AND ( `name` = 'Green' OR `name` = 'Red')
$green = $flowerRepository->query()
->where('id', '>', 1)
->startAndWhereGroup()
->where('name', 'Green')
->or('name', 'Red')
->endGroup()
->findOne();
//или лаконичнее
$green = $flowerRepository->query()
->where('id', '>', 1)
->and(function($q){
$q
->where('name', 'Green')
->or('name', 'Red')
})
->findOne();
//Связи
//Каждая связь добавляет свойства в Сущности и Запросы
//В нашем случае свойство 'flowers' предоставляет методы add(), remove() и removeAll()
//Это намного удобнее чем методы addFlower(), removeFlower() и removeAllFlowers() на самом объекте
$trixie->flowers->add($green);
//При связывании объектов, значение кешируется сразу в обе стороны
//чтобы избежать дополнительных запросов к базе
//В даном случае это кажется на таким уж важным, так как добиться такого эффекта
//для oneToMany достаточно просто. Но для manyToMany оно тоже будет работать
assert($green->fairy() == $trixie);
//Теперь попробуем связать все цветы кроме Green c феей Stella
//И уложиться в один запрос
//Зададим запрос который нашел бы Стеллу
$stellaQuery = $fairyRepository->query()
->where('name', 'Stella');
//И запрос который найдет цветы
$allExceptGreen = $flowerRepository->query()
->whereNot('name', 'Green');
//И теперь магия
$stellaQuery->flowers->add($allExceptGreen);
//Также Query позволяет изменять сущности без выборки
//Например переименуем цветок Purple в Blue
$flowerRepository->query()
->where('name', 'Purple')
->update(array(
'name' => 'Blue'
));
//Можно найти фею у которой есть определенный цветок:
$trixie = $fairyRepository->query()
->relatedTo('flowers', $green)
->findOne();
//А теперь найдем всех фей у которых есть хотя бы один цветок
//И сразу подгрузим все их цветки
$fairies = $fairyRepository->query()
->relatedTo('flowers')
->find(array('flowers')); //так задается прелоудинг связей
//И выведем их как простые объекты
//Удобно для json_encode()
print_r($fairies->asArray(true));
//Больше примеров потом =)
```
Попробовать этот пример у себя достаточно просто:
```
git clone https://github.com/phpixie/orm
cd orm/examples
#если у вас еще нет Композера
curl -sS https://getcomposer.org/installer | php
php composer.phar install
php quickstart.php
```
Эта ORM разрабатывалась больше года и нам очень интересны все ваши вопросы и замечания, очень ждем комментариев. | https://habr.com/ru/post/252305/ | null | ru | null |
# Динамическое создание Windows и Web CRUD-интерфейсов и не только для бизнес приложений с XAF + Entity Framework. Часть 1
У нас есть старенькое веб приложение DXLibrary для учета литературы и поиска интересных пополнений в местной библиотеке, написанное много лет назад за пару часов одним из разработчиков на DevExpress eXpressApp Framework (XAF). Данные приложения хранятся в Microsoft SQL Server, а работа с ними ведётся через DevExpress eXpress Persistent Objects ORM (XPO). Так как [сие чудо](https://habrastorage.org/files/3f2/972/5e4/3f29725e44fa4970b18b1daff639695e.png) до сих пор сносно выполняет свои незаурядные функции, мне захотелось немного освежить его интерфейс под текущие реалии. Помимо украшательства хочется сменить XPO под капотом на Microsoft ADO.NET Entity Framework (EF). Основным мотивом тут для меня является не то, что EF чем-то лучше или хуже (обе ORM давно доказали, что отлично подходят для своих задач), а то, что до сих пор на Хабре не было русскоязычного руководства по интеграции XAF и EF, хотя они уже «не первый год замужем». Есть огромное желание восполнить этот пробел + элементарно хочется реализовать несколько недавних запросов от пользователей «библиотекаря». Наконец, с версии 15.1 XAF предоставляет обновлённый веб интерфейс, адаптированный в том числе для touch-устройств, который хотелось бы лишний раз показать сообществу, что греха таить:-)
Это первая и вводная часть из серии постов, где я попытаюсь показать по шагам вариант ускоренной генерации как веб, так и настольных line-of-business (LOB) приложений по существующей базе данных (БД) либо готовой модели EF, представляющей структуру вышеописанной предметной области. Пользовательский интерфейс будет создаваться автоматически на базе микса технологий ASP.NET WebForms/HTML5 и WinForms, а также соответствующих визуальных компонент DevExpress, скомпонованных вместе в рантайм под чутким руководством XAF. XAF — это наш модульный MVC фреймворк, а, по сути, сложившийся за почти 10 лет существования и постоянно расширяемый набор best patterns & practices для быстрого создания Office-like бизнес приложений для .NET разработчиков (узнать больше на [Хабре](http://habrahabr.ru/search/?q=%5Bxaf%5D&target_type=posts), [сайте](http://www.devexpress.com/xaf)).
Минимальные требования для прохождения
--------------------------------------
1. .NET Framework 4+ и Visual Studio 2010+ (поддерживаются полные и Community Edition версии, кроме express) – далее я буду использовать Visual Studio 2013.
2. Entity Framework 6 Tools (в зависимости от версии Visual Studio могут быть уже встроенными либо требовать [отдельной установки](https://msdn.microsoft.com/en-us/data/ee712906))
3. Полная версия DevExpress Universal v15.1, либо 30-дневная пробная, которая качается с нашего сайта [бесплатно, без регистрации и СМС](https://go.devexpress.com/devexpressdownload_universaltrial.aspx):-) и ставится за пару минут на SSD. Если у вас вдруг есть доступ к [v15.2 Beta](https://www.devexpress.com/Subscriptions/New-2015.xml?product=xaf), то лучше ее и использовать.
4. Microsoft SQL Server для хранения данных (подойдут любые полные/express/localdb версии, начиная с 2000) либо [другой провайдер БД, поддерживаемый EF](https://msdn.microsoft.com/library/dd363565.aspx).
5\*. Не лишним также будет общее знакомство с EF и понимание основных принципов object-relational mapping ([ORM](https://ru.wikipedia.org/wiki/ORM)) и Model-View-Controller ([MVC](https://ru.wikipedia.org/wiki/Model-View-Controller)), лежащих в основе работы с нашим фреймворком.
**Перед тем как начать, мои размышления на тему такого рода фреймворков, возможностей кастомизации и выбора ORM**Важно понимать, что XAF, по своей сути, не является code generator, как, например, наши похожие продукты DevExpress [MVVM Framework](https://documentation.devexpress.com/#WPF/CustomDocument15112) & [Scaffolding Wizard](https://documentation.devexpress.com/#WPF/CustomDocument17425) для WPF/WinForms. Напротив, XAF является самым настоящим динамическим [application framework](https://en.wikipedia.org/wiki/Application_framework), который генерирует пользовательский интерфейс по неким правилам полностью во время исполнения. Так вам не придётся руками перезапускать генерацию форм после каждого изменения вашей исходной модели данных (таких как добавление нового класса или свойства) или терять ранее написанный в сгенерированных формах кастомный код — после запуска XAF приложения вы всегда автоматически получите актуальный результат "[scaffolding](https://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D0%B0%D1%84%D1%84%D0%BE%D0%BB%D0%B4%D0%B8%D0%BD%D0%B3)" UI и БД по вашей текущей структуре данных и набору правил. Практически это означает, что по умолчанию в XAF не генерируется никакой исходный код [CRUD](https://ru.wikipedia.org/wiki/CRUD) форм, к которому разработчик бы имел прямой доступ в Visual Studio, как это происходит в обычной разработке клиентских приложений. Хотя разработчик XAF все-таки имеет полный контроль над конечными кирпичикам UI типа System.Windows.Forms.Control или HTML элементами и может ими манипулировать как в любом другом .NET приложении, большую часть времени типовой процесс XAF разработки представляет из себя настройку системы на более высоком уровне, часто через структуры дата моделей, кросс-платформенные XML настройки UI в дизайнере или через абстракции над UI элеметами в коде. Повторюсь, что доступ на низкий уровень есть, вас никто не ограничивает, можно также миксовать подходы, но требуется это намного реже, а иначе какой тут выигрыш по сравнению с традиционной разработкой? Должен признаться, что в этом и заключается одновременно самая большая прелесть и недостаток XAF, так как поначалу людям сложно перестроиться и абстрагироваться от оперирования визуальными контролами напрямую. Отсюда и крутая кривая обучения на первых этапах.
Наверное, также сразу стоит развеять сомнения по поводу возможностей UI и кастомизации под различные нужды заказчика в такого рода RAD инструментах, как говорится, не квадратно-гнездовым единым! Чтобы лучше представить UI типовых бизнес приложений, которые могут быть созданы с помощью фреймворка, можно посмотреть готовые иллюстрации на странице продукта [тут](https://www.devexpress.com/Products/NET/Application_Framework/gallery.xml), поиграть вживую с демонстрационными приложениями [онлайн](https://www.devexpress.com/Products/NET/Application_Framework/demos.xml) (или лучше из установщика, чтобы заодно захватить и десктопные версии) и, наконец, поглядеть в Интернете примеры production приложений от реальных заказчиков, например, вот хороший [пример](https://www.devexpress.com/Home/Case-Studies/ExelixisSoftware/) или вот парочка от знакомой многим в СНГ Галактики с их AMM, CnP, EAM и др. решениями ([раз](http://www.galaktika.ru/amm/upravlenie-pozakaznym-proizvodstvom.html), [два](http://www.galaktika.ru/amm/upravlenie-serijnym-proizvodstvom.html)). Последние, кстати, вышли из «галактического» тюнинг-ателье:-) [XAFARI](http://xafari.ru/) — набора дополнительных модулей и компонет под платформу XAF. Помимо коммерческих third-party расширений, нельзя не упомянуть и бесплатный проект <http://www.expandframework.com>, который уже 5 лет развивается силами сообщества. Тут же отмечу, что во многом благодаря использованию визуальных компонент DevExpress работать с созданными приложениями вполне возможно, как и на обычном десктопе, так и на touch-устройствах с меньшим экраном, например, планшетах, при минимуме дополнительных настроек со стороны разработчика (причём даже в старом-добром [WinForms](https://documentation.devexpress.com/#WindowsForms/DevExpressXtraEditorsWindowsFormsSettings_TouchUIModetopic)!), но об этом позже.
Если у вас ещё нет готового багажа знаний какой-то ORM, то прежде чем начать работу с XAF, вы наверняка будете мучаться сложным выбором. С одной стороны, имеем дело с XPO — простой и до сих пор здравствующей проприетарной ORM библиотекой (узнать больше из русскоязычных обзоров сообщества: [раз](http://geektimes.ru/post/74009/), [два](https://uriahas.wordpress.com/2013/08/01/%d0%b2%d0%b2%d0%b5%d0%b4%d0%b5%d0%bd%d0%b8%d0%b5-%d0%b2-xpo-%d0%b8-orm/)), которая c 2006 года была единственной выбором для XAF, с огромным числом примеров, документации, видео, бесплатной гарантированной поддержкой от компании-разработчика, а с другой — [рекомендуемая](https://msdn.microsoft.com/en-us/library/ms178359(v=vs.110).aspx) open source технология для доступа к данным для .NET с б**О**льшим числом разработчиков на рынке труда, хорошим продвижением и развитием от Microsoft, поддержкой [сторонних компаний](https://msdn.microsoft.com/ru-ru/library/dd363565.aspx), а также не меньшей базой знаний и технической поддержкой силами сообщества на [StackOverFlow](http://stackoverflow.com/questions/tagged/entity-framework), [Social.MSDN](https://social.msdn.microsoft.com/Forums/en-US/home?category=dataplatformdev), [forums.asp.net](http://forums.asp.net/1227.aspx/1?ADO%20NET%20Entity%20Framework%20LINQ%20to%20SQL%20NHibernate) (правда, без гарантии быстрого ответа либо ответа вообще). Мы проводили опросы среди своих новых пользователей и оказалось, что для многих при прочих равных довольно существенным фактором при выборе технологии оказывается наличие гарантированной технической поддержки (здесь имеется ввиду помощь в случае проблем или вопросов по тому, как лучше сделать), а не то, что где-то там больше или меньше каких-то функций. Технически, если не брать во внимание факт, что формально EF поддерживается XAF позже XPO — с 2012 года, то поддержка двух библиотек на уровне самого XAF и его модулей сравнима по функционалу и охватываемым сценариям. В данный момент доля наших EF пользователей растёт, но все ещё прилично уступает XPO. Думается, релиз EF 7 и также выравнивание по наличию примеров на нашей стороне ещё изменит данное соотношение. Больше мыслей и отзывов наших пользователей на данную тему можно найти в моём [блоге по теме](http://dennisgaravsky.blogspot.com/2014/12/looking-for-practical-experiences-with.html).
**Шаги по созданию нового XAF решения с EF 6
------------------------------------------**0. [Скачаем пробную версию](https://go.devexpress.com/devexpressdownload_universaltrial.aspx) DevExpress Universal с нашего сайта, дождёмся успешной установки;
1. Откроем Visual Studio и запустим мастер создания нового проекта с именем **DXLibraryV2** через стандарное **FILE | New | Project…**, воспользовавшись поиском и выбрав **XAF Solution Wizard** (либо изначально вызвав [специальное меню](https://habrastorage.org/files/283/bdd/402/283bdd402ab44a45a589b73ac50cd87d.png): DEVEXPRESS | All Platforms | New Project...)
**(показать...)**
2. В запустившемся мастере выберем платформу **Windows** и **Web** и нажмём **Next**
**(показать...)**
3. Выберем **Entity Framework Code First** для доступа к данным и нажмём **Next****(показать...)**
4. Выберем **Authentication = Active Directory**, что означает вход в приложение по текущему Windows пользователю, и нажмём Next**(показать...)**
5. Завершим работу нажатием на **Finish**, так как пока нам не нужны больше никакие дополнительные модули**(показать...)**
Основные части созданного XAF решения
-------------------------------------
В результате мастер создаст нам заготовки для будущих приложений согласно выбранным ранее настройкам:
В двух словах, у нас получилось:
* DXLibraryV2.Module — один кросс-платформенный модуль, содержащий общий код для всех платформ (например, бизнес логика, модели данных, настройки метамодели UI, работа с базой и в редких случаях универсальные UI редакторы)
* DXLibraryV2.Module.Wxx — пара платформенно-зависимых модулей, где могут жить код и настройки, специфичные для какой-то из платформ
* DXLibraryV2.Wxx — по одному исполняемому приложению на каждую платформу, т.е. ASP.NET сайт и WinForms приложение. По умолчанию эти приложения будут соединяться с Microsoft SQL Server для хранения данных по connectionString из конфигурационных файлов приложений (Web.config и App.config).
Для удобства, проекты содержат подпапки с говорящими именами и readme.txt файлы, которые могут помочь не заблудиться новичкам ([узнать больше...](https://documentation.devexpress.com/eXpressAppFramework/CustomDocument112569.aspx)).
Если мы прямо сейчас запустим DXLibraryV2.Web и DXLibraryV2.Win из Visual Studio, то получим работающие приложения для веб браузера**\*** и Windows десктопа, которые пока ничему особенному не обучены, ну разве что кроме CRUD управления пользователями, ролями и настройками системы безопасности – эдакая простенькая админка за минуту:
**\*** Чтобы активировать новый веб стиль как на картинке выше, на момент данной публикации нужно дополнительно дописать метод [WebApplication.SwitchToNewStyle](https://documentation.devexpress.com/#eXpressAppFramework/DevExpressExpressAppWebWebApplication_SwitchToNewStyletopic) в Session\_Start. В будущем это не будет требоваться.
Дальше давайте разбираться, как получился данный базовый функционал, какие есть особенности, где тут спрятался EF и как нам его модифицировать в будущем под свои нужды.
Особенности EF интеграции
-------------------------
Прежде всего, основная поддержка EF в XAF реализована в сборках **DevExpress.ExpressApp.EF.v15.1.dll** (для .NET 4.0) и **DevExpress.ExpressApp.EF.45.v15.1.dll** (для .NET 4.5), которые автоматически ссылаются в XAF проектах в зависимости от версии .NET Framework. Если вы используете наш мастер по созданию проектов, то все необходимые EF зависимости добавляются автоматически. Если нет, то их всегда можно добавить в проекты [стандартным способом через NuGet](http://msdn.microsoft.com/en-us/data/ee712906).
На момент написания статьи последняя XAF версия поддерживает **EF 6**, охватывая как code-based стратегии c использованием **DbContext**, так и устаревшую стратегию на базе **ObjectContext** и [EntityObject](https://msdn.microsoft.com/ru-ru/library/system.data.objects.dataclasses.entityobject(v=vs.110).aspx) (в старых версиях также есть поддержка EF 5). По статистике, среди наших пользователей популярность последнего подхода к разработке модели данных сильно уступает первому, а после слухов о вероятном убиении EDMX [в следующей генерации EF](http://blogs.msdn.com/b/adonet/archive/2014/10/21/ef7-what-does-code-first-only-really-mean.aspx) думаю она вообще сойдёт на нет. Официальной поддержки последних бет EF 7 на данный момент у нас нет ввиду постоянных изменений, хотя уже ведутся работы в данном направлении. Сама по себе новая генерация EF уже сейчас содержит много интересных возможностей для нас и наших пользователей и выглядит очень перспективной.
Технически, работа с [EF Code First](http://msdn.microsoft.com/en-us/data/jj193542) подразумевает, что у нас должны быть **POCO бизнес-классы**, определяющие структуры нашей модели данных, и наследник от DbContext, содержащий необходимый набор типизированных коллекций бизнес сущностей [DbSet](https://msdn.microsoft.com/ru-ru/library/gg696460(v=vs.113).aspx), которые могут быть запрошены из базы. Вы ещё помните, что на 5м шаге мы выбрали тип аутентификации пользователей (AuthenticationActiveDirectory), тем самым активировав встроенный модуль системы безопасности (SecurityModule)? Так вот, в результате этого мастер проекта включил в нашего наследника DbContext (*DXLibraryV2.Module\BusinessObjects\DXLibraryV2DbContext.cs*) необходимые встроенные сущности User, Role (а также др. сервисные запчасти), объявленные в опциональной библиотеке [DevExpress.Persistent.BaseImpl.EF.v15.1](https://documentation.devexpress.com/#eXpressAppFramework/CustomDocument112571), идущей как часть стандартной поставки XAF и содержащей готовые классы для типовых случаев.
Вышеупомянутые сущности являются совершенно обычными POCO классами, определяющими какую-то структуру данных и логику, например:
Далее тип пользовательского DbContext либо ObjectContext (в случае EDMX стратегии) вместе с выбранной строкой соединения к базе данных, взятой из конфигурационных файлов исполняемых приложений, передаётся в **EFObjectSpaceProvider** при настройке доступа к данным в наследниках WebApplication (*DXLibraryV2.Web\WebApplication.cs*) или WinApplication (*DXLibraryV2.Win\WinApplication.cs*).
```
public partial class DXLibraryV2WindowsFormsApplication : WinApplication {
public DXLibraryV2WindowsFormsApplication() {
InitializeComponent();
}
protected override void CreateDefaultObjectSpaceProvider(CreateCustomObjectSpaceProviderEventArgs args) {
args.ObjectSpaceProvider = new EFObjectSpaceProvider(
typeof(DXLibraryV2DbContext),
TypesInfo, null,
args.ConnectionString
);
}
```
WxxApplication классы представляют из себя исполняемые приложения для каждой из платформ и связанные с ними сервисы. Их экземпляры создаются и настраиваются при каждом запуске во входных точках приложений, например в методе Session\_Start из DXLibraryV2.Web\Global.asax.cs или методе Main из DXLibraryV2.Win\Program.cs. Среди необходимых настроек приложения помимо компонентов системы безопасности и строки соединения присутствует список зависимых модулей, который может состоять как из сторонних так и из наших собственных модулей, например типа DXLibraryV2Module (*DXLibraryV2.Module\Module.cs*). XAF модули (наследники от [ModuleBase](https://documentation.devexpress.com/#eXpressAppFramework/clsDevExpressExpressAppModuleBasetopic)), как и сами приложения (наследники [XafApplication](https://documentation.devexpress.com/eXpressAppFramework/clsDevExpressExpressAppXafApplicationtopic.aspx)) являются настраиваемыми производными от [System.ComponentModel.Component](https://msdn.microsoft.com/ru-ru/library/system.componentmodel.component(v=vs.110).aspx), для которых также доступны визуальные дизайнеры.
Специально для первого запуска приложений мастером был закодирован тестовый набор данных в методе UpdateDatabaseAfterUpdateSchema наследника [ModuleUpdater](https://documentation.devexpress.com/#eXpressAppFramework/clsDevExpressExpressAppUpdatingModuleUpdatertopic) (*DXLibraryV2.Module\DatabaseUpdate\Updater.cs*) — аналога метода Seed у EFских [database initializerов](http://www.codeguru.com/csharp/article.php/c19999/Understanding-Database-Initializers-in-Entity-Framework-Code-First.htm).
В результате отработки методов ModuleUpdater-ов и связанного кода фреймворком была создана новая база данных на Microsoft SQL Server и соответствующие таблицы с записями:
EFObjectSpaceProvider независимо от выбора code-based или EDMX стратегий работает с ObjectContext API, являющимся для них общим знаменателем, ведь внутри DbContext в EF 6 пока ещё содержит в себе ObjectContext, доступ к которому можно получить через приведение к [IObjectContextAdapter](https://msdn.microsoft.com/ru-ru/library/system.data.entity.infrastructure.iobjectcontextadapter(v=vs.113).aspx). В частности, мы используем его MetadataWorkspace для рефлексии информации о типах и их структуре для дальнейшего построения скелета CRUD пользовательского интерфейса.
Как вы могли заметить из примера кода в ModuleUpdater выше, в контексте XAF CRUD операции рекомендуется производить не напрямую через DbContext/ObjectContext, а через эту абстрактную сущность [IObjectSpace](https://documentation.devexpress.com/#eXpressAppFramework/CustomDocument113707) или в нашем случае её конкретную реализацию для EF — **EFObjectSpace**. Он поставляется вышеупомянутым EFObjectSpaceProvider и использует у себя внутри [ObjectStateManager](https://msdn.microsoft.com/ru-ru/library/system.data.objects.objectstatemanager(v=vs.110).aspx) и [CreateQuery](https://msdn.microsoft.com/ru-ru/library/system.data.objects.objectquery(v=vs.110).aspx) API, чтобы модифицировать или считывать данные. IObjectSpace, по сути, является ORM-независимым воплощением [паттернов Repository и Unit Of Work](http://www.codeproject.com/Articles/770156/Understanding-Repository-and-Unit-of-Work-Pattern), а технически просто оберткой над контекстом данных. Работая через [IObjectSpace API](https://documentation.devexpress.com/#eXpressAppFramework/CustomDocument113711), вы можете раз написав какую-то бизнес логику, мигрировать её на другую ORM без изменений. Более важно, что посредством IObjectSpace интерфейсная часть XAF взаимодействует с данными, например, получает их или «слушает» изменения и обновляет себя соответственно.
Практические заметки на будущее
-------------------------------
**1.** Во время разработки и отладки приложения с тестовой БД после постоянных правок структуры дата модельных классов удобно временно отключать [Code First Migrations фичу ЕF](https://msdn.microsoft.com/data/jj591621.aspx), прописывая нужный [database initializer](http://www.codeguru.com/csharp/article.php/c19999/Understanding-Database-Initializers-in-Entity-Framework-Code-First.htm) с помощью встроенного API из System.Data.Entity, например вот так (DXLibraryV2.Module\Module.cs):
```
// Uncomment this code to delete and recreate the database each time the data model has changed.
// Do not use this code in a production environment to avoid data loss.
// #if DEBUG
// Database.SetInitializer(new DropCreateDatabaseIfModelChanges());
// #endif
```
**2.** Совсем не обязательно использовать встроенные классы User, Role из DevExpress.Persistent.BaseImpl.EF.v15.1– это в основном нужно новичкам для быстрого старта. XAF не является конечным продуктом и, в первую очередь — это гибкий и расширяемый \*фреймворк\* для построения приложений, в котором можно всегда заменить нужные запчасти на свои либо начать делать всё «с нуля», если уже знаешь, что да как. Так, например, вместо встроенных запчастей системы безопасности мы могли запросто объявить свои сущности согласно EF документации и добавить их в наш DbContext.
**3.** Для нормальной работы многих стандартных сценариев желательно реализовывать поддержку INotifyPropertyChanged в ваших бизнес классах (хоть вручную, хоть с помощью утилит [типа этой](https://github.com/Fody/PropertyChanged), которые автоматически вставляют нужную реализацию во время компиляции). Ещё, как вариант, можно реализовать наш специальный интерфейс [IObjectSpaceLink](https://documentation.devexpress.com/#eXpressAppFramework/clsDevExpressExpressAppIObjectSpaceLinktopic) и руками звать ObjectSpace.SetModified(this), чтобы вызвать уведомление об изменении в нужных местах.
**4.** Из опыта, клиенты могут (и хотят) размещать бизнес логику прямо в самих EF классах вместо реализации отдельных контроллеров или сервисов. Не в нашем праве им запрещать (хотя на тему анемичной модели vs богатой [на StackOverFlow куча холиваров](http://stackoverflow.com/search?q=anemic+domain+model), помню даже сам вбросил свои пять копеек [тут](http://stackoverflow.com/questions/4834918/objectcontext-aware-entity-in-ef-to-avoid-anemic-domain-model/28178827#28178827)) и для таких случаев помимо вышеупомянутого IObjectSpaceLink может быть удобен интерфейс [IXafEntityObject](https://documentation.devexpress.com/#eXpressAppFramework/clsDevExpressExpressAppIXafEntityObjecttopic), который облегчает написание логики на создании (OnCreated), загрузке (OnLoaded) и сохранении сущностей (OnSaving).
**5.** Если у вас осталась готовая библиотека EF классов от ASP.NET MVC проекта, вам может быть важно знать, что в данный момент у нас ограниченная поддержка стандартных [Data Annotations](https://msdn.microsoft.com/ru-ru/library/system.componentmodel.dataannotations(v=vs.110).aspx) атрибутов, влияющих на вид интерфейса, например DisplayFormat, UIHint. При этом стандартные атрибуты из EntityFramework.dll, System.ComponentModel.DataAnnotations.dll и других системных сборок, влияющие на поведение самого EF, работают как и должны, например StringLength, NotMapped, ComplexType. Как бы там ни было, в XAF есть [куча своих универсальных атрибутов](https://documentation.devexpress.com/#eXpressAppFramework/CustomDocument112701) на любой вкус и цвет, которые позволяют ускорить настройку UI и связанной логики в простых случаях. Забегая вперед, стоит отметить, что, в общем, для такой задачи предпочтительнее использовать Application Model ([вот тут](http://habrahabr.ru/company/devexpress/blog/153755/) уже рассказывал детальнее).
В заключение
------------
Это, наверное, все основные особенности интеграции EF в XAF, о которых нужно знать на данном этапе. Углубить своё понимание можно с помощью нашей онлайн документации тут: [eXpressApp Framework](https://documentation.devexpress.com/eXpressAppFramework/CustomDocument112670.aspx) > [Concepts](https://documentation.devexpress.com/eXpressAppFramework/CustomDocument112683.aspx) > [Business Model Design](https://documentation.devexpress.com/eXpressAppFramework/CustomDocument113461.aspx) > [Business Model Design with Entity Framework](https://documentation.devexpress.com/eXpressAppFramework/CustomDocument113462.aspx) и [eXpressApp Framework > Getting Started > Basic Tutorial](https://documentation.devexpress.com/#eXpressAppFramework/CustomDocument113496) (тут также содержится информация о фреймворке и основных подходах в общем). Также могут пригодиться демки XCRM, EFDemoCodeFirst, EFDemoModelFirst, которые можно найти в *%Public%\Documents\DevExpress Demos 15.1\Components\eXpressApp Framework\* и которые представляют из себя довольно сложные и законченные приложения, демонстрирующие интеграцию почти со всеми модулями фреймворка. Куча примеров и ответов [в базе знаний техподдержки](https://search.devexpress.com/?q=entity%20framework&m=Documentation) также не будет лишней к упоминанию.
В следующей серии мы будем непосредственно создавать модель данных EF по существующей базе данных и также реализовывать основную логику работы исходного приложения-прототипа.
C уважением,
Денис
P.S.
----
Если вас заинтересовали наши продукты и после их более подробного изучения в течение бесплатного пробного периода вам захочется их приoбрeсти, то до 20 декабря 2015 года включительно вы можете воспользоваться дeсяти пpoцeнтным кyпонoм на пoкyпку в рyблях (~$220 или ~14тыc рyблeй по текущему курсу) новой лицензии DevExpress Universal, включающей в себя [XAF и кучу других инструментов](https://www.devexpress.com/Subscriptions/) для разработки под популярные платформы. Для этого вам нужно будет [перейти в мaгaзин Softline.ru](http://store.softline.ru/developer-express-inc/universal-subscription/) и после оформления зaкaза
**ввeсти в специальное поле кoд**Universal\_XafEf
Отдельное спасибо нашему рeceллеру за то, что достаточно быстро удалось договориться об этой aкции на благо русскоязычного сообщества СНГ в такое время. Если вам вдруг удобнее кyпить в вaлюте [напрямую с нашего сайта](https://www.devexpress.com/Subscriptions/buy.xml), то для получения аналогичной cкидки, напишите [мне на почту](mailto:dennis@devexpress.com) с указанием ссылки на этот пост. Туда же можете присылать любые вопросы по XAF, пожелания или информировать о возможных проблемах. | https://habr.com/ru/post/271331/ | null | ru | null |
# Как работает ViewEncapsulation и ng-deep в Angular
*Перевод (а точнее оригинал) моей статьи опубликованной* [*здесь*](https://dev.to/mprojs/how-viewencapsulation-and-ng-deep-work-in-angular-5gm1)
Многие Angular разработчики и верстальщики, пишущие CSS/SCSS код в Angular-приложениях сталкивались с ситуацией, когда надо применить стили к компоненту вложенному в текущий и не до конца разобравшись как это работает, выключали инкапсуляцию стилей или добавляли ng-deep, при этом не учитывая некоторых нюансов, что в последствии приводит к проблемам. В данной статье я попытаюсь максимально просто и сжато изложить все детали.
Когда у компонента включена инкапсуляция стилей (по умолчанию она включена и в большинстве случаев стоит оставить ее включенной), стили содержащиеся в файле\файлах стилей компонента будут применяться только к элементам этого компонента. Это очень удобно, вам не нужно следить за уникальностью селекторов, не нужно использовать БЭМ или придумывать длинные имена классов и следить за их уникальностью, хотя вы по-прежнему можете это делать, если хотите. Во время компиляции проекта Angular сам добавит к каждому элементу уникальный атрибут, например, `_ngcontent-ool-c142` и заменит ваш класс `.my-class` на `.my-class[_ngcontent-ool-c142]` (это в случае `ViewEncapsulation.Emulated`, которая включена по умолчанию, если вы укажете `ViewEncapsulation.ShadowDom`, поведение будет другое, но результат тот же).
Теперь давайте представим, что у нас есть компонент `ComponentA`
```
Check me
```
в который вложен mat-checkbox из Angular material (это может быть и ваш собственный компонент, не обязательно компоненты из библиотек).
Внутри компонента mat-checkbox есть label,
```
...
```
к которому мы хотим добавить border. Если мы напишем в файле стилей компонента
```
mat-checkbox label {
border: 1px solid #aabbcc;
}
```
то после применения `ViewEncapsulation.Emulated` селектор будет примерно таким
```
mat-checkbox[_ngcontent-uiq-c101] label[_ngcontent-uiq-c101] {
border: 1px solid #aabbcc;
}
```
т. е. border применится к label с атрибутом `_ngcontent-uiq-c101`, но у всех дочерних элементов внутри mat-checkbox будет другой атрибут, т. к. label находится внутри другого компонента, и у него либо будет атрибут с другим ID (id компонента mat-checkbox), либо его не будет вообще, если у компонента в свою очередь отключена инкапсуляция. В данном случае атрибута не будет совсем, т. к. у mat-checkbox как и у других компонентов из Angular Material `ViewEncapsulation.None`.
Таким образом стили, ограниченные атрибутом компонента `ComponentA` применяются только к элементам находящемся непосредственно внутри этого компонента. Если в компоненте находится другой компонент, то на его элементы эти стили уже не распространяются.
Если вам интересно, как именно работает Emulated инкапсуляция в Angular, вы можете найти множество подробных статей на эту тему, здесь же я приведу очень краткое описание, чтобы не раздувать статью. Итак, если у компонента есть инкапсуляция, то к самому компоненту добавится атрибут `_nghost-ID`, а к каждому вложенному элементу добавится атрибут `_ngcontent-ID` и ко всем стилям в этом компоненте в селектор добавится `[_ngcontent-ID]`. Таким образом все стили будут применяться ТОЛЬКО к элементам расположенным непосредственно внутри этого компонента.
Как же быть если нам надо применить стили к элементам внутри вложенного компонента (т. е. в нашем примере к label внутри mat-checkbox)
Для того чтобы применить стили, у нас есть три варианта:
* отключить инкапсуляцию стилей в `ComponentA`
* использовать ng-deep
* поместить css код в глобальные стили, т.е. стили в styles.(s)css или в других файлах указанных в секции styles в angular.json
Давайте рассмотрим их подробнее
Отключение инкапсуляции
-----------------------
В этом случае все стили внутри компонента станут «глобальными», причем это произойдет только после того, как компонент будет создан, т. е. после того как пользователь посетил тот раздел приложения, где используется данный компонент, что сильно затрудняет выявление данной проблемы. Давайте отключим инкапсуляцию стилей у нашего компонента
```
@Component({
selector: 'app-component-a',
templateUrl: './component-a.component.html',
styleUrls: ['./component-a.component.scss'],
encapsulation: ViewEncapsulation.None
})
```
вспомним, что в файле стилей у нас
```
mat-checkbox label {
border: 1px solid #aabbcc;
}
```
до тех пор пока пользователь не открыл страницу, где используется компонент `ComponentА`, все остальные mat- checkbox в приложении выглядят без рамки, но после того, как `ComponentА` создан, css код приведенный выше динамически добавится в секцию | https://habr.com/ru/post/665040/ | null | ru | null |
# Сказ о том как я свой REST фреймворк с веб-сокетами писал
Эта статья посвящена очередному REST фреймворку (для Python 3), особенностью которого является использование веб-сокетов для обмена данными между клиентом и сервером. О том откуда пришла идея, с чем мне пришлось столкнулся при написании своей первой библиотеки для Python и что из этого в итоге получилось, я расскажу далее.
Для тех, кому интересна эта статья — пожалуйста, заходите под кат.
### 1. Идея проекта
Идея зародилась примерно в середине Апреле 2015, когда я задержался с коллегой на работе, с которым мы числимся на одном проекте в своей конторе. Чтобы как-то минимально себя развлечь, пока занимались непосредственно программированием, мы решили поговорить о различных интересных питоновских проектах. В процессе общения как-то спонтанно подошли к теме о собственных проектах и того, что можно было бы интересно использовать далее в своих проектах (не обязательно связанных с работой). При обсуждении непосредственно и возникла идея того, что было бы классно иметь достаточно «гибкий» фреймворк, который использует веб-сокеты, через которые можно передавать данные в обе стороны без каких-либо проблем. Каждый запрос приходит в JSON формате и содержит некоторые заголовки, которые привычны при использовании REST и HTTP протокола. И в качестве приятного дополнения предоставляет возможность передачи уведомлений (нотификаций) со стороны сервера клиенту из коробки по какому-то событию/тайм-ауту.
Естественно после столь продолжительного обсуждения я решился воплотить эту идею в жизнь (а почему бы и да?). Собственный интерес, энтузиазм и желание сделать что-нибудь полезное для развития экосистемы третьего Python'а только давало лишнюю мотивацию побыстрее приступить к делу.
### 2. Постановка целей
Для себя, лично, я выделил еще несколько дополнительных моментов, на которых было также решено сосредоточить собственные усилия при написании библиотеки, кроме того, что бы упомянуто ранее:
* Постараться использовать asyncio при обработке клиентских запросов
* Не более 1-2 зависимых модулей (чем меньше, тем лучше)
* Не должна быть слишком сложной для понимания
* Легкость в использовании (см. фреймворки Django REST, Flask, которые достаточно простые и гибкие)
* Программист может заменить практически любой компонент, тогда, когда ему это необходимо
Естественно, выпустить в первой же версии все вышеупомянутое для меня было совсем чем-то нереальным, поскольку из процесса разработки я просто бы не выходил, поэтому в целях небольшого упрощения было принято решение разбить все на небольшие «кусочки». Их сделать, протестировать, пустить в релиз, а затем уже делать по аналогичной схеме все оставшееся. Сначала пишем то, что является наиболее критичным для библиотеки (роутинг, вьюхи, аутентификация, и т.д.), а позднее, по мере возможностей, добавляем новый функционал.
### 3. Подготовка к разработке: выбор между Aiohttp vs Gevent vs Autobahn.ws
Разработка началась примерно в конце Апреля 2015. Чтобы как-то облегчить себе работу при реализации проекта, начались поиски каких-либо уже готовых решений (или уже существующих библиотек, о которых ранее не предполагал). Библиотек, которые бы имели схожую идею с моей или хотя бы минимально имели из коробки то, что предполагается сделать – не нашлось. Это привело к усложнению задачи, поскольку большую часть необходимых компонентов потребуется написать самостоятельно, исходя из собственного понимания всех происходящих процессов.
Я решил начать непосредственно с библиотек, которые дают возможность использовать веб-сокеты. На тот момент времени было найдено несколько таких пакетов: aiohttp, gevent и autobahn.ws. У каждой библиотеки есть свои достоинства и недостатки, но, в первую очередь, я исходил из их возможностей и возможного дальнейшего переиспользования кода, чтобы не приходилось в очередной раз городить свои велосипеды, особенно там, где это не нужно.
Aiohttp – библиотека для веб-разработки, базирующая на стандартной библиотеке asyncio и разработанная [svetlov](https://habrahabr.ru/users/svetlov/). Не сказать, что у меня был какой-то большой реальный опыт использования этой библиотеки, хотя стоит отметить, что сделано множество вещей очень классно. Однако, предлагаемое решение с веб-сокетами показалось мне несколько низкоуровневым (хотя, в ряде случаев это действительно может быть удобно). Хотелось какого-то большего уровня абстракции (например, как в gevent-websocket или autobahn.ws, где в клиенте/сервере есть методы вроде onMessage и sendMessage, столь похожие на методы из событийно-ориентированного фреймворка Twisted). В остальном же – библиотека прекрасна.
Gevent при первом рассмотрении был одним из тех первых пакетов, на которые было заострено внимания. И также быстро идея о использовании её была отклонена: на момент времени начала проекта (Апрель 2015) gevent не был портирован под третью ветку языка Python. Хотя, если бы все же она была портирована, то я использовал бы именно её, взяв при этом еще расширение gevent-websocket и все могло бы выйти очень даже неплохо. На момент написания статьи данная библиотека уже имеет поддержку третьей ветки, но переходить на нее сейчас я не вижу никакого смысла.
Autobahn.ws – это та библиотека, с которой мне уже ранее приходилось неоднократно сталкиваться при написании своих небольших pet-проектов и с которой у меня уже имеется некий минимальный опыт использования. Достаточно неплохое коммьюнити, плюс автор библиотеки всегда готов помочь в случае возникших проблем (например, когда у меня не получалось совместить ее с Twisted + wxPython, Тобиас очень хорошо объяснил мне как это можно сделать). Последние версии совместимы с asyncio, достаточно добавить декораторы в требуемых местах. Приятной особенностью еще было соответствие документу [RFC6455](http://tools.ietf.org/html/rfc6455) и наличие проверки входящих/исходящих данных (поступили/отправлены ли они в UTF-8 кодировке, что я считаю достаточно удобно). Поэтому было принято решение использовать именно её в качестве основы для будущей библиотеки.
### 4. Проблемы, возникшие при разработке
При написании первой версии библиотеки я просто не знал как подступиться к решению ряда задач. После непродолжительных размышлений я решил просто идти при реализации по пути того, как сервер обрабатывал бы поступивший запрос от клиента, вроде:
1) Получили запрос
2) Проверили что пришли необходимые данные, на основе которых станет понятно каким образом обработать запрос (тип операции, куда обращаемся, и т.д.)
3) Ищем обработчик, соответствующий поступившему запросу (конкретную точку входа и метод, который будет вызываться). Если ничего не нашли – возвращаем ошибку. Если же все отлично, то выбираем соответствующий обработчик и в него передаем полученные аргументы
4) Сформированный ответ привели к определенному формату (JSON, XML, и т.д.)
5) Вернули ответ клиенту
В теории все звучит довольно просто, на деле все оказалось все в точности наоборот. Единственное, что мне приходило в голову, это идти от высокого уровня абстракции к нижним. То есть я шел следующим образом, когда мы работаем с Autobahn.ws и asyncio loop:
1) Создаем экземпляр «фабрики», который будет использовать asyncio loop и принимать входящие подключения и обслуживать их. После выполненного «процесса рукопожатия» мы готовы получать запросы от клиента и выполнять их обработку.
2) Получили запрос от клиента в определенном формате. В нашем случае мы будем получать его в виде JSON следующим образом:
```
{
'method': 'POST',
'url': '/users/create',
'args': {
'token': 'aGFicmFoYWJyX2FkbWlu'
},
'data': {
'username': 'habrahabr',
'password': 'mysupersecretpassword',
}
}
```
Этот JSON имеет достаточно простую структуру. Клиент достаточно определить несколько важных для нас параметров:
* method – тип операции над ресурсом (подобно тому, как это сделано в HTTP).
* url – путь к ресурсу, с которым хотим работать.
* args (опционально) – набор параметров, отсылаемых серверу. Наиболее близкая аналогия это определяемые параметры в URL'е HTTP запроса с помощью "?" и "&" символов, вроде «[habrahabr.ru/?page=2&paginate\_by=25](http://habrahabr.ru/?page=2&paginate_by=25)». Это может быть какой-то список готовых данных (например, идентификаторы пользователей, которым надо назначить определенную группу) или просто набор аргументов для каких-либо фильтров, используемых на стороне сервера в процессе обработки запроса.
* data (опционально) – набор данных, используемых при работе с ресурсом. В целом, можете считать, что это некий аналог телу HTTP запроса.
* event\_name (опционально) — некий уникальный идентификатор, с помощью которого можно понять от какого endpoint'а вернулись данные.
Примерно такого вида запросы будет ожидать получить наш сервер. Если какого-либо из обязательных аргументов нету – говорим об этом сразу (например, забыли добавить method). В противном случае идем далее по нашему списку.
3) Итак, запрос доставлен серверу, он правильном формате и корректен. Теперь мы хотим его обработать соответствующим образом и вернуть ответ. Однако, что нам для этого необходимо? С моей точки зрения, на первое время будет достаточно наличие системы роутинга, позволяющей зарегистрировать на определенный URL требуемый обработчик, который бы формировал соответствующий ответ, преобразовывал его в JSON, XML (или любой другой формат) и возвращал его клиенту.
В этом пункте хочу я обратить ваше внимание на роутинг. Это достаточно важный момент, поскольку нам хотелось бы предоставлять доступ по некоторому фиксированному URL, чтобы получать, например, список текущих пользователей (вроде "/users/"). С другой стороны получать доступ и по URL имеющих вид "/users//", по которым требуется получать детальную информацию о пользователе. То есть роутинг первого вида мы будем рассматривать как простой, статический, а второй – как динамический, поскольку в пути к ресурсу присутствует параметр, меняющийся от запроса к запросу.
Для решения этой задачи нам помогут регулярные выражения. Каждый раз, когда объявляется путь к ресурсу, например:
```
router = SimpleRouter()
router.register('/auth/login', LogIn, 'POST')
router.register('/users/{pk}', UserDetail, ['GET', 'PATCH'])
```
Мы будем выполнять анализ пути к такому ресурсу. И создавать endpoint, который будет обрабатывать запросы только определенного типа и только по указанному пути. Когда придет запрос на этот ресурс, нам будет достаточно пройтись по словарю, где ключом будет путь, а значением – обработчик. В случае, если обнаружен динамический путь, в момент получения запроса, и мы нашли требуемый обработчик, то будем пробрасывать обнаруженный динамический параметр в место обработки запроса, чтобы было возможным получить объект по ключу либо сделать какую-то иную операцию с использованием этого параметра.
Ну и конечно же учитываем случай, когда приходит запрос на несуществующий URL. Для него достаточно будет вернуть ошибку с определенным описанием.
4) Здорово, теперь кое что прояснилось. Умеем находить требуемые пути, обработчики для них, а с помощью регулярок находить и пробрасывать параметры (для случая если попался динамический путь). Далее мы смотрим на параметр method, указанный в JSON и стараемся найти соответствующий метод класса с вьюшки. Если он отсутствует – говорим об этом сразу и не выполняем каких-либо операций. В противном случае делаем вызов обнаруженного метода и формируем ответ.
5) Далее выполняем сериализацию данных (в том числе и для случаев с ошибками) в некоторый формат. По умолчанию все преобразуется в JSON формат.
6) Передаем сформированный ответ клиенту обратно по веб-сокету.
И вот по этому примерному плану я следовал до релиза 1.0. Было достаточно интересно написать свои вьюшки, систему роутинга и прочий интересный функционал. Хотя в процессе написания первого релиза, по ходу развития этого pet-проекта, потребовались модули с конфигурациями (в нашем случае это был модуль аналогичный тому, что есть в Django). Или, например, столь необходимая мне аутентификация медленно привела к реализации поддержки middleware и JSON Web Token модулей. Как и упоминалось ранее – делаем всевозможные модули самостоятельно, не стараемся тянуть что-то лишнее.
Так или иначе, написание «очередного велосипеда» для меня выливалось в дополнительные усилия и затраты по времени. Хотя, честно говоря, я совсем не жалею, что пошел таким путем, поскольку время затраченное на написание, отладку и регулярные доделки дает о себе знать: сейчас стал немного лучше понимать, как это вообще работает.
Если при написании первой версии написание кода и его отладка шла достаточно неплохо, то при реализации версии 1.1 я просто надолго повяз в отладке. Написание и портирование кода не занимало столь много времени, сколько поиск и детальный анализ того что происходит, например:
1) Анализ исходной кодовой базы Django REST фреймворка на предмет того, что и как происходит «под капотом»: что делаем когда хотим записать или прочитать определенный объект; когда и каким образом понимаем, что за поля были получены (и имеют ли они вообще какие-то связи с другими моделями) и во что требуется их сериализовать/десериализовать.
2) Сериализация моделей SQLAlchemy по аналогии с тем, как это происходит между Django REST кодом и Django ORM.
3) Иметь такую возможность работы с роутингом, чтобы можно было получить путь до некоторого объекта через уже написанный API (так, чтобы можно было и прочитать, и записать какие-то данные по полученным URL).
При разработке этой части функционала мне весьма сильно помогли исходные коды библиотеки как Django REST (которая во многом являлась основой для следующей версии), так и исходники SQLAlchemy + marshmallow-sqlalchemy библиотек, которые во многом помогли воплотить все задумки в жизнь.
Хоть и было затрачено очень много ресурсов, но конечный результат полностью оправдал все затраты – теперь мы имеем возможность работать с SQLAlchemy так, как мы привыкли это делать в Django REST. Работа с данными осуществляется одинаково и практически не имеет сильных отличий. Здорово, даже практически переучиваться нет необходимости: доступный API во многом идентичен тому, что используется в Django REST.
### 5. Текущее состояние проекта
На текущий момент времени библиотека предоставляет следующие возможности:
* Роутинг
* Поддержка function- и class-based вьюшек
* Аутентификация через JSON Web Token (хоть и немного ограничено)
* Поддержка файла с конфигурацией, подобной той, что есть в Django Framework
* Сжатие передаваемых сообщений (если поддерживается браузером и установлено нужное расширение)
* Сериализация моделей Django и SQLAlchemy ORM
* Поддержка SSL
### 6. Пример использования
В качестве краткого примера можно привести следующий код, где будет происходить работа с пользователями и email адресами. Начнем таблиц, описанных с помощью SQLAlchemy ORM:
```
# -*- coding: utf-8 -*-
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey
from sqlalchemy.orm import relationship, validates
Base = declarative_base()
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String(50), unique=True)
fullname = Column(String(50), default='Unknown')
password = Column(String(512))
addresses = relationship("Address", back_populates="user")
@validates('name')
def validate_name(self, key, name):
assert '@' not in name
return name
def __repr__(self):
return "" % (self.name, self.fullname, self.password)
class Address(Base):
\_\_tablename\_\_ = 'addresses'
id = Column(Integer, primary\_key=True)
email\_address = Column(String, nullable=False)
user\_id = Column(Integer, ForeignKey('users.id'))
user = relationship("User", back\_populates="addresses")
def \_\_repr\_\_(self):
return "" % self.email\_address
```
Теперь опишем соответствующие сериализаторы для этих двух моделей:
```
# -*- coding: utf-8 -*-
from app.db import User, Address
from aiorest_ws.db.orm.sqlalchemy import serializers
from sqlalchemy.orm import Query
class AddressSerializer(serializers.ModelSerializer):
class Meta:
model = Address
fields = ('id', 'email_address')
class UserSerializer(serializers.ModelSerializer):
addresses = serializers.PrimaryKeyRelatedField(queryset=Query(Address), many=True, required=False)
class Meta:
model = User
```
Как многие из успели заметить, в месте, где мы определили класс для сериализации пользователей, указано поле addresses, с аргументом queryset=Query(Address) в конструкторе класса PrimaryKeyRelatedField. Это сделано для того, чтобы сериализатор для SQLAlchemy ORM мог выстроить связь между полем addresses и таблицей, передавая в этот класс при сериализации первичные ключи. В какой-то степени это аналогично QuerySet из Django фреймворка.
Теперь реализуем вьюшки, позволяющие через некоторый доступный API работать с данными в этих таблицах:
```
# -*- coding: utf-8 -*-
from aiorest_ws.conf import settings
from aiorest_ws.db.orm.exceptions import ValidationError
from aiorest_ws.views import MethodBasedView
from app.db import User
from app.serializers import AddressSerializer, UserSerializer
class UserListView(MethodBasedView):
def get(self, request, *args, **kwargs):
session = settings.SQLALCHEMY_SESSION()
users = session.query(User).all()
data = UserSerializer(users, many=True).data
session.close()
return data
def post(self, request, *args, **kwargs):
if not request.data:
raise ValidationError('You must provide arguments for create.')
if not isinstance(request.data, list):
raise ValidationError('You must provide a list of objects.')
serializer = UserSerializer(data=request.data, many=True)
serializer.is_valid(raise_exception=True)
serializer.save()
return serializer.data
class UserView(MethodBasedView):
def get(self, request, id, *args, **kwargs):
session = settings.SQLALCHEMY_SESSION()
instance = session.query(User).filter(User.id == id).first()
data = UserSerializer(instance).data
session.close()
return data
def put(self, request, id, *args, **kwargs):
if not request.data:
raise ValidationError('You must provide an updated instance.')
session = settings.SQLALCHEMY_SESSION()
instance = session.query(User).filter(User.id == id).first()
if not instance:
raise ValidationError('Object does not exist.')
serializer = UserSerializer(instance, data=request.data, partial=True)
serializer.is_valid(raise_exception=True)
serializer.save()
session.close()
return serializer.data
class CreateUserView(MethodBasedView):
def post(self, request, *args, **kwargs):
serializer = UserSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return serializer.data
class AddressView(MethodBasedView):
def get(self, request, id, *args, **kwargs):
session = settings.SQLALCHEMY_SESSION()
instance = session.query(User).filter(User.id == id).first()
session.close()
return AddressSerializer(instance).data
class CreateAddressView(MethodBasedView):
def post(self, request, *args, **kwargs):
serializer = AddressSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
session.close()
return serializer.data
```
На текущий момент времени мы пишем отдельно вьюшки для работы с объектами и отдельно со списком объектов. В каждом из таких подклассов, унаследованных от MethodBasedView, реализуются конкретные обработчики, которые будут использоваться. Для каждого типа запроса (get/post/put/patch/ и т.п.) пишется свой обработчик.
Последним шагом является регистрация этого API, и чтобы он был доступен нам извне:
```
# -*- coding: utf-8 -*-
from aiorest_ws.routers import SimpleRouter
from app.views import UserListView, UserView, CreateUserView, AddressView, \
CreateAddressView
router = SimpleRouter()
router.register('/user/list', UserListView, 'GET')
router.register('/user/{id}', UserView, ['GET', 'PUT'], name='user-detail')
router.register('/user/', CreateUserView, ['POST'])
router.register('/address/{id}', AddressView, ['GET', 'PUT'], name='address-detail')
router.register('/address/', CreateAddressView, ['POST'])
```
Вообщем-то здесь все готово, остается только запустить сервер и подключиться через какой-нибудь клиент (Python + Autobahn.ws, используя JavaScript, и так далее, вариантов множество). Для примера я просто покажу парочку простых запросов с использованием Python + Authobahn.ws (оговорюсь заранее, пример с клиентом не идеален, здесь задача просто продемонстировать как мы можем это делать):
```
# -*- coding: utf-8 -*-
import asyncio
import json
from hashlib import sha256
from autobahn.asyncio.websocket import WebSocketClientProtocol, \
WebSocketClientFactory
def hash_password(password):
return sha256(password.encode('utf-8')).hexdigest()
class HelloClientProtocol(WebSocketClientProtocol):
def onOpen(self):
# Create new address
request = {
'method': 'POST',
'url': '/address/',
'data': {
"email_address": 'some_address@google.com'
},
'event_name': 'create-address'
}
self.sendMessage(json.dumps(request).encode('utf8'))
# Get users list
request = {
'method': 'GET',
'url': '/user/list/',
'event_name': 'get-user-list'
}
self.sendMessage(json.dumps(request).encode('utf8'))
# Create new user with address
request = {
'method': 'POST',
'url': '/user/',
'data': {
'name': 'Neyton',
'fullname': 'Neyton Drake',
'password': hash_password('123456'),
'addresses': [{"id": 1}, ]
},
'event_name': 'create-user'
}
self.sendMessage(json.dumps(request).encode('utf8'))
# Trying to create new user with same info, but we have taken an error
self.sendMessage(json.dumps(request).encode('utf8'))
# Update existing object
request = {
'method': 'PUT',
'url': '/user/6/',
'data': {
'fullname': 'Definitely not Neyton Drake',
'addresses': [{"id": 1}, {"id": 2}]
},
'event_name': 'partial-update-user'
}
self.sendMessage(json.dumps(request).encode('utf8'))
def onMessage(self, payload, isBinary):
print("Result: {0}".format(payload.decode('utf8')))
if __name__ == '__main__':
factory = WebSocketClientFactory("ws://localhost:8080")
factory.protocol = HelloClientProtocol
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, '127.0.0.1', 8080)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
```
Более детально посмотреть весь исходный код примера можно [здесь](https://github.com/Relrin/aiorest-ws/tree/master/examples/sqlalchemy_orm).
### 7. Дальнейшее развитие
Есть достаточно много идей как расширить текущий функционал библиотеки. Например, можно развивать данный модуль в следующих направлениях:
* Поддержка уведомлений
* Просмотр через браузер документации к API (возможно в виде плагина для Swagger)
* Модули для тестирования API
* Клиенты для Python и JavaScript
* Поддержка Pony и Peewee ORM'ов
Опять же напомню, что многие фичи запланированы на разные релизы, а не на один. Сделано это специально, чтобы не кидаться из крайности в крайность, делая что-то параллельно, ведь по итогу ничего годного из этого не выйдет. И мне проще, и вам.
### 8. И в заключении...
Мне кажется получилось достаточно неплохо для первого раза, не смотря на отсутствие какого-либо опыта в написании собственных библиотек. А внести свой вклад (пусть даже и небольшой) в развитие языка Python – хочется достаточно сильно. Не удивляйтесь тому, сколько времени было на это было затрачено: все делалось (и продолжает делаться) в свободное время и периодическими перерывами (поскольку регулярная работа с одним проектом очень утомляет, а развиваться хочется в нескольких направлениях одновременно).
Так или иначе, буду рад услышать все ваши предложения, идеи и улучшения по данной библиотеке в комментариях (или в виде пул реквестов у меня на GitHub). Не стесняйтесь задавать какие-либо вопросы относительно библиотеки и каких-то особенностей реализации – буду рад любому фидбеку.
Весь вышеприведенный код, а также исходники библиотеки aiorest-ws, можно посмотреть на [GitHub](https://github.com/Relrin/aiorest-ws). Примеры расположены в корне проекта, в каталоге examples. Документацию можно посмотреть [здесь](http://aiorest-ws.readthedocs.org/en/stable/). | https://habr.com/ru/post/274353/ | null | ru | null |
# Использование SPI механизма для создания расширений
Архитектура большинства Java(и не только) приложений сегодня предусматривает возможность расширения функционала посредством различного рода ~~магических~~ воздействий на код. В последнее время это также стало возможно, если использовать какой-нибудь модный [фреймворк или IoC-контейнер](http://habrahabr.ru/blogs/complete_code/116232/). Но что делать, если приложение долгоживущее и слишком сложное для того, чтобы переводить его на использование какого либо фреймворка?
В последнем приложении, с которым я работал, был реализован на тот момент неизвестный мне ~~велосипед~~ SPI механизм, который искал в джарках текстовые файлы вида *META-INF/services/* и брал оттуда название нужного класса, реализующего этот интерфейс, далее этот класс использовался как расширение. Поискав в интернете, узнал, что [Service Provider Interface(SPI)](http://en.wikipedia.org/wiki/Service_provider_interface) представляет собой программный механизм для поддержки сменных компонентов и что этот механизм уже довольно давно используется в [Java Runtime Environment(JRE)](http://en.wikipedia.org/wiki/Java_Runtime_Environment), например в [Java Database Connectivity(JDBC)](http://en.wikipedia.org/wiki/Java_Database_Connectivity):
>
> ```
> ps = Service.providers(java.sql.Driver.class);
> try {
> while (ps.hasNext()) {
> ps.next();
> }
> } catch (Throwable t) {
> // Do nothing
> }
>
> ```
>
>
>
Благодаря этому коду приложения больше не нуждаются в конструкции *Class.forName()* (хотя и с ней будут работать), JDBC драйверы будут подгружены автоматически при первом обращении к методам класса *DriverManager*.
SPI механизм также используется в [Java Cryptography Extension(JCE)](http://en.wikipedia.org/wiki/Java_Cryptography_Extension), [Java Naming and Directory Service(JNDI)](http://en.wikipedia.org/wiki/Java_Naming_and_Directory_Interface), [Java API for XML Processing(JAXP)](http://en.wikipedia.org/wiki/Java_API_for_XML_Processing), [Java Business Integration(JBI)](http://en.wikipedia.org/wiki/Java_Business_Integration), Java Sound, Java Image I/O.
#### Как это работает?
Весь смысл в разделении логики на сервис(Service) и провайдеры(Service Providers). Ссылки на провайдеры сохраняются в джарках расширений в текстовом файле(UTF-8) *META-INF/services/*, в каждой строке полное имя класса провайдера. Пустые строки и комментарии(начинающиеся с символа #) игнорируются. Ограничения на провайдеры: они должны реализовывать интерфейс либо наследоваться от класса сервиса и иметь конструктор по умолчанию(zero-argument public constructor).
Основное приложение для получения списка провайдеров может воспользоваться входящей в состав Java SE 6 API утилитой [java.util.ServiceLoader](http://download.oracle.com/javase/6/docs/api/java/util/ServiceLoader.html), которая работает по следующему принципу:
[](https://habrastorage.org/storage/habraeffect/2e/3d/2e3df5eff8705cb7bac7df1fd23288c8.gif "Хабрэффект.ру")
Пользовательский код запрашивает загрузчик конфигурации для определенного сервиса, загрузчик по мере надобности загружает из конфигурации провайдеры и сохраняет их в кэш. Также есть возможность очистить кэш и заново загрузить конфигурацию.
В более ранних версиях Java SE есть аналогичная утилита *sun.misc.Service*, работает по тому же принципу, но является частью проприетарного ПО ~~Sun~~ Oracle и может быть удалена в следующих релизах Java SE.
#### Пример использования
Например, у нас есть программа, которая ищет музыку на компе и выводит отсортированный по имени результат на экран.
>
> ```
> public class MusicFinder {
>
> public static List getMusic() {
> //some code
> }
> }
>
> public class ReportRenderer {
>
> public void generateReport() {
> final List music = findMusic();
> for (String composition : music) {
> System.out.println(composition);
> }
> }
>
> public List findMusic() {
> final List music = MusicFinder.getMusic();
> Collections.sort(music);
> return music;
> }
>
> public static ReportRenderer getInstance() {
> return new ReportRenderer();
> }
>
> public static void main(final String[] args) {
> final ReportRenderer renderer = ReportRenderer.getInstance();
> renderer.generateReport();
> }
> }
>
> ```
>
>
>
В некоторый момент времени мы осознали всю значимость этой программы для общества и решили поделиться ей со своими друзьями. Друзья попользовались сервисом и решили, что чего-то не хватает. Может выводить в отдельный файл? Но тогда придется переписывать весь этот клевый код. Не придется, можно воспользоваться SPI механизмом.
Например, создадим плагин для нашей супер-программы:
>
> ```
> public class FileReportRenderer extends ReportRenderer {
>
> @Override
> public void generateReport() {
> final List music = findMusic();
> try {
> final FileWriter writer = new FileWriter("music.txt");
> for (String composition : music) {
> writer.append(composition);
> writer.append("\n");
> }
> writer.flush();
> } catch (IOException e) {
> e.printStackTrace();
> }
> }
> }
>
> ```
>
>
>
Поместим в *META-INF/services/com.example.ReportRenderer* следующее:
>
> ```
>
> com.example.FileReportRenderer
>
> ```
>
>
>
Сделаем исходную программу расширяемой:
>
> ```
> public class ReportRenderer {
> //...
>
> public static ReportRenderer getInstance() {
> final Iterator providers = ServiceLoader.load(ReportRenderer.class).iterator();
> if (providers.hasNext()) {
> return providers.next();
> }
>
> return new ReportRenderer();
> }
>
> //...
> }
>
> ```
>
>
>
При запуске приложение, как и прежде, будет выводить всю найденную музыку на экран. Но если мы поместим только что созданную джарку расширения в *classpath*, то мы получим в результате файлик *music.txt*, содержащий результаты поиска.
Теперь пришло время поиграться с *MusicFinder*-ом. Сделаем его тоже расширяемым. Для этого поменяем класс на интерфейс:
>
> ```
> public interface MusicFinder {
>
> List getMusic();
> }
>
> ```
>
>
>
Добавим в основном модуле реализацию:
>
> ```
> public class DummyMusicFinder implements MusicFinder {
> public List getMusic() {
> return Collections.singletonList("From DummyMusicFinder...");
> }
> }
>
> ```
>
>
>
Поддержка расширений в *ReportRenderer*:
>
> ```
> public class ReportRenderer {
> //...
>
> public List findMusic() {
> final List music = new ArrayList();
> for (final MusicFinder finder : ServiceLoader.load(MusicFinder.class)) {
> music.addAll(finder.getMusic());
> }
> Collections.sort(music);
> return music;
> }
>
> //...
> }
>
> ```
>
>
>
Как и в случае с *ReportRenderer* добавим текстовый файл *META-INF/services/com.example.MusicFinder*, содержащий:
>
> ```
>
> com.example.DummyMusicFinder
>
> ```
>
>
>
Опять же результат выполнения первой программы не поменялся. Теперь расширение. Здесь сделаем две реализации *MusicFinder*-а:
>
> ```
> public class ExtendedMusicFinder implements MusicFinder {
> public List getMusic() {
> return Collections.singletonList("From ExtendedMusicFinder...");
> }
> }
>
> public class MyMusicFinder implements MusicFinder {
> public List getMusic() {
> return Collections.singletonList("From MyMusicFinder...");
> }
> }
>
> ```
>
>
>
*META-INF/service/com.example.MusicFinder*:
>
> ```
>
> com.example.MyMusicFinder
> com.example.ExtendedMusicFinder
>
> ```
>
>
>
Ну, вот и все, программа поддерживающая расширения готова, теперь с расширением в *classpath*, она выдаст список:
>
> ```
>
> From DummyMusicFinder...
> From ExtendedMusicFinder...
> From MyMusicFinder...
>
> ```
>
>
>
Исходники примера можно найти [здесь](https://github.com/sody/samples/tree/master/spi).
#### Заключение
Приведенный пример далек от совершенства, и я не претендую на автора самой крутого в мире поисковика музыки. Также я не призываю к фанатическому использованию этого механизма, так как не везде он применим, да и считаю использование IoC-контейнера более красивым решением, но все же кое-где и кое-кому такой подход может оказаться полезным. Спасибо за уделенное на прочтение статьи время.
#### Литература
[Плагин](http://ru.wikipedia.org/wiki/Плагин)
[Service Provider Interface](http://en.wikipedia.org/wiki/Service_provider_interface)
[Service Provider](http://download.oracle.com/javase/1.3/docs/guide/jar/jar.html#Service Provider)
[Service Provider Interface: Creating Extensible Java Applications](http://www.developer.com/java/article.php/3848881/Service-Provider-Interface-Creating-Extensible-Java-Applications.htm)
[Service Loader](http://download.oracle.com/javase/6/docs/api/java/util/ServiceLoader.html) | https://habr.com/ru/post/118488/ | null | ru | null |
# Исследователи восстановили утерянную игру для NES с 30-летних дискет
Привет, я основатель Video Game History Foundation Фрэнк Сифалди. Сегодня мы с Ричем Уайтхаусом расскажем вам историю о том, как восстановили и собрали заново *Days of Thunder* — невыпущенную, никем ранее не виденную игру, соавтором которой был Крис Оберт из Mindscape.
Ушедший от нас в 2012 году программист и дизайнер Крис Оберт (Chris Oberth) сделал долгую и разнообразную карьеру в индустрии видеоигр. Думаю, для большинства из нас главной игрой Криса Оберта была *Anteater* — аркадный проект, который он придумал и разработал во время работы в Stern (или, возможно, вы знаете клон этой игры под названием *Ardy the Aardvark*, который сам Крис написал для домашних компьютеров, или ещё один клон, *Oil’s Well*, созданный другими людьми). Для остальных такой игрой может быть *Winter Games* для Commodore 64 или, возможно, его последние проекты для аркадных автоматов наподобие *Time Killers* или *World Class Bowling*, которые он разрабатывал в Incredible Technologies; или же такими знаковыми играми для вас могли стать несколько проектов, которые он разработал на своём Apple II в конце 70-х и начале 80-х (как он сам любил хвастаться, его Apple II имел серийный номер 201).
В начале 2020 года с Video Game History Foundation связался друг семьи Оберта, попросив помочь разобраться с оставшимися после него материалами. В подвале его дома, где он часто работал, хранились годами нетронутые кучи старых компьютеров, резервных копий на CD-R, гибких дисков, записей, кассет, EPROM и данных на ленточных накопителях, копившиеся со времён его работы с Apple II в конце 70-х. Его семья согласилась временно передать нам эти архивы для разбора.
Как часто бывает с такими архивами, самым важным для нас было попытаться восстановить все утерянные работы Криса — разработанные им игры, которые по тем или иным причинам остались неизданными. К сожалению, мы почти не нашли остатков его работ со времени сотрудничества со Stern, то есть невыпущенная аркадная игра *Crypt*, источником вдохновения для которой послужила *Hunt the Wumpus*, скорее всего, навсегда утеряна. Но остальная часть коллекции дала нам надежду на сохранение его последующих работ для домашних компьютеров и консолей.
*Загадочная «Hot Rod Taxi» стала первым признаком того, что в архиве кода Оберта могут храниться неопубликованные работы.*
Особенно любопытным нам показался 5,25-дюймовый гибкий диск с рукописной пометкой «NINTENDO HOT ROD TAXI FINAL». Название этой игры неизвестно, но мы знали, что Крис разработал по крайней мере одну игру для Nintendo Entertainment System — *American Gladiators*. Нам не были известны подробности о его работе того времени, но, к счастью, позже Оберт дал по крайней мере два интервью первым сайтам поклонников ретро-игр — одно сайту [Derek’s Basement Arcade](https://web.archive.org/web/20040214192249/http://thelittons.net/homearcade/oberth.htm), а второе интервью в трёх частях в 2006 году сайту [Retrogaming Times](http://www.classicplastic.net/trt/arclegacy/legacyindex.html) (оно опубликовано в выпусках 21, 24 и 27 «Retrogaming Times Monthly»). В последнем Крис вкратце упомянул о невыпущенной игре для NES — неопубликованной версии *Days of Thunder*, разработанной для Mindscape (в конечном итоге вместо него был издан ещё один проект, созданный Beam Software). Была ли «Hot Rod Taxi» той самой утерянной *Days of Thunder*? Возможно, из неё убрали название по кинолицензии?
*Hot Rod Taxi для NES, скомпилированная из исходного кода Оберта. Это не совсем игра, она больше напоминает первое технологическое демо. *Days of Thunder* опять от нас ускользнула.*
Вероятно. Возможно. Сделав чистый рип диска и собрав двоичный файл из исходного кода и графических данных, мы получили играбельную игру для NES, которая, хотя и была интересной с исторической точки зрения, не очень походила на игру. Больше она напоминала первую проверку концепции; вероятно, с её помощью Оберт впервые знакомился с совершенно незнакомой ему платформой.
У нас был ещё один объект для поисков: огромная куча резервных копий жёстких дисков (по большей части подписанных), создававшихся на протяжении нескольких лет и сохранённых примерно на 40 гибких дисках. Это не были просто сохранённые на дисках файлы — резервное копирование выполнялось разными инструментами для копирования жёстких дисков, то есть файлы оказались разбиты на части и зашифрованы. Единственный способ их восстановления заключался в оцифровке всей кучи и сборке всех данных.
Теперь я передаю слово Ричу.
*Часть из сотен дисков, оставшихся от Криса Оберта. Возможно ли, что где-то в этой куче есть *Days of Thunder*?*
Восстановление накопителей
--------------------------
Нашей первой задачей в процессе поиска остатков *Days of Thunder* стало восстановление максимально возможного количества данных с различных носителей, в основном представленных старыми дисками на 5,25 дюйма. На некоторых из этих дисков были нечитаемые секторы, но в многие по-прежнему оставались целыми. Кроме того, часть этих дисков сразу удалось считать после создания под MS-DOS файловых систем FAT12. Однако самой многообещающей частью был набор из 21 дисков, содержащий резервные копии четырёх отдельных разделов жёсткого диска в проприетарном формате, сгенерированном [PC Tools 5.1](https://winworldpc.com/product/pc-tools/5x). Нам помогли в этом разобраться надписи «PCTools 5.10. Backup» на этикетках дисков.
*Наша первая попытка воссоздания жёсткого диска Оберта 1989 года с помощью инструмента резервного копирования закончилась неудачей — эмуляция через DOSBox не была способна выполнить эту задачу.*
Сначала я попробовал запустить программу резервного копирования PC Tools через [DOSBox](https://www.dosbox.com/), надеясь, что смогу восстановить резервные копии при помощи эмуляции. Мне не удалось заставить программу распознать образы дисков под DOSBox, и я решил, что для движения по этому пути может потребоваться внесение изменений в сам эмулятор. В этот момент я решил подойти с другой стороны, чтобы понять данные напрямую, и приступил к изучению сырых данных секторов в этих образах резервных дисков.
Структура данных оказалась не особо сложной. Каждая запись о папках и файлах хранилась в упакованном потоке, в котором для обозначения одного из трёх вариантов использовались командные байты. 0xDA означает, что к текущему стеку папок будет добавлена «запись папки». 0xDB означает «запись файла», за которой сразу же следуют сами данные файла. 0xDC означает «извлечение папки», то есть удаление самой последней папки из стека папок. В самих записях мне удалось выявить слова даты/времени в стиле MS-DOS, что позволило нам определить точные даты каждого из файлов в резервной копии.
Начало оказалось многообещающим, оно позволило нам сгенерировать список содержащихся в резервных копиях файлов. Мы быстро нашли кучу исходного кода и данные, которые с высокой вероятностью представляли собой наш большой приз: *Days of Thunder*. К сожалению, у нас всё равно оставалась проблема: даже несмотря на то, что мне удалось сгенерировать полный список путей из резервных копий, большинство интересующих нас данных было сжато проприетарным алгоритмом. Было бы легко на глаз понять используемое здесь сжатие, но поверх уже сжатых данных было использовано ещё и шифрование. К счастью, применённое к данным шифрование было стандартным и не зависело от вводимого пользователем ключа — в противном случае я бы до сих пор восстанавливал данные, а не писал эту статью!
Далее я рассматривал возможность использования нескольких подходов. Первый заключался в создании собственной сборки DosBox, чтобы заставить программу резервного копирования PC Tools правильно работать с исходными образами копий через эмуляцию. Второй подход заключался в обратной разработке используемых в PC Tools шифрования и сжатия, для этого бы потребовалось потратить много времени на дизассемблирование (и, в идеале, на отладку) самой программы. Я умею дизассемблировать системы более масштабные и сложные, чем эта, но решил, что собственная сборка DosBox в любом случае будет полезным инструментом. Можно будет использовать её до того момента, пока не выяснится, что данные резервных копий каким-то образом повреждены. В таком случае мне придётся разобрать каждый их бит, чтобы собрать из обломков всё полезное.
*К нам на помощь пришёл волонтёр VGHF с ником Foone. Для правильного восстановления резервной копии жёсткого диска Оберта он воссоздал соответствующую той эпохе аппаратную среду.*
Третий подход был намного проще, чем два предыдущих: использовать реальное «железо»! К сожалению, у меня под рукой не оказалось нужного оборудования, но мы сразу же смогли воспользоваться помощью [того, у кого оно было](http://foone.org/). Волонтёру Foone удалось собрать и запустить аппаратную систему, и хотя нам пришлось заново рипнуть один из наборов дисков с резервными копиями, чтобы PC Tools понял их, в конечном итоге мы смогли восстановить каждый бит данных каждого из этих четырёх разделов жёсткого диска.
Так как третье решение сработало, мне так и не пришлось погружаться в дебри реверс-инжиниринга использованного в PC Tools алгоритма сжатия. Однако по слухам, это скорее всего было что-то типа [LZSS](https://en.wikipedia.org/wiki/Lempel%E2%80%93Ziv%E2%80%93Storer%E2%80%93Szymanski). Я провёл несколько простых тестов с программой *pcsecure.exe* из набора PC Tools; похоже, она использует сжатие (хоть и не совершенно такое же, если судить результаты, полученные при сжатии соответствующих данных), очень похожее на сжатие, применяемое программой резервного копирования. Также я заметил, что в некоторых случаях сжатие сбоило и создавалоь файлы большего размера, чем можно было бы ожидать в наихудшем для LZSS случае. Например, такая ситуация возникала при сжатии последовательностей совершенно уникальных байтов, которое увеличивало размер файла; предположу, что это вызвано добавлением в данные контрольных байтов.
Сборка исходного кода
---------------------
После кратного изучения я не нашёл ничего напоминающего уже собранный образ ROM. Разумеется, ведь это было бы слишком просто. Итак, у меня были данные, располагавшиеся на четырёх разделах жёсткого диска. Я начал с папки с названием *C:\ROMX\BTR*. Её мы больше всего рады были увидеть тогда, когда изучали полученный список имён файлов. Казалось, что в этой папке находится весь исходный код и какие-то данные для *Days of Thunder*. В папке *C:\UTIL* содержались резервные копии многих инструментов, использовавшихся для разработки игры, в том числе ассемблер/компоновщик. При разработке использовался ассемблер X6502 — кросс-ассемблер 6502, созданный 2500 A.D. Software, Inc. И ассемблер, и компоновщик имели версию 4.03b.
Я собрал исходники и скомпоновал все объекты, при этом были созданы 6 отдельных двоичных файлов. Это переносит нас к следующей части процесса — к программе под названием ROMX. Эта программа является частью пакета ROMulator, созданного GTEK, Inc. Примечательно, что веб-сайт компании [до сих пор работает](http://www.gtek.com/romx.html). В нашем случае программа ROMX использовалась для передачи данных через компьютерный порт RS232 прямиком в память [PRG/CHR](https://wiki.nesdev.com/w/index.php/ROM) картриджа разработки NES. Он позволял разработчикам быстро обновлять и тестировать изменения в коде и графике на реальном «железе». Ещё удобнее то, что они могли выборочно обновлять нужный набор банков, чтобы снизить время итераций при обновлении определённого фрагмента кода или набора тайлов. В исходном коде было довольно много пакетных файлов, выполнявших команды ROMX по загрузке конкретных файлов в конкретные области в PRG/CHR. Вот пакетный файл, из которого можно понять полную схему PRG ROM:
> `ROMX PB0.TSK[TS,M\,%%0000,@0000-ffff]
>
> ROMX PB1.TSK[%%0000,@4000-7fff]
>
> ROMX PB2.TSK[%%0000,@8000-bfff]
>
> ROMX PB3.TSK[%%0000,@C000-ffff]
>
> ROMX PB4.TSK[%%0000,@10000-13fff]
>
> ROMX PB7.tsk[%%0000,@1C000-1ffff]
>
> ROMX CRASHL2.SND[%%0000,@1F000-1ffff]
>
> ROMX SKIDF.SND[%%0030,@1FC80-1fff0,TE]`
Приведённые выше команды сообщают нам, куда нужно помещать 6 двоичных файлов кода (те, о компоновке которых я говорил выше) вместе с двумя предварительно сгенерированными двоичными файлами звуков. Когда один из разработчиков хотел создать простой двоичный файл из памяти PRG или CHR, то вместо копирования всей этой информации с PC он мог просто запустить ROMX с параметрами, позволяющими выполнить дамп всех данных прямо из «железа» и сохранить их в файл.
На этом этапе сборки игры, уже исходя из одного количества банков PRG стало очевидно, что нам потребуется какой-то мэппер, поэтому и просмотрел исходники и встретил код, явным образом работающий с регистрами [MMC1](https://wiki.nesdev.com/w/index.php/MMC1). Я изготовил заголовок iNES с моим 128-килобайтным PRG ROM, соответствующим образом задал биты мэппера, а затем просто забросил в CHR ROM случайный мусор для тестирования. Игра успешно загрузилась в эмуляторе и начала воспроизводить музыку, отображая хаотичные данные из случайных тайлов. Насколько я понял, они должны были обозначать экран заставки.
Отсутствующие символы
---------------------
После запуска игры с набором случайных данных в CHR ROM я понял, что мы увидели довольно уникальные данные тайлов. Часть следов этих данных сохранились в исходном коде. В частности, там был самописный инструмент, предназначенный для парсинга блоков тайлов из файлов CLP программы [Pictor](https://en.wikipedia.org/wiki/PCPaint), запись их во временный файл и загрузка его при помощи ROMX в явно заданные адреса CHR. Этот процесс вызывался для небольших наборов тайлов с машиной и разводным ключом. Однако основная часть данных CHR никак не упоминалась, и не было никаких признаков того, как данные CHR обычно загружались через ROMX.
В ещё одной папке, *C:\ROMX\CHEDIT*, я обнаружил самодельный редактор тайлов NES с остатками данных, которые, кажется, относились к *Days of Thunder*. Мне удалось сопоставить часть экспортированных сюда данных .map и .pal с данными, собиравшимися в PRG, а поскольку они совпали, я предположил, что находящиеся здесь файлы .chr тоже будут соответствовать чему-то, относящемуся к CHR. Я начал с файла с именем *CAR.CHR* и занялся разбором того, где же конкретно он должен находиться в памяти CHR. Оказалось, что это адрес 0x3000. Мне удалось убедиться в этом, взглянув на экран заставки, несмотря на то, что остальная часть CHR была заполнена случайными данными:
*Мы нашли и скомпилировали данные программы, но бОльшая часть графики отсутствовала! К большому сожалению, мы проделали такой большой путь, но всё равно не смогли пересечь финишную черту.*
Мы убедились, что эти конкретные данные принадлежали CHR ROM, но многих данных всё равно не хватало. Я обнаружил в скриптах какой-то утилиты для анимирования ссылки, указывающие на изображения дороги и тайлов в местах, которые отсутствовали в восстановленной нами резервной копии. Я боялся худшего — что мы потеряли большой набор данных CHR вместе с данными исходников для их восстановления.
Зная, что у меня уже есть вероятный кандидат на нахождение большой части данных CHR ROM, я взял уникальную строку байтов из *CAR.CHR* и выполнил её двоичный поиск в каждом из файлов резервной копии, надеясь, что мне повезёт и я найду уже собранный фрагмент CHR ROM. Первая попытка не увенчалась успехом. После этого я решил применить «ядерное» решение — извлёк каждый архив в каждом известном формате из каждой резервной копии жёстких дисков, и проделал то же самое с каждым образом диска, которые мне удалось восстановить. Я выполнил ещё один поиск по всему этому массиву информации, и нашлось единственное совпадение в 128-килобайтном двоичном файле. *О да!*
Соединяем всё вместе
--------------------
Я был очень аккуратен, ведь не факт, что этот двоичный файл с таким удобным размером 128 КБ на самом деле будет совпадать с исходниками и тайлами, с которыми я работаю. Особенно меня настораживало то, что совпадение строки нашлось в другом наборе дисков. Однако на этом этапе у меня уже не было других вариантов, поэтому я взял файл и использовал его для заполнения всего CHR ROM в созданном мной NES ROM. Оказалось, всё находится на тех местах, где и должно быть!
Наконец-то мы впервые за тридцать лет увидели давно утерянную игру *Days of Thunder*!
На этом нашу миссию можно считать успешно завершённой. К сожалению, похоже, что нам не хватает множества исходных данных, и я всё ещё подозреваю, что эти данные хранятся где-то на других разделах жёсткого диска, которые не вошли в восстановленную нами основную резервную копию. Если бы нам не удалось найти двоичный файл CHR из казавшегося независимым набора данных, то мы бы никогда не смогли полностью восстановить игру или в конечном итоге создали бы собственные тайлы, чтобы сохранить какое-то подобие оригинальной игры. Это доказывает, что важен каждый гибкий диск!
Соберите игру и сыграйте сами!
------------------------------
С разрешения семьи Криса Оберта мы загрузили на [GitHub](https://github.com/DickBlackshack/Days-of-Thunder-NES-Unpublished) исходный код Days of Thunder вместе с собственным инструментом сборки и уже собранными двоичными файлами.
*Программист видеоигр Крис Оберт (1953-2012 гг.)*
> См. также:
>
>
>
> * «[Пишем игру «Жизнь» для NES на Rust](https://habr.com/ru/post/504262/)»
> * «[Терраформинг: как создавался Doom 64](https://habr.com/ru/post/502948/)»
> * «[В МТИ открыли исходный код игры Zork 70-х годов](https://habr.com/ru/news/t/501896/)»
> | https://habr.com/ru/post/506102/ | null | ru | null |
# OData REST API — мелкие хитрости (часть 3)
Продолжаем серию постов об особенностях использования протокола OData (см. [часть 1](http://habrahabr.ru/company/databoom/blog/262937/), [часть 2](http://habrahabr.ru/company/databoom/blog/263167/) ).
OData оговаривает что объекты можно создавать и апдейтить используя стандартный http запрос POST, PATCH и PUT. Тело запроса должно содержать JSON описание объекта, который мы хотим проапдейтить или добавить в базу.
Если добавляемый объект не существует — то создается новый объект.
Если объект существует — то поведение отличается:
* PUT — заменяет объект на новый
* PATCH — апдейтит поля объекты новыми значениями
* POST — поведение не оговорено в стандарте (в databoom POST аналогичен PATCH)
4. добавление сложных объектов вместе со связанными объектами
=============================================================
В тексте OData стандарта затерялось несколько важных фраз:
> A request to create an entity that includes related entities, represented using the appropriate inline representation, is referred to as a “deep insert” … On success, the **service MUST create all entities and relate them**.
В результате не все знают, что OData позволяет добавлять объекты вместе с дочерними объектами. Например, мы можем в коллекцию книг добавить новую книгу сразу вместе с ее авторами:
```
{
"id": "book1",
"title": "Cannibal’s Cookbook",
"author":[
{
"id": "person45",
"collections": [{ "id": "persons" }, { "id": "writers" }],
"firstname": "John",
"lastname": "Doe",
"age": 69,
"likes": [{ "id": "book55" }, { "id": "book19" }, { "id": "book66" }]
},
{
"id": "person191",
"collections": [{ "id": "persons" }, { "id": "experts" }],
"firstname": "Lamar",
"lastname": "Courtenay",
"age": 37,
"likes": [{ "id": "book186" }, { "id": "book18" }, { "id": "book31" }]
}
]
}
```
В соответствии со стандартом будут созданы (или проапдейчены) все необходимые объекты и будет установлена связь между ними. После этого Вы сможете получить книгу, или книгу вместе с ее авторами, получить список людей (в который войдут новые люди), писателей, экспертов, получить людей с их книгами и т.д. (см. [часть 1](http://habrahabr.ru/company/databoom/blog/262937/), [часть 2](http://habrahabr.ru/company/databoom/blog/263167/) )
5. установление связей между объектами
======================================
1. Имея возможность добавлять объекты вместе с вложенными объектами, можно **просто устанавливать связи между ними**.
В вышеприведенном примере мы добавляли книгу с автором, который имел поле likes
«likes»: [{ «id»: «book186» }, { «id»: «book18» }, { «id»: «book31» }]
В соответствии со стандартом будут созданы все книги (или проапдейчены, если они уже существуют) и установлены связи между человеком и любимыми книгами. Но поскольку книги имеют только поле id то апдейтить нечего — остается только выставить связи.
2. Существует и **другой способ установки связей**.
Список любимых книг человека с id='person191' доступен через URL
[.../persons(person191)/likes](https://samples.databoom.space/api1/sampledb/collections/persons(person191)/likes)
мы можем добавить книги, послав запрос PUT, POST или PATCH используя этот URL
Замечание: OData допускает, что объекты могут ссылаться на множество других объектов и на них могут ссылаться сразу много объектов. Книга может иметь несколько авторов, а автор может написать много книг. Человек может быть и студентом, и преподавателем одновременно. Объекты могут принадлежать сразу многим коллекциям.
---
Если Вас заинтересовал данный пост, Вы можете также посмотреть нашу документацию и примеры использования [REST API](http://databoom.space/odata-4.html), а также примеры с использованием [JavaScript библиотеки](http://databoom.space/js-guide-5.html)
Продолжение следует… | https://habr.com/ru/post/263435/ | null | ru | null |
# Best App Development Practices To Follow In 2020
As per the stats, there were around 6 billion mobile app users in 2018-19. With increased demand for mobile apps, the number of mobile users has increased exponentially as compared to last years. Hence, it becomes necessary for every mobile app development company to follow some best app development practices in order to deliver the best mobility solution their users.
When we talk about best app development practices, it doesn't mean to leave the traditional approaches and start with new strategies. Actually, it requires to rely on the best old practices using modern app development tools and technologies. Before discussing in the technical terms, we first look at some best app development methodologies to come with a perfect mobile app in this competitive era.
**Let's have a quick look:**
**-> Come up with a comprehensible app idea**
Your mobile application should be easy for users to understand. You can build apps in any specific domain viz. Education apps, [healthcare app](https://www.valuecoders.com/industries/healthcare-software-development-services), social apps etc.
Also be sure to include clear instructions whenever necessary. Keep a balance of text and images and provide concise instructions.Includes text to accompany the graphics. Avoid making the common mistake of relying only on images to tell the story. If your application has too many graphics, users may not be able to discover the real purpose of the application.
**-> Shift focus on core app development**
First, develop the main application. Focus on creating the most important features that will form the core of your application. Additional functionality may be available later in the form of add-ons, which users can purchase when necessary. This ensures that your application is light.
**-> Take care of target audience**
Before creating an application, it is important to know your target audience. Who are you creating the application for? How will they use this application? Is there any particular feature that can generate more appeal than the others? It is important and beneficial to answer these questions in advance.
**-> Choose a right design methodology**
Designing the correct design methodology is the key to developing a successful mobile application. You can list the full functionality and future components of your application on a sheet of paper and eliminate any problems that may arise at this stage. It is also a good idea to involve potential users in the design process. Your comments will help you improve the design in a way that is well accepted by the end user.
**-> Induce security features**
Mobile devices are vulnerable to multiple threats, since they upload and download data wirelessly in a potentially insecure environment. Therefore, when developing an application, you not only need to incorporate the inherent security capabilities of the platform, but also use tools such as encryption to protect sensitive data. Cleaning data remotely from a lost device is essential. Having an automatic backup mechanism also helps users not have to worry about data backup.
**-> Proper testing required**
Testing your application before launch is crucial. Although it is recommended to test the application at each stage of development, it is equally important to test the final product. And be sure to do this not with one but with several different users. In case there are problems, correct them and try the application again.
---
> **Android app development best practices**
The great popularity of android has increased the demand for android applications. It is the responsibility of all mobile app development companies to ensure high user experience always. For this, developers need to follow some best practices for android app development:
**Lets understand this with various coding examples:**
-> Use strings.xml
Adding text as String resources can be useful when support for new languages that are need to be added.
-> Avoid deep levels in layouts
For having a deep hierarchy of Views actually makes the UI slow, in order to manage layout.
Using the correct ViewGroup, deep hierarchies can mostly be avoided
However, it can be created in either of the following ways:
```
```
There is a second way which can be preferred since it has a single level hierarchy.
```
```
-> Use an AsyncTaskLoader instead of an AsyncTask
**A simple AsyncTaskLoader can be created like below:**
```
class SyncLoader extends AsyncTaskLoader {
public SyncLoader(Context context) {
super(context);
}
public String loadInBackground() {
String result = null;
return result;
}
}
```
> **Ios app development best practices**
Xcode is the IDE of choice for most iOS developers, and the only one officially compatible with Apple. There are some alternatives, of which AppCode is possibly the most famous, but unless you are already a person with iOS experience, choose Xcode. Despite its flaws, it is actually quite usable today!
**-> Adding CocoaPods**
If you're planning to include external dependencies for example third-party libraries in your project, CocoaPods provides easy and fast integration. You can install like below:
```
sudo gem install cocoapods
```
**To start, run the below code:**
```
pod init
```
This will create a Podfile holding all your dependencies in one place. After adding your dependencies to the Podfile, you can run
```
pod install
```
**-> Controllers**
Use dependency injection meaning passing any required objects in as parameters, instead of keeping all state around in singletons. The latter is fine only if the state really is global.
**To code in Swift:**
```
let fooView_Controller = FooView_Controller(withView_Model: fooView_Model)
```
**To code in Objective-C:**
```
FooView_Controller *fooView_Controller = [[FooView_Controller alloc] initWithView_Model:fooView_Model];
```
Try to avoid swelling your sight controllers with logic that can reside safely in other places. Soroush Khanlou has a good description of how to achieve this, and architectures like MVVM treat view controllers as views, which greatly reduces their complexity.
**->Include analytics framework**
It is strongly recommended to include an analysis framework in your application, as it allows you to obtain information on how people actually use it. A good practice is to create a thin auxiliary class, e.g. AnalyticsHelper, which handles the translation of internal application models and data formats (FooModel, NSTimeInterval, ...) to the data layer based primarily on strings:
```
func pushAddItem_Event(with item: Item, editMode: EditMode) {
let editModeString = name(for: editMode)
pushToDataLayer([
"event": "addItem",
"itemIdentifier": item.identifier,
"editMode": editModeString
])
}
```
This has the additional advantage of allowing you to swap out the entire Analytics framework behind the scenes if needed, without the rest of the app noticing.
**-> Debug provisioning**
Sometimes you need to debug a provisioning problem. For example, Xcode may refuse to install the compilation on a connected device, because the latter is not in the list of devices in the profile (development or ad-hoc). In those cases, you can use Craig Hockenberry's excellent provisioning add-on by browsing to ~ / Library / MobileDevice / Provisioning Profiles, selecting a .mobileprovision file and pressing the spacebar to start the Finder quick search function. It will show you a lot of information, such as devices, rights, certificates and the application ID.
When it is an existing application file (.ipa), you can inspect your provisioning profile in a similar way: simply rename \* .ipa to \* .zip, unzip it and look for the .app package inside. In the Finder context menu, choose «Show package content» to see a file called embedded.mobileprovision that you can examine with the previous method.
After developing an app, you need to perform the following checks:
Authenticity: It implies that the receipt comes from Apple
App match: It says that the app bundle ID in the receipt matches your app’s bundle identifier
Product match: That the product ID in the receipt matches your expected product identifier
Integrity: It says that the receipt has not been tampered with
Freshness: You haven’t seen the same receipt ID before.
**Ending Notes**
Mobile application development implies strategic thinking using the appropriate mobile application development technology. Taking these best practices into account will help you create a highly functional mobile application without much hassle.
Do you plan to build a mobile application? Do you want to know an estimated cost of mobile application development? Talk to our mobile application development experts to find out how much it costs to build a mobile application. | https://habr.com/ru/post/477504/ | null | en | null |
# PHP 5.3.7 released, но обновление содержит критическую ошибку
18 Августа была анонсирована версия 5.3.7
22 Августа анонсирован Upgrade Warning который не рекомендует установку/апгрейд этой версии.
Вкратце: при использовании функции crypt() для хэшей MD5 выдаётся только соль.
Получается вот такая очень неприятная штука:
`printf("MD5: %s\n", crypt('password', '$1$U7AjYB.O$'));
Должно быть:
----------------
MD5: $1$U7AjYB.O$L1N7ux7twaMIMw0En8UUR1
А получается только соль:
--------------
MD5: $1$U7AjYB.O`
Баг работает только для MD5 (алгортим по-умолчанию в php), DES и BLOWFISH не затронуты.
Разработчики обещают выпустить версию 5.3.8 с багфиксом в течение нескольких дней.
[Bug #55439 crypt() returns only the salt for MD5](https://bugs.php.net/bug.php?id=55439) | https://habr.com/ru/post/126857/ | null | ru | null |
# Автоматизация квартиры с HomePod, Raspberry Pi и Node.js
Перевели для вас [статью Криса Хокинса](https://medium.com/@chrishawkins/automating-my-home-with-homepod-raspberry-pi-and-node-js-b56b39780499), в которой он рассказывает о превращении своей квартиры в умный дом. В качестве базы используется HomePod от Apple, но, конечно, можно применять и другие системы.
У меня дома работает Apple HomePod, который помогает контролировать определенные системы в доме (к примеру, умные лампы) при помощи обычного запроса к Siri. Работает система как из дома, так и вне его (умный помощник есть на телефоне).
> **Skillbox рекомендует:** двухлетний практический курс [«Я — веб-разработчик PRO»](https://iamwebdev.skillbox.ru/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=WEBDEVPRO&utm_content=articles&utm_term=applehomepod).
>
>
>
> **Напоминаем:** *для всех читателей «Хабра» — скидка 10 000 рублей при записи на любой курс Skillbox по промокоду «Хабр».*
Изначально я скептически относился к управлению домом при помощи голосовых команд, ведь далеко не все распознается ассистентами (не только Siri) корректно. Но затем это вошло в привычку. Поскольку у ламп Hue нет физического выключателя, а в приложении нужно совершить несколько действий для управления освещением, я привлек к делу Siri.
Затем мне захотелось начать при помощи голосового помощника управлять и другими системами в доме, например, телевизором или консолью. В случае с ТВ я, например, обнаружил Simple IP Control — метод управления моим Sony Bravia путем отправки команд по TCP.
### Кастомизируем Siri
Во второй половине 2018 года Apple открыла приложение Shortcuts для всех пользователей iOS. Оно позволяет автоматизировать работу с телефоном (или умным домом) без необходимости писать код.
У приложения много встроенных команд. Что ему недостает, так это возможности использовать TCP-команды, хотя там есть механизм работы с URL.
Плюс ко всему, можно писать собственные модули на Objective-C или Swift. Этого решил не делать, поскольку в будущем я могу сменить мой HomePod на другого помощника. Вместо этого мне захотелось написать веб-приложение, которое сможет отвечать на команды Siri.
### Управление Sony Bravia TV
Вооружившись мануалом с командами для моего ТВ, я написал приложение на [Node.js Express (Github)](https://github.com/chrishawkins/room-control), которое научил отвечать на некоторые из общих команд. Начал я с включения и громкости.
Команда setPowerStatus делает все, что нам нужно.
Заголовок состоит из символов \* и s, которые статичны и используются для всех команд. Затем третий байт (с) используется для Command. Есть четыре значения, которые могут занимать эту позицию. C для Command (отправка команды на ТВ), E — для Enquiry (проверка текущего значения определенного параметра, например, громкости), А — Answer (отправляется в ответ на Commands и Enquiries) и N для Notify (оповещение о событиях, вроде отключение громкости).
Для достижения своей цели мне пришлось изучить документацию [Sony’s JSON-RPC](https://pro-bravia.sony.net/develop/integrate/rest-api/spec/). Как оказалось, природа JSON-RPC over HTTP позволила упростить задачу и сократить количество кода.
Работа с JSON-RPC API была простой. Возьмем, например, сервис (system), команду (getPowerStatus) плюс параметры (true или false) и сформируем HTTP-запрос, который затем отправляем на ТВ.
```
let body = JSON.stringify({
method: command,
id: ++this.id,
params: params,
version: "1.0",
});
return new Promise((resolve, reject) => {
fetch('http://' + this.ip + ':' + this.port + '/sony/' + service, {
method: 'post',
headers: { 'X-Auth-PSK': this.psk },
body: body,
}).then(response => {
return response.json();
}).then(response => {
if (response.error && (!response.result || response.result.length === 0)) {
reject({ code: response.error[0] });
} else {
resolve(response.result[0]);
}
}).catch(error => {
reject(error);
});
});
```
По умолчанию аутентификация осуществляется при помощи предварительного ключа, отправляемого в заголовке HTTP-запроса. Но есть более безопасный и удобный способ сделать это при помощи accessControl. В этом случае мы можем отправлять команду на телевизор и осуществлять безопасный обмен кода при базовой HTTP-аутентификации. После того, как аутентификация выполнена один раз, дальнейшая авторизация выполняется при помощи cookie.
Но мой ТВ защищен файерволом, настроенным на роутере, так что я использовал предварительный ключ.
### Включение Xbox One
Xbox, конечно, требовал иной настройки. Microsoft, похоже, приняла решение не использовать REST API, поэтому работа была выполнена при помощи UDP-пакетов.
К счастью, у Node.js есть модуль dgram, который «из коробки» работает со всеми возможностями USP. Вот, что у меня получилось в итоге.
```
turnOn() {
let socket = dgram.createSocket('udp4');
let powerPayload = new Buffer('\x00' + String.fromCharCode(this.liveId.length) + this.liveId.toUpperCase() + '\x00');
let powerHeader = Buffer.concat([new Buffer('dd0200', 'hex'), new Buffer(String.fromCharCode(powerPayload.length)), new Buffer('\x00\x00')]);
let powerPacket = Buffer.concat([powerHeader, powerPayload]);
return this._sendPacket(socket, powerPacket);
}
_sendPacket(socket, buffer) {
return new Promise((resolve, reject) => {
socket.send(buffer, 0, buffer.length, Constants.xboxPort, this.ip, function(err) {
socket.close();
if (err) {
return reject(err);
}
resolve();
});
});
}
```
Для настрйоки я использовал список ID-устройств, который [можно найти здесь](https://support.xbox.com/en-US/my-account/warranty-and-service/find-xbox-one-kinect-serial-number). Если вы хотите просто взять код из моего репозитория, то вам нужно заменить ID в файле config.json.
### Настройка Shortcuts для Siri
Для того, чтобы Siri могла выполнять команды, которые я только что создал, ей нужен помощник. Его я создал из Raspberry Pi, поскольку «малинка» подходит по всем параметрам. Для этого я купил Pi 3 Model B+, поддерживающий Wi-Fi.
У Raspbian есть GUI для настройки. Я подключился к Wi-Fi, затем отключил дисплей и продолжил работу по SSH. Для того, чтобы убедиться в постоянной активности веб-приложения, я настроил сокет активации сервиса в systemd, так что если бы процесс Node.js упал, система автоматически могла его перезапустить.
Собственно, Shortcuts для Siri были самым простым этапом работы. Это интуитивное приложение с нативной поддержкой голосовых команд. Оно по умолчанию уже умело работать с HomePod, дополнительно настраивать ничего не понадобилось.
### Собираем все вместе
Поскольку мой ТВ работает на Android, он поддерживает приложения вроде Netflix и YouTube. Помня об этом, я создал команды для запуска этих сервисов. Кроме того, я добавил команды для контроля громкости, режима работы ТВ, паузы и проигрывания контента.
[Вот примеры](https://github.com/chrishawkins/room-control/blob/master/routes/tv.js) всего, что я создал. Я также постарался сделать проект модульным, так что добавлять другие модели SmartTV — не проблема.
Вот пример модуля, который включает Xbox, ТВ и активизирует первый порт HDMI.
```
router.post('/turnOnXboxAndTV', function(req, res, next) {
Promise.all([
xbox.turnOn(),
tv.turnOn()
.then(() => new Promise(resolve => setTimeout(resolve, 2000)))
.then(() => tv.setInput(config.scripts.xboxInput)),
]).then(() => {
res.sendStatus(200);
}).catch((error) => {
res.status(500).send(error);
});
});
```
А вот как это все работает на практике.
К сожалению, функциональность Siri не слишком хороша. У той же Alexa от Amazon гораздо более обширный спектр возможностей и весьма мощный API. Думаю, на основе Alexa можно создать куда более серьезные проекты.
> **Skillbox рекомендует:**
>
>
>
> * Практический курс [«Мобильный разработчик PRO»](https://skillbox.ru/agima/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=AGIMA&utm_content=articles&utm_term=applehomepod).
> * Онлайн-курс [«Профессия frontend-разработчик»](https://skillbox.ru/frontend-developer/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=FRENDEV&utm_content=articles&utm_term=applehomepod).
> * Практический годовой курс [«PHP-разработчик с 0 до PRO»](https://skillbox.ru/php/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=PHPDEV&utm_content=articles&utm_term=applehomepod).
> | https://habr.com/ru/post/438292/ | null | ru | null |
# Четыре приема быстрой разработки на Unity3D
Больше гибкости, меньше кода — продуктивнее разработка.
Уже долгое время [Unity3D](https://unity.com/) — мой любимый инструмент разработки игр, которым я пользуюсь уже более 8 лет — и для профессиональных продуктов, и для личных проектов, и [при обучении программированию и гейм-дизайну](https://www.saxion.nl/opleidingen/en/fulltime/bachelor/creative-media-and-game-technologies). Более того, я писал на Unity почти на всех гейм-джемах, в которых участвовал, благодаря чему получалось создавать основу игры всего за несколько часов.
Как вы, наверное, знаете, [гейм-джем](https://ru.wikipedia.org/wiki/Game_Jam) — это конкурс разработчиков игр, участники которого делают игру с нуля за короткий период времени. Гейм-джем обычно идет от 24 до 72 часов, но бывают и более длительные — например, [GitHub Game Off](https://github.blog/2020-10-27-github-game-off-2020/), который длится весь ноябрь.
После участия в различных гейм-джемах, в том числе и с самодельным движком моей группы на C++ ([к сожалению, он только на португальском языке](https://github.com/YvensFaos/GondarGameEngine)), я составил список правил быстрого прототипирования, которые вскоре превратились в мой основной принцип разработки ПО: меньше кода — быстрее работа.
Основная идея — писать меньше кода (или, иначе говоря, держать меньшую кодовую базу) — решает две задачи:
1. Защита от ошибок: чем меньше размер кода, тем меньше вероятность сделать ошибку.
2. Экономия времени: при каждом изменении кода нужны обновления и тесты, что требует времени.
А для Unity есть и третья причина: каждое изменение в коде запускает обновление Unity, на что регулярно тратится некоторое количество времени.
В этой статье я расскажу о нескольких приемах, позволяющих легко реализовать этот принцип в Unity3D и таким образом ускорить прототипирование и создание игр в целом.
Для справки: Unity 3D Technologies мне ничего не платили (пока что).
### 1. Сериализация классов и структур
Сериализация — это процесс автоматического преобразования структур данных или состояний объекта в другой формат. В случае Unity это упрощает хранение и реконструкцию данных.
*Класс* и *структуру* можно пометить как сериализуемые — указав [Serializable] над именем. Ниже — пример [из документации Unity](https://docs.unity3d.com/ScriptReference/Serializable.html):
```
[Serializable]
public struct PlayerStats
{
public int movementSpeed;
public int hitPoints;
public bool hasHealthPotion;
}
```
Главное преимущество этого подхода в том, что он дает прямой доступ к соответствующим свойствам через *инспектор*, что особенно удобно при использовании *списков* и *массивов*.
Список характеристик игрока в инспекторе свойств UnityВ вашем проекте наверняка будут повторяющиеся структуры: например, **задания**, **предметы** или даже **диалоги** — их можно реализовать в виде сериализованных *классов* или *структур*, что позволит с легкостью изменять их список значений в *инспекторе*.
То же можно сделать для *перечислений* (их использование [повышает безопасность типов](https://learn.unity.com/tutorial/enumerations)) и более сложных конструкций — например, *спрайтов*. Оба случая приведены на изображении и в коде ниже:
Список характеристик игрока со спрайтами и перечислениями в инспекторе Unity
```
public enum PlayerType
{
ARCHER, KNIGHT
}
[Serializable]
public struct PlayerStats
{
public int movementSpeed;
public int hitPoints;
public bool hasHealthPotion;
public Sprite face;
public PlayerType type;
}
```
Если использовать *перечисление* в сериализованной структуре, то в качестве приятного дополнения вы получите его *идентификаторы* в инспекторе Unity в красивом и удобном выпадающем списке — и больше не нужно запоминать *строки*.
### 2. По возможности используйте RequireComponent
Сценарии с зависимостями от компонентов — обычное дело. Например, сценарий контроллера игрока, скорее всего, будет зависеть от Rigidbody и коллайдеров игрока. Самый безопасный способ обеспечить наличие всех зависимостей у игрового объекта во время выполнения сценария — это пометить его [атрибутом RequireComponent](https://docs.unity3d.com/ScriptReference/RequireComponent.html).
У этого атрибута три основных функции:
1. Обеспечить наличие необходимых компонентов у игрового объекта.
2. Заблокировать удаление необходимых компонентов.
3. Автоматически добавлять необходимые компоненты к игровому объекту, когда к нему прикрепляется сценарий.
Пример кода с использованием RequireComponent показан ниже:
```
[RequireComponent(typeof(Rigidbody))]
public class PlayerScript : MonoBehaviour
{
Rigidbody rigidbody;
void Awake()
{
rigidbody = GetComponent();
}
}
```
Эта функциональность значительно повышает безопасность кода и снижает вероятность непредвиденного *исключения пустого указателя* при попытке получить доступ к недействительным или несуществующим компонентам. Компоненты можно непосредственно прикрепить в окне редактора или получить их с помощью методов *Awake* или *Start*, как показано в примере кода выше.
С точки зрения прототипирования этот подход ускоряет подготовку объектов. Более того, у *классов* и *структур* может быть несколько атрибутов *RequireComponent* сразу. Достаточно указать их в сценарии, а затем просто добавить его в *игровой объект* — и все компоненты будут прикреплены.
А учитывая, что эти компоненты никогда не будут недействительными при обычных обстоятельствах, в сценарии не нужно проверять на значение null, — значит, и кода писать нужно меньше.
### 3. Кнопки интерфейса для нескольких событий
Это, пожалуй, самый простой и эффективный прием из рассматриваемых: использовать одну и ту же *кнопку пользовательского интерфейса Unity* для нескольких событий одновременно. Многие новички в Unity используют кнопки либо для выполнения одной задачи, либо, что еще хуже, для вызова определенного метода в сценарии, обрабатывающего логику кнопки.
Само по себе это не плохо, но в обоих случаях появляется сильная зависимость от изменений в кодовой базе — которые наверняка будут.
Лучше всего перечислять все эффекты кнопки прямо в ее списке событий OnClick: в нем может быть столько событий, сколько нужно, и к ним легче получить доступ и изменить их.
С помощью этого подхода можно, например, использовать onClick одной кнопки для отображения *панели Unity*, воспроизведения звука и запуска анимации. Конкретно для этих задач дополнительный код не потребуется: отображаем панель — ( setActive(true) ), воспроизводим звук — ( play() ) и вызываем Animator — ( setTrigger() ). Примеры вызова этих методов — ниже.
Пример списка с событиями OnClickДовольно часто этот подход используется для программирования переходов по меню. Каждое меню активирует следующее и деактивируется само. При возврате или закрытии меню каждое из них снова деактивирует себя и активирует предыдущее. Самое приятное здесь то, что не понадобится ни строчки кода. Повторюсь: меньше кода — меньше ошибок, быстрее работа.
### 4. Широкое применение событий Unity
В Unity есть специальный класс с именем [UnityEvent](https://docs.unity3d.com/ScriptReference/Events.UnityEvent.html), который ведет как себя метод *OnClick* *кнопки интерфейса Unity*. Переменная *UnityEvent*, доступ к которой есть у сценария, дает тот же интерфейс, что и метод OnClick:
Одна переменная UnityEvent с именем EventsToBeCalledТакая переменная используется практически так же, за исключением того, что для выполнения списка событий переменной *UnityEvent* ее нужно вызывать через сценарий. Во фрагменте кода ниже показано, как добавить переменную *UnityEvent* в сценарий и как пишется простая функция вызова *Invoke*:
```
using UnityEngine;
using UnityEngine.Events;
public class CallEventsScript : MonoBehaviour
{
public UnityEvent eventsToBeCalled;
public void CallEvents()
{
eventsToBeCalled.Invoke();
}
}
```
Метод *CallEvents* вызывает список событий для переменной *UnityEvent*. Это общедоступный метод, поэтому к нему имеют доступ другие сценарии, в том числе [сигналы временной шкалы](https://docs.unity3d.com/Packages/com.unity.timeline@1.0/api/UnityEngine.Timeline.SignalReceiver.html) и [события анимации](https://docs.unity3d.com/Manual/script-AnimationWindowEvent.html). Для этих двух случаев писать код для доступа к методу не нужно — всё делается простым перетаскиванием.
Временная шкала анимации с добавленным событием, которое вызывает метод CallEvents*UnityEvent* также может использоваться для создания очень гибких сценариев, например, для вызова списка событий в таких методах, как *Awake, Start, OnEnable, OnDisable* и т. д. Например, можно написать сценарий, который выполняет список событий в методе *Start*, — это позволит быстро создать функции без необходимости писать код.
Пример из практики — **триггерный ящик**, как я его называю: это *игровой объект* с *коллайдером*, который выполняет одно или несколько действий при столкновении с другими *игровыми объектами*. Его можно легко реализовать с помощью UnityEvent:
```
[RequireComponent(typeof(Collider))]
public class TriggerBoxScript : MonoBehaviour
{
public UnityEvent eventsToBeCalledOnCollision;
public List objectsTagToActivate;
private void OnCollisionEnter(Collision other)
{
if (OtherHasWantedTag(other.gameObject))
{
InvokeEvents();
}
}
private void OnTriggerEnter(Collider other)
{
if (OtherHasWantedTag(other.gameObject))
{
InvokeEvents();
}
}
private bool OtherHasWantedTag(GameObject other)
{
var found = objectsTagToActivate.Find(other.CompareTag);
return found != null;
}
private void InvokeEvents()
{
eventsToBeCalledOnCollision.Invoke();
}
}
```
Пример выше работает и для *триггеров*, и для *коллайдеров без триггера* (метод вызывается и через *OnTriggerEnter*, и через *OnCollisionEnter*). При этом его могут использовать только *игровые объекты*, у которых есть коллайдер.
Пример необходимых компонентов для триггерного ящикаВ примере выше показан *игровой объект с триггерным ящиком*, использующий этот подход. В этом примере всякий раз, когда *игровой объект* «Player» сталкивается с *объектом — триггерным ящиком*, последний воспроизведет звук и деактивируется. Возможности такой структуры почти безграничны: активация врагов, изменение фоновой музыки, точки появления, точки сохранения и т. д.
Заключение
----------
Если коротко, то два главных результата использования описанных подходов — это снижение количества кода и расширение возможностей инспектора Unity. Больше гибкость — шире простор для действий.
В случае событий (*OnClick* и *UnityEvent*) разработчику не нужно беспокоиться о настройке зависимостей объекта (методы объектов можно вызывать напрямую из списков) и проверке их действительности (в списке можно будет привязать только действительные существующие объекты).
Конечно, бывают случаи, в которых эти подходы лучше не использовать: они усложнят работу. Например, если одну и ту же серию задач необходимо выполнить для разных элементов, было бы разумно передать ее определенному методу и вызывать его, а не перечислять все задачи для каждого элемента. Это относится непосредственно ко *кнопкам интерфейса* Unity, для которых в таких ситуациях может быть удобно назначить конкретные методы.
В любом случае, гибкость описанных подходов наверняка перевесит их недостатки — и, конечно же, их легко игнорировать или устранить. Более того, эти приемы позволяют быстро создать прототип и проверить идею, и только после этого приступать к написанию более стабильного и эффективного кода.
Благодарю за внимание.
![Побережье, коричневый песок. Альберт Эдельфельт (1935) [USEUM]](https://habrastorage.org/r/w1560/getpro/habr/upload_files/242/d66/470/242d664703dd898ef9c3156c4a58ae7a.png "Побережье, коричневый песок. Альберт Эдельфельт (1935) [USEUM]")Побережье, коричневый песок. Альберт Эдельфельт (1935) [USEUM]#### О переводчике
Перевод статьи выполнен в Alconost.
Alconost занимается [локализацией игр](https://alconost.com/ru/services/game-localization?utm_source=habr&utm_medium=article&utm_campaign=faster-unity-3d-development), [приложений и сайтов](https://alconost.com/ru/services/software-localization?utm_source=habr&utm_medium=article&utm_campaign=faster-unity-3d-development) на 70 языков. Переводчики-носители языка, лингвистическое тестирование, облачная платформа с API, непрерывная локализация, менеджеры проектов 24/7, любые форматы строковых ресурсов.
Мы также делаем [рекламные и обучающие видеоролики](https://alconost.com/ru/services/video-production?utm_source=habr&utm_medium=article&utm_campaign=faster-unity-3d-development) — для сайтов, продающие, имиджевые, рекламные, обучающие, тизеры, эксплейнеры, трейлеры для Google Play и App Store. | https://habr.com/ru/post/531882/ | null | ru | null |
# Машинное обучение: с чего начать или как построить первую модель
В качестве первой задачи для машинного обучения возьмем что-то понятное и простое, например, прогноз стоимости жилья. Готовый датасет можно найти на сайте kaggle. На первых шагах обучения не стоит брать датасеты с большим количеством переменных, например, «House Prices: Advanced Regression Techniques» состоит из 80 переменных и advanced regression, остановимся на «House Sales in King County, USA» с 21 параметром. Скачиваем данные и анализируем предоставленное описание. В наличии дата, цена, количество спален, ванных комнат, общая и жилая площадь, этажность, оценка вида, вид на море, оценка общего состояния, грейд (оценка строительства и дизайна), площадь над и под уровнем земли, год постройки, год последнего ремонта, код зоны, координаты (долгота и широта), данные о площади домов 15 соседей.
Итак, мы выбрали задачу и готовы приступить к ее решению. Решение будет включать два этапа: анализ данных и построение моделей.
1. Работа с данными.
Сделаем отступление и отдельно отметим важность анализа данных. В настоящий момент все более-менее популярные алгоритмы уже написаны в виде библиотек и непосредственное построение модели сводится к нескольким строкам кода, например, k-ближайших соседей из sklearn в python:
```
from sklearn .neighbors import KNeighborsClassifier
clf_KNN = KNeighborsClassifier() #Создаем модель
clf_KNN.fit(X_train, Y_train) #Обучаем модель
Y_KNN = clf_KNN.predict(X_test) #Предсказываем значения для выборки
```
Всего четыре строчки кода для получения результата. Так в чем же сложность? Сложность заключается в получении того самого X\_train – данных, которые подаются на вход модели. Известный принцип «мусор на входе» = «мусор на выходе» (Англ. Garbage in – garbage out (GIGO)) в моделировании работает более чем на 100% и именно от работы с данными во многом будет зависеть качество полученного решения задачи машинного обучения.
А теперь – в бой!
Для анализа данных мы будем использовать pandas, для понимания и оценки «на глаз» используем простые графики из seaborn.
Импортируем библиотеки, читаем данные, выведем несколько записей из массива данных, посмотрим на типы данных и пропуски в них.
Код и Out
```
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
df = pd.read_csv('…/train.csv')
df.head(5)
```
```
df.info()
```
```
RangeIndex: 21613 entries, 0 to 21612
Data columns (total 21 columns):
id 21613 non-null int64
date 21613 non-null object
price 21613 non-null float64
bedrooms 21613 non-null int64
bathrooms 21613 non-null float64
sqft_living 21613 non-null int64
sqft_lot 21613 non-null int64
floors 21613 non-null float64
waterfront 21613 non-null int64
view 21613 non-null int64
condition 21613 non-null int64
grade 21613 non-null int64
sqft_above 21613 non-null int64
sqft_basement 21613 non-null int64
yr_built 21613 non-null int64
yr_renovated 21613 non-null int64
zipcode 21613 non-null int64
lat 21613 non-null float64
long 21613 non-null float64
sqft_living15 21613 non-null int64
sqft_lot15 21613 non-null int64
dtypes: float64(5), int64(15), object(1)
memory usage: 3.5+ MB
```
Массив данных состоит из 21613 записей без пропусков в данных и содержит только 1 текстовое поле date.
С каждым признаком поработаем подробнее и начнем с самого простого – откинем id (не несет полезной информации), zipcode (код зоны, где расположен дом) и координаты (lat & long), так как мы только знакомимся c machine learning, а корректное преобразование географических данных слишком специфично для начинающего специалиста.
```
df=df.drop(['id','zipcode','lat','long'], axis=1)
```
Теперь посмотрим на дату объявления. Формат даты задан YYYYMMDDT000000, в целом ее тоже можно было бы удалить из датасета, но у нас есть поля год постройки (yr\_built) и год последнего ремонта (yr\_renovated), которые заданы в в формате года (YYYY), что не очень информативно. Оперируя датой объявления можно преобразовать год в возраст вычитанием (год объявления — год постройки / год ремонта). Отметим по части домов год ремонта стоит 0, и, предположив, что это означает отсутствие ремонта с постройки, заменим нули в году ремонта на год постройки, предварительно убедившись, что в данных отсутствуют некорректные записи, где год ремонта меньше года постройки:
```
df[(df['yr_renovated']
```
```
df.loc[df['yr_renovated']==0, ['yr_renovated']]=df['yr_built']
df['yr_built']=df['date'].str[0:4].astype(int)-df['yr_built']
df['yr_renovated']=df['date'].str[0:4].astype(int)-df['yr_renovated']
df=df.drop('date', axis=1)
df.head(5)
```
Следующим параметром проанализируем цену и воспользуемся для этого «Ящиком с усами» (Box plot). Ящик с усами – простой и удобный график, показывающий одномерное распределение вероятностей, или, проще говоря, концентрацию данных. Отрисовывает медиану (линия в центре), верхний и нижний квартили (стороны ящика), края статистически значимой выборки («усы») и выбросы (точки за «усами»). Легко понять по картинке на нормальном распределении (справа). График позволяет быстро оценить где располагается большая часть данных (50% находятся внутри ящика), их симметричность (смещение медианы к одной из сторон ящика и/или длина «усов») и степень разброса – дисперсию (размеры ящика, размеры усов и количество точек-выбросов).
Можно построить распределение только этого признака по всему массиву, но информативнее будет использовать 2 оси – например, цену и количество спален, что в свою очередь также покажет наличие связи между признаками:
```
sns.boxplot(y='price', data=df) #только price
sns.boxplot(y='price', x='bedrooms', data=df) #price & bedrooms
```
Out price & bedrooms:
Из графика сразу видно наличие экстремальных значений price и bedrooms (только представьте дом с 33 спальнями! J). Наличие таких значений (иначе называемых как выбросы) в целевом признаке price часто приводит к переобучению модели, так именно они будут давать большую ошибку, которую алгоритмы стараются минимизировать. Из графика видно, что большая часть (если посчитать – 93,22%) лежит в диапазоне 0-1млн, а свыше 2млн – всего 198 значений (0,92%). От 1% датасета можно избавиться практически безболезненно, поэтому вызвав простой просмотр 217 записей предварительно отсортировав по цене, увидим искомую отметку price в 1 965 000 и удалим все что выше этой цены.
```
df.sort_values (by='price', ascending=False).head(217)
df=df[df['price']<=1965000]
```
Подумаем немного над признаком bedrooms. Мы видим 13 домов с bedrooms = 0, а также странную запись о доме с 33 bedrooms. Поступим также как и с price, удалив нули из bedroms (а заодно и bathrooms):
```
df=df[(df['bedrooms']!=0)&(df['bathrooms']!=0)]
```
Касательно дома с 33 спальнями – учитывая цену, можно предположить что это опечатка и спален на самом деле 3. Сравним жилую площадь этого дома (1620) со средней жилой площадью домов с 3 спальнями (1798,2), что ж вероятно наша догадка верна, поэтому просто изменим это значение на 3 и еще раз построим предыдущий box plot:
```
df.loc[df['bedrooms']==33,['bedrooms']]=3
sns.boxplot(y='price', x='bedrooms', data=df)
```
Чтож, значительно лучше. Аналогично bedrooms посмотрим и на bathrooms. Нулевые значения мы удалили, другие экстремальные значения в поле отсутствуют:
```
sns.boxplot(y='bathrooms', x='bedrooms', data=df)
```
В полях sqft\_living, floors, waterfront, view, condition, grade, sqft\_living15 также все значения более-менее реальны, их трогать не будем:
```
plt.rcParams['figure.figsize']=2,3 #размер картинки
sns.boxplot(y='sqft_living', data=df)
sns.boxplot(y='floors',color='#2ecc71', data=df)
sns.boxplot(y='sqft_living15',color='#9b59b6', data=df)
plt.rcParams['figure.figsize']=4,4
sns.boxplot(y='price', x='waterfront', data=df)
sns.boxplot(y='price', x='view' , data=df)
sns.boxplot(y='price', x='condition' , data=df)
sns.boxplot(y='price', x='grade' , data=df)
```
А вот с sqft\_lot и sqft\_lot15 нужно что-то придумать и из-за больших значений вполне подойдет логарифмирование:
```
df['sqft_lot']=np.log(df['sqft_lot'])
df['sqft_lot15']=np.log(df['sqft_lot15'])
```
sqft\_lot до и после:
sqft\_above и sqft\_basement – составные части sqft\_living, поэтому также трогать их не будем.
На этом с предварительным анализом мы закончим и посмотрим на тепловую карту корреляций:
```
sns.heatmap(df.corr(), cmap = 'viridis',annot = True)
```
Изучив карту корреляций видим, что иногда признаки сильно коррелированы между собой, поэтому удалим часть признаков с высокой корреляцией – sqft\_lot15 (оставим sqft\_lot), yr\_built (оставим yr\_renovated), sqft\_above (sqft\_living).
На этом закончим работу с данными и перейдем к созданию модели.
2. Моделирование
В данной части мы построим 2 модели: линейную регрессию и дерево решений.
Все необходимые нам модели содержаться в библиотеке sklearn.
Для начала отделим целевую переменную от остальных данных для обучения, а также разделим выборки на обучающую (70%) и тестовую (30%, на которой мы проверим как работает модель):
```
Y=df['price']
X=df.drop ('price',axis=1)
from sklearn.model_selection import train_test_split
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0.3, shuffle = True)
```
Также из sklearn для оценки модели загрузим 3 метрики — mean\_absolute\_error (средняя абсолютная ошибка), mean\_squared\_error (Среднеквадратическое отклонение), r2\_score (коэффициент детерминации):
```
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
```
Начнем с линейной регрессии:
```
from sklearn.linear_model import LinearRegression
LR = LinearRegression() #Создаем модель
LR.fit(X_train, Y_train) #Обучаем модель
Y_LR = LR.predict(X_test) #Предсказываем значения для выборки
print ('MAE:', round (mean_absolute_error(Y_test, Y_LR),3)) #Метрики
print ('√MSE:', round (mean_squared_error(Y_test, Y_LR)**(1/2),3))
print ('R2_score:', round (r2_score(Y_test, Y_LR),3))
```
MAE: 124477.452
√MSE 175205.645
R2\_score: 0.627
Дерево решений:
```
from sklearn.tree import DecisionTreeRegressor
TR = DecisionTreeRegressor() #Создаем модель
TR.fit(X_train, Y_train) #Обучаем модель
Y_TR=TR.predict(X_test) #Предсказываем значения для выборк
print ('MAE:', round (mean_absolute_error(Y_test, Y_TR),3)) #Метрики
print ('√MSE:', round (mean_squared_error(Y_test, Y_TR)**(1/2),3))
print ('R2_score:', round (r2_score(Y_test, Y_TR),3))
```
MAE: 151734.906
√MSE 220856.721
R2\_score: 0.407
Исходя из метрик можно сделать вывод о том, что Линейная регрессия показала лучший результат, поэтому логичнее выбрать ее. Однако, мы не задавались вопросами из чего состоит ошибка модели, не является ли модель переобученной, и пр. Вполне вероятно, что к ухудшению результата DecisionTreeRegressor приводит именно переобучение, так как мы даже не ограничивали глубину дерева в параметрах модели. Можем легко проверить это перебрирая глубину деревьев в коротком цикле:
```
dep,score=[],[]
for i in range(3,16):
TR = DecisionTreeRegressor(max_depth=i)
TR.fit(X_train, Y_train)
Y_TR=TR.predict(X_test)
dep.append(i)
score.append(mean_squared_error(Y_test, Y_TR)**(1/2)) #Массив значений √MSE
plt.rcParams['figure.figsize']=6,3
plt.plot(dep, score)
```
Очевидно, что лучший показатель при max\_depth=7, и, посмотрев, на метрики (MAE: 124861.441, √MSE 175322.737, R2\_score: 0.626) становиться понятно, что модель с таким ограничением аналогична линейной регрессии по качеству.
Также мы можем попробовать оценить какие признаки оказались наиболее важны для модели для прогноза стоимости:
Исходя из графика видно, что на стоимость больше всего влияет grade – общая субъективная оценка дома риелторской компанией (что, кстати, говорит о компетентности оценки :-))), на втором месте – площадь дома, а на третьем – год последнего ремонта. Показатели количества спален, ванных комнат, этажей же модель посчитала незначимыми для прогноза.
Для лучшего понимания результатов, посчитаем среднюю ошибку в % — по линейной регрессии средняя ошибка 27,5%, то есть модель ошибается чуть больше, чем на четверть при прогнозе стоимости дома, что довольно много.
Можно ли улучшить результаты? Да, несомненно, на текущем этапе мы получили только базовое решение – некую отправную точку для сравнения лучше или хуже будут модели, которые мы можем создать более сложными методами или применяя более сложную обработку данных.
Мы только чуть-чуть затронули вопрос переобучения и совсем не прикасались к тому, из чего состоит ошибка модели и многим другим аспектам создания модели. Как правило, для ответов на эти вопросы и нахождения оптимального решения используют разнообразные методы валидации моделей, но об этом мы напишем в следующих статях. | https://habr.com/ru/post/505516/ | null | ru | null |
# Идиомы С++. Type erasure
Хотите получить представление о том, как устроен *boost::function*, *boost::any* “под капотом”? Узнать или освежить в памяти, что скрывается за непонятной фразой “стирание типа”? В этой статье я постараюсь кратко изложить мотивацию, стоящую за этой идиомой и ключевые элементы реализации.
#### Мотивация
Как положить в один контейнер объекты никак не связанных друг с другом типов? Например, прочитанные из командной строки опции сразу “разложить” по разным типам и положить в единый контейнер. Или хранить внутри одного объекта “нечто” произвольного типа с единственным ограничением — наличием оператора “()” у хранимого “нечто”? Как, в общем случае, “стереть” тип любого объекта, скрыв его за объектом другого, некоего общего типа?
#### void\*
На самом деле в С++ есть встроенный механизм, позволяющий скрыть тип любого объекта за общим типом. Это — доставшийся в наследство от С, указатель *void\**.
Его можно использовать, например, так:
```
struct A{ void foo(); };
struct B{ int bar(double); };
A a;
B b;
std::vector v;
v.push\_back(&a);
v.push\_back(&b);
static\_cast(v[0])->foo();
static\_cast(v[1])->bar(3.5);
```
Или так:
```
class void_any
{
public:
void_any(const void* h, size_t size) : size_(size)
{
h_ = std::malloc(size);
std::memcpy(h_, h, size);
}
void get(void*& h)
{
h = std::malloc(size_);
std::memcpy(h, h_, size_);
}
~void_any(){ std::free(h_); }
private:
size_t size_;
void* h_;
};
int some_int=675321;
void_any va(&some_int, sizeof(int));
void* pi;
va.get(pi);
std::cout << *(int*)pi << std::endl;
```
Такая схема будет работать, но, думаю, её недостатки очевидны. Можно ошибиться при касте, передать неверный размер в конструктор, нельзя использовать с *rvalue* выражениями. Мы заставляем пользователя помнить о том, объект какого именно типа хранится в указателе и “вручную” приводить к этому типу. Ну а самое главный недостаток, пожалуй, в том, что мы никак не используем систему типов языка на котором пишем. Все равно что забивать гвоздь шуруповертом. Можно, но неудобно. Так как же быть?
#### Шаблоны и наследование
Вы уже наверное догадались, что без шаблонов здесь не обойдется. Да, действительно, в конструктор шаблонного класса (шаблонную функцию) можно передать объект любого типа и, тем самым, скрыть его тип, но этим мы не решим второй проблемы, а именно, скрыть объект любого типа за объектом **одного общего** типа.
```
template
struct some\_t{};
some\_t s1;
some\_t s2;
```
Во фрагменте выше *s1* и *s2* после инстанциирования являются объектами абсолютно разных, несвязанных типов.
К счастью, С++ не ограничивается одними шаблонами. И нам на помощь придет наследование и динамический полиморфизм. Читайте следующий раздел, чтобы понять как именно.
#### Реализация
Итак, от слов к делу. Нам уже ясно, что наша “обертка” не должна быть шаблоном, но при этом должна быть способна в конструкторе принять объект любого типа. Как это возможно? Правильно, с помощью шаблонного конструктора.
```
class any
{
public:
template
any(const T& t);
//…
};
```
Но как теперь сохранить то, что нам передали в конструкторе? Наш класс ничего не знает о типе Т, параметризующем конструктор, поэтому так написать мы не можем:
```
class any
{
//...
private:
T t_;
};
```
Для решения этой проблемы мы будем хранить указатель на абстрактную вспомогательную структуру, а переданное нам в конструкторе *t*, отдадим в структуру-шаблон, наследующую от абстрактной вспомогательной базы.
```
class any
{
public:
any(const T& t) : held_(new holder(t)){}
//…
private:
struct base\_holder
{
virtual ~base\_holder(){}
};
template struct holder : base\_holder
{
holder(const T& t) : t\_(t){}
T t\_;
};
private:
base\_holder\* held\_;
};
```
Отлично! Теперь мы можем сохранить объект любого типа в классе *“any”*. Дело за малым, теперь сохраненный объект надо при необходимости каким-то образом “достать” из недр нашей обертки. Для этого, к сожалению, нам придется воспользоваться *RTTI*. Добавим функцию, возвращающую информацию о типе хранимого значения в наши вспомогательные структуры.
```
struct base_holder
{ //...
virtual const std::type_info& type_info() const = 0;
};
template struct holder : base\_holder
{ //...
const std::type\_info& type\_info() const
{
return typeid(t\_);
}
};
```
Теперь написать функцию возвращения исходного объекта не составит большого труда.
```
template
U cast() const
{
if(typeid(U) != held\_->type\_info())
throw std::runtime\_error("Bad any cast");
return static\_cast\* >(held\_)->t\_;
}
```
Почему *RTTI* нужно использовать к сожалению? Потому что, хотелось бы написать что-то вроде такого, чтобы перенести проверку типа в compile time:
```
U cast(typename std::enable_if\* >(held\_)->t\_)>::value>::type\* = 0) const
{
return static\_cast\* >(held\_)->t\_;
}
```
Почему такое решение не подходит? Дело в том, что
```
std::is_same\* >(held\_)->t\_)>::value
```
всегда будет *true*, независимо от того какой на самом деле тип объекта, хранящегося в *holder*. Такой код будет компилироваться и даже выполняться без падений (если повезет)
```
any a(2);
a.cast();
```
Но результаты будут совсем не те, что ожидает программист.
В классе *boost::function* используется тот же принцип стирания типа. Косметические отличия заключаются в том, что *function* — шаблон, параметризуемый типами возвращаемого значения и аргументов, а во вспомогательных структурах появляется функция
```
virtual return_type operator()(arg_type1, .., arg_typeN);
```
#### Листинг
```
class any
{
public:
template
any(const T& t) : held\_(new holder(t)){}
~any(){ delete held\_; }
template
U cast() const
{
if(typeid(U) != held\_->type\_info())
throw std::runtime\_error("Bad any cast");
return static\_cast\* >(held\_)->t\_;
}
private:
struct base\_holder
{
virtual ~base\_holder(){}
virtual const std::type\_info& type\_info() const = 0;
};
template struct holder : base\_holder
{
holder(const T& t) : t\_(t){}
const std::type\_info& type\_info() const
{
return typeid(t\_);
}
T t\_;
};
private:
base\_holder\* held\_;
};
int main()
{
any a(2);
std::cout << a.cast() << std::endl;
any b(std::string("abcd"));
try
{
std::cout << b.cast() << std::endl;
}
catch(const std::exception& e)
{
std::cout << e.what() << std::endl;
}
return 0;
}
``` | https://habr.com/ru/post/207294/ | null | ru | null |
# Адаптивный антивирус A3 самостоятельно обнаружил и исправил уязвимость ShellShock за 4 минуты
IT-специалисты из Университета Юты создали пакет программ, который не только выявляет и удаляет неизвестные ранее вирусы, но и исправляет последствия их работы. Проект под названием A3 (Advanced Adaptive Applications, а по-нашему — Передовые Приспосабливающиеся Программы, П3) работает с виртуальными машинами, запущенными на серверах.
В отличие от обычного антивируса, у которого есть каталог вирусов, по которому он пытается найти и обезвредить вредоносные программы, А3 отслеживает работу виртуалки и отмечает, когда что-то идёт не так (распознаёт подозрительное и нестандартное поведение системы). Одна из программ проекта записывает состояние виртуальной машины и при необходимости может «отмотать» запись для анализа и исправления.
На «показательных выступлениях» А3 распознал атаку [Shellshock](http://blog.regehr.org/archives/1187) ([печально известный баг bash](http://habrahabr.ru/company/mailru/blog/238475/)) и починил последствия на работающем сервере всего за 4 минуты.
В [отчёте о работе программы](http://blog.regehr.org/archives/1187) представлены подробности работы с этой уязвимостью. После попытки использовать уязвимость на тестовом сервере
```
GET /appstore/index.php HTTP/1.1
User-Agent: () { :;}; /bin/cat /home/mitll/passwd > /tmp/hello.txt
Host: 155.98.38.76:7701
Accept: */*
```
система защиты А3 сработала (попытка получения доступа к запрещённой директории). А3 за 2 минуты просканировал работу виртуальной машины, обнаружил запрещённый вызов, и ещё 1.5 минуты понадобилось ему для поиска проблемы в исходном коде Bash. После этого А3 пропатчил bash, отключив функциональность, приводящую к проблеме, и виртуальная машина продолжила работу в штатном режиме.
Эрик Эйде, представитель института, говорит в интервью на [сайте института](http://unews.utah.edu/news_releases/self-repairing-software-tackles-bugs/): «Здорово, что программа может быстро и без участия человека найти приемлемое решение и исправить серьёзную и весьма распространённую проблему в безопасности. Круто, что можно выбрать “уязвимость недели” и программа с ней справляется».
Пока проект находится в стадии «proof of concept», и разработчики рассматривают возможность его использования на реальных облачных сервисах. Потенциально возможно использовать такой софт на облачных хостингах типа Amazon: если вирус остановит или сломает выполнение виртуалки, программа может починить её и снова запустить автоматически. Проект пока не рассматривается как софт для домашнего использования, хотя в принципе это не исключено.
Проект A3 — часть обширной программы от DARPA под названием [CRASH](http://breakingdefense.com/2012/12/darpa-crash-program-seeks-to-reinvent-computers-for-better-secur/) (аббревиатура от «разработка надёжных, адаптивных, безопасных серверов с чистого листа»), в рамках которого пытаются придумать вариант более безопасной глобальной сети.
У проекта открытый исходный код — желающие могут ознакомиться с подробностями на [странице проекта](https://www.flux.utah.edu/project/a3). | https://habr.com/ru/post/356568/ | null | ru | null |
# Dagger 2. Subcomponents. Best practice. Part 2
Всем привет! В прошлый раз [мы разобрались с реализацией Subcomponent и случаями использования его на примере отдельно взятого экрана](https://habrahabr.ru/post/334710/). Здесь будет несколько отсылок к той статье, поэтому лучше сначала ознакомиться с ней.
Сегодня же мы обсудим создание **реальной** авторизованной зоны приложения и работу с соцсетями. Конечно же не без помощи Dagger’а!
Интересно? Добро пожаловать под кат!
**Абстрагируемся**
Предыдущая статья строилась на абстракции врача и ассистента, но чтобы описать заявленные во вступлении кейсы, я решил подобрать более подходящую.
Представьте крупный железнодорожный вокзал со всеми его развилками, семафорами и длинными грузовыми составами. На платформе 3-го пути под моросящим дождём ожидает свою электричку толпа народу. Вдалеке уже слышен звонкий гудок, люди встают со своих сумок, как вдруг… Долгожданный поезд прибывает на 7-й путь! Видать, машинист не перевел стрелку (а в нашем примере именно машинист переводит стрелки).
И, в общем-то, ничего страшного — добежать до нужной платформы через надземный переход. Страшно, что на 7-й путь с другой стороны подъезжает ТОВАРНЯК!
#### СТОП
Давайте разберемся, как так могло получиться? Причин может быть несколько:
* Первая — это, конечно, невнимательность. Возможно, наш железнодорожный дальнобойщик увлекся написанием смс жене, чтобы та ставила воду на пельмени.
* Нельзя отбросить и человеческий фактор, все-таки «путей много, а он один».
* А может быть он специально?! Ох уж эти нынешние нелегкие времена...
На самом же деле, причина здесь одна — это сама возможность машиниста поехать не туда. Он провел долгое время в пути и его не должна обременять еще и логистика каждого вокзала.
Фух… Как же все-таки хорошо, что в жизни машинист не сам переводит стрелки, а за него это делают **работники станции.**
Но причем тут авторизованная зона?
**Немного боли**
Допустим, перед нами стоит задача: авторизованный пользователь должен видеть одну анимацию, а аноним другую. В большинстве приложений, реализующих подобную логику, вы увидите примерно следующее:
```
if (userIsAuthourized) {
// Здесь может быть всё, что угодно. doSomething();
showAnimation();
} else {
// doOtherthing();
showOtherAnimation();
}
```
И увидите много раз :(
В лучшем случае мы будем иметь по два экземпляра каждого экрана, «зависимого» от состояния авторизации; с общим предком, реализующим основной функционал. И это еще не углубляясь в бизнес-логику…
Возможно, вы уже догадались, к чему я веду.
Переводя эту ситуацию на наш вокзал — ***каждый** машинист* (программный компонент) *самостоятельно выбирает, на какой путь ему прибывать* (какую анимацию отображать).
И тут важно понять, что такая реализация не является именно авторизованной зоной (причина, почему я выделил слово «реальной» в предисловии). «Зона» означает, что из текущего объекта (или состояния) доступен только один определенный функционал — либо пользовательский, либо анонимный. В данной же реализации объект сам решает, к чему обращаться, и, по идее, может обратиться из одной «зоны» к функционалу другой «зоны». That’s wrong.
Да и, опять-таки, это — логика, которой не должно быть в нашем компоненте.
**Время перемен**
Любой функционал, метод или кусок кода можно вынести в класс, чтобы в дальнейшем иметь возможность предоставить или подменить его объект. Вынесем анимацию в UserAnimationFunction и AnonymousAnimationFunction соответственно. Ну и, как мы это уже умеем, заинжектим.
**Преобразование 1**
```
@Inject
UserAnimationFunction userAnimationFunction;
@Inject
AnonymousAnimationFunction anonymousAnimationFunction;
```
От злосчастного if мы, конечно, пока не ушли.
```
if (userIsAuthourized) {
userAnimationFunction.show();
} else {
anonymousAnimationFunction.show();
}
```
**Правильная мысль:**
*Машинист должен просто сообщить о том, что он прибывает, а уже работники станции подготовят для него определенный путь.*
(равно как)
*Программный компонент должен сообщить о необходимости показать анимацию, а ответственный за анимацию объект уже сам решит, какую именно.*
Это — ничто иное, как интерфейс. Определим единый интерфейс для наших анимаций:
```
public interface AuthDependentAnimationFunction {
void show();
}
```
Тогда нам останется лишь вызвать тех самых работников станции, которые выберут за нас путь. Наш компонент должен прийти к виду:
**Преобразование 2**
```
@Inject
AuthDependentAnimationFunction animationFunction;
...
animationFunction.show();
```
**Спроси меня, «как?»**
Вся магия становится возможной с помощью Subcomponent’ов. Как вы помните, в прошлой статье мы использовали Subcomponent’ы, чтобы каждый экран имел собственный граф зависимостей. Время жизни такого графа зависело от времени жизни экрана.
В нашем случае мы будем иметь 2 графа зависимостей: один для авторизованной зоны и другой — для анонимной. Не трудно догадаться, что время жизни будет зависеть от времени авторизованности.
Зачастую, запросы к API включают некоторый токен пользователя, а потому такой токен можно взять за **ядро** нашего авторизованного графа.
Для анонимного графа можно ядро опустить (всё на ваш вкус, можно опустить ядро и для авторизованного).
**Схематично наша система будет выглядеть так:**
Вы, наверное, обратили внимание на интерфейс AuthDependentComponent. Работая с интерфейсами, в своем программном компоненте мы избавились от всех кейсов выбора логики, кроме одного. Наш выбор логики свелся к выбору Component’а для инъекции:
```
if (userIsAuthourized) {
App.getInstance().getUserComponent.inject();
} else {
App.getInstance().getAnonymousComponent.inject();
}
```
А общий интерфейс AuthDependentComponent для двух Subcomponent’ов как раз позволит избавиться и от этого кода.
```
public interface AuthDependentComponent {
void inject(SomeFragment fragment);
}
```
> **Обратите внимание.** AuthDependentComponent — это просто интерфейс без каких-либо аннотаций «Component», «Subcomponent» и т.п. Он необходим нам только как общий предок для двух Component’ов. Также в нём можно описывать inject-методы — Dagger реализует их для каждого из Component’ов наследников.
```
@UserScope
@Subcomponent(modules = UserModule.class)
public interface UserComponent extends AuthDependentComponent {
}
@Module
public class UserModule {
private String userToken;
public UserModule(String userToken) {
this.userToken = userToken;
}
@UserScope
@Provides
AuthDependentAnimationFunction provideAnimationFunction() {
return new UserAnimationFunction();
}
}
@AnonymousScope
@Subcomponent(modules = AnonymousModule.class)
public interface AnonymousComponent extends AuthDependentComponent {
}
@Module
public class AnonymousModule {
@AnonymousScope
@Provides
AuthDependentAnimationFunction provideAnimationFunction() {
return new AnonymousAnimationFunction();
}
}
@Singletone
@Component(modules = AppModule.class)
public interface AppComponent {
UserComponent userComponent(UserModule userModule);
AnonymousComponent anonymousComponent(AnonymousModule anonymousModule);
}
```
Единственным ответственным, знающим текущее состояние авторизованности, становится наш класс App, он и есть работник станции.
```
public class App extends Application {
private AuthDependentComponent authDependentComponent;
...
private void init() {
...
onUserLoggedIn();
}
public void onUserLoggedIn(String userToken) {
authDependentComponent = appComponent.userComponent(new UserModule(userToken));
}
public void onUserLoggedOut() {
authDependentComponent = appComponent.anonymousComponent(new AnonimousModule());
}
public AuthDependentComponent getAuthDependentComponent() {
return authDependentComponent;
}
}
```
В итоге наш экран будет выглядеть так:
```
@Inject
AuthDependentAnimationFunction animationFunction;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
App.getInstance().getAuthDependentComponent().inject(this);
}
public void showAnimation() {
animationFunction.show();
}
```
**Что касается перехода между зонами**
На своей практике я встречал полное пересоздание всех компонентов приложения при смене состояния авторизованности. В принципе — это нормально, т.к. зачастую различия в зонах существенные. В случае пересоздания вновь созданный экран получит себе зависимости уже из соответствующей зоны, т.е. наш код не нуждается в доработках.
Если же ваша логика предусматривает незначительные различия в логике, вы можете обратить внимание на реинжект зависимостей. По сути, при изменении состояния авторизованности просто принудительно вызывайте inject() для программного компонента:
```
App.getInstance().getAuthDependentComponent().inject(this);
```
Так ранее созданные зависимости из старого компонента перепишутся зависимостями из нового.
#### БОНУС
**Кажется, я что-то упоминал о соцсетях?**
Проблема в том, что разработчики разных соцсетей реализовали свои API кто во что горазд. Кто пробовал поддерживать больше чем одну соцсеть одновременно, тот знает. Однако, суть методов этих API примерно одинакова:
— Публикация постов;
— Публикация фотографий;
— Изменение статуса;
— и т.п.
Чтобы всё было красиво, возьмите пример с авторизованной зоной и представьте, что каждая социальная сеть — это отдельная зона. Таким образом, для каждой зоны у вас будет свой Component, предоставляемый в зависимости от того, в какой из соцсетей авторизован пользователь. А работа с API будет происходить опять-таки через интерфейс с вышеописанными функциями, реализованными для каждой соцсети по-разному. Just do it! :)
[Пример с реализацией работы с соц.сетями на github](https://github.com/udy18rus/dagger2sample2)
#### ИТОГ ДВУХ СТАТЕЙ
**Как найти участки кода, где Dagger пришелся бы кстати?**
* Во-первых, это ветвления достаточно большой части логики, будь то бизнес-логика или UI/UX.
* Во-вторых, в большинстве случаев это создание нового объекта, т.е. ориентируемся на ключевое слово new, либо фабричные методы.
В общем-то, желаю всем удачи в постижении Dagger’а и паттерна Dependency Injection.
Пишите свои интересные кейсы и задачи в комментариях, ну и следите за новостями! | https://habr.com/ru/post/337070/ | null | ru | null |
# Место Java в мире HFT
В статье автор пытается проанализировать почему существуют торговые системы написанные на Java. Как может Java соперничать в области высокой производительности с C и C++? Далее размещены небольшие размышления о достоинствах и недостатках использования Java в качестве языка программирования/платформы для разработки систем HFT.
Небольшой дисклеймер: мир Java широк, и в статье я буду подразумевать именно HotSpot реализацию Java, если не сказано обратное.
1. Введение
-----------
Хочется намного рассказать про место Java в мире HFT. Для начала, давайте определимся с тем, что же такое HFT (High Frequency Trading). У этого термина существует несколько определений, объясняющих различные его аспекты. В контексте данной статьи я буду придерживаться объяснения, которое дал Питер Лаури (Peter Lawrey), создатель Java Performance User’s Group: «HFT — это торговля, которая быстрее скорости реакции человека (faster than a human can see)».
Торговые платформы HFT могут анализировать различные рынки одновременно и запрограммированы на проведение сделок в наиболее подходящих рыночных условиях. Применяемая прогрессивная технология дает возможность невероятно быстро обрабатывать данные тысячи транзакций в день, при этом извлекая лишь небольшую прибыль с каждой сделки.
Под данное определение подпадает вся электронная автоматической торговли с характерными временами сотни миллисекунд и меньше, вплоть до микросекунд. Но если достигнуты скорости в единицы микросекунд, то зачем в таком случае нужны системы, которые работают на порядок медленнее? И как они могут зарабатывать деньги? Ответ на этот вопрос состоит из двух частей:
1. Чем быстрее должна быть система, тем проще должна быть заложенная в нее модель. Т.е. если наша торговая логика реализована на FPGA, то о сложных моделях можно забыть. И наоборот, если мы пишем код не на FPGA или plain assembler, то мы должны закладывать в код более сложные модели.
2. Сетевые задержки. Оптимизировать микросекунды имеет смысл только тогда, когда это ощутимо может сократить суммарное время обработки, которое включает сетевые задержки. Одно дело, когда сетевые задержки — это десятки и сотни микросекунд (в случае работы только с одной биржей), и совершенно другое — 20мс в каждую сторону до Лондона (а до Нью-Йорка еще дальше!). Во втором случае оптимизация микросекунд, затраченных на обработку данных, не принесет ощутимого сокращения суммарного времени реакции системы, в которое входит сетевая задержка.
Оптимизация HFT систем в первую очередь преследует сокращение не суммарной скорости обработки информации (throughput), а времени отклика системы на внешнее воздействие (latency). Что это значит на практике?
Для оптимизации по throughput важна результирующая производительность на длительном интервале времени (минуты/часы/дни/…). Т.е. для подобных систем нормально остановить обработку на какой-то ощутимый промежуток времени (миллисекунды/секунды), например на Garbage Collection в Java (привет, Enterprise Java!) если это не влечет существенного снижения производительности на длительном интервале времени.
При оптимизации по latency в первую очередь интересна максимально быстрая реакция на внешнее событие. Подобная оптимизация накладывает свой отпечаток на используемые средства. Например, если для оптимизации по throughput обычно используются примитивы синхронизации уровня ядра ОС (например, мьютексы), то для оптимизации по latency зачастую приходится использовать busy-spin, так как это минимизирует время отклика на событие.
Определив, что такое HFT, будем двигаться дальше. Где же место Java в этом «дивном новом мире»? И как Java может тягаться в скорости с такими титанами, как C, C++?
2. Что входит в понятие «производительность»
--------------------------------------------
В первом приближении, разделим все аспекты производительности на 3 корзины:
1. CPU-производительность как таковая, или скорость выполнения сгенерированного кода,
2. Производительность подсистемы памяти,
3. Сетевая производительность.
Рассмотрим каждую составляющую подробнее.
### 2.1. CPU-performance
**Во-первых**, в арсенале Java есть самое важное средство для генерации действительно быстрого кода: реальный профиль приложения, то есть понимание, какие участки кода «горячие», а какие нет. Это критически важно для низкоуровневого планирования расположения кода.
Рассмотрим следующий небольшой пример:
```
int doSmth(int i) {
if (i == 1) {
goo();
} else {
foo();
}
return …;
}
```
При генерации кода у статического компилятора (который работает в compile-time) физически нет никакой возможности определить (если не брать в расчет PGO), какой вариант более частый: i == 1 или нет. Из-за этого, компилятор может лишь догадываться, какой сгенерированный код быстрее: #1, #2, или #3. В лучшем случае статический компилятор будет руководствоваться какой-либо эвристикой. А в худшем просто расположением в исходном коде.
**Вариант #1**
```
cmpl $1, %edi
je .L7
call goo
NEXT:
...
ret
.L7:
call foo
jmp NEXT
```
**Вариант #2**
```
cmpl $1, %edi
jne .L9
call foo
NEXT:
...
ret
.L9:
call goo
jmp NEXT
```
**Вариант #3**
```
cmpl $1, %edi
je/jne .L3
call foo/goo
jmp NEXT:
.L3:
call goo/foo
NEXT:
…
ret
```
В Java же из-за наличия динамического профиля, компилятор всегда знает какой вариант предпочесть и генерирует код, который максимизирует производительность именно для реального профиля нагрузки.
**Во-вторых**, в Java есть так называемые спекулятивные оптимизации. Поясню на примере. Допустим, у нас есть код:
```
void doSmth(IMyInterface impl) {
impl.doSmth();
}
```
Вроде бы все понятно: должен сгенерироваться вызов виртуальной функции doSmth. Единственное, что могут сделать статические компиляторы С/С++ в данной ситуации — попытаться выполнить девиртуализацию вызова. Однако на практике данная оптимизация случается относительно редко, так как для ее выполнения необходима полная уверенность в корректности данной оптимизации.
У компилятора Java, работающего в момент работы приложения, есть дополнительная информация:
* Полное дерево загруженных в данный момент классов, на основе которого можно эффективно провести девиртуализацию,
* Статистика о том, какая реализация вызывалась в данном месте.
Даже если в иерархии классов есть другие реализации интерфейса IMyInterface, компилятор выполнит встраивание (inline) кода реализации, что позволит, с одной стороны, избавиться от относительно дорогого виртуального вызова и выполнить дополнительные оптимизации с другой стороны.
**В-третьих**, компилятор Java оптимизирует программу под конкретное железо, на котором он был запущен.
Статические компиляторы вынуждены использовать только инструкции достаточно древнего железа для обеспечения обратной совместимости. В результате, все современные расширения, доступные в расширениях x86, остаются за бортом. Да, можно компилировать под нескольких наборов инструкций и во время работы программы делать runtime-dispatching (например, с использованием ifunc'ов в LINUX), но кто это делает?
Компилятор Java знает на каком конкретном железе он запущен и может оптимизировать код под данную конкретную систему. Например, если система поддерживает AVX, то будут использоваться новые инструкция, оперирующие новыми векторными регистрами, что значительно ускоряет работу вычислений с плавающей точкой.
### 2.2. Производительность подсистемы памяти
Выделим несколько аспектов производительности подсистемы памяти: паттерн доступа к памяти, скорость аллокации и деаллокации (освобождения) памяти. Очевидно, что вопрос быстродействия подсистемы памяти крайне обширен и не может быть полностью исчерпан 3 рассматриваемыми аспектами.
#### 2.2.1 Паттерн доступа к памяти
В разрезе паттерна доступа к памяти наиболее интересен вопрос в различии физического расположения объектов в памяти или data layout. И тут у языков С и С++ огромное преимущество — ведь мы можем явно управлять расположением объектов в памяти, а отличии от Java. Для примера рассмотрим следующий код на C++):
```
class A {
int i;
};
class B {
long l;
};
class C {
A a;
B b;
};
C c;
```
При компиляции данного кода компилятором C/C++, поля полей-подобъектов будут физически расположены последовательно, примерно таким образом (не учитываем возможный паддинг между полями и возможные data-layout трансформации, производимые компилятором):
Т.е. выражение виде ‘return c.a.i + c.b.l’ будет скомпилировано в такие инструкции ассемблера x86:
```
mov (%rdi), %rax ; << чтение c.a.i
add ANY_OFFSET(%rdi), %rax ; << чтение c.b.l и сложение с c.a.i
ret
```
Такой простой код был достигнут за счет того, что объект располагается линейно в памяти и компилятор на этапе компиляции смещения требуемых полей от начала объекта. Более того, при обращении к полю c.a.i, процессор загрузит всю кэш-линию длиной 64 байта, в которую, скорее всего, попадут и соседние поля, например c.b.l. Таким образом, доступ к нескольким полям будет относительно быстрый.
Как же будут располагаться данный объект в случае использования Java? В виду того, что объекты не могут быть значениями (в отличии от примитивных типов), а всегда ссылочные, то в процессе выполнения данные будут располагаться в памяти в виде древовидной структуры, а не последовательной области памяти:
И тогда выражение ‘c.a.i + c.b.l’ будет компилироваться в лучшем случае во что-то похожее на такой код ассемблера x86:
```
mov (%rdi), %rax ; << загружаем адрес объекта a
mov 8(%rdi), %rdx ; << загружаем адрес объекта b
mov (%rax), %rax ; << загружаем значение поля i объекта a
add (%rdx), %rax ; << загружаем значение поля l объекта b
```
Мы получили дополнительный уровень косвенности при обращении к данным внутри объектов-полей, так как в объекте типа С находятся всего лишь ссылки на объекты-поля. Дополнительный уровень косвенности ощутимо увеличивает количество загрузок данных из памяти.
#### 2.2.2. Скорость аллокации (выделения)
Тут у Java значительный перевес относительно традиционных языков с ручным управлением памятью (если не брать искусственный случай, что вся память выделяется на стеке).
Обычно для аллокации в Java используются так называемые TLAB'ы (Thread local allocation buffer), то есть области памяти, уникальные для каждого потока. Аллокация выглядит как уменьшение указателя, указывающего на начало свободной памяти.
Например, указатель на начало свободной памяти в TLAB'е указывает на 0х4000. Для аллокации, скажем, 16 байт нужно изменить значение указателя на 0х4010. Теперь можно пользоваться свежевыделенной памятью в диапазоне 0х4000:0х4010. Более того, так как доступ к TLAB'у возможен только из одного потока (ведь это thread-local buffer, как следует из названия), то нет необходимости в синхронизации!
В языках с ручным управлением памятью, для выделения памяти обычно используются функции operator new/malloc/realloc/calloc. Большинство реализаций содержат ресурсы, разделяемые между потоками, и намного более сложны, чем описанный способ выделения памяти в Java. В некоторых случаях нехватки памяти или фрагментации кучи (heap) операции выделения памяти могут потребовать значительного времени, что ухудшит latency.
#### 2.2.3. Скорость освобождения памяти
В Java используется автоматическое управление памятью и разработчик теперь не должен вручную освобождать выделенную ранее память, так как это делает сборщик мусора (Garbage collector). К достоинствам такого подхода следует отнести упрощение написания кода, ведь одним поводом для головной боли меньше.
Однако это приводит к не совсем ожидаемым последствиям. На практике разработчику приходится управлять различными ресурсами, не только памятью: сетевыми соединениями, соединениями с СУБД, открытыми файлами.
И теперь ввиду отсутствия в языке внятных синтаксических средств контроля за жизненным циклом ресурсов приходится использовать достаточно громоздкие конструкции типа try-finally или try-with-resources.
Сравним:
Java:
```
{
try (Connection c = createConnection()) {
...
}
}
```
или так:
```
{
Connection c = createConnection();
try {
...
} finally {
c.close();
}
}
```
С тем, что можно написать в С++
```
{
Connection c = createConnection();
} // деструктор будет автоматически вызван при вызоде из scope'а
```
Однако вернемся к освобождению памяти. Для всех сборщиков мусора, поставляемых с Java, характерна пауза Stop-The-World. Единственный способ минимизации ее влияния на производительность торговой системы (не забываем, что нам нужна оптимизация не по throughput, а по latency) — это уменьшить частоту любых остановок на Garbage Collection.
В настоящий момент наиболее употребимым способом это сделать является «переиспользование» объектов. То есть когда объект нам становится не нужен (в языках C/C++ необходимо вызвать оператор delete), мы записываем объект в некоторый пул объектов. А когда нам необходимо создать объект вместо оператора new, обращаемся к этому пулу. И если в пуле есть ранее созданный объект, то достаем его и используем, как будто он был только что создан. Посмотрим, как это будет выглядеть на уровне исходного кода:
Автоматическое управление памятью:
```
{
Object obj = new Object();
.....
// Здесь объект уже не нужен, просто забываем про него
}
```
И с переиспользованием объектов:
```
{
Object obj = Storage.malloc(); // получаем объект из пула
...
Storage.free(obj); // возвращаем объект в пул
}
```
Тематика переиспользования объектов, как мне кажется, не достаточно освещена и, безусловно, заслуживает отдельной статьи.
### 2.3. Сетевая производительность
Тут позиции Java вполне сравнимы с традиционными языками C и C++. Более того, сетевой стек (уровень 4 модели OSI и ниже), расположенный в ядре ОС, физически один и тот же при использовании любого языка программирования. Все настройки быстродействия сетевого стека, релевантные для C/C++, релевантны и для приложения на Java.
3. Скорость разработки и отладки
--------------------------------
Java позволяет намного быстрее развивать логику за счет намного большей скорости написания кода. Не в последнюю очередь, это является следствием отказа от ручного управления памятью и дуализма указатель-число. Действительно, зачастую быстрее и проще настроить Garbage Collection до удовлетворительного уровня, чем вылавливать многочисленные ошибки управления динамической памятью. Вспомним, что ошибки при разработке на C++ зачастую принимают совершенно мистический оборот: воспроизводятся в релизной сборке или только по средам (подсказка: в английском языке “среда” — самый длинный по написанию день недели). Разработка на Java в подавляющем большинстве случаев обходится без подобного оккультизма, и на каждую ошибку можно получить нормальный stack trace (даже с номерами строк!). Использование Java в HFT позволяет тратить на написание корректного кода существенно меньше времени, что влечет за собой увеличение скорости адаптации системы к постоянным изменениям на рынке.
4. Резюме
---------
В мире HFT то, насколько успешна торговая система зависит от суммы двух параметров: скорости самой торговой системы и скорости ее разработки, развития. И если скорость работы торговой системы — критерий относительно простой и понятный (по крайней мере понятно как измерять), то скорость развития системы ощутимо сложнее в оценке. Можно представить скорость развития как сумму бесчисленного множества факторов, среди которых и скорость написания кода и скорость отладки и скорость профилирования и удобство инструментальных средств и порог входа. Также, важными факторами являются скорость интеграции идей, полученный от аналитиков-квантов (Quantitative Researcher’ов), которые, в свою очередь, могут переиспользовать код продуктовой торговой системы для анализа данных. Как мне кажется, Java — разумный компромисс между всеми этими факторами. Этот язык сочетает в себе:
* достаточно хорошее быстродействие;
* относительно низкий порог входа;
* простоту инструментальных средств (К сожаления, для C++ нет сред разработки, сравнимых с IDEA);
* возможность простого переиспользования кода аналитиками;
* простоту работы под большими технически сложными системами.
Суммируя вышеперечисленное, можно резюмировать следующее: у Java в HFT есть своя существенная ниша. Использование Java, а не С++, ощутимо ускоряет развития системы. В вопросе производительности быстродействие Java может быть сравнимо с быстродействием C++ и кроме того, в Java есть набор уникальных, недоступных для С/С++ возможностей по оптимизации. | https://habr.com/ru/post/331608/ | null | ru | null |
# Красивые формы для приёма банковских карт с CardInfo.js
> **UPD. CardInfo больше не работает. Используйте BinKing.**
> ----------------------------------------------------------
>
>
>
> Гайд по использованию: https://habr.com/ru/post/527796/
>
> Сайт сервиса: https://binkng.io
Всем кто верстал, верстает или будет верстать форму для приёма банковских карт дарю плагин CardInfo.js, с помощью которого можно сверстать вот такую форму:
Плагин по номеру карты определяет один из 49 российских банков (потом и прочие страны добавлю), выдаёт вам логотип банка, цвета для фона, ссылку на сайт банка, определяет тип карты, его логотип и прочее. С этими данными делаете что хотите, верстаете любую форму.
Поиграться с формой можно [на демо странице.](http://srdm.io/%D0%B4%D0%B5%D0%BC%D0%BE/card-info) Код плагина и инструкции по установке [на гитхабе.](https://github.com/iserdmi/card-info)
Под катом:
* Пара слов о плагине;
* Про базу банков, и почему их 49, а не 50;
* Про логотипы банков;
* Про логотипы типов;
* Несколько моих вопросов к читателям;
CardInfo.js
===========
Плагин распространяется через NPM `npm install card-info` и через Bower `bower install card-info`. Подключается путём вставки JS файла в HTML страницу, или можно подключить его как модуль в стиле CommonJS или ES6. Подключить можно главный файл со всей логикой и всеми данными о банках (69 KB), или отдельно файл с логикой (5 KB) и отдельной базу банков для нужной страны (вообще пока есть только Россия, так что это на будущее), подробнее [в документации на гитхабе.](https://github.com/iserdmi/card-info) Плагин независим, то есть для своей работы не требует никаких дополнительных библиотек. Весь код плагина покрыт тестами. Работает даже в IE6. Можете погонять [тесты в браузере.](https://cdn.rawgit.com/iserdmi/card-info/158c9476/test/browser/main.html)
Создайте экземпляра класса CardInfo, передав в конструктор в качестве аргумента строку введённую пользователем в поле с номером карты `var cardInfo = new CardInfo(number)`. Экземпляр будет содержать объект с дополнительной информацией о карте:
* Тип карты (Master Card, Visa, и т.д.);
* Путь к логотипу типа (логотипы для каждого типа вместе с плагином, в белом, чёрном и цветном исполнении);
* Название банка на английском и локальном языке банка;
* Путь к логотипу банка (логотипы для каждого банка из базы распространяются вместе с плагином);
* Цвета в которые нужно окрасить форму;
* Цвет текста, который будет хорошо виден на предложенном фоне и будет сочетаться с логотипом;
* Ссылка на сайт банка;
* Название кода безопасности (CVC, CVV, CID или CVN) для данного типа карт;
* Длина кода безопасности для данного типа карты (Обычно 3, но для американ экспресс 4);
* Маска номера карты (Не всегда 0000 0000 0000 0000);
Все данные о банке определяются по первым 6 цифрам номера карты, данные о типе определяются по перым 1–2 цифрам номера карты. При вызове можно передать ещё и настройки, но об этом в полной мере написано [в документации на гитхабе.](https://github.com/iserdmi/card-info) и я не буду повторяться здесь.
Сам плагин никак не привязан к вёрстке и внешний вид формы вы можете сделать каким угодно используя данные полученные с помощью CardInfo.
База банков
===========
Про каждый банк в базе плагина известны следующие данные:
* Путь к логотипу банка;
* Название банка на английском;
* Название банка на языке той страны, в которой работает этот банк;
* Ссылки на сайт банка;
* Цвета, в которые стоит окрасить форму для этого банка;
* Цвет текста, который будет хорошо смотреться на форме и сочетаться с логотипом;
* Стиль логотипа: белый, чёрный или цветной (нужно для выбора подходящего логотипа типа, об этом в следующем разделе);
* Перечень шестизначных префиксов карт «BIN» соответствующих этому банку;
По BIN (префиксу) и определяется к какому банку принадлежит карта пользователя. Всего в базе 2573 префикса. В среднем на один банк приходится 52 префикса.
На сайте <http://www.banki.ru/> есть информация о 560 российских банках, если бы я нашёл префиксы для всех банков, файл с плагином весил бы много мегабайт. Если бы я скачал и обработал 560 логотипов, подобрал 560 раз цвета для формы и цвет текста, я бы скорее умер от тоски, чем выложил этот плагин.
По-этому было решено взять какое-то оптимальное количество банков, пусть будет 50. Я открыл [список банков отсортированный по финансовому рейтингу.](http://www.banki.ru/banks/?order=fin_rating) и взял 50 первых банков, которые занимаются выпуском кредитных или дебетовых карт. В общем, все самые популярные банки в базу попали.
Префиксы же я взял с сайта [BIN Codes.](https://www.bincodes.com/bin-search/) Возможно каких-то префиксов будет не хватать, какие-то будут неверно определять банк, но это будет скорее исключением. BIN Codes имеет платное АПИ, а если берут деньги, значит скорее всего делают более менее качественно. Также я сравнивал наличие некоторых префиксов в базах разных сайтах с префиксами и BIN Codes себя здорово проявили. Их АПИ позволяет только определить банк по префиксу, а передо мной стояла обратная задача. Я написал им, что хочу создать CardInfo.js и мне нужны префиксы 50 российских банков, я готов платить, но не понимаю, что мне делать, учитывая, что ваше АПИ мне помочь не может. И они, дай бог им здоровья, сказали что я могу просто воспользоваться разделом на их сайте, который задачу решает, но пока не отражён в их АПИ, в общем префиксы получилось достать бесплатно.
Информация по каждому банку содержится в отдельно JSON файле, в папке «banks». Когда я создавал базу этих файлов, я не переходил к следующему, пока не заполню все поля в одном файле и не скачаю логотип. В какой-то момент файлов стало много и я перестал понимать, сколько банков уже есть в моей базе. Проверял я так, смотрел информацию о папке и видел там количество файлов внутри папке. Когда их стало 50, я остановился. Но оказалось там спрятался файлик «.DS\_Store» который сам по себе создаётся почти во всех папках на маках, да ещё почему-то переставший отображаться даже со включенным отображением скрытых файлов. Вот у меня уже всё готово, а я понял что не доделал один банк. Но меня уже воротит от всех этих банков, так что пусть 49 и остаётся :–)
Логотипы банков
===============
Я старался как можно больше логотипов скачать в формате SVG, чтобы при масштабировании они смотрелись лучше, но некоторые удалось найти только в PNG. Все логотипы в исходном размере и формате лежат в папке «src/banks-logos», в папку «dist/banks-logos» были скопированы все SVG логотипы без изменений, а также все SVG и PNG были преобразованы в PNG и обрезаны до 600×200. В общем в папке «dist/banks-logos» есть логотип для каждого банка в формате PNG, а для некоторых ещё и в SVG. Вы можете сами порезать логотипы вызовом команды `npm run build-banks-logos` и передать в неё настройки, подробнее в документации.
Форма получается особенно красивой, если логотип белый, потому что тогда можно форму покрасить в яркие цвета. По-этому, когда это было возможно я редактировал логотип и перекрашивал его в белый цвет. А для Всероссийского Банка Развития Регионов пришлось вообще самому отрисовывать логотип, потому что в интернет я так и не нашёл их логотипа в более или менее потребном виде.
Логотипы типов
==============
Все логотипы типов есть и в SVG и в PNG. Типы есть следующие: Visa, MasterCard, American Express, Diners Club, Discover, JCB, UnionPay, Maestro или МИР. Для каждого типа есть логотип в трёх стилях: белый, чёрный и цветной. Первые 8 логотипов я позаимствовал [у Стюарта Колвиля](https://muffinresearch.co.uk/svg-credit-card-icons/), логотип платёжной системы МИР [у Евгения Катышева](http://evgenykatyshev.ru/notes/all/mir-logo/), а к общему стилю этот же логотип привёл самостоятельно.
У CardInfo существует настройка «brandLogoPolicy», которая определяет стиль логотип типа. Два самых крутых значения для неё это «auto» и «mono». Про остальные в документации.
### auto
Работает так, что если логотип банка чёрный/белый/цветной, то и логотип типа будет чёрным/белым/цветным. Выглядит эффектно, форма становится живой, и всё на ней сочетается.
### mono
Если фон светлый, то логотип типа будет чёрным, если фон тёмный, то логотип будет белым.
Заключение
==========
С CardInfo можно делать классные формы для приёма банковских карт. Я старался сделать этот плагин гибким, удобным, легковесным, надёжным и полезным, и думаю, что у меня получилось. Надеюсь вы будете использовать это плагин с удовольствием, а конверсии на ваших страницах оплаты вырастут. Если удовольствие от использования плагина начнёт зашкаливать, можете меня поблагодарить [на специальной странице для выражения благодарностей Сергею Дмитриеву :–)](http://srdm.io/%D1%81%D0%BF%D0%B0%D1%81%D0%B8%D0%B1%D0%BE)
Обратная связь
==============
* Интересно услышать ваше мнение о плагине и пожелания к дальнейшему развитию
* Если кто-то станет смотреть код, и захочет как-то прокомментировать, буду рад услышать критику
* Я впервые писал тесты, и тут особенно было бы интересно получить обратную связь
* Я собираюсь добавить банки других стран и начать продавать плагин через [CodeCanyon](https://codecanyon.net/) или что-то подобное. Вот только я совсем не могу понять, могу ли я вообще продавать его? Меня смущает то, что в плагине используются логотипы банков, которые мне не принадлежат, и логотипы типов, которые преимущественно нарисовал [Стюарт](https://muffinresearch.co.uk/svg-credit-card-icons/) и распространяет под лицензией MPL 2.0. | https://habr.com/ru/post/324738/ | null | ru | null |
# PHP: атрибуты vs аннотации: оптимизируем метадату Doctrine
```
php
#[ORM\Entity, ORM\Table(name: 'item_price')]
class ItemPrice
{
#[ORM\Id, ORM\Column(type: 'integer'), ORM\GeneratedValue]
private int $id;
#[
ORM\ManyToOne(targetEntity: Item::class, inversedBy: 'prices'),
ORM\JoinColumn(name: 'item_id', referencedColumnName: 'id')
]
private Item $item;
#[ORM\Column(type: 'string')]
private string $amount;
#[ORM\Column(type: 'string')]
private string $currency;
}</code
```
Одним из нововведений PHP 8.0 являются [атрибуты](https://www.php.net/releases/8.0/en.php#attributes). Атрибуты содержат метадату для классов, полей, функций; которая доступна через Reflection API. Казалось бы, то же самое, что и аннотации, тогда зачем обращать внимание на эту фичу?
Все отличие в структурированности. Аннотации являются простой строкой [phpDoc](https://github.com/php-fig/fig-standards/blob/master/proposed/phpdoc.md), а, следовательно, разработчику нужно использовать какой-то механизм для их обработки, чтобы извлечь нужную информацию.
Появляется необходимость парсинга в рантайме. Насколько это плохо? Рассмотрим, как это влияет на производительность на примере Doctrine.
---
[Doctrine](https://www.doctrine-project.org/), как любая ORM, широко использует метадату для своей работы. В частности - маппинги бизнес-сущностей на таблицы в БД. Есть разные реализации способа хранения метадаты:
* Драйвер XML
* Драйвер YAML
* Статический PHP драйвер
* PHP драйвер
* Драйвер аннотаций
* Драйвер атрибутов
В тестах рассмотрим аннотации и атрибуты. Дополнительно посмотрим на статический и обычный PHP драйвер, чтобы сравнить, насколько предыдущие способы уступают ручной инициализации метадаты. Не забудем взглянуть на драйвера аннотаций с кэшом на основе APCu и Redis с целью понять, решают ли они возможную проблему производительности.
Пример использования драйвера аннотаций
```
php
/**
* @ORM\Entity
* @ORM\Table(name="item_price")
*/
class ItemPrice
{
/**
* @ORM\Id
* @ORM\Column(type="integer")
* @ORM\GeneratedValue
*/
private int $id;
/**
* @ORM\ManyToOne(targetEntity="Item", inversedBy="prices")
* @ORM\JoinColumn(name="item_id", referencedColumnName="id")
*/
private Item $item;
/**
* @ORM\Column(type="string")
*/
private string $amount;
/**
* @ORM\Column(type="string")
*/
private string $currency;
}</code
```
Пример использования статического PHP драйвера
```
php
class ItemPrice
{
public static function loadMetadata(ClassMetadata $metadata): void
{
$metadata-setPrimaryTable([
'table' => 'item_price',
]);
$metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_AUTO);
$metadata->mapField([
'fieldName' => 'id',
'type' => 'integer',
'id' => true,
]);
$metadata->mapManyToOne([
'fieldName' => 'item',
'joinColumns' => [
[
'name' => 'item_id',
'referencedColumnName' => 'id',
],
],
'inversedBy' => 'prices',
'targetEntity' => Item::class,
]);
$metadata->mapField([
'fieldName' => 'amount',
'type' => 'string',
]);
$metadata->mapField([
'fieldName' => 'currency',
'type' => 'string',
]);
}
private int $id;
private Item $item;
private string $amount;
private string $currency;
}
```
В качестве теста я 10 минут 1 активным пользователем выполнял запросы на получение метадаты всех классов. Использовалась связка Nginx + PHP-fpm с включенным opcache. Исходники доступны [здесь](https://github.com/Aspirin4k/doctrine-metadata-driver-benchmark).
| | | | | |
| --- | --- | --- | --- | --- |
| **Драйвер** | **Всего запросов** | **Медиана** | **Минимум** | **95-перцентиль** |
| [**AnnotationDriver**](https://github.com/Aspirin4k/doctrine-metadata-driver-benchmark/blob/master/src/Annotation/Entity/Item.php) | **35044** | **16.81ms** | **13.8ms** | **19.16ms** |
| [**AttributeDriver**](https://github.com/Aspirin4k/doctrine-metadata-driver-benchmark/blob/master/src/Attribute/Entity/Item.php) | **106016** | **5.5ms** | **4.02ms** | **6.64ms** |
| [**StaticPHPDriver**](https://github.com/Aspirin4k/doctrine-metadata-driver-benchmark/blob/master/src/Static/Entity/Item.php) | **114089** | **5.08ms** | **3.63ms** | **6.23ms** |
| [**PHPDriver**](https://github.com/Aspirin4k/doctrine-metadata-driver-benchmark/blob/master/src/Include/Metadata/App.Include.Entity.Item.php) | **98042** | **5.48ms** | **3.76ms** | **7.47ms** |
| **Redis Cache** | **36057** | **16.2ms** | **11.67ms** | **19.94ms** |
| **APCu Cache** | **38943** | **15.06ms** | **10.83ms** | **18.51ms** |
Атрибуты показали неплохую производительность на уровне драйверов, использующих PHP-код. Разницу между AttributeDriver, StaticPHPDriver и PHPDriver, думаю, можно считать погрешностью. Главное, что можно увидеть по результатам тестирования - **аннотации в 3 раза медленнее!** Интересен так же тот факт, что кэширование не всегда может помочь ускорить приложение - в Doctrine метадата для каждого класса кэшируется отдельной записью. Это приводит к тому, что ее выгрузка и десериализация для каждого класса в отдельности выходит ненамного быстрее.
---
Если вы ищите способ оптимизировать ваше legacy приложение, и все запросы к БД уже давно проверены, возможно аннотации контроллеров и сущностей ORM - ваша следующая цель.
Тут можно столкнуться с проблемой: legacy - это когда куча кода, а теперь его нужно весь переписывать? Эту проблему можно решить с помощью еще одного варианта, который вы могли видеть в результатах бенчмарка - кодогенерации:
| | | | | |
| --- | --- | --- | --- | --- |
| **Драйвер** | **Всего запросов** | **Медиана** | **Минимум** | **95-перцентиль** |
| [**Generated Static**](https://github.com/Aspirin4k/doctrine-metadata-driver-benchmark/blob/master/src/Generator/cli-generate.php) | **102124** | **5.59ms** | **3.7ms** | **7.38ms** |
Этот вариант позволяет продолжать использовать аннотации, не переписывая весь проект, при этом получая бонусы производительности - ведь аннотации генерируются в код, а код попадает в opcache!
---
Резюмируя:
* Стоит ли использовать в новых приложениях атрибуты вместо аннотаций везде, где это представляется возможным? Однозначно да.
* Нужно ли переписывать аннотации в legacy проекте на атрибуты? Зависит от нефункциональных требований, возможно вам поможет кодогенерация. Например, [подобный скрипт](https://github.com/Aspirin4k/doctrine-annotation-static-reader) мы используем у себя на продакшене. (Еще рабочим вариантом может оказаться автоматический рефакторинг средствами [rector](https://getrector.org/blog/how-to-upgrade-annotations-to-attributes))
Надеюсь, статья была полезна и познакомила вас с ещё одним преимуществом атрибутов перед аннотациями. | https://habr.com/ru/post/686796/ | null | ru | null |
# Релиз CLion 2016.1: новые инструменты и новые языки
Привет, Хабр!
У нас сегодня отличные новости — вышел очередной релиз нашей кросс-платорфменной среды для разработки на C и C++, CLion 2016.1.
Версия 2016.1
=============
Вы, наверное, немного удивлены номером версии. Ближайшие релизы других наших десктопных инструментов, кстати, имеет такую же версию, начиная с IntelliJ IDEA 2016.1. В чем же смысл? Если коротко, то теперь все продукты в рамках пакета JetBrains All Products (то есть все десктопные инструменты) получают обновления примерно в одно и тоже время несколько раз в год. Таким образом, версия — это просто год и последовательный номер “пачки” релизов. Основные возможности, реализованные в платформе, попадают во все IDE одновременно, и такая унификация версий позволяет легче ориенироваться в платформенных изменениях.
Кроме того, мы решили отказаться от схемы выпуска мажорных-минорных релизов. Теперь каждый релиз нацелен на то, чтобы принести пользу как новыми возможностям, так и постоянными баг-фиксами и улучшениями производительности. Подробно о причинах перехода и самой новой схеме можно почитать в [статье](//blog.jetbrains.com/blog/2016/03/09/jetbrains-toolbox-release-and-versioning-changes/) на англоязычном блоге компании.
А теперь — непосредственно о новых возможностях!
C++ парсер и улучшения по работе с кодом на C++
===============================================
Долгое время CLion поддерживал C++11 с ограничениями: некорректно обрабатывались *variadic templates*, *constexpr*, *user-defined литералы*. В этой версии мы взялись за то, что, как нам показалось, “мешает” большинству наших пользователей — **variadic templates**. Код, подчеркнутый красным, некорректные нотификации от анализатора кода, неверное автодополнение и другие проблемы зачастую были связаны именно с этой возможностью C++11. Реализация variadic templates позволила закрыть порядка сотни багов в нашем трекере! В частности, спешим обрадовать пользователей Qt библиотеки — [вызовы connect](http://www.ics.com/blog/qt-and-c11) теперь обрабатываются корректно, а встроенный анализатор кода не предупреждает о некорректных типах:
Какие-то связанные проблемы все еще есть, но их уже значительно меньше. А если вдруг мы еще о чем-то не знаем, обязательно добавляете репорты в наш [трекер](https://youtrack.jetbrains.com/issues/CPP).
Помимо прочего, мы наконец добились корректной работы **автоматического импортирования для символов из STL** (к сожалению, еще остаются проблемы при работе с [MinGW-w64](https://youtrack.jetbrains.com/issue/CPP-5894)). Теперь, если соответствующий заголовочный файл не подключен, а символ уже используется, CLion предлагает добавить нужную директиву `#include`:
Если в CLion поставить курсор на какой-нибудь символ и вызвать окно документации (`Ctrl+Q` для Linux/Windows, `F1` для OS X), можно посмотреть определение соответствующего символа и место, где он определен. В новой версии **окно документации** поддерживает гиперссылки на связанные топики, что существенно облегчает процесс чтения и понимания кода:
Отдельно упомянем новые **возможности кодогенерации** в коде на C++. Раньше для создания новых функций было две возможности — Override и Implement. Теперь появилась еще и Generate Definitions. Чем же они отличаются? По сути, мы выделили из Implement создание тела функции, а в Implement оставили только возможность генерации определения для чисто-виртуальных функций базовых классов. Новая функция доступна из меню генерации (`Alt+Insert` на Windows/Linux, `⌘N` на OS X), напрямую (`Shift+Ctrl+D` на Windows/Linux, `⇧⌘D` на OS X) и через *intention actions* (`Alt+Enter`):
Но главное даже не это. Самым важным улучшение является возможность генерировать функции in-place (не важно, через Override/Implement или через Generate Definitions), то есть там, где стоит курсор. Хотите получить тело функции в заголовочном файле — вызывайте функцию в соответствующем классе в этом заголовочном файле, хотите в .cpp файле — идите туда и вызывайте генерацию там. При наличии нескольких вариантов CLion уточнит, где именно вы хотите получить определение функции:
Управление директориями
=======================
CLion полагается на структуру проекта, которую задает CMake. То есть включены или не включены файлы в проект, где искать файлы из `#include` директив и т. д. А что, если среди файлов, которые стоит иметь включенными в проект, находятся еще и файлы логов или артифакты сборки? Как объяснить CLion, что не надо тратить время на индексацию таких директорий? Или как исключить библиотеку из контекста, в котором работают рефакторинги (вряд ли вам хочется, чтобы рефакторинги повлияли на код библиотеки, который, хоть и лежит внутри вашего проекта, но все же является сторонним)?
Для всех этих целей и реализована новая возможность **Mark directory as**:
Она дает возможность вручную разметить директории соответствующим образом. Выбор повлияет на работу:
* автодополнения и автоимпорта
* кодогенерации
* навигации на файл/класс/символ по его имени
* поиска по указанному пути
* рефакторингов
Так, например, рефакторинги и кодогенерация не будут работать в исключенных из проекта директориях (Excluded) или в библиотеках (Library Files). А навигация и поиск имеют специальные опции для отображения результатов поиска по библиотекам.
Чуть более подробно это расписано в [отдельном посте](//blog.jetbrains.com/clion/2015/12/mark-dir-as/) в нашем англоязычном блоге.
В дополнение к этому, если вы разрабатываете проект на одной машине, а собираете/запускаете на другой, в CLion 2016.1 появилась возможность настроить автоматическую синхронизацию файлов по FTP, FTPS или SFTP.
Отладчик
========
Одна из самых долгожданных возможностей — отладка процесса, запущенного на локальной машине, из IDE. Конечно, многие спросят, а как же [удаленная отладка](https://youtrack.jetbrains.com/issue/CPP-5539)? Пока нет, но до нее мы тоже доберемся!
К процессу можно подконектиться, указав его имя или идентификатор (pid). После установки соединения и при наличии исходного кода, открытого в CLion, Вам будут доступны все возможности встроенного отладчика — точки останова, просмотры значений переменных, вычисления выражений и пр.
Новые языки
===========
В CLion 2016.1 появилась встроенная поддержка Python, а также доступен для установки плагин для поддержки Swift. Если у вас смешанный проект на Python/C/C++ или вас интересует Swift IDE на Linux, то милости просим! В плагинах поддержаны:
* стандартные для наших IDE возможности редактора (подсветка, автодополнение, форматирование)
* навигация по коду и поиск
* анализатор кода (для Python)
* рефакторинги
* отладка
Подробнее про возможности плагинов см. в нашем блоге: [Python](//blog.jetbrains.com/clion/2016/01/python-support-in-clion/), [Swift](//blog.jetbrains.com/clion/2015/12/swift-plugin-for-clion/). А для короткого ознакомления предлагаем два видео:
И многое другое
===============
В этот релиз также вошли следующие изменения:
* Новая команда для сброса CMake Cache. Позволяет почистить CMake Cache и при этом не сбрасывать кеши и индексы самой IDE.
* Поддержка multiple working trees для Git.
* Автоматическое создание Google Test конфигураций при загрузке проекта при наличии в проекте CMake таргета, слинкованного с *gtest* библиотекой.
* Кастомный билд JRE на Linux с исправлениями от команды JetBrains.
И, наконец, небольшое видео, демонстрирующее новые возможности CLion 2016.1:
Об этих и других возможностях новой версии можно почитать [на сайте продукта](http://www.jetbrains.com/clion/whatsnew). Следите также за статьями в нашем [англоязычном блоге](//blog.jetbrains.com/clion/). Как обычно, есть [30-дневная бесплатная пробная версия](https://www.jetbrains.com/clion/download/), а в [разделе цен](//www.jetbrains.com/clion/buy/) можно узнать о стоимости. Мы будем рады ответить на любые ваши вопросы в комментариях.
*Ваша команда JetBrains CLion
The Drive to Develop* | https://habr.com/ru/post/279625/ | null | ru | null |
# Добавляем поддержку ECMAScript 2015 в ExtJS6
Добрый день, мир не стоит на месте, в прошлом году состоялся релиз ECMAScript 2015 (он же ES6), который привнес множество [нововведений](https://github.com/lukehoban/es6features), огорчает лишь одно ExtJS и Sencha cmd пока не научились поддерживать данную спецификацию. Причин для того, что бы уже сейчас разрабатывать приложение с учетом ES6 множество. Основные как мне видится — изучение нового стандарта (ваша рыночная конкурентно-способность возрастает) и создание более простого и лаконичного кода, который радует глаз. В данной статье показывается процесс добавления возможности писать ES6 код для ExtJS, с помощью кросс-компилятора [Babel](https://babeljs.io/) со сборкой на лету.
Настройка Babel
===============
Для начала, нам понадобится создать тестовое приложение
```
sencha -sdk "path\to\framework" generate app TestApp "path\to\application"
```
Так же нам понадобится [npm](https://nodejs.org/en/download/) для установки Babel. В корневой директории созданного приложения, создадим файл package.json с помощью команды
```
npm init
```
**Console output**
После ответов на некоторые вопросы файл будет успешно создан, далее необходимо установить сам кросс-компилятор и плагины к нему.
```
npm install babel-cli --save-dev
```
```
npm install babel-preset-es2015 --save-dev
```
Далее необходимо добавить команды сборки проекта, для этого добавляем в package.json секцию scripts. Так же не забудем добавить плагины для Babel, без них от просто не будет работать, для этого добавим секцию Babel.
```
...
"scripts" : {
"build-prod": "./node_modules/.bin/babel es6 -d app --comments=false --compact=true",
"build-debug": "./node_modules/.bin/babel es6 -d app --sourceMaps=true",
"watch": "./node_modules/.bin/babel es6 -d app --watch"
},
"babel": {
"plugins": [
"check-es2015-constants",
"transform-es2015-arrow-functions",
"transform-es2015-block-scoped-functions",
"transform-es2015-block-scoping",
"transform-es2015-classes",
"transform-es2015-computed-properties",
"transform-es2015-destructuring",
"transform-es2015-for-of",
"transform-es2015-function-name",
"transform-es2015-literals",
"transform-es2015-object-super",
"transform-es2015-parameters",
"transform-es2015-shorthand-properties",
"transform-es2015-spread",
"transform-es2015-sticky-regex",
"transform-es2015-template-literals",
"transform-es2015-typeof-symbol",
"transform-es2015-unicode-regex",
"transform-regenerator",
[ "transform-es2015-modules-commonjs", { "strict" : false }]
]
}
...
```
Настройка Sencha cmd
====================
Со стороны ExtJS проекта, необходимо перенести файл app.js из корня проекта в папку app. Далее папку app необходимо переименовать в es6.
```
mv app.js app
mv app es6
```
Не забудьте указать новое расположение app.js в файле app.json.
```
...
"js": [
...
{
"path": "app/app.js",
"bundle": true
}
]
....
```
Остался последний шаг, отредактируем файл build.xml в корне проекта, добавив в него следующую конструкцию внутрь тега project
```
npm run build-debug
```
Теперь при любых командах sencha (build, watch, refresh) проект будет пересобран на лету, весь исходный код приложения следует хранить в папке es6. Поздравляю, теперь вы можете двигаться в ногу со временем :) | https://habr.com/ru/post/281240/ | null | ru | null |
# Веб-контроль Raspberry Pi GPIO
Доброго времени суток! В этом посте я хочу показать, как управлять электроникой через Интернет используя Raspberry Pi. Выглядеть это будет примерно вот так.
**Краткое описание**:
* Серверная программа, которая работает на Raspberry Pi, для того чтобы читать переменные
* Базы данных MySQL для хранения переменных
* Веб-страница Apache2, для того чтобы контролировать переменные
#### Шаг 1. База знаний
Это уже **должно быть** на вашем Raspberry Pi:
* Веб-сервер Apache
* PHP5
* Сервер MySQL
* phpMyAdmin
Если хотите узнать, как всё это настроить, вам [сюда](http://www.instructables.com/id/Raspberry-Pi-Web-Server/) (инструкция на английском языке).
#### Шаг 2. Создание root аккаунта
Пропустите это, если у вас уже есть аккаунт, а если нет — продолжайте прочтение :)
Войдите в Raspberry Pi используя следующую команду:
`sudo -i`
`passwd root`
Теперь введите и подтвердите пароль для учётной записи.
Затем нужно закрыть SSH сессии и перезапустить его, войдя в систему как root.
#### Шаг 3. Настройка баз данных и phpMyAdmin
Это решение основано на базах данных MySQL, сейчас мы их и настроем.
Итак, для начала скачайте [этот файл](http://raspberrypi-gpio.googlecode.com/files/gpio.sql).
Залогиньтесь в панели управления phpMyAdmin и нажмите кнопку "**Import**" в верхнем меню.
Теперь, в пункте "**File to Import**", нажмите кнопку "**Choose File**" и выберите файл, который скачали до этого (gpio.sql).
И в завершении нажмите кнопку "**Go**" внизу страницы.
Это позволит создать все необходимые таблицы.
Теперь вам нужно добавить нового пользователя в базы данных используя phpMyAdmin. Для того чтобы это сделать, вам следует:
* Кликнуть на "**Users**" вверху страницы.
* Теперь жмите на ссылку "**Add User**".
* В поле "**User name**" введите нужное вам имя пользователя. У ввёл "**gpio**".
* В поле "**Host**" введите "**localhost**".
* Затем в двух полях введите подходящие пароли. (Без пробелов, переносов или специальных символов). Я ввёл "**pr03ND2**".
* Все остальное остальное оставьте по умолчанию, а затем нажмите кнопку "**Add User**" кнопку в правом нижнем углу.
В заключительной части этого шага нужно дать пользователю нужные привилегии.
* Нажмите на кнопку "**Users**" в верхнем меню, затем пролистывайте вниз до тех пор, пока вы не увидете только что добавленного вами пользователя в таблице "**Users Overview**".
* Напротив имени пользователя нажмите на ссылку "**Edit Privileges**".
* Листайте внизу к пункту "**Database-specific privileges**" и выберите "**gpio**" из выпадающего списка, нажмите кнопку "**Go**".
* Отметьте ВСЕ флажки и нажмите кнопку "**Go**" слева снизу.
#### Шаг 4. Shell Script
Это та часть, которая запускает проверку значений в базе данных MySQL на Raspberry Pi.
Этот сценарий довольно прост, но требует настройки.
Сперва скачайте скрипт, введя следующие команды (на Raspberry Pi):
* `sudo -i` и нажмите Return / Enter
* `wget raspberrypi-gpio.googlecode.com/files/GPIOServer.sh` и нажмите Return / Enter
После того, как он это скачает, введите
* `chmod +x GPIOServer.sh` и нажмите Return / Enter
* `nano GPIOServer.sh` и нажмите Return / Enter
Это позволит вам изменить сценарий.
Вы должны изменить следующие переменные в начале файла:
* `mysqlusername="ЗДЕСЬ ИМЯ ПОЛЬЗОВАТЕЛЯ"`
* `mysqlpassword="ЗДЕСЬ ПАРОЛЬ"`
Их нужно изменить на имя пользователя и пароль, которые вы создавали ранее в phpMyAdmin.
После того как всё изменили, удерживайте клавишу **Ctrl** и нажмите **X**, затем отпустите **Ctrl** и нажмите **Y**. Нажмите Return / Enter.
#### Шаг 5. Настройка веб-страницы
Финальный шаг, перед тем как вы сможете использовать это, — настройка веб-страницы.
Для этого, напишите следующие команды, убедившись, что вы залогинены (если нет — напечатайте `sudo -i`).:
* `wget raspberrypi-gpio.googlecode.com/files/control.php` и нажмите Return / Enter
* `wget raspberrypi-gpio.googlecode.com/files/off.jpg` и нажмите Return / Enter
* `wget raspberrypi-gpio.googlecode.com/files/on.jpg` и нажмите Return / Enter
Когда они скачаются, напишите вот это:
* `mv control.php /var/www/control.php` и нажмите Return / Enter.
* `chmod 755 /var/www/control.php` и нажмите Return / Enter.
* `mv off.jpg /var/www/off.jpg` и нажмитеReturn / Enter.
* `chmod 755 /var/www/off.jpg` и нажмите Return / Enter.
* `mv on.jpg /var/www/on.jpg` и нажмите Return / Enter.
* `chmod 755 /var/www/on.jpg` и нажмите Return / Enter.
Теперь вам нужно изменить пару переменных перед использованием файла, поэтому напишите `nano /var/www/control.php` и нажмите Return / Enter.
Измените следующие переменные:
* `$MySQLUsername = "ЗДЕСЬ ИМЯ ПОЛЬЗОВАТЕЛЯ";`
* `$MySQLPassword = "ЗДЕСЬ ПАРОЛЬ";`
Сейчас через браузер зайдите на страницу control.php (у меня [raspberryPi/control.php](http://raspberryPi/control.php), где raspberryPi — имя хоста.)
Там потребуется ввести следующие данные:
Имя пользователя: **admin**
Пароль: **gpio**
Я рекомендую нажать на ссылку «Change Password» сверху страницы и сменить пароль по очевидным причинам.
#### Шаг 6. Использование
Чтобы запустить программы GPIO, сделайте следующее:
Начните SSH сессию на Raspberry Pi и залогиньтесь как root, затем напечатайте `./GPIOServer.sh` и нажмите Return / Enter.
Он попросит ввести время ожидания, оно будет зависеть от потребностей ваших приложений. Но, чем короче время ожидания, тем больше ресурсов сценарий будет использовать (я обычно использую 5).
Готово! Теперь войдите в панель управления (http://ИМЯ ХОСТА/control.php) и наслаждайтесь!
*Для безопасности следует удалить root аккаунт.* | https://habr.com/ru/post/162651/ | null | ru | null |
# Синхронизация музыки и игровых событий на Unity
*Пример редактора уровня в игре.*
Если вы когда либо играли в игры типа Guitar Hero, Osu или Bit Trip Runner вы знаете, как сильно погружает в «поток» простая зависимость геймплея от музыки играющей на фоне. Удивительно, что таких игр, на самом деле не так уж и много. Кроме того, такая синхронизация может быть полезна для создания спецэффектов, но тем не менее почти нигде не встречается, кроме обозначенных выше игр типа rhythm. Вот и я решил воспользоваться таким бесхитростным приемом в собственной игре, а также поделиться наработками.
Я постарался описать конструкцию, удобную как для программирования большого количества игровых событий, так и работающую как можно более оптимальным образом. Применить которую можно почти в любой игре, возможно и вам она пригодится, если вы занимаетесь их разработкой.
Итак, для начала нужно определить класс-событие:
```
[Serializable]
public class Game_event {
public char key; //В зависимости от ключа будет происходить то или иное событие
public float time; //Момент старта события
[NonSerialized]public float finish_time; //Необходим, чтобы событие не было создано повторно после завершения
public bool isFinish(){
//Функция, проверяющая завершение события
return false;
}
public void Create(){
//Создаем необходимые для события объекты
//Важно, что бы все движения объектов зависели от (Main.sound_time - time)
}
public void Destroy(){
//удаляем их
}
public Game_event (float time, char key){
this.time = time;
this.key = key;
}
}
```
Далее, потребуется класс наследованный от MonoBehaviour, в котором будет основной код и, конечно, ссылка на звуковой объект. В моем случае это класс Main.
```
public static float sound_time=0; //глобальная переменная, в которой будет храниться текущее время проигрываемого звука
public static List game\_event = new List(); //список событий
void Update () {
sound\_time = sound.time;
//sound - объект типа AudioSource, содержащий проигрываемую музыку
foreach (Game\_event e in game\_event) {
if (sound\_time>=e.\_time && sound\_time
```
Есть несколько вариантов создания различных событий: путем перечисления непосредственно в коде Game\_event, создание дополнительных классов, либо использование скриптового языка вроде Lua, что конечно удобнее.
---
Редактор
========
Наиболее удобный способ редактирования, на мой взгляд, привязка определенных событий к клавишам, тогда создание уровня превращается в “игру на пианино”, где ваша задача лишь нажимать клавиши в ритм музыке. Именно поэтому в качестве ключа используются соответствующие символы.
Для реализации, потребуется определить доступные для ввода клавиши:
```
public static char[] keys_s = { 'Q','W','E','R','T',
'A','S','D','F','G',
'Z','X','C','V','B'};
//И добавить следующий код
void Update () {
…
Event c_e = Event.current;
if (c_e.isKey && c_e.type == EventType.KeyDown) {
if (Array.Exists(Main.keys_s, c=>c==c_e.keyCode.ToString()[0])) // Проверяем, существует ли нажатая клавиша в массиве допустимых
{
game_event.Add (new Game_event (sound_time,c_e.keyCode.ToString()[0]));
}
}
}
```
Теперь в момент нажатия клавиши, в список запишется соответствующее событие, которое будет проигрываться синхронно звуку.
Может быть очень удобно, подстраивать события под рисунок звуковой волны. Получить текстуру с ее изображением можно следующим способом:
```
float[] samples = new float[sound.clip.samples * sound.clip.channels];
sound.clip.GetData(samples, 0); //Получаем массив с данными сэмпла по которому будет строиться текстура
int frequency = sound.clip.frequency; //битрейт сэмпла
int scale = 10; //пикселей на 1с сэмпла
SoundTex = new Texture2D ((int)(sound.clip.length*sound.clip.channels*scale), 200);
int height = (int)(SoundTex.height / 2);
for (int i=0; i=0) {
c\_hi++;
s\_hi+=samples[k+i\*(int)(frequency/scale)];
}
else {
c\_low++;
s\_low+=samples[k+i\*(int)(frequency/scale)];
}
}
//Рисуем линию от среднего нижнего до среднего верхнего
//Поделена она на более светлую внутреннюю и более темную верхнюю часть, исключительно для красоты
for (int j=0; j<(int)(SoundTex.height); j++) {
if (j<(int)((s\_hi/c\_hi)\*height\*0.6f+height) &&
j>(int)((s\_low/c\_low)\*height\*0.6f+height))
SoundTex.SetPixel(i,j,new Color(0.7f,1,0.7f));
else
if (j<=(int)((s\_hi/c\_hi)\*height+height) &&
j>=(int)((s\_low/c\_low)\*height+height))
SoundTex.SetPixel(i,j,new Color(0,1,0));
else SoundTex.SetPixel(i,j,new Color(0,0,0,0));
}
}
SoundTex.Apply (); //Применяем изменение к текстуре
//Результат можно посмотреть на заглавной картинке
```
Посмотреть, как все работает в действии можно в этом видео: | https://habr.com/ru/post/242631/ | null | ru | null |
# Обработка большого количества задач при помощи delayed_job
Я большой фанат [resque](https://github.com/defunkt/resque), который использует [Redis](http://redis.io) в качестве хранилища, однако если есть необходимость быстро выполнить большое количество фоновых задач, в некоторых случаях **delayed\_job** может работать более эффективно благодаря тому, что он не вызывает [fork()](http://linux.die.net/man/2/fork) каждый раз при выполнении новой задачи.
**fork()** в **Linux** достаточно медленная операция несмотря на все прелести **Copy on Write**. В случае выполнения большого количества однородных задач нет никакого смысла порождать новый процесс для выполнения каждой задачи. Поэтому мы решили использовать [delayed\_job](http://github.com/collectiveidea/delayed_job), который выполняет все задачи в одном цикле последовательно друг за другом.
Преимущество понятно, попробую здесь изложить несколько подсказок как можно устранить недостатки тем самым ускорив выполнение. Я думаю, что это достаточно общеизвестные факты, но новичкам должно быть полезно.
##### Оборачивайте много INSERT в одну транзакцию
**delayed\_job** делает вставку в таблицу **delayed\_jobs** каждый раз, когда добавляется новая задача.
В **ActiveRecord** вызовы **save** по-умолчанию оборачиваются в транзакцию. Поэтому, чтобы не получить огромное количество транзакций при массовом создании фоновых задач, рекомендуется оборачивать всё в одну или несколько транзакций:
```
job_items.in_groups_of(500, false) do |group|
ActiveRecord::Base.transaction do
group.each do |job_item_id|
JobRunner.delay.execute_job(job_item_id)
end
end
end
```
Подробнее здесь: [www.coffeepowered.net/2009/01/23/mass-inserting-data-in-rails-without-killing-your-performance](http://www.coffeepowered.net/2009/01/23/mass-inserting-data-in-rails-without-killing-your-performance/)
##### Избегайте накладных расходов на сериализацию/десериализацию
**delayed\_job** сериализует данные, когда создаёт задачу и десериализует непосредственно перед выполнением. В качестве параметров для фоновых задач всегда лучше передавать объекты класса **Fixnum**, **String** или **Hash** вместо тяжёлых **ActiveRecord** объектов.
```
JobRunner.delay.send_activation_instructions(user.id)
```
Гораздо лучше чем:
```
JobRunner.delay.send_activation_instructions(user)
```
##### Запускайте воркеры delayed\_job по количеству ядер
Многопоточность в **Ruby** оставляет желать лучшего, поэтому обычно всё распараллеливается при помощи создания нескольких процессов.
Не исключение и **delayed\_job**. К примеру, если у вас **top / htop** показывает 4 потока, то для достижения наилучшей производительности нужно запускать 4 воркера:
```
script/delayed_job -i 0 start
script/delayed_job -i 1 start
script/delayed_job -i 2 start
script/delayed_job -i 3 start
```
Иногда можно больше, но здесь уже нужно следить за использованием процессора и учитывать специфику конкретных задач.
Кстати, в **delayed\_job** есть конфигурация для мониторинга нескольких воркеров с помощью monit (см. файл contrib/delayed\_job\_multiple.monitrc).
##### Дополнительно
Так же, стоит обратить внимание на следующие дополнения:
* [github.com/SponsorPay/em-resque](https://github.com/SponsorPay/em-resque) (позволяет работать воркерам асинхронно)
* [github.com/Viximo/delayed\_job\_redis](https://github.com/Viximo/delayed_job_redis) (экспериментальный backend для работы с Redis)
Стоит отметить, что delayed\_job\_redis нам так и не удалось запустить с Rails 3.2. | https://habr.com/ru/post/145899/ | null | ru | null |
# SysAdmin Anywhere: Используем UDP Hole Punching для реализации удаленного рабочего стола
#### Введение
 Системные администраторы по своей природе — люди ленивые. Не любят они по сто раз одно и то же делать. Хотят все автоматизировать, чтобы работало с минимальным вмешательством. И я такой.
Дабы облегчить жизнь себе и мне подобным, была создана программа, которая объединила разрозненные средства администрирования в один продукт с простым названием [SysAdmin](http://ria-media.net/products/sysadmin.aspx). Он включает поддержку мультидоменной сети, отчеты, инвентаризацию и много других полезных вещей, которые разбросаны по разным MMC или входят в сторонние продукты. Работать стало значительно удобней. Данная программа уже доросла до версии 5.3, сменила интерфейс на Metro-style. Но, к сожалению, в ней нет возможности администрировать компьютеры, не включенные в домен.
Однако, хотелось большего:
* Полноценно администрировать удаленные компьютеры;
* Настроить доступ без личного присутствия на удаленной стороне и без наличия квалифицированного сотрудника с удаленной стороны;
* Не открывать порты на маршрутизаторе;
* При невозможности личного присутствия не открывать доступ к маршрутизатору из интернета;
* Не усложнять техническое решение, если необходимо иметь доступ не к одному компьютеру в удаленной сети:
* Не открывать порты на маршрутизаторе для каждого компьютера;
* Не открывать доступ на маршрутизаторе к серверу, а с него к компьютерам (Не всегда есть необходимость в сервере, а введение его в качестве средства для удаленного доступа – экономически нецелесообразно);
* Не открывать один порт и каждый раз не перенастраивать маршрутизатор для доступа к другому компьютеру;
* Не поднимать VPN.
> **Из опыта:**
>
> По работе надо было создать VPN-сеть с региональными отделениями, расположенными по всей стране. В центральном отделении было установлено мощное VPN-оборудование, а на местах планировалось оборудование той же компании, но проще. Необходимо было выяснить все про их интернет — соединение, локальную сеть, установленное оборудование и т.д. Подготовить VPN-оборудование и отправить им, чтобы они его подключили и все заработало. Пикантность ситуации заключалась в том, что это предстояло сделать фактически мне одному, командировки не предусматривались и уровень пользователей на местах был очень разнообразен. Конечно, все было реализовано, но это отняло массу времени на переписку и телефонные разговоры.
Из-за перечисленных ранее ограничений для реализации был необходим посредник. На удаленный компьютер устанавливается клиентская часть, которая создает соединение с посредником, не блокируемое файерволами, т.к. оно инициировано самой удаленной машиной. Администратору достаточно знать только адрес посредника, чтобы, подключившись к нему, получить доступ к удаленным компьютерам. Благодаря такому посреднику, мы получаем ряд преимуществ:
* Нет необходимости открывать порты на маршрутизаторе. Повышается безопасность, снижается уровень необходимой квалификации пользователя;
* Администратор имеет доступ к панели управления, расположенной в облаке, через браузер, поддерживающий Microsoft Silverlight посредством защищенного соединения;
* Команды от администратора при помощи облачного сервиса отправляются на удаленный компьютер. Ответ передается администратору аналогичным образом;
* Удаленный компьютер находится в режиме онлайн, поэтому нет необходимости в присутствии пользователя;
* Дополнительные сервисы (инвентаризация, сервис-деск, отчеты, учет лицензий, архивация, мониторинг и т.д.) с хранением данных в облаке и доступа к ним, даже если удаленный компьютер не подключен к интернету;
* Удаленный рабочий стол (VNC);
* Доступ с мобильного телефона на Windows Phone.
Платформу для посредника долго искать не пришлось. Microsoft Azure, как нельзя кстати, подходила для этого. Тем более была возможность получить 30-ти дневный доступ для экспериментов.
Так сложилось, что к этому времени я сменил сферу деятельности с системного администрирования на программирование., поэтому решил создать сервис самостоятельно.
Ко мне присоединился мой коллега, и мы вместе приступили к разработке прототипа сервиса. Перед нами стояла задача за время тестового периода создать работоспособную модель взаимодействия удаленного клиента с облачным сервисом. Дальнейшие разработки можно было продолжить, используя Azure SDK.
Сложнее всего было организовать постоянное соединение удаленного компьютера с облачным сервисом. В результате долгих и нудных экспериментов (деплой в облако занимает ощутимое время) появилось рабочее решение, которое дало уверенность в достижении поставленной цели.
Мы смогли соединить удаленный компьютер с облаком, при этом ничего не настраивая из сетевого оборудования. Для нас это стало прорывом.
Теперь стояла задача передать команду от администратора в облако, а далее на компьютер и получить от него ответ. Мы остановились на том, что универсальным решением было бы использовать WMI. Причем, облачный сервис не должен знать ничего про WMI. Его задача — пересылка. Это задумывалось для того, чтобы как можно реже приходилось обновлять сам облачный сервис и клиентское ПО на удаленных компьютерах (сейчас обновляется до последней версии нажатием кнопки в консоли).
> **Пример:**
>
> От администратора передается запрос на получение списка установленных служб (Select \* From Win32\_Service) плюс набор полей, значения которых нам нужны. Все это сериализуется JSON, пакуется, шифруется и передается в облако. В облаке данные записываются в очередь и затем забираются из нее экземпляром службы, к которому подключен удаленный компьютер.
>
> Клиент, получив запрос, выполняет его. Полученный результат сериализуется JSON, пакуется, шифруется и передается в обратном порядке администратору.
Использование WMI не ограничивается только запросом, реализован вызов функций и процедур. Например, любую из служб можно остановить.
Казалось бы, все просто, но не стоит забывать, что если мы планируем сделать масштабируемое решение — без работы с несколькими экземплярами нашего сервиса в облаке не обойтись. Работа с ними требует некоторого пересмотра своего опыта в разработке. Всегда надо держать в голове, что существует не один экземпляр, а несколько, и работают они параллельно. Желаете что-то сделать монопольно — не забывайте оповестить об этом остальные экземпляры. Например, биллинг. Будет крайне неприятно, когда каждый экземпляр пройдется по базе и пересчитает баланс клиента, каждый раз уменьшая его. Такой вариант показан в качестве примера того, что может произойти, хотя в настоящее время мы работаем над тем, чтобы исключить эту проблему в будущем.
Создавая сервис, мы исходили из того, что в большинстве случаев не обязательно иметь доступ к удаленному рабочему столу. Достаточно прямого управления процессами, службами и т.п. Это быстрее и проще сделать через веб-интерфейс.
Все же удаленный рабочий стол очень востребован и для его реализации требуется прямое соединение между компьютерами. Передавать такой объем информации через облако нерационально, так как задержка в обновлении экрана может достигать несколько секунд.
#### Реализация UDP Hole Punching
Наиболее интересной задачей оказалась реализация системы удаленного доступа к рабочему столу. Для экономии времени было решено взять уже готовую реализацию VNC что, однако, порождало свои проблемы: соединить напрямую клиент и сервер VNC невозможно. Единственным решением явилось создание посредников, задача которых — ретрансляция трафика. Таким образом, VNC клиент и сервер будут “думать”, что работают локально, когда на самом деле весь трафик между ними мы будем передавать через Интернет.
##### NAT Travesal
Остался открытым вопрос: каким образом передавать информацию между посредниками? Первый приходящий на ум вариант – гонять все через облако – является сколь дорогим столь и неэффективным способом. Гораздо лучше соединить все напрямую. Тут мы и наталкиваемся на стандартную проблему NAT Traversal.
Преобразование сетевых адресов (NAT) не дает возможности устанавливать прямое соединение между клиентами. [NAT](http://ru.wikibooks.org/wiki/%D0%9F%D0%BE%D1%80%D1%82/NAT) – это процесс трансляции локальных адресов, недоступных из Интернета, во внешние. Для обхода NAT существует несколько стандартных способов: открыть порт, поднять VPN.
К сожалению, ни один из них нам не подходит, т.к. сразу усложняет установку всех необходимых компонентов (а ведь мы хотим, чтобы установка клиента на рабочей машине была доступна наименее продвинутым пользователям без помощи админа). Поэтому воспользуемся механизмом UDP Hole Punching.
##### UDP Hole Punching
UDP hole punching — метод для прямого соединения двух компьютеров, которые находятся за NAT-ами. Для инициации соединения требуется третья сторона – сервер, который виден обоим компьютерам. Обычно используются публичные [STUN](http://ru.wikipedia.org/wiki/STUN)-серверы.
Итак, наша задача состоит в том, чтобы напрямую связать клиента на удаленной машине и консоль. Для этого необходимо сделать несколько шагов:
* Узнать внешний IP и порт удаленной машины. Для этого воспользуемся STUN – сетевым протоколом, который позволяет определить внешний IP-адрес.
* Передать эту информацию нашему приложению
* Установить соединение и использовать его далее для обмена данными
##### Как это выглядит в коде?
В теории все просто. Как все это выглядит на практике?
Как видно из изображения выше, немногим сложнее. Сначала мы отправляем запрос на соединение от нашего приложения, который через облако передается приложению на клиентской машине (шаги 1 и 2). Клиентская машина запрашивает свой внешний адрес и порт у STUN-сервера (шаги 3 и 4). В сети можно найти множество реализаций STUN протокола.
```
string address = String.Empty;
udpClient = new UdpClient();
udpClient.AllowNatTraversal(true);
ResultSTUN result = ClientSTUN.Query("stun.ekiga.net", 3478, udpClient.Client);
if (result.NetType == UDP_BLOCKED) { /* обработка ошибки */ }
else { address = result.PublicEndPoint.ToString(); }
```
Т.к. в нашем решении используется UDP, мы можем, используя тот же сокет, подключиться к клиенту (что выгодно отличает его от TCP).
После этих нехитрых манипуляций address будет содержать внешний адрес и порт клиентской машины (или сообщение об ошибке). Эта ценная информация передается консоли управления через облако (шаги 5 и 6). Создать соединение, зная порт и адрес – уже дело техники. Теперь мы можем передавать всю необходимую нам информацию.
Задача NAT Traversal решается просто и изящно при использовании UDP, но что если мы при этом хотим все преимущества TCP: гарантированную доставку пакетов, целостность данных, отсутствие дублирования и т.д.? Первая мысль, которая приходит в голову – написать свой протокол поверх UDP. Естественно, мы далеко не первые, кто столкнулся с этой проблемой. Поэтому после недолгого поиска можно найти такое решение, как [Lindgren.Network](http://code.google.com/p/lidgren-network-gen3/), которое в итоге используется в нашем приложении.
[](http://www.sysadminanywhere.com/) | https://habr.com/ru/post/142858/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.