text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Как сделать веб-аналитику для SaaS через Google Analytics: введение и отслеживание воронки
В чем проблема и почему Google Analytics
----------------------------------------
Столкнулся с тем, что на нескольких SasS проектах не было нормальной аналитики, чтобы:
* Смотреть в разрезе каждого сегмента трафика, как пользователи продвигаются по воронке, например, оформление заказа.
* Считать LTV и CAC, с каналов трафика, рекламных кампаний, простыми словами, сколько потратили на привлечение пользователя и сколько выручки он принес в течение года.
* Считать показатель возврата, то есть остаются ли привлеченные пользователи с нами или уходя спустя время, дает ли канал прирост постоянных клиентов.
Как правило, использовались Google Analytics, ROIStat, Метрика, Amplitude, но ни один инструмент не был до конца интегрирован. Для решения задач выше выбрал Google Analytics (далее GA), он далеко не идеальный, но решить базовые задачи вполне реально и не так затратно.
**Плюсы**
* Умеет принимать внешние данные, например, в него можно отправлять транзакции с помощью POST-запросов
* Отдавать данные в системы визуализации DataStudio, Power BI
* Много справочной информации
* Легко интегрируется со всеми Google-сервисами
* Бесплатный
* Хранит данные 50 месяцев
**Минусы**
* Когда вы выбираете таймфрейм, который содержит 1 млн сессий, то отчет будет построен только на основании 100 тыс., сессий, так как свыше 500 тыс., сессий данные семплируются.
* Данные и отчеты строятся вокруг кук (браузеров, устройств), а не пользователей, следовательно, один пользователь на протяжении года в GA представлен, как 10 разных и склеить их невозможно в рамках GA (возможно, но слишком много костылей).
* Высокий порог входа, так как сложный интерфейс.
Давайте рассмотрим решение каждой задачи от технической реализации до онлайн-отчета, который можно открыть и посмотреть за пару минут.
Так как в одну статью с трудом можно уместить весь материал, то разделю на несколько частей, к тому же не факт, что эта информация нужна сообществу и проблема имеет место быть.
Реализация всех этапов требует уровень средний уровень владения Google Analytics, в рамках одной статьи не получится охватить весь необходимый скилл, но он легко гуглится.
Начнем с построения воронки.
Зачем нужна воронка
-------------------
Самый простой пример воронки, это воронка в интернет магазине бытовой техники.
> *Зашел на сайт > Положил в корзину > Перешел в корзину > Оформление: доставка > Оформление: контактные данные > Оформление: метод оплаты и оплата*
Хороший отчет тот, из которого последуют действия.
* У посетителей из мурманска низкая конверсия на этапе доставки, потому что у текущей логистической компании высокий тариф > нужно искать альтернативы.
* Кладут в корзину, но не продолжают оформление, так как корзина находится слева по задумке дизайнера > меняем положение корзины вправо.
Проектирование воронки и отправка событий
-----------------------------------------
На выходе мы хотим увидеть конверсию из одного этапа воронки в другой и количественные показатели, например.
Этапы воронки могут быть непоследовательны и вариативны, представим, что мы проектируем воронку для сервиса наподобие Авито.
> *Открыл конструктор > Создал объявление > **Регистрация** > Выбор тарифа > Транзакция*
>
>
> ***Регистрация** > Пополнение баланса > Открыл конструктор > Создал объявление > Применил тариф*
>
>
В таком случае нам бы хотелось иметь возможность вручную составлять воронки на ходу и не быть привязанными к определенной последовательности, например, мы хотим посмотреть пользователей, кто сначала создает объявление, а потом платит.
> *Открыл конструктор > Создал объявление > Выбрал тариф > **Оплата***
>
>
И наоборот, сначала, кто пополняет баланс, а потом, создает объявление.
> ***Пополнил баланс** > Открыл конструктор > Создал объявление > Применил тариф*
>
>
Для этого на каждый этап воронки нам нужно отправлять в Google Analytics событие, из которых мы сможем составлять воронки, как нам удобно, поэтому рассмотрим, что это за события и как их отправлять.
Настоятельно рекомендую использовать Google Tag Manager (далее GTM), это слой между сайтом и счетчиками, например, вы можете один раз настроить событие и через GTM отправлять его в Analytics, Метрику и прочее.
Как отправлять события в Google Analytics
-----------------------------------------
### Отправляем события в слой данных GTM
Есть много способов, но самый надежный и правильный, это отправка через слой данных (data layer). Слой данных, это просто транзит между сайтом и счетчиками.
Для отправки мы должны инициировать следующее выражение на javascript.
```
window.dataLayer = window.dataLayer || [];
dataLayer.push({
'event': 'name'
});
```
Разберем подробнее каждую строку
*window.dataLayer = window.dataLayer || [];* — проверяем есть ли уже созданный слой данных, если нет, то создаем новый.
*dataLayer.push({ 'event': 'name’});* — в нужный момент добавляем в слой данных название события;
*'name'* — собственно, название события;
Итого, нам нужно инициировать данное выражение в каждый момент воронки и подставлять название событий, например, мы хотим отправлять события в момент, когда пользователь открывает конструктор объявлений.
```
window.dataLayer = window.dataLayer || [];
dataLayer.push({
'event': 'openAdsEditor'
});
```
Или в момент, когда пользователь заполнил и подтвердил объявление в конструкторе.
```
window.dataLayer = window.dataLayer || [];
dataLayer.push({
'event': 'ad_submit'
});
```
Протестировать, верно ли приходят события, можно в дебаг моде GTM, углубляться в это не будем, так как можно легко погуглить.
Теперь нам нужно извлечь события из слоя данных и отправить в GA
### Извлекаем событие из слоя данных и отправляем в Google Analytics
Создаем триггер в GTM вида **Custom event** (Пользовательское событие) и в поле **Event name** (Название события) указываем **ad\_submit** , это как раз то значение, которое мы указывали при отправке события на сайте.
Далее, это триггер будет инициировать запуск тега, который в свою очередь отправляет событие в Google Analytics.
Далее создаем тег, в котором указываем следующие значения
Категория **funnel** и Действие **ad\_submit** указываются произвольные, именно по ним мы будем идентифицировать событие в GA. В качестве триггера указываем наш созданные ранее триггер **Заполнено объявление**.
После сохранения тега разворачиваем его в продакшн, нажатие на кнопку **Publish** (Публиковать) и тестируем: при заполнении объявления должно приходить событие в отчет GA под названием Real time > Events (В реальном времени > События)
Аналогичный цикл проводим для других событий, то есть этапов воронки, которые мы хотим отслеживать.
Как строить воронку в GA
------------------------
Предположим, мы отправили все события и нужно построить из них воронку.
Создаем сегменты в GA, каждый сегмент равен одному событию, например, создаем сегмент для события **Открыл редактор**, так как оно будет первое в последовательности.
Для этого выбираем любой отчет в GA, например **Channels** (Каналы), и нажимаем **+Add Segment** (Добавить сегмент)
Далее **+ New segment** (Новый сегмент) и задаем параметры сегмента
Во вкладке **Sequence** (Последовательности) **Include** (Включить) **Users** (Пользователей), у которых **Any user interaction** (Любое из взаимодействий) соответствует событию E**vent Category exactly matches funnel AND Event Category exactly matches openAdsEditor**
Простыми словами мы выделяем пользователей, которые взаимодействовали с нашим событием.
Далее делаем второй этап воронки, для этого копируем первый сегмент.
И внутри добавляем событие второго этапа воронки **Заполнил объявление**. Так как нам необходимо, чтобы учитывались только те пользователи **Заполнил объявление**, которые ранее открыли редактор, то в качестве шага один добавляем предыдущее событие воронки **Открыл редактор**, а в качестве шага 2 **Заполнил объявление**.
То есть во второй этап воронки Заполнил объявление у нас попадают только те пользователи, кто прошел первый этап Открыл редактор.
На что смотреть в отчете
------------------------
Изменения воронки в разрезе дней, недель или месяцев.
Воронка в разрезе общих показателей отчете или в разрезе его параметров, а данном случае Каналов трафика.
Немного модифицировав отправку событий можно добавить, например, выбранную тему объявления, чтобы смотреть, по каким тематикам хуже размещаются объявления, но об этом в следующих статьях.
Все, была ли полезна информацию? Какие альтернативные решения? | https://habr.com/ru/post/428225/ | null | ru | null |
# Расширения для Opera: Обмен сообщениями
#### Вступление
С помощью расширений вы можете создавать и добавлять новую впечатляющую функциональность в браузер Opera. Как было упомянуто в других статьях, расширения для Opera содержат фоновый скрипт, внедряемый скрипт и, иногда, всплывающее окно. В этой статье мы рассмотрим, как обеспечить обмен данными между тремя этими компонентами.
> Прежде чем продолжить, вы должны скачать три расширения и установить их в браузер [Opera 11 alpha](http://labs.opera.com/news/2010/10/21/). Мы будем рассматривать тему с помощью кода этих расширений.
>
> 1. [Пример расширения, демонстрирующего обмен данными между фоновым и внедряемым скриптами](http://devfiles.myopera.com/articles/3952/example1.oex)
> 2. [Пример расширения, демонстрирующего обмен данными между фоновым скриптом и всплывающим окном](http://devfiles.myopera.com/articles/3952/example2.oex)
> 3. [Пример расширения, демонстрирующего обмен данными между всплывающим окном и внедряемым скриптом (с небольшой помощью фонового скрипта)](http://devfiles.myopera.com/articles/3952/example3.oex)
>
#### Обмен данными между фоновым и внедряемым скриптами
Opera использует метод postMessage() для отправки сообщения. Если вы хотите отправить данные из фонового скрипта во внедряемый скрипт, то нужно написать следующий код в фоновом скрипте:
```
opera.extension.broadcastMessage("Hello there");
```
После того, как вы послали сообщение, внедряемый скрипт должен принять его, что может быть сделано следующим образом:
```
var thecatch;
opera.extension.onmessage = function(event) {
thecatch = event.data; // event.data в данном случае будет содержать строку "Hello there"
}
}
```
Вот так всё просто. В указанном выше коде, фоновый скрипт отправляет данные внедряемому скрипту, используя метод broadcastMessage, и внедряемый скрипт принимает их. После получения данных, он сохраняет их в переменной thecatch. Необходимо помнить, что используя метод broadcastMessage, вы посылаете сообщение всем внедряемым скриптам и всплывающим окнам, поэтому необходимо использовать этот метод экономно. Обычно, вам необходимо связаться лишь с одним всплывающим окном или внедрённым скриптом (тем, который содержится именно в вашем расширении) используя метод postMessage или каналы сообщений.
Продемонстрируем это с помощью нашего первого тестового примера.
Фоновый скрипт имеет перехватчик события load, который вызывает функцию setupConnection. Вы можете наблюдать вывод метода opera.postError в Error Console (Tools > Advanced > Error Console).
```
window.addEventListener("load", setupConnection, false);
function setupConnection()
{
// Когда внедряемый скрипт активируется, он связывается с фоновым скриптом
opera.extension.onconnect = function(event) {
// Отправляем сообщение источнику, который связывается с нами (в данном случае это внедряемый скрипт)
event.source.postMessage("something");
// Отправляем уведомление в Error Console
opera.postError("sent message to injected script");
}
// Перехватываем сообщения
opera.extension.onmessage = function(event){
// Отправляем уведомление (которое содержит полученное сообщение) в Error Console
opera.postError("This is what I got from injected script: "+event.data);
}
}
```
Обратим внимание на следующий код:
```
opera.extension.onconnect = function(event) {
event.source.postMessage("something");
opera.postError("sent message to injected script");
}
```
Метод onconnect выполняется в момент, когда внедряемый скрипт расширения активируется в документе, соединяя его с фоновым скриптом. То есть, как только внедряемый скрипт загружается, метод onconnect выполняется.
Обработчик onconnect в фоновом скрипте получает обратную ссылку на внедряемый скрипт через объект event.source. Этот порт сообщений может быть использован для прямой связи с внедряемым скриптом, что демонстрируется отправкой строки «something» с помощью метода event.source.postMessage(). Попутно мы шлём небольшое уведомление в Error Console для отслеживания происходящего.
Оставим фоновый скрипт на время и обратим своё внимание на внедряемый скрипт:
```
opera.extension.onmessage = function(event){
// Получаем содержимое входящего сообщения.
var message = event.data;
opera.postError("Background script sent: " + message);
// Шлём обратный ответ.
var reply = "Background script's message only had " + (message ? message.length : 0) + " characters.";
event.source.postMessage(reply);
};
```
Метод onmessage вызывается в момент получения внедряемым скриптом сообщения. Мы сохраняем содержимое сообщения в переменной message. Затем мы используем метод opera.postError для отправки уведомления в Error Console.
Чтобы подтвердить получение сообщения, мы шлём обратный ответ фоновому скрипту, используя объект event.source. Запомните: event.source всегда указывает на источник сообщения.
Итак, теперь мы увидели, как сообщения принимаются внедряемым скриптом и как может быть отправлен ответ фоновому скрипту.
Следующий шаг это приём сообщения фоновым скриптом и его обработка. Вернёмся снова к фоновому скрипту и посмотрим на другой участок кода:
```
// Перехватываем сообщения
opera.extension.onmessage = function(event){
// Отправляем запись (которая содержит полученное сообщение) в Error Console
opera.postError("This is what I got from injected script: "+event.data);
}
```
Здесь, в момент получения сообщения, скрипт отсылает в Error Console уведомление о его получении вместе с содержимым сообщения.
Итого, вот что происходит в расширении:
* Фоновый скрипт шлёт сообщение внедряемому скрипту
* Внедряемый скрипт получает сообщение и отправляет уведомление с содержимым сообщения в Error Console
* Внедряемый скрипт шлёт обратный ответ
* Фоновый скрипт получает ответ и отправляет уведомление с содержимым ответа в Error Console
Если вы установили расширение (обновите страницу, чтобы внедряемый скрипт применился), то отправляйтесь в Error Console. Вы должны увидеть сообщения, показанные на Рис. 1:
**Рисунок 1**: Error Console и уведомления, посланные в неё из расширения.
Мы рассмотрели, как фоновый и внедряемый скрипты могут принимать и отправлять сообщения. Теперь разберём, как можно сделать это со всплывающим окном.
#### Обмен сообщениями между всплывающим окном и фоновым скриптом
Мы будем использовать второй пример расширения для этой главы. Обратите внимание, что в нём нет папки includes и внедряемого скрипта — это лишь фоновый скрипт, html-файлы, config.xml и иконка.
Из предыдущих статей вы уже знаете, как [создать UI-элемент, например кнопку](http://habrahabr.ru/blogs/opera/107067/), так что мы не будет заострять на этом наше внимание. Давайте посмотрим на следующий код в background.js:
```
opera.extension.onconnect = function(event){
event.source.postMessage("sending something");
opera.postError("sent message to popup");
}
```
Как мы знаем из предыдущего примера, этот код будет выполнен, когда что-нибудь свяжется с фоновым скриптом, в данном случае это всплывающее окно. Функция шлёт сообщение «sending something» всплывающему окну и уведомление «Sent message to popup» в Error Console.
Теперь посмотрим на страницу всплывающего окна:
```
window.addEventListener("load", function(){
opera.extension.onmessage = function(event){
event.source.postMessage("do whatever you want with this message");
opera.postError("sent from popup to background script");
}
}, false);
```
Здесь мы перехватываем входящее сообщение и шлём обратный ответ источнику. Так же мы, как обычно, отправляем уведомление в Error Console. Теперь всплывающее окно принимает сообщение и шлёт ответ фоновому скрипту. Осталось только получить этот ответ в фоновом скрипте.
Снова отправляемся в background.js и смотрим код:
```
opera.extension.onmessage = function(event){
opera.postError("This is what I got from injected script: " + event.data);
}
```
Здесь фоновый скрипт перехватывает сообщение и отправляет в Error Console уведомление с содержимым сообщения. Как видите, мы можем использовать тот же код, что и для внедряемого скрипта.
Итого, вот что происходит в расширении:
* Фоновый скрипт шлёт сообщение всплывающему окну
* Всплывающее окно получает сообщение и отправляет уведомление с содержимым сообщения в Error Console
* Всплывающее окно шлёт обратный ответ
* Фоновый скрипт получает ответ и отправляет уведомление с содержимым ответа в Error Console
Всё происходит точно также, как и в предыдущем примере, лишь с той разницей, что у нас нет внедряемого скрипта, и мы связываемся со всплывающим окном.
Если вы установили расширение, то нажмите на его кнопку на панели браузера чтобы запустить обмен сообщениями и откройте Error Console, чтобы увидеть показанное на Рис. 2:
**Рисунок 2**: Error Console и уведомления, посланные в неё из расширения.
#### Обмен сообщениями между всплывающим окном и внедряемым скриптом
Теперь давайте разберём, как обмениваться данными между всплывающим окном и внедряемым скриптом. Фоновый скрипт будет использован только для инициализации соединения, затем всплывающее окно и внедряемый скрипт будут общаться напрямую.
Мы можем достичь этого, создав канал связи. Вы можете узнать больше о каналах связи в [спецификации кросс-документного обмена сообщениями в HTML5](http://dev.w3.org/html5/postmsg/#message-channels), на которой основывается обмен сообщениями в расширениях.
Мы рассмотрим это с помощью третьего примера расширения, так что запускайте свой текстовый редактор и посмотрим на код. В первый очередь, взглянем на фоновый скрипт. Вы заметите знакомые элементы, например добавление кнопки и всплывающего окна. Опустимся к более интересному участку.
Вначале, мы определяем глобальную переменную port, которую будем использовать позже. Посмотрим на обработчик onconnect:
```
opera.extension.onconnect = function( event ){
if( port )
event.source.postMessage( "Respond to the port", [port] );
}
```
В момент подключения к фоновому скрипту, он отправит сообщение 'Respond to the port'. Мы указываем порт для отправки сообщения, но так как переменная port ещё не имеет значения, то сообщение будет отправлено как оно есть.
Теперь поглядим на внедряемый скрипт:
```
var channel = new MessageChannel();
opera.extension.postMessage( "Respond to this immediately", [channel.port2] );
```
Здесь мы создаём новый канал сообщений. Канал сообщений будет иметь два порта, и данные могут быть отправлены и получены через эти два порта. Здесь мы отправляем данные через второй порт и получаем через первый. Затем мы отправляем сообщение, используя метод postMessage(), через второй порт канала сообщений.
Вернёмся к фоновому скрипту:
```
opera.extension.onmessage = function( event ) {
if (event.ports)
port = event.ports[0];
}
```
Фоновый скрипт принимает сообщение от внедряемого скрипта. Теперь ссылка на второй порт канала доступна через объект event.ports[0] и сохраняется в переменной port. Теперь фоновый скрипт готов для подключения всплывающего окна. Когда это произойдёт, метод onconnect вызывается вновь:
```
opera.extension.onconnect = function( event ){
if( port ){
event.source.postMessage( "Respond to the port", [port] );
}
}
```
Теперь, значение переменной port не пусто. Оно содержит ссылку на порт канала сообщений.
Посмотрим на файл всплывающего окна:
```
opera.extension.onmessage = function( event ){
if( event.ports ){
opera.postError( "Responding to port" );
event.ports[0].postMessage( "Hi from popups side!" );
}
}
```
Всплывающее окно принимает сообщение и если оно содержит ссылку на порт, то оно отсылает уведомление в Error Console, и что более важно, шлёт ответ через указанный порт. Теперь осталось лишь получить это сообщение во внедряемом скрипте. Во внедряемом скрипте мы имеем следующий код:
```
channel.port1.onmessage = function( event ){
opera.postError("Here is what i got in the injected script for port1: " + event.data);
}
```
Внедряемый скрипт слушает port1 канала сообщений. При получении сообщения на него, он посылает уведомление в Error Console с содержимым полученного от всплывающего окна сообщения.
Итого, вот что происходит в расширении:
* Внедряемый скрипт загружается.
* Метод onconnect выполняется в фоновом скрипте и отсылает сообщение внедряемому скрипту.
* Внедряемый скрипт получает сообщение и создаёт канал сообщений.
* Внедряемый скрипт отсылает сообщение фоновому скрипту вместе с ссылкой на второй порт.
* Фоновый скрипт принимает сообщение и сохраняет ссылку на порт.
* Всплывающее окно соединяется с фоновым скриптом.
* Метод onconnect выполняется опять, но в этот раз отсылает обратное сообщение вместе с ссылкой на порт внедряемого скрипта.
* Всплывающее окно принимает сообщение, проверяет в нём наличие ссылки на порт. Если таковая имеется, оно шлёт обратное сообщение на этот порт (это port2 канала связи).
* Внедряемый скрипт получает сообщение. После этого он шлёт уведомление в Error Console с текстом, полученным от всплывающего окна.
В этом сценарии фоновый скрипт выступает в роли свахи. Сначала, она связывается с первым участником (внедряемый скрипт). Участник даёт своё номер (второй порт) свахе, который сваха сохраняет. Другой участник (всплывающее окно) связывается со свахой. Как только это происходит, сваха отсылает номер первого участника (внедряемого скрипта) второму участнику (всплывающему окну). Теперь всё дальнейшее общение происходит напрямую между двумя участниками, убирая сваху из уравнения.
#### Подводим итоги
Обмен данными между различными частями расширения довольно прост после того, как вы узнаете как использовать метод postMessage вместе с обработчиками onconnect и onmessage. Вы также можете использовать каналы сообщений для передачи данных, и этот подход необходим, когда данные передаются между всплывающим окном и внедряемым скриптом. Эта статья проливает немного света на передачу данных в трёх сценариях: между фоновым и внедряемым скриптами, межу фоновым скриптом и всплывающим окном, между всплывающим окном и внедряемым скриптом.
#### Ссылки на API
Методы, относящиеся к [фоновому скрипту](http://labs.opera.com/extensions-api/backgroundProcess/BackgroundProcess.html)
Методы, относящиеся к [внедряемому скрипту](http://labs.opera.com/extensions-api/injectedScripts/Extension.html)
Методы, относящиеся к [всплывающим окнам](http://labs.opera.com/extensions-api/popup/PopupProcess.html) | https://habr.com/ru/post/107153/ | null | ru | null |
# Почта Mail.ru начинает в тестовом режиме применять политики MTA-STS
Если кратко, то MTA-STS — это способ дополнительно защитить письма от перехвата (т.е. атак злоумышленник-в-середине aka MitM) при передаче между почтовыми серверами. Он частично решает унаследованные архитектурные проблемы протоколов электронной почты и описан в относительно свежем стандарте RFC 8461. Почта Mail.ru — первая крупная почтовая служба в Рунете, реализующая данный стандарт. А более подробно рассказывается уже под катом.
Какую проблему решает MTA-STS?
==============================
Исторически, протоколы электронной почты (SMTP, POP3, IMAP) передавали информацию в открытом виде, что позволяет ее перехватывать, например при доступе к каналу связи.
Как выглядит механизм доставки письма от одного пользователя к другому:
Исторически, атака MitM была возможна во всех местах, где ходит почта.
Стандарт RFC 8314 требует обязательного использования TLS между почтовой программой пользователя (MUA) и почтовым сервером. Если ваш сервер и используемые почтовые приложения соответствуют RFC 8314, то вы (в значительной мере) устранили возможность атак Man-in-the-Middle между пользователем и почтовыми серверами.
Соблюдение общепринятых практик (стандартизированных RFC 8314) устраняет атаку вблизи пользователя:
Почтовые серверы Mail.ru соответствовали RFC 8314 еще до момента принятия стандарта, фактически, он просто фиксирует уже принятые практики, и нам ничего не пришлось настраивать дополнительно. Но, если ваш почтовый сервер все еще пускает пользователей по небезопасным протоколам обязательно реализуйте рекомендации этого стандарта, т.к. скорее всего как минимум часть ваших пользователей работают с почтой без шифрования, даже если вы его поддерживаете.
Почтовый клиент всегда работает с одним и тем же почтовым сервером одной и той же организации. И можно принудительно заставить всех пользователей подключаться безопасным образом, после чего сделать технически невозможным подключаться небезопасным (это как раз и требует RFC 8314). Это иногда сложно, но реализуемо. С трафиком между почтовыми серверами все еще сложней. Серверы принадлежат разным организациям и зачастую используются в режиме «поставил и забыл», что делает невозможным одномоментное переключение на безопасный протокол без нарушения связности. В SMTP уже достаточно давно предусмотрено расширение STARTTLS, позволяющее серверам поддерживающим шифрование переключиться на TLS. Но атакующий, у которого есть возможно влиять на трафик, может «вырезать» информацию о поддержке этой команды и заставить серверы общаться по обычному текстовому протоколу (т.н. downgrade attack — атака на понижение версии протокола). По этой же причине, для STARTTLS обычно не проверяется соответствие сертификата (недоверенный сертификат может защищать от пассивных атак, и это не хуже отправки письма открытым текстом). Поэтому STARTTLS защищает только от пассивной прослушки.
MTA-STS частично устраняет проблему перехвата писем между почтовыми серверами, когда у атакующего есть возможность активно влиять на трафик. Если домен получателя публикует политику MTA-STS, и сервер отправителя поддерживает MTA-STS, он будет отправлять письмо только через TLS-соединение, только на серверы, определенные политикой, и только с проверкой сертификата сервера.
Почему частично? MTA-STS работает только если обе стороны позаботились о внедрении этого стандарта, и MTA-STS не защищает от сценариев, при которых у атакующего есть возможность получить валидный сертификат домена в одном из публичных CA.
Как работает MTA-STS
====================
**Получатель**
1. Настраивает поддержку STARTTLS с валидным сертификатом на почтовом сервере.
2. Публикует через HTTPS политику MTA-STS, для публикации используется специальный домен mta-sts и специальный well-known путь, например `https://mta-sts.mail.ru/.well-known/mta-sts.txt`. Политика содержит список почтовых серверов (mx) имеющих право получать почту для этого домена.
3. Публикует специальную TXT-запись \_mta-sts в DNS с версией политики. При изменении политики эта запись должна быть обновлена (это сигнализирует отправителю о необходимости перезапросить политику). Например, `_mta-sts.mail.ru. TXT "v=STSv1; id=20200303T120000;"`
**Отправитель**
Отправитель запрашивает DNS-запись \_mta-sts, при ее наличии делает запрос политики по HTTPS (сверяя сертификат). Полученная политика кешируется (на случай, если атакующий блокирует доступ к ней или подменит DNS-запись).
При отправке почты, проверяется что:
* сервер, на который доставляется почта есть в политике;
* сервер принимает почту с использованием TLS (STARTTLS) и имеет валидный сертификат.
Преимущества MTA-STS
====================
MTA-STS использует технологии, которые уже внедрены в большинстве организаций (SMTP+STARTTLS, HTTPS, DNS). Для реализации на стороне получателя не требуется специальной программной поддержки стандарта.
Недостатки MTA-STS
==================
Необходимо следить за валидностью сертификата веб и почтового сервера, соответствием имен, своевременным обновлением. Проблемы с сертификатом приведут к невозможности доставить почту.
На стороне отправителя требуется MTA с поддержкой политик MTA-STS, на текущий момент «из коробки» MTA-STS не поддерживается в MTA.
MTA-STS использует список доверенных корневых CA.
MTA-STS не защищает от атак, в которых атакующий использует валидный сертификат. В большинстве случаев, MitM вблизи сервера подразумевает возможность выпуска сертификата. Подобная атака может быть обнаружена за счет Certificate Transparency. Поэтому в целом, MTA-STS митигирует, но не устраняет полностью возможность перехвата трафика.
Два последних пункта делают MTA-STS менее защищенным, чем конкурирующий стандарт DANE для SMTP (RFC 7672), но более технически надежным, т.е. для MTA-STS низка вероятность, что письмо не будет доставлено из-за технических проблем вызванных внедрением стандарта.
#### Конкурирующий стандарт — DANE
DANE использует DNSSEC для публикации информации о сертификатах и не требует доверия ко внешним удостоверяющим центрам, что гораздо более безопасно. Но использование DNSSEC существенно чаще приводит к техническим сбоям, если опираться на статистику за несколько лет использования (хотя в надежности DNSSEC и его технической поддержки в целом наблюдается положительная динамика). Для реализации DANE в SMTP на стороне получателя наличие DNSSEC для DNS-зоны обязательно, причем для DANE существенна корректная поддержка NSEC/NSEC3, с которой в DNSSEC есть системные проблемы.
Если DNSSEC сконфигурирован с ошибками, это может приводить к отказам в доставке почты, если отправляющая сторона поддерживает DANE, даже если принимающая сторона ничего о нем не знает. Поэтому, несмотря на то что DANE — это более старый и защищенный стандарт и уже поддержан в некотором серверном ПО на стороне отправителя, по факту его проникновение остается незначительным, многие организации не готовы внедрять его из-за необходимости реализации DNSSEC, это существенно тормозило внедрение DANE все те годы, что стандарт существует.
DANE и MTA-STS не конфликтуют друг с другом и могут быть использованы совместно.
Что с поддержкой MTA-STS в Почте Mail.ru
========================================
Mail.ru уже достаточно давно публикует политику MTA-STS для всех основных доменов. Сейчас мы занимаемся внедрением клиентской части стандарта. На момент написания статьи, политики применяются в неблокирующем режиме (в случае если доставка блокирована политикой, письмо будет доставлено через «запасной» сервер без применения политик), затем будет форсирован блокирующий режим для небольшой части исходящего SMTP-трафика, постепенно для 100% трафика будет поддерживаться применение политик.
Кто еще поддерживает стандарт
=============================
Пока политики MTA-STS публикует примерно 0.05% активных доменов, но, тем не менее, они уже защищают большой объем почтового трафика, т.к. стандарт поддерживают крупные игроки — Google, Comcast и частично Verizon (AOL, Yahoo). Многие другие почтовые службы заявили о том, что поддержка стандарта будет реализована в ближайшем будущем.
Как меня это затронет?
======================
Никак, если ваш домен не публикует политику MTA-STS. Если вы опубликуете политику, то письма для пользователей вашего почтового сервера будут лучше защищены от перехвата.
Как мне внедрить MTA-STS?
=========================
**Поддержка MTA-STS на стороне получателя**
Достаточно опубликовать политику через HTTPS и записи в DNS, сконфигурировать валидный сертификат от одного из доверенных CA (можно Let’s encrypt) для STARTTLS в MTA (STARTTLS поддерживается во всех современных MTA), специальной поддержки со стороны MTA не требуется.
По шагам, это выглядит так:
1. Сконфигурируйте STARTTLS в используемом MTA (postfix, exim, sendmail, Microsoft Exchange и т.д.).
2. Убедитесь, что используется валидный сертификат (выдан доверенным CA, не просрочен, субъект сертификата соответствует MX-записи, по которой доставляется почта для вашего домена).
3. Сконфигурируйте TLS-RPT запись, по которой будут доставляться отчеты о применении политик (сервисами поддерживающими отправку отчетов TLS). Пример записи (для домена example.com):
```
smtp._tls.example.com. 300 IN TXT «v=TLSRPTv1;rua=mailto:tlsrpt@example.com»
```
Эта запись инструктирует отправителей почты слать статистические отчеты по использованию TLS в SMTP на адрес `tlsrpt@exmple.com`.
Последите за отчетам несколько дней, убедитесь в отсутствии ошибок.
4. Опубликуйте политику MTA-STS через HTTPS. Политика публикуется как текстовый файл с терминаторами строк CRLF по расположению.
```
https://mta-sts.example.com/.well-known/mta-sts.txt
```
Пример политики:
```
version: STSv1
mode: enforce
mx: mxs.mail.ru
mx: emx.mail.ru
mx: mx2.corp.mail.ru
max_age: 86400
```
Поле version содержит версию политики (сейчас это `STSv1`), Mode задает режим применение политики, testing — тестовый режим (политика не применяется), enforce — «боевой» режим. Сначала опубликуйте политику с mode: testing, если с политикой не найдется проблем в тестовом режиме, через некоторое время можно переключиться на mode: enforce.
В mx задается список всех почтовых серверов, которые могут принимать почту для вашего домена (у каждого сервера должен быть сконфигурирован сертификат, соответствующий имени заданному в mx). Max\_age задает время кеширования политики (однажды запомненная политика будет применяться даже если атакующий блокирует ее отдачу или испортит DNS-записи в течение времени кеширования, сигнализировать о необходимости заново запросить политику можно через изменение mta-sts записи DNS).
5. Опубликуйте в DNS TXT-запись:
```
_mta-sts.example.com. TXT “v=STSv1; id=someid;”
```
В поле id можно использовать произвольный идентификатор (например метку времени), при изменении политики он должен меняться, это позволяет отправителям понять, что необходимо перезапросить кешированную политику (если идентификатор отличается от кешированного).
**Поддержка MTA-STS на стороне отправителя**
Пока с ней плохо, т.к. стандарт свежий.
* Exim — нет встроенной поддержки, есть сторонний скрипт <https://github.com/Bobberty/MTASTS-EXIM-PERL>
* Postfix — нет встроенной поддержки, есть сторонний скрипт о котором подробно рассказано на Хабре <https://habr.com/en/post/424961/>
В качестве послесловия о «mandatory TLS»
========================================
В последнее время регуляторы обращают внимание на безопасность почты (и это хорошо). Например, DMARC обязателен для всех госучреждений в США и все чаще требуется в финансовой сфере, в регулируемых сферах проникновение стандарта достигает 90%. Сейчас некоторые регуляторы требуют внедрения «mandatory TLS» с отдельными доменами, но при этом механизм обеспечения «mandatory TLS» не определяется и на практике эта настройка часто внедряется таким способом, который даже минимально не защищает от реальных атак, которые уже предусмотрены в таких механизмах как DANE или MTA-STS.
Если регулятор требует реализации «mandatory TLS» с отдельными доменами, мы рекомендуем рассмотреть MTA-STS или его частичный аналог как наиболее подходящий механизм, он устраняет необходимость делать безопасные настройки для каждого домена в отдельности. Если у вас есть сложности с реализацией клиентской части MTA-STS (пока протокол не получил широкой поддержки они скорей всего будут), можно рекомендовать такой подход:
1. Опубликуйте политику MTA-STS и/или записи DANE (DANE имеет смысл добавлять только если для вашего домена уже включен DNSSEC, а MTA-STS в любом случае), это защитит трафик в вашу сторону и избавит от необходимости просить другие почтовые службы настроить mandatory TLS для вашего домена, если почтовая служба уже поддерживает MTA-STS и/или DANE.
2. Для крупных почтовых сервисов реализуйте «аналог» MTA-STS через отдельные настройки транспорта для каждого домена, которые зафиксируют MX используемый для релеинга почты и будут требовать для него обязательной проверки TLS-сертификата. Если домены уже публикуют политику MTA-STS, это, скорее всего, можно сделать безболезненно. Само по себе включение обязательного TLS для домена без фиксации релея и проверки сертификата для него неэффективно с точки зрения безопасности и ничего не добавляет к имеющимся механизмам STARTTLS. | https://habr.com/ru/post/515746/ | null | ru | null |
# Конвертируем диапазон IP в бесклассовую адресацию (CIDR) и обратно в Go
При прохождения очередного собеседования мне задали небольшое тестовое задание, написать на Go сетевой сканер открытых портов. Задание в принципе не сложное, но одним из условий было, что в качестве параметра может быть передан как IP-адрес, так и диапазон сетевых адресов в виде сетевой маски: 192.168.8.0/21.
Тема скорее всего очень тривиальная для сетевых инженеров и администраторов и, наверно, даже скучная. Моя цель просто изложить тут алгоритм перевод диапазона IP в сетевую маску (дальше по тексту CIDR) и обратно из CIDR в диапазон адресов.
Немного теории, но тем, кто уже знаком с терминами можно пропустить и сразу перейти к алгоритму.
Итак, что такое IP я думаю всем понятно и пояснять не нужно. Теперь что такое CIDR (или сетевая маска). Представим, что у нас есть IP: «192.168.11.10». На самом деле это 8-битовые значения разделенные точками, и каждая отдельная часть это так называемый [октет](https://en.wikipedia.org/wiki/Octet_(computing)). Понятно, что IP можно представить в виде 32-битового числа.
Именно такое число и передается в IP-пакете. Теперь давайте представим, что у нас есть подсеть состоящая из 8 хостов — 192.168.11.0 до 192.168.11.7 (Note: 192.168.11.0 нельзя использовать в качестве адреса какого-либо сетевого интерфейса, так как этот адрес используется как идентификатор подсети, поэтому фактически адресов будет 7, но для нашего пример это пока не имеет значения.)
Понятно, что подсетей может быть несколько в рамках одном большой сети и отправлять пакет внутри своей подсети нужно напрямую, а скажем если пакет нужно направить в другую подсеть допусти на IP: 192.168.11.22, то его нужно направить сетевому маршрутизатору, который перенаправить этот пакет в другую подсеть. Хранить на хосте отправителе все адреса своей подсети накладно и бессмысленно, поэтому мы просто храним сетевую маску и для выше обозначенной сети из 8 хостов она будет равна — 255.255.255.248. Теперь если разложить сетевую маску на биты — получим 29 единиц и 3 нулей.
Маска подсети никогда не может перемешивать “1” и “0”, поэтому всегда сначала идет последовательность “1”, а потом последовательность “0”. Теперь диапазон выше обозначенных адресов 192.168.11.0 до 192.168.11.7, можно представить как /<Маска подсети>, т.e. 192.168.11.0/29. Это и есть бесклассовая адресация или Classless Inter-Domain Routing (CIDR) и в этой компактной форме можно представить любой диапазон IP адресов. Относительно правильного разбиения на подсети и маршрутизации имеет смысл обратиться к специализированной литературе и не является целью данной статьи — я надеюсь меня простят сетевые администраторы.
Aлгоритм c комментариями приведен ниже. Сразу скажу, что для диапазона 216.58.192.12 — 216.58.192.206, нет возможности разбить на одну подсеть и алгоритм сразу разобьет диапазон на несколько подсетей:
{
«216.58.192.12/30»,
«216.58.192.16/28»,
«216.58.192.32/27»,
«216.58.192.64/26»,
«216.58.192.128/26»,
«216.58.192.192/29»,
«216.58.192.200/30»,
«216.58.192.204/31»,
«216.58.192.206/32”
}
**Convert IPv4 range into CIDR**
```
// Convert IPv4 range into CIDR
func iPv4RangeToCIDR(ipStart string, ipEnd string) (CIDRs []string, err error) {
cidr2mask := []uint32{
0x00000000, 0x80000000, 0xC0000000,
0xE0000000, 0xF0000000, 0xF8000000,
0xFC000000, 0xFE000000, 0xFF000000,
0xFF800000, 0xFFC00000, 0xFFE00000,
0xFFF00000, 0xFFF80000, 0xFFFC0000,
0xFFFE0000, 0xFFFF0000, 0xFFFF8000,
0xFFFFC000, 0xFFFFE000, 0xFFFFF000,
0xFFFFF800, 0xFFFFFC00, 0xFFFFFE00,
0xFFFFFF00, 0xFFFFFF80, 0xFFFFFFC0,
0xFFFFFFE0, 0xFFFFFFF0, 0xFFFFFFF8,
0xFFFFFFFC, 0xFFFFFFFE, 0xFFFFFFFF,
}
// Переведем IP в беззнаковые целые числа.
ipStartUint32 := iPv4ToUint32(ipStart)
ipEndUint32 := iPv4ToUint32(ipEnd)
// Если диапазон задан неверно, просто вернем ошибку.
if ipStartUint32 > ipEndUint32 {
log.Fatalf("start IP:%s must be less than end IP:%s", ipStart, ipEnd)
}
for ipEndUint32 >= ipStartUint32 {
maxSize := 32
// Определим максимальную маску подсети доступную для текущего IP адреса.
for maxSize > 0 {
maskedBase := ipStartUint32 & cidr2mask[maxSize - 1]
if maskedBase != ipStartUint32 {
break
}
maxSize--
}
// Проверим, если маска превышает диапазон указанный в конечном IP адресе. И если превышает, проведем коррекцию.
x := math.Log(float64(ipEndUint32 - ipStartUint32 + 1)) / math.Log(2)
maxDiff := 32 - int(math.Floor(x))
if maxSize < maxDiff {
maxSize = maxDiff
}
// Сохраним CIDR
CIDRs = append(CIDRs, uInt32ToIPv4(ipStartUint32) + "/" + strconv.Itoa(maxSize))
// Увеличим диапазон на размерность подсети и повторим цикл.
ipStartUint32 += uint32(math.Exp2(float64(32 - maxSize)))
}
return CIDRs, err
}
```
Теперь что касается обратного алгоритма, когда нужно перевести такой же диапазон бесклассовой адресации обратно в IP. Лично в моем тестовом задании этот алгоритм не понадобился и возможно кто-то из сетевых администраторов прокомментирует, насколько он нужен в реальной жизни, но я решил написать сразу и тот и другой. Алгоритм до элементарного прост, вы должны в начальному IP подсети прибавить ее размерность.
**Convert CIDR to IPv4 range**
```
// Convert CIDR to IPv4 range
func CIDRRangeToIPv4Range(CIDRs []string) (ipStart string, ipEnd string, err error) {
var ip uint32 // ip address
var ipS uint32 // Start IP address range
var ipE uint32 // End IP address range
for _, CIDR := range CIDRs {
cidrParts := strings.Split(CIDR, "/")
ip = iPv4ToUint32(cidrParts[0])
bits, _ := strconv.ParseUint(cidrParts[1], 10, 32)
if ipS == 0 || ipS > ip {
ipS = ip
}
ip = ip | (0xFFFFFFFF >> bits)
if ipE < ip {
ipE = ip
}
}
ipStart = uInt32ToIPv4(ipS)
ipEnd = uInt32ToIPv4(ipE)
return ipStart, ipEnd, err
}
```
**Note:** *только для Go разработчиков: алгоритм можно сделать еще более производительным, если возвращать данные в формате — (IP, \*IPNet, error), но для универсальности я возвращаю данные как string.*
Код сетевого сканера лежит тут: [GitHub](https://github.com/P-A-R-U-S/Golang-Network-Scanner). Если поставите звездочку, буду благодарен, но только, если я ее заслужил :))
**Ссылки:**
* [Wikipedia.org: Маски подсети](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%81%D0%BA%D0%B0_%D0%BF%D0%BE%D0%B4%D1%81%D0%B5%D1%82%D0%B8)
* [Еще раз про IP-адреса, маски подсетей и вообще](https://habrahabr.ru/post/129664/)
* [CIDR notation](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing#CIDR_notation) | https://habr.com/ru/post/351574/ | null | ru | null |
# «Делай как я!» — изучаем имперсонатор
Самые интересные и перспективные разработки в области AI связаны с нейронными сетями. Сегодня рассмотрим Impersonator++ для накопления опыта в области Deep fake.
В настоящее время самые интересные и перспективные разработки в области AI связаны с нейронными сетями.
Больших успехов они позволяют достичь в области компьютерного зрения, преобразования видео и изображений.
Широкую известность в интернете получили видео, созданные с помощью технологий Deep fake, в которых лица людей заменяются на совершенно другие. Иногда такие работы выглядят очень правдоподобно.
Однако помимо развлекательного характера эти технологии могут быть использованы в корыстных (даже преступных) целях. Если заменить лицо преступника, попавшего под объектив камеры наблюдения на совершенно другое, то у невиновного человека, как минимум может появится много проблем.
В ноябре 2020 года технологии Deep fake получили «долгожданное» продолжение: группа разработчиков из Китая создала инструмент, с помощью которого можно наложить заданные движения на любую личность с сохранением фона.
Чтобы успешно бороться с цифровым мошенничеством следует хорошо знать своего потенциального «врага». Поэтому предлагаем ознакомиться с функционалом Impersonator++. На вход он получает фото личности, которую будут «оживлять», и референсное видео с заданным движением. А на выход подаёт итоговое видео:
На рисунке в первой строке вы видите кадры из референсного видео с заданным движением, в левой части фотографии людей, а в центре кадры из итогового видео, где они двигаются.
Для качественного выявления фальшивок следует применять системный подход и использовать не только принцип «прозрачного ящика», то есть строить анализ не только на основе знаний внутреннего устройства инструментов DeepFake и их алгоритмов, но и работать с чёрным ящиком. То есть зная, что на выходе мы получаем фальшивые видео, мы можем их сами генерировать и использовать в настройке систем опознавания.
Чтобы установить Impersonator++ на ПК необходим либо Linux либо Windows, CUDA, gcc 7.5+, ffmpeg (ffprobe). Прочие технические требования можете прочитать на ресурсе проекта: [https://www.impersonator.org](https://www.impersonator.org/). Также по этой ссылке можно найти статью разработчиков, которая раскрывает технологию работы Impersonator++.
Инструмент включает несколько предобученных на примерах моделей и довольно прост в использовании.
Важным является формат и синтаксис обращения к инструменту. Для установки и настройки следует выполнить несколько команд.
```
!apt-get install ffmpeg # установка ffmpeg
import os
os.environ["CUDA_HOME"] = "/usr/local/cuda-10.1" # задаём CUDA_HOME
!echo $CUDA_HOME
```
Для установки клонируем репозиторий с github и устанавливаем:
```
!git clone https://github.com/iPERDance/iPERCore.git
cd /content/iPERCore/
!python setup.py develop
```
Чтобы скачать предобученные модели, исполняемые файлы и примеры используем следующий код:
```
!wget -O assets/checkpoints.zip "https://download.impersonator.org/iper_plus_plus_latest_checkpoints.zip"
!unzip -o assets/checkpoints.zip -d assets/
!rm assets/checkpoints.zip
!wget -O assets/samples.zip "https://download.impersonator.org/iper_plus_plus_latest_samples.zip"
!unzip -o assets/samples.zip -d assets
!rm assets/samples.zip
```
После установки, разложив в нужные директории картинки с субъектами и видео с действиями, мы можем увеличить обучающую выборку следующим кодом:
```
import os
import os.path as osp
import platform
import argparse
import time
import sys
import subprocess
from IPython.display import HTML
from base64 import b64encode
```
далее задаём директории и значения по умолчанию для параметров:
```
gpu_ids = "0"
# размер изображения
image_size = 512
# число картинок-источников изображения по умолчанию считается 2, но значение обновится, если фактическое окажется меньше num_source
num_source = 2
# директория с ресурсами, моделями и исполняемыми файлами, которые прежде необходимо скачать
assets_dir = "/content/iPERCore/assets"
# директория для сохранения результатов
output_dir = "./results"
# символическая ссылка с актуальной директории с ресурсами на текущую директорию
work_assets_dir = os.path.join("./assets")
if not os.path.exists(work_asserts_dir):
os.symlink(osp.abspath(assets_dir), osp.abspath(work_assets_dir),
target_is_directory=(platform.system() == "Windows"))
cfg_path = osp.join(work_assets_dir, "configs", "deploy.toml")
```
И, наконец, формируем имитацию движения на основе разных фото:
```
model_id = “ident_remove_mask_multi”
# путь к картинке, которая ляжет в основу
src_path = “\”path?=/persons/person1.png\””
# путь к видео с референсным, интересующим нас, движением
ref_path = "\"path?=/movement/remove_the_mask/act1.mp4\""
!python -m iPERCore.services.run_imitator \
--gpu_ids $gpu_ids \
--num_source $num_source \
--image_size $image_size \
--output_dir $output_dir \
--model_id $model_id \
--cfg_path $cfg_path \
--src_path $src_path \
--ref_path $ref_path
```
В папке, которую мы указали для сохранения результата, мы получим файл mp4 с названием модели. Проба пера получилась такой:
Слева расположена исходная фотография, посередине – кадр из референсного видео, справа – кадр из итогового видео.
Видно, что на изображении справа поза человека схожа с позой человека на центральной картинке. При этом относительно исходного варианта фигура кажется даже немного развёрнутой в другую сторону.
Конечно, чем качественнее материал подаётся на вход, тем качественнее на выходе, а так как в данном примере использовались необработанные файлы из интернета, то и результат получается немного сомнительным.
Пока что большинство полученных с помощью DeepFake материалов люди могут распознать невооружённым глазом, но прогресс не стоит на месте, и мы считаем, что уже сейчас стоит разрабатывать/готовить системы распознавания подобных имитаций. Но это уже отдельная тема. Следует также отметить, что орудие может приносить не только вред, но и пользу – всё зависит от рук, в которые оно попадает. А в руках кинематографистов, рекламных агентств, образовательных фондов данный инструмент при дальнейшем развитии может сотворить много интересных вещей. | https://habr.com/ru/post/546334/ | null | ru | null |
# Загрузчик модулей для node js с поддержкой локальных модулей и загрузки модулей по требованию
Я — frontend разработчик и в последнее время мне все чаще приходится пользоваться нодой, будь то использование webpack-а для сборки проекта, либо настройка различных gulp тасков. Хоть у меня и нету большого опыта в использование ноды, со временем у меня накопилось три вещи, которые мне хотелось бы улучшить при работе с модулями:
* Избавиться от кучи require-ов в начале каждого файла
* Подгружать модули только тогда, когда они нужны(особенно это актуально для gulp тасков)
* Иметь возможность работать с локальными модулями проекта, как с внешними модулями, то есть вместо, например,
вызова var core = require('../../deep/deep/deep/core/core'), вызывать этот же модуль вот так var core = require('core')
Для решения всех трех задач по отдельности есть уже различные модули и решения, но во-первых, все они имеют, как мне кажется, недостатки, а во-вторых, ни одно из решений не решает все три проблемы вместе.
Например, для подгрузки модулей по требованию(он же lazy load или load on demand), есть модуль gulp-load-plugins. Он решает 1-ую и 2-ую проблему, но не решает 3-юю и имеет еще один недостаток — чтобы подключить модули, нужно в каждом файле, где эти модули нужны, производить инициализацию gulp-load-plugins модуля. Можно, конечно, делать инициализацию в отдельном файле и экспортировать из файла значение, но в таком случае придется подключать этот файл с использованием относительных или абсолютного путей.
Для решения 3-ей проблемы около года назад в npm добавили поддержку так званых локальных модулей. Суть сводится к тому, что
в package.json в dependencies нужно указать в качестве ключей имена модулей, а в значениях — относительные пути к папкам локальных модулей с префиксом «file:», например, вот часть package.json файла:
```
"dependencies": {
"lodash": "^2.0.0",
"core": "file:deep/deep/deep/core",
"my-other-module": "file:/my-other-module"
}
```
При этом папки локальных модулей должны быть оформлены, как обычные модули, то есть должны содержать свой package.json и readme.md файлы. После запуска npm i ваши локальные модули будут установлены в папку node\_modules, как обычные модули. По мне так это крайне неудобно класть каждый файл проекта в отдельную папку, да еще и заводить на него package.json и readme.md файлы.
Одним словом я не нашел хорошего решения для описанных мною проблем, может плохо искал, но облазив различные форумы и прочитав различные свежие статьи пришел к выводу, что люди до сих пор ищут хорошее решение всех этих проблем.
В итоге я решил написать свое решение, возможно, свой велосипед, о котором и хочу поведать вам. На сколько он хорош или плох судить вам. Итак, позвольте представить вам sp-load. Сразу оговорюсь, префикс sp- не несет в себе никакого сакрального смысла, это всего лишь первые буквы моей фамилии и имени и добавлен не с целью прославить меня, а по причине того, что имена «load», «loader» и прочие были уже заняты.
Итак, вы сделали npm i sp-load -S в своем проекте. Предположим, что вы имеете следующее содержимое package.json файла:
```
{
"name": "your-project",
"version": "1.0.0",
"main": "index.js",
"dependencies": {
"lodash": "^3.10.1",
"sp-load": "^1.0.0"
},
"devDependencies": {
"gulp": "^3.9.0",
"webpack": "^1.12.9"
},
"_localDependencies": {
"core": "./core/core",
"some-module": "./deep/deep/deep/deep/deep/deep/deep/some-module"
}
}
```
И имеете следующую структуру файлов:
```
your-project/
node_modules
sp-load/
...
gulp/
...
lodash/
...
webpack/
...
package.json
core/
core.js
deep/
deep/
deep/
deep/
deep/
deep/
deep/
some-module.js
gulpfile.js
index.js
```
Что вам нужно сделать, чтобы использовать sp-load в простейшем виде? Всего одну вещь, сделать var $ = require('sp-load'); внутри какого-либо файла, например, вот содержимое gulpfile.js:
```
'use strict';
var $ = require('sp-load'),
webpackConfig = {};
$.gulp.task("webpack", function (callback) {
$.webpack(webpackConfig, function (err, stats) {
callback();
});
});
```
Содержимое some-module.js:
```
'use strict';
function someModuleFuction() {
console.log('I\'m some module function call!');
}
module.exports = someModuleFuction;
```
Содержимое core.js:
```
'use strict';
function coreModuleFuction() {
console.log('I\'m core module function call!');
}
module.exports = coreModuleFuction;
```
Содержимое index.js:
```
'use strict';
var $ = require('sp-load');
$.someModule();
$.core();
```
Как вы видите, всё что нужно сделать — подключить sp-load модуль. Он возвращает объект, содержащий список модулей, которые будут подгружены по требованию, то есть модуль будет загружен node-ой при первом обращение по имени модуля, например, $.core().
Также вы, наверное, заметили нестандартное свойство "\_localDependencies" в package.json. В этом свойстве вы можете определить список локальных модулей вашего проекта. Ключи объекта — названиям модулей, значения — относительный путь к файлу модуля(путь относительный package.json файла).
Если же вы хотите обращаться к модулям не как к свойствам объекта, а как к переменным, то можете сделать это следующим образом(в примере используется es6 деструктуризация. как включить возможности es6 в nodejs вы можете прочесть в документацие nodejs):
```
'use strict';
var {someModule, core} = require('sp-load');
someModule();
core();
```
Или с использованием es5:
```
'use strict';
var $ = require('sp-load'),
someModule = $.someModule,
core = $.core;
someModule();
core();
```
В обоих этих примерах, модули someModule и core буду подгружены при присвоение, если же вы хотите, чтобы они были подгружены в момент первого их использования(то есть on demand), то обращайтесь к модулям, как к свойствам объекта $.
Это было простейшее использование sp-load, без каких-либо конфигураций, за исключением использования свойства "\_localDependencies" в package.json. Теперь же хочу показать какие настройки поддерживает sp-load. Для того, чтобы конфигурировать sp-load, необходимо добавить свойство "\_sp-load" в package.json. Ниже приведен пример package.json файла, в котором указаны все возможные настройки с комментариями о назначение каждой из них:
```
{
"name": "your-project",
"version": "1.0.0",
"main": "index.js",
"dependencies": {
"lodash": "^3.10.1",
"sp-load": "^1.0.0"
},
"devDependencies": {
"gulp": "^3.9.0",
"webpack": "^1.12.9"
},
"_localDependencies": {
"core": "./core/core",
"some-module": "./deep/deep/deep/deep/deep/deep/deep/some-module"
},
"_sp-load": {
/*
если значение true, имена модулей будут в виде camel case.
например, вместо $['some-module'] будет $.someModule.
дефолтное значение - true.
*/
"camelizing": false,
/*
эта настройка отвечает за переименование имен модулей. например, вместо $.lodash модуль будет доступен
как $._
*/
"renaming": {
"lodash": "_",
"gulp": "supergulp"
},
/*
если вы хотите заменить часть названия модулей, используйте эту настройку. ключи - регулярные выражения,
значения - строки, на которые будет произведена замена. наиболее частый случай использования - gulp
плагины, большинство из которых начинаются с префикса gulp-, например, gulp-concat, а вы хотите обращаться
к нему как $.concat вместо $.gulpConcat.
*/
"replacing": {
"/^gulp-/": ""
}
}
}
```
Если же вы не хотите засорять package.json файл, то поместите настройки sp-load и список локальных модулей в файл \_sp-load.json, который должен находиться в той же папке, где и package.json, то есть:
```
yourProject/
package.json
_sp-load.json
```
Вот пример содержимого \_sp-load.json файла:
```
{
"_localDependencies": {
"core": "./core/core",
"some-module": "./deep/deep/deep/deep/deep/deep/deep/some-module"
},
"_sp-load": {
"camelizing": false,
"renaming": {
"lodash": "_",
"gulp": "supergulp"
},
"replacing": {
"/^gulp-/": ""
}
}
}
```
И последнее, о чем еще не упомянул. Когда вы делаете $ = require('sp-load');, объект $ содержит свойство "\_spModulesList" в своем прототипе. Это свойство содержит объект, где ключи — имена модулей, а значения — абсолютный путь к файлу модуля. Вот пример содержимого этого объекта:
```
{
"lodash": "lodash",
"sp-load": "sp-load",
"gulp": "gulp",
"webpack": "webpack",
"core": "D://your-project//core//core.js",
"some-module": "D://your-project//deep//deep//deep//deep//deep//deep//deep//some-module.js"
}
```
Для чего это может пригодиться? Например, при использование System.js загрузчика.
Пожалуй, это всё. Перед тем, как опубликовать модуль на npmjs.com, протестировал его, но в реальном проекте ещё его не использовал, поэтому, если будут какие-либо ошибки — буду рад, если сообщите о них.
Ссылка на сам модуль: [sp-load](https://www.npmjs.com/package/sp-load).
**P.S.:** Может, кто-нибудь подскажет, как удалить опубликованный модуль из npmjs.com? Нигде не нашел, как это сделать, а npm unpublish удаляет модуль, но при последующем npm publish приходится увеличивать версию модуля т.к. npm ругается, что текущая версия уже зарегистрирована. | https://habr.com/ru/post/275011/ | null | ru | null |
# Выжимаем все соки из Chromium на Linux
В этой статье рассмотрим, как выжать все соки из Хромиума и максимально ускорить его или другой браузер на его движке (Chromium, Google Chrome, Opera, Vivaldi, Яндекс и др.). За счет включения многих экспериментальных возможностей по вынесу вычислений с процессора на видеокарту и включения использования находящихся в разработке программных алгоритмов. За счет этого наш любимый *хромиум станет работать быстрее, может перестать тормозить или моргать экраном*.
*Поехали!*
Как сделать резервную копию всего профиля браузера (настройки, история. закладки и пр.), написано в конце статьи.
Заходим по адресу **`[chrome://gpu](http://chrome://gpu)`** (да, именно так наберите в адресной строке или скопипастьте)!
[](https://nixtux.ru/wp-content/uploads/2017/10/DeepinScreenshot_select-area_20171002224623.png)
Как видите, у меня везде зеленая надпись «Hardware accelerated», что говорит, что данная функция использует аппаратное ускорение за счет выноса вычислений на видеокарту, а «Enabled» говорит, что программный алгоритм включен.
Теперь зайдите в **`[chrome://flags](http://chrome://flags)`**.Здесь и будем производить б**о**льшую часть настройки.
[](https://nixtux.ru/wp-content/uploads/2017/10/DeepinScreenshot_select-area_20171002234033.png)
На скриншоте красным прямоугольников выделил `#ignore-gpu-blacklist`. Дальше все опции из этого списка буду именовать именно вот так. Можно нажать Ctrl+F и найти настройку по ее скопипащенному названию.
[](https://nixtux.ru/wp-content/uploads/2017/10/DeepinScreenshot_select-area_20171002234238.png)
Теперь у нас открыты и `chrome://gpu`, и `chrome://flags`. Смотрим, какие параметры есть в `chrome://gpu`, и, если параметр не зеленый, а желтый или красный, в `chrome://flags` изменяем соответствующую настройку. *Осторожно, некоторые настройки могут сделать работу браузера нестабильной, зависит от железа.*
**Canvas** — аппаратное ускорение отрисовки [канваса](https://ru.wikipedia.org/wiki/Canvas_(HTML))
В `chrome://flags` это `**#ignore-gpu-blacklist**`
**Откл**ючается включением опции `#disable-accelerated-2d-canvas`
**[CheckerImaging](https://www.google.ru/search?q=chromium+CheckerImaging)** — суть в том, что растеризация картинки убрана из зависимости от растеризации остальной области, с которой связана картинка, что позволяет отрисовывать веб-страницу, не дожидаясь окончания обработки картинки, как-то так. Говорят, сайт Юлмарта начинает отрисовываться намного быстрее.
Это параметр командной строки `**--enable-features="CheckerImaging"**`, подробнее ниже.
**Flash, Flash Stage3D, Flash Stage3D, Flash Stage3D Baseline profile** — аппаратное ускорение декодирования флеш-контента
Тоже `**#ignore-gpu-blacklist**`
**Compositing** — аппаратное ускорение наложения слоев
Скорее всего, тоже `**#ignore-gpu-blacklist**`, я не встречал, чтобы это было не работало (было не зеленым) «из коробки».
**Multiple Raster Threads** — распараллеливание на несколько потоков процесса растеризации векторных элементов веб-страницы
`**#enable-gpu-rasterization**` —> Force-enabled for all layers / Принудительно для всех слоев.
Включение этой опции также может помочь, если у вас *моргает экран при просмотре сайтов*, в т.ч. вконтакте, и видео.
[**Native GpuMemoryBuffers**](https://software.intel.com/en-us/articles/native-one-copy-texture-uploads-for-chrome-os-on-intel-architecture-enabled-by-default) — исключается дополнительный буфер при копировании элементов между CPU и GPU, по умолчанию выключено, почему — подробно написано по ссылке.
Это параметр командной строки `**--enable-native-gpu-memory-buffers**`, подробнее ниже.
**Rasterization** — применение видеокарты для растеризации
`**#enable-gpu-rasterization**`
**Video Decode** — аппаратное ускорение декодирования видео (при просмотре видео декодируется)
**Video Encode** — аналогично кодирование
Входит в `**#ignore-gpu-blacklist**`
**WebGL, WebGL2** — поддержка рендеринга на видеокарте набора инструкций OpenGL, входящих в стандарт WebGL; автоматически выключается, если драйвер видеокарты их не поддерживает.
Входит в `**#ignore-gpu-blacklist**`
Еще есть опция `**#enable-zero-copy**`, выше приведена [ссылка](https://software.intel.com/en-us/articles/native-one-copy-texture-uploads-for-chrome-os-on-intel-architecture-enabled-by-default) на статью инженеров Intel, которые разрабатывали эту функцию (судя по скриншотам и вступлению в статье, разработка происходит на Ubuntu, но коммерчески выгодна в первую очередь из-за Chrome OS). Есть подозрение, что ее работа будет очень специфична для конкретного железа.
**`#enable-tcp-fast-open`** — [TCP Fast Open](https://habrahabr.ru/post/136926/), ускоряет работу сетевого стека, фича ядра Linux, на Windows и MacOS недоступно, виндузятниги ~~с\*\*\*\*~~ ничего не подозревая наслаждаются ущербностью своей операционной системы, яблочники от них не сильно отстают (не воспринимайте близко к сердцу, это шутка).
**`#expensive-background-timer-throttling`** — ограничивает максимальную нагрузку на процессор фоновыми вкладками (т.е. не та вкладка, с которой вы сейчас работаете) до максимум 1%. Далеко не всегда уместно. Вдруг у вас в фоновой вкладке запущена торговля на бирже.
**`#v8-cache-options`** — например, в режиме «Cache V8 compiler data» V8 будет лучше кешировать javascript и не компилировать их заново. Опять же. на некоторых сложных веб-приложениях в теории может вызывать проблемы. V8 — это движок обработки ( в т.ч. компиляции) яваскрипта в Chromium, а компиляция javascript создает основную нагрузку на процессор при работе браузера.
**`#v8-cache-strategies-for-cache-storage`** — можно включить агрессивный кеш V8, речь о кеше в предыдущем абзаце, возможное последствия те же.
**`#shared-array-buffer`** — экспериментальные функции работы с памятью в javascript, подробное объяснение [здесь](https://habrahabr.ru/company/ruvds/blog/332194/).
**`#enable-simple-cache-backend`** —> Enabled/Включено — вместо реализации своего подобия файловой системы в блочном файле для кеша, работаем с файлами непосредственно внутри файловой системы, возлагая большую часть работы на операционную систему и уменьшая нагрузку на ввод-вывод с диска, в т.ч. уменьшаем количество переключений контекста, что должно ускорить работу.
Теперь про **опции командной строки** Chromium и Google Chrome. Теоретически, всякие иные ~~поделия~~ браузеры на движке Сhromium должны их поддерживать, но гарантии нет.
Закрываем все открытые копии Chromium, открываем терминал и выполняем вот такую команду:
```
$ chromium-browser --enable-native-gpu-memory-buffers --enable-features="CheckerImaging"
```
В `chrome://gpu` видим, как стали зелеными пункты CheckerImaging и Native GpuMemoryBuffers (либо браузер вообще не запустился :) ) Но ведь каждый раз запускать браузер через терминал неудобно, поэтому открываем графический редактор [desktop-файлов](https://www.google.ru/search?q=xdg+desktop+files&oq=xdg+desktop+files&aqs=chrome..69i57j0.3738j0j7&client=ubuntu&sourceid=chrome&ie=UTF-8) и в нем дописываем в команду запуска браузера нужные нам параметры (обратите внимание, что на конце есть `%U`, оно заменяется на ссылку или путь к файлу, который нужно открыть, так что его не нужно удалять. В KDE это `kmenuedit` (вызов либо через терминал командой `kmenuedit`, либо подвести курсор к кнопке вызова меню приложений и нажать на правую кнопку мыши 1 раз, затем левой 1 раз нажать на «Редактор меню» в появившемся списке), на остальных DE (XFCE, GNOME, Budgie, LXDE, LXQt и др.) это `menulibre`.
[](https://nixtux.ru/wp-content/uploads/2017/10/DeepinScreenshot_select-area_20171003012230.png)
[](https://nixtux.ru/wp-content/uploads/2017/10/DeepinScreenshot_MenuLibre_20171003001133.png)
[](https://nixtux.ru/wp-content/uploads/2017/10/DeepinScreenshot_select-area_20171003001117.png)
Тру-униксоиды могут скопировать `/usr/share/applications/chromium-browser.desktop` в `~/.local/share/applications/chromium-browser.desktop` и отредактировать параметр Exec, получится то же самое:
[](https://nixtux.ru/wp-content/uploads/2017/10/DeepinScreenshot_select-area_20171003002500.png)
В зависимости от DE, вам может потребоваться повторно вынести ярлык на рабочий стол и/или панели.
**UPD** 10.05.2018.
[Здесь](https://github.com/WArYagTwar/chromiumdesktop) ведется полный список флагов для Chromium, который можно прописать непосредственно в Exec в Desktop-файле, чтобы не нужно было их все включать вручную:
```
chromium-browser --ignore-gpu-blacklist --enable-experimental-canvas-features --enable-accelerated-2d-canvas --canvas-msaa-sample-count=2 --force-display-list-2d-canvas --force-gpu-rasterization --enable-fast-unload --enable-accelerated-vpx-decode=3 --enable-tcp-fastopen --javascript-harmony --enable-checker-imaging --v8-cache-options=code --v8-cache-strategies-for-cache-storage=aggressive --enable-zero-copy --ui-enable-zero-copy --enable-native-gpu-memory-buffers --enable-webgl-image-chromium --enable-accelerated-video --enable-gpu-rasterization
```
**Как измерить скорость работы браузера**, понять, какие опции *на вашем сочетании железа и видеодрайвера* ускоряют работу, а какие замедляют?
Для этого запускайте онлайн бенчмарк [web.basemark.com](https://web.basemark.com/) с различными сочетаниями настроек и сравнивайте количество набранных ~~попугаев~~ баллов.
В `chrome://gpu` браузер может мамой клясться, что включено аппаратное ускорение декодирования видео. Но ведь не каждое видео будет декодироваться аппаратно!
Открываем **`chrome://media-internals/`**, параллельно запускаем проигрывание какого-нибудь видео с [Youtube](https://youtube.com/) и смотрим, каким кодеком оно декодируется.
[](https://nixtux.ru/wp-content/uploads/2017/10/DeepinScreenshot_select-area_20171003012944.png)
Сейчас Google все видео отдает в кодеке VP9 собственной разработки, но на довольно многих старых видеокартах возможно аппаратное декодирование только H.264; расширение [h264ify](https://chrome.google.com/webstore/detail/h264ify/aleakchihdccplidncghkekgioiakgal?hl=ru) заставит браузер сообщать, что он не поддерживает кодеки VP8 и VP9, что заставит Youtube отдавать видео в H.264. См. [youtube.com/html5](https://www.youtube.com/html5)
По умолчанию так:
[](https://nixtux.ru/wp-content/uploads/2017/10/DeepinScreenshot_select-area_20171003014118.png)
С включенным h264ify на его стандартных настройках:
[](https://nixtux.ru/wp-content/uploads/2017/10/DeepinScreenshot_select-area_20171003014246.png)
Вообще нет единого нормального списка, какие драйверы и на каких видеокартах поддерживают аппаратное декодирование, но вот Chromium 62 [появится](https://chromium-review.googlesource.com/c/chromium/src/+/532294) полноценная работа VA-API (API для аппаратного ускорения кодирования и декодирования видео), которая была и раньше, но только на ChromeOS, а, например, [здесь](https://launchpad.net/~saiarcot895/+archive/ubuntu/chromium-dev), Хромиум собирали и собирают с патчем, который включает это и на Линуксе. Для работы рекомендуется свежая версия libva; если у вас, к примеру, Ubuntu 16.04, то можно обновить весь графический стек [отсюда](https://launchpad.net/~xorg-edgers/+archive/ubuntu/ppa), что рекомендуется пользователям современных и не очень видеокарт Intel и AMD, т.к. в наши дни опенсорсный графический стек развивается очень быстро, а мы в статье задействовали множество функций работы с видеокартой. Разработчики Ubuntu 17.10 [работали](https://www.google.ru/search?q=ubuntu+17.10+libva+status&oq=ubuntu+17.10+libva+status&client=ubuntu&sourceid=chrome&ie=UTF-8) над улучшением работы VA-API из коробки. Вообще, с проигрыванием видео на Линуксе никогда не встречал проблем, все хорошо работает из коробки. Для Firefox *было* [дополнение](https://addons.mozilla.org/ru/firefox/addon/watch-with-mpv/), которое позволяло ролик с Youtube проигрывать во внешнем плеере mpv, что на очень старых машинах могло существенно снижать нагрузку на процессор.
— Памагите!!! **Браузер перестал запускаться**!!!
— Такое бывает очень редко, но все же иногда случается, когда настройки работы с видеокартой выкручиваются так, что у браузера не получается с ней работать. Открываем в файловом менеджере папку `~/.config` (~ — это ваша домашняя папка) и находим папку chromium (для Google Chrome она называется google-chrome, Vivaldi — Vivaldi и т.д.).
[](https://nixtux.ru/wp-content/uploads/2017/10/DeepinScreenshot_select-area_20171003010204.png)
В ней хранится наш профиль. Можно просто переименовать папку, например, в chromium.old, а при следующем запуске chromium создаст ее заново и начнет с чистого листа. В качестве **резервной копии (бекапа)** рекомендую до проведения всех манипуляций заархивировать эту папку (и хранить, как зеницу ока). Если вы что-то поломали, а начинать с чистого профиля не хочется, то попробуйте открыть терминал внутри `~/.config/chromium` и выполнить команду:
```
$ grep -inHr "ignore-gpu-blacklist"
```
где вместо ignore-gpu-blacklist подставьте название опции, которая, как вы думаете, с тала причиной неполадок. В ответ команда grep выдаст путь к файлу и номер строки, где есть шанс поправить настройку. Возможно, часть настроек хранится в SQLite базе данных, и тогда потребуется какая-нибудь программа для работы с SQLite-БД и поиска по ним. Честно говоря, ни разу не пробовал так делать.
[](https://nixtux.ru/wp-content/uploads/2017/10/DeepinScreenshot_select-area_20171003010529.png)
За сим отчаливаю, спасибо за внимание, жду отзывов и вопросов в комментариях. | https://habr.com/ru/post/339238/ | null | ru | null |
# Mail.ru Group представила сервис «VK Почта», доступный только для пользователей «ВКонтакте»
Mail.ru Group [рассказала](https://corp.mail.ru/ru/press/releases/10980/) о новом элементе экосистемы VK — сервисе «VK Почта». Теперь пользователи могут зарегистрировать почту с коротким доменом `@vk.com` Почтовый сервис рассчитан только на пользователей социальной сети «ВКонтакте».
К преимуществам «VK Почта» Mail.ru Group относит минималистичный дизайн, персонализацию, технологичность и безопасность. Среди технологичных преимуществ перечислены:
* умная сортировка писем по метатредам, работающая на базе машинного обучения;
* технология «управления рассылками», при которой отписаться от рассылок можно не переходя на сайт отправителя;
* короткие «умные ответы» на письма, сформированные моделью машинного обучения «Почты Mail.ru» на основе содержания других писем;
* антиспам-система на основе машинного обучения, адаптирующаяся к меняющимся сценариям спам-рассылок.
Разработчики указали, что у почтового ящика нет отдельного пароля. Войти в него можно только через единую учётную запись VK Connect. Защитить почту можно с помощью двухфакторной аутентификации, Touch ID или Face ID.
Также пользователи, получающие письма от онлайн-магазинов, смогут из письма перейти в чат с компанией в мессенджере «ВКонтакте» и уточнить все детали по заказу. Пока Mail.ru Group ввела возможность переписки с семью сервисами, среди которых указаны Ozon, Wildberries и Lamoda. Со временем компания обещает расширить список партнёров.
Mail.ru Group утверждает, что экосистемой VK пользуются больше 90 % аудитории Рунета. На данный момент в неё входят соцсети «ВКонтакте» и «Одноклассники», игровая платформа MY.GAMES, сервис объявлений «Юла», сервисы доставки еды Delivery Club, «Самокат» и «Кухня на районе», приложения для заказа такси «Ситимобил» и «Ситидрайв», российский сегмент Aliexpress и образовательные сервисы, такие как GeekBrains и Skillbox.
27 августа «ВКонтакте» [сообщила](https://habr.com/ru/news/t/574992/) о новых функциях «Музыки ВКонтакте». С 30 августа соцсеть внедрила опцию загрузки и офлайн-прослушивания музыки, но только для платных пользователей. Кроме того пользователи без платных подписок смогут продолжить прослушивание треков (с рекламой) только при условии включенного экрана смартфона или открытой вкладкой со страницей «ВКонтакте». | https://habr.com/ru/post/575570/ | null | ru | null |
# Как повысить безопасность вашего сайта на Wordpress
В этой статье описаны самые распространённые проблемы безопасности WordPress и способы их решения, включая советы, как избежать взлома.
Безопасность WordPress является важной темой с тех пор, как эта система управления содержимым (Content Management System или сокращённо — CMS) была выпущена в 2003 году. Как и любое популярное программное обеспечение с длинной и богатой историей, CMS WordPress также может стать целью хакеров. Вредоносные действия могут включать межсайтовые скриптовые атаки, sql-инъекции, [брутфорс атаки](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%BB%D0%BD%D1%8B%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%B1%D0%BE%D1%80) и ряд прочих способов получения несанкционированного доступа.
По мере того как хакеры набираются опыта в поиске новых способов использования уязвимостей, WordPress-разработчики и специалисты по безопасности совершенствуются в создании сайтов, которые сложнее взломать. Есть вещи, которые разработчики и владельцы сайтов на WordPress могут предпринять в первую очередь, если они не хотят, чтобы хакеры легко смогли обойти защиту их сайтов и получить доступ к данным. Ниже мы обсудим некоторые действия, которые может предпринять администратор WordPress, чтобы его сайт не могли взломать.
>
> **Содержание**
> * [Включите правильные разрешения на сервере для wp-config.php и .htaccess](#0)
> * [Используйте актуальную и безопасную версию PHP](#1)
> * [Отключите редактирование тем и плагинов на уровне панели администратора WordPress](#2)
> * [Постоянно обновляйте свои плагины WordPress](#3)
> * [Устанавливайте темы и плагины WordPress только из надёжных источников](#4)
> * [Измените wp\_prefix в базе данных во время установки WordPress](#5)
> * [Не используйте стандартный логин «Admin». Используйте надёжные пароли](#6)
> * [Отключите функцию регистрации пользователей, если она вам не нужна](#7)
> * [Отключите комментарии, если они вам не нужны](#8)
> * [Настройка robots.txt для блокирования несанкционированного доступа к файлам WordPress](#9)
> * [Защитите себя от подбора учётных записей пользователей](#10)
> * [Безопасный доступ к wp-admin / wp-login.php, двухфакторная аутентификация, ограниченное количество попыток входа в систему](#11)
>
>
>
> 1. [*Двухфакторная аутентификация*](#12)
> 2. [*Ограничение количества попыток входа в систему*](#13)
>
>
>
> * [Регулярно делайте резервные копии](#14)
> * [Скрывайте информацию об используемых вами версиях WordPress](#15)
> * [Блокируйте выполнение PHP-скриптов в тех WP каталогах, где это не требуется](#16)
> * [Отключите доступ к REST API вашего WordPress](#17)
> * [Ограничьте или отключите доступ к XML-RPC](#18)
> * [Убедитесь, что ваш сайт имеет SSL-сертификат](#19)
> * [Заключение](#20)
>
>
>
>
>
Включите правильные разрешения на сервере для `wp-config.php` и `.htaccess`
---------------------------------------------------------------------------
Меняем:
```
644 -rw-r–r– /home/user/wp-config.php
644 -rw-r–r– /home/user/cgi-bin/.htaccess
```
на защищённые разрешения:
```
600 -rw——- /home/user/wp-config.php
600 -rw—— /home/user/cgi-bin/.htaccess
```
Используйте актуальную и безопасную версию PHP
----------------------------------------------
По состоянию на 6 мая 2022 года самой последней и рекомендуемой версией PHP для WordPress является 8.0. Всегда можно проверить поддерживаемые и безопасные версии PHP, перейдя [по этой ссылке](https://www.php.net/supported-versions.php). Как и в случае с любым другим программным обеспечением, поддержание всего ПО в актуальном состоянии является важным фактором безопасности WP.
Отключите редактирование тем и плагинов на уровне панели администратора WordPress
---------------------------------------------------------------------------------
Если хакеры получат доступ к учётной записи администратора, то им будет очень легко внедрить вредоносный код в ваши темы и плагины WordPress. Мы будем использовать `DISALLOW_FILE_EDIT`, чтобы запретить редактирование файлов и повысить безопасность сайта.
Рассмотрим ниже, как это сделать:
1. Для начала откроем файл wp-config.php с помощью любого текстового редактора.
2. Внутри этого файла найдите строку `/* That’s all, stop editing! Happy blogging. */` (На этом всё, можете прекратить редактирование! Удачи в ведении блога) и вставьте над ней следующий код: `define( 'DISALLOW_FILE_EDIT,' true );`
3. Сохраните изменения и закройте файл.
4. Если вы все сделали правильно, то ссылки «Plugins > Editor» и «Appearance > Editor» больше не должны быть видны в панели управления.
Постоянно обновляйте свои плагины WordPress
-------------------------------------------
Также хорошей идеей будет следить за тематическими блогами и группами поклонников WP в социальных сетях. Многие пользователи WordPress делятся уведомлениями о критических ошибках в определённых плагинах WordPress. Если вы увидели ошибку, касающуюся плагина, который вы используете на своём сайте WordPress, немедленно выполните обновление. Кроме того, не забудьте удалить неиспользуемые плагины, чтобы избежать ненужных уязвимостей в вашей системе безопасности.
Устанавливайте темы и плагины WordPress только из надёжных источников
---------------------------------------------------------------------
Самый безопасный способ — использовать официальную базу данных/репозиторий.
Темы WordPress можно найти [здесь](https://wordpress.org/themes/),
а доверенные плагины — [здесь](https://wordpress.org/plugins/).
Файлы в этом хранилище были проверены и, очевидно, перед публикацией подвергались сканированию на наличие вредоносных программ.
Измените `wp_prefix` в базе данных во время установки WordPress
---------------------------------------------------------------
По умолчанию установка WordPress происходит с префиксом `wp_`, но в процессе стоит изменить его на собственный. Тем самым мы усложним вредоносным программам доступ к нашей базе данных и возможность извлечь данные.
Не используйте стандартный логин «Admin». Используйте надёжные пароли
---------------------------------------------------------------------
Обязательно смените логин на собственный. Также не забывайте, что взломать сложные пароли с использованием нескольких различных символов намного труднее.
Отключите функцию регистрации пользователей, если она вам не нужна
------------------------------------------------------------------
Для этого:
1. Перейдите на страницу Настройки (`Settings`), раздел Общие (`General`).
2. Снимите флажок в поле «Любой может зарегистрироваться» (`Anyone can register`) в разделе Членство (`Membership`).
3. Сохраните изменения.
Отключите комментарии, если они вам не нужны
--------------------------------------------
Есть несколько способов сделать это. Вы можете использовать свой код, встроенные опции WordPress или плагин.
Чтобы отключить комментарии глобально с помощью самого WordPress, выполните следующие действия:
1. Перейдите в Настройки (`Settings`), раздел Обсуждение (`Discussion`)
2. Снимите галочку в поле «Разрешить людям оставлять комментарии к новым статьям» (`Allow people to post comments on new articles`).
3. Сохраните изменения.
Как мы уже говорили ранее, вы также можете написать свой собственный код или использовать плагин для достижения того же эффекта, но в данном руководстве мы представили только самый быстрый вариант.
Настройка robots.txt для блокирования несанкционированного доступа к файлам WordPress
-------------------------------------------------------------------------------------
Данный файл, размещённый в главной папке домена, служит указателем для [краулеров Google](https://developers.google.com/search/docs/advanced/crawling/overview-google-crawlers?hl=ru) (агентов пользователей), показывающим, какие страницы они должны посещать и индексировать, а какие — нет. Вы можете использовать пример, представленный в сером поле [здесь](https://wpninja.pl/artykuly/zaawansowane-pozycjonowanie-wordpressa/#robots-txt) (не забыв изменить `http://www.example.com/` на ваш собственный домен).
Вы также можете взглянуть на [официальное руководство Google по robots.txt](https://developers.google.com/search/docs/advanced/robots/create-robots-txt.).
Защитите себя от подбора учётных записей пользователей
------------------------------------------------------
Подбор учётных записей пользователей — это форма вредоносной активности, которая позволяет хакерам использовать брутфорс атаки для получения доступа к учётным записям пользователей. Обратите внимание на [обсуждение на StackExchange](https://wordpress.stackexchange.com/questions/182236/completely-remove-the-author-url) о том, как можно снизить риск подобных атак.
Безопасный доступ к wp-admin / wp-login.php, двухфакторная аутентификация, ограниченное количество попыток входа в систему
--------------------------------------------------------------------------------------------------------------------------
Эти меры могут быть реализованы различными способами. Наиболее популярным является ограничение доступа для определённых IP-адресов или отображение дополнительного окна с информацией об аутентификации. Мы также можем установить ограничение на количество попыток входа или вообще использовать двухфакторную аутентификацию.
### Двухфакторная аутентификация
Чтобы подключить эту возможность, сначала загрузите плагин Google Authenticator.
После установки перейдите на страницу профиля и отметьте поле «Активен» (`Active`) в настройках Google Authenticator.
Теперь самое время установить приложение Google Authenticator для [Android](https://play.google.com/store/apps/details?id=com.google.android.apps.authenticator2&hl=pl&gl=US)
или [iOS](https://apps.apple.com/pl/app/google-authenticator/id388497605).
После запуска аутентификатора должен появиться запрос на ввод кода или сканирование QR-кода. Вернитесь в настройки плагина и либо скопируйте код в приложение, либо выберите «Показать/скрыть QR-код» (`Show/Hide QR code`) и отсканируйте его телефоном.
Начнётся автоматическая настройка, вам необходимо принять все изменения и затем нажать «Обновить профиль» (`Update profile`) на подстранице «Ваш профиль» (`Your profile`). С этого момента каждая попытка входа в систему будет требовать двухфакторной аутентификации на странице входа в WordPress.
### Ограничение количества попыток входа в систему
Как ранее уже упоминалось, ещё одним методом предотвращения атак брутфорсом является ограничение количества попыток входа пользователя в систему. Как это сделать?
Наверное, самое простое решение — это использовать один из многочисленных плагинов безопасности WordPress, например, WP Limit Login Attempts от Arshid. Вы можете скачать его [здесь](https://pl.wordpress.org/plugins/wp-limit-login-attempts/).
Регулярно делайте резервные копии
---------------------------------
Даже самой лучшей защиты может быть недостаточно, чтобы спасти ваш сайт от хакеров WordPress. Поэтому убедитесь, что у вас всегда есть резервная копия на случай, если худшее всё-таки произойдёт. Ещё в качестве альтернативы вы можете воспользоваться [следующим плагином безопасности](https://wordpress.org/plugins/updraftplus/).
Скрывайте информацию об используемых вами версиях WordPress
-----------------------------------------------------------
Информация о вашей версии WP может быть полезна хакерам, поэтому нет необходимости делиться ею свободно. Во-первых, заблокируйте доступ к файлу `readme`, добавив следующие строки кода в файл `.htaccess`:
```
order allow,deny
deny from all
```
Во-вторых, вы можете использовать плагин безопасности для деактивации этой информации. Одним из таких плагинов является Sucuri, который после активации будет автоматически скрывать эту информацию, но для уверенности вы можете проверить это, зайдя в «Настройки» (`Settings`) > вкладка «Усиление» (`Hardening`).
Вы также можете удалить информацию о версии, добавив следующие строки кода либо в плагин для конкретного сайта, либо в плагин Code Snippets:
```
function wpbeginner_remove_version() {
return '';
}
add_filter('the_generator', 'wpbeginner_remove_version');
```
В-третьих, вы можете удалить информацию о версии WP в CSS/JS файлах, загружаемых на сайт. [Вот ссылка на то, как это сделать](https://gist.github.com/tjhole/7451994), следуя рекомендациям пользователя tjhole.
Блокируйте выполнение PHP-скриптов в тех WP каталогах, где это не требуется
---------------------------------------------------------------------------
Запретите выполнение файлов PHP в не предназначенных для этого каталогах, чтобы повысить безопасность вашей платформы. Следуя решениям на сайте [wpbeginner](http://wpbeginner.com), откройте текстовый редактор и введите следующий код:
```
deny from all
```
Сохраните этот текстовый файл как `.htaccess` и загрузите его в папку `/wp-content/uploads/` на вашем сайте.
Отключите доступ к REST API вашего WordPress
--------------------------------------------
Если вы не планируете использовать это API, то вы можете отключить к нему доступ с помощью [следующего плагина](https://pl.wordpress.org/plugins/disable-json-api/).
Ограничьте или отключите доступ к XML-RPC
-----------------------------------------
Если вы не используете XML-RPC, вы также можете отключить его с помощью:
```
function remove_xmlrpc_pingback_ping( $methods ) { unset($methods['pingback.ping']); unset($headers['X-Pingback']); return $methods; } add_filter('xmlrpc_enabled', '__return_false'); add_filter('xmlrpc_methods', 'remove_xmlrpc_pingback_ping' );
```
или с помощью .htaccess:
```
Order deny,allow Deny from all
```
Посмотрите [эту ссылку](https://www.wpbeginner.com/plugins/how-to-disable-xml-rpc-in-wordpress/), если вам нужна дополнительная информация.
Убедитесь, что ваш сайт имеет SSL-сертификат
--------------------------------------------
Теоретически можно использовать плагин, но мы рекомендуем действовать вручную, как предложено на [этом сайте](https://thecamels.org/en/compendium-how-to-secure-your-wordpress) (прим. переводчика: статья на англ.языке). Ознакомьтесь с разделом «How to properly enable SSL in WordPress / Как правильно включить SSL в WordPress» и следуйте инструкциям.
Заключение
----------
Безопасность должна быть главным приоритетом любого предприятия, большого или малого. Мы надеемся, что эти рекомендации будут полезны в борьбе с хакерами и вредоносными программами. Обязательно следите за нашими статьями, чтобы получить другие советы и рекомендации.
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**. | https://habr.com/ru/post/664004/ | null | ru | null |
# Правильное использование Exception’ов в PHP
Я рад бы написать что *“эта статья предназначена для новичков”*, но это не так. Большинство php-разработчиков, имея опыт 3, 5 и даже 7 лет, абсолютно не понимают как правильно использовать эксепшены. Нет, они прекрасно знают о их существовании, о том что их можно создавать, обрабатывать, и т.п., но они не осознают их удобность, логичность, и не воспринимают их как абсолютно нормальный элемент разработки.
В этой статье не будет мануала по эксепшенам — это все отлично описано в документации php. Здесь я я расскажу о преимуществах использования эксепшенов, и о том, где их, собственно говоря, надо использовать. Все примеры будут для `Yii`, но это не особо важно.
Почему мы не умеем пользоваться эксепшенами:
--------------------------------------------
Я люблю `PHP`. Это прекрасный язык, как бы его не ругали. Но для начинающих разработчиков он несет определенную опасность: он слишком многое прощает.
`PHP` — это чрезмерно любящая мать. И при отсутствии строгого отца (например, `Java`) или самодисциплины, разработчик вырастет эгоистом, которому плевать на все правила, стандарты и лучшие практики. И вроде бы `E_NOTICE` пора включать, а он все на мать надеется. Которая, между прочим, стареет — ей уже `E_STRICT` c `E_DEPRICATED` нужны, а сынуля все на шее висит.
Виноват ли `PHP` — предмет дискуссий, но то, что с самого начала `PHP` не приучает нас к эксепшенам — это факт: его стандартные функции не создают эксепшены. Они либо возвращают `false`, намекая что что-то не так, или записывают куда-то код ошибки, который не всегда додумаешься проверить. Или впадают в другую крайность — `Fatal Error`.
И пока наш начинающий разработчик пытается написать свою первую быдло-cms, он ни разу не встретиться с механизмом эксепшенов. Вместо этого, он придумает несколько способов обработки ошибок. Я думаю, все понимают о чем я — эти методы, возвращающие разные типы (например, объект при успешном выполнении, а при неудаче — строка с ошибкой), или запись ошибки в какую-либо переменную/свойство, и всегда — куча проверок чтоб передать ошибку вверх по стеку вызовов.
Затем он начнет использовать сторонние библиотеки: попробует, например, `Yii`, и впервые столкнется с эксепшенами. И вот тогда…
И тогда ничего не произойдет. Ровном счетом ничего. У него уже сформировались отточенные месяцами/годами способы обработки ошибок — он продолжит использовать их. Вызванный кем-то (сторонней библиотекой) эксепшн будет восприниматься как определенный вид `Fatal Error`. Да, гораздо более детальный, да подробно логируется, да Yii покажет красивую страничку, но не более.
Затем он научиться отлавливать и обрабатывать их. И на этом его знакомство c эксепшенами закончиться. Ведь надо работать, а не учиться: знаний ему и так хватает (сарказм)!
Но самое ужасное — вырабатывается отношение к эксепшенам как к чему-то плохому, нежелательному, опасному, чего быть не должно, и чего нужно всеми способами избежать. Это абсолютно не правильный подход.
Преимущества эксепшенов
-----------------------
На самом деле использование эксепшенов — крайне лаконичное и удобное решение создания и обработки ошибок. Приведу наиболее значимые преимущества:
### Контекстная логика
Прежде всего, хотелось бы показать что эксепшн — это не всегда только ошибка (как обычно ее воспринимают разработчики). Иногда он может быть частью логики.
Например, есть у нас функция чтения `JSON` объекта из файла:
```
/**
* Читает объект из JSON файла
* @param string $file
* @throws FileNotFoundException файл не найден
* @throws JsonParseException не правильный формат json
* @return mixed
*/
public function readJsonFile($file)
{
...
}
```
Допустим мы пытаемся прочитать какие-то ранее загруженные данные. При такой операции эксепшн `FileNotFoundException` не является ошибкой и вполне допустим: возможно, мы ни разу не загружали данные, поэтому файла и нет. А вот `JsonParseException` — это уже признак ошибки, ибо данные были заргужены, обработаны, сохранены в файл, но почему-то сохранились не правильно.
Совсем другое дело, когда мы пытаемся прочитать файл, который должен быть всегда: при такой операции `FileNotFoundException` так же является сигналом ошибки.
Таким образом, эксепшены позволяют нам определять логику их обработки в зависимости от контекста, что очень удобно.
### Упрощение логики и архитектуры приложения
Попробуйте использовать эксепшены, и вы увидите как ваш код станет более лаконичным и понятным. Исчезнут все костыльные механизмы, возможно, уберутся куча вложенных if’ов, различные механизмы передачи ошибки вверх по стеку вызова, логика станет более простой и прямолинейной.
Места вызовы эксепшенов помогут вашему коллеге лучше понять бизнес логику и предметную область, ибо копаясь в вашем коде он сразу увидит что допустимо, а что нет.
И, если рассматривать какой-либо самодостаточный кусок кода, например, компонента, то список бросаемых им эксепшенов выполняет еще одну важную вещь: дополняет интерфейс этого компонента.
Пользуясь сторонними компонентами мы привыкли обращать внимание только на положительную сторону — на то, что он умеет. При этом обычно не думаем о исключениях, которые он может создать в процессе работы. Список эксепшенов сразу предупреждает где, когда, и какие проблемы могут возникнуть. А предупрежден — значит вооружен.
Вот пример информативного интерфейса, который дополнен знаниями об эксепшенах:
```
interface KladrService
{
/**
* Определяет код КЛАДР по адресу
* @param Address $address
* @return string код для адреса
* @throws AddressNotFoundException адрес не найден в базе адресов
* @throws UnresoledAddressException адрес найден, но для него не существует код КЛАДР
*/
public function resolveCode(Address $address);
/**
* Определяет адрес по коду КЛАДР
* @param string $code
* @return Address
* @throws CodeNotFoundException не найлен код КЛАДР
*/
public function resolveAddress($code);
}
```
Следует упомянуть что разрабатывая классы эксепшенов мы должны следовать принципу информативного интерфейса. Грубо говоря — учитывать их логический смысл, а не физический. Например, если адреса у нас храняться в файлах, то отсутствие файла адреса вызовет `FileNotFoundException`. Мы же должны перехватить его и вызвать более осмысленный `AddressNotFoundException`.
### Использование объектов
Использование определенного класса в качестве ошибки — очень удобное решение. Во первых, класс невозможно перепутать: взгляните на 2 способа обработки ошибки:
```
if(Yii::app()->kladr->getLastError() == ‘Не найден адрес’){
….
}
```
```
try{
...
}
catch(AddressNotFoundException $e){
...
}
```
В первом варианте элементарная опечатке сломает вам всю логику, во втором же ошибку сделать просто невозможно.
Второе преимущество — класс эксепшена инкапсулирует все необходимые данные для его обработки. Например, `AddressNotFoundException` мог бы выглядеть следующим образом:
```
/**
* Адрес не найден в базе адресов
*/
class AddressNotFoundException extends Exception
{
/**
* Не найденный адрес
* @var Address
*/
private $address;
/**
* @param Address $address
*/
public function __construct(Address $address)
{
Exception::__construct('Не найден адрес '.$address->oneLine);
$this->address = $address;
}
/**
* @return Address
*/
public function getAddress()
{
return $this->address;
}
}
```
Как видим — эксепшн содержит адрес, который не удалось найти. Обработчик может его получить и выполнить на основании его какую-то свою логику.
Третье преимущество — это, собственно, все преимущества ООП. Хотя эксепшены, как правило, простые объекты, поэтому возможности ООП мало используются, но используются.
Например, у меня в приложении порядка 70 классов эксепшенов. Из них несколько — базовых — по одному классу на модуль. Все остальные — наследуются от базового класса своего модуля. Сделано это для удобства анализа логов.
Так же я использую несколько ИНТЕРФЕЙС-МАРКЕРОВ:
* **UnloggedInterface:** По умолчанию у меня логируются все необработанные ошибки. Этим интерфейсом я помечаю эксепшены, которые не надо логировать вообще.
* **PreloggedInterface:** Этим интерфейсом я помечаю эксепшены, которые необходимо логировать в любом случае: неважно, обработаны они или нет.
* **OutableInterface:** Этот интерфейс помечает эксепшены, текст которых можно выдавать пользователю: далеко не каждый эксепшн можно вывести пользователю. Например, можно вывести эксепшн с текстом *“Страница не найдена”* — это нормально. Но нельзя выводить эксепшн с текстом *“Не удалось подключиться к Mysql используя логин root и пароль 123”*. `OutableInterface` помечает эксепшены которые выводить можно (таких у меня меньшинство). В остальных ситуация выводиться что то типа *“Сервис не доступен”*.
### Обработчик по умолчанию, логирование
Обработчик по умолчанию — чрезвычайно полезная штука. Кто не знает: он выполняется когда эксепшн не удалось обработать ни одним блоком `try catch`.
Этот обработчик позволяет нам выполнить различные действия перед остановкой скрипта. Самое главное что нужно сделать, это:
**Откат изменений:** так как операция не выполнена до конца, необходимо откатить все сделанные изменения. В противном случае мы испортим данные. Например, можно в `CController::beforeAction()` открыть транзакцию, в `CController::afterAction()` коммитить, а в случае ошибки сделать роллбэк в обработчике по умолчанию.
Это довольно грубый способ отката, плюс зачастую откат подразумевает не только откат транзакций, и знания о том, как правильно откатывать должны находиться в коде бизнес логики. В таких ситуациях следует воспользоваться вот таким приемом:
```
public function addPosition(Position $position)
{
try
{
... выполнение операции ...
}
catch(Exception $e)
{
... откат изменений ...
throw $e; // Заново бросаем тот же эксепшн
}
}
```
Получается что мы откатили изменения и бросили тот же эксепшн, что продолжить его обработку.
**Логирование:** так же обработчик по умолчанию позволяет нам выполнить какое-то кастомное логирование. Например, в моем приложении я все складываю в базу и использую собственное средство для анализа. На работе мы используем [getsentry.com/welcome](https://getsentry.com/welcome/). В любом случае, эксепшн, дошедший до обработчика по умолчанию — скорее всего непредусмотренный эксепшн, и его необходимо логировать. Следует отметить, что в класс эксепшена можно добавить различную информацию, которую необходимо логировать для большего понимания причины возникновения ошибки.
### Невозможность не заметить и перепутать
Огромным плюсом эксепшена является его однозначность: его не возможно не заметить и не возможно с чем-то спутать.
Из первого следует что мы всегда будем осведомлены о возникшей ошибке. И это замечательно — всегда лучше знать о проблеме, чем не знать.
Второй плюс становится очевиден в сравнении с кастомными методами обработки ошибки, например когда метод возвращает `null` если не нашла нужный объект и false в случае ошибки. В таком случае элементарно не заметить ошибку:
```
$result = $this->doAnything(); // null если не нашла нужный объект и false в случае ошибки
// Не заметит ошибки
if($result){ ... }
// Не заметит ошибки
if($result == null){ ... }
// Не заметит ошибки
if(empty($result)){ ... }
// Не заметит ошибки
if($result = null){ ... }
```
Эксепшн же невозможно пропустить.
### Прекращение ошибочной операции
Но самое главное, и самое важное, что делает эксепшн — это прекращает дальнейшее выполнение операции. Операции, которая уже пошла не так. И, следовательно, результат которой непредсказуем.
Огромный минус самопальных механизмов обработки ошибок — необходимость самостоятельно проверять возникновение ошибки. Например, после каждой операции нам нужно писать что то типа:
```
$this->doOperation();
if($this->getLastError() !== null)
{
echo $this->getLastError();
die;
}
```
Это требует определенной дисциплины от разработчиков. А далеко не все дисциплинированны. Далеко не все вообще знают что у вашего объекта есть метод `getLastError()`. Далеко не все понимают, почему вообще так важно проверит что все идет как надо, а если нет — откатить изменения и прекратить выполнение.
В итоге, проверки не делаются, и выполнение операции приводит к совершенно неожиданным результатам: вместо одного пользователя удаляются все, деньги пересылаются не тому человеку, голосования в госдуме выдает ложный результат — подобное я видел десятки раз.
Эксепшн защищает нас от подобных проблем: он либо ищет соответствующий обработчик ( его наличие означает что разработчик предусмотрел данную ситуацию, и все нормально), либо доходит до обработчика по умолчанию, который может откатить все изменения, залогировать ошибку, и выдать соответствующее предупреждение пользователю.
Когда следует вызывать эксепшены:
---------------------------------
С преимуществами вроде разобрались. Надеюсь, я сумел показать что эксепшены являются крайне удобным механизмом.
Встает вопрос: в каких ситуациях стоит вызывать эксепшн?
Если кратко — всегда! Если подробно: всегда, когда ты уверен что операция должна выполниться нормально, но что-то пошло не так, и ты не знаешь что с этим делать.
Посмотрим на простейший экшн добавления записи:
```
/**
* Создает пост
*/
public function actionCreate()
{
$post = \Yii::app()->request->loadModel(new Post());
if($post->save())
{
$this->outSuccess($post);
}
else
{
$this->outErrors($post);
}
}
```
Когда мы введем некорректные данные поста эксепшн не вызывается. И это вполне соответствует формуле:
* На данным шаге мы не уверенны, что операция должна пройти успешно, ибо нельзя доверять данным, введенным пользователем.
* Мы знаем что с этим делать. Мы знаем что в случае некорректных данных, мы должны отобразить пользователю список ошибок. Тут следует отметить что знание о том, “что делать” находиться в пределах текущего метода.
Поэтому в данном случае нет необходимости использовать эксепшены. Но давайте посмотрим на другой пример: Есть страница заказа, на которой есть кнопка, отменяющая заказ. Код отмены заказа выглядит следующим образом:
```
/**
* Отменяет заказа.
* Отмена производиться путем смены статуса на STATUS_CANCEL.
* @throws \Exception
*/
public function cancel()
{
// Проверим, находиться ли STATUS_CANCEL в разрешенных
if(!$this->isAllowedStatus(self::STATUS_CANCEL))
{
throw new \Exception('Cancel status not allowed');
}
// Сообственно смена статуса
$this->status = self::STATUS_CANCEL;
$isSaved = $this->save();
// Проверка на то что все успешно сохранилось и что после сохранения статус остался STATUS_CANCEL
if(!$isSaved|| $this->status !== self::STATUS_CANCEL)
{
throw new \Exception('Bad logic in order cancel');
}
}
```
Сама кнопка отмены показывается только тогда, когда заказ возможно отменить. Таким образом, когда вызывается этот метод, я уверен, что операция должна пройти успешно (в противном случае кнопка бы не отобразилась, и пользователь не смог бы нажать на нее для вызова этого метода).
Первым делом идет предвалидация — мы проверяем действительно ли мы можем выполнить операцию. В теории все должно пройти успешно, но если `isAllowedStatus` вернет `false` — значит что-то пошло не так. Плюс, в пределах текущего метода, мы абсолютно не знаем как обработать эту ситуацию. Понятно, что нужно залогировать ошибку, вывести ее пользователю, и т.п… Но в контексте именно этого метода мы не знаем что с ней делать. Поэтому бросаем эксепшн.
Далее идет выполнение операции и сохранение изменений.
Затем идет поствалидация — мы проверяем, действительно ли все сохранилось, и действительно ли статус изменился. На первый взгляд это может показаться бессмысленным, но: заказ вполне мог не сохранится (например, не прошел валидацию), а статус вполне мог быть изменен (например, кто-то набыдлокодил в `CActiveRecord::beforeSave`). Поэтому эти действия необходимы, и, опять-таки, если что-то пошло не так — бросаем эксепшн, так как в пределах данного метода мы не знаем как обрабатывать эти ошибки.
### Эксепшн vs возврат null
Следует отметить, что эксепшн следует бросать только в случае ошибки. Я видел как некоторые разработчики злоупотребляют ими, бросая их там, где не следовало бы. Особенно часто — когда метод возвращает объект: если не получается вернуть объект — бросается эксепшн.
Тут следует обратить внимание на обязанности метода. Например, `СActiveRecord::find()` не бросает эксепшн, и это логично — уровень его “знаний” не содержит информации о том, является ли ошибкой отсутствие результата. Другое дело, например, метод `KladrService::resolveAddress()` который в любом случае обязан вернуть объект адреса (иначе либо код неправильный, либо база не актуальная). В таком случае нужно бросать эксепшн, ибо отсутствие результата — это ошибка.
В целом же, описанная формула идеально определяет места, где необходимо бросать эксепшены. Но особо хотелось бы выделить 2 категории эксепшенов, которых нужно делать как можно больше:
### Технические эксепшены
Это эксепшены, которые абсолютно не связанны с предметной областью, и необходимы чтобы чисто технически предотвратить выполнение неверной логики.
Вот несколько примеров:
```
// В нескольких if
if($condition1)
{
$this->do1();
}
elseif($condition2)
{
$this->do2();
}
...
else
{
// Когда должен сработать один из блоков if, но не сработал - бросаем эксепшн
throw new BadLogicException;
}
```
```
// То же самое в swith
switch($c)
{
case 'one':
return 1;
case 'two'
return 2;
...
default:
// Когда должен сработать один из блоков case, но не сработал - бросаем эксепшн
throw new BadLogicException;
}
```
```
// При сохранении связанных моделей
if($model1->isNewRecord)
{
// Если первая модель не сохранена, у нее нет id, то строка $model2->parent_id = $model1->id
// сделает битые данные, поэтому необходимо проверять
throw new BadLogicException;
}
$model2->parent_id = $model1->id;
```
```
// Просто сохранении - очень часто разраотчики используют save и не проверяют результат
if(!$model->save())
{
throw new BadLogicException;
}
```
```
/**
* Cкоуп по id пользователя
* @param int $userId
* @return $this
*/
public function byUserId($userId)
{
if(!$userId)
{
// Если не вызывать этот эксепшн, то при пустом userId скоуп вообще не будет применен
throw new InvalidArgumentException;
}
$this->dbCriteria->compare('userId', $userId);
return $this;
}
```
Технические эксепшены помогут не допустить или отловить, имхо, большую часть багов в любом проекте. И неоспоримым плюсом их использования является отсутствие необходимости понимать предметную область: единственное что требуется — это дисциплина разработчика. Я призываю не лениться и вставлять такие проверки повсеместно.
### Эксепшены утверждений
Эксепшены утверждений (по мотивам `DDD`) вызываются когда мы обнаруживаем что нарушается какая-либо бизнес-логика. Безусловно, они тесно связанна с знаниями предметной области.
Они бросаются когда мы проверяем какое-либо утверждение, и видим что результат проверки не соответствует ожидаемому.
Например, есть метод добавления позиции в заказ:
```
/**
* Добовляет позицию в заказ
* @param Position $position
* @throws \Exception
*/
public function addPosition(Position $position)
{
$this->positions[] = $position;
... перерасчет стоимость позиций, доставки, скидок, итоговой стоимсоти ...
// проверям корректность рассчета
if($this->totalCost != $this->positionsCost + $this->deliveryCost - $this->totalDiscounts)
{
throw new \Exception('Cost recalculation error');
}
... Обновление параметров доставки ...
// проверям можем ли мы доставить заказа с новой позицеей
if(!Yii::app()->deliveryService->canDelivery($this))
{
throw new \Exception('Cant delivery with new position')
}
… прочие действия ...
}
```
В процессе добавления позиции происходит куча различных действий. И при этом периодически проверяются различные утверждения: что все суммы сходятся, что заказ может быть доставить — это и есть эксепшены утверждений.
Здесь можно подискутировать на тему необходимости подобных эксепшенов:
Например, можно написать тесты на методы перерасчета стоимости заказа, и проверка в теле метода — не более чем дублирование теста. Можно проверять возможность доставки заказа с новой позицией до добавления позиции (чтоб предупредить об этом пользователя, как минимум)
Но практика показывает, что далеко не всегда удается написать тесты для всех инвариантов объекта. И невозможно защититься от, например, нового разработчика, который может накодить все что угодно.
Поэтому в критичных местах такие эксепшены нужны однозначно.
Изменение логики для избегания эксепшна
---------------------------------------
Как я уже говорил, `PHP` разработчики боятся эксепшенов. Они боятся их появления, и боятся бросать их самостоятельно.
И в этой борьбе с эксепшенами многие допускают ошибку: отступают от изначально четкой, понятной, прямолинейной логики в сторону каких-либо допущений, чтобы хоть как-то выполнить операцию.
Вот пример: необходимо просто отобразить страницу по id (чтоб вы понимали — это реальный код из известного проекта)
```
/**
* Отображает страницу по id
* @param int $id
*/
public function actionView($id = 1)
{
$page = Page::model()->findByPk($id) ?: Page::model()->find();
$this->render('view', ['page' => $page]);
}
```
Несмотря на простейшую и понятную задачу — здесь совершенно дикая логика.
Мало того, что она может показать пользователю совершенно не то что надо, так она еще и маскирует наши баги:
* если `id` не задан — берется `id = 1`. Проблема в том, что когда id не задан — это уже баг, ибо где-то у нас не правильно формируются ссылки.
* Если страница не найдена — значит где-то у нас ссылка на несуществующую страницу. Это тоже, скорее всего, баг.
Такое поведение не приносит пользы ни пользователю, ни разработчикам. Мотивация такой реализации — показать хоть что-то, ибо `404` эксепшн — плохо.
Еще один пример:
```
/**
* Выдает код кладра города
* @param mixed $region
* @param mixed $city
* @return string
*/
public function getCityKladrCode($region, $city)
{
if($сode = ... получение кода для города... )
{
return $сode;
}
return ... получение кода для региона ...
}
```
Тоже из реального проекта, и мотивация такая-же: вернуть хоть что-то, но не вызывать эксепшн, несмотря на то, что метод явно должен возвращать код города, а не региона.
И таких изменений логики в среднестатистическом проекте огромное кол-во. Пока ты помнишь об этом — это кажется безобидным. Но как только забываешь, или подключается другой разработчик — баг обеспечен. Причем неявный баг, плавающий.
Мое мнение — это недопустимо. Просто когда ты работаешь с большими деньгами (а я с ними работал довольно долго), вырабатывается определенные правила, и одно из них — прерывать операцию в случае любого подозрения на ошибку. Транзакция на 10 млн баксов: согласитесь, ее лучше отменить, чем перечислить деньги не тому человеку.
Конечно, обычно мы имеем дело с менее рискованными операциями. И в случае бага, например, инвалид не сможет оставить заявку на установку пандуса в подъезде. И разработчик на раслабоне (его ведь даже не оштрафуют) пренебрегает этими элементарными правилами, мол, подумаешь, мелочь какая. Проблема в том, что когда ему доверят что-то критически важное — вряд ли его подход измениться. Ибо проблема не в знаниях, и не в риске, а в дисциплине и в отношении к делу. И получается, что после таких программистов у нас где-то трубы зимой лопаются, где-то нефть разливается тоннами, где-то люди умирают десятками, где-то деньги воруются миллионами. Подумаешь, мелочь какая!
Собачки
-------
Я почему-то думал что [собачками](http://php.net/manual/ru/language.operators.errorcontrol.php) уже никто не пользуется. Но недавно столкнулся с коллективом разработчиков, которые используют их повсеместно вместо проверки `isset`, поэтому решил написать и про них.
Собачки вместо `isset` используют для лаконичности кода:
```
@$policy->owner->address->locality;
```
против
```
isset($policy->owner->address) ? $policy->owner->address->locality : null;
```
Действительно, выглядит намного короче, и на первый взгляд результат такой же. Но! опасно забывать что собачка — оператор игнорирования сообщений об ошибках. И `@$policy->owner->address->locality` вернет `null` не потому-что проверит существование цепочки объектов, а потому-что просто проигнорирует возникшую ошибку. А это совершенно разные вещи.
Проблем в том, что помимо игнорирования ошибки `Trying to get property of non-object` (которое и делает поведение собачки похожим на `isset`), игнорируются все другие возможные ошибки.
`PHP` — это магический язык! При наличии всех этих магических методов (`__get, __set, __call, __callStatic, __invoke` и пр.) мы не всегда можем сразу понять что происходит на самом деле.
Например, еще раз взглянем на строку `$policy->owner->address->locality`. На первый взгляд — цепочка объектов, если присмотреться пристально — вполне может быть и так:
* `policy` — модель `CActiveRecord`
* `owner` — релейшен
* `address` — геттер, который, например, обращается к какому-либо стороннему сервису
* `locality` — аттрибут у
То есть простой строкой `$policy->owner->address->locality` мы на самом деле запускаем выполнение тысяч строк кода. И собачка перед это строкой скрывает ошибки в любой из этих строк.
Таким образом, столь необдуманное использование собачки потенциально создает огромное кол-во проблем.
Послесловие
-----------
Программирование — потрясающее занятие. На мой взгляд, оно похоже на сборку огромного конструктора LEGO. В самом начале перед тобой инструкция и россыпь мелких деталей. И вот, ты берешь инструкцию, по которой методично собираешь их в небольшие блоки, затем объеденяешь их в нечто большее, еще больше… И ты ловишь кайф от этого чертовски увлекательного процесса, ты ловишь кайф от того, насколько все логично и продуманно устроенно, насколько все эти детальки подходят друг к другу. И вот — перед тобой уже целый трактор, или самосвал. И это потрясающе!
В программировании тоже самое, только роль инструкций выполняют знания паттернов, принципов проектирования классов, лучших практик программирования и построения архитектур. И когда ты все это впитаешь и научишься применять на практике — ты начинаешь ловить кайф от работы, такой же, как при сборке LEGO.
Но попробуйте собрать конструктор без инструкции… Эта мысль похожа на бред. Тем не менее, программисты без всех этих знаний прекрасно работают. Годами. И им это не кажется бредом — они даже не понимают, что что-то делают не так. Вместо этого они жалуются что им дали слишком мало времени.
И если в послесловии [предыдущего поста](http://habrahabr.ru/post/211739/) я предлагал задуматься, надеясь что кто-то изменит свой код к лучшему, то теперь я потерял эту надежду. Видимо, люди действительно ценят только тот опыт, за который заплатили.
Так что всем, кто прочел этот пост и подумал “что за бред”, “я все это знаю, но применять лень”, или “будет сосунок мне указывать” — я желаю совершить баг. Баг, за который оштрафуют или уволят. И тогда вы, возможно, вспомните этот пост, и задумаетесь: “возможно я и в правду что-то делаю не так”?
Совершите его как можно скорее. Ибо лучше один раз ошибиться, но прозреть, чем всю жизнь прожить быдлокоддером. Аминь.
Всем добра ) | https://habr.com/ru/post/264417/ | null | ru | null |
# Задачка на std::multiset или поиск по полям структуры
Попалась небольшая задачка, где-то на 4 часа кодирования, которую счел занимательной.
Есть база пользователей 10 миллионов:
```
class User{
int id;
time_t birthday; // дата рождения
int gender; // пол
int city_id; // место проживания
time_t time_reg; // дата регистрации
};
```
Нужно сделать быстрый поиск по базе, с учетом ее не частого обновления. Поиск может проходить по полям: возрасту, полу, городу. Поля поиска могут быть указаны в группировке или отдельно, например:
* город;
* город, пол;
* пол, возраст.
Данные выдачи должны быть отсортированы по дате регистрации пользователей, и выдаваться постранично по 100 пользователей.
**Подсказка 1:** СУБД не даст нужной скорости.
**Подсказка 2:** Вспомнить сложность операций со множествами, сложность стандартных алгоритмов.
**Подсказка 3:** Проверить время поиска реализованного алгоритма, неплохой результат это порядка 0.005 сек.
Из готовых контейнеров для этой задачи можно использовать **std::vector**, отсортированный по нужному кретерию поиска, и **std::lower\_bound** с реализацией:
```
template
ForwardIterator lower\_bound (ForwardIterator first, ForwardIterator last,
const T& val, Compare comp);
```
Или использовать **std::multiset**. Выбрал std::multiset по причине того, что в него можно засунуть компаратор, который будет использоваться для вставки и поиска.
Захотелось заложить легкое расширение поиска, поэтому пошел по заветам Александреску и реализовал компаратор как стратегию.
Для экономии памяти multiset хранятся указатели на User, поэтому интерфейс критерии поиска выглядит так:
```
class AbstractCriterion
{
public:
virtual ~AbstractCriterion() = default;
virtual bool matched(const User &user) const noexcept = 0;
User patternForSearch() const noexcept
{
User user;
initPattern(user);
return user;
}
virtual int signature() const noexcept = 0;
virtual void initPattern(User &user) const noexcept = 0;
virtual bool operator()(const User *first, const User *second) const noexcept = 0;
};
```
| Метод | Описание |
| --- | --- |
| *matched* | соответствует User данному критерию или нет |
| *patternForSearch* | шаблонный метод для формирования ключа поиска |
| *operator()* | сравнение элементов |
| *signature* | используется как идентификатор критерии |
Примеры реализации двух критерий:
```
class CityCriterion: public AbstractCriterion
{
public:
CityCriterion()
: m_city(0)
{
}
CityCriterion(int city)
: m_city(city)
{
}
bool matched(const User &user) const noexcept final
{
return user.cityId == m_city;
}
void initPattern(User &user) const noexcept final
{
user.cityId = m_city;
}
virtual int signature() const noexcept final
{
return Signatures::City;
}
bool operator()(const User *first, const User *second) const noexcept final
{
return first->cityId < second->cityId;
}
private:
int m_city;
};
class GenderCriterion: public AbstractCriterion
{
public:
GenderCriterion()
: m_gender(No)
{
}
GenderCriterion(int gender)
: m_gender(gender)
{
}
bool matched(const User &user) const noexcept final
{
return user.gender == m_gender;
}
void initPattern(User &user) const noexcept final
{
user.gender = m_gender;
}
virtual int signature() const noexcept final
{
return Signatures::Gender;
}
bool operator()(const User *first, const User *second) const noexcept final
{
return first->gender < second->gender;
}
private:
int m_gender;
};
```
Необязательно ограничиваться имеющимися полями структуры. Например возраст можно вычислять:
```
class AgeCriterion: public AbstractCriterion
{
public:
static const unsigned int SECONDS_IN_YEAR = 31536000;
AgeCriterion()
: m_age(0)
{
time(&m_curTime);
}
AgeCriterion(int age)
: m_age(age)
{
time(&m_curTime);
}
bool matched(const User &user) const noexcept final
{
const unsigned int age = difftime(m_curTime, user.birthday) / SECONDS_IN_YEAR;
return m_age == age;
}
void initPattern(User &user) const noexcept final
{
user.birthday = m_curTime - (m_age + 1) * SECONDS_IN_YEAR;
}
virtual int signature() const noexcept final
{
return Signatures::Age;
}
bool operator()(const User *first, const User *second) const noexcept final
{
const int firstAge = difftime( m_curTime, first->birthday) / SECONDS_IN_YEAR;
const int secondAge = difftime( m_curTime, second->birthday) / SECONDS_IN_YEAR;
return firstAge < secondAge;
}
private:
size_t m_age;
time_t m_curTime;
};
```
Для поиска по двум полям ввел следующий шаблонный класс и функцию:
```
template
class BiCriterion: public AbstractCriterion
{
public:
BiCriterion(const FirstCriterion &first, const SecondCriterion &second)
: m\_first(first), m\_second(second)
{
}
bool matched(const User &user) const noexcept final
{
return m\_first.matched(user) && m\_second.matched(user);
}
void initPattern(User &user) const noexcept final
{
m\_first.initPattern(user);
m\_second.initPattern(user);
}
int signature() const noexcept final
{
const auto sign1 = m\_first.signature();
const auto sign2 = m\_second.signature();
return sign1 | sign2;
}
bool operator()(const User \*first,
const User \*second) const noexcept final
{
const bool less = m\_first(first, second);
if (!less && !m\_first(second, first)) {
return m\_second(first, second);
}
else {
return less;
}
}
private:
FirstCriterion m\_first;
SecondCriterion m\_second;
};
template
BiCriterion AND(const FirstCriterion &first, const SecondCriterion &second)
{
return BiCriterion(first, second);
};
```
Если захочу найти мужиков в возрасте 30 лет, то
```
auto criterion = AND(AgeCriterion(30), GenderCriterion(Male));
```
std::multiset завернул в класс UserDataBase:
```
class UserDataBase
{
using SetComparator = std::function;
using Multiset = std::multiset;
std::vector m\_users;
std::map m\_searchMap;
public:
using SearchResultIteratorPtr = std::unique\_ptr;
UserDataBase() = default;
~UserDataBase();
template
void registryCriterion(const Criterion &criterion)
{
m\_searchMap[criterion.signature()] = Multiset(criterion);
}
void append(const User &user)
{
auto item = new User(user);
m\_users.push\_back(item);
for (auto iter = m\_searchMap.begin();
iter != m\_searchMap.end();
++iter) {
iter->second.insert(item);
}
}
template
SearchResultIteratorPtr search(const Criterion &criterion) const
{
typedef SearchResultIterator ResultIterator;
const auto end = Multiset::const\_iterator();
SearchResultIteratorPtr iterator(new ResultIterator(end, end, criterion));
User pattern;
pattern = criterion.patternForSearch();
if (m\_searchMap.count(criterion.signature())) {
const auto &set = m\_searchMap.at(criterion.signature());
auto iter = set.find(&pattern);
if (iter != set.end()) {
iterator.reset(new ResultIterator(iter, set.end(), criterion));
}
}
return iterator;
}
};
```
Вроде все просто. Сперва регистрируем критерии поиска, потом добавляем элементы:
```
UserDataBase base;
base.registryCriterion(AgeCriterion());
base.registryCriterion(GenderCriterion());
base.registryCriterion(AND(AgeCriterion(), GenderCriterion()));
base.registryCriterion(AND(CityCriterion(), GenderCriterion()));
//..
for (int i = 0; i < MAX_USERS; ++i) {
User usr;
ifs >> usr;
base.append(usr);
}
```
В самом методе поиска нет ничего интересного. Только возврящается указатель на ISearchResultIterator, что бы срезать информацию о типе.
Итератор это обертка над итератором std::multiset, хранящий критерий поиска:
```
template
class SearchResultIterator: public ISearchResultIterator
{
public:
SearchResultIterator(MultisetIterator iter,
MultisetIterator end,
const Criterion &criterion)
: m\_iter(iter), m\_end(end), m\_criterion(criterion)
{
}
bool isValid() const noexcept final
{
return (m\_iter != m\_end)
&& (m\_criterion.matched(\*\*m\_iter));
}
bool next() noexcept final
{
if (isValid()) {
++m\_iter;
return m\_criterion.matched(\*\*m\_iter);
}
else {
return false;
}
}
const User &user() const noexcept final
{
if (isValid()) {
return \*\*m\_iter;
}
else {
return m\_emptyUser;
}
}
private:
MultisetIterator m\_iter;
MultisetIterator m\_end;
Criterion m\_criterion;
User m\_emptyUser;
};
```
Идем по std::multiset пока не дошли до конца и элементы сооветсвтуют критерию поиска.
Использование выглядит так:
```
auto iterator = base.search(AND(AgeCriterion(30), GenderCriterion(Male)));
if (iterator->isValid()) {
printReuslt(iterator);
}
//...
void printReuslt(std::unique_ptr &iter)
{
int cnt = 1;
std::vector users;
users.reserve(100);
do {
users.push\_back(iter->user());
if (cnt == 100) {
break;
}
++cnt;
}
while (iter->next());
std::sort(users.begin(), users.end(), timeSort);
std::cout << std::setw(8) << "USR ID"
<< std::setw(12) << std::left << " REG"
<< std::setw(5) << std::right << "GNDG"
<< std::setw(6) << "CITY"
<< std::setw(12) << "BIRTHDAY" << std::endl;
for (const auto &usr: users) {
std::cout << std::setw(8) << usr.id
<< std::setw(12) << usr.timeReg
<< std::setw(5) << usr.gender
<< std::setw(6) << usr.cityId
<< std::setw(12) << usr.birthday << std::endl;
}
}
```
В принципе при выводе можно не сортировать элементы по времени, если воспользоваться таким свойством, что одинаковые елементы в мультимножестве расположены в том порядке, в каком они добавлялись.
Вроде получилось не так много кода, который вполне можно написать за 4 часа. | https://habr.com/ru/post/312830/ | null | ru | null |
# Нулевой символ внутри тега
*Старый баг дороже новых двух?*
Сделал для себя интересное открытие, оказывается строчку
`<\0b>text` — где \0 — символ с кодом 0
IE интерпретирует как нормальный тег bold со всеми вытекающими, тоже самое касается тегов | https://habr.com/ru/post/57562/ | null | ru | null |
# Domain-driven design, Hexagonal architecture of ports and adapters, Dependency injection и Python
### Prologue
- Глянь, статью на Хабр подготовил.
- Эм... а почему заголовок на английском?
- "Предметно-ориентированное проектирование, Гексагональная архитектура портов и адаптеров, Внедрение зависимостей и Пайто..."
С пронзительным хлопком в воздухе материализуется обалдевший Сатана в обличии сине-жёлтого питона.
### Intro
Как же летит время! Два года назад я расстался с миром Django и очутился в мире Kotlin, Java и Spring Boot. Я испытал самый настоящий культурный шок. Голова гудела от объёма новых знаний. Хотелось бежать обратно в тёплую, ламповую, знакомую до байтов экосистему Питона. Особенно тяжело на первых порах давалась концепция инверсии управления (Inversion of Control, IoC) при связывании компонентов. После прямолинейного подхода Django, автоматическое внедрение зависимостей (Dependency Injection, DI) казалось чёрной магией. Но именно эта особенность фреймворка Spring Boot позволила проектировать приложения следуя заветам Чистой Архитектуры. Самым же большим вызовом стал отказ от философии "пилим фичи из трекера" в пользу Предметно-ориентированного проектирования (Domain-Driven Design, DDD).
Наш проект стремительно растёт и усложняется. Несмотря на это, его легко поддерживать, тестировать и развивать - всё благодаря качественному фундаменту и архитектуре. Код получается выразительным и легковесным. Компоненты - легко заменяемыми. Во всех отношениях это приложение качественнее всего написанного каждым членом нашей команды в прошлом.
Оглядываясь назад вспоминаю, какие пробелы в моём опыте и знаниях не позволяли писать и решать задачи бизнеса *так* элегантно. Если вы живёте в экоситеме Питона и на практике хотите познакомиться со всем перечисленным в заголовке, прошу!
Пользуясь случаем, хочу передать благодарность коллегам, которые поддерживали, учили и направляли меня все эти годы.
### Dependency Injection
Вы знаете что такое Внедрение зависимостей ака Dependency Injection (DI). Точно знаете, хотя можете и не вспомнить формального определения. Давайте на небольшом примере рассмотрим, в чём плюсы и минусы этого подхода (если вам угодно - шаблона).
Допустим нам понадобилась функция, отправляющая сообщения с пометкой "ТРЕВОГА!" в шину сообщений. После недолгих размышлений напишем:
```
from my_cool_messaging_library import get_message_bus()
def send_alert(message: str):
message_bus = get_message_bus()
message_bus.send(topic='alert', message=message)
```
В чём главная проблема функции `send_alert()`? Она зависит от объекта `message_bus`, но для вызывающего эта зависимость совершенно не очевидна! А если вы хотите отправить сообщение по другой шине? А как насчёт уровня магии, необходимой для тестирования этой функции? Что, что? `mock.patch(...)` говорите? Коллеги, атака в лоб провалилась, давайте зайдём с флангов.
```
from my_cool_messaging_library import MessageBus
def send_alert(message_bus: MessageBus, message: str):
message_bus.send(topic='alert', message=message)
```
Казалось, небольшое изменение, добавили аргумент в функцию. Но одним лишь этим изменением мы убиваем нескольких зайцев: Вызывающему очевидно, что функция `send_alert()` **зависит** от объекта `message_bus` типа `MessageBus` (да здравствуют аннотации!). А тестирование, из обезьяньих патчей с бубном, превращается в написание краткого и ясного кода. Не верите?
```
def test_send_alert_sends_message_to_alert_topic()
message_bus_mock = MessageBusMock()
send_alert(message_bus_mock, "A week of astrology at Habrahabr!")
assert message_bus_mock.sent_to_topic == 'alert'
assert message_bus_mock.sent_message == "A week of astrology at Habrahabr!"
class MessageBusMock(MessageBus):
def send(self, topic, message):
self.sent_to_topic = topic
self.sent_message = message
```
Тут искушённый читатель задастся вопросом: неужели придётся передавать экземпляр `message_bus` в функцию `send_alert()` при каждом вызове? Но ведь это неудобно! В чём смысл каждый раз писать
```
send_alert(get_message_bus(), "Stackoverflow is down")
```
Попытаемся решить эту проблему посредством ООП:
```
class AlertDispatcher:
_message_bus: MessageBus
def __init__(self, message_bus: MessageBus):
self._message_bus = message_bus
def send(message: str):
self._message_bus.send(topic='alert', message=message)
alert_dispatcher = AlertDispatcher(get_message_bus())
alert_dispatcher.send("Oh no, yet another dependency!")
```
Теперь уже класс `AlertDispatcher` **зависит** от объекта типа `MessageBus`. Мы **внедряем** эту зависимость в момент создания объекта `AlertDispatcher` посредством передачи зависимости в конструктор. Мы связали (we have wired, не путать с coupling!) объект и его зависимость.
Но теперь акцент смещается с `message_bus` на `alert_dispatcher`! Этот **компонент** может понадобиться в различных местах приложения. Мало ли откуда нужно оправить сигнал тревоги! Значит, необходим некий глобальный контекст из которого можно будет этот объект достать. И прежде чем перейти к построению такого контекста, давайте немного порассуждаем о природе компонентов и их связывании.
### Componential architecture
Говоря о внедрении зависимостей мы не сильно заостряли внимание на типах. Но вы наверняка догадались, что `MessageBus` - это всего лишь абстракция, интерфейс, или как бы сказал [PEP-544](https://www.python.org/dev/peps/pep-0544/) - протокол. Где-то в нашем приложении объявленo:
```
class MessageBus(typing.Protocol):
def send(topic: str, message: str):
pass
```
В проекте также есть простейшая реализация `MessageBus`-a, записывающая сообщения в список:
```
class MemoryMessageBus(MessageBus):
sent_messages = []
def send(topic: str, messagge: str):
self.sent_messages.append((str, message))
```
Таким же образом можно абстрагировать бизнес-логику, разделив абстрактный сценарий пользования (use case) и его имплементацию:
```
class DispatchAlertUseCase(typing.Protocol):
def dispatch_alert(message: str):
pass
```
```
class AlertDispatcherService(DispatchAlertUseCase):
_message_bus: MessageBus
def __init__(self, message_bus: MessageBus):
self._message_bus = message_bus
def dispatch_alert(message: str):
self._message_bus.send(topic='alert', message=message)
```
Давайте для наглядности добавим HTTP-контроллер, который принимает сообщения по HTTP-каналу и вызывает `DispatchAlertUseCase`:
```
class ChatOpsController:
...
def __init__(self, dispatch_alert_use_case: DispatchAlertUseCase):
self._dispatch_alert_use_case = dispatch_alert_use_case
@post('/alert)
def alert(self, message: Message):
self._dispatch_alert_use_case.dispatch_alert(message)
return HTTP_ACCEPTED
```
Наконец, всё это необходимо связать воедино:
```
from my_favourite_http_framework import http_server
def main():
message_bus = MemoryMessageBus()
alert_dispatcher_service = AlertDispatcherService(message_bus)
chat_opts_controller = ChatOpsController(alert_dispatcher_service)
http_server.start()
```
Первой же реакцией здорового программиста будет: "**ну нафига громоздить столько кода?**". Ваша правда, всё вышенаписанное умещается в одну коротенькую функцию:
```
@post('/alert)
def alert(message: Message):
bus = MemoryMessageBus()
bus.send(topic='alert', message=message)
return HTTP_ACCEPTED
```
Коротко? Ещё как! Поддерживаемо? Вообще никак. Почему? Из-за сильнейшей связанности (coupling) компонентов в коде. Уместив всё в одну функцию таким образом, мы намертво привязали логику отправки оповещений к конкретной реализации шины сообщений. Но это ещё полбеды. Самое ужасное то, что **бизнес-составляющая полностью растворилась в технических деталях**. Не поймите меня неправильно, подобный код вполне имеет право на существование. Но простит ли растущее приложение такой сжатый подход?
Вернёмся к нашей компонентной архитектуре. В чём её преимущества?
* Компоненты **изолированы** и независимы друг от друга напрямую. Вместо этого они **связаны посредством абстракций**.
* Каждый компонент работает в чётких рамках и **решает лишь одну задачу**.
* Это значит, что компоненты могут быть протестированы как в полной изоляции, так и в любой произвольной комбинации включающей тестовых двойников (test double). Думаю не стоит объяснять, насколько проще тестировать изолированные части программы. Подход к TDD меняется с невнятного "нуууу, у нас есть тесты" на бодрое "тесты утром, вечером код".
* С учётом того, что зависимости описываются абстракциями, можно безболезненно заменить один компонент другим. В нашем примере - вместо `MemoryMessageBus` можно бухнуть `DbMessageBus`, да хоть в файл на диске писать - тому кто вызывает `message_bus.send(...)` нет до этого никакого дела.
"Да это же SOLID!" - скажите вы. И будете абсолютно правы. Не удивлюсь, если у вас возникло чувство дежавю, ведь благородный дон [@zueve](/users/zueve) год назад детально описал связь SOLID и Чистой архитектуры в статье ["Clean Architecture глазами Python-разработчика"](https://habr.com/ru/company/exness/blog/494370/). И наша компонентная архитектура находится лишь в шаге от чистой "гексагональной" архитектуры. Кстати, причём тут гексагон?
### Architecture is about intent
Одно из замечательных высказываний дядюшки Боба на тему архитектуры приложений - *Architecture is about intent* (Намерения - в архитектуре).
Что вы видите на этом скриншоте?
Не удивлюсь, если многие ответили "Типичное приложение на Django". Отлично! А что же делает это приложение? Вы вероятно телепат 80го уровня, если смогли ответить на этот вопрос правильно. Лично я не именю ни малейшего понятия - это скриншот первого попавшегося Django-приложения с Гитхаба.
Роберт Мартин развивает идею [дальше](https://www.youtube.com/watch?v=WpkDN78P884). Взгляните на архитектурный план этажа и догадайтесь, для чего предназначено это здание?
Разгадка Это один из этажей библиотеки Oodi в Хельсинки.
Надеюсь вам было несложно отгадать эту маленькую загадку и вы вынесли из неё главное: архитектура должна встречать нас с порога, буквально с момента окончания `git clone...`. Как здорово, когда код приложения организован таким образом, что предназначение того или иного файла или директории лежит на поверхности!
В "Гексагональной архитектуре", гексагон в частности призван упростить восприятие архитектуры. Мудрено? Пардон, сейчас всё будет продемонстрировано наглядно.
### Hexagonal architecture of Ports and Adapters
"У нас Гексагональная архитектура портов и адаптеров" - с этой фразы начинается рассказ об архитектуре приложения новым членам команды. Далее мы показываем нечто Ктулхуподобное:
Изобретатель термина "Гексагональная архитектура" Алистар Кокбёрн (Alistair Cockburn) объясняя выбор названия акцентировал внимание на его графическом представлении:
> В гексагоне количество граней не играет роли. Важна сама возможность пририсовать порты и адаптеры по необходимости, выходя за рамки изображения послойных однонаправленных графов. Термин "гексагональная архитектура" вытекает из визуальной составляющей. ([источник](https://alistair.cockburn.us/hexagonal-architecture/))
>
>
Итак, на изображении мы видим:
**Домен** (предметная область) - это сердце приложения. Классы, методы, функции, константы и другие объекты домена повторяют язык предметной области. Например, правило Хабра
> "Пользователь может голосовать за публикации, комментарии и карму других пользователей если его карма ≥ 5"
>
>
будет отображено именно здесь. И как вы наверняка поняли, в домене нет места HTTP, SQL, RabbitMQ, AWS и т.д. и т.п.
Зато всему этому празднику технологий есть место в **адаптерах** подсоединяемых к **портам**. Команды и запросы поступают в приложение через **ведущие** (driver) или API порты. Команды и запросы которые отдаёт приложение поступают в **ведомые** порты (driven port). Их также называют портами интерфейса поставщика услуг (Service Provider Interface, SPI).
Между портами и доменом сидят дирижёры - **сервисы приложения** (Application services). Они являются *связующим звеном* между сценариями пользования, доменом и ведомыми портами необходимыми для выполнения сценария. Также стоит упомянуть, что именно сервис приложения определяет, будет ли сценарий выполняться в рамках общей транзакции, или нет.
Всё это - и порты, и адаптеры и сервисы приложения и даже домен - **слои** архитектуры, состоящие из индивидуальных **компонентов**. Главной заповедью взаимодействия между слоями является "Зависимости всегда направлены от внешних слоёв к центру приложения". Например, адаптер может ссылаться на домен или другой адаптер, а домен ссылаться на адаптер - не может.
И... ВСЁ. Это - вся суть Гексагональной архитектуры портов и адаптеров. Она замечательно подходит для задач с обширной предметной областью. Для голого CRUDа а-ля HTTP интерфейс для базы данных, такая архитектура избыточна - Active Record вам в руки.
Давайте же засучим рукава и разберём на примере, как спроектировать Django-приложение по канонам гексагональной архитектуры.
### Interlude
Дорогой читатель! Спасибо, что дошли до этого места, надеюсь сей опус не утомляет вас, а наоборот захватывает и открывает новые горизонты.
Во второй части вас ждёт реализация гексагональной архитектуры на знакомом нам всем примере. В первой части мы старались абстрагироваться от конкретных решений, будь то фреймворки или библиотеки. Последующий пример построен на основе Django и DRF с целью продемонстрировать, как можно вплести гексагональную архитектуру в фреймворк с устоявшимися традициями и архитектурными решениями. В приведённых примерах вырезаны некоторые необязательные участки и имеются допущения. Это сделано для того, чтобы мы могли сфокусироваться на важном и не отвлекались на второстепенные детали. Полностью исходный код примера доступен в репозитории <https://github.com/basicWolf/hexagonal-architecture-django>.
Upvote a post at Hubruhubr
--------------------------
Представим, что мы разрабатываем новую платформу коллективных технических блогов "Хубрухубр" и нам нужно реализовать сценарий пользования "Проголосовать за публикацию". Вместе с командой экспертов мы разобрали некоторые нюансы этого сценария:
Рейтинг публикации меняется путём голосования пользователей.
1. Пользователь может проголосовать "ЗА" или "ПРОТИВ" публикации.
2. Пользователь может голосовать если его карма ≥ 5.
3. Проголосовать за данную публикацию можно лишь один раз, изменить голос нельзя.
С чего же начать работу? Конечно же с построения модели предметной области!
### Domain model
Давайте ещё раз внимательно прочтём требования и подумаем, как описать "пользователя голосующего за публикацию"? Например ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/main/src/myapp/application/domain/model/voting_user.py)):
```
# src/myapp/application/domain/model/voting_user.py
class VotingUser:
id: UUID
voting_for_article_id: UUID
voted: bool
karma: int
def cast_vote(self, vote: Vote) -> CastArticleVoteResult:
...
```
На первый взгляд - сомнительного вида творение. Но обратившись к деталям сценария мы убедимся, что этот набор данных - необходим и достаточен для голосования. `Vote` и `CastArticleVoteResult` - это также модели домена ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/src/myapp/application/domain/model/vote.py)):
```
# src/myapp/application/domain/model/vote.py
# Обозначает голос "За" или "Против"
class Vote(Enum):
UP = 'up'
DOWN = 'down'
```
В свою очередь `CastArticleVoteResult` - это тип объединяющий оговорённые исходы сценария: `ГолосПользователя`, `НедостаточноКармы`, `ПользовательУжеПроголосовалЗаПубликацию` ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/568e0ab7fa3c5ec879444572a41ad5a3395bbbf8/src/myapp/application/domain/model/cast_article_vote_result.py#L19)):
```
# src/myapp/application/domain/model/cast_article_vote_result.py
...
CastArticleVoteResult = Union[ArticleVote, InsufficientKarma, VoteAlreadyCast]
```
Как вы думаете, каких данных достаточно для описания результата успешно выполненного сценария?
Ответ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/src/myapp/application/domain/model/article_vote.py))
```
# src/myapp/application/domain/model/article_vote.py
@dataclass
class ArticleVote:
user_id: UUID
article_id: UUID
vote: Vote
id: UUID = field(default_factory=uuid4)
```
Но самое интересное будет происходить в теле метода `cast_article_vote()`. И начнём мы конечно же с тестов. Первый же тест нацелен на проверку успешно выполненного сценария ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/tests/test_myapp/application/domain/model/test_voting_user.py#L16)):
```
def test_cast_vote_returns_article_vote(user_id: UUID, article_id: UUID):
voting_user = VotingUser(
user_id=user_id,
voting_for_article_id=article_id,
karma=10
)
result = voting_user.cast_vote(Vote.UP)
assert isinstance(result, ArticleVote)
assert result.vote == Vote.UP
assert result.article_id == article_id
assert result.user_id == user_id
```
Запускаем тест и... ожидаемый фейл. В лучших традициях ТДД мы начнём игру в пинг-понг с тестами и кодом, с каждым тестом дописывая сценарий до полной готовности ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/src/myapp/application/domain/model/voting_user.py)):
```
MINIMUM_KARMA_REQUIRED_FOR_VOTING = 5
...
def cast_vote(self, vote: Vote) -> CastArticleVoteResult1:
if self.voted:
return VoteAlreadyCast(
user_id=self.id,
article_id=self.voting_for_article_id
)
if self.karma < MINIMUM_KARMA_REQUIRED_FOR_VOTING:
return InsufficientKarma(user_id=self.id)
self.voted = True
return ArticleVote(
user_id=self.id,
article_id=self.voting_for_article_id,
vote=vote
)
```
На этом мы закончим моделирование предметной области и приступим к написанию API приложения.
### Driver port: Cast article vote use case
Как было сказано ранее, в гексагональной архитектуре, приложение управляется через API-порты.
Чтобы как-то дотянуться до доменной модели, в наше приложение нужно добавить ведущий порт `CastArticleVotingtUseCase`, который принимает ID пользователя, ID публикации, значение голоса: за или против и возвращает результат выполненного сценария ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/src/myapp/application/ports/api/cast_article_vote/cast_aticle_vote_use_case.py)):
```
# src/myapp/application/ports/api/cast_article_vote/cast_aticle_vote_use_case.py
class CastArticleVoteUseCase(Protocol):
def cast_article_vote(self, command: CastArticleVoteCommand) -> CastArticleVoteResult:
raise NotImplementedError()
```
Все входные параметры сценария обёрнуты в единую структуру-команду `CastArticleVoteCommand` ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/src/myapp/application/ports/api/cast_article_vote/cast_article_vote_command.py)), а все возможные результаты объединены - это уже знакомая модель домена `CastArticleVoteResult` ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/src/myapp/application/domain/model/cast_article_vote_result.py)):
```
# src/myapp/application/ports/api/cast_article_vote/cast_article_vote_command.py
@dataclass
class CastArticleVoteCommand:
user_id: UUID
article_id: UUID
vote: Vote
```
Работа с гексагональной архитектурой чем-то напоминает прищурившегося Леонардо ди Каприо с фразой "We need to go deeper". Набросав каркас сценария пользования, можно примкнуть к нему с двух сторон. Можно имплементировать сервис, который свяжет доменную модель и ведомые порты для выполнения сценария. Или заняться API адаптерами, которые вызывают этот сценарий. Давайте зайдём со стороны API и напишем HTTP адаптер с помощью Django Rest Framework.
#### HTTP API Adapter
Наш HTTP адаптер, или на языке Django и DRF - `View`, до безобразия прост. За исключением преобразований запроса и ответа, он умещается в несколько строк ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/src/myapp/application/adapter/api/http/article_vote_view.py)):
```
# src/myapp/application/adapter/api/http/article_vote_view.py
class ArticleVoteView(APIView):
...
def __init__(self, cast_article_vote_use_case: CastArticleVoteUseCase):
self.cast_article_vote_use_case = cast_article_vote_use_case
super().__init__()
def post(self, request: Request) -> Response:
cast_article_vote_command = self._read_command(request)
result = self.cast_article_vote_use_case.cast_article_vote(
cast_article_vote_command
)
return self._build_response(result)
...
```
И как вы поняли, смысл всего этого сводится к
1. Принять HTTP запрос, десериализировать и валидировать входные данные.
2. **Запустить сценарий пользования**.
3. Сериализовать и возвратить результат выполненного сценария.
Этот адаптер конечно же строился по кирпичику с применением практик TDD и использованием инструментов Django и DRF для тестирования view-шек. Ведь для теста достаточно построить запрос (request), скормить его адаптеру и проверить ответ (response). При этом мы полностью контролируем основную зависимость `cast_article_vote_use_case: CastArticleVoteUseCase` и можем внедрить на её место тестового двойника.
Например, давайте напишем тест для сценария, в котором пользователь пытается проголосовать повторно. Ожидаемо, что статус в ответе будет `409 CONFLICT` ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/tests/test_myapp/application/adapter/api/http/test_article_vote_view.py)):
```
# tests/test_myapp/application/adapter/api/http/test_article_vote_view.py
def test_post_article_vote_with_same_user_and_article_id_twice_returns_conflict(
arf: APIRequestFactory,
user_id: UUID,
article_id: UUID
):
# В роли объекта реализующего сценарий выступает
# специализированный двойник, возвращающий при вызове
# .cast_article_vote() контролируемый результат.
# Можно и MagicMock, но нужно ли?
cast_article_use_case_mock = CastArticleVoteUseCaseMock(
returned_result=VoteAlreadyCast(
user_id=user_id,
article_id=article_id
)
)
article_vote_view = ArticleVoteView.as_view(
cast_article_vote_use_case=cast_article_use_case_mock
)
response: Response = article_vote_view(
arf.post(
f'/article_vote',
{
'user_id': user_id,
'article_id': article_id,
'vote': Vote.UP.value
},
format='json'
)
)
assert response.status_code == HTTPStatus.CONFLICT
assert response.data == {
'status': 409,
'detail': f"User \"{user_id}\" has already cast a vote for article \"{article_id}\"",
'title': "Cannot cast a vote"
}
```
Адаптер получает на вход валидные данные, собирает из них команду и вызывает сценарий. Oднако, вместо продакшн-кода, этот вызов получает двойник, который тут же возвращает `VoteAlreadyCast`. Адаптеру же нужно правильно обработать этот результат и сформировать `HTTP Response`. Остаётся протестировать, соответствует ли сформированный ответ и его статус ожидаемым значениям.
Ещё раз попрошу заметить, насколько *облегчённее* становится тестирование, когда не нужно загружать всё приложение целиком. Адепты Django вспомнят о легковесном тестировании вьюшек посредством `RequestFactory`. Но гексагональная архитектура позволяет шагнуть дальше. Мы избавились от обезьяньих патчей и mock-обёрток конкретных классов. Мы легко управляем поведением зависимостей нашего `View`, ведь взаимодействие с ними происходит через абстрактный интерфейс. Всё это легко модифицировать и отлаживать.
После написания тестов и имплементации для остальных случаев входных и выходных данных, мы получаем отточенный API компонент. Следующим шагом нужно пристыковать этот компонент к рабочей версии сценария.
### Application services
Как дирижёр управляет оркестром исполняющим произведение, так и сервис приложения управляет доменом и ведомыми портами при выполнении сценария.
#### PostRatingService
С места в карьер погрузимся в имплементацию нашего сценария. В первом приближении сервис реализующий сценарий выглядит так ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/src/myapp/application/service/post_rating_service.py)):
```
# src/myapp/application/service/post_rating_service.py
class PostRatingService(
CastArticleVoteUseCase # имплементируем протокол явным образом
):
def cast_article_vote(self, command: CastArticleVoteCommand) -> CastArticleVoteResult:
...
```
Отлично, но откуда возьмётся голосующий пользователь? Тут и появляется первая SPI-зависимость `GetVotingUserPort` задача которой найти голосующего пользователя по его ID. Но как мы помним, доменная модель не занимается записью голоса в какое-либо долговременное хранилище вроде БД. Для этого понадобится ещё одна SPI-зависимость `SaveArticleVotePort`:
```
# src/myapp/application/service/post_rating_service.py
class PostRatingService(
CastArticleVoteUseCase
):
_get_voting_user_port: GetVotingUserPort
_save_article_vote_port: SaveArticleVotePort
# def __init__(...) # внедрение зависимостей oпустим, чтобы не раздувать листинг
def cast_article_vote(self, command: CastArticleVoteCommand) -> CastArticleVoteResult:
voting_user = self._get_voting_user_port.get_voting_user(
user_id=command.user_id,
article_id=command.article_id
)
cast_vote_result = voting_user.cast_vote(command.vote)
if isinstance(cast_vote_result, ArticleVote):
self._save_article_vote_port.save_article_vote(cast_vote_result)
return cast_vote_result
```
Вы наверняка представили как выглядят интерфейсы этих SPI-зависимостей. Приведём один из интерфейсов здесь ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/src/myapp/application/ports/spi/save_article_vote_port.py)):
```
# src/myapp/application/ports/spi/save_article_vote_port.py
class SaveArticleVotePort(Protocol):
def save_article_vote(self, article_vote: ArticleVote) -> ArticleVote:
raise NotImplementedError()
```
За кадром мы конечно же сначала напишем тесты, а уже потом код :) При написании юнит-тестов роль SPI-адаптеров в тестах сервиса, как и в предыдущих примерах, играют дублёры. Но чтобы удержать сей опус в рамках статьи, позвольте оставить тесты в виде ссылки на исходник ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/tests/test_myapp/application/service/test_post_rating_service.py)) и двинуться дальше.
### SPI Ports and Adapters
Продолжим рассматривать SPI-порты и адаптеры на примере `SaveArticleVotePort`. К этому моменту можно было и забыть, что мы всё ещё находимся в рамках Django. Ведь до сих пор не было написано того, с чего обычно начинается любое Django-приложение - модель данных! Начнём с адаптера, который можно подключить в вышеуказанный порт ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/src/myapp/application/adapter/spi/persistence/repository/article_vote_repository.py)):
```
# src/myapp/application/adapter/spi/persistence/repository/article_vote_repository.py
from myapp.application.adapter.spi.persistence.entity.article_vote_entity import (
ArticleVoteEntity
)
from myapp.application.domain.model.article_vote import ArticleVote
from myapp.application.ports.spi.save_article_vote_port import SaveArticleVotePort
class ArticleVoteRepository(
SaveArticleVotePort,
):
def save_article_vote(self, article_vote: ArticleVote) -> ArticleVote:
article_vote_entity = ArticleVoteEntity.from_domain_model(article_vote)
article_vote_entity.save()
return article_vote_entity.to_domain_model()
```
Вспомним, что паттерн "Репозиторий" подразумевает скрытие деталей и тонкостей работы с источником данных. "Но позвольте! - скажете Вы, - a где здесь Django?". Чтобы избежать путаницы со словом "Model", модель данных носит гордое название `ArticleVoteEntity`. `Entity` также подразумевает, что у неё имеется уникальный идентификатор ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/src/myapp/application/adapter/spi/persistence/entity/article_vote_entity.py)):
```
# src/myapp/application/adapter/spi/persistence/entity/article_vote_entity.py
class ArticleVoteEntity(models.Model):
... # здесь объявлены константы VOTE_UP, VOTE_DOWN и VOTE_CHOICES
id = models.UUIDField(primary_key=True, default=uuid4, editable=False)
user_id = models.UUIDField()
article_id = models.UUIDField()
vote = models.IntegerField(choices=VOTES_CHOICES)
...
def from_domain_model(cls, article_vote: ArticleVote) -> ArticleVoteEntity:
...
def to_domain_model(self) -> ArticleVote:
...
```
Таким образом, всё что происходит в `save_article_vote()` - это создание Django-модели из доменной модели, сохранение её в БД, обратная конвертация и возврат доменной модели. Это поведение легко протестировать. Например, юнит тест удачного исхода выглядит так ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/tests/test_myapp/application/adapter/spi/persistence/repository/test_article_vote_repository.py)):
```
# tests/test_myapp/application/adapter/spi/persistence/repository/test_article_vote_repository.py
@pytest.mark.django_db
def test_save_article_vote_persists_to_database(
article_vote_id: UUID,
user_id: UUID,
article_id: UUID
):
article_vote_repository = ArticleVoteRepository()
article_vote_repository.save_article_vote(
ArticleVote(
id=article_vote_id,
user_id=user_id,
article_id=article_id,
vote=Vote.UP
)
)
assert ArticleVoteEntity.objects.filter(
id=article_vote_id,
user_id=user_id,
article_id=article_id,
vote=ArticleVoteEntity.VOTE_UP
).exists()
```
Одним из требований Django является декларация моделей в `models.py`. Это решается простым импортированием:
```
# src/myapp/models.py
from myapp.application.adapter.spi.persistence.entity.article_vote_entity import ArticleVoteEntity
from myapp.application.adapter.spi.persistence.entity.voting_user_entity import VotingUserEntity
```
### Exceptions
Приложение почти готово!. Но вам не кажется, что мы кое-что упустили? Подсказка: Что произойдёт при голосовании, если ID пользователя или публикации будет указан неверно? Где-то в недрах Django вылетит исключение `VotingUserEntity.DoesNotExist`, что на поверхности выльется в неприятный `HTTP 500 - Internal Server Error`, хотя правильнее было бы вернуть `HTTP 400 - Bad Request` с телом, содержащим причину ошибки.
Ответ на вопрос, "В какой момент должно быть обработано это исключение?", вовсе не очевиден. С архитектурной точки зрения, ни API, ни домен не волнуют проблемы SPI-адаптеров. Максимум, что может сделать API с таким исключением - обработать его в общем порядке, а-ля `except Exception:`. С другой стороны SPI-порт может предоставить исключение-обёртку, в которую SPI-адаптер завернёт внутреннюю ошибку. А API может её поймать.
О, я слышу вас, дорогие адепты функционального программирования! "Какие исключения? В топку! Даёшь `Either`!". В ваших словах много правды и эта тема заслуживает отдельной статьи. В одном я же, я полностью соглашусь с вами - **в домене не должно быть исключений!**.
Например, в данной ситуации уместным будет исключение `VotingUserNotFound` ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/src/myapp/application/adapter/spi/persistence/exceptions/voting_user_not_found.py)) в которое оборачивается `VotingUserEntity.DoesNotExist` ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/src/myapp/application/adapter/spi/persistence/repository/voting_user_repository.py#L26)):
```
# src/myapp/application/adapter/spi/persistence/exceptions/voting_user_not_found.py
class VotingUserNotFound(Exception):
def __init__(self, user_id: UUID):
super().__init__(user_id, f"User '{user_id}' not found")
# ---
# myapp/application/adapter/spi/persistence/repository/voting_user_repository.py
class VotingUserRepository(GetVotingUserPort):
...
def get_voting_user(self, user_id: UUID, article_id: UUID) -> VotingUser:
try:
# Код немного упрощён, в оригинале здесь происходит
# аннотация флагом "голосовал ли пользователь за статью".
# см. исходник
entity = VotingUserEntity.objects.get(id=user_id)
except VotingUserEntity.DoesNotExist as e:
raise VotingUserNotFound(user_id) from e
return self._to_domain_model(entity)
```
А вот теперь действительно, приложение почти готово! Осталось соединить все компоненты и точки входа.
### Dependencies and application entry point
Традиционно точки входа и маршрутизация HTTP-запросов в Django-приложениях декларируется в `urls.py`. Всё что нам нужно сделать - это добавить запись в `urlpatterns` ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/src/myapp/urls.py)):
```
urlpatterns = [
path('article_vote', ArticleVoteView(...).as_view())
]
```
Но погодите! Ведь `ArticleVoteView` требует зависимость имплементирующую `CastArticleVoteUseCase`. Это конечно же `PostRatingService`... которому в свою очередь требуются `GetVotingUserPort` и `SaveArticleVotePort`. Всю эту цепочку зависимостей удобно хранить и управлять из одного места - контейнера зависимостей ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/src/myapp/dependencies_container.py)):
```
# src/myapp/dependencies_container.py
...
def build_production_dependencies_container() -> Dict[str, Any]:
save_article_vote_adapter = ArticleVoteRepository()
get_vote_casting_user_adapter = VotingUserRepository()
cast_article_vote_use_case = PostRatingService(
get_vote_casting_user_adapter,
save_article_vote_adapter
)
article_vote_django_view = ArticleVoteView.as_view(
cast_article_vote_use_case=cast_article_vote_use_case
)
return {
'article_vote_django_view': article_vote_django_view
}
```
Этот контейнер инициализируется на старте приложения в `AppConfig.ready()` ([source](https://github.com/BasicWolf/hexagonal-architecture-django/blob/habr/src/myapp/apps.py)):
```
# myapp/apps.py
class MyAppConfig(AppConfig):
name = 'myapp'
container: Dict[str, Any]
def ready(self) -> None:
from myapp.dependencies_container import build_production_dependencies_container
self.container = build_production_dependencies_container()
```
И наконец `urls.py`:
```
app_config = django_apps.get_containing_app_config('myapp')
article_vote_django_view = app_config.container['article_vote_django_view']
urlpatterns = [
path('article_vote', article_vote_django_view)
]
```
### Inversion of Control Containers
Для реализации одного небольшого сценария нам понадобилось создать и связать четыре компонента. С каждым новым сценарием, число компонентов будет расти и количество связей будет увеличиваться в арифметической прогрессии. Как управлять этим зоопарком, когда приложение начнёт разрастаться до неприличных размеров? Тут на помощь приходят Контейнеры Инверсии Управления.
IoC-container - это фреймворк управляющий объектами и их зависимостями во время исполнения программы.
Spring был первым *универсальным* IoC-контейнером / фреймворком с которым я столкнулся на практике (для зануд: Micronaut - да!). Чего уж таить, я не сразу проникся заложенными в него идеями. По-настоящему оценить всю мощь автоматического связывания (autowiring) и сопутствующего функционала я смог лишь выстраивая приложение следуя практикам гексагональной архитектуры.
Представьте, насколько удобнее будет использование условного декоратора `@Component`, который при загрузке программы внесёт класс в реестр зависимостей и выстроит дерево зависимостей автоматически?
T.e. если зарегистрировать компоненты:
```
@Component
class ArticleVoteRepository(
SaveArticleVotePort,
):
...
@Component
class VotingUserRepository(GetVotingUserPort):
...
```
То IoC-container сможет инициализировать и внедрить их через конструктор в другой компонент:
```
```
@Component
class PostRatingService(
CastArticleVoteUseCase
):
def __init__(
self,
get_voting_user_port: GetVotingUserPort,
save_article_vote_port: SaveArticleVotePort
):
...
```
К сожалению мне не приходилось иметь дела с подобным инструментарием в экосистеме Питона. Буду благодарен, если вы поделитесь опытом в комментариях!
### Directory structure
Помните [скриншот](#django-app-screenshot) "типичного Django-приложения"? Сравните его с тем что получилось у нас:
Чувствуете разницу? Нам больше не нужно лезть в файлы в надежде разобраться, что же там лежит и для чего они предназначены. Более того, теперь даже структура тестов и кода приложения идентичны! Архитектура приложения видна невооружённым глазом и существует "на бумаге", а не только в голове у разработчиков приложения.
### Interlude
Давайте дружно выдохнем! Даю честное слово, больше ни одной строчки кода! Новый сценарий пользования готов к испытаниям. И пока коллеги вносят последние штрихи (миграция БД, отписки в трекере задач и т.п.) предлагаю поразмышлять вслух о том, почему гексагональная архитектура и предметно-ориентированное проектирование отлично подходят друг-другу.
### Domain-Driven Design
Эрик Эванс (Eric Evans) популяризировал термин "Domain-Driven Design" в "[большой синей книге](https://www.amazon.com/exec/obidos/ASIN/0321125215/domainlanguag-20)" написанной в 2003м году. И всё заверте... Предметно-ориентированное проектирование - это методология разработки сложных систем, в которой во главу угла ставится понимание разработчиками предметной области путем общение с представителями (экспертами) предметной области и её моделирование в коде.
Мартин Фаулер (Martin Folwer) в своей [статье](https://martinfowler.com/bliki/DomainDrivenDesign.html) рассуждая о заслугах Эванса подчёркивает, что в этой книге Эванс закрепил терминологию DDD, которой мы пользуемся и по сей день.
В частности, Эванс ввёл понятие об **Универсальном Языке** (Ubiquitous Language) - языке который разработчики с одной стороны и эксперты предметной области с другой, вырабатывают в процессе общения **в течении всей жизни продукта**. Невероятно сложно создать систему (а ведь смысл DDD - помочь нам проектировать именно сложные системы!) не понимая, для чего она предназначена и как ею пользуются.
> У него и команды программистов, которой он руководил, на это ушло более года. Работать было особенно тяжело, потому что заказчик ни за что не хотел сообщить, для каких целей создаются подсистемы. В техническом задании он находил только параметры требуемой системы, но никаких сведений о ее использовании. Недри работал чуть ли не вслепую. И вот теперь, когда система пришла в действие, он не удивился, что в ней оказались скрытые дефекты.
>
> - Майкл Крайтон, "Парк Юрского периода"
>
>
Более того, универсальный язык, со всеми оговорёнными терминами, сущностями, действиями, связями и т.д. используется при написании программы - в названиях модулей, функций, методов, классов, констант и даже переменных!
Другой важный термин - **Ограниченный Контекст** (Bounded Context) - автономные части предметной области с устоявшимися правилами, терминами и определениями. Простой пример: в онлайн магазине, модель "товар" несёт в себе совершенно разный смысл для отделов маркетинга, бухгалтерии, склада и логистики. Для связи моделей товара в этих контекстах достаточно наличие одинакового идентификатора (например UUID).
Понятие об **Агрегатах** (Aggregate) - наборе объектов предметной области, с которыми можно обращаться как единым целым, классификации **объектов-значений** и **объектов-сущностей**.
О DDD можно рассуждать и рассуждать. Эту тему не то что в одну статью, её и в толстенную книгу-то нелегко уместить. Приведу лишь несколько цитат, которые помогут перекинуть мостик между DDD и гексагональной архитектурой:
> Предметная область - это сфера знаний или деятельности.
>
> Модель - это система абстракций, представляющих определённый аспект предметной области.
>
> Модель извлекает знания и предположения о предметной области и не является способом отобразить реальность.
>
> Преимущество есть лишь у той модели, которая подходит для решения данной проблемы.
>
>
Эти цитаты взяты из [выступления Эрика Эванса на конференции DDD Europe 2019 года](https://www.youtube.com/watch?v=pMuiVlnGqjk). Приглашаю вас насладиться этим выступлением, прежде чем вы введёте "DDD" в поиск Хабра и начнёте увлекательное падение в бездонную кроличью нору. По пути вас ждёт много открытий и куча набитых шишек. Помню один восхитительный момент: внезапно в голове сложилась мозаика и пришло озарение, что фундаментальные идеи DDD и Agile Manifesto имеют общие корни.
### Hexagonal Architecture
Так причём же здесь Гексагональная архитектура? Я очень надеюсь, что внимательный читатель уже ответил на этот вопрос.
На заре Гексагональной архитектуры в 2005м году, Алистар Кокбёрн [писал](https://alistair.cockburn.us/hexagonal-architecture/):
> Создавайте приложения таким образом, чтобы они могли работать без графического интерфейса или базы данных. Тогда вы сможете запускать автоматические регрессионные тесты, работать даже если база данных не доступна и связывать приложения между собой без какого-либо стороннего участия пользователя.
>
>
Гексагональная архитектура позволяет элегантно изолировать части приложения и связать их посредством абстракций.
Становится просто связать модель предметной области в коде и "на бумаге" используя универсальный язык общения с экспертами. Универсальный язык обогащается с обеих сторон. При написании кода находятся и изменяются объекты, связи между ними и всё это перетекает обратно в модель предметной области.
Взаимодействие с внешним миром также упрощается, ведь оно происходит в рамках изолированных и взаимозаменяемых компонентов.
Тесты. Тэст-Дривэн Дэвэлопмэнт. В самом соке, когда тест пишется, к пока не существующему функционалу и мы даём возможность нашей IDE (или по-старинке) создать класс/метод/функцию/концепцию которая пока существует лишь в тесте. Интеграционные тесты, для которых необязательно загружать всю программу и инфраструктуру, а лишь адаптеры и необходимые для теста сервисы.
В итоге - приложение, код которого построен на языке бизнеса и предметной области. Приложение, архитектура которого позволяет сократить время обратной связи с разработчиками, экспертами предметной области и заказчиками.
### Microservices
Подумайте, каким образом в наши дни разбивают приложение на части, работа которых происходит в ограниченных контекстах? Ответ очевиден - Микросервисы! Все вышеописанные плюсы гексагональной архитектуры применимы и в этом случае. Но помимо вышеописанных плюсов, появляется возможность модифицировать микросервисы буквально методом "вырезать-вставить". Можно откреплять целые куски логики и кода из одних и вставлять в другие, отпочковывать микросервисы из монолита, или собирать всё обратно в монолит. И даже не важно, на каких языках написаны эти микросервисы. Ведь домен изолирован от технической составляющей! Поэтому переписывание на другой язык программирования становится куда более тривиальной задачей.
На десерт - короткое видео на тему от Дейва Фарли: [The problem with microservices](https://www.youtube.com/watch?v=zzMLg3Ys5vI).
### Outro
Спасибо вам уважаемый читатель. Спасибо, что не бросили меня в середине статьи и прошли со мной до конца. Надеюсь тема беседы вас заинтриговала и вы дерзнёте внедрить принципы гексагональной архитектуры и DDD в ваши проекты. Успехов и до новых встреч!
### P.S.
Хотите проверить, насколько вы прониклись вышеизложенным? Тогда подумайте и ответьте, является ли поле `VotingUser.voted` оптимальным решением с точки зрения моделирования предметной области? А если нет, что бы вы предложили взамен? | https://habr.com/ru/post/559560/ | null | ru | null |
# REST сервис на C++: POCO+Angular TODO
[POCO](http://pocoproject.org/) — кроссплатформенная open-source библиотека на С++ под Boost Software License: [ru.wikipedia.org/wiki/POCO](http://ru.wikipedia.org/wiki/POCO).
[POCO](http://pocoproject.org/) имеет в своем составе средства для создания веб-сервисов c [RESTful API](https://ru.wikipedia.org/wiki/REST).
В данной статье рассмотрено создание такого сервиса на примере TODO.
Простейшее приложение TODO — это список задач с возможностью добавить новую или удалить выполненную задачи.
Задача реализована в CTodo. Каждой задаче в списке присваиваются уникальный идентификатор (id) и пользовательское описание (text).
Список задач реализован в CTodoList. Управление списком задач производится методами [CRUD](https://ru.wikipedia.org/wiki/CRUD) Для хранения списка задач используется std::map.
Http сервер бэкенда реализован в TodoServerApp. Данный класс содержит методы CRUD, а также список задач и мьютекс для синхронизации доступа к нему. Метод main вызывается из базового класса POCO ServerApplication.
**TodoServerApp.h**
```
#pragma once
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace Poco;
using namespace Poco::Net;
using namespace Poco::Util;
using namespace std;
/\*\*
Todo
\*/
class CTodo {
size\_t id;
string text;
public:
CTodo(string text): text(text){
}
/\* getters & setters \*/
size\_t getId(){ return id; }
void setId(size\_t id){ this->id = id; }
string getText(){ return text; }
};
/\*\*
Список Todo
\*/
class CTodoList {
size\_t id;
map todos;
public:
CTodoList():id(0){}
/\* CRUD \*/
void create(CTodo& todo){ todo.setId(++id); todos.insert(pair(id, todo)); };
map& readList(){ return todos; }
void del(size\_t id){ todos.erase(id); };
};
/\*\*
Сервер
\*/
class TodoServerApp : public ServerApplication
{
public:
/\* CRUD \*/
static void createTodo(CTodo& todo);
static CTodoList& readTodoList();
//static void updateTodo(size\_t id, CTodo& todo);
static void deleteTodo(size\_t id);
protected:
int main(const vector &);
static Mutex todoLock;
static CTodoList todoList;
};
```
При вызове метода main в классе TodoServerApp создается Http сервер с заданными параметрами (порт 8000 и т.д.). Также серверу передается фабрика обработки запросов TodoRequestHandlerFactory.
После инициализации сервера запускается бесконечный цикл.
В данном случае фабрика TodoRequestHandlerFactory имеет всего два обработчика: CFileHandler для отдачи статики и CTodoHandler собственно для самого REST API.
Обработчик REST API CTodoHandler определяет тип запроса (GET/POST/PUT/DELETE). Для методов PUT/DELETE вычисляется идентификатор по URI. В соответствии с типом запроса производятся необходимые действия с данными списка.
Поскольку данное приложение очень простое, метод PUT не используется. Выдача информации для GET по id конкретного задания также не реализовано.
Далее производится формирование ответа в выходной поток сервера. С этой целью для задачи CTodo и списка задач CTodoList перегружен оператор <<.
**TodoServerApp.cpp**
```
#include
#include
#include "TodoServerApp.h"
Mutex TodoServerApp::todoLock;
CTodoList TodoServerApp::todoList;
ostream& operator<<(ostream& os, CTodo& todo)
{
os << "{ \"\_id\": "<< todo.getId() << ", \"text\": \"" << todo.getText() << "\" }";
return os;
}
ostream& operator<<(ostream& os, CTodoList& todoList)
{
map todos = todoList.readList();
os << "[";
if(!todos.empty())
{
if(todos.size() == 1)
os << todos.begin()->second;
else
for ( map::iterator it = todos.begin();;)
{
os << it->second ;
if(++it != todos.end())
os << ',';
else
break;
}
}
os << "]\n";
return os;
}
class CTodoHandler : public HTTPRequestHandler
{
public:
void handleRequest(HTTPServerRequest &req, HTTPServerResponse &resp)
{
URI uri(req.getURI());
string method = req.getMethod();
cerr << "URI: " << uri.toString() << endl;
cerr << "Method: " << req.getMethod() << endl;
StringTokenizer tokenizer(uri.getPath(), "/", StringTokenizer::TOK\_TRIM);
HTMLForm form(req,req.stream());
if(!method.compare("POST"))
{
cerr << "Create:" << form.get("text") << endl;
CTodo todo(form.get("text"));
TodoServerApp::createTodo(todo);
}
else if(!method.compare("PUT"))
{
cerr << "Update id:" << \*(--tokenizer.end()) << endl;
cerr << "Update text:" << form.get("text") << endl;
//size\_t id=stoull(\*(--tokenizer.end()));
//TodoServerApp::updateTodo(id, form.get("text"));
}
else if(!method.compare("DELETE"))
{
cerr << "Delete id:" << \*(--tokenizer.end()) << endl;
size\_t id=stoull(\*(--tokenizer.end()));
TodoServerApp::deleteTodo(id);
}
resp.setStatus(HTTPResponse::HTTP\_OK);
resp.setContentType("application/json");
ostream& out = resp.send();
cerr << TodoServerApp::readTodoList() << endl;
out << TodoServerApp::readTodoList() << endl;
out.flush();
}
};
#include // std::cout
#include // std::ifstream
#include // std::ifstream
class CFileHandler : public HTTPRequestHandler
{
typedef std::map TStrStrMap;
TStrStrMap CONTENT\_TYPE = {
#include "MimeTypes.h"
};
string getPath(string& path){
if(path == "/"){
path="/index.html";
}
path.insert(0, "./www");
return path;
}
string getContentType(string& path){
string contentType("text/plain");
Poco::Path p(path);
TStrStrMap::const\_iterator i=CONTENT\_TYPE.find(p.getExtension());
if (i != CONTENT\_TYPE.end())
{ /\* Found, i->first is f, i->second is ++-- \*/
contentType = i->second;
}
if(contentType.find("text/") != std::string::npos)
{
contentType+="; charset=utf-8";
}
cerr << path << " : " << contentType << endl;
return contentType;
}
public:
void handleRequest(HTTPServerRequest &req, HTTPServerResponse &resp)
{
cerr << "Get static page: ";
//system("echo -n '1. Current Directory is '; pwd");
URI uri(req.getURI());
string path(uri.getPath());
ifstream ifs (getPath(path).c\_str(), ifstream::in);
if(ifs)
{
resp.setStatus(HTTPResponse::HTTP\_OK);
resp.setContentType(getContentType(path));
ostream& out = resp.send();
char c = ifs.get();
while (ifs.good()) {
out << c;
c = ifs.get();
}
out.flush();
}
else
{
resp.setStatus(HTTPResponse::HTTP\_NOT\_FOUND);
ostream& out = resp.send();
out << "File not found" << endl;
out.flush();
}
ifs.close();
}
};
class TodoRequestHandlerFactory : public HTTPRequestHandlerFactory
{
public:
virtual HTTPRequestHandler\* createRequestHandler(const HTTPServerRequest & request)
{
if (!request.getURI().find("/api/"))
return new CTodoHandler;
else
return new CFileHandler;
}
};
void TodoServerApp::createTodo(CTodo& todo)
{
ScopedLock lock(todoLock);
todoList.create(todo);
}
CTodoList& TodoServerApp::readTodoList()
{
ScopedLock lock(todoLock);
return todoList;
}
void TodoServerApp::deleteTodo(size\_t id)
{
ScopedLock lock(todoLock);
todoList.del(id);
}
int TodoServerApp::main(const vector &)
{
HTTPServerParams\* pParams = new HTTPServerParams;
pParams->setMaxQueued(100);
pParams->setMaxThreads(16);
HTTPServer s(new TodoRequestHandlerFactory, ServerSocket(8000), pParams);
s.start();
cerr << "Server started" << endl;
waitForTerminationRequest(); // wait for CTRL-C or kill
cerr << "Shutting down..." << endl;
s.stop();
return Application::EXIT\_OK;
}
```
Независимо от типа запроса сервис всегда возвращает текущий список задач в формате [JSON](https://ru.wikipedia.org/wiki/JSON).
**Response.json**
```
[
{
"_id": 1,
"text": "First"
},
{
"_id": 2,
"text": "Second"
}
]
```
Фронтенд загружается из ./www/ в дирректории приложения.
Для фронтенда используется [AngularJs](https://angularjs.org/). Код фронтенда практически полностью взят из статьи [scotch.io/tutorials/creating-a-single-page-todo-app-with-node-and-angular](https://scotch.io/tutorials/creating-a-single-page-todo-app-with-node-and-angular)
Вид в index.html состоит из заголовка со счетчиком заданий, списка заданий и формы добавления нового задания.
Контроллер js/app.js вызывает GET для списка при инициализации. Далее — POST при добавлении нового задания из формы, либо DELETE при клике на чекбокс задания.
**index.html**
```
POCO/Angular Todo App
html { overflow-y:scroll; }
body { padding-top:50px; }
#todo-list { margin-bottom:30px; }
POCO/Angular Todo App {{ todos.length }}
----------------------------------------
{{ todo.text }}
Add
```
**js/app.js**
```
// js/app.js
var pocoTodo = angular.module('pocoTodo', []);
function mainController($scope, $http) {
$scope.formData = {};
$http.defaults.headers.post["Content-Type"] = "application/x-www-form-urlencoded";
// when landing on the page, get all todos and show them
$http.get('/api/todos')
.success(function(data) {
$scope.todos = data;
console.log(data);
})
.error(function(data) {
console.log('Error: ' + data);
});
// when submitting the add form, send the text to the node API
$scope.createTodo = function() {
$http.post('/api/todos', $.param($scope.formData)) // $scope.formData)
.success(function(data) {
$scope.formData = {}; // clear the form so our user is ready to enter another
$scope.todos = data;
console.log(data);
})
.error(function(data) {
console.log('Error: ' + data);
});
};
// delete a todo after checking it
$scope.deleteTodo = function(id) {
$http.delete('/api/todos/' + id)
.success(function(data) {
$scope.todos = data;
console.log(data);
})
.error(function(data) {
console.log('Error: ' + data);
});
};
}
```
Репозиторий проекта: [github.com/spot62/PocoAngularTodo](https://github.com/spot62/PocoAngularTodo) | https://habr.com/ru/post/252519/ | null | ru | null |
# MLBootCamp «Оценка производительности». Очень простой и быстрый вариант решения
В этой заметке хочу поделиться своей идеей решения задачи [MLBootCamp «Оценка производительности»](http://mlbootcamp.ru/championship/7/) от Mail.ru. Главное достоинство этого способа — в его простоте и скорости выполнения скрипта. И хотя он не сможет соревноваться в точности с победителями соревнования (мои поздравления!), но может оказаться полезным на практике, если несколько десятых процента не являются критичными, или отправной точкой для дальнейшего развития. Скрипт написан на R.
1. Загрузка и подготовка данных
-------------------------------
Коротко о соревновании, вот как поставлена задача:
> «Мы предлагаем вам научить компьютер предсказывать, сколько секунд будут умножаться две матрицы размера mｘk и kｘn на данной вычислительной системе, если известно, сколько решалась эта задача на других вычислительных системах с другими размерами матриц».
>
>
Стоит сразу отметить, что строго говоря это не так. Нет ни одной вычислительной системы в тестовой выборке, которой бы не было в тренировочной. В качестве метрики используется средняя процентная ошибка ([MAPE](https://en.wikipedia.org/wiki/Mean_absolute_percentage_error)).
А теперь немного подробнее. В обеих выборках для каждого наблюдения имеется 951 признак. Первые три из них это размерности умножаемых матриц, остальные — параметры систем, на которых проводились измерения. Оказывается, что если отбросить параметры умножаемых матриц, то в тренировочной выборке 92 уникальных конфигурации использовавшихся вычислительных систем, т.е. оставшиеся 948 параметров имеют всего лишь 92 комбинации. Заменив эти 948 параметров одним, идентификатором конфигурации, мы получим, что в наших данных всего лишь 4 признака для каждого наблюдения. Подготовим данные для дальнейшей работы добавив еще произведение всех размеров матриц. Теперь в данных есть признаки, *m*, *k*, *n*, *m\*k\*n* и *conf* (идентификатор компьютера). Также, тренировочная выборка содержит целевую переменную *time* — время, за которое было выполнено умножение матриц.
```
library(quantreg)
library(dplyr)
# загрузка исходных данных
y <- read.csv('y_train.csv')[,1]
X.train <- read.csv('x_train.csv', stringsAsFactors = FALSE)
X.test <- read.csv('x_test.csv', stringsAsFactors = FALSE)
# создадим таблицу с уникальными конфигурациями
X.all <- rbind(X.train, X.test)
X.uni <- unique(X.all[,4:951])
# создадим датафрейм с уникальными конфигурациями и вектор с их именами
X.uni <- cbind(conf=paste0('conf', formatC(1:nrow(X.uni), 2, flag = '0')), X.uni)
confs <- unique(X.uni$conf)
# разметим тренировочную выборку именами и выкинем все ненужные столбцы
# преобразуем целый тип к вещественным и добавим целевую переменную
cols <- c('m', 'k', 'n', 'conf')
X.train <- dplyr::inner_join(X.train, X.uni, by=colnames(X.uni)[2:ncol(X.uni)])[cols]
X.train[,1:3] <- lapply(X.train[,1:3], as.numeric) # int->numeric
X.train$mkn <- X.train$m * X.train$k * X.train$n
X.train$time <- y
# то же для тестовой выборки
X.test <- dplyr::inner_join(X.test, X.uni, by=colnames(X.uni)[2:ncol(X.uni)])[cols]
X.test[,1:3] <- lapply(X.test[,1:3], as.numeric) # int->numeric
X.test$mkn <- X.test$m * X.test$k * X.test$n
```
2. Предварительный анализ данных и выбор рабочей модели
-------------------------------------------------------
Теперь можно посмотреть на данные и увидеть ожидаемую зависимость целевой переменной *time* от *m\*k\*n*. Например, конфигурация 39 (слева). Она хорошо аппроксимируется линейной регрессией. Однако, не для всех конфигураций линейная модель может дать хороший результат, например, конфигурация 11 (справа):
Шум и выбросы вносят свой весомый отрицательный вклад модель, поэтому один из вариантов борьбы с ними — удалять такие наблюдения. Недостаток этого способа это решить, насколько наблюдение должно быть «неправильным», чтобы его можно было удалить. Причем для некоторых систем очень мало данных и выкидывать даже зашумленные данные расточительно.
Альтернативный вариант — пользоваться моделями, которые устойчивы к выбросам и шуму. Примеры таких моделей это [квантильная](https://en.wikipedia.org/wiki/Quantile_regression) и [робастная](https://en.wikipedia.org/wiki/Robust_regression) регрессии.
В R их можно найти в пакетах ***quantreg*** и ***MASS*** соответственно. Каждая из них имеет свои настройки, и/или более продвинутые вариации. Здесь эти методы использовались с параметрами по умолчанию. Вот как будет выглядеть график со всеми регрессиями для шумной конфигурации 11:
3. Обучение и тест моделей
--------------------------
Разброс значений целевой переменной варьируется в широких пределах для каждой из систем, поэтому напрашивается решение: обучить стек моделей, по одной на каждую конфигурацию. Пусть зависимость в каждой модели будет немного сложнее, а именно время затраченное от умножение матриц будет зависеть не только от произведения их размеров, но и от каждого из них в отдельности, т.е. *time ~ m + k + n + mkn*:
```
models <- list()
for (i in 1:length(confs)){
# выбор конфигурации
X.conf <- subset(X.train, conf==confs[i])
X.conf$conf <- NULL
# обучаем модель и добавляем ее в стек
fit <- rq(time ~ ., data=X.conf)
models[[confs[i]]] <- fit
}
```
Теперь легко рассчитать предсказания перебирая модели и выбирая из датасета данные, соответствующие каждой отдельно взятой конфигурации и ее модели.
```
y.test <- rep(1, nrow(X.test))
y.train <- rep(1, nrow(X.train))
# предсказания на тренировочной выборке
for (i in 1:length(confs)){
X.conf <- subset(X.train, conf==confs[i])
y.train[as.numeric(rownames(X.conf))] <- predict(models[[confs[i]]])
}
# предсказания на тестовой выборке
for (i in 1:length(confs)){
X.conf <- subset(X.test, conf==confs[i])
y.test[as.numeric(rownames(X.conf))] <- predict(models[[confs[i]]], newdata = X.conf)
}
```
В силу неидеальности исходных данных и, следовательно, полученных моделей в предсказанных значениях будут числа меньше 1, которые по условию задачи быть не должны. Здесь оказывается полезным воспользоваться предсказаниями на тренировочной выборке и заменить все неподходящие значения. Простым и эффективным методом является замена всех чисел, меньших определенной константы, отсечки, ей самой. На графике представлен график метрики (MAPE) в зависимости от значения отсечки *cutoff*. Горизонтальная линия — метрика без замены, вертикальная — отсечка, при котором метрика принимает наименьшее значение.
Используя такую замену можно немного улучшить значение метрики. Как показала практика, уровень отсечки на тренировочной и тестовой выборках приблизительно одинаковый.
Очевидный недостаток приведенного выше кода это то, что модели строились без кросс-валидации, поэтому полученному значению метрики на тренировочной выборке доверять нельзя, как и оценке на публичном лидерборде. Недостаток ликвидируется дополнительным соответствующим кодом.
Однако имеется и явное преимущество — в скорости (у автора скрипт выполнился за полсекунды), что позволяет в короткое время оценить множество различных вариантов комбинаций моделей. Для сравнения, модели с помощью градиентного бустинга, случайных лесов или нейронных сетей строились от как минимум нескольких десятков минут.
Тем не менее, алгоритм с выбором между квантильной и робастной регрессией для каждой конфигурации, показал результат MAPE=5.23% на публичном лидерборде. По итогам соревнования метрики нет, но на основе данных по кросс-валидации ожидается MAPE около 5.4%.
4. Заключение
-------------
Таким образом, обучение стека моделей и прогноз целевой переменной выполняются очень быстро, **меньше секунды** и при этом достигается хорошая точность. Описанный способ можно улучшить за счет более детального внимания к отдельно взятой конфигурации, например, подбирать квантиль для каждой регрессии или параметры при использовании робастных методов, удалять явные выбросы, подбирать отдельно отсечку и т.д., что, как правило, не сильно сказывается на времени выполнения скрипта.
По скромному мнению автора, использование квантильной (или другой, устойчивой к выбросам) регрессии для предсказания времени выполнения компьютерных экспериментов является весьма практичным, точным и куда менее вычислительно затратным, чем способ приведенный в [статье](http://num-meth.srcc.msu.ru/zhurnal/tom_2014/pdf/v15r150.pdf) к соревнованию, где использовались линейная регрессия с удалением значений (собственный велосипед?) и случайные леса. | https://habr.com/ru/post/306198/ | null | ru | null |
# Как начать разработку крупного, нетипичного проекта. Практическое пособие
##### **Выбор платформы для бекенда**
Чтобы создать качественное и производительное Web-приложение, необходимо уделить должное внимание выбору платформы для разработки. Этим нужно заняться сразу же после того, как вы ознакомились, какие задачи должно выполнять это приложение.
В данном случае, немаловажным фактором в техническом задании была предположительно высокая нагрузка на сервис. На рынке есть много хороших инструментов, с помощью которых можно решить поставленную задачу. Некоторые мы используем в разработке, но в этот раз выбор все-таки пал на Yii2.
Если более детально рассматривать этот фреймворк, можно выделить ряд преимуществ:
* Высокая производительность;
* Удобство в работе с базами данных;
* Кэширование страниц и отдельных фрагментов;
* Перехват и обработка ошибок;
* Аутентификация и авторизация;
* Использование миграции базы данных облегчает командную работу.
Установив шаблон advanced, мы уже получаем некоторые необходимые нам возможности, такие как формы регистрации пользователей и входа на сайт с функциональностью восстановления забытого пароля. Еще одно значительное преимущество этого шаблона, – это то, что приложение делится на frontend (пользовательская часть) и backend (часть администратора).
При проектировании структуры приложения были принято решение разнести логические части на модули. Хотя некоторые модули и зависят друг от друга, модульное программирование позволяет удобно расширять и поддерживать код.
##### **Выбор платформы для фронтенда**
Так как наше приложение предполагает наличие множества интерактивных элементов управления, которые будут взаимодействовать друг с другом и с сервером, решили, что jQuery, который идет в коробке c шаблоном advanced, нужно усилить, добавив на фронтэнд AngularJS (потому что Angular для этого и создавался). Он позволяет вводить темплейтинг, не нарушая структуру самого HTML-документа.
Тем самым мы можем сделать верстку, потом добавить темплейт-атрибуты, но верстальщик сможет продолжать работу с документом так, как если бы это был статический HTML. То есть очень просто изменять дизайн в процессе разработки, не опираясь на определенную верстку и атрибуты class, либо id html-элементов. Это большой плюс, особенно, если хочется разделить работу над пользовательским интерфейсом. Эта особенность помогла нам распределить задачи в командной работе. Один человек верстает, второй вводит байндинги и привязывает вьюмодель к бекенду.
К преимуществам использования AngularJS можно отнести:
* Довольно низкий порог вхождения;
* Легкость построения сложных цепей зависимостей;
* Параллельная работа в команде;
* Возможность по максимуму использовать HTML атрибуты, минимизируя javascript код;
* Хорошая поддержка со стороны компании и сообщества;
* Простота работы с REST.
##### **Реализация модульной структуры**
Надеемся, что вы знакомы с Yii2 и уже писали хотя бы несколько приложений на этом фреймворке. Далее будем обращать внимание только на те решения, которые мы применили в нашем проекте.
Мы использовали шаблон advanced, ряд преимуществ которого был описан выше. Но уже на этом этапе, при установке yii2-app-advanced через composer, многие пользователи сталкиваются со следующей ошибкой при попытке открыть сайт в браузере:
The file or directory to be published does not exist: D:\OpenServer\domains\yii2-app-advanced/vendor\bower/jquery/dist
Необходимо установить composer asset plugin и решить проблему следующими командами:
```
cd /path/to/your/project
composer global require "fxp/composer-asset-plugin:~1.1"
composer update
```
Также проверьте, есть ли такие строки в вашем composer.json файле:
```
{
"extra": {
"asset-installer-paths": {
"npm-asset-library": "vendor/npm",
"bower-asset-library": "vendor/bower"
}
}
}
```
Так как мы организовали модульную структуру приложения, первым делом добавим alias для нашей папки с модулями в файл \common\config\bootstrap.php
```
php
Yii::setAlias('@common', dirname(__DIR__));
Yii::setAlias('@frontend', dirname(dirname(__DIR__)) . '/frontend');
Yii::setAlias('@backend', dirname(dirname(__DIR__)) . '/backend');
Yii::setAlias('@console', dirname(dirname(__DIR__)) . '/console');
Yii::setAlias('@modules', dirname(dirname(__DIR__)) . '/modules');</code
```
Теперь все модули, которые мы будим писать, будут располагаться в папке /modules.
Настало время создать первый модуль в этом проекте. Начнем с модуля, который будет отвечать за отображение основных страниц сайта, таких как “Главная страница”, страница контактов, 404 страница, страница “About us”. Для этого мы можем воспользоваться Gii генератором, который может написать код за нас.
Переходим в вашем браузере по ссылке и попадаем на главную страницу генератора.
На данном этапе вы, скорее всего, уже создали базу данных и внесли соответствующие настройки для подключения к ней в файл конфигурации \environments\dev\common\config\main-local.php
```
…
'components' => [
'db' => [
'class' => 'yii\db\Connection',
'dsn' => 'mysql:host=localhost;dbname=your-db-name',
'username' => 'db-user-name',
'password' => 'db-user-password',
'charset' => 'utf8',
],
…
```
Нажимаем кнопку Start в блоке ‘Module Generator’ и попадаем в просмотр генерации модуля.
Заполняем два инпута следующим образом:
```
Module Class:
modules\site\Module
Module ID:
site
```
Жмем кнопку ‘Preview’, затем ‘Generate’ и смотрим, как создаются файлы первого модуля. Осталось только подключить его в конфигурационном файле так, как подсказывает Gii генератор.
Добавим следующие строки в файл \common\config\main.php
```
......
'modules' => [
'site' => [
'class' => 'modules\site\Module',
],
],
......
```
И подправим конфигурационный файл фронтенда \frontend\config\main.php, добавив строчку:
```
......
'defaultRoute' => 'site/site/index',
......
```
Она определяет то, что главная страница у нас находится по роуту 'site/site/index', то есть в нашем модуле Site.
В этом же файле мы удаляем строку
```
'controllerNamespace' => 'frontend\controllers'
```
Это необходимо сделать, потому что теперь в каждом модуле будут определяться свои неймспейсы для контроллеров. Поговорим об этом далее.
Так как мы хотим, чтобы наши модули были максимально независимы друг от друга, и их можно было использовать от проекта к проекту (одни модули подключать к проекту, а другие отключать), будем поддерживать в модуле функционал фронтенда и функционал управления контентом модуля в части администратора. Поэтому контроллеры, модели и view каждой из этих частей мы будем хранить в отдельных каталогах. Структура каталогов модуля будет следующая:
```
…
site
-- controllers
-- -- backend
-- -- frontend
-- models
-- -- backend
-- -- frontend
-- views
-- -- backend
-- -- frontend
…
```
Соответственно, имеющиеся уже у нас в модуле контроллер и view, необходимо перенести в соответствующие папки frontend и не забыть изменить namespace в контроллере на namespace modules\site\controllers\frontend;
Код файла модуля мы перепишем так, чтобы было понятно, к какому контролеру ему обращаться при работе на фронтенде, и к какому при работе в панели администратора. Таким образом на фронтенде он будет обращаться к контроллеру в папке /modules/site/controllers/frontend, а при работе в админ-панели задействовать контроллер в папке /modules/site/controllers/backend.
```
php
namespace modules\site;
/**
* site module definition class
*/
class Module extends \yii\base\Module
{
/**
* @inheritdoc
*/
public $controllerNamespace = 'modules\site\controllers\frontend';
/**
* @var boolean Если модуль используется для админ-панели.
*/
public $isBackend;
/**
* @inheritdoc
*/
public function init()
{
parent::init();
// Это здесь для того, чтобы переключаться между frontend и backend
if ($this-isBackend === true) {
$this->controllerNamespace = 'modules\site\controllers\backend';
$this->setViewPath('@modules/site/views/backend');
} else {
$this->setViewPath('@modules/site/views/frontend');
}
}
}
```
А для того, чтобы настроить доступ к модулю site на бекенде, нужно обозначить его в конфигурационном файле бекенда \backend\config\main.php следующим образом:
```
...
'modules' => [
'site' => [
'isBackend' => true,
]
],
...
```
и заменить строку
```
'controllerNamespace' => 'backend\controllers',
```
на
```
'defaultRoute' => 'site/site/index',
```
Теперь можно создавать контроллеры в папке /modules/site/controllers/backend для бекенда. Я перенесу контроллер SiteController.php с папки /backend/controllers в /modules/site/controllers/backend и заменю в нем namespace, соответственно.
После проведения манипуляций по рефакторингу существующих контроллеров, моделей и представлений и переноса их в наш модуль site, он стал преображаться и приобретать следующий вид:
B этой статье я постарался изложить все плюсы выбранных нами технологий для интересного крупного проекта, предложил способ реализации модульного приложения на Yii2 фреймворке. Это первый пост из цикла статей, в которых я хочу поделиться с вами всеми теми способами, которые мы использовали при решении различного рода нетипичных задач при разработке данного проекта.
В следующей статье я опишу настройку роутинга и создания URL при помощи urlManager для каждого модуля по отдельности. А также разложу по полочкам процесс создания собственных правил для специфических URL с помощью написания класса, который расширяет UrlRuleInterface.
Спасибо за внимание!
Материал подготовлен: [greebn9k](https://habrahabr.ru/users/greebn9k/)(Сергей Грибняк), [pavel-berezhnoy](https://habrahabr.ru/users/pavel-berezhnoy/)(Павел Бережной), [silmarilion](https://habrahabr.ru/users/silmarilion/)(Андрей Хахарев) | https://habr.com/ru/post/304908/ | null | ru | null |
# Измеряем производительность String.format() в Java
### Бэкграунд
Я раньше считал, что JDK в целом хорошо оптимизирована, и если в JDK есть простой способ решения какой-то задачи, то он вполне подойдет для большинства ситуаций и будет работать хорошо.
Но я обнаружил, что иногда некоторые классы или методы работают на удивление плохо. Знание таких аномалий полезно при работе с требовательным к производительности кодом.
В этом посте рассмотрим один из подобных кейсов: поразительно низкая производительность `String.format()` при простой конкатенации строк.
### Более конкретно…
Случай, на который я обратил внимание — это конкатенация строк. Например, получение составных ключей:
```
String key = String.format("%s.%s", keyspace, tableName);
```
Это эквивалентно следующему:
```
String key = keyspace + "." + tableName; // или
key = new StringBuilder().append(keyspace)
.append('.').append(tableName).toString();
```
Можно ожидать одинаковую производительность всех этих вариантов, учитывая, что, с точки зрения пользователя, они выполняют одну и ту же операцию.
### Но у String.format() должны быть низкие накладные расходы?
Следует отметить, что мы рассматриваем очень простой пример. Возможности `String.format()` намного шире — это очень мощный инструмент для различного форматирования строк. Здесь мы будем стрелять из пушки по воробьям.
Важно отметить, что при каждом вызове `format()` происходит декодирование шаблона строки — это накладные расходы, или же JDK должен использовать какое-то хитрое кеширование. Но в отличие от чего-то вроде `Pattern.compile()` для регулярных выражений, для форматированных строк препроцессинг отсутствует.
Учитывая это, разумно предположить, что в нашем простом случае с конкатенацией у `String.format()` будут некоторые издержки.
Но действительно ли будут? Неужели разработчики JDK не совершили здесь еще один впечатляющий подвиг?
### Позовем на помощь нашего друга JMH
Исходный код JMH-теста (`StringConcatenation`) размещен в репозитории <https://github.com/cowtowncoder/misc-micro-benchmarks>.
Вы можете запустить тест следующим образом:
```
java -jar target/microbenchmarks.jar StringConcatenation
```
На своем компьютере (Mac Mini (2018) 3.2Ghz 6-core Intel Core i7) я получил следующие результаты:
```
m1_StringFormat thrpt 15 61337.088 ± 654.370 ops/s
m2_StringBuilder thrpt 15 2683849.107 ± 22092.481 ops/s
m3_StringBuilderPrealloc thrpt 15 2654994.965 ± 36881.162 ops/s
m4_ManualConcatenation thrpt 15 2700825.252 ± 27906.924 ops/s
```
Ваши цифры, конечно, будут немного отличаться.
### Тест-кейсы
Прежде чем перейдем к анализу результатов, приведу описания тест-кейсов:
* `m1_StringFormat`: используется `String.format("%s.%s", first, second)`.
* `m2_StringBuilder`: конкатенация с использованием `StringBuilder`, как было показано ранее.
* `m3_StringBuilderPrealloc`: то же самое, что и m2, но с вычислением оптимального начального размера `StringBuilder`, чтобы избежать многократных повторных выделений памяти для буфера. Это попытка оптимизации m2.
* `m4_ManualConcatenation`: использование оператора "+": `String str = first+"."+second`; (который после компиляции должен стать аналогичным m2).
Во всех тестах конкатенируются пары строк в цикле с 32 итерациями. Тестовые строки довольно просты и могут быть не репрезентативны, но у меня нет цели воспроизвести конкретный кейс (хотя вам следует это сделать, если у вас есть конкретные данные!).
### Разбираемся с результатами
Итак, давайте посмотрим на полученные результаты. Тесты m2, m3 и m4 дают примерно одинаковый результат: около 2,5 миллионов итераций в секунду. При 32 конкатенациях это составит около 80 миллионов конкатенаций в секунду (не забудьте также про различные накладные расходы, такие как сборка мусора). Неплохо.
Но в первом случае (использование `String.format()`) дела обстоят намного хуже — только 62 000 итераций в секунду. Хотя это все еще почти 2 миллиона конкатенаций в секунду (что достаточно для большинства применений), но почти на два порядка медленнее, чем прямое или косвенное использование `StringBuilder`.
То есть в нашем случае `StringBuilder` более чем в 40 раз быстрее `String.format()`. Скорее всего, это гораздо больше, чем большинство Java-разработчиков могло бы предположить.
Первые три случая интересны только тем, что m3 (предварительное выделение буфера в `StringBuilder`) не быстрее, чем использование конструктора по умолчанию. С учетом разброса значений, результаты m2 и m3 перекрываются, поэтому неясно, что из них быстрее. По сути, их производительность практически идентична.
Это может быть связано с тем, что мы используем относительно небольшие строки, для которых размер буфера `StringBuilder` по умолчанию (16) работает достаточно хорошо. Если бы строки были больше, то результаты для версии с предварительным распределением могли быть лучше, но, вероятно, ненамного.
### Но что происходит внутри String.format()?
Можем ли мы выяснить, что происходит под капотом `String.format()`? Это достаточно легко сделать с помощью [async-profiler](https://github.com/jvm-profiling-tools/async-profiler).
Для начала, чтобы JMH-тесты в классе выполнялись эффективно бесконечно (номинально в течение 1 часа вместо 5 секунд на форк), изменим параметры теста в `StringConcatenation.java`.
```
// @Measurement(iterations = 5, time = 1)
@Measurement(iterations = 3600, time = 1)
```
Затем запустим "бесконечный" тест m1 с помощью:
```
java -jar target/microbenchmarks.jar StringConcatenation.m1
```
После запуска посмотрим id процесса (через top) и запустим профилирование в течение 30 секунд:
```
~/bin/async-profiler -e cpu -d 30 -f ~/profile-string-format.txt 67640
```
Мы указали, что хотим использовать профилирование процессора в течение 30 секунд, результаты записать в указанный файл в виде текста (есть и другие форматы, такие как json) и профилировать процесс Java с идентификатором 67640 (вам нужно будет использовать идентификатор вашего запущенного процесса).
Через 30 секунд мы получим файл с результатами (у меня 2592 строки) со сводкой в конце:
```
ns percent samples top
---------- ------- ------- ---
3100000000 10.97% 310 java.util.regex.Pattern$Start.match
2970000000 10.51% 297 java.util.regex.Pattern$GroupHead.match
2370000000 8.39% 237 java.util.Formatter.format
2110000000 7.47% 211 java.lang.AbstractStringBuilder.ensureCapacityInternal
1590000000 5.63% 159 jshort_disjoint_arraycopy
1420000000 5.02% 142 java.util.Formatter$FormatSpecifier.index
1340000000 4.74% 134 java.util.Formatter.parse
1270000000 4.49% 127 arrayof_jint_fill
1240000000 4.39% 124 java.util.regex.Pattern$BmpCharProperty.match
1100000000 3.89% 110 java.util.regex.Pattern.matcher
990000000 3.50% 99 java.util.Formatter$FormatSpecifier.width
980000000 3.47% 98 java.util.regex.Pattern$Branch.match
8
...
```
Глядя на две верхние записи, мы видим, что для декодирования шаблона "%s.%s" используются регулярные выражения (подготовительный этап, о котором я говорил). Третью запись понять немного сложно, но есть несколько других методов с упоминанием `Pattern`, которые, вероятно, также используются для обработки шаблона. В сумме получается около 40% времени профилировщика.
Есть еще интересный момент: внутреннее перераспределение `StringBuilder` по какой-то причине тоже занимает довольно много времени. Но это говорит о том, что больше времени действительно тратится на обработку шаблона строки.
Плохая новость в том, что, похоже, нет никакого способа сделать какой-то препроцессинг `java.util.Formatter`, чтобы избежать повторного создания внутренних структур данных. `Formatter` — класс, который фактически реализует функции форматирования. Все, что делает `String.format()` — это `new Formatter().Format(...).ToString()`. Если бы это было возможно, вероятно, все еще была значительная разница, но не в 40 раз.
### Насколько это все важно?
Влияние на производительность, как всегда, зависит от вашего конкретного случая.
Что касается меня, то я использую `String.format()` в следующих ситуациях:
1. Одиночный вызов во время инициализации.
2. При обработке исключений (которые сами по себе связаны с большими накладными расходами).
3. В других случаях, когда операция вызывается редко.
И избегаю использования в критических участках кода, включая циклы.
---
*Перевод статьи подготовлен в преддверии старта курса* [*Java Developer. Professional*](https://otus.pw/vnchZ/)*.*
* [*Узнать подробнее о курсе*](https://otus.pw/vnchZ/) | https://habr.com/ru/post/580164/ | null | ru | null |
# Три слоя градиента одного слайдера
Мы в Тинькофф разрабатываем [библиотеку Taiga UI:](https://github.com/Tinkoff/taiga-ui) в ней сотни полезных компонентов, директив и сервисов. При разработке нам важно уделять внимание вопросу поддерживаемости кода, поэтому мы стараемся не писать лишнего кода и искать решения, работающие на нативных рельсах браузеров.
В статье поговорим про одно из таких решений — написание [Angular-компонента Slider](https://taiga-ui.dev/components/slider) с помощью встроенных инструментов браузеров и с минимальным использованием Javascript. Расскажу про доступность, интересное решение с многослойным градиентом, немного CSS-хитростей и даже чуть-чуть про Change Detection в Angular.
Когда задача сложнее, чем может показаться
------------------------------------------
Нужно разработать элемент интерфейса, с которым пользователь сможет выбирать число из упорядоченного диапазона. Инпут состоит из двух частей:
* **бегунок, или thumb** — активный элемент инпута, который пользователь перемещает, уменьшая или увеличивая выбранное значение;
* **дорожка, или track** — пространство, вдоль которого двигают бегунок.
Встроенный Slider в ChromeИзначально задача кажется простой. Следи, на каком расстоянии от начала дорожки произошло событие MouseMove/TouchMove, сдвигай туда бегунок и выдавай числовое значение пользователю.
Кажется, что на этом можно закончить и не посвящать этому целую статью. И тут в игру вступают множественные но, о которых не стоит забывать. Нам поможет документация W3C.
W3C — всемирная организация, которая разрабатывает стандарты для построения веб-приложений. Ее цель — сделать веб доступным и понятным для каждого.
Звучит очень абстрактно, поэтому приведу пример. Представьте, что вы заходите на любой сайт и открываете там попап. Какую кнопку клавиатуры вам хочется интуитивно нажать, чтобы закрыть это модальное окно? Esc. Если разработчики сайта добросовестно подошли к своей работе, то, скорее всего, попап действительно закроется при нажатии на эту кнопку.
Это и есть стандарт. Распространением похожих стандартов и занимается W3C. Посмотрим, что нам говорит [W3C про Slider:](https://www.w3.org/WAI/ARIA/apg/patterns/slider/)
**Клавиатурная навигация.** Нажатие клавиш со стрелками вверх/вниз и вправо/влево должно увеличивать/уменьшать значение слайдера на один шаг. Нажатие клавиш Home/End должно перемещать бегунок в начало или конец слайдера. А еще есть рекомендации по поведению клавиш Page Up / Page Down: увеличение/уменьшение значения слайдера на величину большую, чем изменение на шаг при нажатии клавиш со стрелками. При создании своего слайдера придется написать обработчики под восемь кнопок, каждая из которых будет отвечать за определенный результат.
**Доступность.** Сайтом могут пользоваться люди с ограниченными физическими возможностями. Они обычно используют вспомогательные технологии. Например, пользователь может испытывать трудности в использовании клавиатуры и мыши. В таких случаях работают технологии, распознающие голосовые команды. Пользователь проговаривает компьютеру, что нужно сделать на экране. Для корректной работы таких вспомогательных технологий сайт и должен быть грамотно размечен.
Какие требования по доступности предъявляются к слайдеру:
* Бегунок слайдера обязан иметь `role="slider"`.
* Для слайдера должен быть задан `aria-valuenow`, равный текущему числовому значению слайдера.
* Также слайдер должен иметь свойства `aria-valuemin`/`aria-valuemax`, обозначающие минимально/максимально возможное значение слайдера.
* Если числовое значение слайдера недостаточно просто в понимании, то он дополнительно должен иметь `aria-valuetext`. Простой пример из документации: если вы по каким-то причинам решили использовать слайдер для выбора дней недели (от первого до седьмого), то обязательно сопроводите выбранное значение текстовым описанием.
* А еще стоит не забывать про `aria-label`.
Соблюдение всех требований к доступности должно прибавить дополнительных хлопот. А учитывая, что мы проектируем многократно переиспользуемый UI-Kit-компонент, то часть вышеперечисленных свойств придется получать как input-пропсы компонентов.
**У слайдера должна быть возможность конфигурирования шага слайдера.** Например, разработчик может разрешить пользователю выбирать только целочисленные величины. А может разрешить выбирать значение с точностью до 0,0001.
Вот почему все не так просто, как могло показаться с первого взгляда. Но за вас все это может сделать браузер.
Существует встроенный слайдер , который обеспечивает соблюдение всех вышеперечисленных стандартов. Думаю, никого не удивит, что такое встроенное решение не очень красиво, да еще и в каждом браузере выглядит по-разному. Поэтому покажу, как кастомизировать встроенный слайдер под свои нужды, чтобы он выглядел одинаково во всех современных браузерах.
> Компонент спроектируем под Angular. Но JS-кода будет настолько мало, что такое решение вы без труда перенесете под ваш любимый фреймворк.
>
>
Анатомия
--------
Если включить в настройках инструмента разработчика в браузере отображение shadow DOM, то можно обнаружить, что встроенный тег внутри имеет еще теги, которые мы не добавляли. При этом внутренняя структура может отличаться в разных браузерах. Где-то будет плоская структура с тремя `div`-контейнерами, а где-то — дополнительная вложенность.
Каждый движок браузера по-разному подошел к написанию своего слайдера, поэтому все они имеют разную структуру. Но суть одинакова: всегда есть контейнер с дорожкой слайдера и контейнер с бегунком. Просто нужно знать, как обращаться к этим вложенными тегам.
> Обратиться к HTML-тегам внутри , используя CSS-селектор, опирающийся на структуру DOM, не получится (например, `input[type="range"] > div`). Вся разметка слайдера инкапсулирована внутри shadow DOM и недоступна извне. Но браузеры оставили API (псевдоклассы), как все-таки можно достучаться до нужных тегов.
>
>
Все браузеры, использующие WebKit/Blink-движок (например, Safari и Chrome), имеют такую анатомию:
А Mozilla дала больше свободы кастомизации: здесь помимо дорожки и бегунка появляется дополнительный тег, отвечающий за шкалу заполненности слайдера (progress).
Это все, что нужно знать, чтобы написать свой простенький слайдер. Однако если гибкости нужно больше, чем просто покрасить вложенные теги в разные цвета, то могут быть трудности. Расскажу про возможные проблемы и как с ними бороться.
Пишем базовый вариант
---------------------
Для начала создадим основу нашего компонента, опираясь на информацию, полученную ранее.
Зададим [less-переменные](https://lesscss.org/features/#variables-feature) для самодокументируемости кода:
```
@thumb-diameter: 1rem;
@thumb-color: orange;
@track-height: 0.125rem;
@track-color: lightgray;
@track-border-radius: 0.625rem;
```
Создадим [less-миксин](https://lesscss.org/features/#mixins-feature), который отвечает за кастомизацию дорожки слайдера. Пока он будет простым, но в следующих главах мы его значительно расширим.
```
.customize-track() {
height: @track-height;
border-radius: @track-border-radius;
background-color: @track-color;
}
```
Далее создаем миксин для стилизации бегунка слайдера:
```
.customize-thumb() {
/* Clear browser default customization */
appearance: none;
border: none;
/* _________ */
background-color: @thumb-color;
height: @thumb-diameter;
width: @thumb-diameter;
border-radius: 50%;
:not(:disabled)& {
cursor: ew-resize;
}
:focus-visible& {
box-shadow: 0 0 0 2px inset rgba(51, 51, 51, 0.64);
}
}
```
> Если не совсем понятно, как работает символ `&`, советую прочитать [раздел документации по less](https://lesscss.org/features/#parent-selectors-feature).
>
>
Наконец, создадим вспомогательный миксин для webkit-браузеров. Webkit-браузеры не умеют вертикально центрировать бегунок слайдера, если он больше/меньше высоты дорожки слайдера. Множественные способы вертикального центрирования контейнера здесь не помогут, но проблема решается так:
```
/* Vertically centers thumb on the track (webkit only) */
.vertically-align-thumb() {
margin-top: (@track-height / 2) - (@thumb-diameter / 2);
}
```
Теперь можно создавать Angular-компонент. Наш компонент будет без дополнительной верстки, но с атрибутным селектором с нативным элементом .Использование атрибутных компонентов — хорошая практика, когда мы расширяем поведение [нативных элементов.](https://angular.io/guide/accessibility#augmenting-native-elements) В нашей библиотеке Taiga UI можно найти много таких примеров. Об одном из них [я уже писал.](https://habr.com/ru/company/tinkoff/blog/589735/)
Работать компонент будет на OnPush-стратегии. Если вы с ней не знакомы или не пользуетесь ею, рекомендую статью моего коллеги:
OnPush — ваш новый DefaultВ Angular есть два режима change detection: Default и OnPush. В этой статье мы разберем, как можно с...[habr.com](https://habr.com/ru/company/tinkoff/blog/581378/)Содержание Typescript-файла будет такое:
```
import {
ChangeDetectionStrategy,
Component,
} from '@angular/core';
@Component({
selector: 'input[type=range][tuiSlider]',
template: ``,
styleUrls: ['./slider.style.less'],
changeDetection: ChangeDetectionStrategy.OnPush,
})
export class SliderComponent {}
```
> Селектор нашего компонента заставляет пользователя обязательно прописывать тип инпута (type="range"). Есть большой соблазн упростить жизнь пользователям и самим накидывать это статичное свойство через `host` в метаданных компонента. Но, к сожалению, это ломает логику встроенного [controlValueAccessor от команды Angular](https://github.com/angular/angular/blob/master/packages/forms/src/directives/range_value_accessor.ts#L45), который применяется через CSS-селектор `input[type=range]`.
>
>
В Less-файле активно применяем ранее созданные миксины на `:host`-селектор (напоминаю, в данном случае это и будет элемент ).
```
:host {
/* Clear browser default customization */
appearance: none;
background-color: transparent;
outline: none;
/* _________ */
display: block;
cursor: pointer;
width: 100%;
height: @track-height;
/* To catch click events nearby THIN input's track */
padding: 0.4375rem 0;
&:disabled {
opacity: 0.56;
cursor: auto;
}
&::-webkit-slider-runnable-track {
.customize-track();
}
&::-moz-range-track {
.customize-track();
}
&::-webkit-slider-thumb {
.customize-thumb();
.vertically-align-thumb();
}
&::-moz-range-thumb {
.customize-thumb();
}
&::-moz-range-progress {
background: @thumb-color;
border-radius: @track-border-radius 0 0 @track-border-radius;
}
}
```
Готово! Получили базовое кроссбраузерное решение по кастомизации встроенного слайдера. Но проблемы на этом не закончились.
Проблема кастомизации шкалы заполненности в Webkit
--------------------------------------------------
Mozilla позаботилась о желании разработчика кастомизировать шкалу заполненности индикатора — псевдокласс `moz-range-progress`. Но увы, такой функциональности нет для WebKit/Blink-браузеров. Проблему решают [линейные градиенты.](https://developer.mozilla.org/en-US/docs/Web/CSS/gradient/linear-gradient)
Ранее мы просто красили всю дорожку слайдера в серый цвет. А теперь будем красить часть шкалы в цвет заполненности, а оставшуюся часть оставлять серой.
Дополняем в класс компонента немного простой математики, которая посчитает, на сколько процентов заполнился слайдер, и запишет это значение [в CSS-переменную](https://developer.mozilla.org/en-US/docs/Web/CSS/Using_CSS_custom_properties) `--slider-fill-percentage`:
```
// ...
export class SliderComponent {
get min(): number {
return Number(this.elementRef.nativeElement.min) || 0;
}
get max(): number {
return Number(this.elementRef.nativeElement.max || 100);
}
get value(): number {
return Number(this.elementRef.nativeElement.value) || 0;
}
@HostBinding('style.--slider-fill-percentage.%')
get valuePercentage(): number {
return (100 * (this.value - this.min)) / (this.max - this.min) || 0;
}
constructor(
@Inject(ElementRef)
private readonly elementRef: ElementRef
) {}
}
```
Модернизируем прошлый миксин `customize-track`:
```
.customize-track(@progress-filling: false) {
height: @track-height;
border-radius: @track-border-radius;
@filling-progress-gradient: linear-gradient(
to right,
@thumb-color 0 var(--slider-fill-percentage),
@track-color var(--slider-fill-percentage) 100%
);
& when (@progress-filling = true) {
background: @filling-progress-gradient;
}
& when (@progress-filling = false) {
background: @track-color;
}
}
```
Пробуем полученный компонент в действии:
Мы используем `changeDetectionStrategy.OnPush`, поэтому ожидаемо, что слайдер не сделает пересчет значения CSS-переменной `--slider-fill-percentage` в процессе перетаскивания бегунка слайдера. Нам нужно подсказать Angular, когда запускать проверку изменений. Добиться этого просто: проверка изменений должна происходить при срабатывании [InputEvent.](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/input_event) Вешаем пустой обработчик события в метаданные компонента:
```
@Component({
selector: 'input[type=range][tuiSlider]',
template: '',
styleUrls: ['./slider.style.less'],
host: {
'(input)': '0',
},
changeDetection: ChangeDetectionStrategy.OnPush,
})
export class SliderComponent {
// ...
}
```
Теперь при перетаскивании бегунка запускается пересчет значения CSS-переменной `--slider-fill-percentage`.
Одной проблемой меньше, и с этого момента наш слайдер полностью идентичен во всех современных браузерах.
Добавляем ticks через многослойный градиент
-------------------------------------------
У нас есть рабочее решение. Представим, что захотели использовать слайдер со следующим сочетанием нативных атрибутов:
Такая комбинация означает, что пользователь может сдвигать бегунок только на значение, кратное 20. То есть пользователь может выбрать только пять значений в диапазоне, или, другими словами, слайдер состоит из пяти сегментов. Популярная практика для такого кейса — выделение сегментов визуально через отметки/черточки на дорожке слайдера.
Чтобы этого добиться, можно было бы добавить дополнительные элементы/псевдоэлементы внутри инпута. Но такое поведение поддерживают только webkit-браузеры, потому что это не общепринятый стандарт. Еще вариант — попробовать реализовать отметки вновь через градиент, но в прошлой главе на `background`-дорожки уже накинули градиент (то есть место уже как будто занято).
Выход есть: градиенты можно накладывать друг на друга в несколько слоев. С помощью [repeating-linear-gradient](https://developer.mozilla.org/en-US/docs/Web/CSS/gradient/repeating-linear-gradient) создадим новый слой и нанесем его поверх предыдущего.
Но для начала в код компонента добавим:
```
// ...
export class SliderComponent {
@Input()
segments = 1;
//...
@HostBinding('style.--slider-segment-width.%')
get segmentWidth(): number {
return 100 / Math.max(1, this.segments);
}
}
```
Мы добавили для компонента инпут-проперти `segments`, с помощью которой пользователь может задать количество визуальных сегментов, которое он хочет выделить на дорожке слайдера. А новый геттер в компоненте выполняет простое вычисление — считает, сколько процентов от общей длины должен занимать каждый сегмент, а результат сохраняет в CSS-переменную `--slider-segment-width`.
Осталось модернизировать миксин `.customize-track()`. Чтобы на один и тот же фон накладывать несколько слоев градиента, достаточно перечислить их через запятую в свойстве `background-image`. Например:
```
@top-layer: linear-gradient(...)
@middle-layer: repeating-linear-gradient(...)
@bottom-layer: linear-gradient(...)
background-image: @top-layer, @middle-layer, @bottom-layer;
```
Иллюстрация примера, когда несколько слоев градиента накладываются друг на другаГлавное — не запутаться, в каком порядке слои накладываются друг на друга. Самый первый указанный градиент будет наложен поверх всех остальных, а самый последний станет нижним слоем фона. То есть наложение слоев друг на друга начинается с конца перечисления списка.
Все остальные свойства `background-*` имеют аналогичное поведение. Можно указать только один набор параметров для всех слоев, а можно перечислить параметры через запятую — в том же порядке, что и в свойстве `background-image`, задавая свои значения для каждого слоя.
Модернизированный код миксина `customize-track`:
```
@ticks-thickness: 0.25rem;
@tick-color: darkgrey;
.customize-track(@progress-filling: false) {
height: @track-height;
border-radius: @track-border-radius;
@first-tick-offset: ((@thumb-diameter - @ticks-thickness) / 2);
@ticks-background-size: calc(100% - @thumb-diameter);
@hide-first-tick: linear-gradient(
to right,
@thumb-color 0px (@first-tick-offset + @ticks-thickness),
transparent @ticks-thickness
);
@ticks-gradient: repeating-linear-gradient(
to right,
@tick-color 0 @ticks-thickness,
transparent 0 var(--slider-segment-width)
);
@filling-progress-gradient: linear-gradient(
to right,
@thumb-color var(--slider-fill-percentage),
transparent var(--slider-fill-percentage)
);
background-repeat: no-repeat;
background-color: @track-color;
& when (@progress-filling = true) {
background-image:
@hide-first-tick,
@ticks-gradient,
@filling-progress-gradient;
background-position-x: 0, @first-tick-offset, 0;
background-size: @ticks-background-size, @ticks-background-size, auto;
}
& when (@progress-filling = false) {
background-image: @hide-first-tick, @ticks-gradient;
background-position-x: 0, @first-tick-offset;
background-size: @ticks-background-size;
}
}
```
Важная особенность нативных слайдеров: при перемещении бегунка в самый старт/конец дорожки он касается конца дорожки не своим центром, а краешком. То есть бегунок слайдера никогда не выходит за визуальные границы дорожки слайдера. Поэтому самая первая отметка начинается не в самом начале дорожки, а со сдвигом, что позволяет ей быть в центре бегунка (когда тот находится в крайней левой позиции), а также корректно расставляет остальные отметки.
Помимо всех слоев у `background-image` мы также задали значение для `background-color`. Логика здесь следующая: `background-color` выступает в роли самого последнего, запасного, слоя. Вся поверхность дорожки, которая никак не закрывается ни одним из слоев, окрасится в цвет значения этого свойства.
Вот и все. Такое решение — хороший пример того, что порой задачу можно решить без дополнительных вложенных HTML-тегов.
Вместо заключения
-----------------
Весь код статьи я собрал в одном [StackBlitz-примере.](https://stackblitz.com/edit/ng-slider?file=src/slider/slider.component.ts) [В библиотеке Taiga UI](https://github.com/Tinkoff/taiga-ui) мы используем точно такое же решение с небольшими улучшениями. [На витрине компонента Slider](https://taiga-ui.dev/components/slider) можно посмотреть примеры его использования.
Не всегда нужно изобретать свои решения — иногда есть уже готовая нативная альтернатива, которую нужно чуть-чуть доработать.
Отказываясь от готового решения, вы расширяете свою кодовую базу, увеличивая сложность поддержки. Не зря одна современная мудрость гласит: лучший код — тот, который не написан.
Буду рад вопросам и идеям в комментариях. | https://habr.com/ru/post/667254/ | null | ru | null |
# Восстановление данных PostgreSQL после потери pg_control
Для обеспечения отказоустойчивости СУБД PostgreSQL, как и многие базы данных, использует специальный журнал, в котором ведет историю изменения данных. Перед тем как записать данные в файлы БД, сервер PostgreSQL аккумулирует изменения в оперативной памяти и записывает в последовательный файл журнала, чтобы не потерять их из-за непредвиденного отключения питания.
Данные в журнал пишутся до того как пользователь базы данных получит сообщение об успешном применении изменений. Этот журнал называется журналом упреждающей записи (Write-Ahead Log или просто WAL), а файлы журнала хранятся в каталоге pg\_xlog. Также периодически PostgreSQL сбрасывает измененные аккумулированные данные из оперативной памяти на диск. Этот процесс согласования данных называется контрольной точкой (checkpoint). Контрольная точка выполняется также при каждом штатном выключении PostgreSQL.
Информация о том, с какими внутренними значениями завершилась контрольная точка, хранится в файле global/pg\_control и потому этот файл должен быть доступен СУБД еще до момента восстановления данных. Если PostgreSQL отключается нештатно, то изменения из файлов журнала (pg\_xlog) применяются к файлам БД, начиная с позиции последней контрольной точки. Этот процесс называется восстановлением данных.
В файле pg\_control находится информация:
* версия формата control-файла,
* контрольная сумма записанных в этот файл данных,
* версия формата файлов БД,
* уникальный идентификатор экземпляра БД,
* текущее состояние: работает/остановлен,
* позиция в журнале, соответствующая запущенной и предыдущей контрольным точкам,
* текущая ветвь времени (timeline),
* максимальный видимый номер транзакции (xid),
* максимальный номер внутреннего счетчика объектов (oid),
* время создания,
* и многое другое.
Посмотреть содержимое pg\_control можно при помощи утилиты pg\_controldata:
```
$ pg_controldata /var/lib/pgsql/9.5/data
pg_control version number: 942
Catalog version number: 201510051
Database system identifier: 6242923005164171508
Database cluster state: in production
pg_control last modified: Fri Apr 29 01:00:00 2016
Latest checkpoint location: EEAF/BAA5520
Prior checkpoint location: EEAF/BAA5440
...
Latest checkpoint's NextXID: 7/876524573
Latest checkpoint's NextOID: 264355612
Latest checkpoint's NextMultiXactId: 134512401
Latest checkpoint's NextMultiOffset: 547842659
...
```
Если содержимое pg\_control было потеряно, то PostgreSQL не сможет запустить процедуру восстановления. Если же случилось так, что файлы БД неожиданно пропали, что может произойти при аварийном отключении с параметром `fsync=off`, то правильным способом восстановления является переключение на резервную копию. Эта статья может быть полезна в тех случаях, когда нужно в минимальные сроки восстановить работоспособность базы, но невозможно переключиться на резервную копию и можно пожертвовать частью данных.
Файл pg\_control не защищен от сбоев, и восстановить его можно только при помощи утилиты pg\_resetxlog или hex-редактором. Используя pg\_resetxlog, вы можете потерять часть данных. Вы отказываетесь от всех текущих журналов транзакций и считаете, что PostgreSQL завершил свою работу штатно: все данные записаны в файлы, как будто только что завершилась контрольная точка. Вам также придется выбрать максимальный видимый номер счетчика транзакций. Если вы выберете номер транзакции слишком большим, то в файлах данных не окажется информации, которую СУБД еще не сбросила на диск из оперативной памяти, как это сделал бы процесс создания контрольной точки. Если же вы выберете номер транзакции слишком маленьким, то данные, записанные позднее, окажутся невидимыми.
Логично выбрать момент контрольной точки, но откуда можно достать это значение? На помощь приходит штатная утилита pg\_xlogdump, которой можно посмотреть содержимое WAL-файлов. Вам необходимо выбрать самый свежий файл, в котором находится запись о контрольной точке, с типом записи XLOG:
```
$ pg_xlogdump -r XLOG pg_xlog/$FILE
...
rmgr: XLOG len (rec/tot): 80/ 106, tx: 0, lsn: EEAF/0BAA5B40, prev EEAF/0BAA5B08, desc: CHECKPOINT_ONLINE redo EEAF/BAA5B08; tli 2; prev tli 2; fpw true; xid 7/876524573; oid 264355612; multi 134512401; offset 547842659; oldest xid 686019718 in DB 16400; oldest multi 128391103 in DB 16400; oldest/newest commit timestamp xid: 0/0; oldest running xid 876524573; online
```
В данном случае можно выбрать такие параметры для pg\_resetxlog:
```
$ pg_resetxlog -x 876524573 -o 264355612 -m 134512401,128391103 -n /var/lib/pgsql/9.5/data
```
Чтобы указанная команда применила значения, вам необходимо запустить ее без ключа `-n` и с дополнительным ключом `-f`. Команда очистит содержимое каталога pg\_xlog и запишет новые значения в файл pg\_control. После этого вы сможете запустить PostgreSQL без восстановления данных.
Если для восстановления вы выбрали контрольную точку, то, чтобы не попасть в ситуацию, когда вытесненные данные из буферного кэша оказались записанными в файлы БД, рекомендуется до старта экземпляра выставить значение параметра `autovacuum=off` и снять логическую резервную копию при помощи утилиты pg\_dump. Если при снятии резервной копии возникают ошибки, то воспользуйтесь параметром `zero_damaged_pages=on`. После снятия логического резервной копии её необходимо восстановить на новом экземпляре PostgreSQL.
Всем успешной эксплуатации PostgreSQL и резервных копий под рукой! | https://habr.com/ru/post/282770/ | null | ru | null |
# Kaggle: Британские спутниковые снимки. Как мы взяли третье место
Сразу оговорюсь, что данный текст — это не сухая выжимка основных идей с красивыми графиками и обилием технических терминов (такой текст называется научной статьей и я его обязательно напишу, но потом, когда нам заплатят призовые $20000, а то, не дай бог, начнутся разговоры про лицензию, авторские права и прочее.) (UPD: <https://arxiv.org/abs/1706.06169>). К моему сожалению, пока устаканиваются все детали, мы не можем поделиться кодом, который написали под эту задачу, так как хотим получить деньги. Как всё утрясётся — обязательно займемся этим вопросом. (UPD: <https://github.com/ternaus/kaggle_dstl_submission>)
Так вот, данный текст — это скорее байки по мотивам, в которых, с одной стороны, всё — правда, а с другой, обилие лирических отступлений и прочей отсебятины не позволяет рассматривать его как что-то наукоемкое, а скорее просто как полезное и увлекательное чтиво, цель которого показать, как может происходить процесс работы над задачами в дисциплине соревновательного машинного обучения. Кроме того, в тексте достаточно много лексикона, который специфичен для Kaggle и что-то я буду по ходу объяснять, а что-то оставлю так, например, вопрос про гусей раскрыт не будет.
Несколько недель назад на Kaggle закончилось очередное соревнование по компьютерному зрению. Несмотря на все наши старания, в команде с [Сергеем Мушинским](https://www.linkedin.com/in/sergeymushinskiy/) мы таки умудрились финишировать третьими (изначальный маршальский план был остаться в топ-50), что сделало нас причастными к распилу призового фонда, который выделило Британское министерство обороны. Тройка победителей делит $100k: первое место получил [малазиец Kyle](https://www.kaggle.com/kylelee) ($50k), второе — команда [Романа Соловьева](https://www.kaggle.com/zfturbo) и [Артура Кузина](https://www.linkedin.com/in/artur-kuzin-75a48838/) ($30k), а третье — мы, то есть [я](https://www.linkedin.com/in/iglovikov/) и [Сергей Мушинcкий](https://www.linkedin.com/in/sergeymushinskiy/) ($20k). Как side effect я попал в топ-100 в глобальном рейтинге, что никого, конечно, не волнует, но является приятным дополнением к резюме.
Далее по тексту я буду называть Data Scientist’ов кодовым словом «саентолог», что, с одной стороны, подчеркивает глубокую связь Data Scienсe с фундаментальной наукой, а с другой, является стандартным неологизмом в [slack’e Open Data Science](http://ods.ai/), который далее я буду называть просто — «чатик».
Среди саентологов Кремниевой Долины, в которой я в данный момент обитаю, успехи на Kaggle котируются примерно рядом с никак, и рассчитывать на получение призовых денег — довольно смелый ход, поэтому единственно верной мотивацией для участия в соревнованиях являются знания, которые приобретаются в процессе. Кому очень интересно, несколько месяцев назад, когда я писал [похожий текст](https://habrahabr.ru/post/318518/), но про [другую задачу](https://www.kaggle.com/c/allstate-claims-severity#), все вступление я посвятил вопросу мотивации в разрезе соревновательного машинного обучения, где русским по белому расписал, как и почему имеет смысл инвестировать какой-то кусок свободного времени в это занятие.
Надо отметить, что соревнований много, а свободного времени мало, плюс жизнь за пределами монитора и клавиатуры таки существует, поэтому достаточно остро стоит процесс его планирования.
Каждое соревнование на Kaggle, как правило, идет порядка трех месяцев, и одновременно проходят сразу несколько. Организаторы стараются сдвигать их по времени, так что у меня достаточно хорошо показала себя методика, когда соревнования сортируются в порядке наступления дедлайнов и ты работаешь над той задачей, которая заканчивается следующей.
Из плюсов то, что ближе к концу форум насыщен плодотворными дискуссиями, что, в свою очередь, сильно уменьшает время на проверку того, что работает, а что нет, а из минусов, что пары недель по вечерам после работы может не хватить на то, чтобы предложить что-то достойное, и с таким подходом в топ-10 уйти крайне сложно, во всяком случае, у меня получилось только один раз.
Но, так как нам не шашечки, а ехать, такой подход позволил нахвататься машинного обучения до уровня, которого было достаточно, чтобы найти адекватно оплачиваемую позицию Sr. Data Scientist, на которой машинное обучение много используется по работе.
Все это замечательно, но есть нюанс. Классическое машинное обучение — это прекрасно, но нейронные сети — это гораздо более увлекательно, и тот факт, что днем на работе я прикручиваю машинное обучение в production, а по вечерам читаю всякие умные книжки и статьи про Deep Learning, мне кажется неудовлетворительным. Да и вообще, я хочу в DeepMind, но есть гипотеза, что если я сейчас туда подам, никто на мое резюме смотреть не будет, ибо все мои статьи по теоретической физике, а не по машинному обучению, но, что более фундаментально, у меня банально может не хватить знаний, чтобы правильно ответить на вопросы на интервью.
Всю эту лирику я развожу для того, чтобы раскрыть простую мысль: рубить соревнования по Deep Learning, если я хочу найти интересную работу с этим самым Deep Learning — очень надо и это чуть не самый эффективный вариант научиться работать с нейронными сетями в короткие сроки.
Прошлым летом я сунулся на ImageNet и сразу стало понятно, что и инфраструктура у меня не подготовлена, вечно вылезают какие-то мелочи, про которые авторы статей умышленно или случайно умалчивают, но про которые надо знать, да и особенности различных framework’ов я знаю не так хорошо, как мне бы хотелось.
Всю осень на Kaggle шли какие-то неинтересные задачи, причем в каждом втором — data leak, так что вместо машинного обучения публика занималась эксплуатацией кривизны рук организаторов, но с началом зимы карта мне пошла. В последние пару месяцев тысячи опытных Kaggler'ов сидят и удивленно хлопают глазами от того факта, что с декабря стартовало 6 соревнований по Deep Learning с общим призовым фондом $1,475,000. На стаканьи xgboost’ов, как обычно, уже не выехать, надо тратить деньги на GPU / cloud, выходить из зоны комфорта, разминать мозги и начинать работать с нейронными сетями.
Первым среди этих шести соревнований как раз и шла та задача, про которую я дальше буду рассказывать.
Постановка задачи
-----------------
Данные были предоставлены исследовательской лабораторией при министерстве обороны Великобритании и составляли 450 спутниковых снимков нигерийских джунглей общей площадью 450 . То, что это Нигерия, мы узнали уже после окончания. Организаторы достаточно хорошо анонимизировали данные, так что для нас это были просто картинки, без привязки к местности. Я не думаю, что целью соревнования было получить код, который можно вставлять в production и смело начинать наводить ракеты на африканские деревушки. Скорее это было что-то из серии «отправим задачу, возьмем попкорн и будем смотреть, что у этих саентологов получится», то есть обыкновенное Proof Of Concept. Результаты их порадовали настолько, что они запилили свою [собственную копию Kaggle](https://www.datasciencechallenge.org/).
В отличие от классических проблем на сегментацию изображений, в этой задаче каждая из картинок доступна в большом числе спектральных каналов. Причем эти каналы имеют различное разрешение и могут иметь сдвиги по времени и в пространстве.
На выходе же нужно попиксельно предсказать классовую принадлежность. Стоит отметить, что классы не взаимоисключающие, то есть один и тот же пиксель может принадлежать и машине, и дороге, по которой эта машина едет, и дереву, которое над этой машиной и дорогой нависает.
Всего надо было предсказать принадлежность к 10 классам, которые распределены крайне неравномерно, да и еще эти распределения отличаются в train и test, плюс многих классов мало, а машинок так и вообще меньше, чем мало.
Как упоминалось выше, все данные разделены на 26 картинок train set (для них доступны маски), и 425 картинок test set, для которых маски и надо было предсказать. Test set, в свою очередь, тоже был поделен на две части в лучших традициях Kaggle:
* 19% — Public test
* 81% — Private test
Все три месяца, пока шло соревнование, была известна оценка точности модели на Public, а когда соревнование закончилось, итоговый результат подсчитывается по Private части.
#### Метрика
Точность вычислялась как средний [Jaccard Index](https://en.wikipedia.org/wiki/Jaccard_index) по всем классам, то есть поля вносили такой же вклад, как и машинки, при том, что судя по train пикселей с полями в 60 тысяч раз больше.
Вот так все это выглядит навскидку, то есть задача достаточно прямолинейная, особенно учитывая то, что над [похожей задачей](https://www.kaggle.com/c/ultrasound-nerve-segmentation), правда не про спутниковые снимки, а про ультразвуковые сканы, и не для дорог и домов, а для нахождения нервов, я уже работал. Но в целом, с технической стороны это image segmentation как он есть.
### Нюансы
Для любого соревнования, да и вообще задачи машинного обучения, самый важный первый шаг -написать pipeline, который берет сырые данные, чистит, кэширует, что-то тренирует, осуществляет валидацию и подготавливает сабмит. И обычно, за что, часто справедливо, хают Kaggle, данные более-менее чистые и все с технической стороны достаточно прямолинейно и основные проблемы возникают на этапах feature engineering и тренировки моделей, но тут британские военные добавили британской экзотики.
#### Проблема первая
Я смотрю на то, что нам отмаркировали организаторы и не понимаю, что с этим делать. Для тренировки нейронной сети мне на выход нужна матрица `(height, width, num_channels)`, а как ее получить, нет ни малейшего понимания.
Выглядит все это как-то вот так:
`'MULTIPOLYGON (((0.005311 -0.009044999999999999, 0.00531 -0.009035, 0.00531 -0.009024000000000001, 0.005318 -0.009018999999999999, 0.005327 -0.009016, 0.005341 -0.009016, 0.005356 -0.009017000000000001, 0.005372 -0.009023, 0.005375 -0.009031000000000001, 0.005375 -0.009044999999999999, 0.005311 -0.009044999999999999)), ...`
Какие-то полигоны, и много нецелых цифр. Лезем на форум и, как обычно, есть [добрая душа](https://www.kaggle.com/visoft), которая поделилась [кодом](https://www.kaggle.com/visoft/dstl-satellite-imagery-feature-detection/export-pixel-wise-mask), который осуществляет искомое преобразование.
#### Проблема вторая
Правильная валидация — это 90% успеха. На ImageNet такой вопрос не стоит — там организаторы выбирают подвыборку, которая хорошо представляет полное распределение и предоставляют ее участникам. Да и вообще, там картинок столько, что практически любая подвыборка будет работать замечательно. На Kaggle все обычно по-другому. Прецеденты, когда данные хорошо сбалансированы, и локальная валидация соответствует тому, что мы видим на лидерборде, существуют, но это скорее исключение, чем правило. Забегая вперед, скажу, что проблему с валидацией наших результатов мы, также как и, возможно, и все остальные, так и не решили. У [Романа Соловьева](https://www.kaggle.com/zfturbo) (его команда закончила на втором месте) была [какая-то система, с крос валидацией](https://www.kaggle.com/c/dstl-satellite-imagery-feature-detection/discussion/29829), но к ней я отношусь с определенной долей скепсиса.
Идея в том, что картинок мало, и они соответствуют достаточно разным областям. То есть Train, Public и Private — это три разных распределения, сильно скореллированных, но, тем не менее, различных, в чем можно убедиться на картинке выше.
#### Проблема третья
Бог с ней с валидацией, чтобы добраться до первого сабмита, ее можно отключить. Беру стандартную рабочую лошадку задач сегментации Unet, пишу всю инфраструктуру с формированием батчей на лету, аугментацией преобразованиями [группы D4](https://en.wikipedia.org/wiki/Dihedral_group), тренирую сеть предсказывая все 10 классов за раз, что-то даже куда-то сходится.
Натренировал. Круто. Дальше-то что? Следующая проблема — это, как, собственно, сделать само предсказание. Сеть тренировалась на рандомных кропах размером 112x112 из картинок размером 3600x3600 и на этом этапе надо было создавать инфраструктуру, которая будет резать большую картинку на маленькие, предсказывать, правильно обрабатывать краевые эффекты, а потом собирать все обратно. Это муторный, но прямолинейный кусок, хотя, как выяснилось позже, на нем я тоже накосячил.
#### Проблема четвертая
Круто. Я уже чую, что почти добрался до сабмита, и для каждой большой картинки я могу создать маску. Но этого мало. Kaggle принимает предсказание в форме полигонов, а перегнать маски в полигоны с ходу — задача нетривиальная. Лезу на форум. Там есть какой-то код. Я его прикручиваю. Собираю сабмит — размер 4Gb. Загружаю на сайт, загрузка длится дольше чем долго, что-то начинает считаться, и сабмит не проходит. Лезу на форум, а там уже есть ветка, в которой интеллигентно, но без мата, обсуждают именно эту проблему. Какое-то из предложенных решений прикручиваю к сабмиту, теперь файл только 2Gb, что все равно много, но уже лучше — загружаю, и в этот раз загрузка длится в два раза быстрее, чем очень долго, что-то начинает крутиться, и на экране появляется вот такое емкое сообщение.
И вот за всеми движениями уже прошел месяц, а я так и не сделал первый сабмит. Стоит заметить, что параллельно со всем этим процессом я начал искать работу, ориентированную на Deep Learning, для того чтобы усугублять свои знания в данной области в рамках оплачиваемой работы, а не по вечерам, убивая свое свободное время. Напыщенные индусы, которые меня интервьюировали не раз, говорили что-то типа: «Kaggle для детей, там чистые данные, да и код толком писать не надо, не то, что тут у нас в Рогах и Копытах». И во многом они правы, но в разрезе этой задачи про спутниковые снимки по голове стукнуть таких персонажей, конечно, хотелось.
Так вот, страдаю я. Ни черта не получается и непонятно, куда копать. Я сильно грешил на сеть, мол она у меня косячит, и поэтому ошибка в битых полигонах оттого, что предсказывает она плохо, полигоны в сабмите сильно фрагментированы, что приводит к большому размеру сабмита, плюс полигоны имеют какой-то неправильный формат, что и приводит к ошибкам. И весь месяц со всем этим я безуспешно прокувыркался. Надо отметить, что похожий успех имел не я один, но и большинство участников, что привело к тому, что многие не захотели мучаться со всем этим оверхедом и свалили на более прямолинейные, но от того не менее мутные параллельные соревнования [по классификации рыбок](https://www.kaggle.com/c/the-nature-conservancy-fisheries-monitoring) и [рака легких](https://www.kaggle.com/c/data-science-bowl-2017). За месяц до окончания на Leadeboard было порядка 200 человек, причем только 50 из них были выше sample submission.
Итак, что мы хотим? Получить много знаний в задаче по сегментации спутниковых снимков. Но что мы имеем? Да ни черта мы не имеем, кучу кода с какими-то сетями, которые непонятно как работают, если вообще работают.
Оставалось 30 дней, и чтобы в этот промежуток времени что-то склеилось, было необходимо сделать ход конем, что и было успешно осуществлено. В чатике (Slack канал Open Data Science) есть комната kaggle\_crackers, в которой, в теории, происходит интеллигентное обсуждение текущих и прошлых задач по машинному обучению. Собственно, там я и начал активно задавать вопросы по этой задаче, в режиме «вот выдается ошибка, кто сталкивался?». Один из участников чата, а именно простой брутальный парень [Костя Лопухин](https://www.kaggle.com/lopuhin) (финишировал пятым в составе крайне сильного DL квартета ), пока я блеял и спотыкался, прорубился через документацию по OpenCV и shapely, и написал правильный и быстрый код для перегона из маски в полигоны, который позволял сделать сабмиты адекватного размера, и это стало поворотным моментом для всего соревнования, я бы даже сказал, эпохальным. Собственно, с этого все и началось. Этой функцией пользовалось 90% участников, да и вообще, если бы не Костя, сидели бы британские военные и матерились на саентологов, а не запиливали свой Kaggle.
Я прикрутил функцию, сделал сабмит, получил 0 и последнее место на Leaderboard. Связано это было с очередным финтом от организаторов: оказывается, существовали какие-то мутные коэффициенты, которые применялись для анонимизации, и их надо было учесть, а после того, как я их учел, выяснилось, что сети у меня очень даже адекватные и выдают результат в топ-10%. Вопрос с ошибками при сабмите решился раздутием полигонов, потому что, оказывается, код Kaggle не любит полигоны с сильно острыми углами, и, если я не вру, это решение предложил [Александр Мовчан](https://www.kaggle.com/movchan).
Слово за слово, обсуждение этой задачи в профильном канале начало привлекать тех, кому эта задача показалось интересной, особенно когда стало понятно, что вся нездоровая инженерия, которой все занимаются на работе за деньги, но никто не хочет заниматься в свободное время и за бесплатно, преодолима.
Второе эпохальное событие случилось, когда [Артур Кузин](https://www.kaggle.com/drn01z3) (закончил вторым в команде с [Романом Соловьевым](https://www.kaggle.com/zfturbo)) решил показать, что аналитики в Avito не пальцем деланы, и что сейчас он покажет свой высокий класс саентологу из долины, и зафигачил [kernel на Kaggle, который выдает решение end2end](https://www.kaggle.com/drn01z3/dstl-satellite-imagery-feature-detection/end-to-end-baseline-with-u-net-keras/), то есть чистит данные, тренирует модель и делает предсказание, что привлекло еще пару сотен человек поучаствовать в решении этой проблемы.
Под это дело создали отдельный канал, [Артур](https://www.kaggle.com/drn01z3) пригласил в чатик [Романа Соловьева](https://www.kaggle.com/zfturbo), который на Kaggle известен как легендарный ZFTurbo, а в России как скромный научный сотрудник в одном из конструкторских бюро. Также к чатику присоединился [Алексей Носков](https://www.kaggle.com/alexeynoskov). Видимо, его пригласили после того, как в составе команды он занял второе место в закончившемся в январе соревновании [Outbrain Click Prediction](https://www.kaggle.com/c/outbrain-click-prediction). Мой будущий напарник [Сергей Мушинский](https://www.kaggle.com/ceperaang) также решил, что хватит пинать балду в сибирских снегах и взялся за код и чтение литературы. Отдельно хочется отметить [Андрея Стромнова](https://www.kaggle.com/stromnov), который хоть в соревновании и не участвовал, но так как сильно разбирался в предметной области, много консультировал нас на тему специфики работы со спутниковыми снимками.
Коллектив подтянулся, с инженерией мы разобрались, оставалось три недели, и что мы имели?
Абсолютно непонятно, как локально валидироваться. Стандартный способ — взять 5 картинок в holdout set и использовать их для валидации — меня сильно настораживал, ибо приводил к тому, что у нас train, validation, Public и Private — это четыре различных распределения, да и урезать и без того маленький train очень не хотелось.
Саша Мовчан предложил другой способ — от каждой картинки откусить кусок и validation кропать из него. В теории это было лучше, ибо гарантировало, что train и validation из одного распределения. Но это, конечно, тоже не решение, потому что test все равно достаточно сильно отличался, хотя эту гипотезу мы, безусловно, проверили.
В конце концов, каждый придумал что-то свое. Роман не жалел компьютерных ресурсов и делал 5 fold, Костя и Алексей выделяли несколько картинок для валидации, кто-то просто верил Public лидерборду, мотивируясь тем, что там 80 картинок, да и вообще, на задаче сегментации тяжело оверфитить.
Мы с Сергеем использовали рабоче-крестьянское решение и вообще не использовали валидацию. Тренировали, пока train loss не выходил на плато. После этого делались предсказания на весь test, бок о бок — маска и картинка.
И все это просматривалось глазами. С одной стороны, можно было словить очевидные недостатки в коде, например, у меня сеть любила добавить домов ровным слоем по краям картинки, что я решил тем же приемом, что использовался в оригинальной статье про Unet, а именно сделать padding отражением ближайшей области исходной картинки.
Или на картинке выше:
* Пруды напредсказывало в домах и посреди дорог.
* Непонятные куски асфальтовых дорог тут и там. Можно отфильтровать на стадии постпроцессинга по минимальной площади полигонов.
* Разрывы в предсказаниях асфальтовых дорог — можно попытаться исправить через [морфологические преобразования.](http://docs.opencv.org/trunk/d9/d61/tutorial_py_morphological_ops.html)
Также это позволяло понять, на чем мы горим, на False Positive или False Negative и подкорректировать пороги бинаризации. После того, как визуально нам казалось, что стало лучше, отправлялось предсказание на Leaderboard. С одной стороны, такой подход — это нарушение правил, типа, смотреть на test — низкий стиль, но с другой — это жизнь, и занимались мы этим от безысходности. На работе же все время от времени делают manual review, ибо машинное обучение без Human In the Loop — это криминал.
Подытоживая про валидацию — из того, что я видел, наш подход самый надежный.
Следующий вопрос, на который мы всем коллективом пытались получить ответ — как ловить машинки и грузовики. Их целых два класса, то есть 20% итогового результата заложено в них. С машинками основные проблемы были в том, что их мало, каждая из них — это несколько пикселей на асфальте, да и размечены они по-индусски — где-то машина не размечена, где-то вместо машины отмечен мусорный бак, различные бэнды в одном и том же снимке могут быть сделаны с промежутком в несколько секунд, так что если машина движется, вы можете запросто получить на одном и том же снимке машину в различных местах.
Вот это один и тот же грузовик.
Другие команды использовали решения различной степени эффективности, но наша команда решила, опять же, поступить по-простому: мы на машинки забили, отдавая себе отчет, что на этом мы точно теряем. Возможно сейчас, когда я сильно улучшил свои навыки и знания в задачах локализации, я бы поступил по-другому, но на тот момент, видится мне, это было самое правильное решение.
Еще один нюанс, которым обладало данное соревнование — это формат сабмита и метрика, которые позволяли делать предсказания по отдельным классам и проверять, чему это соответствует на Leaderboard. С одной стороны, это позволяло участникам уйти в silent mode, а с другой, иметь более точную оценку предсказаний. Классы настолько разные, что при предсказании их всех за раз очень сложно оценивать прогресс. Из этих соображений все стали делать предсказания поклассово, что привело к появлению сводной таблички, которая выглядела примерно вот так:
В свою очередь, это привело к формированию команд среди тех, кто верил, что это позволит сильно улучшить результат. Сначала Артур с Романом сбились в команду, после них Алексей, Костя и ребята с [deepsystems.io](https://deepsystems.io). А потом и мы с Сергеем образовали команду, причем у нас получилось достаточно удобно из-за сильно различных часовых зон (Ангарск — Сан Франциско), этакая посменная работа.
Стандартный технический вопрос: какую сеть использовать? Каждая статья утверждает, что уж они то, State of The Art, при этом если и не врут, то этот State Of The Art был на других данных, и их опыт не обязательно переносится. Для оценки того, что из литературы можно использовать, а что нет, нужна адекватная валидация, а у нас, как отмечалось выше, ее не было. Все статьи, которые мы обсуждали, оперируют какими-то чистыми большими данными, а вот такого нигерийского паскудства, с которым работали мы, что-то нигде не встречалось.
И, конечно, у того, кто разбирается в задачах сегментации, может возникнуть законный вопрос: «А вы пробовали использовать прием X из статьи Y, ну например CRF для постпроцессинга?» или «А вы пробовали архитектуру сети Z, скажем, вариацию DenseNet для сегментации?». Скорее всего, ответ — да, мы перелопатили кубометры литературы, и многие идеи воплощали в коде и проверяли, но не в том режиме, что каждый пробовал все, скорее так: кто-то пробовал — у него не зашло, он поделился с остальными, и те уже на это время не теряли.
В отличие от стандартной задачи сегментации, где на RGB картинках надо попиксельно отличать золушек от чебурашек, у нас было много каналов на вход в различных диапазонах и это надо было как-то учитывать. Простой вариант — склеить все в один большой бутерброд и на этом тренировать, (Роман так и поступил), или же сделать хитрую сеть с различными входами, как поступил Артур? Довериться сети или же помочь ей дедовскими методами, а именно, делать сегментацию через индексы? Что делать с RGB? Спутник RGB не производит. Получается, что M band в низком разрешении смешивается с P band, который в высоком, добавляется щепотка табаку и получается RGB. Что и было показано в [первом кернеле](https://www.kaggle.com/resolut/dstl-satellite-imagery-feature-detection/panchromatic-sharpening) [Владимира Осина](https://www.kaggle.com/resolut).
Наша команда сделала так: быструю и медленную воду мы нашли через индексы на основе [второго кернела](https://www.kaggle.com/resolut/dstl-satellite-imagery-feature-detection/waterway-0-095-lb) от Владимира Осина.
А для остальных классов мы собрали RGB, P, M и приклеили 4 дополнительных индекса [Enhanced vegetation index (EVI)](https://en.wikipedia.org/wiki/Enhanced_vegetation_index), [Normalized difference water index (NDWI)](https://en.wikipedia.org/wiki/Normalized_difference_water_index), [Canopy Chlorophyl Content Index (CCCI)](https://www.researchgate.net/publication/259360047_Use_of_the_Canopy_Chlorophyl_Content_Index_CCCI_for_Remote_Estimation_of_Wheat_Nitrogen_Content_in_Rainfed_Environments), [Soil-Adjusted Vegetation Index (SAVI)](https://en.wikipedia.org/wiki/Soil-Adjusted_Vegetation_Index). Все эти индексы не добавляют никакой новой информации, так что сеть и так бы разобралась, но, памятуя о том, как добавление квадратичных взаимодействий между признаками помогло градиентному бустингу в [задаче Allstate](https://habrahabr.ru/post/318518/), при том, что этот бустинг должен высокоуровневые взаимодействия находить сам, мы их добавили.
Как видно, на этой картинке вода через индексы находится очень неплохо, поэтому похожие техники и использовались с тех пор, как начали делать мультиспектральные спутниковые снимки.
После этого все это подавалось на вход подкрученной Unet. Unet — это что-то вот такое:
(картинка из [оригинальной статьи](https://arxiv.org/abs/1505.04597), у нас было чуть по-другому (мы добавили BatchNormalization, заменили Relu на Elu, по-другому делали cropping и изменили число фильтров), но концептуально Unet он и в Африке Unet, хотя тут накрутить можно много. Вот интересный пример, [сеть Тирамису](https://arxiv.org/abs/1611.09326), на которую у нас были большие надежды, но что-то она как-то не зашла ни у кого, кроме Алексея Носкова.)
У нас сложилось нестойкое впечатление, что поскольку картинки в Train сильно разные, то в данной задаче большой батч важнее чем большой receptive field, так что мы использовали батч в 128 картинок размером 112x112 и 16 каналами каждая. То есть на вход сети мы подавали матрицу (128, 112, 112, 16).
Сергей на своей GPU проверял с батчем в 96 картинок, зашло нормально, так что, возможно, имело смысл использовать (96, 128, 128, 16), что в общем похоже, но чуть лучше.
Скажу больше, разные классы требовали различного receptive field и разного числа каналов, скажем, поля скорее всего можно было предсказывать на одном M band, разрешения 1.24 m/pixel хватало за глаза. Можно даже уменьшать. И так как этих полей много, то и большой batch size не требовался.
Данных мало, поэтому при тренировке к каждой картинке из батча применялось рандомное преобразование из [группы D4 (группа симметрий квадрата)](https://en.wikipedia.org/wiki/Dihedral_group). Другие команды дополнительно использовали повороты на небольшие углы, но у меня руки не дошли, и без этого то, что работало, работало более-менее, а для машинок этого было маловато в любом случае.
В качестве Optimizer мы использовали [Nadam](http://www.cs.toronto.edu/~fritz/absps/momentum.pdf) и тренировали каждую сеть 50 эпох по 400 updates с learning rate = 1e-3, а потом еще 50 с learning rate = 1e-4
В качестве функции потерь мы использовали вот такое выражение:
Похожая функция потерь хорошо себя показала в другой задаче сегментации. Интуиция за нашим выбором была вот такая: c одной стороны, нам нужна вероятность принадлежности к каждому классу, поэтому хорошо себя покажет binary\_crossentropy, а с другой, наша метрика это jaccard, значит хорошо бы добавить его аппроксимацию в loss function. Как бонус, такая комбинация упрощала жизнь на стадии выбора threshold при перегоне из вероятности принадлежности пикселя к маске к двоичному значению. При этой loss function становится не очень важно, что вы используете: 0.3, 0.5 или 0.7. Вернее, разница есть, но она меньше, чем могла бы быть при использовании голой binary\_crossentropy.
Каждая Fully Convolutional Network грешит тем, что предсказания уменьшают точность при удалении от центра, что обычно решается обрезанием предсказания по краям и / или перехлестом предсказаний. Мы делали и то, и другое. У каждой предсказанной маски по краям обрезались по 16 пикселей. Плюс мы использовали test time augmentation, вот в таком режиме, что отчасти уменьшало краевые эффекты:
К примеру, исходная картинка размером (3348, 3396) добиваться через ZeroPadding до (3392, 3472)
Оставлять края в таком ZeroPadding режиме нельзя, когда я так делал, эта острая грань сетью воспринималась как стена дома, и получались дома, размазанные ровным слоем по всему периметру. Это достаточно легко решается. Как я уже упоминал, в оригинальной статье по Unet это решалось добавлением отражения от исходной картинки в эту область, и мы поступили точно так же.
Эта картинка режется на пересекающиеся куски 112x112, с 16 пиксельным перехлестом. Собирается в один большой батч (а он реально большой: одна картинка 3600x3600 ~ 1800 патчей 112x112), предсказывается, разбирается обратно в большую картинку.
Но можно усугубить. Если отразить/повернуть исходную большую картинку, сделать предсказание, а потом вернуть к исходной ориентации, то выяснится, что нарезка происходила немного по-другому. И если повторить это несколько раз для различных ориентаций и усреднить (в данном случае мы использовали геометрическое среднее), то с одной стороны частично будет закрыт вопрос с краевыми эффектами, а с другой, test time augmentation, который мы провели, уменьшает variance предсказания, что железобетонно добавляет чуть-чуть к точности.
К точности добавляет, но и на предсказания начинает уходить значительно больше времени. Что-то вроде пяти часов на весь test. Другое дело, что это можно распараллелить, но на тот момент дома в компьютере стоял только один Titan, так что test time augmentation под такие задачи, наверно, имеет смысл использовать ближе к финалу. Ну очень уж накладно.
Сделали предсказания. Все? Конечно нет. Остается post processing. Например, можно попытаться убрать все предсказания домов из быстрой воды, которой мы верим больше, чем домам, а всю медленную воду из домов, которым мы верим больше, чем этой медленной воде.
После этого применяется Костина функция, мы пробиваемся через ошибки сабмита, все становится хорошо и приятно, и мы добираем еще немного очков на LeaderBoard.
Если суммировать кусок нашего решения про нейронные сети в двух словах, то может получиться что-то вроде того, что получилось у Артура, когда он на той неделе делал [доклад](https://youtu.be/yUyaYL_x4kQ) на ML-тренировке в Яндексе:
В последние несколько дней, когда все уже эмоционально вымотались, а кто-то еще и физически (ближе к концу я пару часов за ночь вставал по будильнику перезапустить тренировку сети, предсказаний или еще чего-нибудь), хотелось если не хлеба, то зрелищ, и под это дело Сергей выложил на форум скрипт Артура, в котором поправил баги + добавил пару улучшений, а [Михаил Каменщиков](https://www.kaggle.com/greenwolf) пожертвовал готовые натренированные веса для сети для этого скрипта. И этот скрипт выдавал 0.42 на Public Leaderboard, то есть на тот момент что-то в районе 30 места из 420. Халява — это сладкое слово, так что народ начал массово этот скрипт запускать, вызывая стоны гнева на форуме, правда, как выяснилось позже, на Private Leaderboard все было сильно хуже, и весь этот коллектив халявщиков улетел мест на 100 вниз.
Под это дело Михаил моментально разродился вот таким мемом.
Это я к тому, что все вымотаны. Те, кто в топ-10, гадают, останутся ли они там (мечтая о Kaggle’овой ачивке gold medal, которая является необходимым условием для другой ачивки Kaggle Master/GrandMaster), а те кто в топ-3, в похожих мыслях, но уже про деньги.
На финише, на Public Leaderboard в top 10:
1. 0.5858 - [Kyle — альфа-гусь из Малайзии](https://www.kaggle.com/kylelee)
2. 0.5569 — Квартет из [Кости Лопухина](https://www.kaggle.com/lopuhin), [Алексея Носкова](https://www.kaggle.com/alexeynoskov), [Рената Баширова](https://www.kaggle.com/rmbashirov), [Руслана Байкулова](https://www.kaggle.com/romul0212)
3. 0.5484 — [Роман Соловьев](https://www.kaggle.com/zfturbo), [Артур Кузин](https://www.kaggle.com/drn01z3)
4. 0.5413 — [Дмитрий Цыбулевский](https://www.kaggle.com/u1234x1234)
5. 0.5413 — Октет deepsense.io
6. 0.5345 - [ironbar — неизвестный нам испанец](https://www.kaggle.com/ironbar)
7. 0.5338 — [Kohei — неизвестный нам японец](https://www.kaggle.com/confirm)
8. 0.5287 — [Я](https://www.kaggle.com/iglovikov) и [Сергей Мушинский](https://www.kaggle.com/ceperaang)
9. 0.5222 — [Daniel FG — какой-то неизвестный гусь](https://www.kaggle.com/danielfg)
10. 0.51725 — [Евгений Некрасов](https://www.kaggle.com/nekrasov)
Итак, в Москве — ночь на 7 марта, в топ-10 на Public Leaderboard половина команд — из нашего дружного чатика. Все ждут трех часов ночи, объявления результатов. Тут надо отметить, что вся эта месячная движуха вокруг спутниковых снимков подогрела к ней интерес не только участников, но и большого числа болельщиков, которые сами не пробовали окунуться в пучину водоема всей этой инженерной мути, в которую мы не только окунулись, но и благополучно переплыли, поддерживая друг друга от того, чтобы не утонуть. Мне чуть проще — у меня другой часовой пояс, так что я на работе прикручивал очередную модель в production, параллельно наблюдая и участвуя в дискуссиях.
Седьмое марта, 3 часа ночи по Москве, окончание соревнований, все вдохнули, смотрят на сайт — а выдыхать не хочется. Всем хочется развязки, какой бы она ни была, а она не наступает. Зато, вместо этого, приходит от админа вежливое:
> I wanted to remind you that per Dstl's request, we will withhold the private leaderboard until March 14th in order to synchronize with their press release.
Чатик бурил, стонал и матерился, эмоции лились через край.
Через неделю, вышел [пресс релиз](https://www.gov.uk/government/news/dstls-kaggle-competition-has-been-a-great-success), с мощным названием: «Dstl’s Kaggle competition has been a great success» британских военных о том, как они все впечатлены, и рассказали, сколько денег они за это возможно попилили (2,500k), сколько заплатили Kagge (350k за хостинг соревнования, 100k на призы), и что они активно и тщательно анализируют решения победителей.
И чуть позже этих победителей таки объявили. В первой десятке только альфа-гусь Kyle остался без изменений, остальных чуть перемешало, что и не удивительно, учитывая, что Public test и Private test так сильно различались. Артур с Романом поднялись с третьего места на второе, мы с Серегой с восьмого на третье, квартет потерял 3 места и ушел на пятое, Дмитрий Цыбулевский тоже потерял пару мест, зато Евгений Некрасов поднялся на целых три.
Ниже по рейтингу народ метало гораздо сильнее, +- 100 мест влегкую. Например, движения 129 => 19 (это хорошо карта легла), или 20 => 133 (это плохо). Такие движения — классический пример того, что получается когда Train, Public / Private — это различные распределения, и тут помогут либо удача, либо правильный механизм cross validation: под этим я понимаю не то, что пишут в книжках вроде «разделите на 5 statified fold и все нормально», а про то, что на пару порядков замысловатее. Например, есть методика в соревновательном машинном обучении, которая объясняет как выбирать правильный random seed при разбиении на фолды так, чтобы у ваших моделей была выше способность к предсказаниям на тех данных, что ваша модель еще не видела.
Но тем не менее, вся эта движуха — это все равно странно. Да, коллектив оверфитил Public LB в надежде на то, что точность модели на Private будет такая же. И по идее, так и надо было делать. Вот просто потому, что в train — 25 картинок, а в Public — 19% от 425, то есть 80. А 80 — это гораздо больше, чем любой hold out, что вы можете откусить от train. Вера в то, что точность на 80 картинках Public будет похожа на 397 картинок в Private если не железобетонная, но вполне себе логичная.
А вот что получилось на самом деле. После окончания соревнования админы признались, что по факту было размечено только 57 изображений. Есть гипотеза, что изначально у британских военных было 450 картинок, они наняли индусов размечать данные, и кто-то на форуме даже публиковал ссылку на объявление об этой работе. Те успели разметить только 57 картинок. Но так как соревнование надо начинать, то сделали ход конем — 25 картинок в Train, 6 в Public, 26 в Private и 397 для шуму. То есть предсказания на этих 397 картинках мы делали, но они не учитывались. Такой фокус делают достаточно часто, чтобы предотвратить ручную разметку, но обычно об этом объявляют до начала соревнований, а не после. И чатик снова бурлил, стонал и матерился.
Закругляясь, скажу, что лично мне хотелось нахвататься знаний про применение нейронных сетей для сегментации изображений. Тут и статьи по DL, и туториалы по OpenCV, все это воплощено в коде, плюс была написана инфраструктура, которая может быть использована под любую другую задачу сегментации.
У меня появился доступ к коллективу очень умных людей, которые могут и хотят рубить злые проблемы в машинном обучении. Последние два года, после регистрации на Kaggle, я пытался сагитировать одногруппников в аспирантуре, коллег на работе, даже стал соучредителем meetup group San Francisco Kagglers, но все безуспешно. И тут карта легла. И это очень-очень важно.
За третье место меня подняло в Kaggle рейтинге аж до 67 места из 55000, что, будем надеяться, чуть поможет с поиском Deep Learning ориентированной работы, да и деньги, которые мы, кстати, пока так и не получили, являются приятным бонусом.
Что не получилось: работу, напрямую связянную с DL, я пока так и не нашел, хотя я в процессе с парой компаний. Но быть в процессе и получить оффер — это совсем не одно и то же. Два параллельных соревнования про рыбок (приз 150k) и про рак легких (приз миллион долларов) прошли мимо меня, то есть ни знаний, ни денег с этих задач я тоже не получил. Но это все мелочи, на фоне того, что я разобрался с задачами сегментации всего чего можно как классическими методами, так и через Deep Learning.
Что получили британские военные: они получили Proof Of Concept, что делать разметку по спутниковым снимкам можно, и что соревнования — это дешевый вариант поиметь алгоритмы за маленькие деньги, плюc немного PR.
Как я уже упоминал, они даже запилили [свою версию Kaggle](https://www.datasciencechallenge.org/), и даже запустили там пару соревнований, и одно из них про идентификацию машинок на спутниковых снимках. Правда, так как на уровне Британского правительства Граждане России считаются людьми второго сорта, на приз претендовать мы не можем, китайцы, правда, тоже.
Насколько предложенные нами решения далеки от production?
В том виде, в котором они есть сейчас, в production пускать, наверно, не стоит, хотя если добавить данных, нанять специалистов по DL, дотренировать, докрутить эвристик, то можно получить более чем достойные результаты. Но вот прямо сейчас Британские ракеты по нашим предсказаниям наводить, наверно, не стоит, так что Нигерия может спать спокойно.
Наш блог пост на Kaggle (за него вроде обещают дать футболку с надписью Kaggle). Он по английски, в нем меньше динамики, но чуть больше технических деталей — [ссылка](http://blog.kaggle.com/2017/05/09/dstl-satellite-imagery-competition-3rd-place-winners-interview-vladimir-sergey/).
Для тех, кто, таки добрался до этой части текста и ему все еще мало, вот [ссылка на видео](https://www.youtube.com/watch?v=3oG_OqOpHlw&feature=youtu.be&t=58m23s) с выступления Артура в Yandex про свое решение этой задачи плюс [его пост на хабре](https://habrahabr.ru/company/avito/blog/325632/).
В дополнение видео от [Романа](https://www.kaggle.com/zfturbo) (у него профессиональная деформация интересные визуализации делать.)
Ну и напоследок хочется сказать отдельное спасибо всем тем, с кем мы долго и упорно обсуждали эту задачу, что и позволило добраться до топа. Отмечаются в лучшую сторону: [Сергей Мушинский](https://www.kaggle.com/ceperaang), [Артур Кузин](https://www.kaggle.com/drn01z3), [Константин Лопухин](https://www.kaggle.com/lopuhin), [Андрей Стромнов](https://www.kaggle.com/stromnov), [Роман Соловьев](https://www.kaggle.com/zfturbo), [Александр Мовчан](https://www.kaggle.com/movchan), [Артем Янков](https://www.kaggle.com/yankov), [Евгений Нижбицкий](https://www.kaggle.com/nizhibitsky), [Владимир Осин](https://www.kaggle.com/resolut), [Алексей Носков](https://www.kaggle.com/alexeynoskov), [Алексей Романов](https://www.kaggle.com/jgc128), [Михаил Каменщиков](https://www.kaggle.com/greenwolf), [Расим Ахунзянов](https://www.kaggle.com/rasimakhunzyanov), [Глеб Филатов](https://www.kaggle.com/velikolepno), [Егор Панфилов](https://www.kaggle.com/panfilov).
Отдельное спасибо Насте [bauchgefuehl](https://habr.com/ru/users/bauchgefuehl/) за редактирование. | https://habr.com/ru/post/325096/ | null | ru | null |
# Разработка приложений на Elixir/Phoenix с помощью Docker
Под катом небольшое и простое руководство, в котором показано, как использовать Docker Compose для настройки и запуска приложения Elixir/Phoenix + PostgreSQL.
Подготовка
----------
Создаем пустой каталог и переходим в него:
```
mkdir && cd
```
Создаем **Dockerfile** и наполняем содержимым.
**/dockerfile**
```
FROM elixir:latest
RUN apt-get update -qq && apt-get install -y libpq-dev && apt-get install -y build-essential inotify-tools erlang-dev erlang-parsetools apt-transport-https ca-certificates && apt-get update && curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - && echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list && apt-get update && apt-get install --no-install-recommends yarn
RUN mix local.hex --force && mix local.rebar --force
RUN mix archive.install hex phx_new 1.4.0 --force
RUN curl -sL https://deb.nodesource.com/setup_11.x | bash - && apt-get install -y nodejs
WORKDIR /home/app
```
Создаем **docker-compose.yml** и наполняем содержимым.
**/docker-compose.yml**
```
version: '3'
services:
web:
build: .
command: mix phx.server
volumes:
- .:/home/app
ports:
- "4000:4000"
links:
- db
depends_on:
- db
test:
image: \_web
command: mix test
environment:
MIX\_ENV: test
PORT: 4001
volumes:
- .:/home/app
db:
image: postgres:latest
ports:
- '5432:5432'
environment:
POSTGRES\_USER:
POSTGRES\_PASSWORD:
```
Создание проекта
----------------
Генерируем новое приложение, используя docker-compose, где — имя приложения:
```
docker-compose run web mix phx.new . --app
```
Если вы используете Docker в Linux, то созданные файлы принадлежат root, так как контейнер запускается от его имени. Чтобы избежать трудностей в дальнейшем, нужно поменять владельца:
```
sudo chown -R $USER:$USER .
```
Подключение к базе данных
-------------------------
Для подключения к базе данных в настройках нашего приложения необходимо изменить два файла:
**/config/dev.exs**
```
# Configure your database
config :, .Repo,
username: ,
password: ,
database: \_dev,
hostname: "db",
pool\_size: 10
```
**/config/test.exs**
```
# Configure your database
config :, .Repo,
username: ,
password: ,
database: \_test,
hostname: "db",
pool\_size: 10
```
После того как настройки откорректированы, создаем базу для каждого окружения:
```
docker-compose run web mix ecto.create
```
```
docker-compose run test mix ecto.create
```
Запуск приложения
-----------------
Ну и осталось только запустить наше приложение:
```
docker-compose up -d
```
Вот и все. Теперь наше приложение доступно по адресу <http://127.0.0.1:4000>.
Тесты
-----
И в концовке про тестирование.
Для того, чтобы выполнить все тесты, нужно выполнить:
```
docker-compose run test
```
Чтобы выполнить конкретный тест:
```
docker-compose run test mix test test/\_web/controllers/page\_controller\_test.exs
```
На этом все, всем добра! | https://habr.com/ru/post/439718/ | null | ru | null |
# Слово на букву «М», или Монады уже здесь
Про монаду ходит множество мемов и легенд. Говорят, что каждый уважающий себя программист в ходе своего функционального возмужания должен написать хотя бы один туториал про монаду — недаром на сайте языка Haskell даже ведётся [специальный таймлайн](https://www.haskell.org/haskellwiki/Monad_tutorials_timeline) для всех отважных попыток приручить этого таинственного зверя. Бывалые разработчики поговаривают также и о [проклятии монад](http://www.infoq.com/presentations/functional-pros-cons) — мол, каждый, кто постигнет суть этого чудовища, начисто теряет способность кому-либо увиденное объяснить. Одни для этого [вооружаются теорией категорий](http://www.stephendiehl.com/posts/monads.html), другие [надевают космические костюмы](http://web.archive.org/web/20081206204420/http://www.loria.fr/~kow/monads/index.html), но, видимо, единого способа подобраться к монадам не существует, иначе каждый программист не выдумывал бы свой собственный.
Действительно, сама концепция монады неинтуитивна, ведь лежит она на таких уровнях абстракции, до которых интуиция просто не достаёт без должной тренировки и теоретической подготовки. Но так ли это важно, и нет ли другого пути? Тем более, что эти таинственные монады уже окружают многих ничего не подозревающих программистов, даже тех, кто пишет на языках, никогда не считавшихся «функциональными». Действительно, если приглядеться, то можно обнаружить, что они уже здесь, в языке Java, под самым нашим носом, хотя в документации по стандартной библиотеке слово «монада» мы едва ли найдём.
Именно поэтому важно если не постичь глубинную суть этого паттерна, то хотя бы научиться распознавать примеры использования монады в уже существующих, окружающих нас API. Конкретный пример всегда даёт больше, чем тысяча абстракций или сравнений. Именно такому подходу и посвящена эта статья. В ней не будет теории категорий, да и вообще какой-либо теории. Не будет оторванных от кода сравнений с объектами реального мира. Я просто приведу несколько примеров того, как монады уже используются в знакомом нам API, и постараюсь дать читателям возможность уловить основные признаки этого паттерна. В основном в статье пойдёт речь о Java, и ближе к концу, чтобы вырваться из мира legacy-ограничений, мы немного коснёмся Scala.
#### Проблема: потенциальное отсутствие объекта
Посмотрим на такую строчку Java-кода:
```
return employee.getPerson().getAddress().getStreet();
```
Если предположить, что она в своём контексте нормально компилируется, опытный глаз всё равно заметит здесь серьёзную проблему — любой из возвращаемых объектов в цепочке вызовов может отсутствовать (метод вернёт null), и тогда при выполнении этого кода будет выброшен безжалостный NullPointerException. К счастью, мы всегда можем завернуть эту строчку в кучу проверок, например, так:
```
if (employee != null
&& employee.getPerson() != null
&& employee.getPerson().getAddress() != null) {
return employee.getPerson().getAddress().getStreet();
} else {
return "<неизвестно>";
}
```
Выглядит и само по себе не очень, а композируется с другим кодом и того хуже. А главное, если забыть хоть одну проверку, можно получить исключение во время выполнения. Всё потому, что информация о потенциальном отсутствии объекта никак не зафиксирована в типах, и компилятор не спасёт нас от ошибки. Но ведь мы всего лишь хотели выполнить три простых последовательных действия — у сотрудника взять персону, у персоны — адрес, у адреса — улицу. Вроде бы задача простая, а код раздулся от вспомогательных проверок и стал неудобочитаемым.
К счастью, в Java 8 появился тип [java.util.Optional](https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html). В нём есть много интересных методов, но мы поговорим вот об этих:
```
public class Optional {
public static Optional ofNullable(T value) { }
public Optional map(Function super T, ? extends U mapper) { }
public Optional flatMap(Function super T, Optional<U> mapper) { }
}
```
Optional можно рассматривать как контейнер, содержащий либо один элемент, либо ничего. Если вызвать у этого контейнера метод map и передать туда анонимную функцию (лямбду) или ссылку на метод, то map применит эту функцию к находящемуся внутри Optional объекту и вернёт результат, также завернув его в Optional. Если же объекта внутри не окажется — то map просто вернёт опять-таки пустой контейнер Optional, но с другим типовым параметром.
Метод flatMap позволяет делать то же, что и метод map, но он принимает функции, которые сами возвращают Optional — тогда результат применения этих функций не будет дополнительно заворачиваться в Optional, и мы избежим двойной вложенности.
Такой интерфейс Optional позволяет выстраивать вызовы в цепочки, например, следующим образом:
```
return Optional.ofNullable(employee)
.map(Employee::getPerson)
.map(Person::getAddress)
.map(Address::getStreet)
.orElse("<неизвестно>");
```
Выглядит чуть компактнее, чем в предыдущем примере. Но плюсы на этом не заканчиваются. Во-первых, мы убрали из кода всю шелуху, не относящуюся к делу — мы выполнили несколько простых действий с объектом employee, описав их в коде явно и без лишнего вспомогательного кода. Во-вторых, мы можем быть уверены в отсутствии NPE, если где-то на пути этой цепочки встретится null-значение — Optional уберегает нас от этого. В-третьих, полученная конструкция является выражением (а не утверждением, как конструкция if из предыдущего примера), а значит, возвращает значение — следовательно, её значительно легче композировать с другим кодом.
Итого, как же мы решили проблему потенциального отсутствия объекта с помощью типа Optional?
1. Обозначили явно проблему в типе объекта (Optional).
2. Спрятали весь вспомогательный код (проверка на отсутствие объекта) внутрь этого типа.
3. Передали типу набор простых стыкующихся действий.
Что здесь понимается под «стыкующимися действиями»? А вот что: метод Person::getAddress принимает на вход объект типа Person, полученный как результат предыдущего метода Employee::getPerson. Ну а метод Address::getStreet, соответственно, принимает результат предыдущего действия — вызова метода Person::getAddress.
А теперь — главное: Optional в Java — это не что иное, как реализация паттерна монады.
#### Проблема: итерация
Со всем синтаксическим сахаром, появившимся в Java за последние годы, это, казалось бы, уже и не проблема. Однако посмотрим на такой код:
```
List employeeNames = new ArrayList<>();
for (Company company : companies) {
for (Department department : company.getDepartments()) {
for (Employee employee : department.getEmployees()) {
employeeNames.add(employee.getName());
}
}
}
```
Здесь мы хотим собрать имена всех сотрудников всех отделов и всех компаний в единый список. В принципе, код выглядит не так плохо, хотя процедурный стиль модификации списка employeeNames заставит поморщиться любого функционального программиста. Кроме того, код состоит из нескольких вложенных циклов перебора, которые явно избыточны — с помощью них мы описываем механизм итерации по коллекции, хотя нам он по большому счёту неинтересен, мы просто хотим собрать всех людей изо всех отделов всех компаний и получить их имена.
В Java 8 появился целый новый API, позволяющий более удобно работать с коллекциями. Основным интерфейсом этого API является интерфейс [java.util.stream.Stream](https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html), содержащий в себе, в числе прочего, методы, которые могут показаться знакомыми из предыдущего примера:
```
public interface Stream extends BaseStream> {
Stream map(Function super T, ? extends R mapper);
Stream flatMap(Function super T, ? extends Stream<? extends R> mapper);
}
```
Действительно, метод map, как и в случае с Optional, принимает на вход функцию, трансформирующую объект, применяет её ко всем элементам коллекции, а возвращает очередной Stream из полученных трансформированных объектов. Метод flatMap принимает функцию, которая сама по себе возвращает Stream, и сливает все полученные при преобразовании потоки в единый Stream.
С использованием Streams API код итерации можно переписать вот так:
```
List streamEmployeeNames = companies.stream()
.flatMap(Company::getDepartmentsStream)
.flatMap(Department::getEmployeesStream)
.map(Employee::getName)
.collect(toList());
```
Здесь мы немного схитрили, чтобы обойти ограничения Streams API в Java — к сожалению, они не замещают собой существующие коллекции, а являются целой параллельной вселенной функциональных коллекций, порталом в которую является метод stream(). Поэтому каждую полученную в ходе обработки данных коллекцию мы должны ручками проводить в эту вселенную. Для этого мы добавили в классы Company и Department геттеры для коллекций, которые сразу преобразуют их в объекты типа Stream:
```
static class Company {
private List departments;
public Stream getDepartmentsStream() {
return departments.stream();
}
```
Решение если и выглядит более компактным, то ненамного, но плюсы его не только в этом. По сути это альтернативный механизм работы с коллекциями, более компактный, типобезопасный, композируемый, и достоинства его начинают вскрываться по мере увеличения объёма и сложности кода.
Итак, использованный подход к решению проблемы итерации по элементам коллекций вновь можно сформулировать в виде нескольких уже знакомых нам утверждений:
1. Обозначили явно проблему в типе объекта (Stream).
2. Спрятали весь вспомогательный код (итерация по элементам и вызов переданной функции над ними) внутрь этого типа.
3. Передали объекту этого типа набор простых стыкующихся действий.
Подытожим: интерфейс Stream в Java — это реализация паттерна монады.
#### Проблема: асинхронные вычисления
Из того, что до сих пор было сказано, может сложиться впечатление, что паттерн монады предполагает наличие какой-то обёртки над объектом (объектами), в которую можно накидывать функции, преобразующие эти объекты, а весь скучный и ненужный код, связанный с применением этих функций, обработкой потенциальных ошибок, механизмами обхода — описать внутри обёртки. Но на самом деле применимость монады ещё шире. Рассмотрим проблему асинхронных вычислений:
```
Thread thread1 = new Thread(() -> {
String string = "Hello" + " world";
});
Thread thread2 = new Thread(() -> {
int count = "Hello world".length();
});
```
У нас есть два отдельных потока, в которых мы хотим выполнить вычисления, причём вычисления в потоке thread2 должны производиться над результатом вычислений в потоке thread1. Я даже не буду пытаться привести здесь код синхронизации потоков, который заставит эту конструкцию работать — кода будет много, а главное, он будет плохо композироваться, когда таких блоков вычислений будет множество. А ведь мы хотели всего лишь выполнить последовательно друг за другом два простых действия — но асинхронность их выполнения путает нам все карты.
Чтобы побороть излишнюю сложность, ещё в Java 5 появились футуры (Future), позволяющие организовывать блоки многопоточных вычислений в цепочки. К сожалению, в классе [java.util.concurrent.Future](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Future.html) мы не найдём знакомых нам методов map и flatMap — он не реализует монадический паттерн (хотя его реализация [CompletableFuture](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html) подбирается к этому достаточно близко). Поэтому здесь мы опять немного схитрим и выйдем за пределы Java, а попытку представить, как бы выглядел интерфейс Future, появись он в Java 8, оставим в качестве домашнего задания читателям. Рассмотрим интерфейс трейта [scala.concurrent.Future](http://www.scala-lang.org/api/2.11.7/#scala.concurrent.Future) в стандартной библиотеке языка Scala (сигнатура методов несколько упрощена):
```
trait Future[+T] extends Awaitable[T] {
def map[S](f: T => S): Future[S]
def flatMap[S](f: T => Future[S]): Future[S]
}
```
Если приглядеться, методы очень знакомые. Метод map применяет переданную функцию к результату выполнения футуры — когда этот результат будет доступен. Ну а метод flatMap применяет функцию, которая сама возвращает футуру — таким образом, эти две футуры можно объединить в цепочку с помощью flatMap:
```
val f1 = Future {
"Hello" + " world"
}
val f2 = { s: String =>
Future {
s.length()
}
}
Await.ready(
f1.flatMap(f2)
.map(println),
5.seconds
)
```
Итак, как же мы решили проблему выполнения асинхронных взаимозависимых блоков вычислений?
1. Обозначили явно проблему в типе объекта (Future[String]).
2. Спрятали весь вспомогательный код (вызов следующей по цепочке футуры по окончании предыдущей) внутрь этого типа.
3. Передали объекту этого типа набор простых стыкующихся действий (футура f2 принимает объект такого типа (String), который возвращает футура f1).
Можно резюмировать, что Future в Scala также реализует паттерн монады.
#### Итоги
Монада — это паттерн функционального программирования, позволяющий легко и без побочных эффектов композировать (выстраивать в цепочки) действия, которые в противном случае могли бы быть разделены тоннами небезопасного вспомогательного кода. Кроме приведённых примеров, в функциональных языках монады используются для обработки исключительных ситуаций, работы с вводом-выводом, базами данных, состоянием и много где ещё. Паттерн монады реализуем на любом языке, в котором функции являются объектами первого класса (их можно рассматривать как значения, передавать в качестве аргументов и т.д.), и даже в Java он уже кое-где попадается — хотя местами его реализация и оставляет желать лучшего.
Для более глубокого погружения в тему рекомендую следующие ресурсы:
* [Scala Monads: Declutter your code with monadic design](https://www.youtube.com/watch?v=Mw_Jnn_Y5iA)
* [Brian Beckman: Don’t Fear the Monad](https://www.youtube.com/watch?v=ZhuHCtR3xq8)
* [Mario Fusco. Monadic Java](http://www.slideshare.net/mariofusco/monadic-java) | https://habr.com/ru/post/262055/ | null | ru | null |
# Стоит ли Typescript усилий?
Typescript — это скриптовый язык, компилируемый в JavaScript. Разработка Microsoft, которая, на сегодняшний день, успела завоевать и фанатов и недоброжелателей. Главный вопрос для начинающих, и не только: «Зачем он мне нужен?».
Поскольку статей, описывающих достоинства и недостатки, описание языка и примеры работы — валом, я хотел бы описать практические выводы при работе в достаточно крупном приложении.
Начнем с основных плюсов:
1. Строгая типизация
2. Читабельность кода
3. Более легкий переход из мира строгой типизации, нежели на JavaScript напрямую, в котором правит бал Динамика
4. Обратная совместимость с JavaScript
5. Широкая поддержка IDE
### Строгая типизация
Позволяет более полно описывать свойства и методы обьектов и классов, из-за чего пропадает необходимость, которая, лично меня, дико раздражала, делать проверку всех, входящих в метод или функцию, аргументов:
```
function checkAllMyArgsAgain(check, me, please) {
if(check && me && please) {
if(check instanceof CheckObject){
console.log('Урааааа!');
} else {
console.log('И снова исключение...')
}
if(me){ } // И так далее.......
}
}
```
В любом случае, TypeScript сильно упрощает этот процесс:
```
function checkAllMyArgsAgain(check: CheckObject, me: MeObject, please: string): string {
return 'Какая проверка аргументов? Вы о чем? ';
}
```
И мы плавно перейдем ко второму пункту, которому первый сильно способствует:
### Читабельность кода
Из примера выше, очевидно, что читать код на TypeScript будет проще, ввиду отсутствия нагромождений кода, характерные Javascript.
Можно представить, во что превратится код, написанный на JavaScript, спустя какое-то время…
```
function checkMe(check, me) {
if(check && me) {
if(check){ ... }
if(me){ ... }
}
}
function andCheckMe(check, me) {
if(check && me) {
if(check){ ... }
if(me){ ... }
}
}
function andCheckMeToo(check, me) {
if(check && me) {
if(check){ ... }
if(me){ ... }
}
}
```
Против:
```
function checkMe(check: CheckObject, me: MeObject) {
console.log('Ну круто же!');
}
function andCheckMe(check: CheckObject, me: MeObject) {
console.log('Просто песня');
}
function andCheckMeToo(check: CheckObject, me: MeObject) {
console.log('Писать легко и с удовольствием');
}
```
В некоторых случаях, в JS, можно уменьшить ущерб путем абстракций, но в целом, TS сильно впереди по данному вопросу.
### Более легкий переход в мир JS из мира статики
Многие проявляют интерес к JS, но их отпугивает некая хаотичность и непредсказуемость языка. Здесь Вам сильно поможет TS, который позволяет писать JS, более привычным и понятным путем.
### Обратная совместимость с JS
И это, таки, приятный бонус, потому как не придется переписывать весь существующий код, чтобы поиграться с TS и написать лишь часть приложения на нем + есть возможность перенести все любимые библиотеки с JS на TS, если будет такая необходимость.
### Широкая поддержка IDE
TypeScript, на данный момент, имеет поддержку в любой популярной IDE, включая IDEA, WebStorm, Sublime, Atom, и так далее. Соответственно, менять любимую среду разработки не придется.
Теперь опишем основные минусы:
1. Строгая типизация
2. Компилятор
3. Debug
4. А вдруг помрет?
### Строгая типизация
Этот пункт работает как во благо, так и во вред, потому что необходимо описывать все типы для всех обьектов, классов, переменных, и иже с ними, что было не свойственно JavaScript ранее.
Но куда большее зло — миграция существующих популярных JS решений на TS. Видите ли, для каждой портированной либы необходимо описать .d.ts файл, в котором и хранятся все возвращаемые типы и описание всех методов. Уверен, что портирование таких монстров, как jQuery, потребовало немало приседаний.
### Компилятор
Он существенно уменьшает вероятность «тупой» ошибки, типа пропущенных запятых и неправильно написанных имен переменных, но, также, убивает всю прелесть JS, когда большую часть решений можно было написать на коленках и проверить в консоли браузера.
Не стоит забывать, что время от времени, придется обновлять и сам компилятор, поскольку язык развивается и, рано или поздно, появится необходимость обновить существующую версию компилятора, а, возможно, и самого кода.
### Debug
Естественно, любому разработчику необходимо понимать, как, быстро и эффективно, проверять код на ошибки, ловить и исправлять баги. И, первым делом, надо разобраться, как это процесс наладить в TypeScript. Существует множество гайдов для различных IDE: [WebStorm](https://www.google.de/webhp?sourceid=chrome-instant&ion=1&espv=2&ie=UTF-8#q=typescript%20debugging) и [Visual Studio](https://blogs.msdn.microsoft.com/jtarquino/2016/01/24/debugging-typescript-in-visual-studio-code-and-chrome/) о том, как все это дело настроить в редакторах кода и эффективно работать, но с JS этого делать не надо было, потому как, можно было запустить код, наставить точек останова внутри редактора или браузера и спокойно дебажить. С TS придется немного попотеть.
### А вдруг помрет?
Это интересный и серьёзный вопрос, потому как стандарты JS идут в ногу со временем и интегрируют в сам язык многое, что было полезно в TS: классы, стрелочные функции, и так далее. Рано или поздно, все полезные функции TS будет так или иначе перенесены в стандарт языка и TS повесит бутсы на гвоздь. А если ребята из Microsoft решат, что им это не нужно и полностью оставят TS на волю open-source? Понятно, что являясь открытым продуктом, TS не лишиться поддержки совсем — всегда найдутся энтузиасты, но поддержка такого гиганта, как Microsoft, никогда не помешает.
Опять же сам Microsoft, как основного разработчика, многие относят к минусу, потому как репутация у гиганта весьма спорная: Skype, Nokia, Windows Phone, Windows Vista, и так далее.
Надеюсь, что помог кому-то с решением о данном вопросе, либо же заставил задуматься о целесообразности перехода.
Всем спасибо, все свободны! | https://habr.com/ru/post/308374/ | null | ru | null |
# Форматирование милли/микро/нано секунд в java.sql.Timestamp
В JVM 1.8 отсутствует удобный и простой в использовании класс форматирования класса **java.sql.Timestamp** с микро и нано секундами. Есть специализированный пакет **java.time** с достаточно разнообразной функциональностью. Но его использование для преобразования типа **java.sql.Timestamp** в строку и из строки в тип выглядит как то сложновато. Хотелось иметь простой способ преобразования с функциональностью класса **java.text.SimpleDateFormat.**
Конечно есть множество советов и вариантов решения этих преобразований в интернет, но все они меня как то не устроили по разным причинам. Повозившись и помучавшись с поиском решения, решил написать свой класс, при этом реализовывать весь разбор строки и форматирование в строку совсем не хотелось. Решил наследовать свой класс от одного из существующих классов, переопределив поведение только интересуемой меня функциональности. Но и здесь меня ждало большое разочарование из-за ограничения зон видимости полей, методов и используемых классов в классах, от которых я пробовал наследоваться. .
Хочешь не хочешь, но надо все же писать полностью свой класс, но писать то все с нуля не хочется. И тут мне в голову пришла идея, раз нельзя наследоваться от класса java.text.SimpleDateFormat, но использовать-то его можно же. Идея реализации простая - форматировать и разбирать милли/микро/нано секунды отдельно. Сказано - сделано.
```
package ru.funsys.util;
import java.sql.Timestamp;
import java.text.MessageFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Locale;
/**
* Класс форматирования класса Timestamp c милли/микро/нано секундами
*
* @author Валерий Лиховских
*
*/
public class TimestampFormatter {
/**
* строка форматирования даты и времени. Формируется из исходной строки шаблона форматирования
*/
private String format;
/**
* строка форматирования, используемая для парсинга. Формируется из исходной строки шаблона форматирования
*/
private String parse;
/**
* местоположения в строке шаблона форматирования милли/микро/нано секунд. Формируется из исходной строки шаблона форматирования
*/
private int first;
/**
* разрядность после запятой милли/микро/нано секунд, вычисляется по строке шаблона форматирования
*/
private int size;
/**
* Объект локализации
*/
private Locale locale;
/**
* строка шаблона форматирования по умолчанию
*/
public static final String DEFAULT_DATETIME_PATTERN = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXX"; //$NON-NLS-1$
/**
* символ шаблона форматирования милли/микро/нано секунд
*/
public static final char CHAR_S = 'S'; //$NON-NLS-1$
/**
* символ экранирование - одиночный штрих (кавычка)
*/
public static final char CHAR_PRIME = '\''; //$NON-NLS-1$
public TimestampFormatter() {
this(DEFAULT_DATETIME_PATTERN, Locale.getDefault());
}
/**
* @param pattern строка шаблона форматирования по умолчанию
*/
public TimestampFormatter(String pattern) {
this(pattern, Locale.getDefault());
}
/**
* @param pattern строка шаблона форматирования по умолчанию
* @param locale объект локализации
*/
public TimestampFormatter(String pattern, Locale locale) {
first = pattern.indexOf(CHAR_S);
if (first != -1) {
String datetime = pattern.substring(0, first);
int last = pattern.lastIndexOf(CHAR_S) + 1;
if (last > 0 && last < pattern.length()) {
format = datetime + "'{0}'" + pattern.substring(last); // {0} - для милли/микро/нано секунд
parse = datetime + pattern.substring(last);
size = last - first;
} else {
format = datetime + "'{0}'"; // {0} - для милли/микро/нано секунд
parse = datetime;
size = pattern.length() - first;
}
} else {
this.format = pattern;
this.parse = pattern;
size = 0;
}
this.locale = locale;
// Исключить смещение позиции наносекунд из разбираемой строке символа '
int pos = pattern.indexOf(CHAR_PRIME); // текущая позиция символа
while (pos != -1) {
first--;
pos++; // искать следующий символ с позиции
if (pos < pattern.length()) pos = pattern.indexOf(CHAR_PRIME, pos);
else pos = -1;
}
// first теперь имеет значения начала позиции милли/микро/нано секунд в получаемой строке для парсинга
}
/**
* Форматировать Timestamp
*
* @param timestamp значение форматирования
*
* @return строковое представление Timestamp
*/
public String format(Timestamp timestamp) {
String nanos;
if (size == 0) nanos = "";
else nanos = Integer.toString(timestamp.getNanos() + 1000000000).substring(1, 1 + size);
return MessageFormat.format(new SimpleDateFormat(format, locale).format(timestamp), nanos);
}
/**
* Парсить строковое представление Timestamp
*
* @param source строка парсинга
*
* @return результат преобразования в Timestamp
*
* @throws ParseException ошибка форматирования
*/
public Timestamp parse(String source) throws ParseException {
StringBuffer tmpSource = new StringBuffer().append(source.substring(0, first));
if (size > 0) {
tmpSource.append(source.substring(first + size));
}
Timestamp timestamp = new Timestamp(new SimpleDateFormat(parse, locale).parse(tmpSource.toString()).getTime());
if (size > 0) {
int tmpNamo = Integer.parseInt(source.substring(first, first + size));
for (int index = size; index < 9; index++) {
tmpNamo = tmpNamo * 10;
}
timestamp.setNanos(tmpNamo);
}
return timestamp;
}
}
```
В результате получился компактный класс по своей функциональности сопоставимый с классом java.text.SimpleDateFormat. И самое главное, простой в использовании.
```
public static void main(String[] args) {
Timestamp t = new Timestamp(System.currentTimeMillis());
t.setNanos(345012000); // устанавливать наносекунды
TimestampFormatter f = new TimestampFormatter();
String s = f.format(t);
System.out.println(s);
try {
// обратное преобразование для проверки
Timestamp n = f.parse(s);
System.out.println(f.format(n));
} catch (Exception e) {
e.printStackTrace();
}
}
```
Результат
```
2022-11-18T09:20:35.345012+03:00
2022-11-18T09:20:35.345012+03:00
```
Дальнейшее использование этого класса, думаю, затруднений не вызовет. | https://habr.com/ru/post/700148/ | null | ru | null |
# Как собрать акустический левитатор. Инструкция с фотографиями
[](https://habr.com/ru/company/skillfactory/blog/693324/)
Чаще всего движущая сила левитации — это магниты. Но почему не что-нибудь другое? Например, звук, встречные волны которого заставляют небольшой предмет зависнуть в воздухе. Эта работа — моя курсовая по «принципам инженерного дела». Благодарю за помощь миссис Бёрбави [Ms. Berbawy](https://berbawymakers.com/) и моих однокурсников. Материалом делимся к старту [курса по разработке на C++](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_171022&utm_term=lead).
Материалы
---------
**Материалы**
* [Arduino Nano](https://www.amazon.com/ATmega328P-Microcontroller-Board-Cable-Arduino/dp/B00NLAMS9C).
* [Программное обеспечение для Arduino Nano](https://www.arduino.cc/en/software).
* [Ультразвуковые датчики](https://www.amazon.com/SainSmart-HC-SR04-Ranging-Detector-Distance/dp/B004U8TOE6/ref=sr_1_5?dchild=1&keywords=Ultrasonic+distance+sensors%2C+HC-SR04+type+%282%29&qid=1633545319&s=electronics&sr=1-5).
* [Батарея на 9В](https://www.amazon.com/Duracell-Coppertop-Alkaline-Batteries-Count/dp/B0014D0SL8/ref=sxin_15_ac_d_rm?ac_md=1-1-OXYgYmF0dGVyeSAyIHBhY2s%3D-ac_d_rm_rm_rm&cv_ct_cx=9v+battery&dchild=1&keywords=9v+battery&pd_rd_i=B0014D0SL8&pd_rd_r=f887491f-d81f-4786-bfd7-104d9adc5072&pd_rd_w=iTbs1&pd_rd_wg=octoq&pf_rd_p=c41d1f6c-956c-4fe2-8019-1663b7e1dd23&pf_rd_r=2WTGZVYEJ108QS7ZR0GF&psc=1&qid=1633565870&sr=1-2-12d4272d-8adb-4121-8624-135149aa9081).
* [Батарейный отсек](https://www.amazon.com/s?k=9+Volt+Battery+Case&crid=1YX92KKRE5FO4&sprefix=9+volt+battery+case%2Caps%2C100&ref=nb_sb_noss_1).
* [Гибкие кабели](https://www.amazon.com/GenBasic-Solderless-Dupont-Compatible-Breadboard-Prototyping/dp/B01L5UJ36U/ref=sr_1_3?crid=3VRDAZ2KHM3D8&dchild=1&keywords=jumper+wires+male+to+male&qid=1633547142&sprefix=jumper+wires+male%2Caps%2C204&sr=8-3).
* [Тестовая макетная плата](https://www.sparkfun.com/products/12615).
* [Шарики из пенополистирола](https://www.amazon.com/Styrofoam-Balls-Polystyrene-Floral-2300ml/dp/B087284VNT/ref=sr_1_10?dchild=1&keywords=styrofoam+beads&qid=1633565406&sr=8-10).
* [Микросхема L298N.](https://www.amazon.com/Qunqi-Controller-Module-Stepper-Arduino/dp/B014KMHSW6).
* [Перфорированная макетная плата 2 1/2” x 3 1/8”](https://www.allelectronics.com/item/pc-3/2-1/2-x-3-1/8-solderable-perf-board/1.html) (не использовал её в своем проекте, но она может послужить заменой макетной платы).
* Прямая трубка из ПВХ 1/2” (Продаётся в строительных и хозяйственных магазинах вроде Leroy Merlin). [прим. перев. — Home Depot и Lowes не работают в России.
* 2 колена на 90°.
* 1 колено на 90° с внутренней резьбой.
* Тройник для соединения трубок.
* Fusion 360 или другая САПР.
* Доступ к 3D-принтеру (резать древисину или акрил можно лазерами).
* Паяльник и припойная проволока.
* Дополнительные инструменты, например, пассатижи, маркеры, линейки, пинцет, зубочистки и разогреваемый клей.
* «Третья рука» (блок фиксаторов).
Шаг 1. Разбираем датчик расстояния
----------------------------------
[](https://habrastorage.org/webt/cb/tz/b5/cbtzb5ucir8aj6h_mvwannxn6-0.jpeg)
[](https://content.instructables.com/ORIG/F7V/U728/L2RLCXE9/F7VU728L2RLCXE9.jpg?auto=webp&frame=1&width=1024&fit=bounds&md=06008f65907a5591e9a9a0bc90ed4985)
[](https://content.instructables.com/ORIG/FWL/4FNB/L2RLCXEA/FWL4FNBL2RLCXEA.jpg?auto=webp&frame=1&width=1024&fit=bounds&md=edfb09e947e3034e015a018cf4b3f467)
Для начала переделаем ультразвуковые датчики расстояния, отсоединив передатчики (с маркировкой «Т») и вынув всю «внутрянку». У каждой платы один излучатель, поэтому для шага их понадобится две. Контакты излучателей нужно выпаять из печатной платы.
Как только вы отделили их, отделите элемент и сетку от металлического корпуса. После снятия сетки верните элемент в корпус. Снятая сетка нам ещё пригодится.
Шаг 2. Программируем Arduino
----------------------------
Перейдём к коду. Начнём с его выгрузки на Arduino Nano в ПО, которое поставляется с Arduino. Спасибо Ульриху Шмерольду с Makezine за толковые [инструкции](https://makezine.com/projects/micro-ultrasonic-levitator/).
```
byte TP = 0b10101010; // Every other port receives the inverted signal
void setup() {
DDRC = 0b11111111; // Set all analog ports to be outputs
// Initialize Timer1
noInterrupts(); // Disable interrupts
TCCR1A = 0;
TCCR1B = 0;
TCNT1 = 0;
OCR1A = 200; // Set compare register (16MHz / 200 = 80kHz square wave -> 40kHz full wave)
TCCR1B |= (1 << WGM12); // CTC mode
TCCR1B |= (1 << CS10); // Set prescaler to 1 ==> no prescaling
TIMSK1 |= (1 << OCIE1A); // Enable compare timer interrupt
interrupts(); // Enable interrupts
}
ISR(TIMER1_COMPA_vect) {
PORTC = TP; // Send the value of TP to the outputs
TP = ~TP; // Invert TP for the next run
}
void loop() {
// Nothing left to do here :)
}
```
Код выше создаёт две волны 40кГц, равных по силе и противоположных по направлению. Между этими волнами и будет парить наш шарик из пенополистирола. Скомпилируем и отладим код. При отладке убедитесь, что процессорные и последовательные порты подключены правильно, у меня с этим были проблемы. Процессор выбираем по адресу Tools>Processor>ATmega328P (старый загрузчик).
Полная схема и код доступны [здесь](http://makezine.com/go/micro-ultrasonic-levitator). Ещё раз спасибо Ульриху Шмерольду.
Шаг 3. Собираем и тестируем схему
---------------------------------
[](https://habrastorage.org/webt/kl/cn/q5/klcnq5kgap8fiiknzkqofp-dlo8.jpeg)
[](https://habrastorage.org/webt/p_/db/ub/p_dbubsuca7wi7kmhc-qnbplfrm.jpeg)
[](https://content.instructables.com/ORIG/F5R/0LJP/L2T0T98Y/F5R0LJPL2T0T98Y.png?auto=webp&frame=1&width=1024&height=1024&fit=bounds&md=48a6045fd4d47fe67f9ffee2642322fb)
[](https://content.instructables.com/ORIG/FKO/FE60/L2T0T98Z/FKOFE60L2T0T98Z.png?auto=webp&frame=1&fit=bounds&md=caf87433074e03ee3e945fe8224dfa10)
[](https://content.instructables.com/ORIG/FTU/YMXY/L330VO9O/FTUYMXYL330VO9O.jpg?auto=webp&frame=1&width=1024&height=1024&fit=bounds&md=311a354ad578a41d152747dac520b0de)
[](https://content.instructables.com/ORIG/FGO/P7EH/L2T0TA0N/FGOP7EHL2T0TA0N.png?auto=webp&frame=1&fit=bounds&md=cf9ccaaff2b1449d2c8622a7771d66ca)
Соберите схему, показанную на рисунке.
После этого припаяйте провода, обозначенные на схеме буквой «Т» к передатчикам из первого шага. Обратите внимание на проводные контакты от передатчиков к микросхеме LN. Их легко упустить.
Гибкими кабелями подключите батарею к тестовой плате. Если микросхема LN и Arduino включились, электрическая цепь замкнута. Слабое жужжание датчиков тоже говорит о том, что схема работает.
Теперь нам пригодится сетка из первого шага инструкции. Наклейте её на зубочистку горячим клеем. Получится приспособление, с помощью которого мы расположим шарик между звуковыми волнами. Так гораздо удобнее, чем руками или пинцетом.
Теперь нужно немного поколдовать с положением зубочистки и расстоянием между датчиками. В этом шаге используйте зажимы или «третью руку» для удержания датчиков на месте. У меня расстояние между датчиками обычно составляло от одного до полутора сантиметров.
Шаг 4: Собираем корпус
----------------------
[](https://habrastorage.org/webt/ep/fi/0f/epfi0fmfy00d26sgnjctt8ldkx0.jpeg)
[](https://habrastorage.org/webt/ye/tz/0o/yetz0odhkjlzw8jeu3jjwr9ulsm.jpeg)
[](https://content.instructables.com/ORIG/FB3/OF2R/L2T0TBML/FB3OF2RL2T0TBML.jpg?auto=webp&frame=1&width=1024&height=1024&fit=bounds&md=ff0b24b0b0b30343ce8e954a973925be)
[](https://content.instructables.com/ORIG/F7U/LINW/L2T0TCSH/F7ULINWL2T0TCSH.jpg?auto=webp&frame=1&width=1024&height=1024&fit=bounds&md=f2009356ebbb099353c0f35c0cb2b976)
«Третья рука» не может держать нашу схему вечно. Давайте оденем схему и элементы в корпус из ПВХ. Отрежем около 7,1 см от прямой трубки, чтобы перекрыть расстояние между датчиками. Сверху установим проходное колено на 90°. Прикрепим к нему ещё одно колено на 90°. Пропустим через эти коленья верхний датчик. Внешнее колено с внутренней резьбой должно будет держать датчик. Поскольку у меня датчик неплотно прилегал к резьбе, пришлось вставлять между ними кусочки губки. Нижнее колено на 90° с резьбой прикреплено к прямой трубке тройником. Через тройник и колено продет нижний датчик. Для заполнения пустоты вокруг датчика опять пригодилась губка.
Теперь нам нужно основание, на которое будет опираться наша система. Для её создания мне понадобилась среда Fusion 360. Сверху делаем отверстие под тройник — в моём случае с допуском 0,64 см. Высота основания должна быть достаточной, чтобы вместить всю тестовую (макетную) плату. Отверстие сбоку — для проводов от батареи. У меня она расположена вне корпуса. Диаметр отверстия — 5 мм.
Шаг 5. Готово!
--------------
Если основание и корпус собраны, а все элементы уместились внутри, работа закончена. Акустический левитатор готов!
Эта курсовая мне очень понравилась, пусть и пришлось много раз плясать с бубном. Хочу ещё раз поблагодарить миссис Бёрбави, однокурсников и родителей за помощь на протяжении всей работы.
А мы научим писать на C++ и работать с данными, чтобы вы прокачали карьеру или стали востребованным IT-специалистом:
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_171022&utm_term=conc)
* [Профессия Data Analyst (12 месяцев)](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_171022&utm_term=conc)
Чтобы посмотреть все курсы, кликните по баннеру:
[](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_171022&utm_term=banner)
**Краткий каталог курсов**
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_171022&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_171022&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_171022&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_171022&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_171022&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_171022&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_171022&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_171022&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_171022&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_171022&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_171022&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_171022&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_171022&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_171022&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_171022&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_171022&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_171022&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_171022&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_171022&utm_term=cat)
* [Профессия «Белый хакер»](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_171022&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_171022&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_171022&utm_term=cat) | https://habr.com/ru/post/693324/ | null | ru | null |
# Приручаем JMeter
Сегодня я хочу рассказать о замечательном инструменте, название которого вынесено в заголовок статьи. Разумеется, моей целью не является написание подробного руководства по [Apache JMeter](http://jmeter.apache.org/). В своей статье я хочу лишь зафиксировать ряд, на мой взгляд, не очевидных моментов, с которыми мне пришлось столкнуться в своей повседневной работе. Я надеюсь, что моя статья будет полезна (сразу предупреждаю, картинок будет много).
Конечно, я не первый, кто пишет про JMeter на [Хабре](http://habrahabr.ru/search/?q=JMeter), но практически во всех предыдущих статьях, акцент делается на нагрузочное тестирование. Хотя это и основное применение JMeter, но только им его возможности не ограничиваются. Давайте, просто посмотрим, по каким протоколам может работать этот продукт:
* Web — HTTP, HTTPS
* SOAP / REST
* FTP
* Database via JDBC
* LDAP
* Message-oriented middleware (MOM) via JMS
* Mail — SMTP(S), POP3(S) and IMAP(S)
* MongoDB (NoSQL)
* Native commands or shell scripts
* TCP
Таким образом, если перед вами стоит какая-то задача автоматизации и всё, что вам требуется, перечислено в этом списке, определённо стоит подумать об использовании JMeter, перед тем как с головой погрузиться в программирование на любимом Perl, Python или Java. Возможно, такой подход позволит сэкономить очень много времени.
#### **Установка**
С этим всё просто:
1. Устанавливаем [Java](http://www.oracle.com/technetwork/java/javase/downloads/jre7-downloads-1880261.html) (если она еще не установлена)
2. Выкачиваем и распаковываем свежую сборку [JMeter](http://jmeter.apache.org/download_jmeter.cgi)
3. Устанавливаем переменную среды **JMETER\_BIN** на каталог с исполняемыми файлами JMeter (только для Windows)
4. Запускаем **jmeter.bat** или **jmeter.sh** (в зависимости от операционной системы) из каталога **bin**
Единственная проблема, с которой я столкнулся на Windows, связана с тем, что значение переменной JMETER\_BIN должно завершаться символом прямого или обратного слэша. Подробности можно посмотреть в запускаемом скрипте. Чтение [инструкции](http://jmeter.apache.org/usermanual/get-started.html) также не будет лишним.
#### **Запись скрипта**
Это, пожалуй, самая эффектная возможность JMeter. Она уже описывалась [ранее](http://habrahabr.ru/post/140310/), но я повторюсь, поскольку в той статье речь шла об уже немного устаревшей версии. JMeter можно запустить в режиме proxy, таким образом, чтобы весь HTTP-трафик проходил через него. Все подробности взаимодействия будут автоматически записываться в выбранную **Thread Group** или **Recording Controller**. Для добавления новых узлов в дерево, просто нажимаем на правую кнопку мыши и выбираем требуемый тип из выпадающего меню:
**Thread Group**, управляющая такими настройками как количество потоков, используемых для тестирования и количество запросов в тесте, находится в категории **Treads (Users)**, а сам **HTTP(S) Test Script Recorder** в **Non-Test Elements**.
Я выделил на рисунке настройки, на которые следует обратить внимание. Порт возможно придётся изменить, если на 8080 уже что-то поднято. В сложных случаях, в **Test Plan** придётся добавить **HTTP Cookie Manager** и **HTTP Authorization Manager**. После нажатия кнопки Start, идём в настройки любимого браузера:
Взаимодействие с Яндекс, внезапно, оказывается очень непростым:
Полученные запросы (**HTTP Request**) вместе с их настройками (**HTTP Header Manager**) можно перенести в любое место скрипта, используя любимые всеми команды Copy&Paste (Drag&Drop тоже работает). Даже если вы твердо уверены в том, что происходит на вашем сайте, Script Recorder может быть очень полезен, для того чтобы узнать подробности. Кроме того, автоматическая генерация скриптов куда веселее чем вбивание их руками. Более подробно процесс записи скриптов описан в этой [инструкции](https://jmeter.apache.org/usermanual/jmeter_proxy_step_by_step.pdf).
#### **Переменные**
Для чего-то мало-мальски серьёзного, нам потребуется возможность параметризации. Для примера, предположим, что нам требуется задать таймауты, в течение которых JMeter будет ожидать ответа сервера. Вбивать их заново в каждый **HTTP Request**, при любом изменении, было бы слишком утомительно. Заодно определим настройки HTTP Proxy (если он используется):
В поле Password забито значение **${user\_pass}**, тут уж вам придётся поверить мне на слово. Сами настройки удобно держать в **User Defined Variables** (этот элемент можно найти в категории **Config Element**):
Пустые значения переменных проблемой не являются. В соответствующие настройки будут подставлены пустые строки, как того и требуется, в случае если HTTP Proxy не используется. Можно пойти ещё дальше и действительно разместить все HTTP-настройки в одном месте:
Элемент **HTTP Request Defaults**, также как и **User Defined Variables** расположен в категории **Config Element**.
#### **Отладка**
Теперь, было бы неплохо видеть, что происходит при выполнении сценария. Различного вида визуализаторы размещаются в категории **Listener**. Нам понадобится **View Results Tree**. Добавим его и запустим сценарий на выполнение командой **Run/Start** (Ctrl+R). Можно видеть, что ответ сервера также бывает непростым:
Такая картина наблюдается, если адрес редиректит нас на другую страницу и с этим может быть связана одна проблема. Если мы попытаемся анализировать ответ сервера (как это делать я покажу ниже), нам будет доступен лишь последний ответ (той страницы на которую произошёл redirect). Если ответ с предыдущей страницы нам также интересен, автоматический redirect придётся отключить. За это отвечает настройка **Follow Redirects** элемента **HTTP Request**. Разобрав ответ, мы сможем получить адрес целевой страницы и выполнить повторный запрос вручную.
Есть ещё один элемент, крайне полезный для отладки сценариев. Он находится в категории **Sampler** и называется **Debug Sampler**. Каждый раз, когда до него доходит управление, он выводит текущие значения всех переменных. Добавим его в **Thread Group** и запустим сценарий ещё раз (для того, чтобы очистить вывод предыдущего запуска, удобно использовать комбинацию клавиш Ctrl+E):
Все переменные как на ладони. Удобно.
#### **JDBC Request**
Этот Sampler открывает нам доступ в любую базу данных, поддерживающую протокол [JDBC](https://ru.wikipedia.org/wiki/Java_Database_Connectivity). Для начала, добавим в **Test Plan** конфигурационный элемент с настройками подключения к серверу БД (**JDBC Connection Configuration**):
Помимо собственно настроек подключения к БД, здесь важно заполнить поле **Variable Name**. Это имя будет использоваться в **JDBC Request** (**Sampler**) для доступа к пулу сессий:
Если вам интересны результаты select-а, придётся заполнить **Variable Names**. Сам JMeter парсить SQL-запросы на предмет имён столбцов не умеет. Можно перечислять имена столбцов через запятую и пропускать столбцы, не давая им имени. Вставляем **Debug Sampler** и смотрим, что получилось:
Видим, что [документация](http://jmeter.apache.org/usermanual/component_reference.html#JDBC_Request) не врёт. Появились переменные **urls\_1** и **urls\_2** (количество строк, как и обещали, в **urls\_#**). В этом месте, стоит соблюдать осторожность. Записи выбираются не по одной, а все сразу и прочитав >1000 строк можно легко отожрать слишком много памяти. Теперь, было бы неплохо обойти полученные адреса в цикле:
Да, именно вот так заковыристо. Набор переменных **urls** перебираем от 0 до **${urls\_#}** и текущее значение помещаем в **url**. Сам **ForEach Controller** можно найти в категории **Logic Controller**. Внутри него создадим параметризованный **HTTP Request**. Запускаем, смотрим:
Всё работает.
#### **Регулярные выражения**
Теперь, результаты обращений к Web-серверам хотелось бы проанализировать. Для этого, нам предоставлена вся мощь [регулярных выражений](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B3%D1%83%D0%BB%D1%8F%D1%80%D0%BD%D1%8B%D0%B5_%D0%B2%D1%8B%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F). **Regular Expression Extractor** можно найти в **Post Processors**. Добавим его в **HTTP Request** и сконфигурируем:
Здесь, нас интересует только код ответа по HTTP (но, по иллюстрации видно, что можно обрабатывать и содержимое ответа). Будем извлекать цепочку цифр (**Regular Expression**) и помещать результат применения шаблона (**Template**) в переменную **http\_result** (**Reference Name**):
Как и ожидалось, получаем 200. Заодно, можно видеть, каким образом осуществляется захват в переменные регулярным выражением.
#### **Что-то там внутри**
Теперь, допустим, что нас интересует время, в течение которого выполнялся HTTP-запрос. И интересует оно нас не просто для статистики, а мы его хотим как-то использовать в сценарии (например сложить в БД). С этой задачей поможет справиться [BeanShell](http://jmeter.apache.org/usermanual/best-practices.html#bsh_scripting). Конкретно, мы используем его **Pre** — и **PostProcessor**-ы.
В первом будем получать timestamp:
```
Long t = ctx.getPreviousResult().currentTimeInMillis();
vars.put("timestamp", t.toString());
```
А во втором, получать с его помощью временную задержку:
```
Long d = ctx.getPreviousResult().currentTimeInMillis() - Long.parseLong(vars.get("timestamp"));
vars.put("delay", d.toString());
```
В общем, это тоже работает:
Но здесь следует сделать важное замечание. Поскольку, в настоящий момент, я занимаюсь **не** нагрузочным тестированием, производительность этой конструкции для меня не очень важна. Если в вашем случае это не так, стоит ознакомиться со следующей [статьёй](http://habrahabr.ru/post/250731/).
#### **Запуск**
Если бы не было этой возможности, не стоило бы и весь этот разговор заводить. В случае нагрузочного тестирования, сценарий можно запускать из GUI, нет проблем. Но если нас интересует автоматизация, необходимо уметь запускать его молча (например по [cron](https://ru.wikipedia.org/wiki/Cron)-у). Разумеется такая возможность тоже есть:
```
./jmeter.sh -n -t test.jmx -l test.log
```
Сохраняем сценарий в файл с расширением jmx (внутри это XML) и запускаем эту команду. Сценарий отрабатывает без запуска GUI и заодно пишет результаты своей работы в лог. Всё просто и удобно. | https://habr.com/ru/post/261483/ | null | ru | null |
# Использование Grab:Spider для парсинга сайтов
Всем привет!
Я активный пользователь open-source фрэймворка [Grab](http://grablib.org/) ([itforge](http://habrahabr.ru/users/itforge/) уже писал о нем [здесь](http://habrahabr.ru/blogs/python/127584/) и [здесь](http://habrahabr.ru/blogs/python/134918/)) и 1/2 проекта [GrabLab](http://grablab.org/) (который занимается собственно коммерческой эксплуатацией фрэймворка). Т.к. парсим сайты мы часто, помногу и задания как правило совершенно не похожи друг на друга, хотелось бы поделится своим опытом в вопросе построения типичного парсинг проекта.
##### Немного про инструментарий который помогает мне в работе
В качестве рабочего браузера я использую FireFox с плагинами **HttpFox** (анализировать входящий/исходящий http трафик), **XPather** (позволяет проверять xpath выражения), **SQLite Manager** (просмотр sqlite таблиц), код набираю в emacs, где активно использую сниппеты (YASnippets) для часто встречающихся конструкций.
Из-за специфики фрэймворка, как правило, на первом этапе сайт полностью (или если данных много — то частично, для удобства последующей разработки) сохраняется в локальный кэш на базе mongodb, что очень экономит время, т.к. считывание страниц идет из кэша.
Для работы с sql базами куда, как правило (реже в json/xml), нужно разложить данные мы используем ORM — SQLAlchemy.
Собственно сам фрэймворк Grab предполагает большую гибкость в построении проекта и контроль за своими действиями. Однако, последние несколько проектов хорошо ложились в следующую структуру, отлично знакомую тем кто занимается веб-разработкой:
1) models.py — описываю модели данных
2) config.py — аналог settings.py из мира джанги, настройки, инициализация orm.
3) /spiders/\*.py — код пауков
4) spider.py или project\_name.py — главный файл проекта, по совместительству обычно реализует command-line интерфейс для запуска различных пауков, т.к. зачастую сайт парсится по частям.
В качестве примера не сильно оторванного от реальной жизни напишем парсер «Trending projects» и «Most popular Python projects» c open-source цитадели GitHub.
Полный код примера можно посмотреть [тут](https://github.com/istinspring/grab-default-project-example).
Сперва нужно описать [модель](https://github.com/istinspring/grab-default-project-example/blob/master/models.py).
```
class Item(Base):
__tablename__ = 'item'
sqlite_autoincrement = True
id = Column(Integer, primary_key=True)
title = Column(String(160))
author = Column(String(160))
description = Column(String(255))
url = Column(String(160))
last_update = Column(DateTime, default=datetime.datetime.now)
```
Далее, в файле config.py выполняется начальная инициализация orm, создание таблиц, константы и находится функция которая конструирует параметры запуска паука в зависимости от настроек (default\_spider\_params), которая обычо общая для всех пауков в проекте.
```
def init_engine():
db_engine = create_engine(
'sqlite+pysqlite:///data.sqlite', encoding='utf-8')
Base.metadata.create_all(db_engine)
return db_engine
db_engine = init_engine()
Session = sessionmaker(bind=db_engine)
def default_spider_params():
params = {
'thread_number': MAX_THREADS,
'network_try_limit': 20,
'task_try_limit': 20,
}
if USE_CACHE:
params.update({
'thread_number': 3,
'use_cache': True,
'cache_db': CACHE_DB,
'debug_error' :True,
})
return params
```
В большинстве случаев нет необходимости использовать mongodb на сервере, поэтому удобно сделать кэш отключаемым. При деплое проекта я просто ставлю USE\_CACHE = False и все отлично работает. SAVE\_TO\_DB используется чтобы резрешить/запретить запись данных в базу данных.
Собственно переходим к самому интересному у нас будет 2а паука, первый будет парсить 5 репозиториев «Top Trending» проектов, а второй «Most watched Python».
Явно видно, что у этих пауков есть общие части, которые можно и нужно вынести в отдельный, базовый класс и наследовать уже от него, что уменьшает код, упрощает поддержку и делает программу более удобной для восприятия. В более-менее сложном проекте, где есть большое кол-во немного отличающихся друг от друга страниц необходимость выносить часть функционала в суперклассы возникает постоянно.
Не будем пренебрегать ООП и напишем BaseHubSpider в котором определим 2а метода save() и log\_progress().
```
class BaseHubSpider(Spider):
initial_urls = ['http://github.com']
items_total = 0
def save(self, data):
if not SAVE_TO_DB:
return
session = Session()
if not session.query(Item).filter_by(title=data['title']).first():
obj = Item(**data)
session.add(obj)
session.commit()
def log_progress(self, str):
self.items_total += 1
print "(%d) Item scraped: %s" % (self.items_total, str)
```
В реальном приложении весьма вероятно наличие функции разбора страницы в зависимости от каких-то параметров — названий полей которые на каждой странице разные в то время как xpath путь к ним практически одинаковый и т.д.
Например как-нибудь так (это не рабочий пример, а просто иллюстрация для лучшего понимания):
```
XPATH = u'//table[@class="standart-table table"]' + \
u'//tr[th[text() = "%s"]]/td'
values = (
('title', u'Наименование товара'),
('rating', u'Рейтинг'),
('categories', u'Категория товара'),
('description', u'Описание'),
)
for db_field, field_title in values:
try:
data[db_field] = get_node_text(grab.xpath(
XPATH % field_title, None)).strip()
except AttributeError:
data[db_field] = ''
```
<https://github.com/istinspring/grab-default-project-example/blob/master/spiders/lang_python.py>
Код паука который парсит и сохраняет в базу данных 20 самых популярных python проектов.
###### Обратите внимание
```
repos = grab.xpath_list(
'//table[@class="repo"]//tr/td[@class="title"]/..')
for repo in repos:
data = {
'author': repo.xpath('./td[@class="owner"]/a/text()')[0],
'title': repo.xpath('./td[@class="title"]/a/text()')[0],}
```
repos = grab.xpath\_list('') — возвращает список lxml объект, в то время как например grab.xpath('') возвращает первый элемент, т.к. xpath в данном случае метод объекта grab, т.е. оперируя в цикле repo.xpath('./h3/a[1]/text()') — мы получаем список или исключение если lxml не смог найти xpath. Проще говоря, xpath от объекта grab и xpath от lxml объекта — разные вещи, в первом случае вернется первый элемент (или default или бросит exception), а во втором вернется список элементов ['something'].
^^ Читается непонятно, но как только вы встретите подобное на практике, сразу вспомните про этот абзац.
Надеюсь, информация была полезной. Товарищ itforge работает не покладая рук над развитием опен сурс продукта [Grab](http://grablib.org/), документация по grab нему доступна на [русском языке](http://grablib.org/docs), а вот для grab:spider, к сожалению, доступна только [вводная часть](http://grablib.org/docs/spider/tutorial.html).
Для вопросов по фрэймворку у нас есть jabber конференция на **grablab@conference.jabber.ru** | https://habr.com/ru/post/142212/ | null | ru | null |
# ETL процесс получения данных из электронной почты в Apache Airflow
Как бы сильно не развивались технологии, за развитием всегда тянется вереница устаревших подходов. Это может быть обусловлено плавным переходом, человеческим фактором, технологическими необходимостями или чем-то другим. В области обработки данных наиболее показательными в этой части являются источники данных. Как бы мы не мечтали от этого избавиться, но пока часть данных пересылается в мессенджерах и электронных письмах, не говоря и про более архаичные форматы. Приглашаю под кат разобрать один из вариантов для Apache Airflow, иллюстрирующий, как можно забирать данные из электронных писем.
Предыстория
-----------
Многие данные до сих пор передаются через электронную почту, начиная с межличностных коммуникаций и заканчивая стандартами взаимодействия между компаниями. Хорошо, если удается для получения данных написать интерфейс или посадить людей в офисе, которые эту информацию будут вносить в более удобные источники, но зачастую такой возможности может просто не быть. Конкретная задача, с которой столкнулся я, — это подключение небезызвестной CRM системы к хранилищу данных, а далее — к системе OLAP. Так исторически сложилось, что для нашей компании использование этой системы было удобно в отдельно взятой области бизнеса. Поэтому всем очень хотелось иметь возможность оперировать данными и из этой сторонней системы в том числе. В первую очередь, конечно, была изучена возможность получения данных из открытого API. К сожалению, API не покрывало получение всех необходимых данных, да и, выражаясь простым языком, было во многом кривовато, а техническая поддержка не захотела или не смогла пойти навстречу для предоставления более исчерпывающего функционала. Зато данная система предоставляла возможность периодического получения недостающих данных на почту в виде ссылки для выгрузки архива.
Нужно отметить, что это был не единственный кейс, по которому бизнес хотел собирать данные из почтовых писем или мессенджеров. Однако, в данном случае мы не могли повлиять на стороннюю компанию, которая предоставляет часть данных только таким способом.
Apache Airflow
--------------
Для построения ETL процессов мы чаще всего используем Apache Airflow. Для того чтобы читатель, незнакомый с этой технологией, лучше понял, как это выглядит в контексте и в целом, опишу пару вводных.
Apache Airflow — свободная платформа, которая используется для построения, выполнения и мониторинга ETL (Extract-Transform-Loading) процессов на языке Python. Основным понятием в Airflow является ориентированный ацикличный граф, где вершины графа — конкретные процессы, а ребра графа — поток управления или информации. Процесс может просто вызывать любую Python функцию, а может иметь более сложную логику из последовательного вызова нескольких функций в контексте класса. Для наиболее частых операций уже есть множество готовых наработок, которые можно использовать в качестве процессов. К таким наработкам относятся:
* операторы — для перегона данных из одного места в другое, например из таблицы БД в хранилище данных;
* сенсоры — для ожидания наступления определенного события и направления потока управления в последующие вершины графа;
* хуки — для более низкоуровневых операций, например, для получения данных из таблицы БД (используются в операторах);
* и т.д.
Описывать Apache Airflow подробно в этой статье будет нецелесообразно. Краткие введения можно посмотреть [здесь](https://habr.com/ru/company/mailru/blog/339392/) или [здесь](https://habr.com/ru/company/newprolab/blog/358530/).
Хук для получения данных
------------------------
В первую очередь, для решения задачи нужно написать хук, с помощью которого мы могли бы:
* подключаться к электронной почте;
* находить нужное письмо;
* получать данные из письма.
```
from airflow.hooks.base_hook import BaseHook
import imaplib
import logging
class IMAPHook(BaseHook):
def __init__(self, imap_conn_id):
"""
IMAP hook для получения данных с электронной почты
:param imap_conn_id: Идентификатор подключения к почте
:type imap_conn_id: string
"""
self.connection = self.get_connection(imap_conn_id)
self.mail = None
def authenticate(self):
"""
Подключаемся к почте
"""
mail = imaplib.IMAP4_SSL(self.connection.host)
response, detail = mail.login(user=self.connection.login, password=self.connection.password)
if response != "OK":
raise AirflowException("Sign in failed")
else:
self.mail = mail
def get_last_mail(self, check_seen=True, box="INBOX", condition="(UNSEEN)"):
"""
Метод для получения идентификатора последнего письма,
удовлетвораяющего условиям поиска
:param check_seen: Отмечать последнее письмо как прочитанное
:type check_seen: bool
:param box: Наименования ящика
:type box: string
:param condition: Условия поиска писем
:type condition: string
"""
self.authenticate()
self.mail.select(mailbox=box)
response, data = self.mail.search(None, condition)
mail_ids = data[0].split()
logging.info("В ящике найдены следующие письма: " + str(mail_ids))
if not mail_ids:
logging.info("Не найдено новых писем")
return None
mail_id = mail_ids[0]
# если таких писем несколько
if len(mail_ids) > 1:
# отмечаем остальные прочитанными
for id in mail_ids:
self.mail.store(id, "+FLAGS", "\\Seen")
# возвращаем последнее
mail_id = mail_ids[-1]
# нужно ли отметить последнее прочитанным
if not check_seen:
self.mail.store(mail_id, "-FLAGS", "\\Seen")
return mail_id
```
Логика такая: подключаемся, находим последнее самое актуальное письмо, если есть другие — игнорируем их. Используется именно такая функция, потому что более поздние письма содержат все данные ранних. Если это не так, то можно возвращать массив всех писем или обрабатывать первое, а остальные — при следующем проходе. В общем, все как всегда зависит от задачи.
Добавляем к хуку две вспомогательные функции: для скачивания файла и для скачивания файла по ссылке из письма. К слову, их можно вынести в оператор, это зависит от частоты использования данного функционала. Что еще дописывать в хук, опять же, зависит от задачи: если в письме приходят сразу файлы, то можно скачивать приложения к письму, если данные приходят в письме, то нужно парсить письмо и т.д. В моем случае, письмо приходит с одной ссылкой на архив, который мне нужно положить в определенное место и запустить дальнейший процесс обработки.
```
def download_from_url(self, url, path, chunk_size=128):
"""
Метод для скачивания файла
:param url: Адрес загрузки
:type url: string
:param path: Куда положить файл
:type path: string
:param chunk_size: По сколько байтов писать
:type chunk_size: int
"""
r = requests.get(url, stream=True)
with open(path, "wb") as fd:
for chunk in r.iter_content(chunk_size=chunk_size):
fd.write(chunk)
def download_mail_href_attachment(self, mail_id, path):
"""
Метод для скачивания файла по ссылке из письма
:param mail_id: Идентификатор письма
:type mail_id: string
:param path: Куда положить файл
:type path: string
"""
response, data = self.mail.fetch(mail_id, "(RFC822)")
raw_email = data[0][1]
raw_soup = raw_email.decode().replace("\r", "").replace("\n", "")
parse_soup = BeautifulSoup(raw_soup, "html.parser")
link_text = ""
for a in parse_soup.find_all("a", href=True, text=True):
link_text = a["href"]
self.download_from_url(link_text, path)
```
Код простой, поэтому вряд ли нуждается в дополнительных пояснениях. Расскажу лишь про магическую строчку imap\_conn\_id. Apache Airflow хранит параметры подключений (логин, пароль, адрес и другие параметры), к которым можно обращаться по строковому идентификатору. Визуально управление подключениями выглядит вот так
### Сенсор для ожидания данных
Поскольку мы уже умеем подключаться и получать данные из почты, теперь можем написать сенсор для их ожидания. Написать сразу оператор, который будет обрабатывать данные, если они имеются, в моем случае не получилось, так как на основании полученных данных из почты работают и другие процессы, в том числе, берущие связанные данные из других источников (API, телефония, веб метрики и т.д.). Приведу пример. В CRM системе появился новый пользователь, и мы еще не знаем про его UUID. Тогда при попытке получить данные с SIP-телефонии мы получим звонки, привязанные к его UUID, но корректно сохранить и использовать их не сможем. В таких вопросах важно иметь в виду зависимость данных, особенно, если они из разных источников. Это, конечно, недостаточные меры сохранения целостности данных, но в некоторых случаях необходимые. Да и в холостую занимать ресурсы тоже нерационально.
Таким образом, наш сенсор будет запускать последующие вершины графа, если есть свежая информация на почте, а также помечать неактуальной предыдущую информацию.
```
from airflow.sensors.base_sensor_operator import BaseSensorOperator
from airflow.utils.decorators import apply_defaults
from my_plugin.hooks.imap_hook import IMAPHook
class MailSensor(BaseSensorOperator):
@apply_defaults
def __init__(self, conn_id, check_seen=True, box="Inbox", condition="(UNSEEN)", *args, **kwargs):
super().__init__(*args, **kwargs)
self.conn_id = conn_id
self.check_seen = check_seen
self.box = box
self.condition = condition
def poke(self, context):
conn = IMAPHook(self.conn_id)
mail_id = conn.get_last_mail(check_seen=self.check_seen, box=self.box, condition=self.condition)
if mail_id is None:
return False
else:
return True
```
### Получаем и используем данные
Для получения и обработки данных можно написать отдельный оператор, можно использовать готовые. Поскольку пока логика тривиальная — забрать данные из письма, то для примера предлагаю стандартный PythonOperator
```
from airflow.models import DAG
from airflow.operators.python_operator import PythonOperator
from airflow.sensors.my_plugin import MailSensor
from my_plugin.hooks.imap_hook import IMAPHook
start_date = datetime(2020, 4, 4)
# Стандартное конфигурирование графа
args = {
"owner": "example",
"start_date": start_date,
"email": ["home@home.ru"],
"email_on_failure": False,
"email_on_retry": False,
"retry_delay": timedelta(minutes=15),
"provide_context": False,
}
dag = DAG(
dag_id="test_etl",
default_args=args,
schedule_interval="@hourly",
)
# Определяем сенсор
mail_check_sensor = MailSensor(
task_id="check_new_emails",
poke_interval=10,
conn_id="mail_conn_id",
timeout=10,
soft_fail=True,
box="my_box",
dag=dag,
mode="poke",
)
# Функция для получения данных из письма
def prepare_mail():
imap_hook = IMAPHook("mail_conn_id")
mail_id = imap_hook.get_last_mail(check_seen=True, box="my_box")
if mail_id is None:
raise AirflowException("Empty mailbox")
conn.download_mail_href_attachment(mail_id, "./path.zip")
prepare_mail_data = PythonOperator(task_id="prepare_mail_data", default_args=args, dag=dag, python_callable= prepare_mail)
# Описание остальных вершин графа
...
# Задаем связь на графе
mail_check_sensor >> prepare_mail_data
prepare_data >> ...
# Описание остальных потоков управления
```
Кстати, если ваша корпоративная почта тоже на mail.ru, то вам будет недоступен поиск писем по теме, отправителю и т.д. Они еще в далеком 2016 обещали ввести, но, видимо, передумали. Я решил эту проблему, создав под нужные письма отдельную папку и настроив в веб-интерфейсе почты фильтр на нужные письма. Таким образом, в эту папку попадают только нужные письма и условия для поиска в моем случае просто (UNSEEN).
Резюмируя, мы имеем следующую последовательность: проверяем, есть ли новые письма, соответствующие условиям, если есть, то скачиваем архив по ссылке из последнего письма.
Под последними многоточиями опущено, что этот архив будет распакован, данные из архива очищены и обработаны, и в итоге все это дело уйдет далее на конвейер ETL процесса, но это уже выходит за рамки темы статьи. Если получилось интересно и полезно, то с радостью продолжу описывать ETL решения и их части для Apache Airflow. | https://habr.com/ru/post/495676/ | null | ru | null |
# Команда cp: правильное копирование папок с файлами в *nix
В этой статье будут раскрыты некоторые неочевидные вещи связанные с использованием [wildcards](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0) при копировании, неоднозначное поведение команды `cp` при копировании, а также способы позволяющие корректно копировать огромное количество файлов без пропусков и вылетов.
Допустим нам нужно скопировать всё из папки /source в папку /target.
Первое, что приходит на ум это:
```
cp /source/* /target
```
Сразу исправим эту команду на:
```
cp -a /source/* /target
```
Ключ `-a` добавит копирование всех аттрибутов, прав и добавит рекурсию. Когда не требуется точное воспроизведение прав достаточно ключа `-r`.
После копирования мы обнаружим, что скопировались не все файлы — были проигнорированы файлы начинающиеся с точки типа:
`.profile
.local
.mc`
и тому подобные.
Почему же так произошло?
Потому что wildcards обрабатывает shell (`bash` в типовом случае). По умолчанию bash проигнорирует все файлы начинающиеся с точек, так как трактует их как скрытые. Чтобы избежать такого поведения нам придётся изменить поведение `bash` с помощью команды:
```
shopt -s dotglob
```
Чтобы это изменение поведения сохранилось после перезагрузки, можно сделать файл wildcard.sh c этой командой в папке `/etc/profile.d` (возможно в вашем дистрибутиве иная папка).
А если в директории-источнике нет файлов, то shell не сможет ничего подставить вместо звёздочки, и также копирование завершится с ошибкой. Против подобной ситуации есть опции `failglob` и `nullglob`. Нам потребуется выставить `failglob`, которая не даст команде выполниться. `nullglob` не подойдёт, так как она строку с wildcards не нашедшими совпадения преобразует в пустую строку (нулевой длины), что для `cp` вызовет ошибку.
Однако, если в папке тысячи файлов и больше, то от подхода с использованием wildcards стоит отказаться вовсе. Дело в том, что `bash` разворачивает wildcards в очень длинную командную строку наподобие:
```
cp -a /souce/a /source/b /source/c …… /target
```
На длину командной строки есть ограничение, которое мы можем узнать используя команду:
```
getconf ARG_MAX
```
Получим максимальную длину командной строки в байтах:
```
2097152
```
Или:
```
xargs --show-limits
```
Получим что-то типа:
```
….
Maximum length of command we could actually use: 2089314
….
```
Итак, давайте будем обходиться вовсе без wildcards.
Давайте просто напишем
```
cp -a /source /target
```
И тут мы столкнёмся с неоднозначностью поведения `cp`. Если папки /target не существует, то мы получим то, что нам нужно.
Однако, если папка target существует, то файлы будут скопированы в папку /target/source.
Не всегда мы можем удалить заранее папку /target, так как в ней могут быть нужные нам файлы и наша цель, допустим, дополнить файлы в /target файлами из /source.
Если бы папки источника и приёмника назывались одинаково, например, мы копировали бы из /source в /home/source, то можно было бы использовать команду:
```
cp -a /source /home
```
И после копирования файлы в /home/source оказались бы дополненными файлами из /source.
> Такая вот логическая задачка: мы можем дополнить файлы в директории-приёмнике, если папки называются одинаково, но если они отличаются, то папка-исходник будет помещена внутрь приёмника. Как скопировать файлы из /source в /target с помощью cp без wildcards?
Чтобы обойти это вредное ограничение мы используем неочевидное решение:
```
cp -a /source/. /target
```
Те кто хорошо знаком с DOS и Linux уже всё поняли: внутри каждой папки есть 2 невидимые папки "." и "..", являющиеся псевдопапками-ссылками на текущую и вышестоящие директории.
* При копировании `cp` проверяет существование и пытается создать /target/.
* Такая директория существует и это есть /target
* Файлы из /source скопированы в /target корректно.
Итак, вешаем в жирную рамочку в своей памяти или на стене:
>
> ```
> cp -a /source/. /target
> ```
>
Поведение этой команды однозначно. Всё отработает без ошибок вне зависимости от того миллион у вас файлов или их нет вовсе.
### Выводы
Если нужно скопировать **все** файлы из одной папки в другую, не используем wildcards, вместо них лучше использовать `cp` в сочетании с точкой в конце папки-источника. Это скопирует все файлы, включая скрытые и не завалится при миллионах файлов или полном отсутствии файлов.
#### Послесловие
[vmspike](https://habr.com/ru/users/vmspike/) предложил аналогичный по результату вариант команды:
```
cp -a -T /source /target
```
[Oz\_Alex](https://habr.com/ru/users/oz_alex/)
```
cp -aT /source /target
```
ВНИМАНИЕ: регистр буквы `T` имеет значение. Если перепутать, то получите полную белиберду: направление копирования поменяется.
---
Благодарности:
* Компании [RUVDS.COM](https://ruvds.com/) за поддержку и возможность публикации в своем блоге на Хабре.
* За изображение [TripletConcept](https://vk.com/neoprosveschenie). Картинка очень большая и детальная, можно открыть в отдельном окне.
**P.S.** Замеченные ошибки направляйте в личку. Повышаю за это карму.
---
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/471092/ | null | ru | null |
# Как встроить С-библиотеку в Swift-фреймворк
В 2014 году был представлен Swift, новый язык для разработки приложений экосистемы Apple. Новинка принесла не только новые возможности и функции, но и проблемы — тем, кто хотел пользоваться старыми добрыми C-библиотеками. В этой статье я рассмотрю одну из них — бандлинг C-библиотеки в Swift-фреймворк. Существует несколько способов её решения; в данном случае я объясню, как сделать это при помощи clang explicit-модулей.
Для примера мы возьмём внешнюю C-библиотеку [libgif](http://giflib.sourceforge.net/) и встроим её в наш Swift-фреймворк GifSwift. Если вы хотите сразу увидеть результат, полностью проект можно посмотреть [здесь](https://github.com/turbulem/GifSwift).
Подготовка libgif
=================
Прежде чем внедрять в наш проект библиотеку libgif, её нужно собрать из исходников.
1. Скачиваем последнюю версию тарболла [здесь](https://sourceforge.net/projects/giflib/files/).
2. Распаковываем архив, при помощи консоли заходим в папку и запускаем:
```
./configure && make check
```
**Примечание:** для простоты мы собираем библиотеку для платформы x86-64, а потому она будет работать только в iOS-симуляторе или на macOS. Построение мультиархитектурной статической библиотеки – отдельная тема, которой я не касаюсь в этой статье. Полезные инструкции вы найдёте [здесь](https://medium.com/@hassanahmedkhan/a-noobs-guide-to-creating-a-fat-library-for-ios-bafe8452b84b).
3. Если всё пройдёт без ошибок, файлы библиотеки можно будет найти в `${lib_gif_source}/lib/.libs`. Нас интересуют два файла:
```
lib/.libs/libgif.a # Статическая библиотека
lib/gif_lib.h # Интерфейс
```
Настройка проекта
=================
Теперь настроим проект под наши нужды.
1. Создаём новый проект при помощи шаблона Cocoa Touch Framework, даём ему имя *GifSwift*.
2. Добавляем созданные нами файлы библиотеки *libgif* в отдельную группу внутри проекта.
3. Добавляем в проект новый таргет для тестового приложения, чтобы посмотреть результат.
Итоговая структура проекта должна выглядеть примерно так:
Импортируем в Swift
===================
Для того чтобы импортировать C-библиотеку в Swift, мы должны описать её как [модуль](https://clang.llvm.org/docs/Modules.html). Описание представляет собой файл **.modulemap**, содержащий список заголовочных файлов для импорта и статических библиотек для линковки. Полученный модуль может быть импортирован в Swift или Objective-C-код (при помощи `@import`).
Этот способ импорта библиотеки во фреймворк будет работать в большинстве случаев (более подробно об этом подходе читайте [здесь](https://medium.com/swift-and-ios-writing/using-a-c-library-inside-a-swift-framework-d041d7b701d9)). Он отлично подходит, если вы создаёте внутренний фреймворк или просто разбиваете своё приложение на модули. Но такой способ также имеет и недостатки. Например, он неэффективен в том случае, если вы хотите передать свою библиотеку кому-то при помощи Carthage, Cocoapods или в виду бинарного артефакта. Причина в том, что получившийся фреймворк в общем случае не портируем, поскольку при компиляции он привязывается к конкретному расположению заголовочных файлов и библиотек из module map на вашем компьютере.
Явный модуль
============
Чтобы обойти эти ограничения, воспользуемся ещё одним способом — **explicit**-модулем для библиотеки. Еxplicit-модуль — это модуль, который объявляется подмодулем при помощи ключевого слова *explicit*, помещается в родительский модуль и *не импортируется* автоматически. Он работает аналогично `*_Private.h` для фреймворков Objective-C. Если вы хотите использовать объявленные в нём API, необходимо импортировать модуль **явно (explicitly).**
Мы создаём явный модуль для C-библиотеки внутри фреймворка. Для этого нам нужно провести переопределение сгенерированного XCode-модуля. Также обратите внимание на то, что мы не указываем библиотеку libgif.a для линковки (link gif), а вместо этого сделаем это прямо в проекте, используя интерфейс XCode.
*Примечание: узнать больше об explicit-модулях [можно по ссылке](https://clang.llvm.org/docs/Modules.html)*
1. Добавляем в корневую папку проекта файл с названием *GifSwift.modulemap*:
```
framework module GifSwift {
umbrella header "GifSwift.h"
explicit module CLibgif {
private header "gif_lib.h"
}
export *
}
```
Этот файл содержит спецификацию для явного модуля *CLibgif* и состоит из одного объявленного заголовочного файла (поскольку в нашей библиотеке как раз один такой). Файл загружается в получившийся модуль для фреймворка.
2. Файл с описанием модуля не нужно добавлять в состав фреймворка, но он должен быть указан в настройках таргета:
**```
Build Settings — Packaging — Module Map (MODULEMAP_FILE)
=
$SRCROOT/GifSwift/GifSwift.modulemap
```**
3. libgif-файлы должны быть добавлены в таргет фреймворка в виде приватного хедера (*gif\_lib.h*) и статической библиотеки (*libgif.a*). Обратите внимание на то, что заголовочный файл для C-библиотеки добавлен в таргет как private. Это необходимо для нашего explicit-модуля. Ничто не мешает добавить этот заголовочный файл как public, но наша задача – скрыть детали реализации как можно более простыми средствами.
4. Теперь можно импортировать явный модуль внутри фреймворка при помощи `import GifSwift.CLibgif`
Swift-обёртка
=============
Теперь можно заняться интерфейсом нашего фреймворка. Достаточно одного класса, представляющего собой гифку с парой свойств:
```
import Foundation
import GifSwift.CLibgif
public class GifFile {
private let path: URL
private let fileHandlePtr: UnsafeMutablePointer
private var fileHandle: GifFileType {
return self.fileHandlePtr.pointee
}
deinit {
DGifCloseFile(self.fileHandlePtr, nil)
}
// MARK: - API
public init?(path: URL) {
self.path = path
let errorCode = UnsafeMutablePointer.allocate(capacity: 1)
if let handle = path.path.withCString({ DGifOpenFileName($0, errorCode) }) {
self.fileHandlePtr = handle
DGifSlurp(handle)
} else {
debugPrint("Error opening file \(errorCode.pointee)")
return nil
}
}
public var size: CGSize {
return CGSize(width: Double(fileHandle.SWidth), height: Double(fileHandle.SHeight))
}
public var imagesCount: Int {
return Int(fileHandle.ImageCount)
}
}
```
`GifFile.swift` оборачивает низкоуровневые программные интерфейсы для обработки файлов и получает доступ к некоторым свойствам, отображая их на более удобные типы Foundation.
Проверка
========
Для того чтобы протестировать нашу библиотеку, я добавил в проект файл *cat.gif*:
```
import UIKit
import GifSwift
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
if let file = GifFile(path: Bundle.main.url(forResource: "cat", withExtension: "gif")!) {
debugPrint("Image has size: \(file.size) and contains \(file.imagesCount) images")
}
}
}
```
При запуске этого кода в консоли мы увидим следующее:
**"*Image has size: (250.0, 208.0) and contains 44 images"*
Выводы
======**Получившийся фреймворк содержит всё необходимое для использования, имеет Swift-интерфейс и по умолчанию скрывает C-код от клиентов. Впрочем, это не совсем правда. Как я писал выше, импортируя *GifSwift.CLibgif*, вы получите доступ ко всем закрытым модулям, однако по умолчанию такого метода инкапсуляции достаточно, чтобы скрыть детали реализации фреймворка. | https://habr.com/ru/post/435650/ | null | ru | null |
# Диагностическая медицинская экспертная система на Prolog
Вступление
----------
Как то мне посчастливилось выбирать тему дипломной работы по специальности программная инженерия, и я выбрал написание экспертной системы, причем именно на языке Пролог. Хоть в промышленном программировании он почти не используется, он интересен в теоретическом плане позволяет самым быстрым способом прикоснуться к интеллектуальным системам(ИС). Также сам язык интересен в спортивном плане, так как заставляет мыслить в непривычной манере, отличной от мышления процедурного программирования и ООП, что является хорошой тренировкой для мозгов.
Использовалась реализация Prolog — Visual Prolog, с встроенными библиотеками GUI. Но если
вы хотите написать GUI на Qt/C++, то в документации есть инструкция, как импортировать программу в DLL, и скомпилировать ее вместе с C/C++ проектом. Отсюда следует, что совместить можно и с другими языками.
Вообще когда я работал над этим проектом, я не нашел примеров достаточно не примитивных, но в то же время и не настолько больших, как навороченные научные примеры. Поэтому данная статья может оказаться очень хорошей помощью начинающим, и людям желающим написать хотя бы немного похожее на ИС.
Описание назначения системы: есть набор параметров, которым должен соответствовать кардиосигнал(ЭКГ), по которым можно определить заболевание. Человек отвечает на вопросы системы(в режиме диалога), и система, выступая в качестве эксперта по кардиозаболеваниям, делает выводы о потенциальном заболевании человека.
Т.е. данный код можно рассматривать как каркас(prolog-фреймворк), для создания экспертных систем из других областей, просто подставив свои правила, свои данные. Правила, по которым осуществляется вставка будут описаны ниже.
Исчисление предикатов первого порядка и язык Пролог
---------------------------------------------------
Язык Пролог реализует логическую парадигму программирования, идея которой – использование вычислительной техники для логического вывода из декларативного описания предметной области. Это отличает его от процедурных языков программирования, которые описывают четко определенные последовательные действия. Поэтому процедурные языки не подходят для написания ЭС, и если и используются, то только как вспомогательные модули. Также отличительной особенностью языка Пролог, является использование для описания программы подмножества языка логики первого порядка, на котором удобно и проще чем к другим, переходит с естественного языка описания мира человеком. При создании ЭС это является одной из важных проблем – как перевести знания предметной области на ограниченный формальный язык, сохранив при этом информативность вкладываемую человеком. Также существует простая возможность перевести знания обратно из формального к естественной форме, вследствие интуитивной понятности и простоты, по сравнению с логикой второго порядка или другими математическими исчислениями.
Языковые конструкции Пролога можно представить в виде импликаций вида:
`A1, A2, …, An <= B1, B2, …,Bm (n>=0, m>=0) (1)`
где Ai и Bi – атомарные формулы Fi(t1, t2, …, tk) или отрицание Fi(t1, t2, …, tk), где tk – термы(индивидная константа, переменная или результат применения функции)
В Прологе все отношения записываются как факты и правила, где n=1 в формуле (1), для повышения эффективности логического вывода. Правилам соответствует формула, называемая формулой Хорна:
`A<=B1, B2, …, Bm ,где m>0 (2)`
Фактам соответствует формула (2) при m=0:
`A<= (3)`
Формулой, которую нужно доказать в процессе механизма вывода, является формула (1) при n=0, m>0, называется целью или запросом:
`<= B1, B2, …Bm (4)`
Из этих языковых конструкций состоит вся программа на Прологе.
Например, следующее знание, в виде предложения на естественном языке – “Сын Ани любит Машу” можно записать в виде факта:
```
любит(сын(аня), маша)
```
а предложение “Аня любит всех, кого любит Оля” в виде:
```
(любит(аня,X)<=любит(оля,X))
```
Или рассуждение “Каждый человек смертен. Конфуций — человек”:
```
(человек(конфуций)& (смертен(X)<=человек(X)) <= смертен(конфуций)
```
Также Пролог предоставляет средства для определения рекурсивных структур данных, таких как деревья и списки, что приносит дополнительные возможности для удобного описания соответствующих знаний.
Таким образом, видно, что Пролог предоставляет гибкий, простой и интуитивно понятный язык для описания знаний.
Но дальше встает вопрос о выборе реализации этого языка, и было решено целесообразным разрабатывать ЭС на расширении языка Пролог – Visual Prolog.
Visual Prolog
-------------
Visual Prolog – диалект языка Пролог с объектно-ориентированным расширением вместе с интегрированной средой разработки. Эта среда обеспечивает поддержку создания графических интерфейсов и многих других библиотек. Язык Пролог довольно популярный для создания ЭС, с простым синтаксисом, схожим по смыслу с отношениями предметной области и фактами. Вообще сам интерпретатор языка Пролог можно рассматривать как ЭС в терминах логики предикатов первого порядка, в которой пользователь задает вопрос в виде цели, истинность которой нужно доказать. Это декларативный язык, в нем описывается, что нужно получить, вместо последовательного алгоритма, прекрасно подходит для описания знаний небольшой ЭС. По сравнению с альтернативными средами AMZI Prolog и SWI-Prolog, предоставляет очень эффективный интерфейс взаимодействия с другими языками как с помощью компоновки объектных файлов или с помощью динамической загрузки DLL-библиотек, как других языков, так и как самостоятельный DLL-модуль. Также Visual Prolog хорошо документирована, имеет множество примеров. Также существует мнение, что выбор языка реализации, способа представления знаний и метода формирования рассуждений вторичны, по сравнению со знаниями эксперта, и влияют лишь на механизм их успешного использования. Тем не менее, наличие литературы с использованием пролога как средства создания ЭС говорит о пригодности его использования, по крайней мере в небольших системах.
Проектирование ЭС
-----------------
В литературе принято разделять ЭС на несколько основных, мало зависящих друг от друга компонентов: базу знаний, механизм вывода и интерфейс с пользователем.
Существует 2 типа организации экспертных систем: на правилах и на фактах.
Знания ЭС на правилах записывается в виде продукционных правил. Левая часть каждого правила содержит какаю-то альтернативу решения вопроса, а правые части (посылки) специфицируются другими правилами. Единственное исключение – когда правило проверяет наличие в базе данных информации, например ответа на вопрос. Алгоритм работы механизма вывода сводится к сопоставлению, затем при множестве вариантов выбирается нужный в соответствии с заложенным принципом разрешения конфликта и в конце применяется выбранное правило и все начинается сначала. Плюсы у такой организации в том, что очень легко добавлять правила в систему без влияния на другие правила, а дополнять и модифицировать легко, так как программисту нужно просто вставить нужное правило в подходящий блок правил. Также такая организация имеет ограничения, а именно придется организовывать неестественный алгоритм сохранения трассировки или использовать для нее переменную в правилах, но это нарушит удобство модификации правил, так как для каждого предиката правила придется организовывать сохранения трассировки. Также это нарушит читабельность программы и возможность модификации вообще механизма вывода, так как вместе с информацией о правилах будет содержаться учет обхода посредством действия механизма вывода. Дополнительно Пролог не позволяет сохранять правила в файл базы данных и читать правила из базы данных, что не позволило бы обновлять базу знаний во время работы программы. Листинг 1 приводит пример такой организации базы знаний.
Листинг 1
```
diag("SIRS"):-
diag2("SIRS").
diag("Sepsis"):-
diag("SIRS"),
have("Sepsis character").
diag("Hard sepsis"):-
diag("Sepsis"),
have("Hard sepsis character").
diag("Shock sepsis"):-
diag("Hard sepsis"),
have("Shock sepsis character").
diag("MOF"):-
diag("Hard sepsis"),
have("MOF sepsis character").
diag("MOF"):-
diag("Shock sepsis"),
have("MOF sepsis character").
```
Как видно из листинга 1, механизм вывода полностью должен управляться встроенным в Пролог стандартным механизмом вывода.
ЭС организованные на логике (на фактах) более гибкие, так как в отличие от прямой связи правил, они организованы на ссылочной (косвенной) методике описания связей правил. Связи записываются в виде термов, например номеров правил, а не вложенных друг друга правил. Такая запись больше соответствует строгой записи в виде предложений логики предикатов, что и делает механизм вывода таких правил более гибким. В отличие от организации на правилах, поиск решения Пролога менее зависим от процесса логического вывода очередного правила, так как появляется возможность помимо вывода выполнять еще какие-то действия, например, пройтись по альтернативному дереву решений или вовсе изменить ход вывода и вернуться к исходному положению сохранив все данные об этом.
Также как и в организации на правилах здесь действует цикл: сопоставление – разрешение конфликта — переход к очередному правилу, но поскольку механизм вывода управляется опосредовано удобно в процессе выводить информацию о поиске решения и изменять этот формат без изменения базы знаний. Главное преимущество организации на логике в том, что можно сделать так, чтобы переменные, которые сопоставляются в процессе вывода, автоматически доступны в механизме вывода, и их можно было выводить вместе цепочкой последних правил, которые выведены к текущей цели. Но для этого нужно дополнительно предусмотреть механизм привидения типов для разных типов правил. Также база знаний хранится в виде фактов, поэтому ее можно сохранять или читать с файла на носителе. Систему на фактах тяжелее модифицировать и отлаживать чем на правилах, так как механизм вывода управляется значениями переменных и термами, например в виде номера правила, что вносит дополнительные возможности для ошибок.
Также в механизме вывода становится больше влияющих на этот процесс переменных, порой рекурсивного типа и довольно взаимосвязанных, что усложняет разработку, и отлов ошибок, но это цена за гибкость которую она предоставляет. Также система на фактах работает эффективнее и быстрее чем на правилах, что особенно важно для громоздких ЭС реального времени, или даже для распределенных ЭС реального времени.
Большая ЭС для медицинской диагностики в случае поступления больных в критическом состоянии, особенно если используется одновременно множеством врачей, тоже должна укладываться в строгие временные рамки.
Еще систему на фактах тяжелее тестировать из-за ее зависимости от фактов, так как в системе на правилах просто ошибка отразилась бы на механизме вывода, и это сразу бы стало видно, но на фактах скорее всего продолжит дальше работать.
В итоге, так как разрабатываемая система должна обладать информативностью к пользователю, а именно должен выводиться в процессе логического вывода обоснованный ответ на вопрос — почему системе понадобилась затребованная информация, чтобы пользователь знал — на какой стадии поиска решений он находится, что нельзя обеспечить без сохранения трассировки поиска. Также в конце, после ответа на вопрос, пользователь должен иметь возможность увидеть дерево доказательства для найденных решений. Учитывая все параметры системы, самым рациональным мне показалась система на правилах, так как ее можно сохранять на диск и ее механизм вывода легче будет организовать. Также знания по диагностике сердечнососудистых заболеваний, оказалось довольно трудно формализовать из-за их семантической взаимосвязанности, особенно в тех местах, где смысл заключений правил подразумевал учет дополнительной информации, для каждого свой. Поэтому при выборе механизма обмена разнотипным данными между предикатами был отдан расчет на логический способ организации.
Также существует 2 типа – логического вывода: обратный и прямой логический вывод. В сложных системах медицинских консультаций еще применяют комбинацию этих типов: какое-то множество знаний выводится одним типом, а на его основе уже применяется другой.
Прямой вывод заключается в нахождении следствия на основе множества фактов и последующего вывода из новых следствий других заключений. Он эффективен когда существует множество связанных на разных уровнях гипотез, которые нужно доказать или когда множество аксиом для вывода много больше гипотез.
Обратный вывод устроен наоборот, сначала выбирается гипотеза, которую нужно доказать, а затем происходит попытка доказать посылку этой гипотезы, пока не будет найдена очередная посылка в качестве аксиомы.
В ЭС рассуждения на правилах, реализованы методом обратного логического вывода, который использует Пролог. Был выбран такой вариант, так как в отличие от прямого вывода, он эффективнее работает при данных знаниях, поскольку количество целевых вершин много больше фактов и нет конкурирующих гипотез (они независимы).
Реализация
----------
На языке Пролог правила реализованы в виде предиката rule. Каждое правило имеет свой номер и название, которое является гипотезой (заключением), которую нужно доказать. Условию правила соответствует неявное утверждение, которое полностью определяет истинность гипотезы.
Условие правила:
```
Colclusion(K)=C1(K) and (C2(K) or C3(K)) and C4(K)
```
C1(K) = Истинны все заключения правил с номерами, записанных в первом списке для K-ого правила
С2(K) = Истинно хотя бы одно правило из второго списка для K-ого правила
С3(K) = Истинно ровно N(K) заключений правил из второго списка для K-ого правила
C4(K) = Предикат для K-ого правила(предикат doc(K)), который описывает пользователь.
Если любой список пуст, значит соответствующее утверждение истинно.
При этом в предикат для C4 можно вписать любые другие предикаты, но при этом они не должны нарушать логический смысл заключения. Для поддержки отрицания, какого-то существующего заключения в базе знаний можно вписать сюда и его.
Механизм вывода обеспечивает применение правил в нужной последовательности и сохраняет трассировку.
Главные принцип вывода – чтобы доказать истинность заключения, доказать последовательно все его заключения в первом списке, затем доказать заключения второго списка и в конце проверить истинность предиката соответствующего номеру текущего правила. Для проверки второго списка, в случае нахождения хотя бы одного истинного правила, будут проверены все дальше идущие правила до конца списка.
Описание предикатов
-------------------
В общем, принцип кодирования знаний реализован на Прологе с помощью двух предикатов в следующем виде:
rule(K,”Текст заключения — имя правила”, Id, List1, List2, N)
doc(K)
K — номер правила
Id — Идентификатор данных для данного правила
List1 – первый список номеров правил
List2 – второй список номеров правил
N – число истинных заключений
Причем rule всегда записывается как факт, без переменных, и его истинность, как было сказано, определяет помимо списков, соответствующий предикат doc.
Вот несколько примеров записи знаний:
rule(93,«TASH — TASH-score 43% »,tashSc10,[47],[],0)
rule(33,«TASH – Избыток оснований – есть сумма баллов»,none,[],[29,30,31,32],1).
В предикате doc, могут использоваться любые другие предикаты, что дает возможность сопоставить тексту утверждения правила множество любых ситуаций, которые можно описать посредством Пролога.
Таким образов все знания записываются с помощью этих двух предикатов.
В предикатах doc в основном вызываются функции пользовательского интерфейса, так как некоторые правила по смыслу неразрывно связаны с ответом пользователя или в них проводятся проверки на допустимые значения.
Например, предикаты doc для правил, истинность которых зависит от интервала, в котором находится суммарный балл, делают соответствующие проверки.
Предикат doc для диагностирования заболеваний сепсиса использует дополнительный предикат docc, позволяющий не задавать пользователю лишних вопросов. Например, если признак требует наличия хотя бы двух признаков, при отрицательном ответе уже на два признака система не должна задавать еще вопросы, так как очевидно что признак не может быть истинным. Для этого в предикате docc предусмотрена проверка на наличие в базе данных более двух отрицательных ответов. Также нет смысла задавать третий вопрос, если уже есть ответ на два вопроса, достаточных для установления истинности результирующего признака.
Предикат kolNeg(Количество) ищет количество отрицательных ответов в базе данных для данной группы признаков. Для этого он сначала ищет всевозможные признаки данной группы признаков, чтобы не перепутать их с другими группами, а затем считает их из множества в базе данных с помощью предиката kol\_neg\_list\_in\_db, работающего со списком признаков данной группы.
Примеры кода
------------
Проект большой, поэтому приведу наиболее важные отрывки.
Листинг 2 — Список правил
```
rule(11,"Sepsises - SIRS призн. 1: t>38C или t<36С",sirsPr1,[],[],0).
rule(12,"Sepsises - частота сердечных сокращений>90",sirsPr2,[],[],0).
rule(13,"Sepsises - частота дыхания>20 или PaCO2<32mmHg",sirsPr3,[],[],0).
```
Листинг 3 — Список фактов
```
fact1(sirsPr1,"SIRS","SIRS призн. 1: t>38C или t<36С").
fact1(sirsPr2,"SIRS","частота сердечных сокращений>90").
fact1(sirsPr3,"SIRS","частота дыхания>20 или PaCO2<32mmHg").
fact1(sirsPr4,"SIRS","кол-во лейкоцитов>12.000/mm>3, <4.000/mm>3 или >10% band").
```
— Список логических следствий
```
tash_score(1,tashSc1,0,8,"Вероятность прогноза <5%").
tash_score(2,tashSc2,9,9,"Вероятность прогноза 6%").
tash_score(3,tashSc3,10,10,"Вероятность прогноза 8%").
```
Листинг 4 — Машина вывода
```
sizeList([],0):-!.
sizeList([_|T],Size):-
sizeList(T,SizeTail),
Size=SizeTail+1.
append_der_list([],List,List).
append_der_list([H|L1],List2,[H|L3]):-
append_der_list(L1,List2,L3).
any2(NeedSize,NeedSize,_,[],[],_):-!.
any2(_,_,[],[],[],_):-!.
any2(NeedSize,Size,[H|T1],[H|T2],[FirstDer|OtherDer],Why):-
Nomer=[H],
go(Nomer,UnderFirstDer,Why),
rule(H,Text,_,_,_,_),
FirstDer=tree(Text,unmarked,UnderFirstDer,0),%der(H,UnderFirstDer),
Size1=Size+1,!,
any2(NeedSize,Size1,T1,T2,OtherDer,Why).
any2(NeedSize,Size,[_|T1],List,OrDer,Why):-
!,any2(NeedSize,Size,T1,List,OrDer,Why).
go([],[],_):-!.
go([H|T],[FirstDer|OtherDer],Why):-
rule(H,Name,_,ListAnd,ListOr,KolOr),
NewWhy=[Name|Why],
go(ListAnd,UnderFirstDer,NewWhy),
goOr(ListOr,KolOr,_,OrDer,NewWhy),
append_der_list(UnderFirstDer,OrDer,TwoDers),
FirstDer=tree(Name,unmarked,TwoDers,0),
asserta(why_trace(NewWhy)),
doc(H,NewWhy),
go(T,OtherDer,Why).
goOr([],_,[],[],_):-!.
goOr(ListOr,KolOr,ListYes,OrDer,Why):-
KolOr<>0,
any2(KolOr,0,ListOr,ListYes,OrDer,Why),
sizeList(ListYes,KolOr).
goOr(ListOr,0,ListYes,OrDer,Why):-
any2(100000,0,ListOr,ListYes,OrDer,Why),
sizeList(ListYes,KolListYes),
KolListYes>0.
```
Листинг 5 — вывод конечных следствий
```
tashQuestion(Id):-
fact2(Id,_,Prisnak,_),
pos(Prisnak),!.
tashQuestion(Id):-
fact2(Id,_,Prisnak,_),
neg(Prisnak),fail,!.
tashQuestion(Id):-
fact2(Id,_,Prisnak,Ball),
not(neg(Prisnak)),
not(pos(Prisnak)),
dialog_ynw(Prisnak,Ans),
tash_in_data_base(Ans,Prisnak,Ball),!.
tash_in_data_base("y",Prisnak,Ball):-
asserta(pos(Prisnak)),sum_tash(Sum1),Sum2=Sum1+Ball,asserta(sum_tash(Sum2)),!.
tash_in_data_base("n",Prisnak,_):-
asserta(neg(Prisnak)),!,fail.
tash_in_data_base(_,_,_):-
write("\nTASH-not correct answer"),!,fail.
oneQuestion(Id):-
fact1(Id,_,Prisnak),
pos(Prisnak),!.
oneQuestion(Id):-
fact1(Id,_,Prisnak),
not(neg(Prisnak)),
question_sepsis(Prisnak),!.
```
Выводы
------
Надеюсь, эта статья поможет начинающим построить свою экспертную систему. | https://habr.com/ru/post/436722/ | null | ru | null |
# Ванильный JavaScript и HTML. Никаких фреймворков. Никаких библиотек. Никаких проблем
Используете для создания приложений Vue, React, Angular или Svelte? Я использую, и если вы тоже, и уверен, что вам уже давно не приходилось писать приложение, которое выводит информацию без этих прекрасных инструментов.
Когда-то многие из нас писали веб-приложения только с помощью тех средств, что были встроены в браузер. И хотя современные инструменты помогают нам абстрагироваться от этого (и имеют много других преимуществ), всё ещё полезно знать, что происходит у них под капотом.
При выводе небольшого количества информации вам может потребоваться использовать HTML, JavaScript и DOM без каких-либо инструментов. Недавно я написал несколько базовых примеров, которые иллюстрируют основы веб-разработки и помогают в изучении DOM, HTML, JavaScript и принципов работы браузера. Этот опыт позволил мне понять, что другие разработчики — возможно, вы, — будут рады вспомнить, как выводить информацию без использования библиотек.
Кроме того, это забавно, полезно и помогает понять ценность современных библиотек и фреймворков, которые делают за нас так много работы.
Давайте рассмотрим разные способы вывода информации. И держите под рукой эту [документацию](https://developer.mozilla.org/ru/docs/Web/API)!
Образец приложения
------------------
Вот приложение, которое я продемонстрировал в своей статье. Оно извлекает список персонажей и выводит их при нажатии на кнопку. Также приложение отображает индикатор выполнения при извлечении списка.
Инструменты
-----------
Важно выбрать правильные инструменты. В этом упражнении нам нужно отобразить в браузере информацию с помощью конкретных инструментов, доступных всем нам. Никаких фреймворков. Никаких библиотек. Никаких проблем.
Мы будем использовать только HTML, [TypeScript](http://www.typescriptlang.org/?wt.mc_id=johnpapanet-blog-jopapa)/JavaScript, CSS и браузерную DOM (объектную модель документа). Давайте посмотрим, как можно отобразить HTML.
*Здесь вы можете почитать о том, как [писать на TypeScript с помощью VS Code](https://code.visualstudio.com/docs/languages/typescript?wt.mc_id=johnpapanet-blog-jopapa).*
Как вы могли заметить, я использую [TypeScript](http://www.typescriptlang.org/?wt.mc_id=johnpapanet-blog-jopapa). Особенности его набора прекрасно помогают избегать багов, и я пользуюсь его возможностью транспилирования в любой формат JavaScript. Если хотите, можете использовать чистый JavaScript. В будущем я напишу статью о том, [как транспилировать TypeScript](http://www.typescriptlang.org/docs/handbook/tsconfig-json.html?wt.mc_id=johnpapanet-blog-jopapa).
Подход
------
Наше приложение отображает индикатор выполнения и список персонажей. Начнём с самого простого — индикатора, — и рассмотрим разные способы его отображения. Затем перейдём к списку и разберёмся, как меняется ситуация, если нужно выводить больше информации.
Отображение индикатора выполнения
---------------------------------
Индикатор должен отображаться, пока приложение решает, какие персонажи должны попасть в список. То есть сначала индикатор невидим, затем пользователь нажимает кнопку обновления, индикатор появляется, и снова исчезает после отображения списка.
Все нижеописанные методики требуют размещения элементов по мере их создания. Например, индикатор и список персонажей где-то должны располагаться. Одним из решений является ссылка на существующий элемент, уже содержащий их. Или можно ссылаться на элемент и заменять его новыми данными.
### Отображение индикатора с помощью внутреннего HTML
Создать HTML и поместить его внутрь другого элемента — это самое старое решение, но оно работает! Выбираете элемент, в котором появится индикатор, а затем задаёте для новых данных свойство `innerHtml`. Обратите внимание, что мы также пытаемся сделать код удобочитаемым с помощью шаблонных строк, позволяющих охватывать несколько строк.
```
const heroPlaceholder = document.querySelector('.hero-list');
heroPlaceholder.innerHTML = `
`;
```
Просто. Легко. Почему так нельзя сказать про любой код? Ну посмотрите, как быстро этот фрагмент решает проблему!
Вероятно, вы уже заметили, насколько уязвим этот код. Одна ошибка в HTML — и всё! У нас проблема. И действительно ли он удобочитаем? Да, это так, но что будет, когда HTML станет слишком сложным? Когда у вас 20 строк кода с классами, атрибутами и значениями… ну, вы поняли. Да, решение не идеальное. Но при небольшом количестве HTML вполне работает, и я рекомендую присмотреться к нему любителям всё писать в одну строку.
Также обратите внимание, как встроенный контент может влиять на удобочитаемость и стабильность кода. Например, если вам нужно добавить информацию внутрь индикатора для изменяющегося сообщения о загрузке, то можно сделать это с помощью замены, например, `${message}`. Это не хорошо и не плохо, просто добавляет удобство при создании больших шаблонных строк.
И последнее: `innerHTML` *может* влиять на скорость отображения. Я не увлекаюсь избыточной оптимизацией, но лучше проверяйте производительность, потому что `innerHTML` может быть причиной возникновения циклов отрисовки и вывода макетов в браузере. Имейте в виду.
### Индикатор выполнения с помощью DOM API
Уменьшить громоздкость длинных строк можно с помощью DOM API. Создаём элемент, добавляем необходимые классы и атрибуты, задаём значения, а потом добавляем его в DOM.
```
const heroPlaceholder = document.querySelector('.hero-list');
const progressEl = document.createElement('progress');
progressEl.classList.add('hero-list', 'progress', 'is-medium', 'is-info');
const maxAttr = document.createAttribute('max');
maxAttr.value = '100';
progressEl.setAttributeNode(maxAttr);
heroPlaceholder.replaceWith(progressEl);
```
Преимущество в том, что нужно писать больше кода и полагаться на API. То есть по сравнению с `innerHTML` при опечатках повышается вероятность, что система сообщит об ошибке, которая поможет найти причину проблемы и придумать решение.
А недостаток в том, что требуется шесть строк кода для вывода информации, которая выводится одной строкой с помощью `innerHTML`.
Код DOM API для отображения индикатора более читабелен, чем код с `innerHTML`? Я бы поспорил. А не в том ли причина, что HTML-код индикатора очень короткий и простой? Возможно. Если бы было 20 строк, то `innerHTML` стал бы гораздо сложнее в чтении… впрочем, и код DOM API тоже.
### Отрисовка индикатора с помощью шаблонов
Ещё один способ заключается в создании тега и использовании его для упрощения вывода информации.
Создадим и присвоим ему ID. Шаблон не будет отображён на HTML-странице, но позднее вы можете ссылаться на его содержимое и использовать его. Это очень полезно, вы можете писать HTML везде, где это целесообразно: на HTML-странице, с применением всех полезных возможностей HTML-редактора.
```
```
Затем код может взять шаблон с помощью метода `document.importNode()` из DOM API. По мере необходимости код может манипулировать содержимым шаблона. Теперь добавьте это содержимое в DOM, чтобы отобразить индикатор.
```
const heroPlaceholder = document.querySelector('.hero-list');
const template = document.getElementById('progress-template') as HTMLTemplateElement;
const fetchingNode = document.importNode(template.content, true);
heroPlaceholder.replaceWith(fetchingNode);
```
Шаблоны — хороший способ сборки HTML; мне он нравится, потому что позволяет писать HTML там, где это имеет смысл, и можно меньше делать с помощью кода на TypeScript/JavaScript.
Можно ли импортировать шаблоны из других файлов? Да, но с помощью других библиотек. Однако сейчас мы от них сознательно отказались. Импорт HTML обсуждается годами, но, как видно из материалов сайта [«Can I Use»](https://caniuse.com/#feat=imports), даже не все современные браузеры поддерживают эту возможность.
Отображение списка персонажей
-----------------------------
Теперь поговорим о том, как можно отображать список персонажей с помощью тех же трёх методик. Отличие от отрисовки одиночного HTML-элемента и списка персонажей заключается в том, что теперь мы:
* отображаем несколько HTML-элементов;
* добавляем несколько классов;
* добавляем определённую последовательность из дочерних элементов;
* отображаем для каждого персонажа много одинаковой информации;
* динамически отображаем текст внутри элементов.
### Отображение персонажей с помощью внутреннего HTML
При использовании `innerHTML` целесообразно начать с массива персонажей и итерировать его. Таким образом можно создавать по строке за раз. Строки будут отличаться только именами персонажей и описанием, которые можно вставлять с помощью шаблонных строк. Каждый персонаж в массиве создаёт тег `li`, который связывается со строчным массивом. Наконец, строчный массив преобразуется в чистый HTML, обёрнутый в `ul` и назначенный для `innerHTML`.
```
function createListWithInnerHTML(heroes: Hero[]) {
const rows = heroes.map(hero => {
return `- ${hero.name}
${hero.description}
`;
});
const html = `${rows.join('')}
`;
heroPlaceholder.innerHTML = html;
```
Это работает. И *возможно*, это более удобочитаемо. Что насчёт производительности? Трудно ли выявить (или вообще возможно?) опечатки при наборе кода? Судить вам. Но давайте не будем делать выводов, пока не разберёмся с другими методиками.
### Отображение персонажей с помощью DOM API
```
function createListWithDOMAPI(heroes: Hero[]) {
const ul = document.createElement('ul');
ul.classList.add('list', 'hero-list');
heroes.forEach(hero => {
const li = document.createElement('li');
const card = document.createElement('div');
card.classList.add('card');
li.appendChild(card);
const cardContent = document.createElement('div');
cardContent.classList.add('card-content');
card.appendChild(cardContent);
const content = document.createElement('div');
content.classList.add('content');
cardContent.appendChild(content);
const name = document.createElement('div');
name.classList.add('name');
name.textContent = hero.name;
cardContent.appendChild(name);
const description = document.createElement('div');
description.classList.add('description');
description.textContent = hero.description;
cardContent.appendChild(description);
ul.appendChild(li);
});
heroPlaceholder.replaceWith(ul);
}
```
### Отображение персонажей с помощью шаблонов
Список персонажей можно отобразить с помощью шаблонов. Для этого применяется та же методика, что и для отображения элемента . Сначала на HTML-странице создаём шаблон. Этот HTML-код будет чуть сложнее, чем в случае с . Но это не проблема. Это просто HTML внутри HTML-страницы, так что мы можем легко исправлять ошибки и форматирование с помощью прекрасного редактора [VS Code](https://code.visualstudio.com/?wt.mc_id=johnpapanet-blog-jopapa).
```
-
```
Теперь можете написать код для создания списка персонажей. Сначала создаём `ul` для обёртывания строк с персонажами `li`. Теперь можно проходить по массиву и с помощью того же метода `document.importNode()` применять один и тот же шаблон для каждого персонажа. Обратите внимание, что шаблон можно многократно использовать для создания каждой строки. Он превращается в чертёж-исходник, по которому создаётся необходимое количество строк.
Список персонажей должен содержать имена и описания. То есть нужно будет заменять конкретные значения внутри шаблона. Для этого целесообразно каким-то образом определять и ссылаться на места, куда вы будете вставлять эти значения. В нашем примере для получения ссылки на каждого персонажа используется метод `querySelector('your-selector')`, после чего задаётся имя и описание.
```
function createListWithTemplate(heroes: Hero[]) {
const ul = document.createElement('ul');
ul.classList.add('list', 'hero-list');
const template = document.getElementById('hero-template') as HTMLTemplateElement;
heroes.forEach((hero: Hero) => {
const heroCard = document.importNode(template.content, true);
heroCard.querySelector('.description').textContent = hero.description;
heroCard.querySelector('.name').textContent = hero.name;
ul.appendChild(heroCard);
});
heroPlaceholder.replaceWith(ul);
}
```
Этот шаблон проще других методик? Я считаю, что *относительно* проще. С моей точки зрения, код построен по шаблону, который упрощает воспроизведение и читабельность, а также лучше защищает от ошибок.
Итоги
-----
Я не упомянул о том, как отображают информацию популярные фреймворки и библиотеки. Vue, React, Angular и Svelte существенно облегчают задачу и требуют писать меньше кода. Также у них есть и другие преимущества. В этой статье мы рассмотрели лишь относительно простые методики вывода информации с помощью DOM и чистого HTML, а также TypeScript/JavaScript.
К чему мы пришли?
Надеюсь, вы теперь представляете, как выводить информацию без использования библиотек. Есть ли другие способы? Конечно. Можно написать функции, которые упростят код и позволят использовать его многократно? Конечно. Но однажды вам захочется поэкспериментировать с одним из таких прекрасных инструментов, как Vue, React, Angular или Svelte.
Эти фреймворки делают за нас много работы. Вы можете помнить, как выводить информацию с помощью чистого DOM-кода с JavaScript или jQuery. Или как делать это с помощью инструментов вроде handlebars или mustache. А может быть, вы никогда не выводили информацию в DOM без помощи фреймворка. Можете сами представить, какие процессы протекают под капотом современных библиотек и фреймворков, когда они выводят для вас информацию на экран.
Полезно знать, что можно сделать с помощью чистого HTML, TypeScript/JavaScript и CSS, даже если вы используете фреймворк, который избавляет вас от всего этого.
Вне зависимости от вашего опыта, я надеюсь, что вам был полезен этот краткий экскурс в некоторые методики отображения информации. | https://habr.com/ru/post/483726/ | null | ru | null |
# Немного о проектировании самосинхронных схем
На форумах по электронике периодически вспоминают о самосинхронных схемах, но очень мало кто понимает, что это вообще такое, какие полезные свойства есть у самосинхронных схем, и какими недостатками они обладают. Краткий текст ниже позволит читателю ознакомиться с азами синтеза простейших самосинхронных схем, и самому попробовать их проектировать.
В начале несколько вводных слов. Асинхронными можно называть любые схемы без внешнего тактирования. При этом различные виды асинхронных схем используют разный принцип работы, и самосинхронные схемы – всего лишь одна из их разновидностей. Под самосинхронными обычно понимают т.н. полумодулярные схемы, из-за возможности их представления в виде алгебраических структур, составляющих полумодулярные решетки (да простят меня математики за возможные неточности). Одна из особенностей полумодулярных (читать — самосинхронных) схем – независимость от задержек, что на практике означает работоспособность схемы в любых условиях, при которых транзисторы способны переключаться. Впрочем, никто не мешает проектировать самосинхронные схемы на механических реле или любых других перключателях. Не секрет, что разрабатывать такие схемы очень сложно, но зато им не грозит отказ из-за перегрева, к примеру, или эффектов старения.
С введением всё, и можно переходить к практике. По способу проектирования все самосинхронные схемы можно разделить на две группы – автоматы управления, и схемы с большим количеством логики. Откуда берется такое разделение. Автоматы управления, это несложные устройства вроде счетчиков, защелок, триггеров, или каких-то небольших контроллеров. Эти устройства в основном проектируют вручную с помощью сетей Петри (графовый язык описания параллельных динамических процессов), а затем синтезируют в Petrify или других тулах. Под схемами с большим количеством логики следует понимать привычные всем узлы вычислительных устройств: контроллеры периферии, ПДП, блоки арифметики, да все что угодно, где используется умножение, сложение, сравнение, мультиплексирование и т.д. Подобные схемы слишком сложно описываются сетями Петри, и проектируются иначе (это тема отдельного цикла публикаций, а то и целого учебника). Поэтому начнем с азов, с сетей Петри.
Возьмем в качестве примера простейший самосинхронный счетный триггер. Как и все самосинхронные схемы, он работает по тому же принципу, что и кольцевой генератор на инверторах:
Сигнал *P* является счетным, сигналы *x0,x1,y0,y1* – внутренними, пара {*q0,q1*} – выходные сигналы счетчика, а *cd* – индикатор окончания переходных процессов в схеме. Если сигнал *cd* замкнуть на счетный вход *P*, автомат будет работать бесконечно. Кто желает, может в этом убедиться при помощи привычного всем моделирования:
**Исходный код нетлиста с тестбенчем**
```
`timescale 1ns/10ps
module sim();
wire P,cd;
counter dut(.P(P), .cd(cd));
assign P = cd;
initial begin
force P=0;
force dut.x0=0;
force dut.x1=1;
#2;
release P;
release dut.x1;
release dut.x0;
end
endmodule
module counter(
input wire P,
output wire cd
);
wire x0, x1, y0, y1, q0, q1;
nand2 U1 (.A(y0), .B(x1), .Y(x0));
nand2 U2 (.A(y1), .B(x0), .Y(x1));
nand2 U3 (.A(y0), .B(x0), .Y(q0));
nand2 U4 (.A(y1), .B(x1), .Y(q1));
nand3 U5 (.A(P), .B(q0), .C(y1), .Y(y0));
nand3 U6 (.A(P), .B(q1), .C(y0), .Y(y1));
nand2 U7 (.A(q0), .B(q1), .Y(cd));
endmodule
module nand2(
input wire A, B,
output wire Y
);
assign #1 Y = ~(A & B);
endmodule
module nand3(
input wire A, B, C,
output wire Y
);
assign #1 Y = ~(A & B & C);
endmodule
```
Обратите внимание, что у логических элементов обязательно должна быть ненулевая задержка, а схема требует начальной установки. В железе (если кто то попробует сделать эту схему на ПЛИС или россыпи) начальная установка не требуется.
А теперь займемся реверс-инжинирингом, чтобы понять, как получить схему счетного триггера с помощью сетей Петри. Выберем произвольную начальную расстановку значений на выходах элементов (можно взять из моделирования, или придумать самим):
Поскольку *P=cd*, то значение *P* в следующий момент времени должно измениться на 1. Построим граф, в вершинах которого будут переменные, а ребра – направление переключения переменных. Переменные пометим знаком +, если они переключились из 0 в 1, а знаком минус, если они переключились из 1 в 0. Граф введем в редакторе Workcraft ( можно скачать бесплатно с сайта [http://www.workcraft.org](http://www.workcraft.org/). Выбираем меню File — Create work — Signal Transition Graph, и вводим граф). Начальное переключение сигнала *P* из 0 в 1 (т.е. P+) пометим входящей срелкой с кружком (токеном). Получится граф:
После переключения *P* в 1 следует переключение сигнала y0 в 0, затем x0 в 1, и т.д., пока не вернемся к началу. Как видно из графа, выходные переменные {*q1,q0*} переключаются в цикле *10-11-01-11-10-11* и т.д., что соответствует работе счетного триггера. Можно включить режим симулятора работы сети Петри, для этого надо нажать на иконку зеленого треугольника в правом нижнем окне Editor Tools, а затем запустить симуляцию в появившемся выше окне Tool Controls.
Следующий шаг – синтез графа в Petrify. Выбираем в меню Tools – Synthesis – Complex gate synthesis [Petrify], и получаем лог:
Синтез прошел успешно (что означает, что схема является ~~полумодулярной~~ самосинхронной), а полученные формулы соотвествуют исходной схеме. Реверс инжиниринг успешно выполнен.
Из графа становится очевидно, что работоспособность счетного триггера не зависит от задержек: в какое бы место схемы Вы не добавили задержку, это лишь замедлит его работу, но не изменит порядок переключения элементов и не нарушит логику работы схемы.
Описанные процедуры (в порядке: от графа к схеме) позволяют синтезировать и проверять на самосинхронность только схемы защелок, триггеров, счетчиков, либо произвольных контроллеров, чье поведение описывается сетью Петри, содержащей не более 50 переменных. Более сложные схемы приведенным способом разрабатывать нельзя (необходимо использовать другие подходы к проектированию). Но для изучения основ разработки самосинхронных схем, рассмотренный пример счетного триггера (а так же туториалы из дистрибутива workcraft) – самое то. Заинтересовавшимся теорией рекомендую почитать учебник по сетям Петри и самосинхронным схемам: *Мараховский В. Б., Розенблюм Л. Я., Яковлев А. В. Моделирование параллельных процессов. Сети Петри*, а так же изучить материал на сайте разработчиков [workcraft](http://www.workcraft.org/). | https://habr.com/ru/post/306056/ | null | ru | null |
# Язык программирования C∀ (CForAll)
Мой интерес к дизайну языков программирования приводит меня иногда к интересным, но почти неизвестным в широких кругах проектам. Один из таких проектов - язык C∀ (CForAll), разрабатываемый в University of Waterloo. C∀ является расширением ISO C и обеспечивает обратную совместимость с C. Помимо исправления некоторых недостатков Си (которые можно исправить без нарушения обратной совместимости), в C∀ есть некоторые весьма интересные и оригинальные фичи: некоторые расширения классических управляющих операторов, альтернативный синтаксис объявления квалификаторов, кортежи и множественные операции, оригинальное расширение ссылок, полиморфизм, сопрограммы и т.д.
Данная статья представляет собой краткий конспект официального руководства по языку, с некоторыми моими комментариями.
---
Лексика
-------
Первое мелкое, но важное улучшение - подчеркивания в числовых литералах. При этом несколько подчеркиваний подряд ставить нельзя.
```
2_147_483_648; // decimal constant
56_ul; // decimal unsigned long constant
0_377; // octal constant
0x_ff_ff; // hexadecimal constant
0x_ef3d_aa5c; // hexadecimal constant
3.141_592_654; // floating constant
10_e_+1_00; // floating constant
0x_ff_ff_p_3; // hexadecimal floating
0x_1.ffff_ffff_p_128 l; // hexadecimal floating long constant
L_"\x_ff_ee "; // wide character constant
```
Если требуется объявить идентификатор, совпадающий с ключевым словом, то используется вот такой синтаксис:
```
int ``otype = 3; // make keyword an identifier
double ``forall = 3.5;
```
Выражения и управляющие операторы
---------------------------------
### Оператор возведения в степень
Во многих языках пытаются его ввести, и везде придумывают разные операторые символы (^, \*\* и т.п.). На этот раз обратный слэш. Приоритет, как и полагается, выше чем у умножения.
```
x\y; // pow(x,y)
x\=y; // x=pow(x,y)
```
### Улучшенный оператор множественного выбора
По недостаткам "сишного" оператора `switch` проходятся все кому не лень. Всем известная особенность - в большинстве случаев нам не нужно выполнение всех последующих case-блоков после того, как был выполнен необходимый нам блок. Для предотвращения выполнения последующих блоков используется `break`, однако программисты иногда забывают его поставить. Во всех современных языках уже перешли на `match`, лишенный этого недостатка. Кроме того, в сишном `switch` можно вставлять недостижимый код перед первым `case`, и накладывать на switch другие блоки кода (Duff’s device). Все это запрещено в новом операторе `choose`. В нем `break` не требуется, а если нужно явно перейти к следующему блоку - предлагается использовать оператор `fallthru` (или `fallthrough` - первый раз вижу, чтобы два ключевых слова обозначали одно и то же).
Внутри case можно объявлять несколько паттернов через запятую; применять диапазоны; и несколько диапазонов через запятую.
```
switch ( i ) {
case 1, 3, 5: // ...
case 10 ∼ 15: // ...
case 1 ∼ 5, 12 ∼ 21, 35 ∼ 42: // ...
}
```
### Диапазоны
Кстати, вот синтаксис диапазонов
```
1 ∼ 5 // полуоткрытый диапазон [M,N) : 1,2,3,4
1 ∼ =5 // закрытый диапазон [M,N] : 1,2,3,4,5
1 -∼ 5 // полуоткрытый диапазон [N,M) : 4,3,2,1
1 -∼=5 // закрытый диапазон [N,M] : 5,4,3,2,1
1 ∼ @ // диапазон до бесконечности
1 ∼ @ ∼ 2 // диапазон с указанием шага: 1,3,5,7,...
```
Диапазоны используются не только в case, но и в циклах. По сути эти диапазоны - частный случай List Comprehension ("списковых включений" или "генераторов списков", т.е. неких языковых конструкций, которые изнутри - вычисляемые выражения, а снаружи их можно применять вместо списков значений).
### Улучшенные циклы
Некоторые маленькие улучшения в циклах
#### Цикл for по количеству элементов и по диапазонам
```
for ( i; 5 ) // typeof(5) i; 5 is comparison value
for ( i; 1.5 ∼ 5.5 ∼ 0.5 ) // typeof(1.5) i; 1.5 is start value
for ( 5 ) // for ( typeof(5) i; i < 5; i += 1 )
```
#### Циклы без аргументов - бесконечные циклы
(напомню, в С/С++ можно было написать `for(;;)`, а для while все равно указывать аргумент `true` )
```
while ( / * empty * / ) // while ( true )
for ( / * empty * / ) // for ( ; true; )
do ... while ( / * empty * / ) // do ... while ( true )
```
#### Метки для break и contunue
Как в Java - операторы могут передавать управление на метки. Такие переходы не могут образовывать цикл, и не могут вести внутрь управляющих структур; допускаются только выходы наружу из вложенных блоков.
#### Блок else для циклов
Как в Python - управление передается в блок `else`, если внутри цикла не сработал break (т.е. выход из цикла был естественный, по условию самого цикла).
### Оператор with
Оператор создает новую область видимости и представляет поля своего аргумента как локальные переменные внутри своего блока. Позаимствован из языка Pascal, и обобощает возможность С++ неявно обращаться к полям указателя `this`. Может применяться к функциям или как отдельный блок. Может раскрывать сразу несколько составных объектов. При этом могут возникнуть конфликты имен, которые разрешаются обычным способом - явным уточнением.
```
void f( S & this ) with ( this ) {
c; i; d; // this.c, this.i, this.d
}
```
```
struct Q { int i; int k; int m; } q, w;
struct R { int i; int j; double m; } r, w;
with ( r, q ) {
j + k; // unambiguous, r.j + q.k
m = 5.0; // unambiguous, q.m = 5.0
m = 1; // unambiguous, r.m = 1
int a = m; // unambiguous, a = r.i
double b = m; // unambiguous, b = q.m
int c = r.i + q.i; // disambiguate with qualification
(double)m; // disambiguate with cast
}
```
Обработка исключений
--------------------
Про обработку исключений написано немного, но заявляется, что поддерживаются как обычные исключения с раскруткой стека, так и исключения с возобнолением. Добавлен и отсутствующий в C++ оператор finally.
```
// E - тип исключения
void f() {
// ...
throwResume E{}; ... // resumption
// ...
throw E{}; // termination
}
try {
f();
}
catch( E e ; boolean-predicate ) { // termination handler
// recover and continue
}
catchResume( E e ; boolean-predicate ) { // resumption handler
// repair and return
}
finally {
// always executed
}
```
Альтернативный синтаксис объявления квалификаторов
--------------------------------------------------
Синтаксис объявления переменных С/С++ славится своей сложностью - особенно когда дело касается типов и объектов со множеством квалификаторов, что-то вроде массива указателей на функции, принимающих массивы указателей и возвращающих указатели на массивы. Какие-то квалификаторы относятся к типу, какие-то - к объекту; одни пишутся перед именем переменной, другие - после. Это приводит к различным неоднозначностям, которые я возможно опишу в другой статье.
В современных языках для упрощения парсинга и борьбы с неоднозначностями обычно применяют форму с начальным ключевым словом (`var`, `let` и т.п.) и "типом справа" по отношению к объектам. В С∀ решили сохранить "тип слева", но разместили все квалификаторы перед типом. В результате синтаксис стал однозначным, чтение и запись - простыми и естественными. Вот прямо так: "указатель на массив из 10 указателей на целое": `*[10]*int` . Да, теперь все квалификаторы относятся к типу, и исчезла возможность объявлять разные квалификаторы для разных переменных в одной строке; но и в других языках (в которых "тип справа") этой возможности нет. Фактически, это исключительная особенность С/С++, не так уж и часто используемая.
Еще примеры. Читается очень просто, не так ли?
```
const * [ 5 ] const int y; // const pointer to array of 5 const integers
const * const int x; // const pointer to const integer
static * const int y; // internally visible pointer to constant int
```
Что интересно, в С∀ в целях обратной совместимости оставили и старый синтаксис деклараций. Понятно что это криво, но здесь интересна сама идея того, как можно упростить сложные декларации, а не конкретная реализация.
Указатели и ссылки
------------------
В большинстве языков указатели требуют явного разыменования. В некоторых языках, таких как Алгол68, осуществляется неявное разыменование указателей в выражениях.
```
p2 = p1 + x; // compiler infers *p2 = *p1 + x;
```
Неявное разыменование дает более компактный код. Оно подходит, если работа со значениями значительно более востребована, чем работа с адресами. Для сравнения:
```
* p2 = (( * p1 + * p2) * ( ** p3 - * p1)) / ( ** p3 - 15);
p2 = ((p1 + p2) * (p3 - p1)) / (p3 - 15);
```
Для поддержки неявного разыменования в С∀ введены ссылки. Они похожи на ссылки C++, но отличаются в некоторых аспектах.
```
int x, y, & r1, & r2, && r3;
&r1 = &x // r1 points to x
&r2 = &r1 // r2 points to x
&r1 = &y // r1 points to y
&&r3 = &&r2 // r3 points to r2
r2 = ((r1 + r2) * (r3 - r1)) / (r3 - 15); // implicit dereferencing
```
Инициализация ссылок осуществляется конструкцией `&r = &v` . Важно, что инициализация синтаксически отличается от присваивания `r = v` . В С++ для обоих действий используется обычное присваивание, хотя по смыслу действия были разные - в первом случае брался адрес переменной и сохранялся в ссылке (неявном указателе), во втором - значение переменной записывается по адресу, хранимому в ссылке.
Ссылки могут быть двойными, тройными и т.д. (конструкция `&& r3`). Это полностью аналогично указателям: ссылка на ссылку означает, что переменная - неявный указатель, хранящий адрес другого неявного указателя. Указатели и ссылки взаимозаменяемы, поскольку оба содержат адреса. Отличается только синтаксис
```
int x, *p1 = &x, **p2 = &p1, ***p3 = &p2, &r1 = x, &&r2 = r1, &&&r3 = r2;
*** p3 = 3; // change x
r3 = 3; // change x, ***r3
** p3 = ...; // change p1
&r3 = ...; // change r1, (&*)**r3, 1 cancellation
* p3 = ...; // change p2
&&r3 = ...; // change r2, (&(&*)*)*r3, 2 cancellations
&&&r3 = p3; // change r3 to p3, (&(&(&*)*)*)r3, 3 cancellations
```
Ссылки могут иметь квалификаторы. Сама ссылка & является квалификатором и подчиняется тем же правилам, что и квалификатор указателя и массива.
В противоположность С∀ , ссылки С++ являются неизменяемыми однократно инициализируемыми. Также С++ не поддерживает массивы ссылок.
Смысл инициализации ссылок отличается от присваивания, поскольку она происходит для пустого (неинициализированного) объекта (т.е. до инициализации ссылка никуда не указывает). Поэтому имеет смысл только семантика адреса, т.е. само инициализирующее значение должно быть адресом. Маловероятно, что присвоение значения x указателю осмысленно. Следовательно, при инициализации ссылки требуется адрес, и излишне требовать явного взятия адреса объекта, которым инициализируют ссылку.
```
int * p = &x // assign address of x 9
int * p = x; // assign value of x 10
int & r = x; // must have address of x
```
По той же причине не требуется оператор взятия адреса при передаче по ссылке в функцию. Также если возвращаемое значение - ссылка, то при присваивании результата оператор ссылки не требуется.
```
int & f( int & r ); // reference parameter and return
z = f( x ) + f( y ); // reference operator added, temporaries needed for call results
```
Можно получать адреса и ссылки литералов и выражений. Причем эти адреса и ссылки могут быть не только константными, но и изменяемыми. Компилятор сам создает необходимые временные объекты и использует их адреса.
```
void f( int & r );
void g( int * p );
f( 3 );
g( &3 ); // compiler implicit generates temporaries
f( x + y );
g( &(x + y) ); // compiler implicit generates temporaries
```
Подводя итоги: интуитивно понятно, что авторы сделали полностью симметричную систему ссылок и указателей, с той лишь разницей, что у указателя - явное разыменование при доступе к значению, а у ссылки соответствующая lvalue-операция "взятия адреса" при изменении самой ссылки. Выглядит, по правде говоря, мозгодробительно. Но зато ссылка стала first-class объектом (пусть и специфическим). Стоило ли делать вот именно так? Насколько часто востребована операция неявного разыменования, если все равно используются различные "умные указатели"?
Перечисления
------------
Кроме обычных, в С∀ доступны нецелочисленные (по сути - объектные) перечисления. Базовый тип указывается в круглых скобках после ключевого слова enum.
```
enum( double ) Math { PI_2 = 1.570796, PI = 3.141597, E = 2.718282 }
enum( char * ) Name { Fred = "Fred" , Mary = "Mary" , Jane = "Jane" };
enum( [int, int] ) { T1 = [ 1, 2 ], T2 = [3, 4] }; // tuples
enum( S ) s { A = { 5, 6 }, B = { 7, 8 } }; // struct S { int i, j; };
```
Перечисления одного типа могут "наследоваться" - точнее, "включаться" одно в другое.
```
enum( char * ) Name2 { inline Name, Jack = "Jack" , Jill = "Jill" };
enum Name3 { inline Name2, Sue = "Sue" , Tom = "Tom" };
```
Разумеется, имена в базовом перечислении и в перечислении-наследнике должны быть уникальными.
Структуры
---------
### Безымянные поля структур
Можно вставлять в структуры любое количество безымянных полей. Это может быть полезно, например, для формирования каких-то структур с зарезервированными полями.
```
struct {
int f1; // named field
int f2 : 4; // named field with bit field size
int : 3; // unnamed field for basic type with bit field size
int ; // disallowed, unnamed field
int * ; // disallowed, unnamed field
int ( * )( int ); // disallowed, unnamed field
};
```
### Вложенные структуры
В Си можно описывать одну структуру внутри другой, но она все равно будет располагаться в глобальном пространстве имен. В С∀ исправили эту странность - имя объемлющей структуры стало пространством имен для вложенной. В отличие от С++, в С∀ для доступа ко вложенным сущностям используется точка, а не `::`
### Встраивание
Одну структуру можно встроить в другую так, как это реализовано в Go (и даже лучше - используется ключевое слово `inline`). Это очень простая и в то же время мощная концепция, прямо готовая для proposal'а в очередной стандарт С и/или С++... Удивительно - почему ее сразу не сделали в Си?
```
struct Point { double x, y, x; };
struct ColoredPoint {
inline Point; // anonymous member (no identifier)
int Color;
};
ColoredPoint cp;
cp.x = 10.3; // x from Point is accessed directly
cp.Color = 0x33aaff;
```
Кортежи
-------
### Множественный возврат из функций
В Си и в большинстве языков программирования функция возвращает только одно значение; но иногда нужно больше. Чтобы вернуть больше, применяют агрегацию (возврат структуры с несколькими полями) или возврат через аргументы по указателю/ссылке. В С∀ сделана попытка реализации непосредственного возврата из функции нескольких значений. Для этого используются квадратные скобки:
```
[ char, int, double ] f()
{
return [ 'c', 123, 3.14 ];
}
```
Использование нескольких возвращаемых значений:
```
int quot, rem; 37
[ quot, rem ] = div( 13, 5 );
```
Каждый элемент кортежа может быть чем угодно, в т.ч. и другим (вложенным) кортежем.
### Передача сразу нескольких значений в функцию
При передаче в функцию кортеж разворачивается сразу в несколько значений.
```
printf( "%d %d\n" , qr ); // print quotient/remainder
```
### Объявление объектов кортежей
```
[ double, int ] di;
[ double, int ] * pdi;
[ double, int ] adi[10];
```
Можно объявить и сразу инициализировать, например возвратом из функции
```
[int, int] qr = div( 13, 5 );
```
### Доступ к отдельным элементам
Похоже на реализацию в Swift: используются константные номера элементов и оператор "точка" (а для указателей и "стрелка").
```
[int, double] x;
[char * , int] f();
[int, double] * p;
int y = x.0; // access int component of x
y = div(20,7).1; // access int component of functions return
p->0 = 5; // access int component of tuple pointed-to by p 39
y = [ f(), x ].1.0; // access first component of second component of tuple expression
```
### Флаттернизация и структуризация
Кортежи не имеют жесткой структуры и могут при необходимости структурироваться и деструктурироваться. Функция, принимающая несколько аргументов, может принять соответствующий кортеж, и наоборот - функция, принимающая кортеж, может принять несколько аргументов. Т.е. кортежи могут неявно раскрываться и наоборот, неявно формироваться в соответствии с контекстом. Например, есть функция и ее вызов:
```
int f(int, [double, int]);
f([5, 10.2], 4);
```
Сначала список аргументов раскрывается в `5, 10.2, 4`, затем структурируется в `5, [10.2, 4]`.
### Присваивание
Предусмотрено "массовое" и "множественное" присваивание
```
[y, x] = 3.14; // mass assignment
[x, y] = [y, x]; // multiple assignment
```
При множественном присваивании размеры кортежей должны совпадать. Оба вида присваивания распараллеливаются.
### Множественный доступ к полям структур
Еще одна красивая фича:
```
struct S { char x; int y; double z; } s;
s.[x, y, z] = [ 3, 3.2, ' x ' ];
f( s.[ y, z ] );
```
Функции
-------
### Именованные аргументы
Функцию вида `void foo( int x, int y, int z ) {...}` можно вызывать с именованными аргументами:
```
foo( z : 3, x : 4, y : 7 );
```
### Аргументы по умолчанию
Фича как в С++ и множестве других языков. Однако, можно пропускать аргументы не только в конце списка, но и в любом другом месте, просто поставив нужное количество запятых.
```
void p( int x = 1, int y = 2, int z = 3 ) {...}
p(); // rewrite ⇒ p( 1, 2, 3 )
p( 4, 4 ); // rewrite ⇒ p( 4, 4, 3 )
p( , 4, 4 ); // rewrite ⇒ p( 1, 4, 4 ) -- можно пропускать в начале!
p( 4, , 4 ); // rewrite ⇒ p( 4, 2, 4 ) -- и в середине
p( , , 4 ); // rewrite ⇒ p( 1, 2, 4 )
p( , , ); // rewrite ⇒ p( 1, 2, 3 )
```
### Вложенные функции
В С∀ функции можно объявлять внутри других функций. Такие вложенные функции не являются first-class объектами, т.е. это не полноценные "лямбды" с "замыканиями", их нельзя возвратить из функции в качестве результата и они не захватывают объекты из объемлющего контекста. Но тем не менее вложенные функции могут обращаться к локальным переменным объемлющих. Такая реализация ближе всего к вложенным процедурам Pascal.
```
int foo() {
int i = 7;
void bar( int j ) {
i += j;
}
bar(10);
return i;
}
```
### Постфиксные функции
Альтернативный синтаксис вызова, при котором аргумент указывается перед именем функции. Обычно используется для преобразования базовых литералов в пользовательские литералы, где `?`` `обозначает имя постфиксной функции, а` ``` обозначает вызов постфиксной функции. Например, следующий код преобразует литералы, представляющие физические величины, в другие единицы измерения.
```
double ?`ft(double f) { return f / 3.28084; }
printf("100 feet == %f meters\n", 100`ft);
```
Постфиксные функции могут быть и с несколькими аргументами, в этом случае постфикс применяется к кортежу.
Перегрузка
----------
### Перегрузка функций
Язык поддерживает перегрузку функций. Что интересно, заявлена поддержка перегрузки по возвращаемому значению.
```
int f();
double f();
f(); // ambiguous
(int)f(); // choose "int f()"
```
### Перегрузка операторов
Также можно перегружать операторы. Используется специальный синтаксис со знаками вопроса, обозначающими операнды. Оператор {} - это "конструктор", используемый для инициализации объектов.
```
type Complex = struct {
double real;
double imag;
}
void ?{}(Complex &c, double real = 0.0, double imag = 0.0) {
c.real = real;
c.imag = imag;
}
Complex ?+?(Complex lhs, Complex rhs) {
Complex sum;
sum.real = lhs.real + rhs.real;
sum.imag = lhs.imag + rhs.imag;
return sum;
}
```
### Перегрузка переменных
Да, такое тоже возможно. Несколько переменных разных типов с одним именем:
```
int pi = 3;
float pi = 3.14;
char pi = .p.;
```
Полиморфизм
-----------
Одна из ключевых особенностей С∀ - это перегружаемые параметрически-полиморфные функции, обобщенные с помощью оператора forall (язык назван именно по этому ключевому слову). Внешне - что-то вроде шаблонной функции:
```
forall( otype T ) T identity( T val ) { return val; }
int forty two = identity( 42 );
```
Эту функцию можно применить к любому полному объектному типу (`otype`). C∀ передает размер и выравнивание типа, представленного параметром `otype`, а также оператор присваивания, конструктор, конструктор копирования и деструктор. Если эта дополнительная информация не нужна, например, для указателя, параметр типа может быть объявлен как тип данных (`dtype`). Еще бывает `ftype` (функциональный тип) и `ttype` (тип-кортеж).
Поддерживается что-то вроде концептов. Например, это работает для всех типов, поддерживающих сложение:
```
forall(otype T | { T ?+?(T,T); }) T twice (T x) { return x+x; }
int val = twice(twice(3));
```
Уcловия концептов можно группировать в трейты
```
trait sumable( otype T ) {
void ?{}( T &, zero_t ); // constructor from 0 literal
T ?+?( T, T ); // assortment of additions
T ?+=?( T &, T );
T ++?( T & );
T ?++( T & );
};
```
и затем использовать
```
forall( otype T | sumable( T ) ) // polymorphic, use trait
T sum( T a[ ], size_t size ) {
T total = 0; // instantiate T from 0 by calling its constructor
for ( i; size ) total += a[i]; // select appropriate +
return total;
}
int sa[ 5 ];
int i = sum( sa, 5 ); // use int 0 and +=
```
Паралеллизм
-----------
Заявлена поддержка стековых и бесстековых сопрограмм, а также потоков. Интересное решение - имя main с аргументом соответствующего типа используется как имя главной функции (точки входа) сопрограммы или потока.
### Генераторы
Генераторы - бесстековые сопрограммы (т.е. они используют стек вызывающей стороны). Ключевое слово suspend используется для приостановки корутины и возврата управления в вызывающий контекст, и ключевое слово resume - для возобновления выполнения корутины с того места, где она вернула управление.
```
generator Fibonacci {
int fn; // used for communication
};
void main( Fibonacci & fib ) { // called on first resume
int fn1, fn2; // retained between resumes
fib.fn = 0;
fn1 = fib.fn; // 1st case
suspend; // restart last resume
fib.fn = 1;
fn2 = fn1;
fn1 = fib.fn; // 2nd case
suspend; // restart last resume
for () {
fn = fn1 + fn2; fn2 = fn1; fn1 = fn; // general case
suspend; // restart last resume
}
}
int next( Fibonacci & fib ) {
resume( fib ); // restart last suspend
return fib.fn;
}
```
### Корутины
Стековые сопрограммы также поддерживаются
```
#include
#include
// match left/right parenthesis: ((())) match, (() mismatch
enum Status { Cont, Match, Mismatch };
coroutine CntParens {
char ch; // used for communication
Status status;
};
void main( CntParens & cpns ) with( cpns ) { // coroutine main
unsigned int cnt = 0;
for ( ; ch == '('; cnt += 1 ) suspend; // count left parenthesis
for ( ; ch == ')' && cnt > 1; cnt -= 1 ) suspend; // count right parenthesis
status = ch == ')' ? Match : Mismatch;
}
void ?{}( CntParens & cpns ) with( cpns ) { status = Cont; }
Status next( CntParens & cpns, char c ) with( cpns ) { // coroutine interface
ch = c;
resume( cpns );
return status;
}
int main() {
CntParens cpns;
char ch;
for () { // read until end of file
sin | ch; // read one character
if ( eof( sin ) ) { sout | "Mismatch"; break; } // eof ?
Status ret = next( cpns, ch ); // push character for checking
if ( ret == Match ) { sout | "Match"; break; }
if ( ret == Mismatch ) { sout | "Mismatch"; break; }
}
}
```
### Мониторы
Конструкции, аналогичные структурам, но с неявной (генерируемой компилятором) защитой полей от одновременного доступа из разных потоков.
```
monitor Account {
const unsigned long number;
float balance;
};
```
### Потоки
```
#include
#include
thread T {
int id;
};
void ?{}( T & t ) { t.id = 0; }
void ?{}( T & t, int id ) { t.id = id; }
void main( T & t ) with( t ) { // thread starts here
sout | id;
}
int main() {
enum { NumThreads = 5 };
T t[ NumThreads ]; // create/start threads
T \* tp[ NumThreads ];
for ( i; NumThreads ) {
tp[i] = new( i + 1 ); // create/start threads
}
for ( i; NumThreads ) {
delete( tp[i] ); // wait for thread to terminate
}
}
```
Что дальше
----------
Это очень краткий обзор, упускающий многие детали и не рассматривающий некоторые вопросы. [Страница проекта](https://cforall.uwaterloo.ca). На сайте есть ссылка на гитхаб. Также в сети есть несколько публикаций, посвященных разным аспектам языка.
Все это можно проверить (что я и делал в некоторых непонятных случаях): исходники компилятора и инструкции для сборки доступны на гитхабе. Единственная особенность - сборка зачем-то требует рута, нужна запись в /usr/local/bin и возможно еще куда-то. Наверное это можно исправить, но я не специалист в сборочных скриптах make, да и под виртуалкой как-то без разницы.
Лично мне всегда интересно посмотреть на альтернативные языки программирования, альтернативные и расширенные реализации привычных вещей. То, что язык не слишком сильно отличается от самых распространенных языков - для меня плюс, не нужно ломать мозги для адаптации к новому синтаксису, а можно спокойно изучать новые идеи в привычном окружении. Надеюсь что вам тоже понравилось. | https://habr.com/ru/post/587428/ | null | ru | null |
# Делаем собственный NTP-сервер Stratum-1
На написание этой заметки меня натолкнул хабраюзер [BarsMonster](https://habrahabr.ru/users/barsmonster/) со своим топиком [«О точном времени»](http://habrahabr.ru/blogs/sysadm/79461/).
В своей статье он призывал хабраюзеров «Давать больше Stratum-1 серверов», но не сказал как (:
#### Выбор источника точного времени
Я проделывал эту работу примерно три года назад, когда в сети информации по этой теме было гораздо меньше. Основным источником моих познаний была документация из пакета ntp-doc (/usr/share/doc/ntp-doc/html/refclock.html), также её можно найти в [сети](http://www.eecis.udel.edu/~mills/ntp/html/refclock.html).
Само название Stratum-1 означает, что наш NTP-сервер непосредственно подключен к источнику точного времени.
Давайте посмотрим какие у нас есть варианты этих источников:
1. **Радиостанции точного времени**
Ничего сложного, берём подходящую частоту из [справочника](http://yandex.ru/yandsearch?text=%D0%A1%D0%BF%D1%80%D0%B0%D0%B2%D0%BE%D1%87%D0%BD%D0%B8%D0%BA+%D0%BA%D0%BE%D1%80%D0%BE%D1%82%D0%BA%D0%BE%D0%B2%D0%BE%D0%BB%D0%BD%D0%BE%D0%B2%D0%B8%D0%BA%D0%B0&from=os&lr=213), паяем приёмник и преобразователь в удобный для компьютера интерфейс. ^\_^
Я забросил этот вариант, т.к. напротив моей старой работы стояло здание то ли ФАПСИ, то ли ещё какой-то службы, в общем эфир был довольно зашумлён (-:
2. **Телефон GSM или CDMA**
Как-то я им не доверяю, хотя не самый плохой вариант.
3. **Приёмник GPS или ГЛОНАСС**
Этот вариант мне показался самым реальным.
#### Подключаем
Приёмник ГЛОНАСС тогда было сложно достать, поэтому я пошел в магазин и купил GPS-приёмник с RS232-м интерфейсом и внешней антенной. Антенну прилепил на металлический подоконник за окном, а приёмник соответственно подключил к COM-порту одного из серверов.
Первым делом нам нужно убедиться что приёмник «видит» спутники. Мой, например, в этом случае начинает весело подмигивать светодиодом.
Более универсальный способ — посмотреть что он отдаёт в COM-порт:
> cat /dev/ttyS0
Тут мы должны увидеть дамп протокола NMEA.
#### Настраиваем
Для работы ntpd нам нужно сделать символические ссылки:
> /dev/gps0 -> /dev/ttyS0
>
>
Если вы используете udev, то полезно будет создать правило /etc/udev/rules.d/10-gps.rules следующего содержания:
> KERNEL==«ttyS0», NAME="%k", SYMLINK+=«gps0», MODE=«0660», GROUP=«uucp»
>
>
Модифицируем ntp.conf:
> # Local Clock — если теряем спутники, то снижаем stratum до 10
>
> server 127.127.1.0
>
> fudge 127.127.1.0 stratum 10
>
>
>
> # NMEA GPS driver
>
> server 127.127.20.0 prefer
>
>
>
> driftfile /var/lib/ntp/ntp.drift
>
> restrict default nomodify notrust # Отдаём время всем
>
> restrict 127.0.0.1 # Разрешаем себе всё
>
> disable auth
>
> logfile /var/log/ntp/messages
>
>
В строке server 127.127.20.0 число 20 — это ответ на «главный вопрос жизни, вселенной и вообще» номер соответствующего [драйвера источника точного времени](http://www.eecis.udel.edu/~mills/ntp/html/drivers/driver20.html).
Перезапускаем NTPD и смотрим статус. Должно быть что-то подобное:
> `ntpq -p
>
> remote refid st t when poll reach delay offset jitter
>
> ==============================================================================
>
> LOCAL(0) LOCAL(0) 10 l 52 64 377 0.000 0.000 0.002
>
> *GPS_NMEA(0) .GPS. 0 l 15 64 377 0.000 -0.018 0.004`
>
>
Всё, сервер можно пиарить регистрировать в [списке stratum-1 серверов](http://support.ntp.org/bin/view/Servers/StratumOneTimeServers).
Надеюсь эта статья поможет увеличить количество хороших NTP-серверов в рунете (-;
**[Важный UPD]**
Мне тут человек постучался в IM, у него нет аккаунта на Хабре, просил меня прояснить ситуацию с переходниками COM-USB. Цитирую:
> brn:
>
> Так вот, так как в приёмниках часто один из служебных пинов COM разъёма заведён на 1PPS сигнал, который обозначает начало очередной секунды, в случае USB этот сигнал будет потерян
>
> А, так сигнал NMEA без PPS даёт точность порядка 50-100 миллисекунд, а для сервера точного времени это неприемлимо
>
>
Это как раз проясняет почему у меня был такой разбег с коллегой из Новосибирска — мой приёмник PPS не поддерживал.
Чтобы использовать PPS, нужно в конфиг ntp заменить NMEA на PPS:
> # PPS driver
>
> server 127.127.22.0 prefer
>
> enable pps
>
>
**[UPD2]**
Встречаем нового хабраколлегу [brn](https://habrahabr.ru/users/brn/)!
Он уже успел написать [топик про NMEA](http://brn.habrahabr.ru/blog/79701/).
[BarsMonster](https://habrahabr.ru/users/barsmonster/), спасибо за инвайт. | https://habr.com/ru/post/79629/ | null | ru | null |
# Анонсирована разработка шрифтов STIX версии 2.0.0, направленная на улучшение их текстовой составляющей
Создание так называемых «текстовых» шрифтов является одним из сложнейших, тончайших и благороднейших искусств. Действительно, во всех ситуациях они призваны не только простимулировать чувство уважения к набранному тексту, но и учесть множество мелких и не очень технических и тактических нюансов, связанных с традициями того или иного языка. Кроме этого, в зависимости от конкретной сферы использования задачи перед таким шрифтом ставятся поистине грандиозные: если это вузовский или даже школьный учебник, то – всячески поддерживать в пытливом уме читателя огонёк интереса к науке, не стесняясь овевать его элементами «академического духа», но не подавая признаков сухости и не допуская ни малейшей «эстетической перегрузки»; если документ, имеющий юридическую силу, – чётко выдерживать атмосферу строгости и нейтральности, не допуская жёсткости и колючести; в художественном или публицистическом произведении – способствовать максимально быстрому и скользяще лёгкому чтению с минимальным застреванием взгляда на непривычных деталях шрифтового рисунка; наконец, в научной работе, словаре или энциклопедии – кроме всего прочего, обеспечить авторов всем необходимым набором символов, позаботившись о предупреждении случаев нежелательного сходства (О+0, I+l+1, v+ʋ+ν+υ…). Последняя категория требует гигантских финансовых (так, уже к 2007 году, к стадии беты с довольно ограниченным набором символов, на создание шрифтов STIX было потрачено [около миллиона долларов](http://www.councilscienceeditors.org/wp-content/uploads/v31n1p011.pdf)), организационных и человеческих ресурсов, и мегакорпорации типа Microsoft или Google в этом случае вынуждены идти на компромисс с точки зрения проработки рисунков: например, символ единицы в Segoe UI – основном шрифте Microsoft для интерфейсов и веб-документации – представлял собою такой ужас, что к выпуску Windows 8 [был радикально изменён](http://www.istartedsomething.com/20120302/segoe-ui-gets-a-subtle-facelift-in-windows-8).
В советское время решения всех этих проблем возлагались на научно-исследовательские институты, разрабатывавшие отдельные, утверждаемые ГОСТами гарнитуры с непритязательными названиями ([Школьная](http://standartgost.ru/%D0%93%D0%9E%D0%A1%D0%A2%203489.23-71), [Обыкновенная новая](http://standartgost.ru/%D0%93%D0%9E%D0%A1%D0%A2%203489.9-71), [Энциклопедическая](http://standartgost.ru/%D0%93%D0%9E%D0%A1%D0%A2%203489.29-71), [Литературная](http://standartgost.ru/%D0%93%D0%9E%D0%A1%D0%A2%203489.33-72), [Журнальная](http://standartgost.ru/%D0%93%D0%9E%D0%A1%D0%A2%203489.25-71)), а в современных реалиях на переднем краю фронта сражаются выдержанные в стиле «Таймс» творения под предводительством «Times New Roman» и STIX (всевозможные модификации незабвенного кнутовского [Computer Modern](http://en.wikipedia.org/wiki/Computer_Modern), не очень подходящие для набора хоть чего-то, отличающегося от математических абстракций и квантовомеханических выкладок, не имеют никакого отношения к веб-дизайнерам: в прямом начертании они чрезмерно сухи, а в курсиве – по-старомодному тяжеловесны; что же касается Cambria, то… это [отдельный](http://typophile.com/node/32739) разговор). Но если первый несвободен с лицензионной и зачастую откровенно [небрежен](http://www.paratype.ru/e-zine/defis_07/times/Zarub.HTM) с художественной и типографской точек зрения, то второй на данный момент времени олицетворяет главную надежду тех, кто стремится блюсти эстетическое качество текстов, относящихся к точным наукам.
И честно-то говоря, я, давно и с нетерпением следя за развитием проекта, думал, что должны пройти ещё лет пятьдесят, пока STIX, с недавних пор доступный как в веб-, так и в LaTeX-версии, дойдёт до того уровня оснащённости OpenType-фичами, на котором сейчас находится шрифт Times New Roman версии 6.80, но на минувшей неделе внезапно [блеснул лучик надежды](http://www.stixfonts.org)!
> …рады сообщить, что версия 2.0.0 – новое поколение STIX – в настоящее время находится в разработке. В этом релизе внимание будет обращено главным образом на значительную доработку текстовой части шрифта и приведение ее в соответствие с высокими требованиями профессионалов в области научно-технического издательства и учёных…
>
>
Ориентировочным сроком названо начало 2015 года, но по предыдущему опыту могу сказать, что буду рад, если реальный продукт выйдет хотя бы к концу 2015.
Вообще, прежде всего, чтобы представлять себе уровень шрифта STIX – рекомендую, помимо [википедии](http://en.wikipedia.org/wiki/STIX_Fonts_project), посмотреть на [историю его развития](http://www.stixfonts.org/proj_timeline.html) и прочесть [этот pdf-документ](http://www.councilscienceeditors.org/wp-content/uploads/v31n1p011.pdf) (к сожалению, аж 2007 года давности).
Не повторяя того что там изложено, лишь обращу внимание на «забавный» факт: рождение звезды в далёком 1995 году стало возможным благодаря… ресурсу Elsevier (человеку по имени Arie de Ruiter) – организации, чья деятельность, помнится, в прошлом году [упоминалась](http://habrahabr.ru/post/190024) как минимум в двух [статьях](http://habrahabr.ru/post/189944) на Хабрахабре, но, увы, в несколько негативном аспекте…
Именно STIX является главной рабочей лошадкой javascript-проекта MathJax, пришедшего в качестве стандарта на отображение математических формул в браузерах и используемого как в Википедии, так и в [Stackexchange](http://www.mathjax.org/stack-exchange-continues-as-mathjax-partner-3). На MathJax вынуждены [ссылаться](https://code.google.com/p/chromium/issues/detail?id=152430) и хроморазработчики, пока не способные внедрить поддержку MathML в своё детище, а в браузере Firefox даже само по себе зарождение нормального рендеринга MathML стало возможным только благодаря STIX.
Итак, вопрос первый: что из себя представляет «текстовая часть» STIX на данный момент? Пока ровно ничего из того, что пригодилось бы для текста на русском языке: кернинговые пары для латиницы, пригодные для использования на размерах от 8 до 12 пунктов (с точки зрения веб-дизайнера это эквивалентно полному отсутствию кернинга) и несколько стандартных лигатур.
Вопрос второй: что такое желаемый (только с точки зрения автора этих строк, разумеется) уровень текстовой части? Для наглядной демонстрации лучше всего, пожалуй, будет привести исходный текст в формате HTML+CSS и картинку того, во что его отрендерит Firefox. Сделаю это в порядке собственных приоритетов: ударения, кернинг, надстрочные и подстрочные индексы, дроби и регистрозависимый режим, причём поскольку Times New Roman лишён трёх последних фич, придётся использовать, допустим, Constantia:
```
СВЁКЛОПОДЪЁ́МНИК УЗНАЮ́Т
СВЁКЛОПОДЪЁ́МНИК УЗНАЮ́Т
Удивительный = DEVASTATING
Удивительный = DEVASTATING
Катера ходят от точки *A*₁ до точки *B*₂
Катера ходят от точки *A*1 до точки *B*2
и встречаются на пристани с 7⁴⁰ до 17³⁵
и встречаются на пристани с 740 до 1735
Бассейны заполнены на 4/5 и 1/8 объема
Бассейны заполнены на 4/5 и 1/8 объема
ЗНАНИЕ – СИЛА! ТАНК Т-34
ЗНАНИЕ – СИЛА! ТАНК Т-34
``` | https://habr.com/ru/post/225165/ | null | ru | null |
# Пишем расширение под PHP (7.0.7) без знаний о С/C++ и как это вообще работает
Можно ли написать свой модуль (расширение) к PHP без особых знаний, требующих большого времени изучения теории? Если умеешь программировать на самом PHP, то написать простейший код на С не составит особого труда, тем более, что PHP позволяет генерировать каркас под разрабатываемое расширение, в рамках которого потом пишешь код. Есть еще набирающий популярность [зефир на хабре](https://habrahabr.ru/post/194838/) для этого вопроса. Данная публикация для тех, кто решил покопаться в исходниках PHP, немного посмотреть его внутренности, преследуя цель лишь поверхностного исследования. В данный момент я тот же самый исследовать без необходимых знаний. На собеседованиях по PHP часто просят написать код подсчета [факториала](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%BA%D1%82%D0%BE%D1%80%D0%B8%D0%B0%D0%BB). Вот такую функцию мы и напишем сейчас на С, которую потом можно вызывать из кода PHP. Я буду описывать действия, которые я сам делал и при этом ничего не знаю изначально по этой части. В интернете можно найти много статей по этому вопросу, большинство из них описывает информацию с использованием zval «старого» формата, но я не думаю, что будет хуже если и я еще добавлю от себя.
В PHP есть уже готовый инструмент ./ext\_skel (находится в папке ext), который генерирует будущий шаблон (каркас) для расширения. Я не буду описывать все, что им генерируется и зачем (сам особо в этом ничего еще не понимаю и не знаю), а просто распишу минимальные правки, которую решат нашу задачу. Весь процесс происходит в CentOS 7.
Создаем каркас для будущего расширения mathstat, которое будет содержать функцию factorial().
```
[root@localhost ext]# ./ext_skel --extname=mathstat
Смотрим, что содержится в папке mathstat.
[root@localhost mathstat]# ls
config.m4 config.w32 CREDITS EXPERIMENTAL mathstat.c mathstat.php php_mathstat.h tests
```
После выполнения команды создания расширения, будет выдана следующая вспомогательная информация.
```
To use your new extension, you will have to execute the following steps:
1. $ cd ..
2. $ vi ext/mathstat/config.m4
3. $ ./buildconf
4. $ ./configure --[with|enable]-mathstat
5. $ make
6. $ ./sapi/cli/php -f ext/mathstat/mathstat.php
7. $ vi ext/mathstat/mathstat.c
8. $ make
```
В PHP7 файла buildconf после генерации у меня нет (наверное это остатки ранних версий PHP), но я знаю, что сейчас компиляция расширений начинается с команды phpize. Она “создает” кучу файлов, среди которых есть необходимый ./configure. Напомню, что пользовательский вариант компиляции расширения состоит в последовательном выполнении следующих команд.
```
Phpize -> ./configure -> make -> make test -> make install
```
Если сразу сделать эту последовательность команд, то make install по не ясным причинам будет ломаться и выдавать ошибку на копирование. Если кто в курсе, отпишите, в комментариях, почему так.
```
[root@localhost eugene]# make install
Installing shared extensions: /usr/local/lib/php/extensions/no-debug-non-zts-20151012/
cp: cannot stat 'modules/*': No such file or directory
make: *** [install-modules] Error 1
```
Phpize создает файлы на основе описания config.m4. Это, как я понял, своеобразный декларативный способ описания того, каким будет расширение, будет ли оно подтягивать внешние исходники или нет и т.д… Поэтому просмотрев другие расширения PHP в исходниках, я просто решил его максимально упростить, чтобы минимизировать ошибки компиляций с чистого листа. Действую по принципу — ничего не хочу, «все галочки снимаю».
Открываем этот файл (config.m4) и оставляем только этот текст. Опция “--enable-mathstat” говорит о том, что это просто расширение без внешних исходников (библиотек) и который можно либо включить, либо выключить. (dnl означает комментирование строки)
```
dnl $Id$
PHP_ARG_ENABLE(mathstat, whether to enable mathstat support,
[ --enable-mathstat Enable mathstat support])
if test "$PHP_MATHSTAT" != "no"; then
PHP_NEW_EXTENSION(mathstat, mathstat.c, $ext_shared,, -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1)
fi
```
Перезапускаем команду phpize.
```
[root@localhost mathstat]# phpize
Configuring for:
PHP Api Version: 20151012
Zend Module Api No: 20151012
Zend Extension Api No: 320151012
[root@localhost mathstat]# ls
acinclude.m4 config.guess configure EXPERIMENTAL mathstat.c php_mathstat.h
aclocal.m4 config.h.in configure.in install-sh mathstat.php run-tests.php
autom4te.cache config.m4 config.w32 ltmain.sh missing tests
build config.sub CREDITS Makefile.global mkinstalldirs
```
Далее, делаем знакомые команды:
```
./configure && make
```
make test — запустит один изначально созданный тест. Про эти [тесты PHP](https://habrahabr.ru/post/303116/) я как то писал уже вкратце.
```
[root@localhost mathstat]# make install
Installing shared extensions: /usr/local/lib/php/extensions/no-debug-non-zts-20151012/
```
В этот раз “make install” проходит, далее пробуем прописывать расширение в php.ini.
Определяем, где находится php.ini.
```
[root@localhost mathstat]# php --ini
Configuration File (php.ini) Path: /usr/local/lib
Loaded Configuration File: /usr/local/lib/php.ini
Scan for additional .ini files in: (none)
Additional .ini files parsed: (none)
viim /usr/local/lib/php.ini
extension=mathstat.so
;zend_extension = /usr/local/lib/php/extensions/no-debug-non-zts-20151012/xdebug.so
[root@localhost mathstat]# systemctl restart php-fpm
[root@localhost mathstat]# php -m | grep -i math
mathstat
```
Команда php -m (просматривает все установленные модули) говорит, что вроде бы все нормально, расширение mathstat подгрузилось.
Запускаем в текущей директории тестовый файл mathstat.php
```
[root@localhost mathstat]# php mathstat.php
Functions available in the test extension:
confirm_mathstat_compiled
Congratulations! You have successfully modified ext/mathstat/config.m4. Module mathstat is now compiled into PHP.
[root@localhost mathstat]#
```
Отлично, что — то уже работает.
2. Начинаем реализовывать функцию factorial().
Редактируем файл mathstat.c для добавления функции factorial().
Для этого нужно добавить функцию в “список” mathstat и сделать на неё заглушку, через макрос. Делаю все по аналогии как в других расширениях.
```
const zend_function_entry mathstat_functions[] = {
PHP_FE(confirm_mathstat_compiled, NULL) /* For testing, remove later. */
PHP_FE(factorial, NULL)
PHP_FE_END /* Must be the last line in mathstat_functions[] */
};
```
Реализация функции заглушки. Делается в обертке макроса. Как он работает в итоге, пока не ясно, оставляю изучение себе на будущее. Просто делаю в аналогичном формате.
```
PHP_FUNCTION(factorial)
{
RETURN_LONG(1000);
}
```
В данной случае под каждый тип возвращаемых данных, свой вариант RETURN\_. Поиск в интернете покажет все возможные варианты. У нас просто целое значение. Тут вроде все просто.
Далее повторяем make clean && make && make install
```
[root@localhost mathstat]# make clean
find . -name \*.gcno -o -name \*.gcda | xargs rm -f
find . -name \*.lo -o -name \*.o | xargs rm -f
find . -name \*.la -o -name \*.a | xargs rm -f
find . -name \*.so | xargs rm -f
find . -name .libs -a -type d|xargs rm -rf
rm -f libphp.la modules/* libs/*
Build complete.
Don't forget to run 'make test'.
[root@localhost mathstat]# make install
Installing shared extensions: /usr/local/lib/php/extensions/no-debug-non-zts-20151012/
[root@localhost mathstat]# systemctl restart php-fpm
[root@localhost mathstat]# systemctl status php-fpm
● php-fpm.service - The PHP FastCGI Process Manager
Loaded: loaded (/usr/lib/systemd/system/php-fpm.service; enabled; vendor preset: disabled)
Active: active (running) since Thu 2016-06-16 01:12:22 EDT; 5s ago
Main PID: 32625 (php-fpm)
CGroup: /system.slice/php-fpm.service
├─32625 php-fpm: master process (/usr/local/etc/php-fpm.conf)
├─32626 php-fpm: pool www
└─32627 php-fpm: pool www
Jun 16 01:12:22 localhost.localdomain systemd[1]: Started The PHP FastCGI Process Manager.
Jun 16 01:12:22 localhost.localdomain systemd[1]: Starting The PHP FastCGI Process Manager...
```
Перезапуск php-fpm не показал, что что-то сломали и поэтому идем дальше и тестим наличие функции в расширении. Делаю на всякий случай, даже если компиляция прошла.
```
[root@localhost mathstat]# php mathstat.php
Functions available in the test extension:
confirm_mathstat_compiled
factorial
Congratulations! You have successfully modified ext/mathstat/config.m4. Module mathstat is now compiled into PHP.
```
Наименование функции появилось и более того, теперь мы можем её уже вызывать из кода PHP.
```
[root@localhost mathstat]# php -a
Interactive mode enabled
php > echo factorial(1);
1000
php >
```
Видно, что функция вызвалась и вернула заранее указанное значение 1000.
Научим функцию принимать аргумент и его же отдавать, для этого необходимо сделать описание аргумента функции. Смотрим аналогии в других расширениях PHP (я смотрел bcmath). Куча макросов, но формат понятен, в принципе.
```
ZEND_BEGIN_ARG_INFO(arginfo_factorial, 0)
ZEND_ARG_INFO(0, number)
ZEND_END_ARG_INFO()
```
И добавляем его использование в функции. Если оставлять NULL, то умолчанию считается, что тип аргумента типа int.
```
/* {{{ mathstat_functions[]
*
* Every user visible function must have an entry in mathstat_functions[].
*/
const zend_function_entry mathstat_functions[] = {
PHP_FE(confirm_mathstat_compiled, NULL) /* For testing, remove later. */
PHP_FE(factorial, arginfo_factorial)
PHP_FE_END /* Must be the last line in mathstat_functions[] */
};
```
Немного исправляем тело функции.
```
PHP_FUNCTION(factorial)
{
int argc = ZEND_NUM_ARGS();
long number = 0;
if (zend_parse_parameters(argc, "l", &number) == FAILURE) {
RETURN_LONG(0);
}
RETURN_LONG(number);
}
```
Здесь используется zend\_parse\_parameters, который проверяет переданные аргументы на тип используя формат в кавычках (""), затем по адресу задает принятое значение. Детали можно легко найти в интернете. Для задачи реализации факториала больших знаний пока не нужно.
Проверяем после перекомпиляции (make clean && make && make install).
```
[root@localhost mathstat]# php -r "echo factorial('80');";
80[root@localhost mathstat]# php -r "echo factorial(80);";
80[root@localhost mathstat]#
```
Если передадим строку в аргументе, получим ошибку. Пока не ясно, как на самом деле все это работает до конца, но требуемая задача сделана.
```
[root@localhost mathstat]# php -r "echo factorial('aaaa');";
PHP Warning: factorial() expects parameter 1 to be integer, string given in Command line code on line 1
PHP Stack trace:
PHP 1. {main}() Command line code:0
PHP 2. factorial() Command line code:1
Warning: factorial() expects parameter 1 to be integer, string given in Command line code on line 1
Call Stack:
0.2040 349464 1. {main}() Command line code:0
0.2040 349464 2. factorial() Command line code:1
```
Так как тело функции вроде бы отрабатывает, реализуем теперь сам алгоритм расчета факториала. Как Вы знаете, алгоритм основан на рекурсивном вызове, сделаем тоже самое. Прописываем тело функции calculate() в этом же файле mathstat.c с последующим его вызовом.
```
static long calculate(long number)
{
if(number == 0) {
return 1;
} else {
return number * calculate(number - 1);
}
}
PHP_FUNCTION(factorial)
{
int argc = ZEND_NUM_ARGS();
long number = 0;
if (zend_parse_parameters(argc, "l", &number) == FAILURE) {
RETURN_LONG(0);
}
number = calculate(number);
RETURN_LONG(number);
}
```
Компилируем, перезапускаем, проверяем.
```
[root@localhost mathstat]# php -a
Interactive mode enabled
php > echo factorial(1);
1
php > echo factorial(2);
2
php > echo factorial(3);
6
php > echo factorial(4);
24
php > echo factorial(5);
120
```
Удивительно, но это работает. Получается, чтобы реализовать данную функцию без базовых знаний как там все устроенно в PHP, да и сам язык С/C++ не смотрелся с университета, мне понадобилось не более 3-4 часов. Весь процесс написания кода напоминает работу в каком то фреймворке для PHP. Все что нужно, это изучить архитектуру фреймворка и его API, а дальше работать в рамках его каркаса, тоже самое и здесь.
Особо большого кода по описанному варианту нет, но оставлю [ссылку на github](https://github.com/eugenekurilov/mathstat) | https://habr.com/ru/post/303572/ | null | ru | null |
# [Программирование] Работа со строкой состояния в Android
Статья рассказывает о том как работать со строкой состояния в Android. Статья рассчитана на начинающих программистов под Android только осваивающих разработку под платформу. Также стоит заметить что строка состояния в большей степени используется для уведомления пользователя о каких либо событиях произошедших в системе, что по целевой задаче роднит её со всплывающими уведомлениями Toast. На Хабрахабре уже [имеется](http://habrahabr.ru/blogs/android/85449/) достаточно полная статья о работе с Toast, и данный пост лишь развивает тему уведомлений.
Сам текст статьи писался для песочницы, и по сути Hello world как он есть. Сейчас меня интересует интересно ли вообще кому либо это направление, или же оно того не стоит.
#### Кратко о строке уведомления
На первом скриншоте представлена раскрытая строка состояния в стандартной оболочке Android (некоторые производители мобильных устройств в своих оболочках могут изменить её внешний вид, хотя суть остаётся той же). Строка состояния в Android по большей части используется для уведомления пользователя о каких либо событиях произошедших в системе, а также о результатах работы каких либо приложений. Существенным отличием от всплывающих уведомлений Toast является то что уведомления в строке состояния не пропадают спустя время, и «висят» там до тех пор пока пользователь как-то на них отреагирует. Строку состояния удобно использовать для получения уведомлений от приложений запущенных в фоновом режиме, а также с появлением уведомления можно проиграть какой либо звук, вибрацию, или же воспользоваться мигающими индикаторами на устройстве (если они имеются). Уведомление представленное на скриншоте — именно то чего сегодня мы и будем добиваться.
#### Создание простого уведомления в строке состояния
Для начала попробуем создать стандартное уведомление для командной строки так как это рекомендуют в Google. Разметку интерфейса приложения оставим без изменений (уведомление будет появляться сразу после его запуска). И так, пример кода (с комментарием того что возможно может быть не ясным):
> `public class NotificationBar extends Activity {
>
> /\*\* Called when the activity is first created. \*/
>
>
>
> private static final int NOTIFY_ID = 1; // Уникальный индификатор вашего уведомления в пределах класса
>
> @Override
>
>
>
> public void onCreate(Bundle savedInstanceState) {
>
> super.onCreate(savedInstanceState);
>
> setContentView(R.layout.main);
>
> NotificationManager mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE); // Создаем экземпляр менеджера уведомлений
>
> int icon = android.R.drawable.sym_action_email; // Иконка для уведомления, я решил воспользоваться стандартной иконкой для Email
>
> CharSequence tickerText = "Hello Habrahabr"; // Подробнее под кодом
>
> long when = System.currentTimeMillis(); // Выясним системное время
>
> Notification notification = new Notification(icon, tickerText, when); // Создаем экземпляр уведомления, и передаем ему наши параметры
>
> Context context = getApplicationContext();
>
> CharSequence contentTitle = "Habrahabr"; // Текст заголовка уведомления при развернутой строке статуса
>
> CharSequence contentText = "Пример простого уведомления"; //Текст под заголовком уведомления при развернутой строке статуса
>
> Intent notificationIntent = new Intent(this, NotificationBar.class); // Создаем экземпляр Intent
>
> PendingIntent contentIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);class); // Подробное описание в UPD к статье
>
> notification.setLatestEventInfo(context, contentTitle, contentText, contentIntent); // Передаем в наше уведомление параметры вида при развернутой строке состояния
>
> mNotificationManager.notify(NOTIFY_ID, notification); // И наконец показываем наше уведомление через менеджер передав его ID
>
> }
>
> }`
>
> \* This source code was highlighted with [Source Code Highlighter](http://virtser.net/blog/post/source-code-highlighter.aspx).
**CharSequence tickerText = «Hello Habrahabr»;** — в этой строке мы указываем текст который будет показан в свёрнутой строке состояния на несколько секунд при появлении уведомления. Спустя несколько секунд он исчезнет, а в строке останется лишь иконка.
Вот пожалуй и всё. Можно открывать шампанское, и наблюдать то что у нас получилось.
#### Создание расширенного уведомления в строке состояния
Теперь несколько усложним задачу — мы будем создавать уведомление не по шаблону что предлагает Google, а по собственной разметке (благо такая возможность имеется). И так создадим новый файл разметки в папке layout, у вас он должен получиться таким:
> `<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
>
> android:orientation="horizontal"
>
> android:layout\_width="fill\_parent"
>
> android:layout\_height="fill\_parent"
>
> android:padding="3dp"
>
> >
>
> <ImageView android:id="@+id/image"
>
> android:layout\_width="wrap\_content"
>
> android:layout\_height="fill\_parent"
>
> android:layout\_marginRight="10dp"
>
> />
>
> <TextView android:id="@+id/text"
>
> android:layout\_width="wrap\_content"
>
> android:layout\_height="fill\_parent"
>
> android:textColor="#000"
>
> />
>
> LinearLayout>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Также добавим какую либо картинку в папку drawable дабы потом установить её в ImageView.
Теперь код. Код не сильно отличается от кода простого уведомления, но тем не менее требует комментария
> `public class NotificationBar extends Activity {
>
> /\*\* Called when the activity is first created. \*/
>
>
>
> private static final int NOTIFY\_ID = 1; // Уникальный индификатор вашего уведомления в пределах класса
>
> @Override
>
>
>
> public void onCreate(Bundle savedInstanceState) {
>
> super.onCreate(savedInstanceState);
>
> NotificationManager mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION\_SERVICE); // Создаем экземпляр менеджера уведомлений
>
> int icon = android.R.drawable.sym\_action\_email; // Иконка для уведомления, я решил воспользоваться стандартной иконкой для Email
>
> CharSequence tickerText = "Hello Habrahabr"; // Подробнее под кодом
>
> long when = System.currentTimeMillis(); // Выясним системное время
>
> Intent notificationIntent = new Intent(this, NotificationBar.class); // Создаем экземпляр Intent
>
> Notification notification = new Notification(icon, tickerText, when); // Создаем экземпляр уведомления, и передаем ему наши параметры
>
> PendingIntent contentIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0); // Подробное описание смотреть в UPD к статье
>
> RemoteViews contentView = new RemoteViews(getPackageName(), R.layout.notlayout); // Создаем экземпляр RemoteViews указывая использовать разметку нашего уведомления
>
> contentView.setImageViewResource(R.id.image, R.drawable.habr); // Привязываем нашу картинку к ImageView в разметке уведомления
>
> contentView.setTextViewText(R.id.text,"Привет Habrahabr! А мы тут, плюшками балуемся..."); // Привязываем текст к TextView в нашей разметке
>
> notification.contentIntent = contentIntent; // Присваиваем contentIntent нашему уведомлению
>
> notification.contentView = contentView; // Присваиваем contentView нашему уведомлению
>
> mNotificationManager.notify(NOTIFY\_ID, notification); // Выводим уведомление в строку
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В итоге можем открывать вторую бутылку, и наблюдать примерно такую картину:
#### Добавляем звук и вибрацию, мигаем индикаторами.
Для пущей важности добавим звук при выводе уведомления и вибрацию. Сделать это совсем не сложно.
**notification.defaults |= Notification.DEFAULT\_SOUND;** — данная строка присваивает уведомлению звук что используется в системе по умолчанию.
**notification.sound = Uri.parse(«file:///sdcard/notification/ringer.mp3»);** — таким способом можно установить звук из файла на SD карте.
**notification.defaults |= Notification.DEFAULT\_VIBRATE;** — данная строка добавляет вибрацию в колличестве времени по умолчанию.
Кроме того имеется возможность задать время вибрации самостоятельно. Делается это двумя строчками
**long[] vibrate = {0,100,200,300}**; — создаем массив, в котором 1-ое число — время которое следует подождать до того как запустить вибрацию. Второе значение — время первой вибрации в миллисекундах (аналогично и 3, и 4 значение). Количество вибраций может быть бесконечно большим по усмотрению программиста.
**notification.vibrate = vibrate;** — присваиваем массив нашему уведомлению.
**notification.defaults |= Notification.DEFAULT\_LIGHTS;** — данной строкой мы можем по мигать индикаторами с параметрами по умолчанию.
Конечно можно настроить параметры и в ручную.Для этого нам потребуется 4 строки:
**notification.ledARGB = 0xff00ff00;** — задаем цвет для RGB индикатора.
**notification.ledOnMS = 300;** — задаем время между миганиями
**notification.ledOffMS = 1000;** — задаем время спустя которое горящий индикатор потухнет
**notification.flags |= Notification.FLAG\_SHOW\_LIGHTS;** — разрешаем мигать
Тут следует заметить что далеко не на всех девайсах вообще имеются какие либо индикаторы.
Естественно все эти установки нужно производить до строчки вызова уведомления.
#### Заключение
Вот пожалуй и всё. Пост никак не претендует на полноту, и всё же данной информации должно быть вполне достаточно новичкам. В качестве источника, а также более полного описания работы с NotificationBar могу привести [оригинальную](http://developer.android.com/guide/topics/ui/notifiers/notifications.html) статью на [developer.android.com](http://developer.android.com/). Надеюсь статья поможет кому либо в изучении возможностей платформы. Спасибо за внимание.
UPD: при внимательном рассмотрении выяснилось что комментарий к одной из строчек кода отсутствует (обещается объяснить под кодом, но самого объяснения нет). Досадную ошибку исправляет, а также ряд ф-и строки состояния о которых я сообщить забыл восполняет пользователь [djvu](https://habrahabr.ru/users/djvu/), взглянуть можно в комментариях: [1](http://habrahabr.ru/blogs/android/111238/#comment_3546742), [2](http://habrahabr.ru/blogs/android/111238/#comment_3546811). О существовании серьезных подводных камней сообщает [sdmitry](https://habrahabr.ru/users/sdmitry/) вот [тут](http://habrahabr.ru/blogs/android/111238/#comment_3546874). | https://habr.com/ru/post/111238/ | null | ru | null |
# Оптимизация расходов Yota: попытка #3
Привет, хабр!
Наступило лето и очень многие уезжают из города. Кто-то на время отпуска, а кто-то и на все лето (если работа позволяет). Но одна из главных проблем за городом (для всех людей, так или иначе связанных с IT) — отсутствие нормального проводного быстрого интернета. Но это частично решается благодаря существованию LTE-сетей.
В моем регионе крупных провайдеров LTE всего два: Мегафон и Yota. Мегафон существенно дешевле, но у него есть одна крайне неприятная особенность: ограничение в 20гб трафика в месяц даже на максимальном тарифе.
Поэтому выбор оператора, на мой взгляд, очевиден. Но все же платить за 20 мегабит в два раза больше чем за 100 дома — сомнительное удовольствие. Но при этом, в отличие от других операторов, Yota позволяет в в любой момент бесплатно изменять текущий тариф в личном кабинете с перерасчетом оплаченного времени. Нужна скорость — выкручиваем ползунок на максимум. Нет? Тогда можно снизить скорость и платить меньше. Ну как тут можно удержаться и не автоматизировать этот процесс?
На хабре уже были статьи ([раз](http://habrahabr.ru/post/166721/), [два](http://habrahabr.ru/post/176817/)), описывающие попытки йотоводов-автоматизаторов. Однако, в силу некоторых особенностей, их творения мне не подошли и пришлось написать свой, существенно отличающийся, велосипедОднако, в силу некоторых особенностей, их творения мне не подошли и пришлось написать свой, существенно отличающийся, велосипед.
А начнем мы, пожалуй, с разбора причин, по которым мне не подошли чужие велосипеды. Особо нетерпеливые / материально заинтересованные могут сразу перейти к разделу, описывающему реализацию.
##### Постановка задачи
[Вариант](http://habrahabr.ru/post/166721/) [linx56](https://habrahabr.ru/users/linx56/) мне не подошел ну совсем никак, потому как он работает phantomjs, для работы которого нужно довольно нехилое железо (которым Raspberry PI не является). Да и даже если я поставлю это на свой основной компьютер и оставлю его работать круглосуточно, забив в cron расписание по которому нужно отключать интернет, то я ~~получу счет за электричество больше, чем сэкономлю~~ все равно не получу нормального результата, потому как интернет используется довольно непредсказуемо (и не только мной, но и членами семьи, для которых главное чтобы «просто работало»).
[Второй вариант](http://habrahabr.ru/post/176817/) от [bambrman](https://habrahabr.ru/users/bambrman/) существенно выигрывает у первого тем, что вместо phantomjs использует сильно менее прожерливый curl. Но в остальном все то же самое.
В итоге было решено написать еще один велосипед, в основе которого лежало бы не расписание (или руки человека), а текущая скорость, потребляемая всеми устройствами в локальной сети.
##### Реализация
Я использовал Raspberry Pi и скрипт на Python, который каждые n секунд подключается по SSH к главному домашнему роутеру (TP-LINK WDR4300 с OpenWrt на борту) и при помощи ifconfig стягивает статистику нужного интерфейса.
После этого он считает среднюю скорость за промежуток между последним и предыдущим замером и отправляет ее в модуль, который отвечает за переключение тарифов в соответствии с текущей скоростью и настройками конфига. Чтобы было понятнее, приведу здесь его часть:
```
modes: {
0: 320,
290: 512,
495: 768,
700: 1.0,
900: 2.1,
1900: 3.1,
2900: 4.1,
3900: 6.5,
6500: 8.0,
8000: 10.0,
10000: 15.0,
14800: 20.0
}
```
Как вы видите, в качестве ключа словаря выступает скорость в килобитах, а в качестве значения — тариф йоты.
По результатам замера текущей скорости у нас получилось, скажем, 1530 килобит. Округляем в меньшую сторону до значения ближайшего ключа в конфиге и получаем 900. Соответственно, должен использоваться тариф со скоростью 2.1 мегабит. В случае, если этот тариф уже активен, ничего не происходит. Но вот если тариф нужно повышать, то тут есть одна особенность.
Проблема в том, что если интернет долгое время не использовался (и активировался тариф в 320 кбит/с), а потом кто-то внезапно включил YouTube, то последовательное переключение с 320 кбит/с до 3.1 мбит/с может занять немало времени (не говоря уже о вечно лагающем ЛК Yota). С другой стороны, прыгать каждый раз на максимальный тариф, когда кто-то решил загрузить пару страниц и несколько картинок — тоже плохая идея. В общем я не придумал ничего лучше, чем добавить в конфиг
```
speed_increase_step: 1
```
Этот параметр указывает на размер шага апгрейда между тарифами. То есть при установке speed\_increase\_step = 5, апгрейд с 320 кбит/с произойдет сразу до 3.1 мегабит, а дальше 15.0 и 20.0. И если возможная скорость не будет использоваться полностью, это будет компенсировано механизмом даунгрейда.
###### Даунгрейд
В случае, если активный тариф долгое время не используется в полную силу (текущая скорость не превышает нужного для текущего тарифа порога), скрипт ждет n минут и выполняет переключение на тариф, который удовлетворяет текущим запросам локальной сети (на основании средней скорости). Это самое количество минут задается в параметре hold\_high\_speed\_time в минутах.
```
hold_high_speed_time: 3
```
По сути, основной функционал на этом завершается. Правда, есть еще кое-что, что, возможно, кого-нибудь да заинтересует:
##### Уведомления о смене тарифа через PushBullet
Писалось, как и все остальное, в первую очередь для себя. Но, честно честно говоря, так и не пригодилось, потому как генерирует слишком много спама. Но может кому понравится ;)
Включается это дело все там же, в конфиге:
```
pb_enabled: true
pb_api: v13WA7HYfwj99gUz8rwvK2m7eLN1uheVxZujAgP8gn2su
pb_devices: [
ujAgP8gn2sasFDsgsWhxs,
ujAgP8gn2mkasnuH2Gtga
]
```
Как видите, здесь все довольно просто. pb\_enabled принимает значения true/false. Назначение очевидно.
pb\_api — ваш ключ со страницы [www.pushbullet.com/account](https://www.pushbullet.com/account)
pb\_devices — список идентификаторов устройств, на которые рассылаются уведомления. Взять можно тут: [api.pushbullet.com/v2/devices](https://api.pushbullet.com/v2/devices). При входе вас попросят авторизоваться: просто введите ключ api в поле логина. Полное описание метода тут: [docs.pushbullet.com/v2/devices](http://docs.pushbullet.com/v2/devices/)
Ну что же. ~~Дело сделано, сообщение доставлено.~~ Теперь можно и ~~код показать~~ рассказать, как все это дело готовить.
##### Установка
* Первым делом идем и устанавливаем на свой роутер OpenWrt. Ну или что-нибудь подобное с SSH, авторизацией по ключам и утилитой ifconfig.
* После этого нужно найти что-то вроде Raspberry Pi. То, на чем можно запустить третий питон и где есть ssh-клиент с авторизацией по ключам.
* Настраиваем авторизацию по ключу для подключения к роутеру. Убеждаемся что команда вида (с вашими данными, конечно же) «ssh 192.168.1.1 -p 22 -l root ifconfig» работает без дополнительных вопросов
* Ставим Python 3 и pip. Изначально все писалось и тестировалось на 3.2.3. На совместимость с более ранними версиями тестов не было
* Клонируем репозиторий проекта с GitHub: <https://github.com/wutiarn/yota-speed-controller>
* Делаем cd в папку с репозиторием
* Выполняем pip3 install -r requirements.txt. Обратите внимание, что pip может иметь другое имя (pip-3.2, например)
* Редактируем config.yaml. Описания большинства его параметров есть вверху. Остальные, как мне кажется, в представлении не нуждаются. Ну разве что кроме interface. По умолчанию там указан eth0.2. Обычно в openwrt именно eth0.2 является wan-интерфейсом, но лучше проверить. Также стоит отметить опцию use\_ssh. Если выставить ее в false, то совершенно логично, мониториться будет локальный интерфейс. Ну это на случай если у кого-нибудь в качестве роутера используется полноценный компьютер. Ну или кто-то запустит все это дело прямо на роутере
* После этого запускаем main.py. Можно как напрямую (предварительно дав ему права на исполнения), так и передав интерпретатору питона
* Если все работает, то устанавливаем supervisor (обычно есть в стандартных репозиториях)
* Перемещаем файл yota.conf в папку /etc/supervisor/conf.d/ попутно подправив в нем пути к main.py и, если хотите, к файлу, в который будет писаться лог
* И перезапускаем supervisor командой supervisorctl reload. Демон должен запуститься автоматически. Посмотрите напоследок логи. В них должно быть что-то вроде:
```
2014-07-06 14:16:01,805 [INFO] yota | Initializing
2014-07-06 14:16:11,497 [INFO] yota.web | CURRENT TARIFF: 512
2014-07-06 14:16:11,712 [INFO] yota | Initialised
2014-07-06 14:16:11,718 [INFO] yota | Starting
2014-07-06 14:16:16,016 [DEBUG] yota.current_speed_provider | Current speed: RX: 5 TX: 9. Summary: 14, Time: 3
2014-07-06 14:16:17,262 [INFO] yota.speed_control | Downgrade started: 2014-07-06 14:19:16.022307
2014-07-06 14:16:18,315 [DEBUG] yota.current_speed_provider | Current speed: RX: 7 TX: 19. Summary: 26, Time: 2
2014-07-06 14:16:20,575 [DEBUG] yota.current_speed_provider | Current speed: RX: 12 TX: 20. Summary: 32, Time: 2
```
Вот, собственно, и все. Понимаю, что это некоторое злоупотребление щедростью Yota (хотя, учитывая тарифы, щедростью ли?), но тем не менее смею надеяться, что никто ничего менять не собирается. В конце концов, людей, способных развернуть у себя такое, не так много. А если учесть, что мало кто из них пользуется Yota, то так и вообще мелочь. | https://habr.com/ru/post/228959/ | null | ru | null |
# Detect it to pop it — используем “взрослые” инструменты Intel для решения “детской” задачи
Задачу обнаружения различных объектов сейчас модно решать на основе глубокого обучения. Но для этого нужно собрать и разметить датасет, сконструировать глубокую нейронную сеть, обучить ее и запустить “в продакшн”. И если раньше для всего этого приходилось самостоятельно писать код, то сейчас можно воспользоваться продвинутыми инструментами, призванными упростить процесс. Мы воспользуемся CVAT ([Computer Vision Annotation Tool](https://github.com/openvinotoolkit/cvat)) для разметки датасета, OpenVINO Training Extensions для обучения модели и OpenVINO Object Detection Demo для ее запуска. При этом, мы не напишем ни одной строчки кода (команды консоли не в счет).
Поп-ит и симпл-димпл захватили умы молодежи, и я поддался тренду и тоже приобрел себе круглый цветастый поп-ит. Вдоволь наигравшись с антистресс-игрушкой по прямому назначению, я решил что она может послужить еще одной цели - развитию компетенций в компьютерном зрении.
Так родилась задача обнаружения самого поп-ита на изображениях и детектирования его выпуклых и вогнутых "пупырок". Также важным условием являлся выбор простых инструментов, чтобы не было необходимости разбираться в сложностях конструирования и обучения object detection моделей.
Разметка набора данных с помощью CVAT
-------------------------------------
Собрать и разметить набор данных для задачи object detection - не самая приятная задача для разработчиков. На помощь в этом деле приходит [CVAT](https://github.com/openvinotoolkit/cvat) - инструмент для разметки изображений и видео. Он имеет много интересных возможностей:
* Удобная работа с большими объемами данных - можно разбить разметку большого количества данных на подзадачи и выполнять их независимо, привлекая несколько исполнителей.
* Автоматическая аннотация - можно прогнать ваши изображения через встроенные в CVAT модели глубокого обучения. С их помощью CVAT может сделать за вас часть работы по разметке, останется поправить классы (но с детектированием отдельных пупырок поп-ит такое не получится - в предобученных моделях нет такого класса или классов, на него похожих).
Для небольших проектов достаточно возможностей на сайте [cvat.org](https://cvat.org/). Если возникает необходимость использовать свои DL модели при автоматической разметке, или необходимость разметить очень большой датасет, то можно установить CVAT локально.
Для разметки я сделал 10 фотографий поп-ита в разных ракурсах и разных конфигурациях, упаковал их в zip архив.
Порядок действий при работе с платформой [cvat.org](https://cvat.org/):
1. Пройти регистрацию и выполнить вход на сайте [cvat.org](https://cvat.org/);
2. Создать новый проект, в поле настройки проекта создать три метки классов (popit, pressed, released);
Создаем новый проект, добавляем три класса объектов
3. Открыть проект, в проекте создать новую задачу, в нижнее поле поместить архив с изображениями;
4. Открыть задачу и открыть одну гиперссылку в номере работы для доступа в интерфейс разметки;
5. Разметить изображения инструментом Rectangle;
6. Сохранить изменения и экспортировать разметку в формате MS COCO.
Команда разработки поддерживает [документацию](https://openvinotoolkit.github.io/cvat/docs/getting_started/) о работе с CVAT в актуальном состоянии.
Интерфейс CVAT для разметки очень лаконичен, и визуально напоминает Photoshop. Слева инструменты для разметки, сверху по центру элементы навигации, справа размеченные объекты. На 10 тренировочных изображениях я разметил 290 прямоугольников, с CVAT на это ушло чуть больше получаса. И тут меня настигли сомнения в успешности моей задумки — в некоторых ракурсах я сам не мог понять, выгнуты пупырки наружу или прожаты вниз. Собственно, именно в этот момент в датасеты закрадываются ошибки, их можно встретить в большинстве крупных датасетов, как например в [ImageNet](https://arxiv.org/pdf/2006.07159.pdf). Но желание экспериментов не позволило остановиться в начале пути.
Интерфейс разметки изображений в CVAT, 29 ограничивающих прямоугольников на одно изображениеНа странице CVAT на [GitHub](https://github.com/openvinotoolkit/cvat) есть раздел Screencasts, в нем представлены видео, которые показывают возможности инструмента при разметке изображений и видео.
Обучение модели с помощью Training Extensions
---------------------------------------------
Для обучения модели мы воспользуемся [Training Extensions](https://github.com/openvinotoolkit/training_extensions) - фреймворком для обучения глубоких моделей, с помощью которого обучаются некоторые модели из репозитория Open Model Zoo. Нас интересует Custom Object Detection; для этой задачи в Training Extensions используется модель mobilenet-v2-ssd, предобученная на датасете MS COCO.
Для некоторых моделей нежелательно, чтобы в данных для обучения рамки объектов [пересекались](https://blog.roboflow.com/cvat/). Это снова намекало на неудачный конец моих экспериментов, поскольку больше половины фотографий сделаны в таком ракурсе, что ограничивающие боксы пересекаются. Что ж, все равно продолжим и посмотрим что получится!
Первая стадия - сборка пакета Intel OpenVINO Training Extensions по инструкции из [README.md](https://github.com/openvinotoolkit/training_extensions/blob/develop/README.md), здесь менять ничего не требуется. Поскольку в Windows есть проблемы с выделением всей памяти фреймворку машинного обучения, придется воспользоваться Ubuntu 18.04 или 20.04. Также ограничение на момент июля 2021 - при обучении на GPU требуется CUDA 10.2 (это соответствует драйверу nvidia-440), c версией младше или старше пакет не соберется.
```
cd ~/
git clone https://github.com/openvinotoolkit/training_extensions.git
export OTE_DIR=`pwd`/training_extensions
git clone https://github.com/openvinotoolkit/open_model_zoo --branch develop
export OMZ_DIR=`pwd`/open_model_zoo
cd ~/training_extensions
sudo apt-get install python3-pip
python3 -m venv venv
source venv/bin/activate
pip3 install -e ote/
```
После сборки пакета ote нужно подготовиться к обучению модели детектирования. Для этого модифицируем инструкцию из файла [README.md](https://github.com/openvinotoolkit/training_extensions/blob/develop/models/object_detection/model_templates/custom-object-detection/readme.md) по тренировке модели детектирования объектов под себя.
```
cd ~/training_extensions/models/object_detection
./init_venv.sh
source venv/bin/activate
```
В инструкции обучается модель с самым маленьким размером входного изображения, я беру версию с входным изображением 512\*512, потому что в самой маленькой пупырки будут совсем маленькие по размерам.
```
export MODEL_TEMPLATE=`realpath ./model_templates/custom-object-detection/mobilenet_v2-2s_ssd-512x512/template.yaml`
export WORK_DIR=/tmp/my_model
python ../../tools/instantiate_template.py ${MODEL_TEMPLATE} ${WORK_DIR}
```
Задаем пути к файлам созданного нами датасета в домашней директории и список классов для обучения (не забудьте проверить соответствие путей файлам датасета):
```
export OBJ_DET_DIR=`pwd`
export TRAIN_ANN_FILE="/home/eugene/popit-dataset/train.json"
export TRAIN_IMG_ROOT="/home/eugene/popit-dataset/train"
export VAL_ANN_FILE="/home/eugene/popit-dataset/val.json"
export VAL_IMG_ROOT="/home/eugene/popit-dataset/val"
export CLASSES="popit,pressed,released"
```
Для обучения модели нам нужно определить некоторые параметры - размер пачки, количество эпох, количество GPU (если их несколько). Если при старте обучения у вас программа упала с ошибкой о нехватке памяти, уменьшите размер пачки (16 -> 8 -> 4 -> 2 -> 1). Лучше, конечно, чтобы было хотя бы 8 гигабайт видеопамяти; я сам использовал GTX 1070 Ti, она справляется с размером пачки 16 и для средней модели, и для большой. Итераций можно поставить побольше, на своем датасете из 10 картинок я установил 50 итераций, чтобы обучение укладывалось в полчаса. Фреймворк генерирует код для старта обучения модели в папке `${WORK_DIR}`, где мы потом сможем забрать результаты.
```
cd ${WORK_DIR}
python train.py --load-weights ${WORK_DIR}/snapshot.pth \
--train-ann-files ${TRAIN_ANN_FILE} \
--train-data-roots ${TRAIN_IMG_ROOT} \
--val-ann-files ${VAL_ANN_FILE} \
--val-data-roots ${VAL_IMG_ROOT} \
--save-checkpoints-to ${WORK_DIR}/outputs \
--classes ${CLASSES} \
--gpu-num 1 \
--epochs 50 \
--batch-size 16
```
После обучения можно протестировать результаты на валидационной части датасета, и сохранить изображения с помощью параметра `--save-output-to`, например, на рабочий стол.
```
python eval.py --load-weights ${WORK_DIR}/outputs/latest.pth \
--test-ann-files ${VAL_ANN_FILE} --test-data-roots ${VAL_IMG_ROOT} \
--save-metrics-to ${WORK_DIR}/metrics.yaml \
--classes ${CLASSES} \
--save-output-to ${WORK_DIR}/output_images
```
После обучения и валидации модели сконвертируем модель в формат OpenVINO. Модель состоит из двух файлов - .xml с архитектурой и параметрами сети и .bin с весами. Перед экспортом нужно активировать OpenVINO с помощью скрипта `setupvars.sh`:
```
source ~/intel/openvino_2021/bin/setupvars.sh
pip install -r ~/intel/openvino_2021/deployment_tools/model_optimizer/requirements_onnx.txt
python export.py --load-weights ${WORK_DIR}/outputs/latest.pth --save-model-to ${WORK_DIR}/export
```
В папке `${WORK_DIR}/export` будут храниться модели, в формате onnx и OpenVINO.
Запуск инференса с помощью OpenVINO
-----------------------------------
Запускать инференс модели будем с помощью OpenVINO Object Detection Demo из репозитория Open Model Zoo. В нем можно использовать для детектирования как одно изображение, так и папку с изображениями, а также можно подать на вход видео из файла или с веб-камеры. Чтобы использовать в демо камеру, запускайте с ключом -i 0 (номер камеры).
```
python "C:\Program Files (x86)\Intel\openvino_2021\deployment_tools\open_model_zoo\demos\object_detection_demo\python\object_detection_demo.py" \
-m export_512\model.xml -at ssd -i 0 -t 0.2
```
По результатам тестирования обученной модели видно, что у меня получилось научить модель детектировать сам поп-ит и отдельные пупырки, однако обучить разделять “лопнутые” и “нелопнутые” не удалось. Можно добавить классификационную модель, которая будет их классифицировать, но тогда все же придется программировать конвейер из двух моделей на C++ или Python.
В моем случае не удалось решить задачу на 100%, однако сам поп-ит и пупырки на нем успешно детектируются. Какие можно сделать выводы на будущее:
* Можно решать задачи по обучению глубоких моделей не написав ни строчки кода (если не считать консоль);
* Делать разметку современными инструментами очень удобно;
* Датасет должен быть большой и разнообразный;
* Есть в лопании пупырок что-то успокаивающее.
### Вместо заключения
Мне очень нравится, что инструменты Intel идут в тренде снижения сложности входа в разработку приложений. Такие вещи помогут создавать приложения с применением глубокого обучения более широкому кругу школьников и студентов. Кстати, любую стадию экспериментов можно повторить самостоятельно - и изображения, и разметка, и модели доступны в [репозитории](https://github.com/FenixFly/popit-materials). | https://habr.com/ru/post/568408/ | null | ru | null |
# Разбираемся с условными брейкпоинтами в C++
Для большинства случаев дебаггинга вам должно с головой хватать стандартных точек останова (breakpoints или брейкпоинтов). Но иногда кода для проверки, объектов или случаев попросту слишком много. Что делать, если мы хотим отфильтровать код, генерирующий точку останова? Прошу вас поприветствовать условные точки останова!
В подавляющем большинстве случаев мы ограничиваемся стандартными точками останова функций. Мы просто устанавливаем точку останова в определенной функции и дожидаемся ее вызова. Но если код, который нам необходимо отлаживать, сложен, мы можем воспользоваться дополнительной фичей брейкпоинтов: условиями.
Давайте рассмотрим простой пример: что, если нам нужно отлаживать цикл, который перебирает 100 прямоугольников, и у нас есть подозрение, что прямоугольники большого размера каким-то образом повреждаются в результате обработки в рамках этого цикла? Вы же не будете отлаживать каждую итерацию этого цикла? Вас может еще хватить на первые десять объектов, но перебирать вручную сто или даже тысячу - это безумие! Возможно, мы могли бы установить условную точку останова и работать только с большими прямоугольниками, с которыми у нас возникает проблема.
Вот наш код:
```
// Делаем несколько прямоугольников большими
// left, top, right, bottom
rects[7] = { 10, 100, 200, 0 };
rects[17] = { 10, 100, 200, 0 };
rects[37] = { 10, 100, 200, 0 };
ScanForInvalidRects(rects);
for (auto &r : rects)
{
ScanRectangle(r);
}
ScanForInvalidRects(rects);
```
Похоже, что наш код делает что-то с прямоугольниками, ширина которых больше 100. Поэтому, чтобы отловить эти прямоугольники, мы установим точку останова, подобную той, что показана на **рисунке 1**:
Рисунок 1: Установка точки останова для перехвата интересующих нас прямоугольниковКогда мы будем отлаживать этот код, дебаггер остановится, только если будет удовлетворено указанное нами условие. Мы можем сосредоточиться на проблемных случаях, сэкономив кучу времени.
Как вы могли заметить, в Visual Studio 2015 значительно улучшили диалоговое окно для добавления условий (Conditions) и действий (Actions). Например, вы можете открыть его и продолжать редактировать код. Ранее (как, например, в Visual Studio 2013, показанном на **рисунке 2**) все окна для условий (“Filter”, “Condition” и “When Hit”) были стандартными модальными окнами. Более того, само по себе окно намного чище.
Рисунок 2: Для сравнения аналог окна из Visual Studio 2013 Теперь, когда мы знаем, как создавать простые условия, давайте углубимся в более сложные возможности.
Expression Evaluator (встроенное средство вычисления выражений) — мы можем писать код внутри редактора условий, но есть некоторые ограничения: вы не можете вызывать код, который имеет какие-либо побочные эффекты, создает новые переменные, содержит new/delete или макросы. К сожалению, это также означает, что мы не можем вызвать пользовательскую функцию с локальными переменными, поскольку она изменяет текущее состояние приложения.
Но у нас в арсенале есть ряд встроенных функций `string` ('`strlen`', '`strcmp`', '`strst`', ...), `system` ('`GetLastError`') и некоторые математические функции.
Полный список выражений, которые можно использовать для создания условий, вы найдете в статье MSDN «[Выражения в отладчике](https://msdn.microsoft.com/en-us/library/za56x861.aspx)».
Но это еще не все.
В крайнем случае, если нам нужно создать более сложное условие, которое невозможно реализовать с помощью встроенных условных брейкпоинтов, мы можем задействовать для этого собственный код. Мы можем написать условие в нашем коде и, когда это условие выполняется, вызывать [функцию DebugBreak](https://msdn.microsoft.com/en-us/library/ms679297.aspx). Конечно, наш код нужно перекомпилировать каждый раз, когда мы будем вносить изменения.
По умолчанию окна условий для точек останова позволяют нам накладывать ряд предопределенных условий для ваших локальных переменных, но на них наши возможности не ограничиваются:
* Счетчик срабатываний (Hit Count): точка останова будет срабатывать после заданного количества итераций, например, каждый пятый раз или только в десятый, или после сотой итераций.
* Фильтр (Filter): позволяет фильтровать точки останова на данной машине, процессе или потоке.
Хотя это и не является условием, в окне установки условной точки останова вы можете указать “действие” (action), которое будет выполняться при попадании в точку останова. Например, мы можем вывести значение переменной или текущее состояние стека. Это очень удобно, поскольку означает, что мы можем динамически вставлять трассировочные операторы без перекомпиляции кода.
Условные точки останова дают нам возможность сосредоточиться на конкретных проблемах и случаях. Это особенно важно в ситуациях, когда нужно оперировать огромным количеством объектов или событий. Грамотное использование условных точек останова может сэкономить вам кучу времени.
Код примера можно найти в моем [репозитории на GitHub](https://github.com/fenbf/articles/tree/master/DebuggingTipsSamples).
#### Ссылки:
* [MSDN: Expressions in the Debugger](https://msdn.microsoft.com/en-us/library/za56x861.aspx)
* [StackOverflow: Conditional breakpoint: This expression has side effects and will not be evaluated](http://stackoverflow.com/questions/19778948/conditional-breakpoint-this-expression-has-side-effects-and-will-not-be-evaluat)
* [MSDN: New Breakpoint Configuration Experience in Visual Studio 2015](https://blogs.msdn.microsoft.com/visualstudioalm/2014/10/06/new-breakpoint-configuration-experience-in-visual-studio-2015/)
* [MSDN: Conditional Breakpoints](https://blogs.msdn.microsoft.com/visualstudioalm/2013/10/11/conditional-breakpoints/)
---
> Статья подготовлена в преддверии старта курса [**"C++ Developer. Professional"**](https://otus.pw/fQJ3b/)**.**
>
> А уже сегодня вечером состоится открытое занятие «**ООП глазами C++**». Хоть и модно критиковать ООП-подход к разработке кода, он остаётся самым популярным во многих и многих сферах. Поэтому не знать и не уметь использовать данную парадигму разработки для настоящего профессионала просто не вежливо. На вебинаре поговорим и посмотрим на примерах о том, как термины ООП реализуются в синтаксисе языка C++. Регистрируйтесь [**по ссылке.**](https://otus.pw/ismq/)
>
> | https://habr.com/ru/post/689212/ | null | ru | null |
# CSS Bugs. Ошибки, возникающие при верстке
### 1. Удвоение полей у плавающих (float) блоках в IE 5-6
**Проблема:** мы очень часто используем поля (margin) и не реже их применяем к блокам со свойством float, ожидая нужный результат, можно сильно удивиться, когда IE вдруг сдвинет наш блок на большее расстояние, чем предполагалось. Конкретно: ошибка левого поля (margin-left) – при свойстве float c параметром left, ошибка правого поля (margin-right) – при свойстве float c параметром right.
`#FloatBlock
{
background-color:#ccc;
width:200px;
height:100px;
float:left;
margin-left:50px;
}`
Ожидаемый результат (корректный):
Какой же результат мы видим в IE (некорректный):
**Решение:** все просто, необходимо добавить строчку display:inline, т.е. объявить блок как строчный.
`#FloatBlock
{
background-color:#ccc;
width:200px;
height:100px;
float:left;
margin-left:50px;
display:inline;
}`
### 2. Проблема с плавающими (float) блоками.
**Проблема:** Блок, содержащий плавающий блок не принимает необходимую высоту, для того чтобы вместить его, высота остается такой, как будто плавающего блока нет. И это вовсе не ошибка, т.к. при применении свойства float блок изымается из нормального потока.
`FLOAT
Контейнер содержащий блок, к которому применено свойство float`
`#Container
{
border:red solid 1px;
}
#FloatBlock
{
width:100px;
height:100px;
border:#000 solid 1px;
float:right;
}`
Ожидаемый результат:
В итоге:
**Решение:**
1. Использование дополнительного блока со свойством clear
`FLOAT
Контейнер содержащий блок, к которому применено свойство float
#Container
{
border:red solid 1px;
}
#FloatBlock
{
width:100px;
height:100px;
border:#000 solid 1px;
float:right;
}
.clear
{
clear:both;
}`
2. Использование overflow:hidden
`#Container
{
border:red solid 1px;
width:100%;
overflow:hidden;
}`
3. Использование float:left
`#Container
{
border:red solid 1px;
float:left;
}`
Сразу все глюки не припомнить. Данный список предлагаю продолжить… | https://habr.com/ru/post/9611/ | null | ru | null |
# Easy linux management over twitter
Доброго времени суток, дорогие Хабраюзеры.
Этот пост навеян появлением [статьи](http://habrahabr.ru/blogs/python/127237/) про Twitter бота и всяких свистелок-плясалок для него. Представляю вам свое видение api Твиттера. Добро пожаловать под кат.
~~Необходимо учесть, что данный топик был опубликован мною в песочницу, когда я был еще незарегистрированным. И тут неожиданно мне пришел еще один инвайт, так что топик публикую как есть, без изменений, а о появлении второго аккаунта пренепременно сообщу в суппорт.~~
Итак, как гласит заголовок, приложение-бот будет использовать api твитера для управления машины с линуксом на борту.
В качестве языка разработки был избран python и, как следствие, библиотека tweepy. Хауту по начальной настройке данной библиотеки можно найти по ссылке, указанной выше.
Конфигурация
Перейдем непосредственно к сабжу. Код оформлен как полноценный линукс-демон, имеет файл конфигурации и работает с плагинами.
Рассмотрим файл конфигурации:
```
# Twitter credentials
CONSUMER_KEY = ''
CONSUMER_SECRET = ''
ACCESS_KEY = ''
ACCESS_SECRET = ''
# base path
BASE_PATH = os.path.dirname(__file__)
# pid path
PID_PATH = BASE_PATH+'/elmot.pid'
# people nicknames who can manage system
AUTHORIZED_ACCOUNTS = []
# logfile
LOG_PATH = BASE_PATH+'/log/elmot.log'
ERROR_LOG_PATH = BASE_PATH+'/log/elmot.err'
# type None to disable incoming message log
INCOMING_MESSAGE_LOG = BASE_PATH+'/log/incoming.log'
# run elmot as user (do not use root)
RUN_UID = pwd.getpwnam("root").pw_uid
```
Все прозрачно. Чтобы начать работать необходимо лишь заполнить поля consumer\_key, consumer\_secret, пользовательские ключи — access\_key и access\_secret, полученные ранее. Также необходимо добавить ники людей, которым разрешено управлять системой в AUTHORIZED\_ACCOUNTS.
Плагины
Перейдем к плагинам. Весь функционал предоставляется только с их помощью. Шаблон плагина выглядит следующим образом:
```
class Plugin(object):
name = 'undefined'
keyword = 'undefined'
# actions:
# 0 - silent
# 1 - private message
# 2 - tweet to timeline
action = 2
controlled = True
def __init__(self):
print '*', self.name, 'loaded'
def execute(self, message):
pass
# run method only for non controlled plugins
# for threading support with python Threads
def run():
pass
```
где name — название плагина, keyword — его уникальный идентификатор, по которому происходит обращение к нему.
Action — необходимое действие, то есть плагин может молчать, ответить Вам в личку, либо написать в свой таймлайн.
Поле controlled говорит плагину, будет ли он интерактивным — принимать и обрабатывать сообщения клиента. Если плагин интерактивен — то он слушает сообщения, приходящие в личку боту и, если сообщение адресовано ему, вызывает метод execute, в котором можно реализовать что-угодно. Если же плагин «молчалив», он запускает код из метода run() в отдельном потоке.
Как этим пользоваться
Просто отправляем боту личное сообщение вида «keyword command args». Бот распарсит сообщение и передаст его на обработку плагину с соответствующим keyword. Для примера рассмотрим плагин uptime. Он получает лишь один параметр — keyword и сообщает в свой таймлайн uptime машины, на которой работает.
Реализованные плагины
conntest — постоянная проверка линка с удаленным хостом (хостами). О проблемах пишет в таймлайн.
removetweets — удаляет n твитов из таймлайна бота (пример «removetweets 5»).
sshmonitor — мониторинг ssh сервера на основе парсинга auth.log. Пишет в таймлайн об ошибках аутентификации.
uptime — выводит аптайм машины.
Вот и все, можно реализовать любой плагин на свой вкус и мониторить что угодно (или рестартить службы например) через твиттер.
Спасибо за внимание, жду ваших комментариев.
P.S. [Код](https://github.com/thefrolov/elmot) на github.
P.P.S. Для старта демона необходимо использовать линк в директории bin. | https://habr.com/ru/post/127793/ | null | ru | null |
# Второй чемпионат по программированию: разбираем задачи ML-трека
В октябре состоялся второй чемпионат по программированию. Мы получили 12 500 заявок, более 6000 человек попробовали свои силы в соревнованиях. В этот раз участники могли выбрать один из следующих треков: бэкенд, фронтенд, мобильную разработку и машинное обучение. В каждом треке требовалось пройти квалификационный этап и финал.
По традиции мы опубликуем разборы треков на Хабре. Начнём с задач квалификационного этапа по машинному обучению. Команда подготовила пять таких задач, из которых составила два варианта по три задачи: в первом варианте были задачи A1, B1 и C, во втором — A2, B2 и C. Варианты случайно распределялись между участниками. Автор задачи C — наш разработчик Павел Пархоменко, остальные задачи составил его коллега Никита Сендерович.
За первую простую алгоритмическую задачу (A1/A2) участники могли получить 50 баллов, правильно реализовав перебор по ответу. За вторую задачу (B1/B2) мы давали от 10 до 100 баллов — в зависимости от эффективности решения. Чтобы получить 100 баллов, требовалось реализовать метод динамического программирования. Третья задача была посвящена построению кликовой модели по предоставленным обучающим данным. В ней требовалось применить методы работы с категориальными признаками и воспользоваться нелинейной моделью обучения (например, градиентным бустингом). За задачу можно было получить до 150 баллов — в зависимости от значения функции потерь на тестовой выборке.
А1. Восстанови длину карусели
-----------------------------
#### Условие
| | |
| --- | --- |
| Ограничение времени | 1 с |
| Ограничение памяти | 256 МБ |
| Ввод | стандартный ввод или input.txt |
| Вывод | стандартный вывод или output.txt |
Рекомендательная система должна эффективно определять интересы людей. И помимо методов машинного обучения, для выполнения этой задачи используются специальные интерфейсные решения, которые явным образом спрашивают пользователя, что ему интересно. Одним из таких решений является карусель.
Карусель — это горизонтальная лента из карточек, каждая из которых предлагает подписаться на конкретный источник или тему. Одна и та же карточка может встречаться в карусели несколько раз. Карусель можно прокручивать слева направо, при этом после последней карточки пользователь снова видит первую. Для пользователя переход от последней карточки к первой незаметен, с его точки зрения лента бесконечна.
В какой-то момент любопытный пользователь Василий заметил, что лента на самом деле зациклена, и решил выяснить истинную длину карусели. Для этого он стал прокручивать ленту и последовательно выписывать встречающиеся карточки, для простоты обозначая каждую карточку строчной латинской буквой. Так Василий выписал первые n карточек на листок бумаги. Гарантируется, что он просмотрел все карточки карусели хотя бы один раз. Потом Василий лёг спать, а утром обнаружил, что кто-то пролил стакан с водой на его записи и некоторые буквы теперь невозможно распознать.
По оставшейся информации помогите Василию определить наименьшее возможное количество карточек в карусели.
**Форматы ввода/вывода и примеры**#### Формат ввода
В первой строке задано одно целое число n (1 ≤ n ≤ 1000) — количество символов, выписанных Василием.
Вторая строка содержит выписанную Василием последовательность. Она состоит из n символов — строчных букв латинского алфавита и знака #, который обозначает, что букву на этой позиции невозможно распознать.
#### Формат вывода
Выведите одно целое положительное число — наименьшее возможное количество карточек в карусели.
#### Пример 1
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `5
abcab` | `3` |
#### Пример 2
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `7
abbabba` | `3` |
#### Пример 3
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `5
ab#ba` | `2` |
#### Пример 4
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `6
######` | `1` |
#### Примечания
В первом примере все буквы удалось распознать, минимальная карусель могла состоять из 3 карточек — abc.
Во втором примере все буквы удалось распознать, минимальная карусель могла состоять из 3 карточек — abb. Обратите внимание, что вторая и третья карточки в этой карусели одинаковые.
В третьем примере наименьшая возможная длина карусели получается, если предположить, что на третьей позиции находился символ a. Тогда исходная строка — ababa, минимальная карусель состоит из 2 карточек — ab.
В четвёртом примере исходная строка могла быть любой, например ffffff. Тогда карусель могла состоять из одной карточки — f.
#### Система оценки
Только при прохождении всех тестов за задачу можно получить **50 баллов**.
В тестирующей системе тесты 1–4 — примеры из условия.
#### Решение
Достаточно было перебрать возможную длину карусели от 1 до n и для каждой фиксированной длины проверить, могла ли она быть таковой. При этом понятно, что ответ всегда существует, поскольку значение n гарантированно является возможным ответом. Для фиксированной длины карусели p достаточно проверить, что в переданной строке для всех i от 0 до (p – 1) на всех позициях i, i + p, i + 2p и т. д. находятся одинаковые символы или #. Если хотя бы для какого-то i встречается 2 различных символа из диапазона от a до z, то карусель не может быть длины p. Поскольку в худшем случае для каждого p нужно пробежаться по всем символам строки один раз, сложность такого алгоритма — O(n2).
```
def check_character(char, curchar):
return curchar is None or char == "#" or curchar == char
def need_to_assign_curchar(char, curchar):
return curchar is None and char != "#"
n = int(input())
s = input().strip()
for p in range(1, n + 1):
is_ok = True
for i in range(0, p):
curchar = None
for j in range(i, n, p):
if not check_character(s[j], curchar):
is_ok = False
break
if need_to_assign_curchar(s[j], curchar):
curchar = s[j]
if not is_ok:
break
if is_ok:
print(p)
break
```
А2. Восстанови длину карусели
-----------------------------
#### Условие
| | |
| --- | --- |
| Ограничение времени | 1 с |
| Ограничение памяти | 256 МБ |
| Ввод | стандартный ввод или input.txt |
| Вывод | стандартный вывод или output.txt |
Рекомендательная система должна эффективно определять интересы людей. И помимо методов машинного обучения, для выполнения этой задачи используются специальные интерфейсные решения, которые явным образом спрашивают пользователя, что ему интересно. Одним из таких решений является карусель.
Карусель — это горизонтальная лента из карточек, каждая из которых предлагает подписаться на конкретный источник или тему. Одна и та же карточка может встречаться в карусели несколько раз. Карусель можно прокручивать слева направо, при этом после последней карточки пользователь снова видит первую. Для пользователя переход от последней карточки к первой незаметен, с его точки зрения лента бесконечна.
В какой-то момент любопытный пользователь Василий заметил, что лента на самом деле зациклена, и решил выяснить истинную длину карусели. Для этого он стал прокручивать ленту и последовательно выписывать встречающиеся карточки, для простоты обозначая каждую карточку строчной латинской буквой. Так Василий выписал первые n карточек. Гарантируется, что он просмотрел все карточки карусели хотя бы один раз. Поскольку Василий отвлекался на содержимое карточек, при выписывании он мог по ошибке заменять одну букву на другую, но известно, что всего он сделал не более k ошибок.
Вам в руки попали записи, сделанные Василием, вы также знаете значение k. Определите, какое наименьшее количество карточек могло быть в его карусели.
**Форматы ввода/вывода и примеры**#### Формат ввода
В первой строке заданы два целых числа: n (1 ≤ n ≤ 500) — количество символов, выписанных Василием, и k (0 ≤ k ≤ n) — максимальное число ошибок, которое допустил Василий.
Вторая строка содержит n строчных букв латинского алфавита — выписанная Василием последовательность.
#### Формат вывода
Выведите одно целое положительное число — наименьшее возможное количество карточек в карусели.
#### Пример 1
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `5 0
abcab` | `3` |
#### Пример 2
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `5 1
abcba` | `2` |
#### Пример 3
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `7 1
abbabba` | `3` |
#### Пример 4
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `6 6
abcabc` | `1` |
#### Примечания
В первом примере k = 0, и мы точно знаем, что Василий не ошибался, минимальная карусель могла состоять из 3 карточек — abc.
Во втором примере наименьшая возможная длина карусели получается, если предположить, что Василий по ошибке заменил третью букву a на c. Тогда настоящая строка — ababa, минимальная карусель состоит из 2 карточек — ab.
В третьем примере известно, что Василий мог сделать одну ошибку. Однако размер карусели минимален, если предположить, что он не делал ошибок. Минимальная карусель состоит из 3 карточек — abb. Обратите внимание, что вторая и третья карточки в этой карусели одинаковые.
В четвёртом примере мы можем сказать, что Василий ошибся при вводе всех букв, и исходная строка на самом деле могла быть любой, например ffffff. Тогда карусель могла состоять из одной карточки — f.
#### Система оценки
Только при прохождении всех тестов за задачу можно получить **50 баллов**.
В тестирующей системе тесты 1–4 — примеры из условия.
#### Решение
Достаточно было перебрать возможную длину карусели от 1 до n и для каждой фиксированной длины проверить, могла ли она быть таковой. При этом понятно, что ответ всегда существует, поскольку значение n гарантированно является возможным ответом, каким бы ни было значение k. Для фиксированной длины карусели p достаточно посчитать независимо для всех i от 0 до (p – 1), какое минимальное количество ошибок допущено на позициях i, i + p, i + 2p и т. д. Это число ошибок минимально, если принять за истинный символ тот, который встречается на этих позициях чаще всех. Тогда число ошибок равно количеству позиций, на которых стоит другая буква. Если для некоторого p общее число ошибок не превосходит k, то значение p является возможным ответом. Поскольку для каждого p нужно пробежаться по всем символам строки один раз, сложность такого алгоритма — O(n2).
```
n, k = map(int, input().split())
s = input().strip()
for p in range(1, n + 1):
mistakes = 0
for i in range(0, p):
counts = [0] * 26
for j in range(i, n, p):
counts[ord(s[j]) - ord("a")] += 1
mistakes += sum(counts) - max(counts)
if mistakes <= k:
print(p)
break
```
B1. Оптимальная лента рекомендаций
----------------------------------
#### Условие
| | | | |
| --- | --- | --- | --- |
| | **Все языки** | **Oracle Java 8** | **GNU c++17 7.3** |
| Ограничение времени | 5 с | 3 с | 1 с |
| Ограничение памяти | 256 МБ |
| Ввод | стандартный ввод или input.txt |
| Вывод | стандартный вывод или output.txt |
Формирование очередной порции персональной выдачи рекомендаций для пользователя — непростая задача. Рассмотрим n публикаций, выбранных из рекомендательной базы по итогам отбора кандидатов. Публикация под номером i характеризуется оценкой релевантности si и набором из k бинарных атрибутов ai1, ai2, ..., aik. Каждый из этих атрибутов отвечает некоторому свойству публикации, к примеру, подписан ли пользователь на источник этой публикации, была ли публикация создана за последние 24 часа и т. д. Публикация может обладать сразу несколькими из этих свойств одновременно — в таком случае соответствующие атрибуты принимают значение 1, а может и не обладать ни одним из них — и тогда все её атрибуты равны 0.
Для того чтобы лента пользователя была разнообразной, необходимо выбрать среди n кандидатов m публикаций так, чтобы среди них оказалось не менее A1 публикаций, обладающих первым свойством, не менее A2 публикаций, обладающих вторым свойством, …, Ak публикаций, обладающих свойством под номером k. Найдите максимально возможную суммарную оценку релевантности m публикаций, удовлетворяющих этому требованию, либо определите, что такого набора публикаций не существует.
**Форматы ввода/вывода и примеры**#### Формат ввода
В первой строке заданы три целых числа — n, m, k (1 ≤ n ≤ 50, 1 ≤ m ≤ min(n, 9), 1 ≤ k ≤ 5).
В следующих n строках заданы характеристики публикаций. Для i-й публикации задано целое число si (1 ≤ si ≤ 109) — оценка релевантности данной публикации, и далее через пробел строка из k символов, каждый из которых равен 0 или 1 — значения каждого из атрибутов данной публикации.
В последней строке заданы k целых чисел, разделённых пробелами — значения A1, ..., Ak (0 ≤ Ai ≤ m), определяющие требования к итоговому набору из m публикаций.
#### Формат вывода
Если не существует набора из m публикаций, удовлетворяющих ограничениям, выведите число 0. Иначе выведите одно целое положительное число — максимально возможную суммарную оценку релевантности.
#### Пример 1
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `4 2 2
8 00
6 01
5 10
2 11
1 1` | `11` |
#### Пример 2
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `3 2 2
3 01
3 10
3 10
1 2` | `0` |
#### Примечания
В первом примере необходимо из четырёх публикаций с двумя свойствами выбрать две так, чтобы было не менее одной публикации, обладающей первым свойством, и одной, обладающей вторым свойством. Самую большую сумму релевантностей можно получить, если взять вторую и третью публикации, хотя под ограничения также подходит любой вариант с четвёртой публикацией.
Во втором примере невозможно выбрать две публикации так, чтобы обе обладали вторым свойством, ибо им обладает только первая публикация.
#### Система оценки
Тесты к этой задаче состоят из пяти групп. Баллы за каждую группу ставятся только при прохождении всех тестов группы и всех тестов **предыдущих** групп. Прохождение тестов из условия необходимо для получения баллов за группы начиная со второй. Всего за задачу можно получить **100 баллов**.
В тестирующей системе тесты 1–2 — примеры из условия.
1. **(10 баллов)** тесты 3–10: k = 1, m ≤ 3, si ≤ 1000, не требуется прохождение тестов из условия
2. **(20 баллов)** тесты 11–20: k ≤ 2, m ≤ 3
3. **(20 баллов)** тесты 21–29: k ≤ 2
4. **(20 баллов)** тесты 30–37: k ≤ 3
5. **(30 баллов)** тесты 38–47: нет дополнительных ограничений
#### Решение
Есть n публикаций, у каждой есть скор и k булевых флажков, требуется выбрать m карточек, таких что сумма релевантностей максимальна и выполнено k требований вида «среди выбранных m публикаций должно быть ≥ Ai карточек с i-ым флажком», либо определить, что такого набора публикаций не существует.
**Решение на 10 баллов**: если есть ровно один флажок, достаточно взять A1 публикаций с этим флажком, имеющих наибольшую релевантность (если таких карточек меньше, чем A1, то искомого набора не существует), а остальные (m – A1) добрать оставшимися карточками с наилучшей релевантностью.
**Решение на 30 баллов**: если m не превосходит 3, то можно найти ответ полным перебором всевозможных O(n3) троек карточек, выбрать наилучший по суммарной релевантности вариант, удовлетворяющий ограничениям.
**Решение на 70 баллов** (на 50 баллов всё то же самое, только проще реализовать): если есть не более 3 флажков, то можно разбить все публикации на 8 непересекающихся групп по набору флажков, которыми они обладают: 000, 001, 010, 011, 100, 101, 110, 111. Публикации в каждой группе нужно отсортировать по убыванию релевантности. Далее можно за O(m4) перебрать, сколько лучших публикаций мы берём из групп 111, 011, 110 и 101. Из каждой берём от 0 до m публикаций, в сумме не более m. После этого становится ясно, сколько публикаций необходимо добрать из групп 100, 010 и 001, чтобы требования удовлетворялись. Остаётся добрать до m оставшимися карточками с наилучшей релевантностью.
**Полное решение**: рассмотрим функцию динамического программирования dp[i][a]...[z]. Это максимальная суммарная оценка релевантности, которую можно получить, использовав ровно i публикаций, чтобы было ровно a публикаций с флажком A, ..., z публикаций с флажком Z. Тогда исходно dp[0][0]...[0] = 0, а для всех остальных наборов параметров значение положим равным -1, чтобы в дальнейшем максимизировать это значение. Далее будем «вводить в игру» карточки по одной и с помощью каждой карточки улучшать значения этой функции: для каждого состояния динамики (i, a, b, ..., z) с помощью j-й публикации с флажками (aj, bj, ..., zj) можно попробовать совершить переход в состояние (i + 1, a + aj, b + bj, ..., z + zj) и проверить, не улучшится ли результат в этом состоянии. Важно: при переходе нас не интересуют состояния, где i ≥ m, поэтому всего состояний у такой динамики не более mk + 1, и итоговая асимптотика — O(nmk + 1). Когда посчитаны состояния динамики, ответом является состояние, которое удовлетворяет ограничениям и даёт наибольшую суммарную оценку релевантности.
С точки зрения реализации для ускорения работы программы полезно хранить состояние динамического программирования и флажки каждой из публикаций в упакованном виде в одном целом числе (см. код), а не в списке или кортеже. Такое решение использует меньше памяти и позволяет эффективно производить апдейты состояний динамики.
Код полного решения:
```
def pack_state(num_items, counts):
result = 0
for count in counts:
result = (result << 8) + count
return (result << 8) + num_items
def get_num_items(state):
return state & 255
def get_flags_counts(state, num_flags):
flags_counts = [0] * num_flags
state >>= 8
for i in range(num_flags):
flags_counts[num_flags - i - 1] = state & 255
state >>= 8
return flags_counts
n, m, k = map(int, input().split())
scores, attributes = [], []
for i in range(n):
score, flags = input().split()
scores.append(int(score))
attributes.append(list(map(int, flags)))
limits = list(map(int, input().split()))
dp = {0 : 0}
for i in range(n):
score = scores[i]
state_delta = pack_state(1, attributes[i])
dp_temp = {}
for state, value in dp.items():
if get_num_items(state) >= m:
continue
new_state = state + state_delta
if value + score > dp.get(new_state, -1):
dp_temp[new_state] = value + score
dp.update(dp_temp)
best_score = 0
for state, value in dp.items():
if get_num_items(state) != m:
continue
flags_counts = get_flags_counts(state, k)
satisfied_bounds = True
for i in range(k):
if flags_counts[i] < limits[i]:
satisfied_bounds = False
break
if not satisfied_bounds:
continue
if value > best_score:
best_score = value
print(best_score)
```
B2. Приближение функции
-----------------------
#### Условие
| | |
| --- | --- |
| Ограничение времени | 2 с |
| Ограничение памяти | 256 МБ |
| Ввод | стандартный ввод или input.txt |
| Вывод | стандартный вывод или output.txt |
Для оценки степени релевантности документов используются различные методы машинного обучения — например, решающие деревья. k-ичное решающее дерево имеет в каждом узле решающее правило, которое разделяет объекты на k классов по значениям некоторого признака. На практике обычно используются двоичные решающие деревья. Рассмотрим упрощённую версию задачи оптимизации, которую необходимо решать в каждом узле k-ичного решающего дерева.
Пусть дискретная функция f определена в точках i = 1, 2, ..., n. Необходимо найти кусочно-постоянную функцию g, состоящую не более чем из k участков постоянства, такую что значение SSE = (g(i) – f(i))2 минимально.
**Форматы ввода/вывода и примеры**#### Формат ввода
В первой строке заданы два целых числа n и k (1 ≤ n ≤ 300, 1 ≤ k ≤ min(n, 10)).
Во второй строке задано n целых чисел f(1), f(2), ..., f(n) — значения приближаемой функции в точках 1, 2, ..., n (–106 ≤ f(i) ≤ 106).
#### Формат вывода
Выведите единственное число — минимальное возможное значение SSE. Ответ считается правильным, если абсолютная или относительная погрешность не превосходит 10–6.
#### Пример 1
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `3 1
1 2 3` | `2.000000` |
#### Пример 2
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `3 2
1 2 3` | `0.500000` |
#### Пример 3
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `5 2
2 1 5 3 4` | `2.500000` |
#### Примечания
В первом примере оптимальная функция g — константа g(i) = 2.
SSE = (2 – 1)2 + (2 – 2)2 + (2 – 3)2 = 2.
Во втором примере есть 2 варианта. Либо g(1) = 1 и g(2) = g(3) = 2.5, либо g(1) = g(2) = 1.5 и
g(3) = 3. В любом случае SSE = 0.5.
В третьем примере оптимальное приближение функции f с помощью двух участков постоянства изображено ниже: g(1) = g(2) = 1.5 и g(3) = g(4) = g(5) = 4.
SSE = (1.5 + 2)2 + (1.5 – 1)2 + (4 – 5)2 + (4 – 3)2 + (4 – 4)2 = 2.5.
#### Система оценки
Тесты к этой задаче состоят из пяти групп. Баллы за каждую группу ставятся только при прохождении всех тестов группы и всех тестов **предыдущих** групп. Прохождение тестов из условия необходимо для получения баллов за группы начиная со второй. Всего за задачу можно получить **100 баллов**.
В тестирующей системе тесты 1–3 — примеры из условия.
1. **(10 баллов)** тесты 4–22: k = 1, не требуется прохождение тестов из условия
2. **(20 баллов)** тесты 23–28: k ≤ 2
3. **(20 баллов)** тесты 29–34: k ≤ 3
4. **(20 баллов)** тесты 35–40: k ≤ 4
5. **(30 баллов)** тесты 41–46: нет дополнительных ограничений
#### Решение
Как известно, константа, которая минимизирует значение SSE для набора значений f1, f2, ..., fn, — это среднее перечисленных здесь значений. При этом, как нетрудно убедиться путём простых выкладок, само значение SSE = .
**Решение на 10 баллов**: просто считаем среднее всех значений функции и SSE за O(n).
**Решение на 30 баллов**: перебираем последнюю точку, относящуюся к первому участку постоянства из двух, для фиксированного разбиения вычисляем SSE и выбираем оптимальное. Кроме того, важно не забыть разобрать кейс, когда участок постоянства только один. Сложность — O(n2).
**Решение на 50 баллов**: перебираем границы разбиения на участки постоянства за O(n2), для фиксированного разбиения на 3 отрезка вычисляем SSE и выбираем оптимальное. Сложность — O(n3).
**Решение на 70 баллов**: предподсчитываем суммы и суммы квадратов значений fi на префиксах, это позволит быстро считать среднее и SSE на любом отрезке. Перебираем границы разбиения на 4 участка постоянства за O(n3), с помощью предподсчитанных значений на префиксах за O(1) вычисляем SSE. Сложность — O(n3).
**Полное решение**: рассмотрим функцию динамического программирования dp[s][i]. Это наименьшее значение SSE, если приближать первые i значений с помощью s отрезков. Тогда
dp[0][0] = 0, а для всех остальных наборов параметров значение положим равным бесконечности, чтобы в дальнейшем минимизировать это значение. Будем решать задачу, постепенно увеличивая значение s. Как вычислить dp[s][i], если уже посчитаны значения динамики для всех меньших s? Достаточно обозначить за t количество первых точек, покрытых предыдущими (s – 1) отрезками, и перебрать все значения t, а остальные (i – t) точек приблизить с помощью оставшегося отрезка. Нужно выбрать наилучшее по итоговому SSE на i точках значение t. Если предподсчитать суммы и суммы квадратов значений fi на префиксах, то это приближение будет производиться за O(1), и значение dp[s][i] удастся вычислить за O(n). Итоговым ответом будет значение dp[k][n]. Итоговая сложность алгоритма — O(kn2).
Код полного решения:
```
n, k = map(int, input().split())
f = list(map(float, input().split()))
prefix_sum = [0.0] * (n + 1)
prefix_sum_sqr = [0.0] * (n + 1)
for i in range(1, n + 1):
prefix_sum[i] = prefix_sum[i - 1] + f[i - 1]
prefix_sum_sqr[i] = prefix_sum_sqr[i - 1] + f[i - 1] ** 2
def get_best_sse(l, r):
num = r - l + 1
s_sqr = (prefix_sum[r] - prefix_sum[l - 1]) ** 2
ss = prefix_sum_sqr[r] - prefix_sum_sqr[l - 1]
return ss - s_sqr / num
dp_curr = [1e100] * (n + 1)
dp_prev = [1e100] * (n + 1)
dp_prev[0] = 0.0
for num_segments in range(1, k + 1):
dp_curr[num_segments] = 0.0
for num_covered in range(num_segments + 1, n + 1):
dp_curr[num_covered] = 1e100
for num_covered_previously in range(num_segments - 1, num_covered):
dp_curr[num_covered] = min(dp_curr[num_covered], dp_prev[num_covered_previously] + get_best_sse(num_covered_previously + 1, num_covered))
dp_curr, dp_prev = dp_prev, dp_curr
print(dp_prev[n])
```
C. Предсказание кликов пользователя
-----------------------------------
#### Условие
Одним из важнейших сигналов для рекомендательной системы является поведение пользователя. Таких данных зачастую достаточно, чтобы построить бейзлайн приемлемого качества.
В этом задании вам нужно построить рекомендательную систему на основе данных о действиях пользователей в персональной ленте рекомендаций Яндекс.Дзена.
Вам доступны 2 датасета: тренировочный (train.csv) и тестовый (test.csv). Каждая строка в датасетах соответствует взаимодействию некоторого пользователя с некоторым документом, показанным ему в ленте рекомендаций. Датасеты содержат следующие колонки:
— sample\_id — числовой id взаимодействия,
— item — числовой id показанного пользователю документа,
— publisher — числовой id автора документа,
— user — числовой id пользователя,
topic\_i, weight\_i — числовой id i-ой темы документа и степень принадлежности документа данной теме (целое число от 0 до 100) (i = 0, 1, 2, 3, 4),
— target — факт клика пользователя на документ (1 — был клик, 0 — был показ без клика). Этот столбец присутствует только в тренировочном датасете.
Необходимо построить модель для предсказания кликов пользователя и применить её к тестовому датасету.
Гарантируется, что все встречающиеся в тестовом датасете значения столбцов item, publisher, user, topic встречаются и в тренировочном датасете.
В качестве решения нужно отправить csv-файл, состоящий из двух колонок: sample\_id и target, где sample\_id — id строки из тестового датасета, а target — предсказанная вероятность клика. Количество строк в этом файле должно совпадать с количеством строк в test.csv. Строки в файле с решением должны быть отсортированы по возрастанию значений колонки sample\_id (в том же порядке, что и в test.csv). Все значения вероятностей в колонке target должны быть вещественными числами от 0 до 1.
Для оценки качества отправленного решения используется метрика logloss.
За эту задачу можно получить максимум 150 баллов. Для конвертации метрики logloss в баллы используется следующая функция:
При отправке решения logloss вычисляется сразу на всём тестовом датасете и конвертируется в итоговый балл за посылку. Баллы считаются с точностью до 2 знаков после запятой, logloss решения показывается с точностью до 4 знаков после запятой.
**Форматы ввода/вывода и примечания**#### Формат ввода
Фрагмент train.csv:
| |
| --- |
| `sample_id,item,publisher,user,topic_0,topic_1,topic_2,topic_3,topic_4,weight_0,weight_1,weight_2,weight_3,weight_4,target
0,531,147,2925,411,477,618,249,460,27,18,9,8,7,0
1,1574,260,2981,212,287,382,302,51,27,11,2,1,0,0
2,940,394,1230,145,150,212,170,174,7,6,6,5,5,0
3,52,520,2597,201,283,618,249,617,35,33,30,11,9,1
4,766,55,1680,362,150,477,305,388,51,15,13,10,9,1
...` |
Фрагмент test.csv:
| |
| --- |
| `sample_id,item,publisher,user,topic_0,topic_1,topic_2,topic_3,topic_4,weight_0,weight_1,weight_2,weight_3,weight_4
1009109,1716,349,1053,362,397,430,287,431,54,54,51,26,13
1009110,1707,202,254,150,73,356,212,482,29,7,5,5,4
1009111,1592,520,1524,397,287,356,330,281,95,46,6,5,3
1009112,1541,82,2994,397,287,102,323,356,93,77,25,7,4
1009113,52,520,936,201,283,618,249,617,35,33,30,11,9
...` |
#### Формат вывода
Фрагмент возможного файла с решением:
| |
| --- |
| `sample_id,target
1009109,0.2449
1009110,0.7809
1009111,0.1317
1009112,0.9552
1009113,0.6703
...` |
#### Примечания
Датасеты можно скачать по ссылке: [yadi.sk/d/pVna8ejcnQZK\_A](https://yadi.sk/d/pVna8ejcnQZK_A). Там же вы сможете найти бейзлайн, который поможет приступить к задаче.
Для подсчета значения метрики logloss на одном объекте тестового датасета используется следующая функция:
`EPS = 1e-4
**def** logloss(y_true, y_pred):
**if abs**(y_pred - 1) < EPS:
y_pred = 1 - EPS
**if abs**(y_pred) < EPS:
y_pred = EPS
**return** -y_true ∗ log(y_pred) - (1 - y_true) ∗ log(1 - y_pred)`
Итоговый logloss за посылку вычисляется как среднее значение logloss по всем объектам тестового датасета.
Для подсчёта баллов по logloss используется следующая функция:
`**def** score(logloss):
**if** logloss > 0.5:
**return** 0.0
**return** min(150, (200 ∗ (0.5 - logloss)) ∗∗ 2)`
#### Решение
Нужно предсказать, понравится ли пользователю публикация. Есть разные способы решить задачу. Надо учитывать, что все сущности (документы, пользователи, источники, темы) одинаковые как в тренировочном, так и в тестовом датасете — то есть нет проблем с тем, что о каких-то документах из тестового датасета мы не знаем, как с ними взаимодействуют пользователи.
Мы опишем некоторые подходы участников, набравших 100 и более баллов (из 150).
Самый простой способ — загрузить датасет в CatBoost и аккуратно подобрать гиперпараметры. Поскольку CatBoost умеет хорошо обрабатывать категориальные признаки (которых было большинство в исходном датасете), даже такое простое решение давало хороший результат. Чтобы повысить качество работы метода, можно было сгенерировать больше признаков. К примеру, сделать разные признаки-счётчики: кликабельность документа , пользователя, источника, тем, какие-то парные взаимодействия (как часто пользователь кликает на темы статьи).
Хороший результат можно было получить и с помощью коллаборативных методов. Например, можно было использовать разложение матрицы документ-пользователь или методы, которые учитывают другие доступные данные: FM (Factorization Machines) и FFM (Field-aware Factorization Machines).
---
Если вы планируете участвовать в соревнованиях по машинному обучению, посмотрите [разбор](https://habr.com/ru/company/yandex/blog/461273/) ML-трека первого чемпионата. | https://habr.com/ru/post/477452/ | null | ru | null |
# Шесть простых примеров по Mockito (перевод)
**Маленький комментарий:**/\*
Решил ознакомиться с тем, что из себя представляет эта библиотека, и отыскал замечательную [статью](http://gojko.net/2009/10/23/mockito-in-six-easy-examples/), прочтение которой я хотел бы закрепить, для чего и решил перевести её на русский.
Конечно же, принимается конструктивная критика.
Надеюсь, что комментарии будут полезнее самой статьи, как это обычно и бывает. ;)
\*/
Mockito — прекрасная мок-библиотека для Java. Я очарован тем, как легко её использовать в сравнении с другими подобными библиотеками из мира Java и .NET. В этой статье я привожу всё, что Вам потребуется для старта, в шести очень лёгких примерах.
Для начала, скачайте mockito с <http://mockito.org/> (на момент написания ведёт на <https://code.google.com/p/mockito/>).
**Или просто добавьте это в зависимости в pom maven-проекта:**
```
org.mockito
mockito-core
RELEASE
test
```
Почти всё самое интересное может быть взято из класса org.mockito.Mockito (или можно [статически импортировать](https://stokito.wordpress.com/2011/04/05/%D0%B2%D0%BE%D0%B7%D0%BC%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D0%B8-java-%D1%81%D1%82%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9-%D0%B8%D0%BC%D0%BF%D0%BE%D1%80%D1%82/) его методы, что я и использую в этой статье). Итак, начнём.
Чтобы создать заглушку (или мок), используйте **mock(class)**. Затем используйте **when(mock).thenReturn(value)**, чтобы указать возвращаемое значение для метода. Если Вы укажете более одного возвращаемого значения, они будут возвращены методом последовательно, пока не вернётся последнее, после этого при последующих вызовах будет возвращаться только последнее значение (таким образом, чтобы метод всегда возвращал одно и то же значение, просто укажите его единожды). Например:
```
import static org.mockito.Mockito.*;
import static org.junit.Assert.*;
import java.util.Iterator;
import org.junit.Test;
....
@Test
public void iterator_will_return_hello_world() {
//подготавливаем
Iterator i = mock(Iterator.class);
when(i.next()).thenReturn("Hello").thenReturn("World");
//выполняем
String result = i.next()+" "+i.next();
//сравниваем
assertEquals("Hello World", result);
}
```
Этот пример демонстрирует создание мок-итератора и «заставляет» его возвращать «Hello» при первом вызове метода **next()**. Последующие вызовы этого метода будут возвращать «World». После этого мы можем выполнять обычные assert'ы.
Заглушки также могут возвращать различные значения в зависимости от передаваемых в метод аргументов. Пример:
```
@Test
public void with_arguments() {
Comparable c = mock(Comparable.class);
when(c.compareTo("Test")).thenReturn(1);
assertEquals(1, c.compareTo("Test"));
}
```
Здесь мы создаём объект-заглушку Comparable, и возвращаем 1 в случае, если он сравнивается с определённым String-значением («Test», в данном случае).
Если метод имеет какие-то аргументы, но Вам всё равно, что будет в них передано или предсказать это невозможно, то используйте **anyInt()** (и альтернативные значения для других типов). Пример:
```
@Test
public void with_unspecified_arguments() {
Comparable c = mock(Comparable.class);
when(c.compareTo(anyInt())).thenReturn(-1);
assertEquals(-1, c.compareTo(5));
}
```
Эта заглушка возвращает -1 вне зависимости от переданного аргумента. Void-методы составляют некоторую проблему, так как Вы не можете использовать их в методе **when()**.
Альтернативным синтаксисом в этой ситуации будет **doReturn(result).when(mock\_object).void\_method\_call();**. Вместо возврата результата Вы также можете использовать **.thenThrow()** или **doThrow()** для void-методов. Пример:
```
@Test(expected=IOException.class)
public void OutputStreamWriter_rethrows_an_exception_from_OutputStream()
throws IOException {
OutputStream mock = mock(OutputStream.class);
OutputStreamWriter osw = new OutputStreamWriter(mock);
doThrow(new IOException()).when(mock).close();
osw.close();
}
```
В этом примере выбрасывается IOException, когда в заглушке OutputStream вызывается метод close. Мы с лёгкостью проверяем, что OutputStreamWriter пробрасывает такой эксепшн наружу.
Чтобы проверить, что метод действительно был вызван (типичное использование объектов-заглушек), мы можем использовать **verify(mock\_object).method\_call;**. Пример:
```
@Test
public void OutputStreamWriter_Closes_OutputStream_on_Close()
throws IOException {
OutputStream mock = mock(OutputStream.class);
OutputStreamWriter osw = new OutputStreamWriter(mock);
osw.close();
verify(mock).close();
}
```
В этом примере мы проверяем, что OutputStreamWriter совершает вызов метода **close()** во вложенном OutputStream.
Вы можете использовать аргументы в методах и подстановки для них, такие как **anyInt()**, как в одном из предыдущих примеров. Стоит отметить, что Вы не можете смешивать литералы и матчеры. Используйте матчер **eq(value)** для конвертирования литерала в матчер, который сравнит значение. Mockito предоставляет уйму уже готовых матчеров, но иногда Вам может потребоваться более гибкий подход. К примеру, OutputStreamWriter будет буферизовать вывод и затем передавать его обёрнутому объекту при заполнении буфера, но мы не знаем, насколько длинный буфер нам собираются передать. Здесь мы не можем использовать сравнение на равенство. Однако, мы можем запилить собственный матчер:
```
@Test
public void OutputStreamWriter_Buffers_And_Forwards_To_OutputStream()
throws IOException {
OutputStream mock = mock(OutputStream.class);
OutputStreamWriter osw = new OutputStreamWriter(mock);
osw.write('a');
osw.flush();
// не можем делать так, потому что мы не знаем,
// насколько длинным может быть массив
// verify(mock).write(new byte[]{'a'}, 0, 1);
BaseMatcher arrayStartingWithA = new BaseMatcher() {
@Override
public void describeTo(Description description) {
// пустота
}
// Проверяем, что первый символ - это A
@Override
public boolean matches(Object item) {
byte[] actual = (byte[]) item;
return actual[0] == 'a';
}
};
// проверяем, что первый символ массива - это A, и что другие два аргумента равны 0 и 1.
verify(mock).write(argThat(arrayStartingWithA), eq(0), eq(1));
}
```
И это всё, что Вам потребуется, чтобы начать. А сейчас возьмите и отрефакторите всю эту изимокщину в своих проектах!
**Весь текст класса с тестами:**
```
import static org.mockito.Mockito.*;
import static org.junit.Assert.*;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.Iterator;
import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.junit.Test;
public class MockitoTests {
@Test
public void iterator_will_return_hello_world() {
//подготавливаем
Iterator i = mock(Iterator.class);
when(i.next()).thenReturn("Hello").thenReturn("World");
//выполняем
String result = i.next() + " " + i.next();
//сравниваем
assertEquals("Hello World", result);
}
@Test
public void with_arguments() {
Comparable c = mock(Comparable.class);
when(c.compareTo("Test")).thenReturn(1);
assertEquals(1, c.compareTo("Test"));
}
@Test
public void with_unspecified_arguments() {
Comparable c = mock(Comparable.class);
when(c.compareTo(anyInt())).thenReturn(-1);
assertEquals(-1, c.compareTo(5));
}
@Test(expected = IOException.class)
public void OutputStreamWriter_rethrows_an_exception_from_OutputStream()
throws IOException {
OutputStream mock = mock(OutputStream.class);
OutputStreamWriter osw = new OutputStreamWriter(mock);
doThrow(new IOException()).when(mock).close();
osw.close();
}
@Test
public void OutputStreamWriter_Closes_OutputStream_on_Close()
throws IOException {
OutputStream mock = mock(OutputStream.class);
OutputStreamWriter osw = new OutputStreamWriter(mock);
osw.close();
verify(mock).close();
}
@Test
public void OutputStreamWriter_Buffers_And_Forwards_To_OutputStream()
throws IOException {
OutputStream mock = mock(OutputStream.class);
OutputStreamWriter osw = new OutputStreamWriter(mock);
osw.write('a');
osw.flush();
// не можем делать так, потому что мы не знаем,
// насколько длинным может быть массив
// verify(mock).write(new byte[]{'a'},0,1);
BaseMatcher arrayStartingWithA = new BaseMatcher() {
@Override
public void describeTo(Description description) {
// пустота
}
// Проверяем, что первый символ - это A
@Override
public boolean matches(Object item) {
byte[] actual = (byte[]) item;
return actual[0] == 'a';
}
};
// проверяем, что первый символ массива - это A, и что другие два аргумента равны 0 и 1.
verify(mock).write(argThat(arrayStartingWithA), eq(0), eq(1));
}
}
```
P.S.: Дальше можно почитать введение в PowerMock: <http://habrahabr.ru/post/172239/>.
И вот эту статью: <http://habrahabr.ru/post/72617/> | https://habr.com/ru/post/243155/ | null | ru | null |
# Микросервисы — MIF на C++
Около трех лет назад у меня была идея создания небольшого каркаса для разработки небольших сервисов, которые могли бы как-то взаимодействовать между собой, предоставлять API во вне, работать с базами данных и кое-что по мелочи еще. Во время решения некоторых рабочих задач, окончательно сформировалась идея своего проекта, близкого к решению рабочих задач. Примерно год назад все это сформировалось в проект [MIF (MetaInfo Framework)](https://github.com/tdv/mif). Предполагалось, что с его помощью можно будет решать такие задачи, как:
* Разработка легковесных HTTP сервисов
* Коммуникация микросервисов через передаваемые между процессами интерфейсы
* Сериализация и десериализация на базе рефлексии структур данных в разные форматы
* Работа с базами данных
* Некоторые вспомогательные компоненты для создания каркасов сервисов
Все это ориентировано на разработку backend сервисов для веба, но может использоваться и в других системах.
Введение
========
Выход нового стандарта C++, подготовка следующего. Проходят года, а рефлексии в C++ нет. Обсуждалась возможность появления рефлексии в C++, и казалось, что в очередной стандарт она будет включена. Нет… Может быть рефлексия и не нужна? Может быть… Но есть задачи, где она могла бы быть полезна: межпроцессное взаимодействие (IPC, RPC, REST API, микросервисы), работа с базами данных (ORM), различные (де)сериализаторы и т.д. — в общем есть пространство для применения.
Компилятор имеет всю информацию о типах, и почему бы ему не поделиться ей с разработчиками? Попробую предположить, что всего лишь нет документа, по которому разработчики компиляторов должны отпускать честным разработчикам прочего программного обеспечения эту информацию. Такой документ — это стандарт C++, в котором никак не появится регламент «отоваривания».
Во многих языках рефлексия есть. C++ считается языком для разработки программ, где важна производительность и, казалось бы, одна из его сфер применения — это веб-разработка. Разработка backend сервисов. В этой отрасли есть и REST API, и ORM и всевозможная сериализация во что угодно (часто угодно в json). Для решения этих задач приходится использовать готовые библиотеки или писать свои, в которых данные C++ связываются вручную с другими сущностями, например, отображение структур в C++ в формат json. Иногда с помощью макросов добавляется метаинформация о типе, которая используется в дальнейшем при построении REST API, ORM и т.д. Есть даже решения с плагинами для компилятора, например, [odb](http://www.codesynthesis.com/products/odb/).
Хотелось бы иметь что-то более естественное, без кодогенерации внешними утилитами, нагромождения макросов и шаблонов или ручного «мапинга». Этого пока нет и для решения приведенных задач нужно выбирать какой-то из приведенных подходов.
Предлагаемое решение основано на добавлении метаинформации к C++ типам с последующим ее использованием при решении разных задач. Можно сказать, что «тип нужно обуть в метаинформацию о нем» после чего он сможет смело шагать через границы процессов и датацентров и иметь возможность представляться по разному (binary, json, xml, text, etc) с минимальным вмешательством разработчика.
Часто подобные задачи решаются с применением кодогенерации, например, [thrift](https://thrift.apache.org/), [gSOAP](http://www.cs.fsu.edu/~engelen/soap.html), [protobuf](https://developers.google.com/protocol-buffers/docs/overview) и т.д. Мне хотелось получить свое решение, которое исключит внешнюю кодогенерацию, а все необходимое будет добавлено к типу в момент компиляции, и при этом есть желание максимально сохранить естественный синтаксис языка C++, не создавая новый язык в существующем языке.
MIF в примерах
==============
Хотелось бы показать некоторые возможности проекта MIF. А по обратной связи на пост, возможно, подготовлю и пост о реализации со всеми ее занудствами, тонкостями и объяснениями почему было выбрано то или иное решение.
Перечисленные в начале поста задачи предполагают, что будет какая-то возможность отображать C++ типы данных для сериализации, объектно-ориентированного межпроцессного взаимодействия, реализации REST API и т.д. С этого предлагаю и начать…
Рефлексия
---------
Рефлексия — основа всего проекта, позволяющая решать мои прикладные задачи.
Пример, как можно получить название C++ структуры данных, количество ее полей и обратиться к одному из полей по его номеру.
```
struct Data
{
int field1 = 0;
std::string field2;
};
```
Решение поставленной задачи могло выглядеть так:
```
int main()
{
Data data;
data.field1 = 100500;
data.field2 = "Text";
using Meta = Mif::Reflection::Reflect;
std::cout << "Struct name: " << Meta::Name::GetString() << std::endl;
std::cout << "Field count: " << Meta::Fields::Count << std::endl;
std::cout << "Field1 value: " << data.field1 << std::endl;
std::cout << "Field2 value: " << data.field2 << std::endl;
std::cout << "Modify fields." << std::endl;
data.\*Meta::Fields::Field<0>::Access() = 500100;
data.\*Meta::Fields::Field<1>::Access() = "New Text.";
std::cout << "Field1 value: " << data.field1 << std::endl;
std::cout << "Field2 value: " << data.field2 << std::endl;
return 0;
}
```
Все примерно так бы и было, немного по другому записано, но стандарт не дает возможности так просто отображать C++ типы данных. А чтобы приведенный код работал, нужно добавить к структуре Data метаинформацию
```
MIF_REFLECT_BEGIN(Data)
MIF_REFLECT_FIELD(field1)
MIF_REFLECT_FIELD(field2)
MIF_REFLECT_END()
MIF_REGISTER_REFLECTED_TYPE(Data)
```
Метаинформацию о типе можно было бы добавить и в сам тип, расширив его. От такого решения хотелось отказаться чтобы иметь возможность отображать типы, вмешиваться в код которых нет возможности (типы сторонних библиотек). Несколько макросов позволяют добавить всю нужную для дальнейшей работы информацию. Так же есть возможность наследования, но об этом позже …
**Код примера целиком**
```
// STD
#include
#include
// MIF
#include
#include
struct Data
{
int field1 = 0;
std::string field2;
};
MIF\_REFLECT\_BEGIN(Data)
MIF\_REFLECT\_FIELD(field1)
MIF\_REFLECT\_FIELD(field2)
MIF\_REFLECT\_END()
MIF\_REGISTER\_REFLECTED\_TYPE(Data)
int main()
{
Data data;
data.field1 = 100500;
data.field2 = "Text";
using Meta = Mif::Reflection::Reflect;
std::cout << "Struct name: " << Meta::Name::GetString() << std::endl;
std::cout << "Field count: " << Meta::Fields::Count << std::endl;
std::cout << "Field1 value: " << data.field1 << std::endl;
std::cout << "Field2 value: " << data.field2 << std::endl;
std::cout << "Modify fields." << std::endl;
data.\*Meta::Fields::Field<0>::Access() = 500100;
data.\*Meta::Fields::Field<1>::Access() = "New Text.";
std::cout << "Field1 value: " << data.field1 << std::endl;
std::cout << "Field2 value: " << data.field2 << std::endl;
return 0;
}
```
Немного усложненный пример: попробовать написать обобщенный код вывода на консоль всех полей структуры и ее базовых структур.
**Пример обхода структуры**
```
// STD
#include
#include
#include
#include
// MIF
#include
#include
#include
struct Base1
{
int field1 = 0;
bool field2 = false;
};
struct Base2
{
std::string field3;
};
struct Nested
{
int field = 0;
};
struct Data : Base1, Base2
{
int field4 = 0;
std::string field5;
std::map field6;
};
MIF\_REFLECT\_BEGIN(Base1)
MIF\_REFLECT\_FIELD(field1)
MIF\_REFLECT\_FIELD(field2)
MIF\_REFLECT\_END()
MIF\_REFLECT\_BEGIN(Base2)
MIF\_REFLECT\_FIELD(field3)
MIF\_REFLECT\_END()
MIF\_REFLECT\_BEGIN(Nested)
MIF\_REFLECT\_FIELD(field)
MIF\_REFLECT\_END()
MIF\_REFLECT\_BEGIN(Data, Base1, Base2)
MIF\_REFLECT\_FIELD(field4)
MIF\_REFLECT\_FIELD(field5)
MIF\_REFLECT\_FIELD(field6)
MIF\_REFLECT\_END()
MIF\_REGISTER\_REFLECTED\_TYPE(Base1)
MIF\_REGISTER\_REFLECTED\_TYPE(Base2)
MIF\_REGISTER\_REFLECTED\_TYPE(Nested)
MIF\_REGISTER\_REFLECTED\_TYPE(Data)
class Printer final
{
public:
template
static typename std::enable\_if(), void>::type
Print(T const &data)
{
using Meta = Mif::Reflection::Reflect;
using Base = typename Meta::Base;
PrintBase<0, std::tuple\_size::value, Base>(data);
std::cout << "Struct name: " << Meta::Name::GetString() << std::endl;
Print<0, Meta::Fields::Count>(data);
}
template
static typename std::enable\_if
<
!Mif::Reflection::IsReflectable() && !Mif::Serialization::Traits::IsIterable(),
void
>::type
Print(T const &data)
{
std::cout << data << std::boolalpha << std::endl;
}
template
static typename std::enable\_if
<
!Mif::Reflection::IsReflectable() && Mif::Serialization::Traits::IsIterable(),
void
>::type
Print(T const &data)
{
for (auto const &i : data)
Print(i);
}
private:
template
static typename std::enable\_if*::type
Print(T const &data)
{
using Meta = Mif::Reflection::Reflect;
using Field = typename Meta::Fields::template Field*;
std::cout << Field::Name::GetString() << " = ";
Print(data.\*Field::Access());
Print*(data);
}
template
static typename std::enable\_if*::type
Print(T const &)
{
}
template
static void Print(std::pair const &p)
{
Print(p.first);
Print(p.second);
}
template
static typename std::enable\_if*::type
PrintBase(T const &data)
{
using Type = typename std::tuple\_element::type;
Print(static\_cast(data));
PrintBase*(data);
}
template
static typename std::enable\_if*::type
PrintBase(T const &)
{
}
};
int main()
{
Data data;
data.field1 = 1;
data.field2 = true;
data.field3 = "Text";
data.field4 = 100;
data.field5 = "String";
data.field6["key1"].field = 100;
data.field6["key2"].field = 200;
Printer::Print(data);
return 0;
}*******
```
**Результат**
```
Struct name: Base1
field1 = 1
field2 = true
Struct name: Base2
field3 = Text
Struct name: Data
field4 = 100
field5 = String
field6 = key1
Struct name: Nested
field = 100
key2
Struct name: Nested
field = 200
```
Пример является прототипом для полноценного сериализатора, т.к. на основе добавленной метаинформации сериализует структуру в поток (в примере в стандартный поток вывода). Для определения является ли тип контейнером используется функция из пространства имен Serialization. В этом пространстве имен собраны готовые сериализаторы в json и boost.archives (xml, text, binary). Построены они по принципу близкому к приведенному в примере. Если нет необходимости расширить фреймворк своим сериализатором, то писать подобный код нет необходимости.
Вместо использования класса Printer можно воспользоваться готовым сериализатором, например, в json, и количество кода сильно сократится.
```
#include
#include
// Data and meta
int main()
{
Data data;
// Fill data
auto const buffer = Mif::Serialization::Json::Serialize(data); // Сериализация в json
std::cout << buffer.data() << std::endl;
return 0;
}
```
**Результат работы**
```
{
"Base1" :
{
"field1" : 1,
"field2" : true
},
"Base2" :
{
"field3" : "Text"
},
"field4" : 100,
"field5" : "String",
"field6" :
[
{
"id" : "key1",
"val" :
{
"field" : 100
}
},
{
"id" : "key2",
"val" :
{
"field" : 200
}
}
]
}
```
Для разнообразия можно попробовать воспользоваться сериализацией boost.archives в формате xml.
**Сериализация в xml с помощью boost.archives**
```
// BOOST
#include
// MIF
#include
#include
// Data and meta
int main()
{
Data data;
// Fill data
boost::archive::xml\_oarchive archive{std::cout};
archive << boost::serialization::make\_nvp("data", data);
return 0;
}
```
**Результат работы**
```
xml version="1.0" encoding="UTF-8" standalone="yes" ?
1
1
Text
100
String
2
0
key1
100
key2
200
```
Из примера видно, что кроме вызова конкретного сериализатора ничего не меняется. Используется одна и та же метаинфомация. Она же будет использоваться и в других местах при реализации межпроцессного взаимодействия.
Сериализации и десериализаторы нескольких форматов реализованы в каркасе. А при необходимости добавить поддержку нового формата можно сделать на примере класса Printer или взяв за основу (де)сериализатор формата json, используя предложенное API для обхода C++ структур данных. Есть некоторые ограничения на типы (куда же без них), но об этом позже.
Далее предлагаю перейти к более интересным вещам — реализации межпроцессного взаимодействия на базе передаваемых между процессами интерфейсов (C++ структур данных с чисто виртуальными методами).
Межпроцессное взаимодействие
----------------------------
С чего начинался проект MIF — это реализация межпроцессного взаимодействия. В ней была первоочередная потребность. На одной из первых реализаций этого механизма был разработан один из сервисов, который на момент написания этих строк поста отработал стабильно более полугода без падений и перезагрузок.
Имелась потребность сделать коммуникацию сервисов, расположенных на нескольких машинах, с помощью интерфейсов. Хотелось работать с сервисами как будто они все находятся в одном процессе.
Пример показывает насколько близко удалось приблизиться к желаемому результату.
**Задача:** разработать сервер и клиент для обмена информацией о сотрудниках вымышленной компании.
Решение подобных задач сводится к нескольким однотипным шагам
* Определить интерфейс(ы) взаимодействия компонент
* Определить пользовательские структуры данных (если в этом есть необходимость) для параметров методов или как возвращаемые значения
* Добавить метаинформацию
* Реализовать серверное приложение
* Реализовать клиентское приложение
[Пример complex\_type](https://github.com/tdv/mif/tree/master/examples/complex_type)
### Общая часть
**Структуры данных**
```
// data.h
namespace Service
{
namespace Data
{
using ID = std::string;
struct Human
{
std::string name;
std::string lastName;
std::uint32_t age = 0;
};
enum class Position
{
Unknown,
Developer,
Manager
};
struct Employee
: public Human
{
Position position = Position::Unknown;
};
using Employees = std::map;
} // namespace Data
} // namespace Service
```
**Метаинформация**
```
// meta/data.h
namespace Service
{
namespace Data
{
namespace Meta
{
using namespace ::Service::Data;
MIF_REFLECT_BEGIN(Human)
MIF_REFLECT_FIELD(name)
MIF_REFLECT_FIELD(lastName)
MIF_REFLECT_FIELD(age)
MIF_REFLECT_END()
MIF_REFLECT_BEGIN(Position)
MIF_REFLECT_FIELD(Unknown)
MIF_REFLECT_FIELD(Developer)
MIF_REFLECT_FIELD(Manager)
MIF_REFLECT_END()
MIF_REFLECT_BEGIN(Employee, Human)
MIF_REFLECT_FIELD(position)
MIF_REFLECT_END()
} // namespace Meta
} // namespace Data
} // namespace Service
MIF_REGISTER_REFLECTED_TYPE(::Service::Data::Meta::Human)
MIF_REGISTER_REFLECTED_TYPE(::Service::Data::Meta::Position)
MIF_REGISTER_REFLECTED_TYPE(::Service::Data::Meta::Employee)
```
**Интерфейс**
```
// imy_company.h
namespace Service
{
struct IMyCompany
: public Mif::Service::Inherit
{
virtual Data::ID AddEmployee(Data::Employee const &employee) = 0;
virtual void RemoveAccount(Data::ID const &id) = 0;
virtual Data::Employees GetEmployees() const = 0;
};
} // namespace Service
```
**Метаинформация**
```
// ps/imy_company.h
namespace Service
{
namespace Meta
{
using namespace ::Service;
MIF_REMOTE_PS_BEGIN(IMyCompany)
MIF_REMOTE_METHOD(AddEmployee)
MIF_REMOTE_METHOD(RemoveAccount)
MIF_REMOTE_METHOD(GetEmployees)
MIF_REMOTE_PS_END()
} // namespace Meta
} // namespace Service
MIF_REMOTE_REGISTER_PS(Service::Meta::IMyCompany)
```
Определение структуры данных и добавление метаинформации к ней такое же, как и в примерах с рефлексией, за исключением того, что все разнесено по пространствам имен.
Определение интерфейса — это определение C++ структуры данных, содержащей только чисто виртуальные методы.
Для интерфейсов было другое пожелание — возможность запрашивать из одного интерфейса другие, содержащиеся в реализации, и, возможно, не связанные в единую иерархию. Поэтому определяемый интерфейс всегда должен наследовать Mif::Service::IService или любой другой, наследуемый от Mif::Service::IService. Есть множественное наследование. Наследование делается через промежуточную сущность Mif::Service::Inherit. Это шаблон с переменным числом параметров. Его параметрами служат наследуемые интерфейсы или реализации ([inheritance](https://github.com/tdv/mif/tree/master/examples/inheritance)). Это необходимо для реализации механизма запроса интерфейсов такого же, как dynamic\_cast, но работающего и за границами процесса.
Добавление метаинформации к интерфейсу особо не отличается от добавления метаинформации для структур данных. Это другой, но аналогичный, набор макросов. Возможно позднее все же все будет сведено к единому набору макросов для определения структур данных и интерфейсов. Пока они разные. Так сложилось в ходе развития проекта.
Указывать при добавлении метаинформации к интерфейсу его базовые интерфейсы не надо. Вся иерархия будет найдена в момент компиляции. Здесь небольшая вспомогательная сущность Mif::Service::Inherit играет свою основную роль в поиске наследников и связанной с ними метаинформации.
При добавлении метаинформации к интерфейсам указывается только интерфейс и его методы без указания параметров, возвращаемых значений и cv-квалификаторов. Было желание сделать добавление метаинформации к интерфейсам в духе минимализма. Отсутствие перегрузки стало платой за минимализм. Считаю это малой ценой за возможность не перечислять все параметры и возвращаемые типы значений для каждого метода и не править их при небольших правках в интерфейсе.
Определив общие сущности, осталось реализовать серверное и клиентское приложения.
У каждого интерфейса может быть множество реализаций. Их как-то нужно отличать. При создании объекта нужно явно указывать желаемую реализацию. Для этого нужны идентификаторы реализаций интерфейсов и их связь с реализациями.
Для удобства и отказа от «магических значений в коде» идентификаторы реализаций лучше вынести в один или несколько заголовочных файлов. В проекте MIF в качестве идентификатора используются числа. Чтобы им как-то придать уникальность при этом не городить какие-то счетчики или все не помещать в один единый enum и иметь возможность логически разнести идентификаторы по разным файлам и пространствам имен, предлагается в качестве идентификаторов использовать crc32 от строки, с придумыванием уникальности которой проблем у разработчика должно быть меньше.
Для реализации интерфейса IMyCompany нужен идентификатор
```
// id/service.h
namespace Service
{
namespace Id
{
enum
{
MyCompany = Mif::Common::Crc32("MyCompany")
};
} // namespace Id
} // namespace Service
```
### Серверное приложение
**Реализация IMyCompany**
```
// service.cpp
// MIF
#include
#include
#include
// COMMON
#include "common/id/service.h"
#include "common/interface/imy\_company.h"
#include "common/meta/data.h"
namespace Service
{
namespace Detail
{
namespace
{
class MyCompany
: public Mif::Service::Inherit
{
public:
// …
private:
// …
// IMyCompany
virtual Data::ID AddEmployee(Data::Employee const &employee) override final
{
// ...
}
virtual void RemoveAccount(Data::ID const &id) override final
{
// ... }
}
virtual Data::Employees GetEmployees() const override final
{
// ...
}
};
} // namespace
} // namespace Detail
} // namespace Service
MIF\_SERVICE\_CREATOR
(
::Service::Id::MyCompany,
::Service::Detail::MyCompany
)
```
Есть несколько моментов, на которые хотелось бы обратить внимание:
* Наследование в реализации так же через Mif::Service::Inherit. Это не обязательно, но можно считать хорошим тоном и будет полезно при реализации нескольких интерфейсов с наследованием части ранее уже реализованных интерфейсов.
* Вся реализация может и, предпочтительно, должна быть сделана в одном cpp-файле, без разделения на h и cpp файлы. Что позволяет усилить инкапсуляцию и в больших проектах уменьшить время компиляции за счет того, что все необходимые включаемые файлы реализации находятся в файле с реализацией. При их модификации перекомпиляции подвергается меньшее число зависимых cpp-файлов.
* Каждая реализация имеет точку входа — MIF\_SERVICE\_CREATOR, что является фабрикой реализации. Параметрами являются класс-реализация, идентификатор и при необходимости переменное количество параметров, передаваемых в конструктор реализации.
Для завершения серверного приложения осталось добавить точку входа — функцию main.
```
// MIF
#include
// COMMON
#include "common/id/service.h"
#include "common/ps/imy\_company.h"
class Application
: public Mif::Application::TcpService
{
public:
using TcpService::TcpService;
private:
// Mif.Application.Application
virtual void Init(Mif::Service::FactoryPtr factory) override final
{
factory->AddClass<::Service::Id::MyCompany>();
}
};
int main(int argc, char const \*\*argv)
{
return Mif::Application::Run(argc, argv);
}
```
При создании точки входа нужно реализовать свой класс приложения — наследник от базового класса приложений или от одного из предопределенных шаблонов приложений. В переопределенном методе Init нужно добавить к фабрике все существующие реализации интерфейсов, которые будет экспортировать сервис (factory->AddClass). В метод AddClass можно передавать параметры конструктора реализации.
Сервис использует предопределенный транспорт tcp, сериализацию на базе boost.archive в бинарном формате со сжатием gzip данных для обмена информацией об интерфейсах, методах, параметрах, возвращаемых результатах, исключениях и экземплярах объектов.
Можно использовать другой вид транспорта (например, http, который так же доступен в MIF или реализовать свой), сериализации и собрать свою уникальную цепочку обработки данных (определение границ пакета, сжатие, шифрование, многопоточную обработку и т.д.). Для этого нужно воспользоваться уже не шаблоном приложения, а базовым классом приложений (Mif::Application::Application), определить самостоятельно нужные части цепочки обработки данных или транспорт.
В первой версии проекта MIF не было предопределенных шаблонов приложений. Примеры выглядели не такими короткими, но показывали весь путь, который нужно проделать для полного контроля над потоком обработки данных. Вся цепочка показана в примерах первой версии проекта ([MIF 1.0](https://github.com/tdv/mif/tree/v1.0.0)).
### Клиентское приложение
На стороне клиента используется все, что было определено в общей части.
Клиент — это такой же каркас приложения (в примере используется предопределенный шаблон приложения), в котором запрашивается удаленная фабрика классов / сервисов, через которую создается нужный объект и вызываются его методы.
```
// MIF
#include
#include
// COMMON
#include "common/id/service.h"
#include "common/ps/imy\_company.h"
class Application
: public Mif::Application::TcpServiceClient
{
public:
using TcpServiceClient::TcpServiceClient;
private:
void ShowEmployees(Service::Data::Employees const &employees) const
{
// ...
}
// Mif.Application.TcpServiceClient
virtual void Init(Mif::Service::IFactoryPtr factory) override final
{
auto service = factory->Create(Service::Id::MyCompany);
{
Service::Data::Employee e;
e.name = "Ivan";
e.lastName = "Ivanov";
e.age = 25;
e.position = Service::Data::Position::Manager;
auto const eId = service->AddEmployee(e);
MIF\_LOG(Info) << "Employee Id: " << eId;
}
{
Service::Data::Employee e;
e.name = "Petr";
e.lastName = "Petrov";
e.age = 30;
e.position = Service::Data::Position::Developer;
auto const eId = service->AddEmployee(e);
MIF\_LOG(Info) << "Employee Id: " << eId;
}
auto const &employees = service->GetEmployees();
ShowEmployees(employees);
if (!employees.empty())
{
auto id = std::begin(employees)->first;
service->RemoveAccount(id);
MIF\_LOG(Info) << "Removed account " << id;
auto const &employees = service->GetEmployees();
ShowEmployees(employees);
try
{
MIF\_LOG(Info) << "Removed again account " << id;
service->RemoveAccount(id);
}
catch (std::exception const &e)
{
MIF\_LOG(Warning) << "Error: " << e.what();
}
}
}
};
int main(int argc, char const \*\*argv)
{
return Mif::Application::Run(argc, argv);
}
```
### Результат
**Результат работы серверного приложения**
```
2017-08-09T14:01:23.404663 [INFO]: Starting network application on 0.0.0.0:55555
2017-08-09T14:01:23.404713 [INFO]: Starting server on 0.0.0.0:55555
2017-08-09T14:01:23.405442 [INFO]: Server is successfully started.
2017-08-09T14:01:23.405463 [INFO]: Network application is successfully started.
Press 'Enter' for quit.
2017-08-09T14:01:29.032171 [INFO]: MyCompany
2017-08-09T14:01:29.041704 [INFO]: AddEmployee. Name: Ivan LastName: Ivanov Age: 25 Position: Manager
2017-08-09T14:01:29.042948 [INFO]: AddEmployee. Name: Petr LastName: Petrov Age: 30 Position: Developer
2017-08-09T14:01:29.043616 [INFO]: GetEmployees.
2017-08-09T14:01:29.043640 [INFO]: Id: 0 Name: Ivan LastName: Ivanov Age: 25 Position: Manager
2017-08-09T14:01:29.043656 [INFO]: Id: 1 Name: Petr LastName: Petrov Age: 30 Position: Developer
2017-08-09T14:01:29.044481 [INFO]: Removed employee account for Id: 0 Name: Ivan LastName: Ivanov Age: 25 Position: Manager
2017-08-09T14:01:29.045121 [INFO]: GetEmployees.
2017-08-09T14:01:29.045147 [INFO]: Id: 1 Name: Petr LastName: Petrov Age: 30 Position: Developer
2017-08-09T14:01:29.045845 [WARNING]: RemoveAccount. Employee with id 0 not found.
2017-08-09T14:01:29.046652 [INFO]: ~MyCompany
2017-08-09T14:02:05.766072 [INFO]: Stopping network application ...
2017-08-09T14:02:05.766169 [INFO]: Stopping server ...
2017-08-09T14:02:05.767180 [INFO]: Server is successfully stopped.
2017-08-09T14:02:05.767238 [INFO]: Network application is successfully stopped.
```
**Результат работы клиентского приложения**
```
2017-08-09T14:01:29.028821 [INFO]: Starting network application on 0.0.0.0:55555
2017-08-09T14:01:29.028885 [INFO]: Starting client on 0.0.0.0:55555
2017-08-09T14:01:29.042510 [INFO]: Employee Id: 0
2017-08-09T14:01:29.043296 [INFO]: Employee Id: 1
2017-08-09T14:01:29.044082 [INFO]: Employee. Id: 0 Name: Ivan LastName: Ivanov Age: 25 Position: Manager
2017-08-09T14:01:29.044111 [INFO]: Employee. Id: 1 Name: Petr LastName: Petrov Age: 30 Position: Developer
2017-08-09T14:01:29.044818 [INFO]: Removed account 0
2017-08-09T14:01:29.045517 [INFO]: Employee. Id: 1 Name: Petr LastName: Petrov Age: 30 Position: Developer
2017-08-09T14:01:29.045544 [INFO]: Removed again account 0
2017-08-09T14:01:29.046357 [WARNING]: Error: [Mif::Remote::Proxy::RemoteCall] Failed to call remote method "IMyCompany::RemoveAccount" for instance with id "411bdde0-f186-402e-a170-4f899311a33d". Error: RemoveAccount. Employee with id 0 not found.
2017-08-09T14:01:29.046949 [INFO]: Client is successfully started.
2017-08-09T14:01:29.047311 [INFO]: Network application is successfully started.
Press 'Enter' for quit.
2017-08-09T14:02:02.901773 [INFO]: Stopping network application ...
2017-08-09T14:02:02.901864 [INFO]: Stopping client ...
2017-08-09T14:02:02.901913 [INFO]: Client is successfully stopped.
2017-08-09T14:02:02.901959 [INFO]: Network application is successfully stopped.
```
Да, исключения так же преодолевают границы процессов…
```
[WARNING]: Error: [Mif::Remote::Proxy::RemoteCall] Failed to call remote method "IMyCompany::RemoveAccount" for instance with id "411bdde0-f186-402e-a170-4f899311a33d". Error: RemoveAccount. Employee with id 0 not found.
```
Из сообщения видно, что был повторно вызван метод удаления информации о сотруднике с идентификатором 0. На стороне сервера уже такой записи нет, о чем сервер сообщил исключением с текстом «Employee with id 0 not found»/
Пример продемонстрировал межпроцессное взаимодействие клиента с сервером, максимально скрывая все детали связанные с транспортом и форматом передаваемых данных.
Этот пример завершает показ базы, лежащей в основе проекта MIF. К дополнительным возможностям можно отнести
* [Возможность запрашивать интерфейсы](https://github.com/tdv/mif/tree/master/examples/inheritance) у реализации не объединенные в единую иерархию (не считая наследования от Mif::Service::IService).
* Передавать указатели и умные указатели на интерфейсы между сервисами. Что может пригодиться для разных реализаций сервисов с обратными вызовами. Например, сервис на базе publish/subscribe. В качестве примера приведена реализация паттерна [visitor](https://github.com/tdv/mif/tree/master/examples/visitor), части которого находятся в разных процессах и взаимодействуют по tcp.
HTTP
----
В примере межпроцессного взаимодействия можно легко заменить существующий TCP -транспорт, на HTTP -транспорт. Появится возможность обращаться к сервисам с помощью привычных средств, например, curl или из браузера.
Поддержка HTTP дает возможность строить сервисы, которые одновременно могут являться и web-сервером с каким-нибудь json REST API, и в то же время поддерживать ранее продемонстрированное взаимодействие через C++ интерфейсы.
Комфорт часто связан с ограничениями. Таким ограничением при использовании HTTP-транспорта является отсутствие возможности обратного вызова методов, передаваемых интерфейсов. Решение на базе HTTP-транспорта не ориентировано на построение приложений publish / subscribe. Это связано с тем, что работа по HTTP предполагает подход «запрос-ответ». Клиент посылает запросы серверу и ждет ответа.
Предложенный в MIF TCP-транспорт такого ограничения не имеет. Вызвать методы может как клиент, так и сервер. В этом случае размываются разграничения клиента и сервера. Появляется канал, по которому объекты могут общаться друг с другом, вызывая методы с любой его стороны. Это дает возможность двустороннего взаимодействия для построения архитектуры publish / subscribe, что было продемонстрировано в примере межпроцессным [посетителем](https://github.com/tdv/mif/tree/master/examples/visitor).
В MIF HTTP уделено особое внимание, т.к. изначально направленность была на разработку backend сервисов для веба. Нужно было создавать небольшие HTTP веб-сервисы, получать данные от поставщиков по HTTP и только после этого была добавлена возможность использования HTTP в качестве транспорта при маршалинге интерфейсов между процессами. Поэтому хотелось бы в начале продемонстрировать примеры создания простых web-сервисов, клиентов, а в конце привести пример web-сервера с поддержкой передачи интерфейсов между процессами.
### Простой HTTP web-сервер
```
// MIF
#include
#include
#include
class Application
: public Mif::Application::HttpServer
{
public:
using HttpServer::HttpServer;
private:
// Mif.Application.HttpServer
virtual void Init(Mif::Net::Http::ServerHandlers &handlers) override final
{
handlers["/"] = [] (Mif::Net::Http::IInputPack const &request,
Mif::Net::Http::IOutputPack &response)
{
auto data = request.GetData();
MIF\_LOG(Info) << "Process request \"" << request.GetPath()
<< request.GetQuery() << "\"\t Data: "
<< (data.empty() ? std::string{"null"} :
std::string{std::begin(data), std::end(data)});
response.SetCode(Mif::Net::Http::Code::Ok);
response.SetHeader(
Mif::Net::Http::Constants::Header::Connection::GetString(),
Mif::Net::Http::Constants::Value::Connection::Close::GetString());
response.SetData(std::move(data));
};
}
};
int main(int argc, char const \*\*argv)
{
return Mif::Application::Run(argc, argv);
}
```
Для проверки работы можно воспользоваться командой
```
curl -iv -X POST "http://localhost:55555/" -d 'Test data'
```
Всего около трех десятков строк кода и многопоточный HTTP эхо-сервер на базе каркаса приложений MIF готов. В качестве backend используется libevent. Простое тестирование с помощью утилиты ab выдает средний результат до 160K запросов в секунду. Конечно все зависит от «железа», на котором проводится тестирование, операционной системы, сети и т.д. Но для сравнения что-то подобное было сделано на Python и Go. Сервер на Python отработал в 2 раза медленнее, а на Go результат был лучше в среднем на 10% от результата сервера из примера. Так что, если Вы C++ разработчик и Python и Go Вам чужды или есть иные, возможно официально закрепленные внутренними распоряжениями в рамках проекта, причины любить только C++, то можно воспользоваться предложенным решением и получить неплохие результаты по скорости работы и срокам разработки …
### HTTP клиент
Клиентская часть представлена классом [Mif::Net::Http::Connection](https://github.com/tdv/mif/blob/master/include/mif/net/http/connection.h). Это основа HTTP-транспорта маршалинга C++ интерфейсы в MIF. Но пока не про маршалинг… Класс может использоваться отдельно от всей инфраструктуры межпроцессного взаимодействия MIF-микросервисов, например, для скачивания данных поставщиков, например, медиаконтента, прогноза погоды, биржевых котировок и т.д.
Запустив приведенный выше эхо-сервис, можно к нему обратиться таким клиентом:
```
// STD
#include
#include
#include
#include
// MIF
#include
#include
int main()
{
try
{
std::string const host = "localhost";
std::string const port = "55555";
std::string const resource = "/";
std::promise promise;
auto future = promise.get\_future();
Mif::Net::Http::Connection connection{host, port,
[&promise] (Mif::Net::Http::IInputPack const &pack)
{
if (pack.GetCode() == Mif::Net::Http::Code::Ok)
{
auto const data = pack.GetData();
promise.set\_value({std::begin(data), std::end(data)});
}
else
{
promise.set\_exception(std::make\_exception\_ptr(
std::runtime\_error{
"Failed to get response from server. Error: "
+ pack.GetReason()
}));
}
}
};
auto request = connection.CreateRequest();
request->SetHeader(Mif::Net::Http::Constants::Header::Connection::GetString(),
Mif::Net::Http::Constants::Value::Connection::Close::GetString());
std::string data = "Test data!";
request->SetData({std::begin(data), std::end(data)});
connection.MakeRequest(Mif::Net::Http::Method::Type::Post,
resource, std::move(request));
std::cout << "Response from server: " << future.get() << std::endl;
}
catch (std::exception const &e)
{
std::cerr << "Error: " << e.what() << std::endl;
return EXIT\_FAILURE;
}
return EXIT\_SUCCESS;
}
```
Это базовый пример без учета особого внимания на обработку ошибок. Он демонстрирует возможность разработки простого клиента. Конечно лучше использовать что-то иное, например, на базе библиотеки curl, но иногда в простых случаях вполне может быть достаточно приведенного выше кода.
### HTTP web-сервер с двойным интерфейсом
Пример подводит итог по поддержке HTTP в проекте MIF. В примере показан HTTP web-сервер, к которому можно обращаться из браузера или с помощью curl, а так же клиентом, работающим через C++ интерфейсы и не желающего знать ничего о транспорте и формате данных. Используется тот же каркас приложения Mif::Application::HttpServer, что и ранее. Ниже приведены необходимые для демонстрации фрагменты кода. Целиком пример доступен на github в примере [http](https://github.com/tdv/mif/tree/master/examples/http).
#### Общая часть
**Интерфейс**
```
namespace Service
{
struct IAdmin
: public Mif::Service::Inherit
{
virtual void SetTitle(std::string const &title) = 0;
virtual void SetBody(std::string const &body) = 0;
virtual std::string GetPage() const = 0;
};
} // namespace Service
```
Добавление метаинформации к интерфейсу, идентификатор сервиса-реализации — все, аналогично приведенным ранее примерам межпроцессного взаимодействия.
#### Серверная часть
**Каркас приложения**
```
class Application
: public Mif::Application::HttpServer
{
//...
private:
// Mif.Application.HttpService
virtual void Init(Mif::Net::Http::ServerHandlers &handlers) override final
{
std::string const adminLocation = "/admin";
std::string const viewLocation = "/view";
auto service = Mif::Service::Create(viewLocation);
auto webService = Mif::Service::Cast(service);
auto factory = Mif::Service::Make();
factory->AddInstance(Service::Id::Service, service);
std::chrono::microseconds const timeout{10000000};
auto clientFactory = Service::Ipc::MakeClientFactory(timeout, factory);
handlers.emplace(adminLocation, Mif::Net::Http::MakeServlet(clientFactory));
handlers.emplace(viewLocation, Mif::Net::Http::MakeWebService(webService));
}
};
```
Обработчик ресурса задается уже не напрямую, а через дополнительную обертку, которая позволяет:
* Добавлять к ресурсу разные обработчики
* Автоматически делать разбор параметров запроса и данных из тела запроса
* Автоматически сериализовать ответ в выбранный формат
* Объединять два подхода: работу по HTTP через, возможно, REST API и работу с клиентом с поддержкой маршалинга C++ интерфейсов
Все эти возможности реализованы в базовом классе Mif::Net::Http::WebService. Пользовательский класс должен наследовать его. Т.к. это уже сервис, который содержит чисто виртуальные методы, реализация которых скрыта в сервисном коде каркаса, то экземпляры классов-наследников должны создаваться так же как и все сервисы — фабричным методом. Чтобы сервис можно было использовать как обработчик HTTP web-сервера нужно создать обертку функцией Mif::Net::Http::MakeServlet.
***Сервисы MIF и веб-сервисы — это разные сервисы. Под MIF сервисами стоит понимать только классы-реализации интерфейсов, которые не обязаны заниматься только обработкой HTTP-запросов или иных сетевых запросов. Веб-сервисы уже более привычное понятие. Но при необходимости в MIF это все легко объединяется в единое целое и приведенный пример этому подтверждение.***
**Сервис-обработчик**
```
namespace Service
{
namespace Detail
{
namespace
{
class WebService
: public Mif::Service::Inherit
<
IAdmin,
Mif::Net::Http::WebService
>
{
public:
WebService(std::string const &pathPrefix)
{
AddHandler(pathPrefix + "/stat", this, &WebService::Stat);
AddHandler(pathPrefix + "/main-page", this, &WebService::MainPage);
}
private:
// …
// IAdmin
virtual void SetTitle(std::string const &title) override final
{
// ...
}
// …
// Web hadlers
Result Stat()
{
// ...
std::map resp;
// Fill resp
return resp;
}
Result
MainPage(Prm const &format)
{
// ...
}
};
} // namespace
} // namespace Detail
} // namespace Service
MIF\_SERVICE\_CREATOR
(
::Service::Id::Service,
::Service::Detail::WebService,
std::string
)
```
Хотелось бы обратить внимание на несколько моментов:
* Выше уже упоминалась необходимость использования Mif::Service::Inherit при написании реализаций. Здесь как раз роль Mif::Service::Inherit полностью оправдана. С одной стороны класс наследует интерфейс IAdmin и реализует все его методы, а с другой наследует реализацию интерфейса IWebService в виде базового класса Mif::Net::Http::WebService, которая делает работу с HTTP проще.
* В конструкторе добавляются обработчики ресурсов. Полный путь строится из пути ресурса, с которым связан класс-наследник Mif::Net::Http::WebService и пути, который указан при вызове AddHandler. В примере путь для получения статистики по выполненным запросам будет выглядеть, как **/view/stat**
* Возвращаемый тип обработчика может быть любым, который можно вывести в поток. Кроме того в качестве возвращаемого типа можно использовать обертку-сериализатор. Она сериализует переданный встроенный или пользовательский тип в свой формат. В этом случае для сериализации пользовательских типов используется добавленная к ним метаинформация.
* Методы-обработчики могут принимать параметры. Для описания параметров используется сущность Prm. Класс Prm принимает тип параметра, его имя. При необходимости пользовательская реализация разбора параметров может быть передана в Prm. Поддерживается конвертация параметров запроса к интегральным типам, типам с плавающей точкой, множества параметров с разделителем в виде точки с запятой (некоторые stl контейнеры, например, list, vector, set). Так же дата, время и timestamp целиком, которые можно привести к типам boost::posix\_time. Десериализация данных тела запроса производится классом Content. Класс использует метаинформацию и преданный десериализатор. При необходимости получить доступ к заголовкам запроса или ко всей карте параметров, в качестве параметра обработчика можно указать Headers и / или Params. Одновременно можно использовать все указанные классы. Подробная работа с параметрами показана в примере [http\_crud](https://github.com/tdv/mif/tree/master/examples/http_crud)
* При определении фабричного метода для создания класса реализации в макрос MIF\_SERVICE\_CREATOR передается дополнительный параметр, который должен быть передан в конструктор реализации. Использование макроса MIF\_SERVICE\_CREATOR упоминалось выше.
**Клиент**
Клиент не имеет особых отличий от ранее приведенных примеров. Исключением является отсутствие предопределенной цепочки обработки запросов. Она формируется разработчиком самостоятельно. Для работы по HTTP в MIF нет предопределенных цепочек обработки запросов. Особенности реализации… О причинах, возможно, что-то в последующих постах будет написано. Полный код клиента — это пример [http](https://github.com/tdv/mif/tree/master/examples/http).
**Результаты**
Для тестирования собранный сервер нужно запустить и попробовать обратиться к нему, например, с использованием команды curl или из браузера
```
curl "http://localhost:55555/view/main-page?format=text"
curl "http://localhost:55555/view/main-page?format=html"
curl "http://localhost:55555/view/main-page?format=json"
```
После чего запустить клиентское приложение, которое обращается через интерфейс администратора и меняет данные и повторно попробовать выполнить приведенные curl команды. Можно заметить, что внесенные клиентом изменения были успешно применены и выдаваемый по HTTP результат изменился.
Работа с базами данных
----------------------
Backedn без БД? Как же без них? Не обязательно, но и не редко…
На текущий момент работа с базами данных в MIF реализована без опоры на метаинформацию. Пока что почти классика работы с БД. Эта часть была нужна для разработки сервисов, которые что-то должны были хранить в БД. Но разработка этой части велась с прицелом на то, что она станет основой для ORM, где уже в полной мере будет использована вся метаинформация, добавляемая к типам. С ORM как-то пока не сложилось. Было несколько попыток реализовать. Получалось или сильно громоздко, или не гибко. Думаю, что компромисс между лаконичностью и гибкостью скоро будет достигнут и в ближайших версиях ORM все же появится, т.к. уж очень хочется иметь возможность какие-то проверки переложить на компилятор, а не ловить в момент исполнения программы ошибки, связанные с простейшими ошибками и опечатками в сырых строках SQL-запросов.
Пока ORM нет, немного классики …
Работа с БД содержит несколько шагов:
* Создание объекта-подключения к БД
* Выполнение запросов, через полученное подключение
* Обработка результатов
* Транзакции
Кто работал с какими-нибудь обертками такими, как JDBC (в Java) или что-то подобное для C++ ничего нового для себя тут не откроют.
В примере [db\_client](https://github.com/tdv/mif/tree/master/examples/db_client) показана работа с двумя СУБД: PostgreSQL и SQLite.
HTTP CRUD сервер
----------------
Пример [http\_crud](https://github.com/tdv/mif/tree/master/examples/http_crud) является логическим завершением демонстрации работы с HTTP и БД — классика простых микросервисов для веба, которые не взаимодействуют непосредственно друг с другом.
Класс web-сервера содержит обработчики всех базовых операций CRUD. Работа с БД ведется в обработчиках. Такой код можно нередко встретить в разных успешно работающих сервисах. Но не смотря на его изначальную простору, в нем есть недостаток — зависимость от СУБД. А при желании отказаться от реляционной БД и перейти к NoSQL базе данных код всех обработчиков почти полностью будет переписан. Во многих реальных проектах стараюсь избегать подобной работы с БД. Выносить в отдельные фасады высокоуровневые функции логики. Фасады — это как правило C++ интерфейсы с конкретными реализациями. А замена БД сводится к очередной реализации интерфейса и запросу у фабрики реализации с новым идентификатором. Играя капитана очевидности, можно сказать, что такой подход себя не раз оправдал.
Заключение
==========
Все, что рассмотрено выше: рефлексия, сериализация, межпроцессное взаимодействие, маршалинг интерфейсов, работа с БД, поддержка HTTP — все нашло свое отражение в итоговом примере построения небольшой [системы на микросервисах](https://github.com/tdv/mif/tree/master/examples/microservices). Пример демонстрирует небольшой сервис, состоящий из двух микросервисов, взаимодействующих между собой. Один сервис является фасадом к БД, а второй предоставляет Json API для внешних клиентов. Пример является модифицированной версией рассмотренного примера [http\_crud](https://github.com/tdv/mif/tree/master/examples/http_crud) и является логическим завершением (объединением) всему, о чем шла речь в рамках поста.
Некоторые части MIF, не были рассмотрены, например, [db\_client](https://github.com/tdv/mif/tree/master/examples/db_client), но работа с БД показана в других примера. Работа с сервисами (реализациями интерфейсов) так же частично затронута в примерах. Некоторые части MIF, такие как сериализация, работа с БД и поддержка HTTP уже неоднократно проверены. Межпроцессному взаимодействию пока было уделено меньше времени на проверку и отладку, несмотря на то, что некоторым частям в разработке было уделено много времени. Например, к таким можно отнести поддержку передачи интерфейсов как параметров в другой процесс и обратный вызов их методов. Что является по сути «эго-фичей». Хотелось попробовать реализовать подобный механизм, показанный в примере [visitor](https://github.com/tdv/mif/tree/master/examples/visitor), но в дальнейшем есть желание довести эту часть до полноценного проверенного и отлаженного решения.
В дальнейшем, возможно, при наличии интереса к изложенному материалу, пост будет иметь продолжение с тем, что не вошло в этот, например, что «под капотом» MIF, почему приняты те или иные решения, какие задачи пришлось решить, чем не подошел thrift или иные подобные решения, какие недочеты вижу и что хотелось бы поменять и усовершенствовать и т.д. Проект появился, как «home project» и, к моему же удивлению, является проектом, которому я уделяю внимание уже почти год, то не должно возникнуть проблем с тем, о чем можно еще написать.
Подводя итог, продублирую ссылку на проект [MIF on C++](https://github.com/tdv/mif).
*Спасибо за внимание.* | https://habr.com/ru/post/239571/ | null | ru | null |
# Расширяя границы или о задаче проверки гипотезы о нормальности многомерного распределения
*Краткий рассказ про пакет MVN*
### Минутка теории
Допустим, у нас есть некоторое совместное распределение n переменных – и нам необходимо проверить, является ли оно нормальным. Решить эту задачу просто нам мешает один маленький факт – из нормальности многомерного распределения следует нормальность распределения каждой переменной в отдельности, но в обратную сторону это работает только при случае независимости компонентов распределения, что на практике не выполняется почти никогда. Поэтому приходится что-то изобретать.
Схема проверки статистической гипотезы о нормальности многомерного распределения идентична соответствующей для одномерного случая, только в ней используются другие тесты.
Тест Мардиа (оригинальная работа: K. V. Mardia. Measures of multivariate skewness and kurtosis with applications. Biometrika, 57(3): 519–530, 1970) основан на вычислении эксцесса и асимметрии многомерного распределения по формулам
n - количество наблюдений, р – переменныхПри этом m – это расстояние Маланхобиса между i-м и j-м наблюдениями
S - ковариационная матрицыВ такой трактовке рассчитанная величина асимметрии, умноженная на n/6, распределена по закону Хи-квадрат с p(p+1)(p+2)/6 степенями свободы, а величина эксцесса распределена по закону нормального распределения со средним p(p+2) и отклонением 8p(p+2)/n
Тест Хенце-Циклера (базовая работа: N. Henze and B. Zirkler. A class of invariant consistent tests for multivariate normality. Communications in Statistics - Theory and Methods, 19(10):3595–3617, 1990.) основан на следующей формуле расчета статистического критерия:
D – расстояние Маланхобиса, β – параметрЗначения критерия распределены по логнормальному закону с параметрами
Тест Ройстона основан на идее теста Шапиро-Уилкса. Значение статистического критерия рассчитывается по формуле
Его величина распределяется по закону Хи-квадрат с количеством степеней свободы, равным е. Цепочка расчетов следующая:
Wj – значение статистики Шапиро-Уилка для j-ой переменной, r – коэффициент корреляцииТест Дорника-Хансена (оригинальная работа: Doornik, J. A., and H. Hansen. 2008. An omnibus test for univariate and multivariate normality. Oxford Bulletin of Economics and Statistics 70: 927–939.) основан на преобразовании многомерных наблюдений и вычислении эксцесса и асимметрии для одномерной переменной.
Преобразование проводиться по формуле
Первая матрица этого произведения – центрированная матрица исходных данных Х
Вторая матрица – диагональная матрица, в которой элементы равны S-1/2 для отдельной переменной
Третья матрица – матрица собственных векторов корреляционной матрицы С
Четвертая матрица – диагональная матрица собственных значений матрицы СДалее рассчитывается эксцесс и асимметрия для каждой переменной в новой матрице.
Значения асимметрии (b1) и эксцесса (b2) распределены не по нормальному закону. Для их трансформации применяются следующие преобразования:
Полученные значения z1 и z2 объединяются в вектора Z1 и Z2, а рассчитанная величина статистики распределена по закону Хи-квадрат с числом степеней свободы, равном 2k
Формула расчета тестовой статистикиТест Е-статистики (тест Шекели-Риццо, базовая работа: G.J. Szekely, M.L. Rizzo. A new test for multivariate normality / Journal of Multivariate Analysis 93 (2005) 58–80) подразумевает вычисление тестовой статистики с помощью разложения в ряд Тейлора:
n – количество наблюдений, d – количество переменныхy – центрированная матрица наблюдений, получаемая путем постолбцовых пребразований как
### Методология
Для примера выберем базу данных “Crime” из пакета plm, и возьмем оттуда три переменных:
prbpris – вероятность тюремного заключения
avgsen – средний срок заключения, дней
pctymle – доля в населении мужчин в возрасте 15-24 лет
Из этих трех переменных соберем две базы данных – с двумя и тремя переменными:
```
library(MVN)
library(tidyverse)
library(plm)
data("Crime")
glimpse(Crime)
ggplot(Crime, aes(x=Crime$avgsen)) + geom_density()
# Crime$prbpris - точно, avgsen - 70/30, pctymle - 50/50
Data_1 <- Crime[,c(6,7)]
Data_2 <- Crime[,c(6,7,24)]
```
### Расчеты и описание
Базовая функция расчетов – функция mvn со следующими параметрами:
data - База данных (в виде матрицы или датафрейма)
subset - Факторная группировочная переменная
mvnTest - Определяет статистический тест, которым проводится проверка
desc - Логическая переменная. Если она равна истине, выводятся описательные статистики
univariateTest - Определяет статистический тест, которым проводится проверка на нормальность отдельных переменных
univariatePlot - Определяет вид выводимого одномерного графика нормальности
multivariatePlot - Определяет вид графика ошибок
multivariateOutlierMethod - Выбирает метод определения выбросов
Проверим наши данные на нормальность с помощью классического теста Мардиа
Результат один – NO в графах «Result» и «Normality» говорят нам о том, что нельзя принять гипотезу как о нормальном многомерном распределении как всей совокупности переменных, так и нормальности распределения каждой переменной в отдельности.Можно глазами посмотреть на Q-Q график
```
mvn(data = Data_1, mvnTest = "mardia", multivariatePlot = "qq")
```
А также на двумерный график распределения
```
mvn(data = Data_1, mvnTest = "mardia", multivariatePlot = "qq")
```
И на двумерный контурный график
```
mvn(data = Data_1, mvnTest = "energy", multivariatePlot = "contour")
```
Цифры - соответствующие квантилиМожно также вывести, например, Q-Q график по каждой переменной в отдельности
```
mvn(data = Data_1, mvnTest = "mardia", univariatePlot = "qqplot")
```
Особенно интересна возможность, предоставляемая переменной subset. Если есть группировочная переменная, есть возможность проверить многомерные / одномерные нормальности в зависимости от разных ее значений:
В нашем примере гипотеза о многомерной нормальности не подтверждается для любого из рассматриваемых регионов, но переменная «вероятность тюремного заключения» распределена по нормальному закону для западного и центрального района.Это основы функционала пакета MVN. Все материалы доступны на <https://github.com/acheremuhin/Multivariate_normal> | https://habr.com/ru/post/597865/ | null | ru | null |
# SNMP + Java – личный опыт. Пишем парсер MIB-файлов
SNMP – не самый юзер-френдли протокол: MIB-файлы слишком длинные и запутанные, а OID'ы просто невозможно запомнить. А что если возникла необходимость работать с SNMP на Java? Например, написать автотесты для проверки API SNMP-сервера.
Путём проб и ошибок при наличии довольно скудного количества информации по теме мы все же придумали, как подружить Java и SNMP.
В этой серии статей я постараюсь поделиться полученным опытом работы с протоколом. Первая статья в серии будет посвящена реализации парсера MIB-файлов на Java. Во второй части я расскажу о написании SNMP-клиента. В третьей части речь пойдёт о реальном примере использования написанной библиотеки: автотестах для проверки взаимодействия с устройством по протоколу SNMP.
Вступление
----------
Всё началось с того, что поступила задача написать автотесты для проверки работы аудио-видео регистратора по протоколу SNMP. Осложняло ситуацию то, что информации по взаимодействию с SNMP на Java не так уж много, особенно если говорить о русскоязычном сегменте интернета. Конечно, можно было посмотреть в сторону C# или Python. Но в C# ситуация с протоколом примерно такая же сложная, как и в Java. В питоне же есть пара неплохих библиотек, но у нас уже была готовая инфраструктура для автотестов REST API данного устройства именно на Java.
Как и для любого другого протокола взаимодействия по сети, нам нужен был SNMP-клиент для работы с различными видами запросов. Автотесты должны были уметь проверять успешность GET- и SET-запросов для скалярных и табличных параметров. Для таблиц требовалось также иметь возможность проверить добавление и удаление записей, если сама таблица допускает эти операции.
Но помимо клиента библиотека должна была содержать класс для работы с MIB-файлами. Этот класс должен был уметь распарсить MIB-файл для получения типов данных, границ допустимых значений и т.д., чтобы не хардкодить то, что всегда может измениться.
В ходе поиска подходящих библиотек для Java мы не нашли ни одной библиотеки, которая позволяла бы работать и с запросами, и с MIB-файлами. Поэтому мы остановились на двух разных библиотеках. Для клиента вполне логичным показался выбор широко используемой org.snmp4j.snmp4j (https://www.snmp4j.org), а для парсера MIB-файлов выбор пал на не особо известную библиотеку net.percederberg.mibble (https://www.mibble.org). Если с snmp4j выбор был очевиден, то mibble была выбрана за наличие достаточно подробной (хоть и англоязычной) документации с примерами. Итак, начнём.
Пишем парсер MIB-файлов
-----------------------
Все, кто когда-либо видел MIB-файлы, знают, что это боль. Попробуем это исправить с помощью несложного парсера, который значительно облегчит поиск информации из файла, сведя его к вызову того или иного метода.
Такой парсер можно использовать как отдельную утилиту для работы с MIB-файлами или включить в любой другой проект под SNMP, например, при написании SNMP-клиента или автоматизации тестирования.
#### Подготовка проекта
Для удобства сборки мы используем Maven. В зависимости добавляем библиотеку net.percederberg.mibble (https://www.mibble.org), которая облегчит нам работу с MIB-файлами:
```
net.percederberg.mibble
mibble
2.9.3
```
Так как она лежит не в центральном репозитории Maven, добавляем в pom.xml следующий код:
```
opennms
OpenNMS
http://repo.opennms.org/maven2/
```
Если проект собирается с помощью мавена без ошибок, всё готово для работы. Осталось только создать класс парсера (назовём его MIBParser) и импортировать всё, что нам нужно, а именно:
```
import net.percederberg.mibble.*;
```
#### Загрузка и валидация MIB-файла
Внутри класса будет только одно поле – объект типа net.percederberg.mibble.Mib для хранения загруженного MIB-файла:
```
private Mib mib;
```
Для загрузки файла пишем вот такой метод:
```
private Mib loadMib(File file) throws MibLoaderException, IOException {
MibLoader loader = new MibLoader();
Mib mib;
file = file.getAbsoluteFile();
try {
loader.addDir(file.getParentFile());
mib = loader.load(file);
} catch (MibLoaderException e) {
e.getLog().printTo(System.err);
throw e;
} catch (IOException e) {
e.printStackTrace();
throw e;
}
return mib;
}
```
Класс net.percederberg.mibble.MIBLoader валидирует файл, который мы пытаемся загрузить и бросит исключение net.percederberg.mibble.MibLoaderException в случае, если найдёт в нём какие-то ошибки, в том числе ошибки импорта из других MIB-файлов, если они не лежат в той же директории или не содержат импортируемые MIB-символы.
В методе loadMib ловим все исключения, пишем о них в лог и прокидываем дальше, т.к. на этом этапе продолжение работы невозможно – файл не валидный.
Написанный метод мы вызываем в конструкторе парсера:
```
public MIBParser(File file) throws MibLoaderException, IOException {
if (!file.exists())
throw new FileNotFoundException("File not found in location: " + file.getAbsolutePath());
mib = loadMib(file.getAbsoluteFile());
if (!mib.isLoaded())
throw new MibLoaderException(file, "Not loaded.");
}
```
Если файл успешно загрузился и распарсился, продолжаем работу.
#### Методы для получения информации из MIB-файла
С помощью методов класса net.percederberg.mibble.Mib можно искать отдельные символы MIB-файла по имени или OID с помощью вызова метода getSymbol(String name) или getSymbolByOid(String oid) соответственно. Эти методы возвращают нам объект net.percederberg.mibble.MibSymbol, методами которого мы будем пользоваться для получения необходимой информации по конкретному MIB-символу.
Начнём с самого простого и напишем методы для получения имени символа по его OID и, наоборот, OID по имени:
```
public String getName(String oid) {
return mib.getSymbolByOid(oid).getName();
}
public String getOid(String name) {
String oid = null;
MibSymbol s = mib.getSymbol(name);
if (s instanceof MibValueSymbol) {
oid = ((MibValueSymbol) s).getValue().toString();
if (((MibValueSymbol) s).isScalar())
oid = new OID(oid).append(0).toDottedString();
}
return oid;
}
```
Возможно, это особенности конкретного MIB-файла, с которым мне было необходимо работать, но по каким-то причинам для скалярных параметров возвращался OID без нуля на конце, поэтому в метод получения OID’а был добавлен код, который в случае, если MIB-символ скалярный, просто добавляет к полученному OID «.0» с помощью метода append(int index) из класса net.percederberg.mibble.OID. Если у вас работает и без костыля, поздравляю :)
Для получения остальных данных по символу пишем один вспомогательный метод, где получаем объект net.percederberg.mibble.snmp.SnmpObjectType, содержащий в себе всю необходимую информацию о том MIB-символе, из которого он получен.
```
private SnmpObjectType getSnmpObjectType(MibSymbol symbol) {
if (symbol instanceof MibValueSymbol) {
MibType type = ((MibValueSymbol) symbol).getType();
if (type instanceof SnmpObjectType) {
return (SnmpObjectType) type;
}
}
return null;
}
```
Например, мы можем получить тип MIB-символа:
```
public String getType(String name) {
MibSymbol s = mib.getSymbol(name);
if (getSnmpObjectType(s).getSyntax().getReferenceSymbol() == null)
return getSnmpObjectType(s).getSyntax().getName();
else
return getSnmpObjectType(s).getSyntax().getReferenceSymbol().getName();
}
```
Здесь есть предусмотрено 2 способа получения типа, т.к. для примитивных типов работает первый вариант:
```
getSnmpObjectType(s).getSyntax().getName();
```
а для импортированных – второй:
```
getSnmpObjectType(s).getSyntax().getReferenceSymbol().getName();
```
Можно получить уровень доступа к символу:
```
public String getAccess(String name) {
MibSymbol s = mib.getSymbol(name);
return getSnmpObjectType(s).getAccess().toString();
}
```
Минимальное допустимое значение числового параметра:
```
public Integer getDigitMinValue(String name) {
MibSymbol s = mib.getSymbol(name);
String syntax = getSnmpObjectType(s).getSyntax().toString();
if (syntax.contains("STRING"))
return null;
Pattern p = Pattern.compile("(-?\\d+)..(-?\\d+)");
Matcher m = p.matcher(syntax);
if (m.find()) {
return Integer.parseInt(m.group(1));
}
return null;
}
```
Максимальное допустимое значение числового параметра:
```
public Integer getDigitMaxValue(String name) {
MibSymbol s = mib.getSymbol(name);
String syntax = getSnmpObjectType(s).getSyntax().toString();
if (syntax.contains("STRING"))
return null;
Pattern p = Pattern.compile("(-?\\d+)..(-?\\d+)");
Matcher m = p.matcher(syntax);
if (m.find()) {
return Integer.parseInt(m.group(2));
}
return null;
}
```
Минимальную допустимую длину строки (зависит от типа строки):
```
public Integer getStringMinLength(String name) {
MibSymbol s = this.mib.getSymbol(name);
String syntax = this.getSnmpObjectType(s).getSyntax().toString();
Pattern p = Pattern.compile("(-?\\d+)..(-?\\d+)");
Matcher m = p.matcher(syntax);
return syntax.contains("STRING") && m.find()?Integer.valueOf(Integer.parseInt(m.group(1))):null;
}
```
Максимальную допустимую длину строки (зависит от типа строки):
```
public Integer getStringMaxLength(String name) {
MibSymbol s = mib.getSymbol(name);
String syntax = getSnmpObjectType(s).getSyntax().toString();
Pattern p = Pattern.compile("(-?\\d+)..(-?\\d+)");
Matcher m = p.matcher(syntax);
if (syntax.contains("STRING") && m.find()) {
return Integer.parseInt(m.group(2));
}
return null;
}
```
Также можно получить имена всех колонок в таблице по её имени:
```
public ArrayList getTableColumnNames(String tableName) {
ArrayList mibSymbolNamesList = new ArrayList<>();
MibValueSymbol table = (MibValueSymbol) mib.findSymbol(tableName, true);
if (table.isTable() && table.getChild(0).isTableRow()) {
MibValueSymbol[] symbols = table.getChild(0).getChildren();
for (MibValueSymbol mvs : symbols) {
mibSymbolNamesList.add(mvs.getName());
}
}
return mibSymbolNamesList;
}
```
Сначала стандартным образом получаем MIB-символ по имени:
```
MibValueSymbol table = (MibValueSymbol) mib.findSymbol(tableName, true);
```
Затем проверяем, является ли он таблицей и что дочерний MIB-символ – строка этой таблицы и, если условие возвращает true, в цикле идём по дочерним элементам табличной строки и добавляем имя элемента в результирующий массив:
```
if (table.isTable() && table.getChild(0).isTableRow()) {
MibValueSymbol[] symbols = table.getChild(0).getChildren();
for (MibValueSymbol mvs : symbols) {
mibSymbolNamesList.add(mvs.getName());
}
}
```
Итоги
-----
Этих методов хватает для получения любой информации из MIB-файла по каждому конкретному символу, зная только его имя. Например, при написании SNMP-клиента можно включить в него такой парсер, чтобы методы клиента на вход принимали не OID’ы, а имена MIB-символов. Это повысит надёжность кода, т.к. опечатка в OID’е может привести не к тому символу, к которому мы хотим обратиться. А нет OID’ов – нет и проблем.
В плюс идёт читаемость кода, а значит и его поддерживаемость. Проще вникнуть в суть проекта, если код оперирует человеческими названиями.
Ещё одно применение – это автоматизации тестирования. В тестовых данных можно получать граничные значения числовых параметров динамически из MIB-файла. Так, если изменятся граничные значения у каких-то MIB-символов в новой версии тестируемого компонента, не придётся менять код автотестов.
В целом, при помощи парсера работать с MIB-файлами становится намного приятнее, и они перестают быть такой уж болью. | https://habr.com/ru/post/427267/ | null | ru | null |
# Сжатие указателей в Java
В статье речь пойдет о реализации сжатия указателей в **Java Virtual Machine 64-bit**, которое контролируется опцией **UseCompressedOops** и включено по-умолчанию для 64 битных систем начиная с Java SE 6u23.
Описание проблемы
=================
В 64 битной JVM указатели занимают в 2 раза больше (сюрприз-сюрприз) места в памяти чем в 32 битной. Это может увеличивать размер данных в 1,5 раза по сравнению с аналогичным кодом для 32 битной архитектуры. При этом в 32 битной архитектуре можно адресовать только 2^32 байт (4 ГБ), что довольно мало в современном мире.
Давайте напишем небольшую программу и посмотрим на то, сколько байт занимают объекты Integer:
```
import java.util.stream.IntStream;
import java.util.stream.Stream;
class HeapTest {
public static void main(String ... args) throws Exception {
Integer[] x = IntStream.range(0, 1_000_000).boxed().toArray(Integer[]::new);
Thread.sleep(6000000);
Stream.of(x).forEach(System.out::println);
}
}
```
Здесь мы выделяем миллион объектов класса Integer и надолго засыпаем. Последняя строка нужна для того, чтобы компилятор вдруг не проигнорировал создание массива (хотя на моей машине без этой строки объекты создаются нормально).
Компилируем и запускаем программу с отключенным сжатием указателей:
```
> javac HeapTest.java
> java -XX:-UseCompressedOops HeapTest
```
С помощью утилиты **jcmd** смотрим распределение памяти:
```
> jps
45236 HeapTest
...
> jcmd 45236 GC.class_histogram
```
На картинке видно, что общее количество объектов равно **1000128**, а размер памяти, который занимают эти объекты **24003072 байт**. Т.е. **24** байта на объект (почему именно 24 будет написано ниже).
А вот память той же программы, но с включенным флагом **UseCompressedOops**:
Теперь каждый объект занимает **16 байт**.
Плюсы сжатия очевидны =)
Решение
=======
Как же JVM сжимает указатели? Эта техника называется **Compressed Oops**. Oop расшифровывается как *ordinary object pointer* или *обычный указатель на объект*.
Трюк состоит в том, что в 64 битной системе данные в памяти выровнены по машинному слову, т.е. по 8 байт. И адрес всегда имеет три нулевых бита в конце.
Если при сохранении указателя сдвигать адрес на 3 бита вправо (операция называется **encode**), а перед использованием сдвигать на 3 бита влево (соответственно **decode**), то можно уместить в 32-х битах указатели размером в **35 бит**, т.е. адресовать до **32 ГБ** (2^35 байт).
Если размер кучи для вашей программы больше 32GB, то сжатие перестает работать и все указатели становятся размеров в 8 байт.
Когда опция **UseCompressedOops** включена, то сжимаются следующие типы указателей:
* Поле класса для каждого объекта
* Объекты поля класса
* Элементы массива объектов.
Объекты самой JVM никогда не сжимаются. При этом сжатие происходит на уровне виртуальной машины, а не байт-кода.
Подробнее про размещение объектов в памяти
==========================================
А теперь давайте с помощью утилиты [jol (Java Object Layout)](http://openjdk.java.net/projects/code-tools/jol/) посмотрим внимательнее на то, сколько памяти занимает наш Integer в разных JVM :
```
> java -jar jol-cli-0.9-full.jar estimates java.lang.Integer
***** 32-bit VM: **********************************************************
java.lang.Integer object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 8 (object header) N/A
8 4 int Integer.value N/A
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
***** 64-bit VM: **********************************************************
java.lang.Integer object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 16 (object header) N/A
16 4 int Integer.value N/A
20 4 (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
***** 64-bit VM, compressed references enabled: ***************************
java.lang.Integer object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 12 (object header) N/A
12 4 int Integer.value N/A
Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total
***** 64-bit VM, compressed references enabled, 16-byte align: ************
java.lang.Integer object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 12 (object header) N/A
12 4 int Integer.value N/A
Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total
```
Разница между "64-bit VM" и "64-bit VM, compressed references enabled" состоит в уменьшении **object header** (заголовок) на 4 байта. Плюс, в случае без сжатия, появляется необходимость добавить еще 4 байта для [выравнивания данных](https://ru.wikipedia.org/wiki/%D0%92%D1%8B%D1%80%D0%B0%D0%B2%D0%BD%D0%B8%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85) в памяти.
Что такое этот object header? Почему он уменьшился на 4 байта?
На картинке изображен object header, равный 12 байтам, т.е. с включенной опцией UseCompressedOops. Заголовок состоит из некоторых внутренних флагов JVM, а так же указателя на класс данного объекта. Видно, что указатель на класс занимает 32 бита. Без сжатия он занимал бы 64 бита и размер object header был бы уже 16 байт.
Кстати, можно заметить, что есть еще вариант для 16-байтового выравнивания. В таком случае можно увеличить память до 64 ГБ.
Минусы сжатия указателей
========================
У сжатия указателей, конечно же есть очевидный минус — расходы на операции **encode** и **decode** при каждом обращении к указателю. Точные цифры будут зависеть от конкретного приложения.
К примеру вот график пауз сборщика мусора для сжатых и не сжатых указателей, взятый отсюда [Java GC in Numbers — Compressed OOPs](http://blog.ragozin.info/2013/07/java-gc-in-numbers-compressed-oops.html)
Видно, что при включенном сжатии, GC паузы длятся дольше. Более подробно об этом можно почитать в самой статье (статья довольно старая — 2013 года).
Ссылки:
[Compressed oops in the Hotspot JVM](https://wiki.openjdk.java.net/display/HotSpot/CompressedOops)
[How does JVM allocate objects](https://umumble.com/blogs/java/how-does-jvm-allocate-objects%3F/)
[CompressedOops: Introduction to compressed references in Java](https://www.javacodegeeks.com/2016/05/compressedoops-introduction-compressed-references-java.html)
[Trick behind JVM's compressed Oops](https://stackoverflow.com/questions/25120546/trick-behind-jvms-compressed-oops)
[Java HotSpot Virtual Machine Performance Enhancements](https://docs.oracle.com/javase/7/docs/technotes/guides/vm/performance-enhancements-7.html) | https://habr.com/ru/post/440166/ | null | ru | null |
# Атаки на трасты между доменами
Рано или поздно в ходе пентеста встает задача компрометации всего леса — при условии, что есть какие-либо права в одном из доменов. В такие моменты возникает куча вопросов о трастах, их свойствах и самих атаках. Попробуем во всем этом разобраться.
Доверие между доменами используется для прохождения аутентификации пользователей одного домена на контроллере другого домена. Иначе говоря, чтобы пользователи с домена А могли иметь доступ к ресурсам домена Б. Доменная структура может быть двух видов:
* деревья доменов;
* леса доменов.
При создании дерева доменов между доменами по умолчанию устанавливаются транзитивные доверительные отношения. Все компьютеры имеют общие:
* глобальный каталог;
* пространство имен;
* схему.
Деревья доменов могут объединяться в леса. При создании леса доменов устанавливаются транзитивные доверительные отношения, и все компьютеры в лесу имеют общие:
* глобальный каталог;
* схему.
Ниже представлена таблица с типами доверия между доменами и их свойствами.
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| № | Trust Type | Transitivity | Direction | Authentication Mechanism | Description |
| 1 | External | Non-transitive | One-way or two-way | NTLM Only | Устанавливаются между доменами, принадлежащими к разным лесам, либо c доменом Windows NT 4.0. |
| 2 | Realm | Transitive or non-transitive | One-way or two-way | Kerberos Only | Устанавливаются между Windows и не Windows доменами, использующими протокол Kerberos. Данный тип доверительных отношений может использоваться для обеспечения сквозной аутентификации на Windows и UNIX-системах. |
| 3 | Forest | Transitive | One-way or two-way | Kerberos or NTLM | Устанавливаются между лесами. При этом администраторы сами решают, какими будут отношения — двусторонними или односторонними. |
| 4 | Shortcut | Transitive | One-way or two-way | Kerberos or NTLM | Устанавливаются между доменами различных деревьев, принадлежащих к одному лесу. Используются для уменьшения пути доверия, тем самым повышая эффективность взаимодействия между двумя доменами. |
| 5 | Parent-Child | Transitive | Two-way | Kerberos or NTLM | Устанавливаются автоматически при создании в дереве нового домена. В рамках дерева доменов отношения описываются схемой Parent-Child. |
| 6 | Tree-Root Trust | Transitive | Two-way | Kerberos or NTLM | Устанавливаются автоматически при создании в существующем лесе нового дерева доменов. Фактически доверительные отношения устанавливаются между корневым доменом леса и создаваемым доменом, который будет являться корневым для нового дерева. |
Более наглядно типы доверий между доменами проиллюстрированы на картинке ниже.
#### Транзитивность (Transitivity)
Транзитивность нужна для определения доверия за пределами двух доменов, между которыми оно было сформировано, и используется для расширения отношений доверия с другими доменами. Если мы добавляем к домену дочерний домен, между родительским и дочерним доменами устанавливаются двусторонние доверительные отношения. Эти отношения транзитивны, т.е. если домен A доверяет домену D и домен D доверяет домену E, то домен A доверяет и домену E.
Нетранзитивное доверие можно использовать для отказа доверия с другими доменами.
#### Направление (Direction)
Путь доверительных отношений — это ряд доверительных отношений между доменами, к которому должны поступать запросы на проверку подлинности. Иными словами, прежде чем аутентифицировать пользователя, определяется доверие между доменами. Чтобы пользователи домена A могли получить доступ к ресурсам домена D, домен D должен доверять домену A.
Направление доверия бывает двух типов:
* одностороннее;
* двустороннее.
Одностороннее доверие — это однонаправленный путь проверки подлинности, который создается между двумя доменами. В однонаправленном доверии между доменом A и доменом B пользователи в домене B имеют доступ к ресурсам в домене A. Однако пользователи в домене A не имеют доступа к ресурсам в домене B. Такой тип доверия не транзитивен.
Двустороннее доверие — это комбинация двух однонаправленных доверительных отношений. В двунаправленном доверии между доменами A и B их пользователи имеют доступ к ресурсам обоих доменов. Такой тип доверия транзитивен.
Направление доверия всегда противоположно направлению доступа. Показательная схема от Microsoft ниже:
Ссылки для более глубокого ознакомления с типами доверий:
* [External Trust](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc732859%28v%3dws.10%29)
* [Realm](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc731297%28v%3dws.10%29)
* [Forest](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc771397%28v%3dws.10%29)
* [Shortcut](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc754538%28v%3dws.10%29)
#### Kerberos между доверенными доменами
Рассмотрим пример. Client пытается получить доступ к Server.
**С 1 по 3 пункты происходят стандартные действия при использовании протокола Kerberos.*** Пароль преобразуется в NTLM-хеш, временная метка шифруется хешем и отправляется на KDC в качестве аутентификатора в запросе TGT-тикета (AS-REQ). Контроллер домена (KDC) проверяет информацию пользователя и создает TGT-тикет.
* TGT-тикет шифруется, подписывается и отправляется пользователю (AS-REP). Только служба Kerberos (KRBTGT) может открыть и прочитать данные из TGT-тикета.
* Пользователь представляет TGT-тикет контроллеру домена при запросе TGS-тикета (TGS-REQ). Контроллер домена открывает TGT-тикет и проверяет контрольную сумму PAC.
Изменения начинаются с пункта 4: появляется inter-realm TGT-тикет, так называемый реферальный тикет, который шифруется/подписывается inter-realm ключом, создаваемым из доверенного пароля. Доверенный пароль задается при установке доверительных отношений и известен обоим контроллерам домена. Используя inter-realm TGT-тикет, пользователь домена 1 может запросить TGS-тикет для доступа к ресурсам домена 2.
#### NTLM между доверенными доменами
1. Клиент отправляет запрос для аутентификации непосредственно на сам ресурс, находящийся в другом домене, к которому он хочет получить доступ.
2. Сервер получает запрос от клиента и посылает ему ответ CHALLENGE\_MESSAGE, в котором содержится случайная последовательность из 8 байт. Она называется Server Challenge.
3. Клиент, получив от сервера последовательность Server Challenge, при помощи своего пароля производит шифрование этой последовательности, а затем посылает серверу ответ, который содержит 24 байта.
4. Сервер отправляет запрос и ответ на контроллер своего домена B.
5. В случае аутентификации между трастами выполняется следующая логика:
* Проверяется Direction Trust Relationships (направление доверительных отношений).
+ На контроллер домена A отправляются учетные данные клиента для прохождения аутентификации.
+ Если доверительных отношений нет, то проверяется Transitivity (транзитивность) с доменом A.
* Проверка Transitivity (транзитивность) между доменами
+ Если транзитивность между доменами есть, то передается запрос аутентификации следующему домену в пути доверия. Этот контроллер домена повторяет процесс, проверяя учетные данные пользователя по своей базе данных учетных записей безопасности.
+ Если транзитивности нет, клиенту возвращается сообщение об отказе в доступе.
6-8. Ответ с решением об аутентификации клиента.
Атаки на трасты между доменами
==============================
Итак, для проведения атаки нам потребуется информация о доверительных отношениях в нашем домене.
#### Перечисление трастов
Существует 3 основных метода для перечисления трастов в домене:
1. через Win32 API;
2. через .NET методы;
3. через LDAP.
***Win32 API***
Перечисление осуществляется с помощью вызова функции [DsEnumerateDomainTrusts](https://docs.microsoft.com/ru-ru/windows/win32/api/dsgetdc/nf-dsgetdc-dsenumeratedomaintrustsa), которая возвращает структуру [DS\_DOMAIN\_TRUSTSA](https://docs.microsoft.com/ru-ru/windows/win32/api/dsgetdc/ns-dsgetdc-ds_domain_trustsa). При использовании данного метода возвращается SID и GUID целевого домена, [флаги](https://msdn.microsoft.com/en-us/library/ms675976(v=vs.85).aspx) и [атрибуты](https://docs.microsoft.com/ru-ru/windows/win32/api/ntsecapi/ns-ntsecapi-trusted_domain_information_ex), характеризующие текущие доверительные отношения в домене.
**Флаги**
| | |
| --- | --- |
| DS\_DOMAIN\_DIRECT\_INBOUND | Enumerate domains that directly trust the domain which has ServerName as a member. |
| DS\_DOMAIN\_DIRECT\_OUTBOUND | Enumerate domains directly trusted by the domain which has ServerName as a member. |
| DS\_DOMAIN\_IN\_FOREST | Enumerate domains that are a member of the same forest which has ServerName as a member. |
| DS\_DOMAIN\_NATIVE\_MODE | Enumerate domains where the primary domain is running in Windows 2000 native mode. |
| DS\_DOMAIN\_PRIMARY | Enumerate domains that are the primary domain of the domain which has ServerName as a member. |
| DS\_DOMAIN\_TREE\_ROOT | Enumerate domains that are at the root of the forest which has ServerName as a member. |
**Атрибуты**
| | |
| --- | --- |
| TRUST\_ATTRIBUTE\_NON\_TRANSITIVE | Disallow transitivity. |
| TRUST\_ATTRIBUTE\_UPLEVEL\_ONLY | The trust link is not valid for client operating systems earlier than Windows 2000. |
| TRUST\_ATTRIBUTE\_FILTER\_SIDS | Quarantine domains. |
| TRUST\_ATTRIBUTE\_FOREST\_TRANSITIVE | The trust link may contain forest trust information. |
| TRUST\_ATTRIBUTE\_CROSS\_ORGANIZATION | This trust is to a domain/forest that is not part of this enterprise. |
| TRUST\_ATTRIBUTE\_TREAT\_AS\_EXTERNAL | Trust is treated as external for trust boundary purposes. |
| TRUST\_ATTRIBUTE\_WITHIN\_FOREST | Trust is internal to this forest. |
[BloodHound](https://github.com/BloodHoundAD/BloodHound) собирает информацию с помощью метода Win32 API.
***.Net***
Используется метод [GetCurrentDomain](https://docs.microsoft.com/en-us/dotnet/api/system.directoryservices.activedirectory.domain.getcurrentdomain?redirectedfrom=MSDN&view=netframework-4.8)из пространства имен [System.DirectoryServices.ActiveDirectory.Domain], который возвращает экземпляр класса [System.DirectoryServices.ActiveDirectory.Domain](https://docs.microsoft.com/en-us/dotnet/api/system.directoryservices.activedirectory.domain?redirectedfrom=MSDN&view=netframework-4.8). В этом классе реализован метод [GetAllTrustRelationships](https://msdn.microsoft.com/en-us/library/system.directoryservices.activedirectory.domain.getalltrustrelationships(v=vs.110).aspx),), который возвращает все доверительные отношения для текущего домена.
```
([System.DirectoryServices.ActiveDirectory.Domain]::GetCurrentDomain()).GetAllTrustRelationships()
```
Использование данного метода реализовано в модуле Get-DomainTrust в [PowerView](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1).
Одним из преимуществ этого метода является его простота. Информацию легко читать и понимать, но ее объем значительно меньше, чем при выполнении перечисления другими методами.
***LDAP***
Информация о доверительных отношениях домена хранится в Active Directory как objectClass класса [trustedDomain](https://docs.microsoft.com/ru-ru/windows/win32/adschema/c-trusteddomain).
Пример использования:
```
dsquery * -filter "(objectClass=trustedDomain)" -attr *
```
[PowerView](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1) по умолчанию использует данный метод.
Имея информацию о доменах и типах доверия, можно переходить непосредственно к самой атаке. Рассмотрим 2 варианта:
1. Нам удалось скомпрометировать домен, и мы имеем права администратора домена.
2. У нас нет прав администратора домена.
С правами администратора одного из доменов
------------------------------------------
В зависимости от домена, который был скомпрометирован, можно выделить несколько векторов атак:
| | | | | |
| --- | --- | --- | --- | --- |
| № | Стартовый домен. Позиция атакующего | Атакуемый домен | Техника атаки | Доверительные отношения |
| 1 | Root | Child | Golden Ticket + Enterprise Admin Group | Inter-realm (2-way) |
| 2 | Child | Child | Эксплуатация SID History | Inter-realm Parent-Child (2-way) |
| 3 | Child | Root | Эксплуатация SID History
Эксплуатация билетов доверия | Inter-realm Tree-Root(2-way) |
| 4 | Forest 1 | Forest 2 | Printer Bug | Inter-realm Forest or External trust (2-way) |
Стоит отметить, что для успешной реализации всех векторов необходимо двустороннее доверие между доменами.
#### *1. Эксплуатация SID History*
[SID History](https://docs.microsoft.com/en-us/windows/win32/adschema/a-sidhistory) был введен для облегчения миграции пользователей из одного домена в другой. Атрибут cодержит в себе предыдущие SID объекты. Каждый раз, когда объект перемещается из одного домена в другой, создается новый SID, который становится objectSID. Предыдущий SID добавляется в свойство sIDHistory.
В каждом лесу есть группа пользователей Enterprise Admins, которая существует только в root-домене и имеет права локального администратора на контроллерах домена всех Child-доменов леса. Впервые данная атака был продемонстрирована [Sean Metcalf](https://twitter.com/PyroTek3) на [BlackHat USA 2015](https://www.blackhat.com/docs/us-15/materials/us-15-Metcalf-Red-Vs-Blue-Modern-Active-Directory-Attacks-Detection-And-Protection.pdf). Суть атаки в том, что мы выпускаем Golden-тикет с добавлением дополнительного SID группы Enterprise Admins. Это выполняется путем добавления ExtraSids в структуре [KERB\_SID\_AND\_ATTRIBUTES](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-pac/69e86ccc-85e3-41b9-b514-7d969cd0ed73), которая отправляется в структуре [KERB\_VALIDATION\_INFO](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-pac/69e86ccc-85e3-41b9-b514-7d969cd0ed73).
Демонстрация атаки:
В [impacket](https://github.com/SecureAuthCorp/impacket) есть [скрипт](https://github.com/SecureAuthCorp/impacket/blob/master/examples/raiseChild.py), который все это автоматизирует.
#### *2. Golden Ticket + Enterprise Admin Group*
Имея права администратора в Root-домене, мы можем создать Golden Ticket с добавлением пользователя в группу Enterprise Admins (519).
```
Kerberos::golden /domain: /sid: /krbtgt: /user: /groups:500,501,513,512,520,518,519 /ptt
```
Как было написано выше, Enterprise Admin имеет права локального администратора на DC Child-доменов. Таким образом нам удастся скомпрометировать в лесу все Child-домены.
#### *3. Эксплуатация билетов доверия*
Для доступа к какому-либо ресурсу по протоколу Kerberos, необходим TGS-тикет, который шифруется NTLM-хешем пароля сервисной учетной записи. Контроллер домена хранит хеши паролей пользователей только своего домена, поэтому, когда пользователю из домена А нужен доступ к ресурсу в домене Б, используется inter-realm key. Данный ключ создается на основе доверенного пароля, который устанавливается при создании доверительных отношений между доменами в одном лесу. В базе паролей (NTDS.dit) на контроллере домена можно найти пользователей со знаком $ на конце. Их пароль и используется для создания inter-realm ключей. Для создания inter-realm TGT-тикета нам необходим хеш пароля этой учетной записи.
```
Kerberos::golden /user: /domain: /sid: /sids: /aes256: /service:krbtgt /target: /ptt
```
Демонстрация атаки:
Атака особенно актуальна, когда служба ИБ заметила угрозу и сменила пароль krbtgt 2 раза. В этом случае мы сможем создавать golden-тикеты, используя доверенный пароль между доменами.
#### *4. Printer Bug*
В Windows Print System Remote Protocol (MS-RPRN) есть метод RpcRemoteFindFirstPrinterChangeNotification(Ex), включенный по умолчанию, который позволяет принудительно выполнить аутентификацию на любом компьютере с запущенной службой Spooler на указанном хосте по протоколу Kerberos либо NTLM. В случае c NTLM мы можем выполнить NTLM-relay, либо начать брутить пароль компьютера (никогда не сбрутите). В случае с Kerberos необходима скомпрометированная машина с неограниченным делегированием. Тогда мы сможем забрать TGT-тикет и развить атаку.
Демонстрация атаки:
Рисунок ниже демонстрирует этапы, показанные на видео.
У нас нет прав администратора домена
------------------------------------
Немного теории. [Carlos Garsia](https://twitter.com/ciyinet) в своем [докладе](https://www.youtube.com/watch?v=6aV5tZlQ2EQ) привел отличную таблицу, которая иллюстрирует свойства разных типов групп.
Из особенностей стоит учитывать, [что в глобальный каталог группы типа AD Domain Local и AD Global реплицируются без членов групп, а группы типа AD Universal реплицируется вместе с пользователями.](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc759007(v=ws.10))
> Because of the way that groups are enumerated by the Global Catalog, the results of a back-link [i.e. memb search can vary, depending on whether you search the Global Catalog (port 3268) or the domain (port 389), the kind of groups the user belongs to (global groups vs. domain local groups).
В случае, если у нас нет прав администратора домена, выполняем перечисление объектов. Нас интересуют:
1. Пользователи другого домена, которые имеют права локального администратора на машинах в нашем домене.
2. Пользователи из других доменов, состоящие в группах домена пользователя. Группы, содержащие пользователей из другого домена.
3. Foreign ACL Principals.
#### *1. Пользователи другого домена, которые имеют права локального администратора на машинах в нашем домене*
Поиск пользователей из другого домена, являющихся локальными администраторами на хостах в нашем домене в BloodHound:
```
MATCH (c:Computer)
OPTIONAL MATCH p1 = (u1)-[:AdminTo]->(c)
WHERE NOT u1.domain = c.domain
WITH p1,c OPTIONAL MATCH p2 = (u2)-[:MemberOf*1..]->(:Group)-[:AdminTo]->(c)
WHERE NOT u2.domain = c.domain
RETURN p1,p2
```
Команда в [PowerView](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1):
```
Get-NetLocalGroupMember
```
#### *2. Пользователи из других доменов, состоящие в группах домена пользователя. Группы, содержащие пользователей из другого домена*
Как уже говорилось выше, в глобальный каталог реплицируются пользователи, состоящие только в группах типа Universal. Для демонстрации этой особенности выполним запрос групп в глобальном каталоге, содержащих хотя бы одного пользователя и прямой ldap-запрос к контроллеру домена.
```
Get-DomainGroup -Properties name, grouptype, member, DistinguishedName -LDAPFilter '(member=*)' -SearchBase "GC://jet.lab"
```
При выполнении запроса к глобальному каталогу, мы видим только одну группу Universal Group c типом AD Universal из домена one.jet.lab.
Если мы выполним прямой LDAP-запрос к домену one.jet.lab, то увидим другие группы с типом AD Domain local и AD Global.
Это важно учитывать при выполнении перечисления пользователей и групп.
Команды в [PowerView](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1):
```
Get-DomainForeignUser -Domain
Get-DomainForeignGroupMember -Domain
```
#### *3. Foreign ACL Principals*
Дескриптор безопасности ntSecurityDescriptor (https://docs.microsoft.com/en-us/windows/win32/adschema/a-ntsecuritydescriptor) доступен для всех пользователей из доверенных доменов и реплицируется в глобальный каталог. Таким образом мы можем запросить все DACL для всех объектов в доверяющих доменах и отфильтровать пользователей из других доменов.
```
Get-DomainObjectAcl -Domain jet.lab -ResolveGuids | ?{$_.SecurityIdentifier -like ‘SID_Domain*’}
```
Итак, нам удалось выявить пользователя Mike из домена forestc.lab, который имел права на группу Global Group в домене jet.lab.
P.S. Для защиты между лесами используется SID Filtering и Selective Authentication. Атаку между лесами с включенным SID Filtering привел [dirkjan](https://twitter.com/_dirkjan) в совем [блоге](https://dirkjanm.io/active-directory-forest-trusts-part-one-how-does-sid-filtering-work/). Также 9 июля компания Microsoft выпустила [обновление](https://support.microsoft.com/en-us/help/4490425/updates-to-tgt-delegation-across-incoming-trusts-in-windows-server) , которое отключает TGT-делегирование между лесами по умолчанию. Теперь всё, история с неограниченным делегированием и компрометацией одного леса из другого при используемом протоколе Kerberos больше не работает. | https://habr.com/ru/post/466445/ | null | ru | null |
# Скрипт для мониторинга состояния хостов в сети
Я работаю админом и в моей зоне ответственности находится ряд серверов: роутеры, серверы БД, терминальные серверы и т.д. И хочется быть в курсе, если какойто из серверов вдруг пропал из сети — где-то упал линк с удаленной сетью, где-то вдруг произошел хрестоматийный случай с техничкой, шваброй и кабелем, где-то еще какой форс-мажор случился. И при этом не хочется заморачиваться с тяжеловесными системами мониторинга, вроде Zabbix.
Хочу поделиться с обществом своим скриптом для своевременного уведомления о пропавшей связи с серверами. Скрипт написан на Perl и крутится на моем рабочем десктопе в среде Debian GNU/Linux. Скорей всего без лишних приседаний запустится и в другом дистрибутиве линукса.
Итак, скрипт с комментариями:
````
#!/usr/bin/perl
# Подключаем модули:
use strict; # Включаем строгое определение переменных.
use Net::Ping::External qw(ping); # Подключаем модуль для ICMP-пинга
# Конфигурационные переменные:
my $tries = 3; # Количество попыток пинга каждого хоста
my $timeout = 5; # Таймаут пинга
my $interval = 5; # Интервал между проверками
# Хеш-массив с хостами для проверки. Имя для отображения => айпи или хостнейм
my %hosts = (
"HOST-1" => "10.0.0.1",
"HOST-2" => "10.0.0.2"
);
# Далее, собственно, сам скрипт
# Определеяем вспомогательный хеш, в котором будут храниться состояния хостов
my %state = ();
# По умолчанию все хосты живые
while (my ($name, $ip) = each(%hosts)) {
$state{$name} = "UP";
}
# Запускаем бесконечный цикл
while () {
# Массивы для вновь упавших и вновь поднявшихся хостов
my @uphosts = ();
my @downhosts = ();
# Проходим в цикле весь хеш проверяемых хостов
while (my ($name, $ip) = each(%hosts)) {
# Счетчик ответов сбрасываем в ноль
my $cnt = 0;
# Выполняем нужное количество пингов, увеличивая счетчик ответов при удачных пингах
for (my $i = 1; $i <= $tries; $i++) {
if (ping(hostname => $ip, timeout => $timeout)) {
$cnt++;
}
}
# Если хост не ответил ни разу, он предположительно мертв
if ($cnt == 0) {
# Если до этого он был жив, надо уведомить админа о вновь упавшем хосте, добавляем в список
if ($state{$name} eq "UP") {
$state{$name} = "DOWN";
push(@downhosts, $name);
}
# Если хост ответил хоть на один пинг - он жив
} else {
# Снова проверяем предыдущее состояние
if ($state{$name} eq "DOWN") {
$state{$name} = "UP";
push(@uphosts, $name);
}
}
}
# Поверки закончены, проверяем списки и, если есть хосты с изменившимися состояниями,
# уведомляем админа средствами libnotify
if (scalar(@uphosts) > 0) {
my $lst = join(", ", @uphosts);
`notify-send -u normal NetMon "Hosts becomes up: $lst"`;
}
if (scalar(@downhosts) > 0) {
my $lst = join(", ", @downhosts);
`notify-send -u critical NetMon "Hosts becomes down: $lst"`;
}
# Отдыхаем заданный интервал времени
sleep($interval * 60);
};
````
Теперь оговорки по скрипту.
У перла, а конкретно у Net:Ping есть особенность. Если использовать встроенный перловый модуль Net::Ping с типом пинга ICMP, то потребуются привилегии суперпользователя root. Это связано с реализацией ICMP-пинга в этом модуле через RAW-сокеты, которыми имеет право пользоваться только root. Поэтому я использовал в этом скрипте Net::Ping::External, который реализует пинг через внешние вызовы.
Помимо уведомления админа всплывающими нотифами можно дописать, например, запись информации о падениях-поднятиях в текстовый лог (свой или через syslog), можно отправлять сообщения на мыло, в джаббер, смс на телефон и т.д. Полный полет для фантазии.
До кучи, можно дописать проверку на живость сервисов, например веб, почты, фтп, самбы. Но это уже выйдет за рамки простого пинговальщика и будет похоже на тяжеловесные системы мониторинга. | https://habr.com/ru/post/66142/ | null | ru | null |
# Как мы делали Warface для Денди
В октябре 2020 мне написал мой друг Андрей Скочок, работающий в Mail.ru, и предложил сделать для них необычную промоакцию.
Суть в том, что в ноябре для их игры Warface выходило обновление, и Андрею пришла в голову идея разослать различным видеоблогерам картриджи для Денди, которые будут в качестве тизера демонстрировать несколько картинок из вселенной игры, а в конце показывать промокод.
Как обычно, моё повествование и в виде традиционной текстовой статьи, и посредством видео. Кому как больше нравится.
Видео
-----
Статья
------
Сделать всё это нужно было в максимально сжатые сроки, у нас был всего один месяц, так что даже заказывать что-либо из Китая — вообще не вариант. Впрочем, тупо отобразить картинки — не такая уж хитрая задача, тем более рисовать их будут сами дизайнеры Mail.ru, так что я прикинул свои возможности и согласился.
### Аппаратные ограничения
Первым делом мы решили определиться, какой будет бюджет у железа картриджа. Дело в том, что чем проще и дешевле аппаратная начинка, тем более жёсткие рамки будут у художников-дизайнеров. Разработчикам самых первых игр для Famicom было весьма нелегко, тогда в картриджах не было ничего кроме непосредственно памяти с данными игры.
**Небольшое пояснение по терминам**
Давайте сразу определимся, что когда я пишу «Денди», «Famicom» или «NES», я подразумеваю по сути одно и то же. Для тех, кто не в курсе: то, что у нас в России называли «Денди», в Японии называлось «Фамиком», а в Европе и США — NES.
Почти 10 лет назад я писал на Хабре статью "[Игры для NES/Famicom/Денди глазами программиста](https://habr.com/ru/post/229187/)". С тех пор моё понимание архитектуры NES выросло в разы, я сам научился программировать под эту консоль и даже начал на этом зарабатывать. Можете перечитать ту статью, но тут я попробую рассказать основные моменты заново, дополнив всё более низкоуровневыми подробностями.
Многие наверное замечали, что изображение в играх на Famicom состоит из блоков повторяющихся картинок. Они имеют размер 8 на 8 пикселей и называются тайлами.
Видеопроцессор консоли ищет эти изображения в младших восьми килобайтах видеопамяти (адреса $0000-$1FFF), эта область памяти называется «pattern table». Ну и раз размер памяти ограничен, то соответственно и количество используемых тайлов ограничено.
Восемь килобайт — это ровно 512 тайлов, они делятся на две области, по четыре килобайта. Обычно их называют «left pattern table» и «right pattern table», по тому, как они обычно отображаются в отладчике эмулятора.
Для отрисовки фона в каждый момент времени может использоваться только один из этих pattern tabl’ов, на выбор программиста. То есть я могу нарисовать фон либо любой комбинацией из первых 256 тайлов, либо любой комбинацией из вторых 256 тайлов, но никак не могу брать картинки сразу и там, и там. Вторые же 256 тайлов обычно используются для спрайтов. Это можно отчетливо увидеть в отладчике эмулятора. Впрочем, изображение на экране телевизора рисуется построчно, и если очень захотеть, можно переключить используемый pattern table где-то посреди экрана, когда уже нарисовалась верхняя часть, но ещё не нарисовалась нижняя. Но это надо ещё умудриться поймать нужный момент и сделать это без глюков.
Наверное вы спросите меня: а 256 тайлов — это вообще много или мало? Ну смотрите: разрешение изображения на NES — 256 на 240 пикселей. Это 32 тайла в ширину и 30 в высоту, итого 960. Выходит, что из уникальных 256 тайлов можно составить лишь чуть больше четверти изображения на экране. Вот мы и наблюдаем в играх на Денди, что фоновое изображение состоит из повторяющихся кусочков. Но я еще не сказал, где же хранится эта область памяти от $0000 до $1FFFF. А этой памяти вообще нет внутри консоли. Она всегда находится в картридже.
А теперь прибавьте к вышесказанному то, что в самых первых картриджах не было никаких вспомогательных схем и оперативки. Эти pattern tabl’ы хранились на неперезаписываемой памяти. И разработчикам нужно было составить из этих 256 тайлов всю игру. Однако, со временем стало проще, в картриджах начали появляться мапперы.
Маппер — это дополнительная логическая схема в картридже, задача которой — обманывать консоль. Область памяти под pattern table ограничена восемью килобайтами, и это никак не обойти. Но когда видеочип читает данные из этой памяти картриджа, не обязательно всегда отдавать одни и те же значения. Можно увеличить память в картридже и отдавать данные то из одной области, то из другой. Так один и тот же адрес в адресном пространстве видеочипа может вести в разные области памяти картриджа, в зависимости от того, как настроен маппер. Собственно, поэтому он и называется маппером — он маппит одну область памяти на другую. Такие области памяти называют банками. Обычно за один банк принимают минимальный переключаемый объем памяти.
Благодаря этому игры стали выглядеть гораздо более разнообразно. Вот мы играем в первый уровень, и маппер в картридже отдаёт один набор из 256 тайлов. Переходим на другой уровень, игра перенастраивает маппер на другой банк, и по тем же адресам доступны уже другие 256 тайлов.
На всю эту матчасть я сейчас отвлекся лишь для того, чтобы вам стало понятно, насколько важно сразу определиться с тем, какое железо будет стоять в картридже. Если сделаем картридж максимально дешевым, то художникам придется уложить все картинки в 256 тайлов. Ну ладно, в 512 тайлов, можно переключать pattern table между экранами, но это всё равно жесть.
К счастью, мы пришли к тому, что бюджет на картриджи хоть и ограниченный, но всё-таки есть, к тому же я нашел в продаже в Москве максимально дешевое железо. В качестве логики, которая возьмет на себя задачи маппера, я выбрал ПЛИС **EPM3064**. ПЛИС — это программируемая логика, и использовать ее — отличный вариант, когда мы не знаем точно заранее, какой функционал нам понадобится. У нее объем — 64 макроячейки, это очень мало, но для наших задач должно хватить. К тому же она толерантна к 5 вольтам, что избавит нас от необходимости ставить шифтеры и конвертировать напряжения в 3.3 вольта, на которых работают современные микросхемы.
В качестве самой памяти же я нашел микросхемы по 128 килобайт с… вы только не смейтесь, ультрафиолетовым стиранием. Эти микросхемы наверное лежали и ждали меня на складах ещё с восьмидесятых. Но устаревшие компоненты далеко не всегда дешево продаются, а тут прям будто распродажа была. Повезло.
Получается, что у нас нет ни жёсткого ограничения на объём, ни какого-либо лимита на тайлы. Дизайнеров-художников можно в этом плане не напрягать. Однако, все еще остаются ограничения по цветам, а они у Famicom очень суровые.
Всего Famicom может отображать около 50 цветов. Почему около, а не точное количество? Ну, потому что некоторые цвета повторяются или очень похожи.
А ещё некоторые цвета — это чёрный чернее чёрного, и их нельзя использовать, т.к. многие телевизоры воспринимают такой цвет как сигнал вертикальной синхронизации, и изображение начинает прыгать, ведь в NTSC кодировании именно таким пониженным напряжением, ниже напряжения чёрного цвета, отмечаются границы между кадрами.
Но для каждой точки на экране не указывается код конкретного цвета. Как я уже сказал, восемь килобайт — это 512 тайлов размером 8 на 8 пикселей. С помощью простейшей математики вы можете посчитать, что это лишь два бита на пиксель, то есть только четыре цвета.
Сама же последовательность выводимых на экран тайлов хранится в области памяти, которая называется nametable. Она располагается в диапазоне от $2000 до $2FFF, имеет размер в четыре килобайта и делится на четыре части по одному килобайту. Каждая часть отвечает за один экран. Зачем больше одного? Чтобы можно было заранее отрисовать фон за пределами экрана, а потом его просто двигать. Этот процесс можно наглядно отследить в отладчике эмулятора.
Так четыре части nametable составляют собой два экрана в ширину и два в высоту. Где же находится эта память — в консоли или картридже? Ну, очевидно, это оперативная память, ведь фон нужно постоянно видоизменять, и она находится внутри консоли. Однако, в Нинтендо решили сэкономить на компонентах. Вместо четырех килобайт видеопамяти внутри консоли стоят только два, остальные два дублируются с первыми двумя. Такое дублирование памяти называется зеркалированием или миррорингом, когда один блок памяти зеркалирует другой.
Эффект зеркалирования для внешнего наблюдателя выглядит так, будто есть один большой кусок памяти, но на самом деле он состоит из нескольких идентичных доппельгангеров. Когда мы записываем что-либо в любой из таких кусков, изменения сразу же отображаются в других, ведь на самом деле это тот же самый регион памяти, просто доступный сразу по нескольким адресам. Так вот, у нас есть четыре nametabl’а, но внутри консоли память только под два. Какой же из них по каким адресам доступен?
Первый располагается слева сверху и справа сверху, а второй слева снизу и справа снизу?
Или же под углом в 90 градусов?
А эту конфигурацию может менять сам картридж! Для этого в разъеме выделен отдельный контакт. У простейших картриджей эта конфигурация фиксированная, и если в игре экран двигается слева направо, мирроринг обычно вертикальный, а если снизу вверх, то горизонтальный. Посмотрите на скриншот выше — в Марио мирроринг вертикальный, т.к. экран двигается только слева направо. Бывает ещё одноэкранный мирроринг, когда каждый nametable ведёт в одну область памяти, ну а в теории можно получить совсем экзотические комбинации вроде мирроринга крест-накрест или в форме буквы L.
 
Когда начали производить более сложные картриджи, появилась возможность переключать мирроринг на лету, эту функцию взял на себя маппер. Предусмотрена и возможность совсем избавиться от мирроринга, поставив недостающие два килобайта видеопамяти в сам картридж.
Но что-то я опять отвлекся. Что же такое nametable? В нём банально содержатся номера тайлов из pattern tabl’а. По одному байту на тайл, как раз 256 вариантов.
Но тайлов у нас на экране 960, а не 1024, поэтому в конце каждого nametabl’а остаётся 64 байта. Эти 64 байта называют «attribute table». Они в совокупности с цветовыми кодами в тайлах и отвечают за цвет, но номера цветов опять же содержатся не здесь.
Под цветовые палитры есть ещё одна область памяти в видеочипе, размером в 32 байта. Именно тут указываются номера используемых на экране цветов, по одному байту на цвет. 16 байт для фона и 16 байт для спрайтов.
Но каждые из этих 16 байт делятся на четыре палитры по четыре цвета. Четыре цвета — именно такой выбор у нас для каждого тайла, помните? Вот тут и задается какие конкретно четыре цвета используются. А в attribute table указывается, какая из этих четырех палитр в какой области экрана используется. При этом из-за ограничений памяти номер палитры задается не для каждого тайла на экране, а для блоков в два на два тайла, ведь attribute table имеет размер всего в 64 байта, а тайлов на экране 960.
Я прекрасно понимаю, что к текущему моменту почти все из вас окончательно запутались. Давайте все как-то обобщим. Значит, видеочип рисует фоновое изображение так:
* Для каждого кусочка в 8 на 8 пикселей он берет из nametable номер тайла
* По соответствующему этому тайлу адресу из pattern table он берет само изображение тайла
* у этого тайла вместо цвета каждого пикселя указан номер одного из четырех цветов в палитре
* в какой именно палитре из четырех доступных указано в attribute table для каждого блока в 16 на 16 пикселей
И как же мне объяснить все эти нюансы дизайнерам? Я с этим работаю регулярно, и то мне сложно все в голове держать. На самом деле им не нужно знать технические тонкости. Достаточно сказать, что нужно нарисовать картинку размером 256 на 240 пикселей, при этом можно использовать только определённые цвета, но каждый блок в 16 на 16 пикселей может использовать только четыре цвета, и комбинаций таких цветов тоже может быть только четыре.
Правда, и это не все ограничения.
Вот есть четыре палитры по четыре цвета, так вот у них нулевой цвет в каждой палитре должен быть одинаковым. Он считается цветом фона. В случае со спрайтами, кстати, первый цвет вообще игнорируется, т.к. всегда означает прозрачный цвет. И ещё наверное нужно предупредить дизайнеров, что картинка сплющивается до соотношения сторон 4:3, то есть пиксели не квадратные.
Я передал эту информацию и начал работать над аппаратной частью.
### Схема и плата
Проектировать картридж для Фамикома мне не впервой, и по сравнению с другими моими работами тут все достаточно просто. Подключаем микросхемы памяти к соответствующим выводам разъема картриджа, а в качестве маппера добавляем ПЛИС, которая будет управлять старшими адресными линиями. Чтобы можно было управлять маппером, подключаем его еще и параллельно линиям данных процессора. Было решено сразу добавить управление линиями записи, чтобы можно было прошить микросхемы памяти уже прямо в картридже, это будет гораздо удобнее. И на всякий случай я подключил к ПЛИС линию прерываний, вдруг мне понадобится генерировать их из картриджа?
Развести такую плату не особо сложно, компонентов мало. Маппер я поместил на обратную сторону, а спереди разместил память и добавил логотип Warface.
Как я уже говорил, ждать, пока платы изготовят в Китае, времени нет, поэтому в очередной раз было заказано производство в Зеленограде. Я разместил заказ и выдохнул.
### Обработчик изображений
Что же там в этом время у художников… А там все плохо. Андрей прислал мне несколько картинок, спрашивая, подходят ли они.
   
И нет, без дополнительной обработки они никак не подходили. Быстро пришло осознание, что нужна какая-то программа, которая обрабатывала бы рисунки нужным образом и показывала, что получится на выходе.
На самом деле у меня уже были наработки такой программы на C#, ведь я уже работал с изображениями при программировании под NES, но эти наработки были очень сырыми, и это стало отличным поводом довести все до полноценного проекта. Цель такой программы — получать на входе картинки и конвертировать их в понятный для Фамикома формат, вписывая при этом изображения во все технические ограничения, если это необходимо. Для этого каждое изображение, а выводимая на экран картинка может состоять из нескольких исходных изображений, должно пройти целый ряд преобразований.
Первым делом нужно сделать так, чтобы в картинке использовались только те цвета, которые доступны на NES. Напомню, это около пятидесяти цветов. То есть нужно пройтись по каждому пикселю в изображении, посмотреть на его цвет и найти наиболее похожий из палитры доступных на NES цветов. И эта задача только на первый взгляд кажется такой простой. Это если живому человеку показать какой-нибудь цвет, то он скажет, какие цвета на него больше всего похожи. Но как это вычислить автоматически? Должна же быть какая-то математическая формула для вычисления коэффициента схожести двух цветов.
Сначала я подумал, что надо тупо взять RGB модель и вычислить, на сколько отличаются значения яркости красного, яркости зеленого и яркости синего, а потом эти разности сложить. И чем больше полученное число, тем сильнее отличаются цвета. Но это максимально тупо.
Потом я подумал, что надо рассматривать каждый цвет как точку в трехмерном пространстве, координаты которой определяют значения красного, зеленого и синего, а разница между цветами — это соответственно расстояние между точками, которое вычисляется извлечением корня из суммы квадратов. Но это тоже некорректно.
В общем, все придумано до нас, и не надо изобретать велосипед. На википедии есть целая статья посвященная этой задаче: [en.wikipedia.org/wiki/Color\_difference](https://en.wikipedia.org/wiki/Color_difference)
Я ничего не понимаю в этих формулах, но самое главное, что я узнал название алгоритма — «CIEDE2000», а по названию уже легко найти библиотеку с его реализацией. Я воспользовался библиотекой «ColorMine».
```
static Color FindSimilarColor(IEnumerable colors, Color color)
{
Color result = Color.Black;
double minDelta = double.MaxValue;
foreach (var c in colors)
{
var delta = color.GetDelta(c);
if (delta < minDelta)
{
minDelta = delta;
result = c;
}
}
return result;
}
// Change all colors in the images to colors from the NES palette
foreach (var imageNum in imagesOriginal.Keys)
{
Console.WriteLine($"Adjusting colors for file #{imageNum} - {imageFiles[imageNum]}...");
var image = new FastBitmap(imagesOriginal[imageNum].GetBitmap());
imagesRecolored[imageNum] = image;
for (int y = 0; y < image.Height; y++)
{
for (int x = 0; x < image.Width; x++)
{
var color = image.GetPixel(x, y);
var similarColor = nesColors[FindSimilarColor(nesColors, color)];
image.SetPixel(x, y, similarColor);
}
}
}
```
Надо бы это дело немного оптимизировать, но пока оставим так.
Вторым шагом нужно разбить изображение на блоки по 16 на 16 пикселей, составить список цветов для каждого блока и убедиться, что в каждом из них используется только три цвета помимо цвета фона. Фоновый цвет чаще всего проще указать вручную, хотя я добавил и функционал автоматического выбора на основе самого популярного цвета. Если же в блоке больше трех цветов, то, что поделать, картинка пострадает, берем три самых часто встречающихся. Так мы получаем четырехцветную палитру для каждого блока. Но у нас еще может использоваться только четыре палитры на весь экран, помните? Поэтому надо подсчитать, как часто используется каждая из палитр, и на следующем шаге выбрать только четыре.
```
var top4 = new List();
// Calculate palettes if required
if ((new int[] { 0, 1, 2, 3 }).Select(i => paletteEnabled[i] && fixedPalettes[i] == null).Any())
{
// Creating and counting the palettes
Dictionary paletteCounter = new Dictionary();
foreach (var imageNum in imagesOriginal.Keys)
{
Console.WriteLine($"Creating palettes for file #{imageNum} - {imageFiles[imageNum]}...");
var image = imagesRecolored[imageNum];
// For each tile/sprite
for (int tileY = 0; tileY < image.Height / tilePalHeight; tileY++)
{
for (int tileX = 0; tileX < image.Width / tilePalWidth; tileX++)
{
// Create palette using up to three most popular colors
var palette = new Palette(
image, tileX \* tilePalWidth, tileY \* tilePalHeight,
tilePalWidth, tilePalHeight, bgColor.Value);
// Skip tiles with only background color
if (!palette.Any()) continue;
// Do not count predefined palettes
if (fixedPalettes.Where(p => p != null && p.Contains(palette)).Any())
// Считаем количество использования таких палитр
continue;
// Count palette usage
if (!paletteCounter.ContainsKey(palette))
paletteCounter[palette] = 0;
paletteCounter[palette]++;
}
}
}
```
Но на этот раз неразумно будет выбрать тупо четыре самых часто используемых палитры. Может так получиться, что одна палитра включает в себя все цвета другой палитры. Нужно их сгруппировать.
```
// Group palettes
Console.WriteLine($"Calculating final palette list...");
// From most popular to less popular
var sortedKeys = paletteCounter.OrderByDescending(kv => kv.Value).Select(kv => kv.Key).ToArray();
// Some palettes can contain all colors from other palettes, so we need to combine them
foreach (var palette2 in sortedKeys)
foreach (var palette1 in sortedKeys)
{
if ((palette2 != palette1) && (palette2.Count >= palette1.Count) && palette2.Contains(palette1))
{
// Move counter
paletteCounter[palette2] += paletteCounter[palette1];
paletteCounter[palette1] = 0;
}
}
// Remove unsed palettes
paletteCounter = paletteCounter.Where(kv => kv.Value > 0).ToDictionary(kv => kv.Key, kv => kv.Value);
```
Затем берем уже самые часто используемые палитры, но надо проверить, не остались ли в них незанятые цвета. Если остались, то можно попробовать объединить их с менее популярными палитрами, выиграв таким образом дополнительные цвета. Напомню, что на входе может быть несколько изображений, но ограничения по цветам для них общие.
```
// Get 4 most popular palettes
top4 = sortedKeys.Take(4).ToList();
// Use free colors in palettes to store less popular palettes
foreach (var t in top4)
{
if (t.Count < 3)
{
foreach (var p in sortedKeys)
{
var newColors = p.Where(c => !t.Contains(c));
if (p != t && (paletteCounter[t] > 0) && (paletteCounter[p] > 0)
&& (newColors.Count() + t.Count <= 3))
{
var count1 = paletteCounter[t];
var count2 = paletteCounter[p];
paletteCounter[t] = 0;
paletteCounter[p] = 0;
foreach (var c in newColors) t.Add(c);
paletteCounter[t] = count1 + count2;
}
}
}
}
```
Следующим шагом обрабатываем изображение так, чтобы каждый блок в 16 на 16 пикселей соответствовал какой-либо палитре. Напомню, на предыдущих этапах мы могли потерять часть доступных цветов. Тут опять идёт в дело алгоритм для подсчета цветовой разницы. С его помощью проходимся по каждой из выбранных палитр, находим в них максимально похожий цвет для каждого пикселя, но при этом суммируем цветовую разницу. На основе полученной суммы выбираем максимально подходящую палитру. Запоминаем её индекс, он пригодится нам для attribute table, а затем уже заменяем каждый цвет в блоке на максимально похожий из выбранной палитры.
```
// Calculate palette as color indices and save them to files
var bgColorId = FindSimilarColor(nesColors, bgColor.Value);
for (int p = 0; p < palettes.Length; p++)
{
if (paletteEnabled[p] && outPalette.ContainsKey(p))
{
var paletteRaw = new byte[4];
paletteRaw[0] = bgColorId;
for (int c = 1; c <= 3; c++)
{
if (palettes[p] == null)
paletteRaw[c] = 0;
else if (palettes[p][c].HasValue)
paletteRaw[c] = FindSimilarColor(nesColors, palettes[p][c].Value);
}
File.WriteAllBytes(outPalette[p], paletteRaw);
Console.WriteLine($"Palette #{p} saved to {outPalette[p]}");
}
}
```
Не буду вставлять сюда прям весь код, он очень объёмный. Код я уже выложил её на GitHub: [github.com/ClusterM/NesTiler](https://github.com/ClusterM/NesTiler). Программа пока что весьма сырая и плохо документирована, как обычно.
Я пропустил через эту утилиту картинки, которые прислал Андрей, и стало наглядно видно, что в ограничения они совсем не вписываются, хотя после обработки моими алгоритмами изображения оставались различимыми, хоть и с сильными искажениями по цветам.
 
 
Я отправил Андрею эту программу в комплекте с .bat файлом, чтобы он передал её дизайнерам, и они могли сами с легкостью просмотреть на то, что у них получается.
Андронидзе же мне в ответ прислал полный набор абсолютно не адаптированных под железо картинок и сценарии… Стоп. Сценарии?
### Код маппера
Да, внезапно выяснилось, что мне нужно ещё сделать то, чего не было в первоначальном задании, а именно плавно выводить на экран текст. Это тот случай, когда заказчик думает, что добавляет какую-то простую задачу, а на деле она сложнее всего остального, что есть в проекте. Ну ладно. Надо — сделаю. Нужные шрифты у меня уже есть, они используются в меню моего картриджа для вывода названий игр. Всего получается семь вариантов сценария, в каждом четыре уникальных экрана текста и четыре рисунка. Почти все рисунки участвуют сразу в нескольких сценариях.
Помимо этого Андрей спросил, можно ли добавить в нашу программу музыку. Сам я музыку писать не умею и ответил, что смогу добавить её, если мне пришлют готовую мелодию в формате NSF. А написать её можно, например, в программе FamiTracker. Это специальный трекерный редактор музыки для Famicom, и он умеет экспортировать написанную музыку в NSF. Андрей сказал, что поищет музыканта. Я же в это время приступил к написанию кода. Начал я с кода для ПЛИС в картридже.
Программируемая логика позволяет нам реализовать практически любой маппер, для которого у нас в схеме подключены все необходимые выводы. Какой же выбрать маппер, чтобы он подходил для наших нужд? Да зачем вообще ограничивать себя существующими мапперами, если можно разработать свой собственный, заточенный под наши задачи?
Нам же нужно обойти ограничение в 256 тайлов на экран. Pattern table с тайлами хранится в картридже, а изображение отрисовывается построчно. Можно сделать так, чтобы в верхней части экрана использовался один набор тайлов из адресов от $0000 до $1FFF, а при отрисовке нижней части экрана переключаться в картридже на другой банк, чтобы использовались уже другие 256 тайлов. Видеочип будет брать данные по тем же адресам от $0000 до $1FFF, но там уже будут другие рисунки. Точнее нам нужно разбить экран аж на четыре части, ведь 256 тайлов — это только 64 строки. То есть на отрисовку одного экрана с полноценной картинкой нам нужно переключать за кадр четыре банка по четыре килобайта.
16 килобайт на картинку. В своё время столько могла весить целая игра!
Так вот, основная сложность в отслеживании точного момента, когда на экране рисуется нужная строка. Это умеет делать маппер MMC3, генерируя в нужный момент прерывание, но если я буду переключать банки по прерыванию, это чревато небольшими глюками из-за того, что прерывание обрабатывается не мгновенно.
Так почему бы не разработать свой собственный маппер, который будет автоматически на заданной строке переключать банки памяти с тайлами? Прошивку для ПЛИС я как обычно пишу на языке Verilog (у Хабра почему-то нет подсветки для этого языка).
Определим регистр, указывающий, нужно ли переключать банки автоматически. Регистр с номером текущего банка. И регистр с номером текущего блока — от нуля до трех.
```
reg chr_auto_switch = 0;
reg [4:0] chr_bank;
reg [1:0] chr_latch;
```
Когда на выводе A12, то есть на двенадцатом бите адресной шины видеочипа, низкий уровень, то есть видеочип обращается к первым четырем килобайтам памяти, где у нас хранится левый pattern table, мы управляем старшими адресными линиями микросхемы памяти на основе регистров.
```
assign ppu_addr_out[16:10] = !ppu_addr_in[12]
? (
chr_auto_switch
? {chr_bank[4:2], chr_latch[1:0], ppu_addr_in[11:10]} // $0000-$0FFF is autoswitchable
: {chr_bank[4:0], ppu_addr_in[11:10]} // $0000-$0FFF is switchable manually
)
: {5'b11111, ppu_addr_in[11:10]}; // $1000-$1FFF is fixed to the last
```
Если включено автопереключение, то значение старших адресных линий берется из регистра с номером банка, а младших — из регистра с номером блока. Если автопереключение выключено, то используем только регистр с номером банка. Когда же видеочип обращается к правому pattern table, будем на всех линиях выдавать единички, то есть фиксировано последний банк.
Значениями регистров нам нужно ещё как-то управлять. Для этого будем ловить обращения процессора к памяти и реагировать на операцию записи по адресам от $6000 до $7FFF. Это свободные адреса, так что никаких конфликтов не будет.
```
always @ (negedge m2)
begin
if (romsel && !cpu_rw && cpu_a13 && cpu_a14) // write to $6000-$7FFF
begin
chr_auto_switch = cpu_data[7];
chr_bank[4:0] = cpu_data[4:0];
end
end
```
Значения с шины данных в этот момент, то есть записанные по этому адресу данные, копируем в регистры автопереключения и номера банка. Значение же регистра с текущим номером блока будем менять в счетчике строк. Принцип его работы я скопировал из моего же кода маппера MMC5. Он основан на том, что в конце отрисовки каждой строки видеочип делает два пустых обращения к nametable. Зачем он это делает? Это загадка, никто не знает. Но это можно использовать для подсчёта отрисованных срок.
```
// scanline counter, counts dummy PPU reads, detects v-blank automatically
reg [3:0] ppu_rd_hi_time = 0; // counts how long there is no reads from PPU to detect v-blank
reg [1:0] ppu_nt_read_count; // nametable read counter
reg [7:0] scanline = 0; // current scanline
reg new_screen = 0; // stores 1 when v-blank detected ("in frame" flag)
reg new_screen_clear = 0; // flag to clear new_screen flag
// V-blank detector
always @ (negedge m2, negedge ppu_rd)
begin
if (~ppu_rd)
begin
ppu_rd_hi_time = 0;
if (new_screen_clear) new_screen = 0;
end else if (ppu_rd_hi_time < 4'b1111)
begin
// Counting how long there is no PPU reads
ppu_rd_hi_time = ppu_rd_hi_time + 1'b1;
end else begin
// Too long, v-blank detected
new_screen = 1;
end
end
// Scanline counter
always @ (negedge ppu_rd)
begin
if (!new_screen && new_screen_clear) new_screen_clear = 0;
if (new_screen & !new_screen_clear)
begin
scanline = 0;
new_screen_clear = 1;
chr_latch <= 0;
end else if (ppu_addr_in[13:12] == 2'b10)
begin
if (ppu_nt_read_count < 3)
begin
ppu_nt_read_count = ppu_nt_read_count + 1'b1;
end else begin
if (scanline == 64) chr_latch <= 1;
if (scanline == 128) chr_latch <= 2;
if (scanline == 192) chr_latch <= 3;
scanline = scanline + 1'b1;
end
end else begin
ppu_nt_read_count = 0;
end
end
```
На 64й, 128й и 192й строках меняем значение регистра текущего блока. Если обращений к видеопамяти нет в течении долгого времени, обнуляем счетчик строк и сбрасываем номер блока на ноль.
Вроде это всё, что нужно для управления доступом к памяти видеочипа, но нужно ещё управлять и памятью на основной шине, к которой обращается процессор. Это память с кодом нашей программы. Сделаем там аналогично, чтобы верхняя часть памяти была фиксирована на последний банк, а нижняя переключалась через регистр.
```
reg [2:0] prg_bank;
assign prg_addr = cpu_a14
? {3'b111, cpu_a13} // fixed last bank @ $C000-$FFFF
: {prg_bank, cpu_a13}; // selectable @ $8000-$BFFF
```
Чтобы различать запись в регистр видеопамяти и в регистр основной памяти, будем смотреть на нулевую адресную линию. Получается, один регистр будет записываться по четным адресам, а другой по нечетным.
```
always @ (negedge m2)
begin
if (romsel && !cpu_rw && cpu_a13 && cpu_a14) // write to $6000-$7FFF
begin
if (!cpu_a0)
begin // even
prg_bank[2:0] = cpu_data[2:0];
end else begin // odd
chr_auto_switch = cpu_data[7];
chr_bank[4:0] = cpu_data[4:0];
end
end
end
```
### Эмулятор
По мере написания самой программы для NES её надо как-то отлаживать. Я не настолько крутой, чтобы долго писать код на ассемблере, потом долго записывать картридж, и только после этого видеть, что оно не работает. Ну и потом вслепую искать свою ошибку. Конечно же тестировать и отлаживать свой код можно на эмуляторе. Я предпочитаю использовать эмулятор fceux, в нем хороший отладчик. Вот только мы сделали картридж с кастомным железом, и эмулятор о нём не знает.
Не беда, исходный код эмулятора открыт, и можно достаточно легко добавить поддержку нашего маппера, нужно просто описать принцип его работы на языке С. Указываем, на запись в какие адреса нужно реагировать, и как нужно переключать банки памяти. Номер текущей строки на экране доступен в глобальной переменной scanline. Не забываем определить и функцию, которая будет вызываться при отрисовке следующей строки.
```
static uint8 prg_bank = 0;
static uint8 chr_bank = 0;
static void WARFACE_Sync(void) {
setprg16(0x8000, prg_bank);
setprg16(0xC000, ~0);
if (chr_bank & 0x80)
{
if (scanline >= 64)
setchr4(0x0000, (chr_bank & 0x1C) | 0);
else if (scanline >= 128)
setchr4(0x0000, (chr_bank & 0x1C) | 1);
else if (scanline >= 192)
setchr4(0x0000, (chr_bank & 0x1C) | 2);
else
setchr4(0x0000, (chr_bank & 0x1C) | 3);
}
else {
setchr4(0x0000, chr_bank & 0x1F);
}
setchr4(0x1000, ~0);
}
static DECLFW(WARFACE_WRITE) {
if ((A & 1) == 0)
prg_bank = V;
else
chr_bank = V;
WARFACE_Sync();
}
```
### Написание кода для NES
Теперь можно наконец-то начать писать код основной программы. Под Фамиком я как обычно программирую на ассемблере.
Помимо стандартного кода инициализации первым делом я напишу подпрограммы для переключения банков основной памяти и памяти видеочипа. Для последнего нужны два режима — обычный и с автопереключением в картридже. Там мы храним pattern table.
```
; субрутина выбора PRG банка
select_prg_bank:
sta
```
Ещё напишу функцию, которая будет ожидать окончания отрисовки экрана, ведь многие операции мы можем выполнять только тогда, когда видеочип не в процессе вывода изображения. Заодно в этой же функции добавим чтение контроллера, ведь это как раз надо делать каждый кадр.
```
; субрутина простого ожидания vblank
wait_blank_simple:
jsr read_controller
bit $2002
.loop:
lda $2002
bpl .loop
rts
```
Помимо этого нужна подпрограмма для копирования nametable из основной памяти в память видеочипа. Напомню, nametable хранится в оперативной памяти внутри консоли, поэтому данные туда надо записать вручную.
```
; загружаем nametable в $2000
; в A номер банка
; в COPY_SOURCE_ADDR - адрес данных
load_name_table:
tax
lda ACTIVE_BANK
pha
txa
jsr select_prg_bank
lda #$20
sta $2006
lda #$00
sta $2006
ldy #$00
ldx #$04
.loop:
lda [COPY_SOURCE_ADDR], y
sta $2007
iny
bne .loop
inc
```
Компилируем, запускаем в эмуляторе и… работает!
Но что-то немного не так. Банки переключаются не на тех строках. И это очевидно косяк эмуляции, а не самого ROM’а. Конечно же, счетчик строк обновляется в конце строки, а не в начале. Надо это учитывать.
```
static void WARFACE_Sync(void) {
setprg16(0x8000, prg_bank);
setprg16(0xC000, ~0);
if (chr_bank & 0x80)
{
if (scanline < 63 || scanline > 240)
setchr4(0x0000, (chr_bank & 0x1C) | 0);
else if (scanline < 127)
setchr4(0x0000, (chr_bank & 0x1C) | 1);
else if (scanline < 191)
setchr4(0x0000, (chr_bank & 0x1C) | 2);
else
setchr4(0x0000, (chr_bank & 0x1C) | 3);
}
else {
setchr4(0x0000, chr_bank & 0x1F);
}
setchr4(0x1000, ~0);
}
```
Вот теперь всё верно. Мне не нравится только, что картинка появляется сразу. Во всех хороших играх яркость картинки нарастает постепенно. Ну, на сколько это позволяют доступные на NES цвета. Попробую сделать так же.
Нумерация цветов у Фамикома сделана так, что младшие четыре бита означают оттенок, а старшие два — яркость. Но это не точно. Сигнал генерируется аналоговый, и цвета могут варьироваться в зависимости от консоли, телевизора, цветовой системы и прочих факторов. Поэтому в эмуляторах цветовую палитру зачастую можно настроить.
В общем, для затемнения будем просто отнимать от значения цвета шестнадцатеричное число $10, то есть шестнадцать, при этом если значение получается меньше нуля, то заменяем его на код черного цвета. Также, стоит не забывать про запретные цвета. Как я уже говорил, можно получить значение чернее черного, от которого телевизоры будут сбоить. Так что на это тоже стоит сделать проверку.
```
; затемняет загруженную палитру
dim:
ldx #0
.loop:
lda PALETTE_CACHE, x
sec
sbc #$10
bpl .not_minus
lda #$1D
.not_minus:
cmp #$0D
bne .not_very_black
lda #$1D
.not_very_black:
sta PALETTE_CACHE, x
inx
cpx #16
bne .loop
rts
```
Выполнять операцию затемнения будем в цикле, для каждого цвета в палитре. Только делать это надо во временном буфере, куда будем загружать оригинальные данные палитры, и откуда уже после затемнения будем их выгружать в память видеочипа.
Сам процесс затемнения весьма прямолинеен. Собственно, один раз загружаем данные во временный буфер и несколько раз вызываем подпрограмму затемнения с подпрограммой переноса результата в видеопамять, делая между этим паузы в несколько кадров. Ну и потом уже просто заполняем всё чёрным цветом.
```
; плавно затухает экран
dim_out:
jsr preload_palette
jsr dim
jsr load_palette
ldx #5
jsr wait_blank_x
jsr dim
jsr load_palette
ldx #5
jsr wait_blank_x
jsr dim
jsr load_palette
ldx #5
jsr wait_blank_x
jsr load_black
jsr wait_blank
rts
```
А вот когда надо наоборот постепенно проявить картинку, всё несколько сложнее. Сначала показываем чёрный цвет. Затем загружаем палитру во временную память. После этого три раза затемняем её и загружаем результат в видеопамять. Делаем паузу в несколько кадров и повторяем весь процесс, затемняя уже два раза. Потом так же, затемняя один раз и в конце концов уже без затемнения.
```
; плавно проявляет экран
dim_in:
jsr preload_palette
jsr dim
jsr dim
jsr load_palette
ldx #5
jsr wait_blank_x
jsr preload_palette
jsr dim
jsr load_palette
ldx #5
jsr wait_blank_x
jsr preload_palette
jsr load_palette
jsr wait_blank
rts
```
Напомню, между отображением картинок надо сделать, чтобы выводился текст. Точнее Андрей хотел, чтобы текст шел поверх картинок, но NES такое не осилит. И картинка, и текст являются фоном, а на этой консоли доступен только один фон. Можно было бы вывести текст спрайтами, но спрайтов в каждой строке может быть только восемь. Кстати, в титрах американской версии Super Mario Bros. 2 так и сделали, поэтому имена всех монстров не длиннее восьми букв, хех.
Я решил сделать по классике, текст на чёрном фоне. Вот только в моем шрифте номера тайлов с буквами не совпадают с номерами букв в стандартных кодировках, поэтому надо написать простенькую программу-конвертер из текста в специальный бинарный файл, который уже можно будет подключить в ассемблере.
Выводим постепенно текст по одному символу, ничего особенного. Но надо ещё учитывать, не встретили ли мы символ перехода на следующую строку. Если встретили, обнуляем положение воображаемого курсора и увеличиваем счетчик строк.
Ассемблерный код слишком длинный, чтобы вставлять его в статью. Давайте я просто оставлю ниже ссылку на GitHub.
Но весь текст может не помещаться на одном экране. Поэтому ближе к концу экрана надо запускать процесс плавной прокрутки, а после тридцатой строки нужно писать уже во второй nametable. Мирроринг у нас всегда горизонтальный. В отладчике эмулятора наглядно видно, как это происходит в видеопамяти.
Я решил немного заморочиться. Я же уже написал функцию, которая делает затемнение. Почему бы не сделать так, чтобы буквы проявлялись постепенно? Да, мы не можем менять палитру отдельно для одного тайла, но почему бы сначала не отображать букву спрайтом, для которого задаётся отдельная палитра? Больше восьми спрайтов на строку быть не может, но он будет только один — на момент проявления буквы. То есть пока буква проявляется, это спрайт, а затем спрайт исчезает и заменяется уже обычным тайлом с буквой. Для зрителя это выглядит как постепенно проявляющийся текст. Правда, буквы печатаются слишком быстро, чтобы это прям заметить, но с таким эффектом всё-таки смотрится немного лучше.
### Музыка
Вскоре со мной связался музыкант, которого Андронидзе подключил к этому проекту. И для меня стало приятным сюрпризом, что это аж сам Manwe из демогруппы SandS. Он же Александр Мачуговский. Это достаточно известный демосценер, музыкант и просто классный мужик.
Я объяснил ему, что мне надо получить музыку в формате NSF и рассказал, какие инструменты можно для этого использовать. Велосипед изобретать не надо, уже существует несколько хороших трекерных редакторов, чтобы писать музыку под Famicom. Трекерные редакторы — это как раз то, с чем работают демосценеры, когда им нужно уложить полноценную музыкальную композицию в очень маленький объём данных. А нам будет доступно для музыки только 32 килобайта памяти, так как подружить музыку с переключением банков будет весьма проблемно. Семплы же вообще нужно уложить в 16 килобайт, т.к. процессор Фамикома может читать их только из старших 16 килобайт памяти. Это аппаратное ограничение.
В итоге Manwe прислал мне музыку в виде NSF файла. И тут надо рассказать, что такое NSF файл. Понятное дело, что это такой контейнер с музыкой из игры для NES. Но что он из себя представляет? На самом деле в этом файле содержится непосредственно программный код для консоли. И проигрыватели NSF файлов по сути являются эмуляторами. Помимо кода там есть ещё заголовок размером в 128 байт.
В нём нас в первую очередь интересуют три адреса: $008, $00A и $00C Это адрес, по которому мы должны разместить код из файла, адрес функции, которую нужно вызвать для инициализации, и адрес функции которую мы должны вызывать каждый кадр для воспроизведения музыки.
В Makefile я написал вот такую вот длинную строчку, чтобы путём использования утилит dd и hexdump вытащить из бинарного NSF файла эти адреса и сохранить их в виде ассемблерного файла с константами.
```
$(MUSIC_ASM): $(MUSIC)
printf \
"NSF_LOAD_ADDR .equ `hexdump $(MUSIC) --skip 8 --length 2 \
--format '"$$%X"'`\nNSF_INIT_ADDR .equ `hexdump $(MUSIC) --skip 10 --length 2 \
--format '"$$%X"'`\nNSF_PLAY_ADDR .equ `hexdump $(MUSIC) --skip 12 --length 2 \
--format '"$$%X"'`" > music.asm
```
Непосредственно код воспроизведения музыки можно вытащить через тот же dd. Теперь подключаем его, указав имя константы в качестве адреса, добавляем вызов кода инициализации и делаем так, чтобы функция воспроизведения вызывалась каждый кадр.
```
.org NSF_LOAD_ADDR
music:
.incbin music_bin ; Код музыки
```
```
; инициализация музыки
init_music:
lda ACTIVE_BANK
pha
lda #BANK(music)/2
jsr select_prg_bank
; номер трека
lda #0
; в регистре X задаётся регион: PAL или NTSC
ldx #0
; инициализируем музыкальный проигрыватель
jsr NSF_INIT_ADDR
pla
jsr select_prg_bank
rts
```
У нас же уже есть код, который вызывается для ожидания окончания отрисовки экрана и который вызывается каждый кадр. Добавим работу с музыкой непосредственно перед ожиданием конца кадра, чтобы функция музыки вызывалась, пока видеочип занят выводом изображения, и процессор ничем не занят.
```
; вызываем код музыки из предпоследнего банка
; заодно это делает ack прерыванию
lda #BANK(music)/2
sta $6000
; играем музыку
jsr NSF_PLAY_ADDR
```
И вуаля! Музыка играет, но… Явно фальшивит. Очевидно, это из-за того, что функция воспроизведения вызывается не с равным интервалом. В какие-то моменты процессор освобождается раньше, в какие-то позже. Ну хорошо, тогда будем вызывать музыкальную функцию точно в момент, когда мы дождались окончания отрисовки изображения. Можно даже делать это в специальном прерывании, которое срабатывает именно в этот момент. И музыка стала воспроизводиться нормально, но появились визуальные артефакты.
Очевидно, это происходит по той причине, что из-за слишком долгой работы с музыкальным кодом процедура загрузки данных в nametable стала выполняться слишком поздно, не успевая завершиться до начала отрисовки нового кадра. Что же делать… Как заставить этот кусок кода выполняться с точным интервалом во время вывода изображения, когда не надо выполнять другой код? В Фамикоме нет никаких таймеров или иных способов отсчитывать время. Я не знаю точно, как решали эту проблему разработчики игр. По идее можно использовать так называемый sprite-0 hit. Но раз уж я могу программно модифицировать маппер в картридже, почему бы не добавить таймер в сам картридж?
Я сделал так, чтобы старший бит в регистре программных банков запускал таймер, счетчик которого будет уменьшаться при каждом такте процессора, а при достижении нуля пусть картридж дергает линию генерации прерываний. Хватит счетчика размером в 14 бит, это 4095 тактов.
```
reg [13:0] timer = 0;
reg timer_elapsed = 0;
assign irq = timer_elapsed ? 1'b0 : 1'bZ;
always @ (negedge m2)
begin
if (timer != 0)
begin
timer = timer - 1'b1;
if (timer == 0) timer_elapsed = 1;
end
if (romsel && !cpu_rw && cpu_a13 && cpu_a14) // write to $6000-$7FFF
begin
if (!cpu_a0)
begin // even
prg_bank[2:0] = cpu_data[2:0];
if (cpu_data[7]) timer = 4095;
timer_elapsed = 0;
end else begin // odd
chr_auto_switch = cpu_data[7];
chr_bank[4:0] = cpu_data[4:0];
end
end
end
```
Будем запускать его строго в момент окончания отрисовки экрана, затем заниматься всеми срочными делами, а через 4095 тактов сработает прерывание, в котором можно будет заниматься музыкой. В этот момент процессор свободен, а прерывание обеспечивает точность. Заодно туда можно перенести и код опроса контроллера.
```
; основное прерывание по таймеру картриджа
IRQ:
php
pha
tya
pha
txa
pha
; вызываем код музыки из предпоследнего банка
; заодно это делает ack прерыванию
lda #BANK(music)/2
sta $6000
; играем музыку
jsr NSF_PLAY_ADDR
; читаем контроллер
lda #BANK(read_controller)/2
sta $6000
jsr read_controller
; возвращаем назад активный банк
lda
```
Не забудем модифицировать и код эмулятора. Это достаточно просто. Нужно определить функцию, которая вызывается каждый такт процессора, сделать счётчик, а при достижении нуля вызывать функцию, которая имитирует срабатывание прерывания.
```
static void WARFACE_CpuCounter(int a) {
while (a--)
{
if (timer > 0)
{
timer--;
if (!timer) X6502_IRQBegin(FCEU_IQEXT);
}
}
}
static void WARFACE_Power(void) {
SetReadHandler(0x8000, 0xFFFF, CartBR);
SetWriteHandler(0x6000, 0x7FFF, WARFACE_WRITE);
GameHBIRQHook = WARFACE_ScanlineCounter;
MapIRQHook = WARFACE_CpuCounter;
WARFACE_Reset();
}
```
Теперь музыка работает прекрасно! Однако, после тестирования ROM’а на эмуляторе Manwe заметил, что не всё так гладко. Дело в том, что привычная нам Денди сильно отличается от тех консолей, которые были во всём цивилизованном мире. По сути NES и Famicom делятся на два региона, их обычно называют по стандартам кодирования видео сигнала — NTSC и PAL.
В Японии и Америке NTSC регион. Да, в Японии был Фамиком, в Америке NES, консоли разные, но платформа и регион одинаковые. Они выдают соответственно NTSC сигнал с частотой 60 кадров в секунду. Игры для японского Фамикома и американской NES тоже по пути вполне совместимы между собой, и отличаются только совместимостью с дополнительными аксессуарами, языком и собственно разъёмом картриджа. Иногда это вообще абсолютно одинаковые ROM’ы, и в первых картриджах для NES можно было встретить тупо пассивный переходник. С помощью аналогичных переходников можно легко переносить игры между этими консолями.
В Европе же тоже была NES, но уже PAL региона. Она отличается не только кодированием видеосигнала и частотой кадров в 50 Гц. Там уже другая частота процессора, другие делители. Даже если соорудить какие-то переходники и обойти защиту от пиратства, многие игры NTSC региона не будут корректно работать на PAL консолях и наоборот. В Европе даже есть свои эксклюзивы, которые недоступны для остального мира, а все это из-за того, что игры для PAL региона заточены под совсем другие частоты.
В основном эмуляторы заточены под эти два региона. И программа для написания музыки, которую использовал Manwe, тоже. Но что же с нашей Денди? Вопреки распространенным заблуждениям Денди не является консолью PAL-региона. Да, у неё PAL сигнал, но на самом деле это чертов гибрид! Всё сделано так, чтобы Денди кодировала видео в PAL, но при этом была совместима с японскими картриджами NTSC региона! У неё свои собственные частоты, и хоть она и выводит сигнал с частотой в 50 Гц, с европейскими эксклюзивами она несовместима. Она заточена под игры NTSC региона, хоть они на ней и тормозят, и выглядят сплющенными. Можно сказать, что пираты создали свой собственный регион.
Часто в эмуляторах его и добавляют отдельно, так и называя — Денди, хоть это лишь название чисто российской торговой марки, в других странах были свои клоны.
Есть даже мнение, что пираты сделали всё как раз по уму в отличии от разработчиков официальных консолей, ведь они не сломали совместимость с японскими играми, хотя их всё равно пришлось бы адаптировать под другую скорость. Но вернёмся к нашей музыке. Что же делать, если на Денди DPCM канал звучит неправильно? Было решено тупо сделать в NSF файле второй трек, уже без DPCM канала. Чтобы определять при запуске тип консоли, и если это Денди, то запускать урезанный вариант мелодии. Определить тип консоли достаточно легко, подсчитав примерное количество тактов процессора за один кадр. И у PAL, и у NTSC, и у Денди это разные значения.
; определяем тип консоли
; отключаем NMI
lda #%00000000
sta PPUCTRL
bit PPUSTATUS
console\_detect\_init:
bit PPUSTATUS
bpl console\_detect\_init
console\_detect\_loop:
inx
bne console\_detect\_s
iny
console\_detect\_s:
bit PPUSTATUS
bpl console\_detect\_loop
lda #$01
cpy #$09
bne console\_detect\_end
lda #$00
console\_detect\_end:
sta
; включаем NMI
lda #%10000000
sta PPUCTRL
Да, на Денди музыка теперь звучит не так насыщенно. Но, увы, лучше уж так, чем с искаженной мелодией.
Когда с музыкой разобрались, Manwe посмотрел на то, что у нас получается с картинками и решил ещё заняться их обработкой, чтобы они не просто вписывались в ограничения консоли, но ещё и оставались при этом красивыми.
 
 
Как он это делал — я не представляю. В видео он сам рассказывает об этом процессе.
Осталось добавить самые мелочи. Андрей просил, чтобы при наборе на геймпаде культового Konami-кода отображались титры. Ничего особо сложного. Наспех набросал картинку в Paint’е и добавил в функцию чтения контроллера проверку на Konami-код.
```
konami_code_check:
ldy
```
### Запуск на реальном железе
Пока мы всем этим занимались, приехали платы и компоненты. Внешне платы получились очень красивыми. Глянцевая черная маска, симметрия и логотип Warface. Красота. Фото есть в самом начале статьи.
Но когда я записал картридж, всё оказалось очень плохо. Музыка опять играет с какой-то плавающей скоростью. И ведь на эмуляторе всё нормально было. Это лишний раз говорит о том, что эмуляторы работают не идеально. У них есть обязательный минимум — это корректная эмуляция существующих игр. Но если создавать что-то свое, достаточно легко наткнуться на такую ситуацию, когда эмулятор работает неточно. Особенно в таких ситуациях, когда в эмуляторе глюков нет, а на реальном железе они проявляются. Мало кому нужно, чтобы эмулятор воспроизводил какие-то дефекты. Это надо, пожалуй, только разработчикам вроде меня.
На самом деле энтузиастами давно уже составлен так называемый Errata список для NES. Это список, который описывает, в каких случаях железо может вести себя некорректно или неочевидно: [www.nesdev.org/wiki/Errata](https://www.nesdev.org/wiki/Errata). И там я нашёл свою ошибку: [www.nesdev.org/wiki/NMI#Race\_condition](https://www.nesdev.org/wiki/NMI#Race_condition). Если ждать завершения отрисовки экрана одновременно и через опрос регистра, и по прерыванию, то возникает состояние гонки, и прерывание срабатывает не всегда. Поэтому музыка и играет с плавающей скоростью, ведь она завязана на это прерывание. И да, для запуска игр эмулировать эту особенность совсем не нужно, вот эмулятор fceux и не учитывает её.
Эта проблема достаточно просто решается, нужно ожидать завершения отрисовки экрана только в одном месте. Буду делать это только по прерыванию и изменять там значение специальной переменной.
```
; прерывание по vblank
NMI:
php
inc
```
Музыка стала звучать прекрасно. Но на телевизоре все картинки почему-то стали зелёными. Вот причину этой проблемы я уже долго не мог понять. И ведь на эмуляторе опять же все в порядке. Я пробовал одновременно открыть рядом эмулятор и захват с реальной консоли. Показывал это Manwe, и мы вместе долго пытались понять причину появления вездесущего зелёного цвета.
В итоге мы поняли, что это банально особенности работы композитного сигнала. Он так устроен, что соседние пиксели влияют друг на друга, а Manwe при работе с картинками активно использовал дизеринг. Дизеринг — это намеренное подмешивание шума, чтобы изображение смотрелось лучше при ограниченном количестве цветов. Увы, от такого искажения цвета никак не избавиться без редактирования самих картинок, такие уж аппаратные особенности композитного сигнала.
Хотя на самом деле в те времена некоторые разработчики умудрялись даже использовать эти артефакты, чтобы сделать игры красивее. Самый известный пример — это полупрозрачный водопад в Сонике на Sega Mega Drive.
И это часто используют как аргумент в холиварах о том, что же лучше — RGB подключение или классический композит. Ведь RGB делает изображение гораздо чётче, но разработчики часто делали игры без расчёта на то, что мы будем видеть их такими. Я думаю, что тут нет какого-то однозначного ответа.
К счастью мы обнаружили, что прямо в эмуляторе fceux есть встроенный фильтр, который имитирует артефакты композитного сигнала.
Причём, хорошо так имитирует, даже есть лёгкое дрожание изображения. Это помогло Manwe доработать картинки так, чтобы они в итоге выглядели хорошо. Местами это даже сыграло нам на руку, например сделав траву более зелёной.
Завершали мы всё буквально в последний день. Я записал 15 картриджей, ещё несколько мы оставили себе на память. Всё это я отправил курьером Андрею, и он их получил прямо в последнюю ночь перед сдачей проекта.
Весьма непростой задачей было ещё найти подходящие консоли. Казалось бы, клоны Фамикома сейчас где только не продают, иногда даже до сих пор под брендом Денди. Но Mail.ru серьёзная компания, и если нелицензированные клоны игровых консолей ещё можно отправить, то вот наличие встроенных игр — это уже распространение пиратского контента. И консоли без встроенных игр найти было непросто, но Андрей как-то с этим справился. Правда, все они конечно же оказались так называемого «Денди»-региона с PAL видеовыходом, и игры на них тормозят, как это было у нас на Денди в девяностые.
Как бы там ни было, я очень доволен результатом. Получилась весьма интересная и необычная промоакция, в создании которой было действительно классно участвовать, и это даже принесло мне определенный опыт.
Исходный код проекта: [github.com/ClusterM/nes-warface](https://github.com/ClusterM/nes-warface)
Исходный код NesTiler: [github.com/ClusterM/NesTiler](https://github.com/ClusterM/NesTiler/)
Моя ветка эмулятора fceux: [github.com/ClusterM/fceux](https://github.com/ClusterM/fceux)
Моя ветка компилятора NES: [github.com/ClusterM/nesasm](https://github.com/ClusterM/nesasm) | https://habr.com/ru/post/657395/ | null | ru | null |
# Взгляд из Google на оптимизацию сайтов
На сайте моей компании я выложил свой перевод [интервью Андре Вейера](http://jamesnorquay.com/an-interview-ex-member-matt-cuttss-search-quality-team/) (Andre Weyher), в прошлом — сотрудника отдела качества поиска в Google, которое он дал австралийскому интернет-маркетологу Джеймсу Норкею (James Norquay). Так как весь текст довольно длинный, здесь я перечислю основные (на мой взгляд, новые) моменты. Если кому-то интересен полный текст перевода — адрес в обсуждении ниже, ~~из скромности~~. Интервью свежее, 16 октября с.г.
Основная мысль интервью — «если вы хотите, чтобы ваш сайт был повыше в результатах поиска, делайте его так, как будто никакого SEO нет. Этого от вас ждет и пользователь, и Google».
Несколько интересных ответов Андрэ, которые мне (и комментаторам оригинального интервью на сайте Джеймса) показались не столь банальными (простите, если вы это уже знаете, вдруг кто-то еще не знает):
1. ключевые слова (анкоры), с которых на ваш сайт идут ссылки, Google делит на коммерческие и некоммерческие;
2. более 2-х коммерческих ключевых слов в теге
```
```
вызывает у Google подозрение на спам;
3. ссылки с «хороших» страниц имеют на порядки больший вес, чем ссылки с «плохих» (это и так ясно, но интересно соотношение — в оригинале 3 хороших лучше 1000 плохих, хотя «1000» может быть фигурой речи);
4. Google не все каталоги считает злом;
5. в Google+ можно сделать профиль *своего сайта* (а я-то думал, что там все больше люди!)
6. и последнее по счету, но не по значению: Андре сотоварищи сделали сайт [netcomber.com](http://netcomber.com), на котором можно искать сайты, принадлежащие одному владельцу (принадлежность определяется по 3000 параметрам). Рекомендуют использовать для поиска кластеров поискового спама, наблюдения за сайтами конкурентов и прочего. Цинично намекая, что «пока бесплатно».
Буду рад, если кто-нибудь поделится ощущениями от использования netcomber.com — мне показалось, что сайты на русском языке он не очень понимает. Я для примера смотрел сайт rbc.ru — так он нашел довольно странные сайты с якобы теми же хозяевами. Впрочем, не исключено, что хозяева на самом деле и правда одни и те же… И еще может быть поможет с поиском копипасты с вашего сайта. | https://habr.com/ru/post/155459/ | null | ru | null |
# Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Практическое применение: управляем яркостью светодиода
#### Вступление
В двух предыдущих статьях мы генерировали при помощи ШИМ тактовый сигнал нужной нам частоты, получая на светодиоде равный промежутки свечения и его отсутствия. Данная задача имеет место быть на практике (в одной из последующих статей мы с ней точно столкнемся). Но чаще всего ШИМ используют по другому назначению. Одно из самых распространенных — управление яркостью светодиодов или скоростью вращения моторов. Так же при помощи ШИМ можно генерировать звук (о чем будет следующая статья). А в данной статье мне хотелось бы рассказать, как на нашем контроллере можно реализовать управление яркостью светодиода.
#### Начнем: изменение настроек основного таймера
За основу мы возьмем проект из [этой статьи](http://habrahabr.ru/post/267051/). На основе функции **initTimerPWMled** создадим функцию **initTimerPWMconstPeriod**. Параметром функции будет уже не PWM\_speed (частота ШИМ-а), а **timeEnabledState** — время действия импульса. О теории генерации напряжения на выводе методом ШИМ прекрасно рассказывает [эта](http://h4e.ru/obshchie-svedeniya/110-shim-shirotno-impulsnaya-modulyatsiya) коротенькая статья. Для начала определимся с параметрами:* Пусть длительность целого периода функции будет 0xFFFF тиков таймера (можно выбрать любое значение, я выбрал это значение для удобства и чтобы не менять код для следующей статьи о генерации звука ШИМ-ом)
* Тогда параметр функции timeEnabledState будет показывать сколько тактов из 0xFFFF на выводе присутствует «1». Все остальное время на канале «0». Например, при timeEnabledState = 0x4000, сигнал будет иметь следующий вид.
При 0x8000 будут почти равны.
Ну а при 0xF000 сигнал «1» будет почти всегда.
Чем меньше по времени период, тем лучше. Мы выбрали период длинной в 0xFFFF тактов. Для достижения хороших результатов, нам нужно, чтобы частота прохождения этих периодов была максимальна. Для этого выключим делитель тактового сигнала в функции initTimerPWMconstPeriod.
```
MDR_TIMER1->PSG = 0; // Делитель тактовой частоты отсутствует.
```
Далее нужно изменить способ формирования сигнала. Как мы помним из предыдущей статьи, за это отвечает группа бит **OCCM** регистра **CH1\_CNTRL**. Тогда мы выбирали режим инвертирования сигнала REF при CNT == CCR1. Так как CCR было = 0 по умолчанию, то регулируя ARR основного счетчика — мы получали тот же эффект. Сейчас же мы в ARR записываем количество тактов всего периода (0xFFFF), а в CRR будем писать количество тактов единицы на выводе (время действия импульса). А режим выберем 6 (0b110:1, если DIR= 0 (счет вверх), CNT
```
MDR_TIMER1->ARR = 0xFFFF; // Период постоянный. И дает возможнсоть выбирать период заполнения от 0 до 0xFFFF.
MDR_TIMER1->CCR1 = timeEnabledState; // Канал будет держать 1 до этого значения и 0 - после.
MDR_TIMER1->CH1_CNTRL = 6<= CCR1;
```
По сути, на этом этапе мы уже получили функцию, задающую скважность ШИМ сигнала. Но нужно позаботиться о том, чтобы при смене значения CCR1 счетчик не вышел за пределы. Для этого нужно установить бит **CRRRLD** в регистре **CH1\_CNTRL2**. Он разрешает смену значения CCR1 и CCR2 лишь при CNT == 0.
```
MDR_TIMER1->CH1_CNTRL2 = TIMER_CH_CNTRL2_CCRRLD; // CCR1 обновляется лишь при CNT = 0. Чтобы не было глюков.
```
#### Закончим: изменение параметров прерывания
С настройкой ШИМ-а разобрались. Осталось только немного изменить прерывание по опросу клавиш. Зададим новую переменную, характеризующую длительность импульса в периоде. Назовем ее **PWM\_time**. По умолчанию пусть будет 0xFFFF (ШИМ-а при таком значении нет, светодиод горит). А далее посмотрим, с каким интервалом делать шаг при нажатии на клавишу. Для этого разложим число тактов периода на простые множители.
```
// 65535 = 3·5·17·257. 257 раз пусть будет для нас диапазоном от 0 - не горит до 257 - горит на полную. => шаг 3*5*17 = 255.
```
Из расчета видим, что шагая с интервалом 255 мы можем пройти всю шкалу от 0 до 257. Так и поступим. Получим следующий код.
```
// 65535 = 3·5·17·257. 257 раз пусть будет для нас диапазоном от 0 - не горит до 257 - горит на полную. => шаг 3*5*17 = 255.
if (UP_FLAG == 0) PWM_time+=255; // Проверияем, нажата ли какая-нибудь клавиша. Если нажата - что-то делаем с частотой.
else if (DOWN_FLAG == 0) PWM_time-=255;
else if (LEFT_FLAG == 0) PWM_time-=255;
else if (RIGHT_FLAG == 0) PWM_time+=255;
if (PWM_time < 0) PWM_time = 0; // Проверяем, чтобы время "единицы" было не меньше нуля и не больше периода.
else if (PWM_time > 0xFFFF) PWM_time = 0xFFFF;
```
Осталось только присвоить новое значение.
```
MDR_TIMER1->CCR1 = PWM_time; // Меняем частоту.
```
Еще раз замечу, что период мы не трогаем. Он постоянен. Меняем только длительность импульса. Целиком прерывание будет иметь следующий вид.
```
int PWM_time = 0xFFFF; // По началу горит полностью.
void Timer2_IRQHandler (void)
{
MDR_TIMER2->STATUS = 0; // Сбрасываем флаг. Обязательно первой коммандой.
//LED1_FLAG = !LED1_FLAG; // Показываем, что прерывание было обработано.
// 65535 = 3·5·17·257. 257 раз пусть будет для нас диапазоном от 0 - не горит до 257 - горит на полную. => шаг 3*5*17 = 255.
if (UP_FLAG == 0) PWM_time+=255; // Проверияем, нажата ли какая-нибудь клавиша. Если нажата - что-то делаем с частотой.
else if (DOWN_FLAG == 0) PWM_time-=255;
else if (LEFT_FLAG == 0) PWM_time-=255;
else if (RIGHT_FLAG == 0) PWM_time+=255;
if (PWM_time < 0) PWM_time = 0; // Проверяем, чтобы время "единицы" было не меньше нуля и не больше периода.
else if (PWM_time > 0xFFFF) PWM_time = 0xFFFF;
MDR_TIMER1->CCR1 = PWM_time; // Меняем частоту.
}
```
Я намеренно скрыл строку инверсии светодиода, показывающую, что прерывание происходит. Ибо тока на 2 светодиода не хватает и появляются нежелательные пульсации.
#### Заключение
В данной статье мы рассмотрели, как можно настроить ШИМ и управлять им. В следующей статье мы попробуем сгенерировать при помощи ШИМ звук.
Проект на [github](https://github.com/Vadimatorik/k1986be92qi_gpio_and_pwm_led).
**Список предыдущих статей.**1. [Переходим с STM32F103 на К1986ВЕ92QI. Или первое знакомство с российским микроконтроллером.](http://habrahabr.ru/post/255199/#first_unread)
2. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Настройка проекта в keil и мигание светодиодом.](http://habrahabr.ru/post/255323/)
3. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Системный таймер (SysTick).](http://habrahabr.ru/post/255415/)
4. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Настройка тактовой частоты.](http://habrahabr.ru/post/255479/)
5. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Практическое применение: Генерируем и воспроизводим звук. Часть первая: генерируем прямоугольный и синусоидальный сигнал. Освоение ЦАП (DAC).](http://habrahabr.ru/post/255513/)
6. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Практическое применение: Генерируем и воспроизводим звук. Часть вторая: генерируем синусоидальный сигнал. Освоение DMA.](http://habrahabr.ru/post/256091/)
7. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Практическое применение: Генерируем и воспроизводим звук. Часть третья: генерируем синусоидальный сигнал. Простой взгляд на DMA + первое знакомство с таймерами.](http://habrahabr.ru/post/256577/)
8. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Практическое применение: Генерируем и воспроизводим звук. Часть четвертая: создаем цифровую часть одноголосной и многоголосой музыкальной открытки.](http://habrahabr.ru/post/256621/)
9. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Практическое применение: Опрашиваем клавиши, генерируем ШИМ. Сравнение кода на CMSIS и SPL (PWM+TIM+PORT). Часть первая.](http://habrahabr.ru/post/267051/)
10. [Переходим с STM32 на российский микроконтроллер К1986ВЕ92QI. Практическое применение: Опрашиваем клавиши, генерируем ШИМ. Сравнение кода на CMSIS и SPL (PWM+TIM+PORT). Часть вторая.](http://habrahabr.ru/post/270863/) | https://habr.com/ru/post/270887/ | null | ru | null |
# Пишем Lisp-интерпретатор на Java
Некоторое время назад мне захотелось написать свой небольшой интерпретируемый скриптовый язык, просто ради фана, не ставя перед собой каких-либо серьезных задач. Я тогда активно читал известную волшебную книгу SICP (Структура и интерпретация компьютерных программ), и мне захотелось реализовать описываемые в ней абстракции — функции как объекты первого класса, замыкания, макросы и т.п. Параллельно я интересовался языком Haskell, и решил совместить приятное с приятным, и написать интерпретатор языка на нем. В моем языке должна была быть строгая семантика с вызовом по значению и мутабельные переменные. Получившийся язык Lisp-семейства я в своем локальном окружении связал с именем Liscript, полная реализация которого уместилась в примерно 250 строк, включая парсер, ядро и консольный/файловый ввод-вывод. Этого более чем хватало, чтобы ради интереса решать любые задачки, какими обычно мучают студентов, которых угораздило изучать Lisp по учебной программе.
По прошествии времени мне захотелось сделать к интерпретатору кроссплатформенный GUI-интерфейс с перспективой портирования на Android, поэтому я реализовал второй вариант интерпретатора на Java, внешний вид которого вы можете видеть на картинке выше. Да, он поддерживает графический вывод и вообще interoperability с Java, и этот Тетрис написан на Liscript, видна часть его кода. Кому интересны подробности — прошу под кат.
В рамках одной статьи сложно уместить все особенности языка и его реализации, а писать сериал из многих статей, начиная с пространного описания реализации парсера с помощью стандартной библиотеки мне скромность не позволит. (К слову сказать, в обоих реализациях — и на Haskell и на Java я не пользовался никакими библиотеками парсинга, а писал все вручную — на Haskell это заняло аж целых 10 строк кода). Поэтому некоторые вещи буду писать в стиле «пришел, увидел, победил». В общем, написал я парсеры текста в AST типов. Единственно, хочу отметить пару моментов — я не фанат скобочек, но легкость парсинга, гомоиконность кода (код как данные) и отсутствие инфиксных бинарных операторов с необходимостью учета приоритета и ассоциативности и разбора через Польшу или сортировочные станции с лихвой перевешивает все претензии к подобному синтаксису. В результате парсинга я получаю список, который передается функции интерпретации. В Java-реализации я не стал пользоваться библиотечными типами списков, а навеловипедил свой — простой, односвязный, потоконебезопасный и т.п.:
**Заголовок спойлера**
```
/** тип языка Liscript - односвязный список */
public static class ConsList {
/** объект - значение головы текущего списка */
public Object car;
/** список - значение хвоста текущего списка */
public ConsList cdr;
/** Конструктор со значениями головы и хвоста.
* @param h объект - голова списка
* @param t список - хвост списка
*/
ConsList(Object h, ConsList t) { car = h; cdr = t; }
/** проверяет, является ли список пустым
* @return истина/ложь
*/
public boolean isEmpty() { return this.car == null && this.cdr == null; }
/** возвращает размер списка
* @return размер
*/
public int size() {
int r = 0;
ConsList p = this;
while (!p.isEmpty()) {r += 1; p = p.cdr;}
return r;
}
/** @return строковое представление текущего списка */
@Override
public String toString() { return showVal(this); }
}
```
Подобным же образом реализованы типы-классы для функции, макроса. Пример кода класса-типа функции:
**Заголовок спойлера**
```
/** тип языка Liscript - функция */
public static class Func {
/** односвязный список имен параметров функции */
public ConsList pars;
/** тело функции */
public Object body;
/** окружение, в котором создана функция */
public Env clojure;
/** Конструктор
* @param p односвязный список имен параметров функции
* @param b тело функции
* @param c окружение, в котором создана функция
*/
Func(ConsList p, Object b, Env c) { pars = p; body = b; clojure = c; }
/** @return строковое представление функции */
@Override
public String toString() { return showVal(this); }
}
```
### Окружение
Реализовано в полном соответствии с SICP — иерархическая структура словарей, где каждый словарь — HashMap, класс содержит методы добавления, получения и изменения значения по строковому имени. И тут уже можно проявить творческий подход: например, что делать, если пытаемся получить значение по отсутствующему ключу (имени переменной)? Прервывать исполнение с ошибкой? Или возвращать строковое представление ключа? То же самое, если пытаемся добавить переменную, имя которой уже содержится в словаре текущего кадра окружения — давать ошибку или переопределять переменную? Подобные мелочи в результате определяют особенности языка, и например мне нравится, что я могу сам определять их. Получаем автоцитирование и глубокое связывание, со всеми плюсами и минусами такого подхода.
Также мне захотелось реализовать переменную арность особых форм прямо в ядре языка, а не потом в стандартной библиотеке. Многие из них допускают передачу ряда параметров и/или работают не совсем так, как их одноименные аналоги в других диалектах Lisp — это не усложняет реализацию интерпретатора. Пример работы с окружением (после => идет ответ интерпретатора):
```
++ "a1 = " a1 ", b1 = " b1 ", c1 = " c1
=> a1 = a1, b1 = b1, c1 = c1
def a1 1 b1 (+ a1 1) (++ "c" a1) (+ a1 b1)
=> OK
++ "a1 = " a1 ", b1 = " b1 ", c1 = " c1
=> a1 = 1, b1 = 2, c1 = 3
set! (++ "a" 1) 5 c1 10
=> OK
++ "a1 = " a1 ", b1 = " (get (++ "b" 1)) ", c1 = " c1
=> a1 = 5, b1 = 2, c1 = 10
```
### Функции
Являются объектами первого класса. При создании функция захватывает текущий контекст. При вызове аргументы вычисляются строго последовательно. Реализована автоматическая оптимизация хвостовых вызовов — ТСО:
```
defn is-even (n) (cond (= n 0) true (is-odd (- n 1)) )
=> OK
defn is-odd (n) (cond (= n 0) false (is-even (- n 1)) )
=> OK
is-even 10000
=> true
is-even 10001
=> false
```
Особая форма tray позволяет печатать стек вызовов при применении функции. Вот так, например, происходит вычисление факториала от 3:
**Заголовок спойлера**
```
defn f (i) (cond (< i 2) 1 (* i (f (- i 1))))
=> OK
tray f 3
=>
1 ← (f 3)
2 ← f
2 → (lambda (i) (cond (< i 2) 1 (* i (f (- i 1)))))
2 ← (cond (< i 2) 1 (* i (f (- i 1))))
3 ← (< i 2)
4 ← i
4 → 3
3 → false
3 ← (* i (f (- i 1)))
4 ← i
4 → 3
4 ← (f (- i 1))
5 ← f
5 → (lambda (i) (cond (< i 2) 1 (* i (f (- i 1)))))
5 ← (- i 1)
6 ← i
6 → 3
5 → 2
5 ← (cond (< i 2) 1 (* i (f (- i 1))))
6 ← (< i 2)
7 ← i
7 → 2
6 → false
6 ← (* i (f (- i 1)))
7 ← i
7 → 2
7 ← (f (- i 1))
8 ← f
8 → (lambda (i) (cond (< i 2) 1 (* i (f (- i 1)))))
8 ← (- i 1)
9 ← i
9 → 2
8 → 1
8 ← (cond (< i 2) 1 (* i (f (- i 1))))
9 ← (< i 2)
10 ← i
10 → 1
9 → true
8 → 1
7 → 1
6 → 2
5 → 2
4 → 2
3 → 6
2 → 6
1 → 6
6
```
Если при вызове функции аргументов передано больше, чем количество формальных параметров, то последний формальный параметр свяжется со списком вычисленных оставшихся переданных аргументов. Если меньше — то эти формальные параметры окажутся не связаны в окружении вычисления функции и при вычислении ее тела будут искаться в окружениях верхнего уровня иерархии. Можно было бы выбрать вариант каррирования — возвращать частично примененную функцию, или выдавать ошибку несоответствия количества аргументов.
### Макросы
Liscript поддерживает так называемые runtime-макросы, которые являются объектами первого класса языка. Их можно создавать, связывать с именами, возвращать как результат функций и выполнять в процессе работы (интерпретации кода). Полученное из текста исходного кода выражение сразу начинает интерпретироваться, без предварительной стадии раскрытия макросов, поэтому макросы остаются полноправными типами языка и раскрываются и вычисляются в процессе интерпретации по всем правилам вычисления макросов — сначала производится подстановка в тело макроса невычисленных переданных аргументов а затем это тело макроса вычисляется в текущем окружении (в отличие от тела функции, которое всегда вычисляется в отдельном собственном окружении, в котором уже присутствуют предварительно вычисленные значения фактических параметров):
```
def m (macro (i r) (cond (<= i 0) 'r (m (- i 1) (cons i r))))
=> OK
m 5 nil
=> (cons (- (- (- (- 5 1) 1) 1) 1) (cons (- (- (- 5 1) 1) 1) (cons (- (- 5 1) 1) (cons (- 5 1) (cons 5 nil)))))
eval (m 5 nil)
=> (1 2 3 4 5)
```
### Interoperability с Java
Реализовано через механизм Java Reflection. Всего 2 особые формы: class — определяет класс по полному имени и java — вызывает метод класса с переданными параметрами. Поиск нужного метода среди одноименных перегруженных осуществляется с учетом количества и типов переданных параметров. Для ускорения работы однажды найденный и вызванный в текущем сеансе работы интерпретатора метод класса запоминается в таблице вызванных методов и при вызове любого метода сначала происходит поиск в таблице — мемоизация.
```
def m (java (class "java.util.HashMap") "new")
=> OK
java m "put" 1 "a"
=> OK
java m "put" "b" 2
=> OK
java m "get" 1
=> a
m
=> {1=a, b=2}
```
Таким образом мы можем получить доступ ко многим ресурсам языка реализации, в том числе и к графике. Вот такой код открывает отдельное окно с нарисованной красной линией на белом фоне:
```
(def image (java (class "java.awt.image.BufferedImage") "new" 100 100 1))
(def imageGraphics (java image "createGraphics"))
(java imageGraphics "setBackground" (java (class "java.awt.Color") "new" 255 255 255))
(java imageGraphics "clearRect" 0 0 100 100)
(java imageGraphics "setColor" (java (class "java.awt.Color") "new" 255 0 0))
(java imageGraphics "drawLine" 10 10 90 90)
(def icon (java (class "javax.swing.ImageIcon") "new"))
(java icon "setImage" image)
(def label (java (class "javax.swing.JLabel") "new"))
(java label "setIcon" icon)
(def window (java (class "javax.swing.JFrame") "new"))
(java window "setLayout" (java (class "java.awt.FlowLayout") "new"))
(java window "add" label)
(java window "setVisible" true)
(java window "pack")
```
Разумеется, можно выделить типичные блоки в отдельные функции или макросы и прописать их один раз в стандартной библиотеке, которая подгружается при старте интерпретатора. А поскольку интерпретатор реализует многопоточное выполнение задач в отдельных закладках с общим мутабельным окружением (да, я знаю, что выбранная в качестве хранилища словаря HashMap не является потокобезопасной и это может создать проблемы при одновременном изменении окружения из параллельных потоков, и лучше было применить HashTable), так вот, это позволяет в одной закладке запустить процедуру, вызывающую саму себя через определенное время ожидания по таймеру, а в другом окне (потоке) — процедуру, запрашивающую пользовательский ввод и выполняющую определенные действия. Так и был реализован Тетрис (с особенностью блокирующего пользовательского ввода — каждую команду надо подтверждать с помощью Ctrl+Enter).
Данный проект доступен на Github по адресу [github.com/Ivana-/Liscript-GUI-Java-Swing](https://github.com/Ivana-/Liscript-GUI-Java-Swing). В нем содержатся исходные файли интерпретатора и его GUI на Swing (я знаю что уже 21 век на дворе, но на JavaFX пока переписывать не тороплюсь), а также файлы скриптов стандартной библиотеки, описания языка, интерпретатора и достаточное количество демо-примеров. При желании покритиковать прошу учесть, что это мой первый проект на Java и на ООП языке вообще, так что многое может быть реализовано неоптимально. Но мне будет интересны мнения и обратная связь по этому проекту. | https://habr.com/ru/post/281859/ | null | ru | null |
# Обзор и настройка расширения Unite
Был удивлен, что на хабре нет описания расширения Unite, которое позволяет заменить просто огромное количество плагинов для Vim. Unite сочетает в себе функционал таких расширений как: CtrlP, FuzzyFinder, ack, yankring, LustyJuggler, buffer explorer и т.д.
### Установка Unite
Прежде чем приступить к настройке расширения необходимо установить зависимости. Я использую Vundle, поэтому устанавливать будем через него. Для доступа к некоторым функциям Unite необходим плагин vimproc. Для этого добавим следующие строчки в наш файл .vimrc:
```
Bundle 'Shougo/vimproc.vim'
Bundle 'Shougo/unite.vim'
```
Перезапускаем редактор и вводим команду :BundleInstall. Откомпилируем vimproc:
```
cd ~
cd .vim/bundle/vimproc.vim
make -f make_mac.mak # тут зависит от платформы, для Linux: make_unix.mak
```
Установка всех зависимостей завершена, переходим к настройке Unite. Давайте добавим следующие строки в vimrc:
```
" Автоматический insert mode
let g:unite_enable_start_insert = 1
" Отображаем Unite в нижней части экрана
let g:unite_split_rule = "botright"
" Отключаем замену статус строки
let g:unite_force_overwrite_statusline = 0
" Размер окна Unite
let g:unite_winheight = 10
" Красивые стрелочки
let g:unite_candidate_icon="▷"
```
Ознакомимся с некоторыми командами Unite:
| Команда | Описание |
| --- | --- |
| Unite file | открыть список файлов и директории в текущем проекте |
| Unite buffer | показать открытые буферы |
| Unite file buffer | показать файлы и открытые буферы |
Команда Unite так же поддерживает опции, например запустив Unite с опцией -auto-preview мы запустим Unite с функцией предпросмотра файлов (как в Sublime).
Если вам нужно ходить по файлам рекурсивно, то есть осуществлять поиск по текущему проекту просто вводя начальные буквы файла как в CtrlP и Command-T, для этого достаточно запустить Unite с флагом file\_rec/async, хочу предупредить что без сборки vimproc данная опция работать не будет:
```
Unite file_rec/async
```
Что бы поиск происходил по первым введенным буквам нужно добавить опцию -start-insert:
```
Unite file_rec/async -start-insert
```
И наконец конечный результат команды, которую я привязал к комбинации leader+f
```
nnoremap f :Unite -buffer-name=files -start-insert buffer file\_rec/async:!
```
Скриншот редактора с запущенным Unite
У Unite есть так же и командный режим, который запускается нажатием клавиши Ctrl+i в открытом буфере Unite. Командный режим позволяет создавать и сравнивать файлы, директории, создавать закладки, выполнять grep и т. д. Кстати, посмотреть список закладок можно командой :Unite bookmark, а добавить файл в закладки можно из командного режима.
### Создаем собственное меню в Unite
В Unite есть возможность создавать собственное меню (за подсказку спасибо хабрапользователю [gmist](http://habrahabr.ru/users/gmist/)). Пример использования:
```
let g:unite_source_menu_menus = {}
let g:unite_source_menu_menus.mymenu = {
\ 'description' : 'My Unite menu',
\ }
let g:unite_source_menu_menus.mymenu.candidates = {
\ 'mru&buffer' : 'Unite buffer file_mru',
\ 'tag' : 'Unite tag',
\ 'file' : 'Unite file',
\ 'file_rec' : 'Unite file_rec',
\ 'file_rec/async' : 'Unite file_rec/async',
\ 'find' : 'Unite find',
\ 'grep' : 'Unite grep',
\ 'register' : 'Unite register',
\ 'bookmark' : 'Unite bookmark',
\ 'output' : 'Unite output',
\ }
function g:unite_source_menu_menus.mymenu.map(key, value)
return {
\ 'word' : a:key, 'kind' : 'command',
\ 'action__command' : a:value,
\ }
endfunction
```
Запустить меню можно командой
```
:Unite menu:mymenu
```
### Еще несколько примеров работы Unite
Поиск по файлу как в CtrlP
```
:Unite file_rec/async
```
**Пример работы**
Поиск как в ack.vim
```
:Unite grep:.
```
**Пример работы**
Поиск по истории как в yankring/yankstack
```
let g:unite_source_history_yank_enable = 1
:Unite history/yank
```
**Пример работы**
Переключение буферов как в LustyJuggler
```
:Unite -quick-match buffer
```
**Пример работы**
[Страница проекта](https://github.com/Shougo/unite.vim) | https://habr.com/ru/post/201564/ | null | ru | null |
# Как мы ИИ учили новости понимать
Все мы хотим быть в курсе происходящего поэтому часть своего времени тратим на чтение новостей, и сейчас все чаще новости приходят не из новостных сайтов или газет, а из каки-то телеграм-каналов. В итоге, через какое-то время, оказывается, что ты подписан на десяток(а может и на десятки каналов), которые постоянно что-то пишут – как следствие, тратится либо огромное количество времени на то, чтобы "что-то не пропустить". Но если посмотреть – большинство из них пишут примерно об одном, просто по-разному. Так и пришла идея научить ИИ отбирать новости, которые действительно являются главными. Конечно, есть разные ТОП-ы, вроде Яндекс.Новостей или что-то вроде итогов дня от какого-то уважаемого СМИ, но везде есть нюансики. В этой статье я постараюсь описать эти нюансики и что у нас получилось, а что нет.
Нюансики и источники
--------------------
Вообще новости очень субъективная вещь, каждый сам выбирает источники – кому верить, а кому нет, именно поэтому очень часто получается достаточно однобокая картинка мира, если читать какое-то одно издание – там есть редакционная политика, которая чаще всего топит "за определенную повестку". Да, раньше был прекрасный проект Яндекс.Новости, который сейчас тоже превратился в инструмент, где транслируется определенный пул новостей – и это не проблема конкретного прокта, скорее это проблема того пула источников с которым они работают. Сразу забегая вперед – у нас была аналогичная проблема, когда мы отбирали источники себе.
Чтобы побороть эту пресловутую однобокость мы для себя поставили задачу следующим образом:
* У нас в качестве источников будут новостные телеграмм-каналы, которые оперативно следят за происходящим
* Мы постарались отобрать телеграмм каналы с разной повесткой, как раз для того, чтобы уйти от однобокого освещения каких-либо новостей(да-да, по большому счету это тоже можно назвать редакционной политикой на этапе отбора, но придумать более объективный способ у нас не получилось)
* Все отобранные источники – равны, это значит, что канал с 100 тыс. подписчиками и канал с 10 тыс. подписчиками(но при этом уважаемого издания) – с точки зрения авторитетности равны. Ну не умеет какое-то гос. СМИ в СММ, ну не игнорировать же его сообщения
Таким образом у нас получилось собрать порядка 100 изданий, который мы "читаем" и пытаемся собрать актуальную новостную картину дня. При этом для начала мы прошлись по рейтингу [медиалогии](https://www.mlg.ru/ratings/) для того, чтобы отобрать топовые – таким образом у нас есть и, например, новости из телеграм-канала Известий, GQ, личного канала Ксении Собчак и т.д. Конечно мы посмотрели топовые каналы с огромным количеством подписчиков - типа канала Ивлеевой, но, если честно какой-то полезной информации мы там не нашли.
Собираем свой ТОП
-----------------
Есть миллион разных вариантов, как можно собирать ТОП, особенно когда ты большой поисковик с кучей ресурсов, кучей перекрёстных данных, индексами цитирования, данными по просмотрам и т.д. Но у нас, очевидно всего этого нет и надо было как-то выкручиваться. В итоге пришлось придумать свою методику отбора сообщений из того, что есть. А было не много – просто текст, количество просмотров сейчас и потенциальное количество просмотров(из статистики по каналу в целом)... и вообщем-то все. И да, еще надо не ошибиться – то, что ты уже запостил "отпостить" нельзя(конечно технически можно, но тогда надо опять же садить человека, который будет следить и в общем-то теряется весь смысл). Короче, если ты выбрал какую-то новость и запостил помимо всего прочего надо следить за сюжетом и новые сообщения, которые добавляются в сюжет уже постить не надо, даже если очень хочется.
Таким образом перед собой мы поставили себе такую задачу чтобы обрабатывать весь этот поток данных:
* У нас должна быть методика отбора новостей из разных каналов по принципу "похожести контекста", чтобы понимать – что разные источники пишут одну и туже новость
* У нас должна быть возможность отбирать "сообщения", которые бы максимально коротко и емко описывали новость – т.е. чтобы в одном сообщении было как можно меньше "воды" и максимальное количество фактов
* Новость должна быть "интересной" и эмоциональной – т.е. мы должны как-то определить, что аудитория интересуется этой темой сейчас
А с точки зрения того, что должна уметь наша нейрона, чтобы вот это все можно было делать без человеческого вмешательства:
* определять похожесть текста(потом мы обошлись без нейронки)
* понимать в каком тексте у нас больше всего фактов – тут мы решаем классическую NLP задачу по поиску [NER](https://en.wikipedia.org/wiki/Named-entity_recognition) тексте – чем больше этих самых сущностей, тем больше фактов
* уметь как-то понимать "будет" ли эта новость интересна читателям или нет
Технически получилось достаточно простое решение – у нас есть всего 3 компонента, которые все эти сложные вещи автоматизируют: парсим источники, обрабатываем сообщения и добавляем метаданные по которым можно собирать и ранжировать(этим и занимается нейронка), обратная интеграция – постим в канал. Ну и все это упаковываем в оркестратор, чтобы у нас все интеграции обработки не отваливались, а если и отваливались - то данные не просаживались.
"Идеальная" нейросеть для NLP
-----------------------------
Прочитав кучу статей про достижения [трансформеров](https://habr.com/ru/post/486358/) в решении задачи NLP, конечно же было решено сразу попробовать [BERT](https://habr.com/ru/search/?q=%5BBERT%5D&target_type=posts), ведь с помощью одной обученной нейросети сразу решить все задачи. В интернете даже оказалось несколько обученных моделей на русском языке. Но не тут-то было. На самом деле мы попробовали несколько нейросетей и отказались от них по одной и тоже причине – **нейросеть, которая отлично себя показывает в MVP не всегда лучший вариант для работы в продуктиве**:
* Какая бы идеально обученная или оттюненая ни была модель на момент запуска ее **надо будет регулярно дообучать**. Особенно это касается задач, связанных с NLP в тех ситуациях, когда у вас меняется язык – вводятся новые сущности, меняются интересы и т.п. Как вы понимаете - новости это то поле, где это все плывет очень быстро. И даже если вы нашли и обучили модель на датасете полугодовой давности, то совсем не факт, что у вас эта модель будет хорошо показывать результаты сейчас.
* **Тяжелые нейронные сети, вроде BERT достаточно ресурсоемкие** – если нет проблем с ресурсами, конечно это все можно запросто отбалансировать и запускать в параллели, но зачем это делать, если можно ту же самую задачу почти с такими же результатами решить с меньшими затратами на ресурсы.
В итоге, наш MVP с BERT умер в первый же день, когда мы попробовали обрабатывать 20 каналов – обученная сеть искала криво(надо было тюнить), отдельный сервак, выделенный под работу BERT - отставал от новостей, т.е. количество сообщений приходивших для обработки росло быстрее, чем нейросеть могла их обрабатывать. Конечно можно было купить еще ресурсов, отбалансировать, но в этот момент мы поняли, что придется все начинать с нуля – искать другую нейросеть, собирать свои датасеты и обучать(ну или тюнить).
Что перебрали и не выбрали:
* BERT – ресурсоемкая, медленная, сложно добавлять новые сущности NER в существующую модель, нужно достаточно большое количество ресурсов для обучения
* [Natasha](https://github.com/natasha/natasha) – очень крутой проект, если вам надо решать задачи NLP для русского языка: быстрая, точная, простой API, но без возможности тюнить самостоятельно. Т.е. если вам хватает функциональности "из коробки" – отличное решение
* [Stanza](https://stanfordnlp.github.io/stanza/index.html) – достаточно популярный пакет готовых инструментов для решения NLP задач, наличием готовых моделей, относительно быстрый и точный
Но в итоге мы становились на [Spacy](https://spacy.io), который на наш взгляд дал все, что нужно было нам:
* достаточную скорость
* точность и гибкость обучения
* решение сразу нескольких NLP задач, используя один пакет: NER, лематизацию, анализ тональности текста, анализ зависимостей
* небольшое потребление ресурсов(по сравнению с той же BERT)
Большой минус - отсутствие готовой русскоязычной модели нужно качества, но в нашем случае такой модели не могло быть в принципе, поэтому решили собирать движок для выделения метаданных из текста с помощью Spacy.
> Тут нужно сделать небольшую ремарку, в процессе написания статьи обнаружилось, что есть проект: [Natasha-spacy](https://github.com/natasha/natasha-spacy), в котором ребята решили большинство граблей и этой моделью можно будет пользоваться в большинстве проектов, где не нужно регулярно обновлять модель. Но даже в этом случае, если бы была такая модель на момент решения задачи в рамках нашего проекта - пару недель, а то и больше, мы бы точно сэкономили.
>
>
Собираем датасет
----------------
Ни для кого не секрет, что если есть готовая модель и готовый датасет – то вопрос обучения, это вопрос времени и ресурсов. И если посмотреть на тот же самый английский язык – там все хорошо: есть куча готовых моделей на все случаи жизни. Нет модели – окей, есть датасет, дополняй его и обучай или тюнингуй модель для своей задачи. У нас же проблема усугублялась тем, что при решении задачи NER нам было недостаточно стандартных PER, LOC, ORG сущностей, нам важно было добавить еще выделение "денег" и "дат" в разных форматах и формах, т.к. это тоже касается важных фактах в новостях.
Датасеты на которых можно обучить основную часть языковой модели - словоформы, леммы, зависимости и т.п. Причем датасеты уже подготовлены к наиболее популярному формату [CONLLU](https://universaldependencies.org/format.html), именно этот формат чаще всего используется для базового обучения моделей на разных языках. Наиболее часто используемые датасеты:
* [GSD](https://universaldependencies.org/treebanks/ru_gsd/index.html)
* [SynTagRus](https://universaldependencies.org/treebanks/ru_syntagrus/index.html)
* [Taiga](https://universaldependencies.org/treebanks/ru_taiga/index.html)
В зависимости от решаемой задачи можно выбирать один из них или миксовать как-то. Но у всех у них есть одна проблема - они не содержат NER. Конечно можно посадить большое количество людей и разметить нужные вам тексты на нужные вам термины в этих текстах. Но, только если у вас есть ресурсы и время на разметку. У нас такой роскоши не было, и надо было как-то выкручиваться. Поэтому после недолгих поисков был найден еще один прекрасный проект – «[Открытый корпус](http://opencorpora.org)», который как раз и занимается тем, что собирает и выделяет набор сущностей в тексте. Да, конечно у проекта своя методология выделения сущностей(не совместимы с CONLLU), свои форматы выгружаемых текстов для которых пришлось писать свой парсер для приведения этого корпуса к формату CONLLU. Но, основной плюс этого всего был в том, что весь этот корпус собран вручную.
Но что касается сущностей для выявления "денег" и "дат" – у нас все равно не было данных. Но это оказалась простая задача, решаемая простыми regexp-ами, через которые мы прогнали уже собранный вручную текст и обогатили и этими сущностями.
**Эмоциональная окраска**
Что может быть проще, думали мы и к тому моменту нашли уже несколько датасетов в которых все тексты разделялись на "позитивный" и "негативный". Но когда мы открыли и посмотрели на эти датасеты - нас ждало очередное разочарование:
* все они в большей степени подходили для оценки комментариев, например для оценки товара, сервиса или продукта
* большая часть из них вызывала споры, т.к. посмотрев на репрезентативную выборку мы поняли, что понятие "позитивный" или "негативный" очень сильно разнится у разных людей, нам же нужна "среднестистическая оценка"
* когда мы говорим про новости – зачастую очень сложно понять - а позитивная это новость или негативная, посмотрите, например, на актуальный ТОП сегодняшних новостей и ради интереса попробуйте отнести их к той или иной категории, а потом спросите хотя бы у 3-х друзей – как они их отнесут
Короче нас ждал очередной провал и мы уже хотели отказаться от этой фичи. Ну подумаешь, ну мы не будем понимать что за новость, интересная она или нет.
Отказываться было нельзя, поэтому решили собрать свой собственный датасет из "открытых данных". К открытым данным мы отнесли публичные старицы в Facebook(например [themeduza](https://www.facebook.com/themeduza/), [forbesrussia](https://www.facebook.com/forbesrussia/)) новостных изданий и, внезапно, новости на государственном сайте [ria.ru](https://ria.ru). И это стало нашим спасением – если внимательно посмотреть на любую публикацию - внизу есть важная и нужная нам информация о среднестатистической реакции читателей на эту новость. О чудо! У нас есть - заголовки, короткий текст и полный текст новости, а главное набор реакций большого количества разных людей, реагирующей на эту информацию. После небольшого усложнения нашей инфраструктуры и ~полутора месяцев скрупулёзного сбора данных у нас появился нужный нам датасет.
В итоге, наша модель с помощью собранного датасета должна была уметь не только определять "позитивная" или "негативная" эта новость, а понимать злит, радует, расстраивает, восхищает ли она людей, и вообще интересная она или нет.
Если посмотреть на среднее количество действий пользователей под каждым постом для каждой отдельно взятой страницы можно достаточно просто понять, какие новости вызывают максимальный интерес у пользователей – они чаще на них реагируют и с какими эмоциями. Именно такие темы новостей мы будем считать "наиболее интересными" на данный момент времени, и очевидно - эти интересы регулярно меняются.
Перенос в продуктив
-------------------
Тут наверное немного надо еще рассказать про инфраструктуру – собственно сколько ресурсов нужно для того, чтобы это все работало и не проседало при той нагрузке, которая у нас есть. А есть у нас есть примерно 4-5 тыс сообщений, которые надо распарсить, прогнать через нейронную сеть, которая должна обогатить каждое сообщение метаданными, а потом еще выбрать какое-то сообщение в качестве "главного".
Среднее количество сообщений в деньИ вся эта инфраструктура крутится на 4 GB RAM, 2 vCPUs со средней нагрузкой 8% на CPU, короче все очень экономичненько. Да, много сил и времени заняла тонкая настройка airflow, но это дало свои плоды(для понимания - airflow "из коробки" перманентно нагружал инстанс 16 GB RAM, 4 vCPUs в среднем на 32%). Очевидно, что использование более тяжелых моделей нейросетей требовало бы еще большего количество ресурсов. А в нашем случае, когда у нас сообщения анализируются порционно и все это происходит в рамках DAG-ов, которые каждый раз загружают и выгружают соответствующие модели – это бы порушило архитектуру в целом.
ИнфраструктураНаконец настал "день X", когда мы собрали и запустили все компоненты в продуктив. На тот момент у нас было:
* Загруженная история из интересующих каналов за последние полгода(интеграционное решение построено таким образом, что при добавлении нового канала оно подгружает историю за последние полгода, можно и больше, но не интересно)
* Обученная нейронная сеть, которая могла обогащать каждое из сообщений дополнительной информацией – выявлять NER для каждой записи, оценивать сообщения по уровню "интересности" и эмоциональному окрасу новости, выглядит это примерно так(абсолютно рандомный пример если что)
```
"source": {
"id": 1115468824,
"username": "lentadnya",
"title": "Лента дня",
"participants": 47148
},
"text": "«Россия, матушка, забери Донбасс домой»: Маргарита Симоньян попросила присоединить Донбасс к России. Тут лучше не пересказывать, просто послушайте",
"views": 405,
"link": "https://t.me/lentadnya/16263",
"interesting": 0.12,
"reaction": {
"enjoyment": 0.04400996118783951,
"sadness": 0.0019097710028290749,
"disgust": 0.8650462031364441,
"anger": 0.08112426102161407,
"fear": 0.00790974497795105
},
"entities": [
"Россия",
"Маргарита Симоньян",
"Донбасс",
"России"
],
"tags": [
"россия",
"маргарита симоньян",
"донбасс",
"россия"
]
```
И после первого же прогона у нас получились достаточно спорные результаты, которые заставили еще немного усложнить архитектуру решения и немного перекроить нашу нейронку.
**Проблема №1**: Эмоциональная окраска и "интересность" хорошо аранжировалась только для сообщений, который были примерно в том же временном периоде, что и данные для обучения. Это как бы очевидно, но в действительности – уже через 3-4 недели, показатели начинают плыть. Т.е. с историей мы уже ничего не сделаем, т.к. у нас нет никакой выборки по истории на которой мы могли бы нормально обучить модель и прогнать историю, чтобы она была нормально отранжирована. Для новый данных – на регулярной основе мы продолжаем собирать данные из публичных источников и поддерживать актуальность модели.
**Проблема №2**: Актуальность NER – тут тоже происходит деградация модели. Конечно медленнее, чем для эмоций и интересов, но все равно точность просаживается. Пока эта проблема решается костылем. Костыль в нашем случае вылудит следующим образом - раз в неделю мы деваемы выборку по 100 рандомным сообщениям и вручную(да, к сожалению пока так) оцениваем на сколько точно происходит выявление NER и их лемматизация. Как только показатель падает меньше чем 85%. Происходит обучение модели на новых данных и снова контролируем этот показатель. Есть гипотеза обучить более тяжелую модель, например BERT в качестве "эталонной" и просто периодически сверяться на ней, но пока эта гипотеза только в проработке - если будет интересно, отдельно расскажем об этом как-нибудь.
**Проблема №3**: Дело в том, что в процессе анализа источников и выборки сообщения для формирования своего собственного рейтинга главных новостей, как я писал в начале, мы используем в том числе показатель, который показывает количество разных источников, которые написали сообщения в этом сюжете. Чтобы понять на сколько этот сюжет сейчас интересный. Ведь чем больше каналов пишут об этом - тем эта "новость" более важна и актуальная. Но мы столкнулись с тем, что в телеграмме есть "консорциумы", которые в определенный момент времени начинают форсить какое либо сообщение. Да, они не репостят одно и тоже сообщение(с этим было бы проще), но они в свойственной тому или иному каналу форсят одну и ту же мысль с указанием одинаковыми набором NER и эмоциональной окраской выводят "новость в топ". Не будем называть конкретные каналы, но в результате таких манипуляций внезапно мы сталкиваемся с картиной, которую мы видим, например в топе новостей у Яндекса. При этом "независимые" каналы, в случае какой-то важной новости реже "в унисон" – как следствие. Новости "сеток" прорываются и в наш топ. Да, можно выкинуть соответствующие "сетки" и оставить только один канал из группы, но это противоречит концепции нашей внутренней цензуры, так что пока думаем как решить эту проблему. Если есть предложения пишите в комментарии.
Ну и кто дочитал до этого момента, я надеюсь будет интересно а как же выглядит наш топ: <https://t.me/mygenda>.
Ну и как говорят модные блоггеры: подписывайтесь, делитесь комментариями и задайте вопросы. Надеюсь это было интересно. | https://habr.com/ru/post/540876/ | null | ru | null |
# Прогнозирование физики на стороне клиента в Unity
### TL;DR
Я создал демо, показывающее, как реализовать прогнозирование на стороне клиента физического движения игрока в Unity — [GitHub](https://github.com/spectre1989/unity_physics_csp).
### Введение
В начале 2012 года я написал [пост](http://www.codersblock.org/blog//2012/02/client-side-prediction-in-unity.html) о как-бы-реализации прогнозирования на стороне клиента физического движения игрока в Unity. Благодаря [Physics.Simulate()](https://docs.unity3d.com/ScriptReference/Physics.Simulate.html) тот неуклюжий обходной способ, который я описал, больше не нужен. Старый пост до сих пор является одним из самых популярных в моём блоге, но для современного Unity эта информация уже неверна. Поэтому я выпускаю версию 2018 года.
### Что-что на стороне клиента?
В соревновательных многопользовательских играх необходимо по возможности избегать читерства. Обычно это значит, что применяется сетевая модель с авторитарным сервером: клиенты отправляют серверу вводимую информацию, а сервер превращает эту информацию в перемещение игрока, а потом отправляет снэпшот получившегося состояния игрока обратно клиенту. При этом возникает задержка между нажатием клавиши и отображением результатом, что неприемлемо для любых активных игр. Прогнозирование на стороне клиента — это очень популярная техника, скрывающая задержку, прогнозируя то, каким будет получившееся движение и сразу показывая его игроку. Когда клиент получает результаты от сервера, он сравнивает их с тем, что спрогнозировал клиент, и если они отличаются, то прогноз был ошибочным и нуждается в коррекции состояния.
Получаемые от сервера снэпшоты всегда прибывают из прошлого относительно прогнозируемого состояния клиента (например, если передача данных от клиента серверу и обратно занимает 150 мс, то каждый снэпшот будет запаздывать не менее чем на 150 мс). В результате этого, когда клиенту нужно скорректировать неправильный прогноз, он должен откатиться к этой точке в прошлом, а затем воспроизвести всю введённую в промежутке информацию, чтобы вернуться к тому, где он находится. Если движение игрока в игре основано на физике, то необходим Physics.Simulate() для симуляции в одном кадре нескольких циклов. Если при движении игрока используются только Character Controllers (или capsule cast и т.д.), тогда можно обойтись без Physics.Simulate() — и я предполагаю, что производительность будет лучше.
Я воспользуюсь Unity, чтобы воссоздать сетевое демо под названием [«Zen of Networked Physics»](https://code.google.com/archive/p/gamephysics/downloads) [Гленна Фидлера](https://gafferongames.com/), которое мне уже давно нравится. У игрока есть физический куб, к которому он может прикладывать силы, толкая его в сцене. Демо симулирует различные условия сети, в числе задержку и утерю пакетов.
### Приступаем к работе
Первое, что нужно сделать — отключить автоматическую симуляцию физики. Хотя Physics.Simulate() позволяет нам сообщить физической системе, когда начинать симуляцию, по умолчанию она выполняет симуляцию автоматически на основании фиксированной дельты времени проекта. Поэтому мы отключим её в **Edit->Project Settings->Physics**, сняв флажок "**Auto Simulation**".
Для начала мы создадим простую однопользовательскую реализацию. Ввод сэмплируется (w, a, s, d для перемещения и пробел для прыжка), и всё сводится к простым силам, прикладываемым к Rigidbody с помощью AddForce().
```
public class Logic : MonoBehaviour
{
public GameObject player;
private float timer;
private void Start()
{
this.timer = 0.0f;
}
private void Update()
{
this.timer += Time.deltaTime;
while (this.timer >= Time.fixedDeltaTime)
{
this.timer -= Time.fixedDeltaTime;
Inputs inputs;
inputs.up = Input.GetKey(KeyCode.W);
inputs.down = Input.GetKey(KeyCode.S);
inputs.left = Input.GetKey(KeyCode.A);
inputs.right = Input.GetKey(KeyCode.D);
inputs.jump = Input.GetKey(KeyCode.Space);
this.AddForcesToPlayer(player.GetComponent(), inputs);
Physics.Simulate(Time.fixedDeltaTime);
}
}
}
```
*Перемещение игрока, пока сеть не используется*
### Отправка ввода на сервер
Теперь нам нужно отправить ввод на сервер, который тоже выполнит этот код движения, сделает снэпшот состояния куба и отправит его обратно клиенту.
```
// client
private void Update()
{
this.timer += Time.deltaTime;
while (this.timer >= Time.fixedDeltaTime)
{
this.timer -= Time.fixedDeltaTime;
Inputs inputs = this.SampleInputs();
InputMessage input_msg;
input_msg.inputs = inputs;
input_msg.tick_number = this.tick_number;
this.SendToServer(input_msg);
this.AddForcesToPlayer(player.GetComponent(), inputs);
Physics.Simulate(Time.fixedDeltaTime);
++this.tick\_number;
}
}
```
Здесь пока ничего особенного, единственное, на что я хочу обратить внимание — добавление переменной tick\_number. Она нужна, чтобы когда сервер отправляет снэпшоты состояния куба обратно клиенту, мы могли узнать, какому такту клиента соответствует это состояние, чтобы можно было сравнить это состояние с предсказанным клиентом (что мы добавим чуть позже).
```
// server
private void Update()
{
while (this.HasAvailableInputMessages())
{
InputMessage input_msg = this.GetInputMessage();
Rigidbody rigidbody = player.GetComponent();
this.AddForcesToPlayer(rigidbody, input\_msg.inputs);
Physics.Simulate(Time.fixedDeltaTime);
StateMessage state\_msg;
state\_msg.position = rigidbody.position;
state\_msg.rotation = rigidbody.rotation;
state\_msg.velocity = rigidbody.velocity;
state\_msg.angular\_velocity = rigidbody.angularVelocity;
state\_msg.tick\_number = input\_msg.tick\_number + 1;
this.SendToClient(state\_msg);
}
}
```
Всё просто — сервер ждёт сообщений ввода, когда он его получает, то симулирует такт. Затем он берёт снэпшот получившегося состояния куба и отправляет его обратно клиенту. Можно заметить, что tick\_number в сообщении состояния на единицу больше, чем tick\_number в сообщении ввода. Так сделано, потому что лично мне интуитивно более удобно думать о «состоянии игрока в такт 100» как о «состоянии игрока в **начале** такта 100». Поэтому состояние игрока в такте 100 в сочетании с вводом игрока в такте 100 создают новое состояние для игрока в такте 101.
Staten + Inputn = Staten+1
==========================
Я не говорю, что вы должны воспринимать это так же, главное — постоянство подхода.
Также нужно сказать, что я не *отправляю* эти сообщения через реальный сокет, а имитирую его, записывая их в очереди, симулируя задержку и утерю пакетов. Сцена содержит два физических куба — один для клиента, другой для сервера. При обновлении клиентского куба я отключаю GameObject серверного куба, и наоборот.
Однако я не симулирую сетевой дребезг и доставку пакетов в неправильном порядке, и именно поэтому делаю допущение, что каждое получаемое сообщение ввода новее предыдущего. Эта имитация нужна для того, чтобы очень просто выполнять «клиент» и «сервер» в одном инстансе Unity, чтобы мы могли скомбинировать кубы сервера и клиента в одной сцене.
Также можно заметить, что если сообщение ввода сбрасывается и не достигает сервера, то сервер симулирует меньшее количество тактов, чем клиент, а потому будет создавать другое состояние. Это правда, но даже если бы мы симулировали эти пропуски, то ввод всё равно мог быть неверным, что тоже привело бы к другому состоянию. С этой проблемой мы разберёмся позже.
Надо также добавить, что в этом примере есть только один клиент, что упрощает работу. Если бы у нас было несколько клиентов, то нам понадобилось бы а) при вызове Physics.Simulate() проверять, что на сервере включен куб только одного игрока или б) если сервер получил ввод от нескольких кубов, симулировать их все вместе.
*Задержка 75 мс (150 мс в обе стороны)
0% утерянных пакетов
Жёлтый куб — серверный игрок
Синий куб — последний снэпшот, полученный клиентом*
Всё пока выглядит хорошо, но я был немного избирательным с тем, что я фиксировал на видео, чтобы скрыть довольно серьёзную проблему.
### Сбой детерминированности
Посмотрите теперь на это:
*Ой-ёй...*
Это видео было записано без утерь пакетов, тем не менее, симуляции всё равно разнятся при совершенно одинаковом вводе. Я не совсем понимаю, почему так происходит — PhysX должен быть достаточно детерминированным, поэтому я нахожу поразительным то, что симуляции так часто расходятся. Это может быть связано с тем, что я постоянно включаю и отключаю GameObject кубов, то есть возможно, что проблема уменьшится при использовании двух разных инстансов Unity. Это может быть и багом, если вы увидите его в коде на GitHub, то дайте мне знать.
Как бы то ни было, неверные прогнозы — это неотъемлемый факт в прогнозировании на стороне клиента, поэтому давайте с ними справляться.
### Можно сделать перемотку?
Процесс достаточно прост — когда клиент прогнозирует движение, он сохраняет буфер состояния (позицию и поворот) и ввод. После получения сообщения состояния от сервера он сравнивает полученное состояние с прогнозируемым состоянием из буфера. Если они отличаются на слишком большую величину, то мы переопределяем состояние клиентского куба в прошлом, а затем симулируем заново все промежуточные такты.
```
// client
private ClientState[] client_state_buffer = new ClientState[1024];
private Inputs[] client_input_buffer = new Inputs[1024];
private void Update()
{
this.timer += Time.deltaTime;
while (this.timer >= Time.fixedDeltaTime)
{
this.timer -= Time.fixedDeltaTime;
Inputs inputs = this.SampleInputs();
InputMessage input_msg;
input_msg.inputs = inputs;
input_msg.tick_number = this.tick_number;
this.SendToServer(input_msg);
uint buffer_slot = this.tick_number % 1024;
this.client_input_buffer[buffer_slot] = inputs;
this.client_state_buffer[buffer_slot].position = rigidbody.position;
this.client_state_buffer[buffer_slot].rotation = rigidbody.rotation;
this.AddForcesToPlayer(player.GetComponent(), inputs);
Physics.Simulate(Time.fixedDeltaTime);
++this.tick\_number;
}
while (this.HasAvailableStateMessage())
{
StateMessage state\_msg = this.GetStateMessage();
uint buffer\_slot = state\_msg.tick\_number % c\_client\_buffer\_size;
Vector3 position\_error = state\_msg.position - this.client\_state\_buffer[buffer\_slot].position;
if (position\_error.sqrMagnitude > 0.0000001f)
{
// rewind & replay
Rigidbody player\_rigidbody = player.GetComponent();
player\_rigidbody.position = state\_msg.position;
player\_rigidbody.rotation = state\_msg.rotation;
player\_rigidbody.velocity = state\_msg.velocity;
player\_rigidbody.angularVelocity = state\_msg.angular\_velocity;
uint rewind\_tick\_number = state\_msg.tick\_number;
while (rewind\_tick\_number < this.tick\_number)
{
buffer\_slot = rewind\_tick\_number % c\_client\_buffer\_size;
this.client\_input\_buffer[buffer\_slot] = inputs;
this.client\_state\_buffer[buffer\_slot].position = player\_rigidbody.position;
this.client\_state\_buffer[buffer\_slot].rotation = player\_rigidbody.rotation;
this.AddForcesToPlayer(player\_rigidbody, inputs);
Physics.Simulate(Time.fixedDeltaTime);
++rewind\_tick\_number;
}
}
}
}
```
Буферизированные данные ввода и состояние хранятся в очень простом циклическом буфере, где в качестве индекса используется идентификатор такта. И выбрал для тактовой частоты физики значение 64 Гц, то есть буфер на 1024 элементов даёт нам место на 16 секунд, и это значительно больше того, что нам может понадобиться.
*Коррекция включена!*
### Передача избыточного ввода
Сообщения ввода обычно очень малы — нажатые кнопки можно скомбинировать в битовое поле, которое занимает всего несколько байтов. В нашем сообщении ещё есть номер такта, занимающий 4 байта, но мы можем запросто сжать их, воспользовавшись 8-битным значением с переносом (возможно, интервала 0-255 будет слишком мало, мы можем подстраховаться и увеличить его до 9 или 10 бит). Как бы то ни было, эти сообщения имеют достаточно малый размер, и это значит, что мы можем отправлять в каждом сообщении множество данных ввода (на тот случай, если предыдущие данные ввода были утеряны). Как далеко назад нам стоит возвращаться? Ну, клиент знает номер такта последнего сообщения состояния, которое он получил от сервера, поэтому нет смысла возвращаться дальше, чем этот такт. Также нам нужно наложить ограничение на количество избыточных данных ввода, которые отправляются клиентом. В своём демо я этого не делал, но это стоит реализовать в готовом коде.
```
while (this.HasAvailableStateMessage())
{
StateMessage state_msg = this.GetStateMessage();
this.client_last_received_state_tick = state_msg.tick_number;
```
Это простое изменение, клиент просто записывает номер такта последнего полученного сообщения состояния.
```
Inputs inputs = this.SampleInputs();
InputMessage input_msg;
input_msg.start_tick_number = this.client_last_received_state_tick;
input_msg.inputs = new List();
for (uint tick = this.client\_last\_received\_state\_tick; tick <= this.tick\_number; ++tick)
{
input\_msg.inputs.Add(this.client\_input\_buffer[tick % 1024]);
}
this.SendToServer(input\_msg);
```
Сообщение ввода, отправляемое клиентом, теперь содержит список данных ввода, а не только один элемент. Часть с номером такта получает новое значение — теперь это номер такта первого ввода в этом списке.
```
while (this.HasAvailableInputMessages())
{
InputMessage input_msg = this.GetInputMessage();
// message contains an array of inputs, calculate what tick the final one is
uint max_tick = input_msg.start_tick_number + (uint)input_msg.inputs.Count - 1;
// if that tick is greater than or equal to the current tick we're on, then it
// has inputs which are new
if (max_tick >= server_tick_number)
{
// there may be some inputs in the array that we've already had,
// so figure out where to start
uint start_i = server_tick_number > input_msg.start_tick_number ? (server_tick_number - input_msg.start_tick_number) : 0;
// run through all relevant inputs, and step player forward
Rigidbody rigidbody = player.GetComponent();
for (int i = (int)start\_i; i < input\_msg.inputs.Count; ++i)
{
this.AddForcesToPlayer(rigidbody, input\_msg.inputs[i]);
Physics.Simulate(Time.fixedDeltaTime);
}
server\_tick\_number = max\_tick + 1;
}
}
```
Когда сервер получает сообщение ввода, он знает номер такта первого ввода и количество данных ввода в сообщении. Поэтому он может вычислить такт последнего ввода в сообщении. Если этот последний такт больше или равен номеру такта сервера, то он знает, что сообщение содержит хотя бы один ввод, который сервер ещё не видел. Если это так, то он симулирует все новые данные ввода.
Вы могли заметить, что *если* мы ограничим количество избыточных данных ввода в сообщении ввода, то при достаточно большом количестве утерянных сообщений ввода у нас появится пробел симуляции между сервером и клиентом. То есть сервер может симулировать такт 100, отправить сообщение состояния для начала такта 101, а потом получить сообщение ввода, начинающееся с такта 105. В показанном выше коде сервер перейдёт к 105, он не попытается симулировать промежуточные такты на основе последних известных данных ввода. Нужно ли вам это — зависит от вашего решения и от того, какой должна быть игра. Лично я не стал бы заставлять сервер строить догадки и перемещать игрока по карте из-за плохого состояния сети. Я считаю, что лучше оставить игрока на месте, пока соединение не восстановится.
В демо «Zen of Networked Physics» есть функция отправки клиентом «важных ходов», то есть он отправляет избыточные данные ввода только тогда, когда они отличаются от ввода, переданного ранее. Это можно назвать дельта-сжатием ввода, и с помощью него ещё больше уменьшить размер сообщений ввода. Но пока я этого не делал, потому что в этом демо нет никакой оптимизации загрузки сети.
*Перед отправкой избыточных данных ввода: при потере 25% пакетов движение куба медленное и дёрганное, его продолжает отбрасывать назад.*
*После отправки избыточных данных ввода: при потере 25% пакетов по-прежнему есть дёрганная коррекция, но кубы движутся с приемлемой скоростью.*
### Изменяющаяся частота снэпшотов
В этом демо частота, с которой сервер отправляет клиенту снэпшоты, варьируется. При сниженной частоте клиенту понадобится больше времени на получение коррекции от сервера. Поэтому когда клиент ошибается в прогнозе, то до получения сообщения состояния он может отклониться ещё сильнее, что приведёт к более заметной коррекции. При высокой частоте снэпшотов утеря пакетов гораздо менее важна, поэтому клиенту не приходится ждать долго получения следующего снэпшота.
*Частота снэпшотов 64 Гц*
*Частота снэпшотов 16 Гц*
*Частота снэпшотов 2 Гц*
Очевидно, что чем выше частота снэпшотов, тем лучше, поэтому стоит отправлять их как можно чаще. Но это ещё зависит от объёма дополнительного трафика, его стоимости, наличия у вас выделенных серверов, вычислительных затрат серверов, и так далее.
### Сглаживание коррекции
Мы создаём неверные прогнозы и получаем дёрганные коррекции чаще, чем хотелось бы. Не имея должного доступа к интеграции Unity/PhysX, я почти никак не могу отладить эти ошибочные прогнозы. Я говорил это раньше, но повторю ещё раз — если вы найдёте что-то связанное с физикой, в чём я ошибаюсь, то дайте мне знать об этом.
Я обошёл решение этой проблемы, замазав трещины старым добрым сглаживанием! Когда происходит коррекция, клиент просто сглаживает в течение нескольких кадров позицию и поворот игрока по направлению к правильному состоянию. Сам физический куб корректируется мгновенно (он невидим), но у нас есть второй куб только для отображения, который позволяет выполнять сглаживание.
```
Vector3 position_error = state_msg.position - predicted_state.position;
float rotation_error = 1.f - Quaternion.Dot(state_msg.rotation, predicted_state.rotation);
if (position_error.sqrMagnitude > 0.0000001f ||
rotation_error > 0.00001f)
{
Rigidbody player_rigidbody = player.GetComponent();
// capture the current predicted pos for smoothing
Vector3 prev\_pos = player\_rigidbody.position + this.client\_pos\_error;
Quaternion prev\_rot = player\_rigidbody.rotation \* this.client\_rot\_error;
// rewind & replay
player\_rigidbody.position = state\_msg.position;
player\_rigidbody.rotation = state\_msg.rotation;
player\_rigidbody.velocity = state\_msg.velocity;
player\_rigidbody.angularVelocity = state\_msg.angular\_velocity;
uint rewind\_tick\_number = state\_msg.tick\_number;
while (rewind\_tick\_number < this.tick\_number)
{
buffer\_slot = rewind\_tick\_number % c\_client\_buffer\_size;
this.client\_input\_buffer[buffer\_slot] = inputs;
this.client\_state\_buffer[buffer\_slot].position = player\_rigidbody.position;
this.client\_state\_buffer[buffer\_slot].rotation = player\_rigidbody.rotation;
this.AddForcesToPlayer(player\_rigidbody, inputs);
Physics.Simulate(Time.fixedDeltaTime);
++rewind\_tick\_number;
}
// if more than 2ms apart, just snap
if ((prev\_pos - player\_rigidbody.position).sqrMagnitude >= 4.0f)
{
this.client\_pos\_error = Vector3.zero;
this.client\_rot\_error = Quaternion.identity;
}
else
{
this.client\_pos\_error = prev\_pos - player\_rigidbody.position;
this.client\_rot\_error = Quaternion.Inverse(player\_rigidbody.rotation) \* prev\_rot;
}
}
```
Когда возникает ошибочный прогноз, клиент отслеживает разность позиции/поворота после коррекции. Если общее расстояние коррекции позиции больше 2 метров, то куб просто перемещается рывком — сглаживание всё равно выглядело бы плохо, так пусть он хотя бы как можно быстрее вернётся к верному состоянию.
```
this.client_pos_error *= 0.9f;
this.client_rot_error = Quaternion.Slerp(this.client_rot_error, Quaternion.identity, 0.1f);
this.smoothed_client_player.transform.position = player_rigidbody.position + this.client_pos_error;
this.smoothed_client_player.transform.rotation = player_rigidbody.rotation * this.client_rot_error;
```
В каждом кадре клиент выполняет lerp/slerp по направлению к правильной позиции/повороту на 10%, это стандартный степенной подход к усреднению движения. Он зависит от частоты кадров, но для целей нашего демо этого вполне достаточно.
*Задержка 250 мс
Утеря 10% пакетов
Без сглаживания коррекция очень заметна*
*Задержка 250 мс
Утеря 10% пакетов
Со сглаживанием коррекцию заметить гораздо сложнее*
Конечный результат работает довольно хорошо, я хочу создать его версию, которая действительно будет отправлять пакеты, а не имитировать их. Но, по крайней мере, это proof of concept системы прогнозирования на стороне клиента с настоящими физическими объектами в Unity без необходимости использования физических плагинов и тому подобного. | https://habr.com/ru/post/432190/ | null | ru | null |
# Новые функции в репозитории фреймворка: ORM/ActiveRecord
Я хотел бы начать серию статей о развитии движка LiveStreet, а именно его *фреймворковой* части. LiveStreet получил довольно широкую популярность как *блогосоциальный хабраклон*, но за 2 года перерос уже в нечто значительно большее. Особенно с выходом версии 0.4.\*, когда появились широкие [возможности для написания плагинов](http://livestreet.ru/blog/dev_documentation/3531.html) с [функционалом наследования и делегирования](http://livestreet.ru/blog/dev_documentation/4499.html).
Достаточно [большое количество крупных социальных сетей](http://habrahabr.ru/blogs/livestreet/93756/#habracut) уже [построено на LiveStreet](http://livestreetcms.com/showcase) с использованием этих технологий.
В связи с этим у разработчиков появляется необходимость в разработке функционала, модулей и хаков для своих проектов. Внедрение плагинов упростило этот процесс в разы. Мы продолжаем работать в этом направлении: сейчас я расскажу об альфа-версии реализации [ORM](http://ru.wikipedia.org/wiki/ORM)-подхода на основе паттерна [ActiveRecord](http://ru.wikipedia.org/wiki/ActiveRecord), который мы разработали (и продолжаем разрабатывать) в LiveStreet.
##### Что такое ORM (в двух словах)
Идея ORM заключаются в представлении, отображении таблиц базы данных как классов (моделей), а записей из них как объектов этого класса. Основная цель ORM подхода: автоматизировать стандартные рутинные функции ([CRUD](http://en.wikipedia.org/wiki/Create,_read,_update_and_delete)) для работы с данными в базе, избавить от лишней необходимости писать SQL-запросы и формировать ответы.
##### Как было раньше
Раньше при создании модели (*Sample*) нужно было выполнить ряд однообразных действий и написать или скопипастить доброе количество кода. Только по структуре LS нужно было создать 3 больших файла:
**/modules/sample/Sample.class.php** — файл модуля: набор функций для управления моделями: *AddSample(), UpdateSample(), GetSampleById(), GetSampleByBlablabla()* и т.п., каждая из которых в большинстве своем вызывает синоним из маппера (см. дальше) и обрабатывает кэширование.
**/modules/sample/entity/Sample.entity.class.php** — сущность модели, имеет список методов а-ля *getId(), getBlablabla(), setId(), setBlablabla()*;
**/modules/sample/mapper/Sample.mapper.class.php** — sql-маппер модели, который содержит почти те же функции, что и в файле модуля, только с sql-запросами к таблицам.
И все эти методы нужно было прописывать/переписывать вручную каждый раз при создании новой модели. Кроме того нужно было прописывать дополнительные настройки, такие как имя таблицы в базе данных и т.п.
##### Что можно делать теперь
Что дает нам реализация ORM? Фактически — возможность избавится от **~80% процентов однообразного кода**.
Модули, сущности и мапперы, которые наследуют соответствующие ORM-классы автоматически обладают большинством стандартных методов: *get\*(), Add(), Save(), GetBy\*(), GetItemsBy\*(), Delete()* и т.д.
Приведу более подробный, классический пример. Допустим, мы хотим создать модуль «фотоальбом».
1) Сперва создадим таблицы сущностей «Album» *prefix\_album* и «Photo» *prefix\_photo* в базе данных вида:
```
album_id | author_id | album_title
```
и
```
photo_id | album_id | photo_title | photo_img_src
```
2) Создаем файл модуля нашей галереи: **/classes/modules/gallery/Gallery.class.php**:
```
php
class ModuleGallery extends ModuleORM {
public function Init() {
parent::Init();
}
}
?
```
3) Создаем файлы сущностей **/classes/modules/gallery/entity/Album.entity.class.php** и **/classes/modules/gallery/entity/Photo.entity.class.php**:
```
php
class ModuleGallery_EntityAlbum extends EntityORM {}
?
```
и
```
php
class ModuleGallery_EntityPhoto extends EntityORM {}
?
```
4) И… на этом все. Теперь мы можем управлять нашими сущностями через singleton Engine:
```
// Сущность текущего юзера:
$oUserCurrent = Engine::GetInstance()->User_GetUserCurrent();
// или short-alias:
$oUserCurrent = LS::CurUsr();
// создание пустой сущности:
$oAlbum = Engine::GetEntity('ModuleGallery_EntityAlbum');
// или short-alias:
$oAlbum = LS::Ent('Gallery_Album');
// задание свойств модели
$oAlbum->setAutorId($oUserCurrent->getId());
$oAlbum->setTitle('First Album');
// сохранение сущности в таблице `prefix_album`
$oAlbum->Add();
// или
$oAlbum->Save();
// поиск сущности по ключу:
$oAlbum = Engine::GetInstance()->Gallery_GetAlbumByTitle('First Album');
// или short-alias:
$oAlbum = LS::E()->Gallery_GetAlbumByTitle('First Album');
// выборка коллекции (ключевое слово "Items"):
$aPhotos = LS::E()->Gallery_GetPhotoItemsByAlbumId($oAlbum->getId());
// выборка по нескольким параметрам:
$oPhoto = LS::E()->Gallery_GetPhotoByTitleAndAlbumId('Пейзаж',$oAlbum->getId());
// изменение сущностей:
foreach($aPhotos as $oPhoto) {
$oPhoto->setAlbumId(2);
$oPhoto->Save();
}
// и т.д...
```
По нашим прикидкам даже этого небольшого набора хватает для реализации 30%-40% методов (читай — строк кода), описанных в стандартных модулях, сущностях и мапперах старым методом.
Мне кажется… это здорово! :)
##### Что еще?… Отношения (Relations)
Немаловажный элемент в любом веб-приложении это связи (отношения) моделей. Обычно эти связи создаются через базу данных с помощью первичных ключей (primary key) в таблицах.
Вернемся к нашему примеру: очевидно, что фотографии в галерее относятся к альбому, и поэтому не знаю, как вы, а я считаю что было бы круто, чтобы вместо
```
// выборка коллекции (ключевое слово "Items"):
$aPhotos = LS::E()->Gallery_GetPhotoItemsByAlbumId($oAlbum->getId());
```
мы могли бы просто написать…
```
$aPhotos = $oAlbum->getPhotos();
```
Да, было бы определённо круче! Нет проблем :) Чтобы связать сущности нужно просто настроить их отношения с помощью массива *$aRelations* в описании класса сущности.
Вернемся к нашему пока пустующему файлу **/classes/modules/gallery/entity/Album.entity.class.php** и добавим в него такой код:
```
php
class ModuleGallery_EntityAlbum extends EntityORM {
protected $aRelations = array(
'photos' = array(self::RELATION_TYPE_HAS_MANY,'ModuleGallery_EntityPhoto','album_id'),
'author' => array(self::RELATION_TYPE_BELONGS_TO,'ModuleUser_EntityUser','author_id'),
// или короче:
'photos' => array('has_many','Gallery_Photo','album_id'),
'author' => array('belongs_to','User','author_id'),
);
}
?>
```
А для файла **/classes/modules/gallery/entity/Photo.entity.class.php** напишем так:
```
php
class ModuleGallery_EntityPhoto extends EntityORM {
protected $aRelations = array(
'album' = array('belongs_to','Gallery_Album','album_id'),
);
}
?>
```
И все. Теперь мы можем еще проще оперировать с сущностями, **внимание**:
```
$aPhotos = $oAlbum->getPhotos();
$sUserLogin = $aPhotos[0]->getAlbum()->getAuthor()->getLogin();
```
Разберемся с синтаксисом массива *$aRelations*.
Его ключи — имена связанных сущностей, которые потом будет доступны через *get\**. Значения в большинстве случаев также массивы, состоящие из следующих элементов:
* Тип отношения. На настоящих момент доступны типы: *belongs\_to, has\_one, has\_many, many\_to\_many* и *tree*
* Сущность, которую мы цепляем
* Поле в таблице, которое содержит первичный ключ цепляемой или текущей сущности, в зависимости от типа отношений
* Название связующей join-таблицы для типа *many\_to\_many*
##### Что дальше?
На первый раз, думаю пока хватит, в следующей статье я подробнее остановлюсь на описании типов отношений, отдельно расскажу о типе *tree*, который позволяет управлять древовидными структурами; о возможностях автоматической подгрузки связанных сущностей в *GetBy\*()*; а также о дополнительных методах, таких как *GetByFilter(), GetCountItemsBy\*(), GetByArray\*(), Update(), Delete(), Reload(), reload\*()* и других.
##### Зачем это все?
Мы зовем разработчиков. Несмотря на успешный старт, комьюнити фреймворка сейчас находится почти в детском возрасте, а мы прекрасно понимаем, что без хороших людей, без настоящей команды, нам будет гораздо сложнее вывести LiveStreet на международный уровень. Да, а мы к этому и стремимся :)
Я искренне надеюсь, что наши нововведения помогут разработчикам (а также всем остальным: пользователям и стартаперам, копирайтерам и PR-менеджерам, специалистам и инвесторам) заинтересоваться действительно замечательным, молодым и перспективным движком **LiveStreet**.
И, наконец, я хотел бы заранее попросить не затевать холиваров на тему «А у RoR/ZF/Yii ActiveRecord в сторазкруче» и «не парьтесь, поставьте себе Doctrine!» и т.п. Давайте будем оптимистами.
Спасибо за внимание.
С уважением,
Александр Зинчук (Ajaxy). | https://habr.com/ru/post/109571/ | null | ru | null |
# Настройка Sendmail для отправки почты без попадания в Спам
Столкнулся с проблемой: на правильно настроенном сервере Apache с установленными модулями и настроенными доменными записями у провайдера — письма отправленные через функцию mail из скриптов php попадали в спам или не доставлялись вовсе.
Начал разбираться и не смог найти не одной полноценной публикации в рунете, которая раскрывала бы проблему и помогала решить все вопросы.
Вашему вниманию представляю собранный из разных источников, проверенный и используемый способ настройки сервера для правильной отправки писем sendmail.
Система: Ubuntu 20.06
Почтовый сервис: Яндекс
**1. Установка Sendmail**
Если по какой-то причине не был установлен. Произведите базовую установку и настройку
```
sudo apt-get install php-mail
sudo apt-get install sendmail
sudo sendmailconfig
```
**Правим php.ini**
Вместо noreply@site.ru пишем почту на которую будут приходить отчеты (заголовок Return-Path:).
```
sendmail_path = "/usr/sbin/sendmail -t -f noreply@site.ru -i"
```
Заголовок «Return-Path:» является важным заголовком в глазах почтовых сервисов.
Если его не установить, заголовок будет равен примерно такому значению «Return-Path: ».
Очень желательно чтобы значение заголовка всегда совпадало с именем домена с которого отправляется письмо, независимо от значения заголовка «From:», иначе оно может быть отправлено в «Спам» или же отклонено вовсе.
**2. Настройка DNS записей**
Нам необходимо настроить SPF, DMARC, DKIM записи.
Какая за что отвечает расписывать не буду. В рунете огромное количество инструкций.
Если тоже используете какой-либо почтовый сервис, у них свои подробные инструкции по настройке.
На что следует обратить внимание — чтобы в SPF был прописан IP-адрес сервера.
```
v=spf1 ip4:ip_server include:_spf.yandex.net ~all
```
Затем следует запросить у провайдера DNS-хостинга **обратную запись rDNS** (PTR-запись).
Привязать свой домен к ip-адресу сервера.
Как правило провайдер самостоятельно ее устанавливает по запросу.
**4. Изменить hostname**
Установить hostname равный названию нашего домена:
```
sudo hostnamectl set-hostname site.ru
```
**5. Редактировать файл sendmail.mc**
Переходим к файлу /etc/mail/sendmail.mc
Нам необходимо настроить заголовки «Received: from» и «Received: by». Они являются важными при определении уровня доверия к серверу отправляющему электронную почту.
Добавляем следующие строки в конце файла перед MAILER\_DEFINITIONS
```
FEATURE(allmasquerade)
FEATURE(masquerade_envelope)
FEATURE(local_no_masquerade)
MASQUERADE_AS(`site.ru')
```
И в конец файла:
```
define(`MAIL_HUB', `site.ru.')dnl
define(`LOCAL_RELAY', `site.ru.')dnl
```
**6. Проверяем настройки apache и файервола**
```
sudo ufw allow 25
sudo nano /etc/apache2/envvars
```
Ищем строчки и заменяем www-data на текущего пользователя под которым запущен apache
export APACHE\_RUN\_USER=www-data
export APACHE\_RUN\_GROUP=www-data
**7. Обновляем конфигурацию и перезагружаем sendmail**
```
sudo sendmailconfig
sudo service sendmail restart
sudo systemctl restart apache2
``` | https://habr.com/ru/post/564750/ | null | ru | null |
# Список покупок
#### Описание
[](http://habrastorage.org/storage3/39c/547/9d3/39c5479d3712b7873d9dcd471dce7d07.jpg)У меня всегда неожиданно заканчиваются продукты. Казалось, ещё вчера был стратегический запас пива, а сегодня его уже нет. Ну и, конечно, когда обнаруживаешь, что чего-то не хватает, под рукой нет ни телефона, ни записной книжки. Не удивительно, поскольку дело обычно происходит на кухне в самый разгар готовки.
Я решил создать аппарат, который позволит одним нажатием кнопки отметить, чего не хватает. Аппарат передаёт информацию об отсутствующих продуктах на телефон и реагирует, если что-то было куплено.
В этой заметке я бы хотел рассказать о том, как я собрал эту штуку, с какими сложностями столкнулся и как вышел из положения.
#### Демонстрация работы
#### История напоминалки
Я не первый, кто придумал вешать список покупок на стену. Примерно такую же штуку использовали в начале XX века в Америке. Хозяйка отмечала, что кончилось, вставляя колышки в отверстия перед названием продукта. Помощники по кухне покупали необходимое и доставали колышки. Эти напоминалки выглядели примерно так:
Я понял, что мне совершенно необходимо перенести эту идею в XXI век, и я принялся за дело.
#### Архитектура системы
Система состоит из трёх компонентов:
1. Доска с кнопками
2. Сервер, обрабатывающий запросы
3. iOS приложение
При нажатии кнопки доска шлёт запрос на сервер. Сервер сохраняет состояние и использует Apple Push Notifications, чтобы оповестить приложение. Приложение запрашивает состояние с сервера и отправляет туда обновления о купленных продуктах. Каждые 5 минут доска обновляет свое состояние с сервера.
##### Доска с кнопками
Основа системы – микроконтроллер [STM32F051](http://www.st.com/web/catalog/mmc/FM141/SC1169/SS1574/LN7). Я использую именно его из-за простоты подключения и работы.
В качестве Wi-Fi модуля я выбрал [RN-XV WiFly](https://www.sparkfun.com/products/11048). Этот модуль чрезвычайно просто программировать и использовать: всё, что надо, это питание, сброс и UART подключение.
На доске установлено 35 кнопок без фиксации (то есть, кнопка пропускает ток, только пока держишь палец). Каждая кнопка содержит небольшой светодиод.
Я использовал кнопки [TL1265](http://www.mouser.com/ds/2/140/TL1265-26217.pdf). Каждая кнопка подключаласть через отдельный транзистор. Это было необходимо, чтобы не превышать максимальную силу тока регистров сдвига:
[](http://habrastorage.org/storage3/696/72c/ac5/69672cac5fd3870a664b0bef026296ff.png)
Кнопки (и их светодиоды) подключены с использованием регистров сдвига. [74HC165A](http://www.nxp.com/documents/data_sheet/74HC_HCT165.pdf) для считывания состояния кнопок:
[](http://habrastorage.org/storage3/131/3fb/ec6/1313fbec6e91fc0d65cae0feda8cc622.png)
[74HC594](http://www.ti.com/lit/ds/symlink/sn74hc594.pdf) для управления светодиодами:
[](http://habrastorage.org/storage3/8ef/c6e/e69/8efc6ee69c7b9b47d73e240ff5532a3b.png)
К сожалению, бесплатная верия программы Eagle CAD накладывает ограничение на размер одной схемы. Так что пришлось делать несколько небольших схем с кнопками, основной управляющий модуль и связывать всё это проводами:
С другой стороны основной слой выглядит вот так:
Раньше я травил схемы дома, но на этот раз решил заказать в компании [OSH Park](http://oshpark.com). Схемы были изготовлены за 10 дней. К качеству претензий нет:
[](http://habrastorage.org/storage3/fe2/148/680/fe21486800dae462a95b7edf6724acae.jpg)
В доме валялось довольно много старых транзисторов и резисторов, устанавливаемых в сквозное отверстие, почти все ушли на этот проект:
[](http://habrastorage.org/storage3/fe0/cb7/c06/fe0cb7c06bc4ac89c814ae3e75ebae18.jpg)
##### Сервер, обрабатывающий запросы
Пожалуй, это было самой простой частью. Сервер написан на PHP, использует MySQL для хранения состояния и `stream_socket_client('ssl://gateway.sandbox.push.apple.com:2195', ...)` для отсылки Apple Push Notifications.
##### iOS приложение
Тут тоже ничего сложного. Два экрана, один с закончившимися продуктами, другой с полным списком:
[](http://habrastorage.org/storage3/a18/c5d/b53/a18c5db5392543781b5332e65b5a8e00.png)
#### Сборка корпуса
Мне очень нравятся аккуратные корпуса любительских проектов. Основой корпуса для этого проекта послужила обычная фоторамка. Сплошное стекло пришлось заменить вырезанным на заказ прозрачным пластиком:
С надписями дело было сложнее. Мне никак не удавалось либо аккуратно подписать, либо аккуратно вырезать отвестия для кнопок. В результате я нашел, как мне кажется, весьма изящное решение. Используя лазерный резак, я сначала проделал отверстия для кнопок. Потом, на меньшей мощности, вырезал борозды для букв. Я залил борозды, используя перо и белые чернила. Вот процесс работы:
[](http://habrastorage.org/storage3/449/ea4/3b3/449ea43b388cb6d3f11cedf46dc96bdd.jpg)
Таким образом у меня получилось три слоя:
[](http://habrastorage.org/storage3/08c/f30/a69/08cf30a69b3067f72c27d6bb6f49b1d9.jpg)
#### Результат
Вот, что получилось в результате:
[](http://habrastorage.org/storage3/39c/547/9d3/39c5479d3712b7873d9dcd471dce7d07.jpg)
Вот, как это смотрится в комнате:
[](http://habrastorage.org/storage3/f3b/aa0/48d/f3baa048d0e167aa952e9e0250c6fe37.jpg)
Я буду рад ответить на любые вопросы про эту штуку. Также было бы здорово услывать мнения о том, что можно улучшить, на что следует обратить внимание.
В любом случае, теперь я уверен, что с такой штукой стратегический запас пива в моем холодильнике не иссякнет! | https://habr.com/ru/post/202550/ | null | ru | null |
# Знакомимся с Fabric.js. Часть 2-я
*Это вторая часть серии статей об открытой Javascript canvas библиотеке Fabric.js.*
В [первой части](http://habrahabr.ru/post/162367/) этой серии, мы ознакомились с самыми базовыми аспектами canvas библиотеки [Fabric.js](http://fabricjs.com). Мы узнали чем может быть полезна Fabric, рассмотрели её объектную модель и иерархию объектов; увидели что существуют как простые фигуры (прямоугольник, треугольник, круг), так и сложные (SVG). Научились выполнять простые операции над этими объектами.
Ну вот, разобрались с азами, давайте приступать к более интересным вещам!
Анимация
--------
Любая уважающая себя canvas библиотека в наше время включает в себя средства работы с анимацией. Fabric — не исключение. Ведь мы имеем мощную объектную модель и гибкие графические возможности. Было бы грех не уметь это приводить в движение.
Вы наверное помните как менять атрибут у объекта. Просто вызываем метод `set`, передавая соответствующее значение:
```
rect.set('angle', 45);
```
Анимировать объект можно по такому же принципу и с такой же лёгкостью. Каждый объект в Fabric имеет метод `animate` (наследуя от `fabric.Object`) который… анимирует этот объект.
```
rect.animate('angle', 45, {
onChange: canvas.renderAll.bind(canvas)
});
```
Первый аргумент это атрибут который хотим менять. Второй аргумент — финальное значение этого атрибута. Например, если прямоугольник находится под углом -15°, и мы указываем «45», то угол постепенно изменится с -15° до 45°. Ну а последний аргумент — опциональный объект для более детальных настроек (длительность, вызовы, easing, и т.д.)
`animate` кстати имеет очень полезную функциональность — поддержку относительных значений. Например, если нужно подвинуть объект на 100px вправо, то сделать это очень просто:
```
rect.animate('left', '+=100', { onChange: canvas.renderAll.bind(canvas) });
```
По такому же принципу, для поворота объекта на 5 градусов против часовой стрелки:
```
rect.animate('angle', '-=5', { onChange: canvas.renderAll.bind(canvas) });
```
Вы наверняка заметили что мы постоянно указываем вызов «onChange». Разве 3-й аргумент не опциональный? Да, именно так. Дело в том что как раз это вызывание `canvas.renderAll` на каждый кадр анимации позволяет видеть саму анимацию! Mетод `animate` всего лишь изменяет значение атрибута в течении указаного времени, и по определённому алгоритму (easing). `rect.animate('angle', 45)` изменяет значение угла, при этом не перерисовывая экран после каждого изменения. А перерисовка экрана нужна для того чтобы увидеть анимацию.
Ну а почему же `animate` не перерисовывает экран автоматически? Из-за производительности. Ведь на холсте могут находиться сотни или даже тысячи объектов. Было бы довольно ужасно если каждый из объектов перерисовывал экран при изменении. В таком случае лучше использовать например `requestAnimationFrame` для постоянной отрисовки холста, не вызывая `renderAll` для каждого объекта. Однако в большинстве случаев, вы скорее всего будете использовать `canvas.renderAll` как «onChange» вызов.
Возвращаясь к опциям для анимации, что же именно мы можем менять?
* **from**: Позволяет менять начальное значение атрибута для анимации (если не хотим использовать текущее).
* **duration**: Длительность анимации. По умолчанию 500 (ms).
* **onComplete**: Функция для вызова в конце анимации.
* **easing**: Функция easing (смягчение).
Все эти опции более менее очевидны, кроме наверное easing. Давайте посмотрим поближе.
По умолчанию, `animate` используют линейную функцию для смягчения анимации. Если такой вариант не подходит, в Fabric имеется большой набор популярных easing функций (доступных через объект `fabric.util.ease`). Например, вот так можно подвинуть объект направо, при этом отпружинивая в конце:
```
rect.animate('left', 500, {
onChange: canvas.renderAll.bind(canvas),
duration: 1000,
easing: fabric.util.ease.easeOutBounce
});
```
Заметьте что мы используем `fabric.util.ease.easeOutBounce` как опцию смягчения. Есть и другие популярные функции — `easeInCubic`, `easeOutCubic`, `easeInElastic`, `easeOutElastic`, `easeInBounce`, `easeOutExpo`, и т.д.
Вот в принципе и всё что нужно знать о анимации. Теперь можно с лёгкостью делать интересные вещи — менять угол объекта чтобы сделать его вращающимся; анимировать left/top чтобы его двигать; анимировать width/height для увеличения/уменьшения; анимировать opacity для появления/исчезания; и т.д.
Фильтры изображений
-------------------
В первой части этой серии, мы узнали как работать с изображениями в Fabric. Как вы наверное помните, для этого используется `fabric.Image` конструктор, передавая в него ![]() елемент. Также есть метод `fabric.Image.fromURL`, с помощью которого можно создать объект прямо из строки URL. И конечно же эти `fabric.Image` объекты можно кинуть на холст где они отобразятся как и всё остальное.
Работать с изображениями прикольно, а с фильтрами изображений — ещё веселей!
Fabric уже имеет несколько фильтров, а также позволяет легко определять свои. Некоторые фильтры из Fabric вам наверное знакомы — удаление белого фона, перевод в чёрно-белый, негатив или яркость. А некоторые менее популярны — градиентная прозрачность, сепия, шум.
Так как же применить фильтр к изображению? Каждый `fabric.Image` объект имеет «filters» атрибут, который просто является массивом фильтров. Каждый элемент в этом массиве — или один из существующих в Fabric или собственный фильтр.
Ну вот, к примеру, сделаем картинку чёрно-белой:
```
fabric.Image.fromURL('pug.jpg', function(img) {
// добавляем фильтр
img.filters.push(new fabric.Image.filters.Grayscale());
// применяем фильтры и перерисовываем канвас после применения
img.applyFilters(canvas.renderAll.bind(canvas));
// добавляем изображения на холст
canvas.add(img);
});
```
 | https://habr.com/ru/post/167119/ | null | ru | null |
# Создание переиспользуемых пайплайнов для GitLab CI на bash
За последние несколько лет я очень полюбил [GitLab CI](https://docs.gitlab.com/ee/ci/README.html). В основном за его простоту и функциональность. Достаточно просто создать в корне репозитория файл `.gitlab-ci.yml` , добавить туда [несколько строчек кода](https://docs.gitlab.com/ee/ci/quick_start/#create-a-gitlab-ciyml-file) и при следующем коммите запустится пайплайн с набором джобов, которые будут выполнять указанные команды.
А если добавить к этому возможности [include](https://docs.gitlab.com/ee/ci/yaml/#include) и [extends](https://docs.gitlab.com/ee/ci/yaml/#extends), можно делать достаточно интересные вещи: создавать шаблонные джобы и пайплайны, выносить их в отдельные репозитории и повторно использовать в разных проектах без копирования кода.
Но к сожалению, не всё так радужно, как хотелось бы. Инструкция `script` в GitLab CI очень низкоуровневая. Она просто выполняет те команды, которые ей переданы в виде строк. Писать большие скрипты внутри YAML не очень удобно. По мере усложнения логики количество скриптов увеличивается, они перемешиваются с YAML делая конфиги нечитаемыми и усложняя их поддержку.
Мне очень не хватало какого-то механизма, который бы упростил разработку больших скриптов. В результате у меня родился микрофреймворк для разработки GitLab CI, про который я и хочу рассказать в этой статье (на примере простого пайплайна для сборки docker-образов).
Пример: Сборка docker-образов в GitLab
--------------------------------------
Я хочу рассмотреть процесс создания пайплайна на примере простой задачи, которую часто встречал у разных команд: создание базовых docker-образов в GitLab для их повторного использования.
Например, команда пишет микросервисы и хочет для них для всех использовать свой собственный базовый образ с набором предустановленных утилит для отладки.
Или другой пример, команда пишет тесты и хочет используя [services](https://docs.gitlab.com/ee/ci/yaml/#services) прямо в GitLab создавать для них временную базу данных (или очередь, или что-то ещё) используя свой собственный образ.
В целом, создать docker-образ из отдельного докерфайла в GitLab достаточно просто. Например можно сделать это с помощью такого `.gitlab-ci.yml`:
```
services:
- docker:dind
Build:
image: docker
script:
- |
docker login "$CI_REGISTRY" \
--username "$CI_REGISTRY_USER" \
--password "$CI_REGISTRY_PASSWORD"
docker build \
--file "Dockerfile" \
--tag "$CI_REGISTRY/$CI_PROJECT_PATH:$CI_COMMIT_REF_SLUG" .
docker push "$CI_REGISTRY/$CI_PROJECT_PATH:$CI_COMMIT_REF_SLUG"
```
Здесь мы создаём пайплайн с одним джобом `Build`, который на каждый коммит логинится в [GitLab Container Registry](https://docs.gitlab.com/ee/user/packages/container_registry/), собирает образ из файла докерфайла в корне репозитория и пушит полученный образ. В качестве тега образа используется название ветки или тега, где происходит сборка (возможно не самая лучшая схема, но это сделано для примера).
Но предположим, что нам необходимо создать чуть более сложный пайплайн, который будет работать следующим образом:
* В репозитории может находиться несколько докерфайлов, которые будут располагаться в подпапке `dockerfiles`.
* На каждый коммит должен запускаться пайплайн с двумя джобами:
+ `Build All` - будет находить и пересобирать все докерфайлы в подпапке `dockerfiles`. Этот джоб будет ручным (запускается по кнопке из интерфейса).
+ `Build Changed`- будет находить и пересобирать все докерфайлы в подпапке `dockerfiles`, которые были изменены в последнем коммите. Этот джоб будет автоматическим (запускается сразу при коммите) и будет появляться только при изменении файлов.
Подобный пайплайн должен достаточно хорошо работать. Он будет быстро пересобирать все изменённые докерфайлы при каждом коммите. При этом у разработчиков останется возможность вручную пересобрать сразу всё, если это потребуется.
Структура репозитория для такого пайплайна может выглядеть следующим образом:
Содержимое и название докерфайлов особой роли не играет, но в данном случае это докерфайлы для разных версий .NET.
В интерфейсе гитлаба подобный пайплайн может выглядеть следующим образом:
Результатом работы такого пайплайна станет набор docker-образов, которые можно будет найти в Container Registry проекта:
А теперь попробуем создать пайплайн, который бы решал нашу задачу.
Шаг 1: Решение "в лоб"
----------------------
Начнём самого простого и очевидного решения. Мы можем поместить весь код в файл `.gitlab-ci.yml`. В таком случае он будет выглядеть следующим образом:
```
services:
- docker:dind
stages:
- Build
Build All:
stage: Build
image: docker
when: manual
script:
- |
dockerfiles=$(find "dockerfiles" -name "*.Dockerfile" -type f)
docker login "$CI_REGISTRY" \
--username "$CI_REGISTRY_USER" \
--password "$CI_REGISTRY_PASSWORD"
for dockerfile in $dockerfiles; do
path=$(echo "$dockerfile" | sed 's/^dockerfiles\///' | sed 's/\.Dockerfile$//')
tag="$CI_REGISTRY/$CI_PROJECT_PATH/$path:$CI_COMMIT_REF_SLUG"
echo "Building $dockerfile..."
docker build --file "$dockerfile" --tag "$tag" .
echo "Pushing $tag..."
docker push "$tag"
done
Build Changed:
stage: Build
image: docker
only:
changes:
- 'dockerfiles/*.Dockerfile'
- 'dockerfiles/**/*.Dockerfile'
script:
- |
apk update
apk add git # Вообще говоря, так не очень хорошо делать, но для примера можно...
dockerfiles=$(git diff --name-only HEAD HEAD~1 -- 'dockerfiles/***.Dockerfile')
docker login "$CI_REGISTRY" \
--username "$CI_REGISTRY_USER" \
--password "$CI_REGISTRY_PASSWORD"
for dockerfile in $dockerfiles; do
path=$(echo "$dockerfile" | sed 's/^dockerfiles\///' | sed 's/\.Dockerfile$//')
tag="$CI_REGISTRY/$CI_PROJECT_PATH/$path:$CI_COMMIT_REF_SLUG"
echo "Building $dockerfile..."
docker build --file "$dockerfile" --tag "$tag" .
echo "Pushing $tag..."
docker push "$tag"
done
```
Ссылки на проект:
* [Репозиторий (ветка step1)](https://gitlab.com/chakrygin/dockerfiles-example/-/tree/step1)
* [Пайплайн](https://gitlab.com/chakrygin/dockerfiles-example/-/pipelines/303649278)
Здесь мы делаем следующее:
* Создаём джоб `Build All`, который:
+ Запускается вручную, т.к. содержит настройку `when: manual`.
+ Выполняет поиск всех докерфайлов при помощи команды:
- `find "dockerfiles" -name "*.Dockerfile" -type f`
* Создаём джоб `Build Changed`, который:
+ Создаётся только при изменении докерфайлов, т.к. содержит настройку `only:changes`.
+ Выполняет поиск всех докерфайлов, изменённых в последнем коммите при помощи команды:
- `git diff --name-only HEAD HEAD~1 -- 'dockerfiles/***.Dockerfile'`
* В остальном оба джоба работают одинаково, после поиска докерфайлов, они проходят по ним циклом, вырезают из названия каждого докерфайла префикс `dockerfiles/` и суффикс `.Dockerfile`, после чего собирают его и пушат в GitLab Container Registry.
Данный пайплайн работает но есть очевидные проблемы:
* Скрипты обоих джобов практически полностью дублируются (за исключением поиска докерфайлов)
* Скрипты сильно загромождают конфиг, усложняя его понимание.
В этом месте появляется тот микрофреймворк для разработки GitLab CI про который я упоминал в самом начале.
GitLab CI Bootstrap
-------------------
[GitLab CI Bootstrap](https://gitlab.com/chakrygin/bootstrap) - это микрофреймворк для разработки GitLab CI. Его основные цели:
* Разделить описание пайплайна (файл `.gitlab-ci.yml`) и его скрипты (bash или shell), чтобы оставить YAML более декларативным.
* Дать возможность разбивать большие скрипты на более мелкие и подключать одни скрипты к другим, чтобы улучшить структурирование кода и упростить его поддержку.
* Дать возможность выносить скрипты и джобы (со скриптами) в отдельные репозитории, чтобы повторно использовать их в разных проектах.
GitLab CI Bootstrap состоит из одного единственного файла [bootstrap.gitlab-ci.yml](https://gitlab.com/chakrygin/bootstrap/-/blob/master/bootstrap.gitlab-ci.yml), который необходимо подключить в файле `.gitlab-ci.yml` при помощи [include](https://docs.gitlab.com/ee/ci/yaml/#include). Сделать это можно несколькими способами. Проще всего скопировать файл в свой проект и подключить его через [include:local](https://docs.gitlab.com/ee/ci/yaml/#includelocal):
```
include:
- local: 'bootstrap.gitlab-ci.yml'
```
В этом файле находится один единственный скрытый джоб `.bootstrap`, который имеет следующий вид:
```
.bootstrap:
before_script:
- |
...
```
Другие джобы могут расширять джоб `.bootstrap`, используя [extends](https://docs.gitlab.com/ee/ci/yaml/#extends):
```
example:
extends: '.bootstrap'
script:
- '...'
```
В таких джобах будет включаться механизм загрузки скриптов (который описан ниже), который позволяет загружать скрипты из текущего репозитория или из любого другого репозитория внутри того же экземпляра GitLab.
При этом для загрузки скриптов **не нужны** специальные [токены доступа](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html%5C). Загружать скрипты можно даже из **внутреннего** или **приватного** репозиториев. Главное, чтобы у разработчика, запустившего пайплайн был доступ на чтение к этим репозиториям.
Единственным требованием для загрузчика является наличие bash или shell. Также желательно наличие git, однако при его отсутствии он будет установлен автоматически. Благодаря этому джоб `.bootstrap` можно использовать [практически с любыми официальными docker-образами](https://hub.docker.com/search?q=&type=image&image_filter=official) и он будет там корректно работать.
Итак, давайте посмотрим, как это поможет нам упростить наш пайплайн для сборки docker-образов.
### Шаг 2: Выносим все скрипты в отдельный файл
Все джобы, использующие джоб `.bootstrap` автоматически проверяют наличие в репозитории специального файла `.gitlab-ci.sh`. При его наличии этот файл автоматически загружается и все переменные и функции, которые в нём определены становятся доступными на этапе выполнения скриптов джоба.
Поэтому мы можем вынести все скрипты в этот файл и разбить их на функции, чтобы избежать дублирования, а затем вызвать эти функции из файла `.gitlab-ci.yml`:
Файл `.gitlab-ci.yml`:
```
include:
- project: '$CI_PROJECT_NAMESPACE/bootstrap'
ref: 'master'
file: 'bootstrap.gitlab-ci.yml'
services:
- docker:dind
stages:
- Build
Build All:
stage: Build
image: docker
extends: .bootstrap
when: manual
script:
- search_all_dockerfiles_task
- build_and_push_dockerfiles_task
Build Changed:
stage: Build
image: docker
extends: .bootstrap
only:
changes:
- 'dockerfiles/*.Dockerfile'
- 'dockerfiles/**/*.Dockerfile'
script:
- install_git_task
- search_changed_dockerfiles_task
- build_and_push_dockerfiles_task
```
Файл `.gitlab-ci.sh`:
```
DOCKERFILES=""
function search_all_dockerfiles_task() {
DOCKERFILES=$(find "dockerfiles" -name "*.Dockerfile" -type f)
}
function search_changed_dockerfiles_task() {
DOCKERFILES=$(git diff --name-only HEAD HEAD~1 -- 'dockerfiles/***.Dockerfile')
}
function install_git_task() {
# Вообще говоря, так не очень хорошо делать, но для примера можно...
apk update
apk add git
}
function build_and_push_dockerfiles_task() {
docker login "$CI_REGISTRY" \
--username "$CI_REGISTRY_USER" \
--password "$CI_REGISTRY_PASSWORD"
for dockerfile in $DOCKERFILES; do
path=$(echo "$dockerfile" | sed 's/^dockerfiles\///' | sed 's/\.Dockerfile$//')
tag="$CI_REGISTRY/$CI_PROJECT_PATH/$path:$CI_COMMIT_REF_SLUG"
echo "Building $dockerfile..."
docker build --file "$dockerfile" --tag "$tag" .
echo "Pushing $tag..."
docker push "$tag"
done
}
```
Ссылки на проект:
* Репозиторий (ветка step2): <https://gitlab.com/chakrygin/dockerfiles-example/-/tree/step2>
* Пайплайн: <https://gitlab.com/chakrygin/dockerfiles-example/-/pipelines/303676828>
Теперь все скрипты у нас вынесены в отдельный файл `gitlab-ci.sh` и разбиты на функции, которые вызываются из файла `.gitlab-ci.yml`. Функции `search_all_dockerfiles_task` и `search_changed_dockerfiles_task` заполняют переменную `DOCKERFILES`, которая позже используется функцией `build_and_push_dockerfiles_task` для сборки докерфайлов.
Шаг 3: Переносим пайплайн в отдельный репозиторий
-------------------------------------------------
Мы сделали работающий пайплайн и вынесли его скрипты в отдельный файл, но пока этот пайплайн находится в том же репозитории, что и докерфайлы. Это означает, что если другая команда захочет использовать его для сборки своих докерфайлов, им придётся скопировать все скрипты. А это в свою очередь означает, что если нам необходимо будет внести в пайплайн какие-нибудь изменения, то потом их нужно будет внести и всем командам, которые скопировали себе пайплайн.
Вместо этого мы можем вынести пайплайн в отельный репозиторий и предложить нескольким командам подключить его через [include](https://docs.gitlab.com/ee/ci/yaml/#include).
Однако для этого придётся внести в пайплайн небольшое изменение. Дело в том, что поскольку скрипты теперь будут фактически расположены не в том же репозитории, где запускается пайплайн, джоб должен как-то это понять и определить, откуда загрузить скрипты. Это делается при помощи специальных переменных, которые добавляются в пайплайн.
Если в джобе, использующей джоб `.bootstrap` определена переменная `CI_IMPORT`, то этот джоб проверит наличие трёх переменных: `CI_{module}_PROJECT`, `CI_{module}_REF` и `CI_{module}_FILE`, где `{module}` - это нормализованное значение переменной `CI_IMPORT` (приведённое в верхнему регистру с заменой дефисов на подчёркивания).
Если все три переменные существуют, джоб перед загрузкой скриптов из файла `.gitlab-ci.sh` сначала загрузит файл, указанный в этих переменных.
Наш репозиторий с докерфайлами теперь будет выглядеть так:
Файл `.gitlab-ci.yml`:
```
include:
- project: '$CI_PROJECT_NAMESPACE/dockerfiles-example-ci'
ref: 'step3'
file: 'dockerfiles.gitlab-ci.yml'
```
Сам пайплайн в отдельном репозитории будет выглядеть следующим образом:
Файл `dockerfiles.gitlab-ci.yml` (сюда перенесён код из `.gitlab-ci.yml`):
```
include:
- project: '$CI_PROJECT_NAMESPACE/bootstrap'
ref: 'master'
file: 'bootstrap.gitlab-ci.yml'
services:
- docker:dind
stages:
- Build
variables:
CI_DOCKERFILES_PROJECT: '$CI_PROJECT_NAMESPACE/dockerfiles-example-ci'
CI_DOCKERFILES_REF: 'step3'
CI_DOCKERFILES_FILE: 'dockerfiles.gitlab-ci.sh'
Build All:
stage: Build
image: docker
extends: .bootstrap
variables:
CI_IMPORT: dockerfiles
when: manual
script:
- search_all_dockerfiles_task
- build_and_push_dockerfiles_task
Build Changed:
stage: Build
image: docker
extends: .bootstrap
variables:
CI_IMPORT: dockerfiles
only:
changes:
- 'dockerfiles/*.Dockerfile'
- 'dockerfiles/**/*.Dockerfile'
script:
- search_changed_dockerfiles_task
- build_and_push_dockerfiles_task
```
Файл `dockerfiles.gitlab-ci.sh` (сюда перенесён код из `.gitlab-ci.sh`):
```
DOCKERFILES=""
function search_all_dockerfiles_task() {
DOCKERFILES=$(find "dockerfiles" -name "*.Dockerfile" -type f)
}
function search_changed_dockerfiles_task() {
DOCKERFILES=$(git diff --name-only HEAD HEAD~1 -- 'dockerfiles/***.Dockerfile')
}
function build_and_push_dockerfiles_task() {
docker login "$CI_REGISTRY" \
--username "$CI_REGISTRY_USER" \
--password "$CI_REGISTRY_PASSWORD"
for dockerfile in $DOCKERFILES; do
path=$(echo "$dockerfile" | sed 's/^dockerfiles\///' | sed 's/\.Dockerfile$//')
tag="$CI_REGISTRY/$CI_PROJECT_PATH/$path:$CI_COMMIT_REF_SLUG"
echo "Building $dockerfile..."
docker build --file "$dockerfile" --tag "$tag" .
echo "Pushing $tag..."
docker push "$tag"
done
}
```
Ссылки на проект:
* Репозиторий с докерфайлами (ветка step3): <https://gitlab.com/chakrygin/dockerfiles-example/-/tree/step3>
* Репозиторий с пайплайном (ветка step3): <https://gitlab.com/chakrygin/dockerfiles-example-ci/-/tree/step3>
* Пайплайн: <https://gitlab.com/chakrygin/dockerfiles-example/-/pipelines/303702906>
Оба наших джоба `Build All` и `Build Changed` содержат переменную `CI_IMPORT` со значением `dockerfiles`. Поэтому загрузчик при старте джоба также проверит наличие трёх переменых: `CI_DOCKERFILES_PROJECT`, `CI_DOCKERFILES_REF` и `CI_DOCKERFILES_FILE`, которые также определены в пайплайне.
Благодаря этим переменным загрузчик понимает, что должен загрузить скрипты из файла `dockerfiles.gitlab-ci.sh`, который находится в репозитории `$CI_PROJECT_NAMESPACE/dockerfiles-example-ci`, в ветке `step3`.
Кроме того, мы убрали из скриптов функцию `install_git_task`. Явная установка git больше не нужна, т.к. загрузчик сам по себе требует git для загрузки скриптов из другого репозитория и поэтому устанавливает git самостоятельно.
Шаг 4: Разбиваем большие скрипты на отдельные файлы
---------------------------------------------------
Мы вынесли пайплайн в отдельный репозиторий и теперь другие команды могут подключать его в свои проекты простым инклюдом. Изменения, которые мы будем вносить в пайплайн будут автоматически отражаться на всех командах и нам не придётся ходить по командам с просьбами обновиться на последнюю версию.
Однако сейчас все скрипты у нас находятся в одном файле `dockerfiles.gitlab-ci.sh`. По мере добавления функциональности, количество кода в нём будет расти и ориентироваться в нём будет всё сложнее и сложнее.
К счастью, если в процессе загрузки скрипта в нём встречается вызов функции `include`, файл, указанный в аргументе этой функции также загружается. При этом не важно, в каком репозитории находится загружаемый скрипт. Функция `include` всегда загружет файл из **того же репозитория**, из которого она вызвана.
Также хочу отметить, что эта функция всегда загружает каждый файл только один раз, даже если вызов функции `include` с этим файлом встретится несколько раз.
Поэтому мы можем разбить наш файл `dockerfiles.gitlab-ci.sh` на несколько более мелких:
Файл `dockerfiles.gitlab-ci.sh`:
```
include "tasks/search.sh"
include "tasks/docker.sh"
```
Файл `tasks/search.sh`:
```
DOCKERFILES=""
function search_all_dockerfiles_task() {
DOCKERFILES=$(find "dockerfiles" -name "*.Dockerfile" -type f)
}
function search_changed_dockerfiles_task() {
DOCKERFILES=$(git diff --name-only HEAD HEAD~1 -- 'dockerfiles/***.Dockerfile')
}
```
Файл `tasks/docker.sh`:
```
function build_and_push_dockerfiles_task() {
docker login "$CI_REGISTRY" \
--username "$CI_REGISTRY_USER" \
--password "$CI_REGISTRY_PASSWORD"
for dockerfile in $DOCKERFILES; do
path=$(echo "$dockerfile" | sed 's/^dockerfiles\///' | sed 's/\.Dockerfile$//')
tag="$CI_REGISTRY/$CI_PROJECT_PATH/$path:$CI_COMMIT_REF_SLUG"
echo "Building $dockerfile..."
docker build --file "$dockerfile" --tag "$tag" .
echo "Pushing $tag..."
docker push "$tag"
done
}
```
Ссылки на проект:
* Репозиторий с докерфайлами (ветка step4): <https://gitlab.com/chakrygin/dockerfiles-example/-/tree/step4>
* Репозиторий с пайплайном (ветка step4): <https://gitlab.com/chakrygin/dockerfiles-example-ci/-/tree/step4>
* Пайплайн: <https://gitlab.com/chakrygin/dockerfiles-example/-/pipelines/303704359>
Заключение
----------
В данной статье мы прошли по шагам создания переиспользуемого пайплайна для GitLab CI с использованием bash и [GitLab CI Bootstrap](https://gitlab.com/chakrygin/bootstrap).
Чтобы не увеличивать статью я описал только самые основные возможности своего микрофреймворка. Кроме этого он также позволяет:
* Подключать скрипты из нескольких репозиториев по цепочке. Т.е. общий пайплайн, вынесенный в отдельный репозиторий сам по себе может также подключать скрипты из ещё нескольких репозиториев. Это создаёт большой простор для создания целых библиотек для GitLab CI.
* Получать доступ к произвольным файлам в подключаемом репозитории. Это можно использовать для написания скриптов на других языках, таких как Python или C#.
* Делать хуки на определённые функции. Это позволяет разработчикам, использующим общий пайплайн расширять его логику при необходимости.
Если нужно, я могу рассказать про эти возможности в комментариях.
Я пока не могу сказать, что мой микрофреймворк близок к версии 1.0. Ещё есть вещи, над которыми стоит поработать. Тем не менее, ранние его версии я успешно использовал в нескольких проектах и это действительно сильно упростило мне разработку.
Исходники: можно найти тут: <https://gitlab.com/chakrygin/bootstrap>
Репозитории с примерами тут:
* <https://gitlab.com/chakrygin/dockerfiles-example>
* <https://gitlab.com/chakrygin/dockerfiles-example-ci> | https://habr.com/ru/post/557682/ | null | ru | null |
# Работа с квалифицированными сертификатами в свете новой редакции Приказа №795 ФСБ РФ от 21.01.2021. Часть II
После опубликования [статьи](https://habr.com/ru/post/588681), посвящённой требованиям Приказа №795 ФСБ России [в редакции](https://ucparma.ru/files/%D0%9F%D1%80%D0%B8%D0%BA%D0%B0%D0%B7%20%D0%A4%D0%A1%D0%91%20%D0%A0%D0%BE%D1%81%D1%81%D0%B8%D0%B8%20%D0%BE%D1%82%2027.12.2011%20N%20795%20(%D1%80%D0%B5%D0%B4.%20%D0%BE%D1%82%2029.01.2021).rtf) от 29 января 2021 года, меня не покидало чувство её незавершённости. Это чувство было связано с тем, что в статье ни слова не было сказано про утилиту CAFL63, которая позволяет разворачивать удостоверяющие центры. И естественным является то, что её тоже необходимо привести в соответствие с новыми требованиями. На эту незавершённость обратили внимание и [читатели](https://habr.com/ru/post/588681/#comment_23717139):
> Планируется ли доработка утилиты CAFL63 для создания удостоверяющих центров в свете последних изменений, про которые вы говорите в статье
И такая доработка утилиты [CAFL63](https://habr.com/ru/post/413493/) была проведена. Доработанную утилиту для разных платформ можно скачать здесь:
**Доработанную утилиту для разных платформ можно скачать здесь:**
* [OS X](https://github.com/a513/CAFL63/raw/master/distr/CAFL63_mac.tar.bz2)
* [Linux64](https://github.com/a513/CAFL63/raw/master/distr/CAFL63_linux64.tar.bz2)
* [Linux32](https://github.com/a513/CAFL63/raw/master/distr/CAFL63_linux32.tar.bz2)
* [Win64](https://github.com/a513/CAFL63/raw/master/distr/CAFL63_setup_win64.exe)
* [Win32](https://github.com/a513/CAFL63/raw/master/distr/CAFL63_setup_win32.exe)
Напомним, что утилита CAFL63 позволяет избавиться от большого многообразия файлов, с которыми работает программа openssl, и перейти к работе с базами данных, а также даёт графический интерфейс для выпуска сертификатов и управления ими.
Поскольку утилита CAFL63 написана на tcl/tk, то основные изменения, с точки зрения просмотра сертификатов выпущенных по новым требованиям, аналогичны изменениям, сделанным в утилите [cryptoarmpkcs](https://habr.com/ru/post/588681/#armpkcs). Это касается и включения новых oid-ов в пакет pki и функции разбора расширения identificationKind.
Более серьёзная проблема связана с выпуском самих сертификатов, поскольку здесь задействуется утилита openssl или утилита, сделанная на её основе.
Расширение identificationKind без проблем можно добавить для новых сертификатов через секцию расширений cert\_ext (параметр –extentions cert\_ext) конфигурационного файла config.cfg (параметр –config config.cfg):
```
openssl x509 -req -inform PEM -outform PEM -CA rootca.pem -CAkey rootca.key -passin pass:01234567 -extfile config.cfg -extensions cert_ext -days 366 -set_serial 4100 –in req.csr
```
Эта команда предписывает утилите openssl создать сертификат из запроса (x509 -req), находящего в файле req.csr (*-in req.csr)*, добавив в сертификат расширения из секции cert\_ext (*-extensions cert\_ext*) конфигурационного файла config.cfg (*-extfile config.cfg*)
Если мы хотим указать, что идентификация владельца сертификата проводилась в его личном присутствии, то в секции cert\_ext будет записан код:
```
[cert_ext]
1.2.643.100.114 = DER:02:01:00
```
Такая запись в конфигурационном файле приведет к появлению в сертификате информации о том, что владелец сертификата лично приходил в удостоверяющий центр для получения сертификата.
Если для идентификации использовалась электронная подпись на действующем сертификате, то код будет следующим:
```
OID.1.2.643.100.114 = DER:02:01:01
```
И т.д.
Хотелось, чтобы и атрибут INNLE (oid — 1.2.643.100.4) для юридических лиц можно было бы также легко добавлять в запрос и сертификат. И на первый взгляд это так, вместо имени INNLE будем задействовать его oid в секции req\_distinguished\_name при создании запроса:
```
[ req ]
distinguished_name = req_distinguished_name
. . .
[ req_distinguished_name ]
C = RU
ST = Московская область
O = Тест юридического лица
CN = urlitzo
#INNLE = 8765432109
#Атрибут INNLE имеет oid 1.2.643.100.4
#OID.1.2.643.100.4 = <10 цифр INNLE>
OID.1.2.643.100.4 = 8765432109
emailAddress = ul@ul.ca
```
После внесения этих изменений в конфигурационный файл config.cfg и выполнения команды:
```
openssl req -new -utf8 -config config.cfg -key urlitzo.key -passin pass:01234567 -outform PEM
```
мы получаем запрос с атрибутом INNLE (для просмотра мы использовали утилиту cryptoarmpkcs):
И на первый взгляд всё хорошо, но если посмотреть asn1-структуру запроса, то окажется что атрибут INNLE имеет тип кодирования UTF8:
Это противоречит новым требованиям, в которых для INNLE определён другой тип кодирования:
> INNLE (ИНН юридического лица).
>
>
>
> Значением атрибута INNLE является строка, состоящая из 10 цифр и представляющая ИНН владельца квалифицированного сертификата — юридического лица. Объектный идентификатор типа атрибута INNLE имеет вид 1.2.643.100.4, тип атрибута INNLE описывается следующим образом:
>
>
>
> INNLE::= NUMERIC STRING SIZE 10;
>
>
В итоге становится ясным, что требуется внесение изменений в основной код проекта openssl для поддержки в нём новых oid-ов и в первую очередь INNLE и OGRNIP. Тем более, что oid-ы INN и OGRN в проект openssl уже внесены.
Исходя из этих реалий, было решено добавить в проект CAFL63 встроенный модуль openssl, который доработан с учетом Приказа №795 ФСБ России в редакции от 29.01.2021 года. Это позволяет использовать утилиту CAFL63 для развёртывания учебного или корпоративного удостоверяющего центра независимо от наличия у пользователя openssl с поддержкой последних требований.
Начав работу с утилитой CAFL63 с нажатия кнопки «Создать БД», пользователь, пройдя несколько шагов, попадёт на вкладку выбора модуля OpenSSL:
Здесь можно либо выбрать собственный модуль openssl, либо ввести текст «internalModule» для использования встроенного модуля. Оставляем internalModule и нажимаем кнопку «След>»:
После создания базы данных УЦ начинаем работу на УЦ с нажатия кнопки «Открыть БД». После открытия базы данных следует настроить шаблоны для сертификатов которые будут выпускаться на УЦ (Средства → Настройки → Типы сертификатов → Юридическое лицо → Редактировать):
И начнём мы, как вы уже догадались, с профиля сертификатов для юридических лиц:
Этот механизм позволяет редактировать существующие профили и создавать новые. Для каждого профиля (вкладка «KeyPair») указывается тип ключ, который будет создаваться при генерации запроса. Для генерации ключей помимо утилиты openssl могут используются и криптографические [токены PKCS#11](https://habr.com/ru/post/400943/) с поддержкой российской криптографии. В этом случае указывается библиотека для доступа к токенам:
Получить сертификат на УЦ CAFL63 пользователь может одним из двух способов.
Первый: прийти на УЦ с готовым запросом в формате PKCS#10, в котором содержатся все необходимые о нём сведения, подписанные его закрытым ключом. Это самый безопасный способ. Сотрудники УЦ в этом случае никак не пересекаются с закрытым ключом заявителя. В будущем им нельзя будет предъявить никаких претензий, что они могли что-то подписать за владельца сертификата. В этом случае запрос пользователя импортируется в систему и помечается как созданный пользователем за пределами УЦ:
Во втором случае запрос создается на УЦ. При его создании, помимо выбора профиля сертификата, будет предложено определиться с механизмом генерации закрытого ключа. Для генерации ключа может быть использован как токен PKCS#11, так и утилита openssl:
Первый из этих вариантов более предпочтителен, тем более, если токен не позволяет экспортировать закрытые ключи.
При генерации закрытого ключа утилитой openssl он вместе с сертификатом упаковывается в защищенный контейнер PKCS#12 и передаётся заявителю. В последнем случае заявитель должен как-то удостовериться, что на УЦ не осталось дубликата ключа.
Перед выпуском сертификата запрос должен пройти процедуру утверждения. Для этого необходимо выделить запрос и нажать правую кнопку мыши. В появившемся меню выбрать пункт «Принятие решения»:
После утверждения запроса можно выпускать сертификат. В процессе выпуска сертификата будет предложено еще раз просмотреть запрос, а также указать способ идентификации заявителя:
Это последнее требование из новой редакции Приказа №795, реализация которого была добавлена в утилиту CAFL63.
После нужно перейти на вкладку «Сертификаты», где проводится основная работа с сертификатами, и выгрузить сертификат заявители. Сертификат передается либо просто как файл, если заявитель пришёл с готовым запросом. Если заявитель использовал при генерации токен PKCS#11, то вместе с сертификатом ему передаётся и сам токен. При генерации ключевой пары модулем openssl, пользователю передаётся защищенный контейнер PKCS#12, в котором находится и сам ключ, и сертификат пользователя и корневой сертификат УЦ:
Скоро будем отмечать 10-летний Юбилей Приказа ФСБ России от 27.12.2011 №795. И ждём новой редакции. | https://habr.com/ru/post/591369/ | null | ru | null |
# L-Systems — математическая красота растений
Красота растений привлекала внимание математиков веками. Активнее всего изучались интересные геометрические свойства растений, такие как симметрия листьев относительно центральной оси, радиальная симметрия цветов, и спиральное расположение семечек в шишках. «Красота связана с симметрией» (H. Weyl. Symmetry). Во время роста живых организмов, особенно растений, можно четко видеть регулярно повторяющиеся многоклеточные структуры. В случае составных листьев, например, маленькие листочки, которые являются частью большого взрослого листа, имеют ту же форму, что весь лист имел на раннем этапе формирования.
В 1968г. Венгерский биолог и ботаник Аристид Линденмайер (Aristid Lindenmayer) предложил математическую модель для изучения развития простых многоклеточных организмов, которая позже была расширена и используется для моделирования сложных ветвящихся структур — разнообразных деревьев и цветов. Эта модель получила название Lindenmayer System, или просто L-System.
*Для тех, кто в теме и не хочет все читать целиком, проскрольте вниз, есть вопрос.*
Я буду сокращать L-System до L в тексте.
### Rewriting.
Основная идея L — постоянная перезапись (rewriting) элементов строки. О чем это? Вкратце, rewriting — это способ получения сложных объектов путем замены частей простого начального объекта по некоторым правилам. Классическим примером является снежинка. На рисунке initiator — это начальный объект, грани которого заменяются на generator. Далее с новым объектом проделывается то же самое. В данном случае обычный фрактал.
Возвращаясь к L и проводя аналогию с фракталами, можно сказать, что L оперирует со строкой символов по специальным правилам, начиная с первоначальной простой аксиомы. Люди, знакомые с понятием грамматики, сразу заметят, что по сути L ей и является. Но фундаментальное отличие L от [формальных грамматик](http://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%80%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0) состоит в том, что правила применяются одновременно ко всей строке, к каждому символу, плюс, нет понятий терминальных и нетерминальных символов. То есть «вывод» по этой грамматике может продолжаться бесконечно. Одновременность применения правил очень быстро становится понятна, если учесть откуда пришла эта модель. В биологии каждая клетка растет, делится и развивается параллельно во времени. На следующей картинке видно соотношение между контекстносвободными (OL), контекстнозависимыми (IL) L и другими формальными грамматиками в [иерархии Хомского](http://ru.wikipedia.org/wiki/%D0%98%D0%B5%D1%80%D0%B0%D1%80%D1%85%D0%B8%D1%8F_%D0%A5%D0%BE%D0%BC%D1%81%D0%BA%D0%BE%D0%B3%D0%BE).
### Самые простые L-Systems.
Также, как и в классификации Хомского, L имеют и свою классификацию от простых до сложных и мощных.
Самым простым примером являются детерминированные контекстносвободные L или сокращенно DOL. Я не люблю формальные определения грамматик, так что скажу просто своими словами. Есть некоторый набор символов — алфавит. Этим алфавитом записывается строка, с которой работает L. Есть аксиома — первоначальная строка из одной или более буквы и набор правил вида a → ab. Во время каждой итерации алгоритма, применяя правило к букве из текущей строки, она (буква) заменяется на набор букв справа от стрелки. Проще рассмотреть конкретный пример развития многоклеточного организма Anabaena catenula, который изучал Линденмайер, когда он предложил модель L.
Пусть наш алфавит состоит из следующих символов, каждый из которых обозначает некоторую клетку: al ar bl br.
Аксиома состоит из одного символа.
*ω: ar*
И 4 правила.
*p1: ar → albr
p2: al → blar
p3: br → ar
p4: bl → al*
Правила говорят какие символы меняются на какие в процессе роста организма. На картинке видно как применяя правила мы наблюдаем «деление» клеток и развитие.
### Черепашья интерпретация строк.
Пока мы видели как нарисовать одномерную бактерию, но с помощью известного детского языка программирования [LOGO](http://ru.wikipedia.org/wiki/%D0%9B%D0%BE%D0%B3%D0%BE_(%D1%8F%D0%B7%D1%8B%D0%BA_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)), в котором предлагается управлять черепашкой и рисовать фигуры на экране, можно будет уже рисовать двумерные и трехмерные фракталы и повторяющиеся структуры. Как? Все просто. Берем алфавит, в котором каждый символ означает некоторую команду для двумерной или трехмерной черепашки:
* F — продвинуться вперед и нарисовать линию
* f — продвинуться вперед ничего не рисуя
* + — повернуть влево
* — — повернуть вправо
* & — повернуть вниз
* ^ — повернуть вверх
* \ — наклониться влево
* / — наклониться вправо
* | — развернуться на 180 градусов
Эти команды используют дефолтные значения угла поворота δ, длины шага и базисные векторы двумерного и трехмерного пространства. Примеры двумерных фракталов и порождающих их L можно увидеть на следующей картинке.
### Растения и ветвящиеся структуры.
Все, что было до этого является, в общем-то, непрерывными кривыми. Разумеется, таким образом весьма трудно смоделировать растения с их ветвящейся топологией. Для этого в алфавит были добавлены символы [ и ], которые обозначают начало и конец ветвления соответственно. Когда черепашка встречает символ [, ее текущее состояние пишется в стек и вытаскивается оттуда при встрече символа ].
Уже такой простой грамматикой можно сгенерировать довольно интересные двумерные и трехмерные объекты похожие на деревья.
### Более сложные грамматики.
Разумеется, наука не стояла на месте, и сейчас мы имеем солидную иерархию L начиная с простых DOL рассмотренных ранее.
**Стохастические L.**
Стохастические L добавляют возможность задания вероятности выполнения того или иного правила, и в общем случае не являются детерминированными, ибо разные правила могут иметь один и тот же символ слева. Это вносит некоторый элемент случайности в получающиеся структуры.
**Контекстнозависимые L.**
Также, как и контекстнозависимость в формальных граматиках, в L синтаксис правил усложняется и принимает во внимание окружение заменяемого символа.
**Парамметрические L.**
К каждому символу добавляется параметр-переменная (возможно не одна), которая позволяет, например указывать величину угла поворота для + и -, длину шага и толщину линии, проверять условия для применения правила, считать количество итераций и передавать «сигналы» вперед и назад. Пример парамметрической L.
`ω : B(2)A(4, 4)
p1 : A(x, y) :y <= 3 → A(x ∗ 2, x + y)
p2 : A(x, y) :y > 3 → B(x)A(x/y, 0)
p3 : B(x) :x < 1 → C
p4 : B(x) :x >= 1 → B(x − 1)`
Парамметрические контекстнозависимые L позволяют моделировать рост многоклеточных организмов и растений с учетом биохимических процессов и окружающей среды. Например, наша старая знакомая Anabaena catenula в более сложной форме. Пример из книжки [1].
Как написано в книге, данная бактерия состоит из двух видов клеток: вегетативные клетки и [гетероцисты](http://ru.wikipedia.org/wiki/%D0%93%D0%B5%D1%82%D0%B5%D1%80%D0%BE%D1%86%D0%B8%D1%81%D1%82%D1%8B). Обычно, вегетативные клетки делятся на две подобные вегетативные клетки. Однако, в некоторых случаях вегетативные клетки превращаются в гетероцистов. Их распределение следует хорошо наблюдаемому шаблону, в котором соседние гетероцисты разделены примерно одинаковым числом вегетативных клеток. Но как же организм поддерживает постоянное расстояние между гетероцистами во время роста? Предложенная модель описывает этот феномен с точки зрения биологии. Предполагается, что расположение гетероцистов регулируется соединениями азота, производимые этими клетками, которые передаются в другие клетки организма и потребляются в вегетативных клетках. Если содержание этих соединений в молодй вегетативной клетке падает ниже определенного уровня, эта клетка превращается в гетероцист.
L-System ниже моделирует рост бактерии с учетом вышесказанного.
#define присваивает значения константам используемым в L.
#include загружает форму гетероциста, в данном случае круг.
Клетки представлены модулем F(s, t, c), где s — длина клетки, t — тип клетки (0 — гетероцист, 1 и 2 — вегетативные клетки), а c — концентрация азота.
`#define CH 900 /* high concentration */
#define CT 0.4 /* concentration threshold */
#define ST 3.9 /* segment size threshold */
#include H /* heterocyst shape specification */
#ignore f ∼ H
ω : -(90)F(0,0,CH)F(4,1,CH)F(0,0,CH)
p1 : F(s,t,c) : t=1 & s>=6 → F(s/3*2,2,c)f(1)F(s/3,1,c)
p2 : F(s,t,c) : t=2 & s>=6 → F(s/3,2,c)f(1)F(s/3*2,1,c)
p3 : F(h,i,k) < F(s,t,c) > F(o,p,r) : s>ST|c>CT → F(s+.1,t,c+0.25*(k+r-3*c))
p4 : F(h,i,k) < F(s,t,c) > F(o,p,r) : !(s>ST|c>CT) → F(0,0,CH) ∼ H(1)
p5 : H(s) : s<3 → H(s*1.1)`
### Гипножаба.
Вот, например, недавняя гипножаба, покорившая интернет, по сути является комбинацией простейших L.
`#define R 1.456
ω : A(1)
p1 : A(s) → F(s)[+A(s/R)][−A(s/R)]`
### Более advanced.
Это всего лишь поверхностное описание теории и небольшие примеры применения на практике. Что ждет любопытного исследователя дальше?
* Моделирование роста двумерных и трехмерных многоклеточных организмов
* Анимация роста организмов деревьев
* Моделирование влияния окружающей среды
* Моделирование химикобиологических процессов и growth functions
* Применение L для генерации поверхностей
* Другие разнообразные варианты использования, в том числе для моделирования недвижимости и городов
### Примеры.
### Использование.
Еще в конце 80х L использовались для визуализации моделей растений. Сейчас возможности компьютеров ушли далеко вперед. Многие игры и инструменты 3d моделирования используют процедурную генерацию контента, в том числе и L-Systems. Как видите, из набора простых правил можно получить огромное количество разных растений и засадить ими целые поля.
Из редакторов я сам пользуюсь L в [Houdini](http://www.sidefx.com), слышал, что есть плагины и для других пакетов. Так называемая [Виртуальная Лаборатория](http://algorithmicbotany.org) позволяет экспериментировать и анимировать L.
Методы использования грамматик также используются в так называемых [Shape Grammars](http://en.wikipedia.org/wiki/Shape_grammar), но об этом потом.
Некоторые посты в интернете.
<http://avalter.blogspot.com/2009/08/2d-l.html>
### Книги и дополнительный материал.
Вообще говоря, единственная доступная книга — это [The Algorithmic Beauty of Plants](http://algorithmicbotany.org/papers/#abop). Также, по интернету разбросаны старые рандомные статьи. Более-менее новые можно найти на [springerlink.com](http://www.springerlink.com) за кучу денег или в институтской библиотеке забесплатно.
Что сказать, материала довольно маловато.
### Околобиологические мысли.
Я сам имею ровно никакое отношение к биологии, а являюсь Магистром Математики с небольшими невиными увлечениями. Но мне чрезвычайно нравится идея L-Systems. Простота с огромными возможностями. Когда-то давно я задумывался как же так в ДНК содержится полная информация обо мне. Как же можно в каждую клетку впихнуть всю информацию обо всех клетках? А никак, можно сказать, теория L открыла мне глаза! У меня в ДНК написано не как я выгляжу, а как меня собрать (общими словами). Что-то похожее на набор правил в L, только относящееся к синтезу протеинов.
Простая модель так четко описывает нашу с вами жизнь.
Дальше больше — превращаем правила в «ДНК» и генетическим алгоритмом выращиваем виртуальных многоклеточных.
### Научные мысли.
Мне бы хотелось найти людей, которые тоже заинтересованы в научной составляющей L, поделиться материалами и статьями. Так уж получилось, что я сейчас работаю над апгрейженной концепцией L-Systems, но не имею возможности просмотреть что писалось по этой теме за последние пять лет. Не хочется изобретать велосипед.
Связаться с автором КНИГИ не удалось, автоответчик говорит, что он уехал на шабаш до января (8
Также, я ищу информацию по Shape Grammars для 3d моделирования. Есть задача генерировать из параметров космические корабли, ну знаете такие огромные штуковины с кучей мелких деталей — идеальные кандидаты для SG. Неужели придется писать плагин для Houdini на Python? | https://habr.com/ru/post/69989/ | null | ru | null |
# Все нововведения Windows 10 2004 (20H1)
Сегодня вечером был выпущен финальный ISO-образ Windows 10 2004 (20H1). Им стал билд за номером **19041.208.vb\_release\_svc\_im.200416-2050**. Образы для разработчиков уже доступны на MSDN как вскоре и сами знаете где.
Вместе с ISO-образами было выпущено обновление [KB4556803](https://www.deskmodder.de/blog/2020/05/12/kb4556803-windows-10-2004-19041-264-manueller-download/), после установки которого версия ОС становится 19041.264.
Раз образы финальные выпущены, можно и поговорить о том, что нового ждёт пользователей в майском обновлении Windows 10.
Больше контроля над необязательными обновлениями
------------------------------------------------
Центр обновления Windows автоматически устанавливает множество обновлений, но некоторые из них опциональны. Отныне же появилась кнопка, показывающая все необязательные обновления в одном месте.
Тут появятся обновления драйверов, крупные обновления как это майское (которое предположительно начнет распространяться через Центр обновлений Windows [28 мая](https://www.zdnet.com/article/microsoft-rolls-out-windows-10-2004-release-preview-ahead-of-expected-may-release-to-mainstream-users/)), ежемесячные и не связанные с безопасностью.
Чтобы найти список необязательных обновлений, перейдите в **Параметры → Обновление и безопасность → Центр обновления Windows → Просмотреть необязательные обновления**.
«Загрузка из облака» для переустановки Windows 10
-------------------------------------------------
Windows 10 получила новую функцию «Загрузка из облака» для возврата компьютера в исходное состояние. Теперь, если перейти в Параметры > Обновление и безопасность > Восстановление, вместо создания загрузочного носителя для переустановки ОС Windows может скачать и установить самую актуальную версию Windows 10.
Регулирование пропускной способности для обновлений Windows
-----------------------------------------------------------
Теперь Параметры предложат больше контроля над пропускной способностью для загрузки обновлений Windows. В текущей версии Windows можно выставить максимальный предел в процентах от доступной пропускной способности. Windows 10 версии 2004 даст возможность установить абсолютный предел пропускной способности для более точного регулирования объема загружаемых обновлений. Ранее эта опция была доступна лишь через групповые политики.
Найти новую функцию можно, перейдя в **Параметры → Обновление и безопасность → Оптимизация доставки → Дополнительные параметры**.
WSL 2 с ядром Linux
-------------------
Новая подсистема Windows для Linux (WSL) – пожалуй, самое важное изменение в Windows 10 20H1. Это WSL версии 2, и она гораздо более мощная, чем первая версия. WSL 2 использует реальное ядро Linux, чтобы предоставить полноценное окружение Linux на Windows 10.
Microsoft подготовила свое собственное ядро Linux для WSL 2, которое будет обновляться через Центр обновлений Windows. Пользователи смогут сами собрать свое собственное ядро Linux и использовать его на WSL 2.
В WSL 2 обещают «значительный прирост производительности операций ввода/вывода» и «полную совместимость системных вызовов». Эта совместимость означает поддержку таких технологий как Docker, в отличие от WSL 1, где эта функция была недоступна.
Кроме этого, Microsoft добавила поддержку для устройств ARM64. Иными словами, WSL теперь работает на ПК с архитектурой ARM.
Ускоренный поиск
----------------
Microsoft сообщает, что теперь за счет обнаружения пиковых нагрузок ОС сможет оптимизировать работу индексирования.
Поиск в Windows станет работать также быстрее по умолчанию, так как по умолчанию идексирование будет исключать из поиска «папки для разработчиков» вроде .git, .hg, .svn, .Nuget, и прочие. Это скажется на скорости компиляции и синхронизации кода.
Тип диска в Диспетчере задач
----------------------------
Теперь диспетчер задач в Windows 10 отображает тип диска: SSD или HDD. Вы сможете найти эту информацию во вкладке «Производительность».
Температура GPU в Диспетчере задач
----------------------------------
Если у вас имеется видеокарта с минимальной версией драйвера WDDM 2.4, в разделе «Производительность» также можно найти данные о GPU. Эта функция работает лишь с внешними видеокартами.
Счетчик FPS Xbox Game Bar
-------------------------
Во время игры нажмите Windows+G, чтобы открыть Game Bar, и вы увидите счетчик кадров.
Вход в Windows без пароля
-------------------------
Чтобы использовать Windows Hello и входить без пароля, перейдите в **Параметры → Учетные записи → Варианты входа**. Эта настройка позволяет входить по пин-коду, используя распознавание лица (Windows Hello) или по отпечатку пальца.
Переименование виртуальных рабочих столов
-----------------------------------------
Теперь вместо стандартных названий «Рабочий стол 1», «Рабочий стол 2» и т. д. вы можете переименовывать их. Чтобы сделать это, просто нажмите на имя рабочего стола сверху панели Просмотра задач.
Улучшенная страница информации о состоянии сети
-----------------------------------------------
Произошел редизайн страницы «Состояние сети»: **Параметры → Сеть и Интернет → Состояние**. Теперь в верхней части страницы отображаются все доступные сетевые интерфейсы. Microsoft сообщает, что новый дизайн интерфейса «предоставляет больше информации о подключении вашего устройства, объединяя несколько страниц, чтобы дать вам одно четкое представление о том, как вы подключены к интернету». Windows также отображает потребленный трафик по каждому из интерфейсов.
Встроенная поддержка для IP-камер
---------------------------------
Windows 10 получила встроенную поддержку IP-камер в локальной сети. Раньше вам понадобилось бы стороннее ПО, чтобы подключиться к таким.
С этим обновлением вы сможете добавить сетевую камеру, перейдя **Параметры → Устройства → Bluetooth или другие устройства → Добавление Bluetooth или другого устройства**. Если Windows 10 обнаружит в локальной сети поддерживаемую камеру, вы сможете добавить ее в систему одним нажатием.
Для доступа к IP-камерам вам поможет встроенное приложение «Камера». На данный момент заявлена поддержка камер стандарта ONVIF Profile S.
Контроль над перезапуском приложений при входе в систему
--------------------------------------------------------
После перезапуска ПК Windows 10 автоматически перезапускает много приложений. Теперь появился новый параметр, который позволит легко отключить это.
Перейдите в **Параметры → Учетные записи → Варианты входа**. Переключите в состояние «Откл.» кнопку «Автоматически сохранять мои перезапускаемые приложения при выходе из системы и перезапускать их после выхода».
Раньше этот параметр был скрыт и объединен с «Использовать мои данные для входа для автоматического завершения настройки устройства и открытия моих приложений после перезапуска или обновления». Теперь это два обособленных параметра.
Очистка диска больше не будет очищать папку «Загрузки»
------------------------------------------------------
Microsoft исключила папку «Загрузки» из классической очистки диска. Противники данного пункта говорили, что есть большая вероятность очистить все файлы в данной папке, в особенности, если вы непродвинутый пользователь и не осведомлены, что этот пункт добавили в очистку диска.
Данный пункт переехал в «Память устройства», который располагается в **Параметры → Система → Память устройства → Настроить контроль памяти или запустить его**.
Paint и WordPad – теперь дополнительные компоненты
--------------------------------------------------
Microsoft перенесла Paint и WordPad в разряд «дополнительные компоненты». Они все еще предустанавливаются по умолчанию, но их можно удалять, чтобы освободить немного места. Перейдите в **Параметры → Приложения → Приложения и возможности → Дополнительные компоненты**, где вы обнаружите Paint и WordPad вместе с остальными дополнительными компонентами такими, как, например, Windows Media Player.
Баннер в приложении «Параметры»
-------------------------------
Microsoft экспериментирует с баннером в Параметрах уже давненько и вернула его окончательно в релизе 20H1. Новый баннер появился в верхней части домашней страницы «Параметры», отображая иконку профиля, имя аккаунта и ссылку на редактирование данных учетной записи Microsoft. Также можно увидеть быстрые ссылки на OneDrive и настройки Центра управления обновлениями и информацию об их статусе.
Улучшение сопряжения Bluetooth-устройств
----------------------------------------
Если поблизости будет обнаружено устройство в режиме сопряжения, вы увидите уведомление с предложением о сопряжении. Весь процесс сопряжения происходит прямо через всплывающее уведомление, без необходимости открывать «Параметры».
Быстрое сопряжение работает пока только с клавиатурами и мышками для Microsoft Surface, но в будущем оно сможет заработать и с остальными устройствами, сделав процесс сопряжения Bluetooth-устройств быстрее.
Индикатор текстового курсора
----------------------------
Теперь вы можете настроить размер и цвет индикатора текстового курсора в Windows 10.
Чтобы ознакомиться с настройкой, перейдите в **Параметры → Специальные возможности → Текстовый курсор**. Включите «индикатор текстового поля» и выберите размер и цвет курсора.
Функция Drag-and-Drop с помощью движения глаз
---------------------------------------------
У Windows 10 имеется функция Управления глазами при наличии специального устройства для отслеживания движений глаз. Это функция для людей с ограниченными возможностями позволяет управлять ПК с помощью движения глаз. В обновлении «May 2020 Update» эта функция была улучшена: теперь вы можете перетаскивать объекты с помощью мышки движениями глаз.
Обновленная страницы языковых настроек
--------------------------------------
Теперь страница языковых настроек отображает язык интерфейса Windows по умолчанию, приложений, сайтов, раскладки клавиатуры, распознавание речи и настройки региона.
Переработаны настройки уведомлений
----------------------------------
Теперь, когда вам приходит уведомление, появилась опция выключить уведомления для этого приложения или сразу перейти в настройки уведомлений для него.
Улучшения при работе с несколькими мониторами
---------------------------------------------
Windows 10 версии 2004 включает в себя Windows Display Driver Model (WDDM) 2.7, который улучшает общую игровую производительность, выходной видеосигнал и частоту обновления при использовании нескольких мониторов в связке.
Обновление добавляет поддержку переменной частоты обновления видео ускорителя, которая позволит видеокартам управлять их видеопамятью. Согласно Microsoft, данный параметр должен снизить задержки и улучшить среднюю частоту кадров в играх.
Переменную частоту обновления можно включить, перейдя в Настройки → Система → Дисплей. Microsoft уведомляет, что для работы необходим драйвер Intel 27.20.100.7859 и NVIDIA drivers 450.12 или выше.
AMD еще предстоит выпустить совместимые драйверы для Windows 10 с поддержкой WDDM 2.7, так как ПК с графикой AMD не поддерживают функцию аппаратного ускорения Microsoft.
Улучшена частота обновления и устранены разрывы при использовании нескольких мониторов
--------------------------------------------------------------------------------------
Your browser does not support HTML5 video.
Обновление снижает разрывы при перемещении окна программы из одного монитора в другой, если у последнего выставлена другая частота обновления.
Для пользователей с одним монитором была исправлена ошибка, когда перемещение второго окна могло вызывать дерганье в игре, запущенной в оконном режиме.
Калькулятор
-----------
Добавлена возможность отображать калькулятор поверх остальных окон.
Календарь
---------
Добавлена возможность быстрого добавления события или напоминания прямо с панели задач
Сокращено время на установку функциональных обновлений
------------------------------------------------------
Начиная с версии 1703 уменьшается время на установку функциональных обновлений: со средним значением более 80 минут на 1703 до менее 20 минут на версии 2004, перезагружая устройство лишь единожды.
Улучшен контроль над зарезервированным хранилищем
-------------------------------------------------
Добавлены новые команды для управления зарезервированным хранилищем
```
Get-WindowsReservedStorageState
Set-WindowsReservedStorageState -State Disable
```
Улучшено уведомление об ожидающем установки обновлении
------------------------------------------------------
Уведомление о предстоящем обновлении теперь будет появляться в Центре уведомлений, предлагая варианты: «Перезагрузиться прямо сейчас», «Перезагрузиться ночью» и «Выбрать время». Уведомление также напомнит о необходимости подключить ваше устройство к сети питания, чтобы обновление не прервалось.
Прочие нововведения
-------------------
* Новые возможности DirectX 12: превью для разработчиков DirectX Raytracing Tier 1.1, DirectX Mesh Shader и другие.
Настройка скорости курсора мыши: перейдите в **Параметры → Устройства → Мышь**. Ранее данная настройка располагалась в Панели управления.
* Раздел дополнительных компонентов получил улучшенный интерфейс:
Раздел располагается по адресу: **Параметры → Приложения → Приложения и возможности**. Теперь есть возможность выбрать и установить множество компонентов за раз, а также осуществлять поиск по имеющимся компонентам, отсортировав их по своему усмотрению. Доступен просмотр даты установки каждого компонента и его статус.
* PowerShell Integrated Script Editor стал дополнительным компонентом, но установлен по умолчанию.
В публикации также использовались материалы статей следующих сайтов
-------------------------------------------------------------------
* [thewincentral.com](https://thewincentral.com/windows-10-20h1-update-version-2003-all-changes-new-features-categorized-changelog)
* [techcommunity.microsoft.com](https://techcommunity.microsoft.com/t5/windows-it-pro-blog/pilot-new-features-with-the-windows-insider-program-for-business/ba-p/1220464)
* [mspoweruser.com](https://mspoweruser.com/windows-update-notification-now-much-better-in-windows-10-2004/)
* [windowslatest.com](https://www.windowslatest.com/2020/02/20/windows-10-20h1-to-improve-video-output-multi-monitor-support/)
* [reddit.com](https://www.reddit.com/r/Windows10/comments/f57tk4/dwm_multiple_monitors_with_different_refresh_rate/)
**Добавлено**
**#1** Полезный [комментарий](https://habr.com/ru/post/499522/#comment_21608026) от [dartraiden](https://habr.com/ru/users/dartraiden/)
**#2** По поводу [32-битных образов](https://habr.com/ru/post/499522/#comment_21612420) для производителей
**#3** Windows 10 2004 стал [доступен](https://habr.com/ru/post/499522/#comment_21667796) в 20:00 по московскому времени.
**#4** Известные [проблемы](https://docs.microsoft.com/en-us/windows/release-information/status-windows-10-2004).
**#5** Более [не поддерживаемые](https://docs.microsoft.com/en-us/windows/deployment/planning/windows-10-deprecated-features) и [удаленные](https://docs.microsoft.com/en-us/windows/deployment/planning/windows-10-removed-features) компоненты в Windows 10 2004.
**#6** 1 июля обновление стало [доступно](https://docs.microsoft.com/en-us/windows/release-information/resolved-issues-windows-10-2004#421msgdesc) для Microsoft Surface Pro 7 и Microsoft Surface Laptop 3, как сообщил [BleepingComputer.com](https://www.bleepingcomputer.com/news/microsoft/microsoft-lifts-windows-10-2004-update-block-on-surface-devices/).
**P. S.** Также, кому интересно, может тонко настроить как текущий релиз Windows 10, так и майский, с помощью моего скрипта на PowerShell: [Windows 10 Setup Script](https://github.com/farag2/Windows-10-Setup-Script/releases) | https://habr.com/ru/post/499522/ | null | ru | null |
# Asterisk queues, мелкие хитрости
Хочу рассказать про некоторые хитрости с очередями в asterisk к которым я пришел решая задачи с отзвоном. Прошу иметь ввиду, что я начинающий специалист и те хитрости которые «открыл» давно решены тем или иным способом. Тем не менее вероятно эти сведения тоже кому-то пригодятся.
Основным условием было — использование только стандартного функционала без обращения к внешним скриптам.
#### **Очередь из локальных каналов**
В исходной задаче было несколько неумных шлюзов (без собственных очередей) с двумя и более каналов в каждом, через которые требовалось отзваниваться с той или иной степенью равномерности.
queues.conf
```
[queue-out]
strategy=rrmemory
autofill=yes
ringinuse=no ; система не должна звонить на канал который уже используется иначе каналы будут затыкаться
member => Local/out11@dialout
member => Local/out12@dialout
member => Local/out21@dialout
member => Local/out22@dialout
```
extensions.conf
```
exten => _X.,1,NoOp()
same => n,Set(_NEXTEN=${EXTEN}) ; передаем номер в очередь
same => n,Queue(queue-out,r)
same => n,Hangup
[dialout]
exten => out11,1,Dial(SIP/gate1/01${NEXTEN}) ; таким образом можно формировать номер для статической очереди
same => n,Hangup
exten => out12,1,Dial(SIP/gate1/02${NEXTEN})
same => n,Hangup
exten => out21,1,Dial(SIP/gate2/01${NEXTEN})
same => n,Hangup
exten => out22,1,Dial(SIP/gate2/02${NEXTEN})
same => n,Hangup
```
#### **Очередь из локальных каналов — вариант 2 и контроль нагрузки**
Добавились пиры с неограниченым явно количеством каналов, требовалось как то их описать для очереди. Попутно выяснилось, что таким образом можно управлять количеством исходящих звонков — сколько каналов распишем, столько и будет звонков одновременно.
queues.conf
```
[queue-out]
strategy=rrmemory
autofill=yes
ringinuse=no
; вариант для 14 исходящих каналов
; сколько каналов реально - неизвестно или неограничено, данным конфигом мы заставляем систему
; использовать до 14 каналов одновременно
member => Local/out01@dialout
member => Local/out02@dialout
member => Local/out03@dialout
member => Local/out04@dialout
...
member => Local/out12@dialout
member => Local/out13@dialout
member => Local/out14@dialout
```
extensions.conf
```
exten => _X.,1,NoOp()
same => n,Set(_NEXTEN=${EXTEN}) ; передаем номер в очередь
same => n,Queue(queue-out,r)
same => n,Hangup
[dialout]
exten => _outXX,1,Dial(SIP/provider1/${NEXTEN}) ; формируем двухзначный номер канала
same => n,Hangup
```
#### **Очередь из локальных каналов — вариант 3 и резервирование**
Имеем два пира — основной и запасной. Соответственно звоним на первый пока не достигнем установленных нами ограничений, при превышении плавно переходим на запасной. Либо первый по каким то причинам становится недоступен — тогда сразу переходим на запасной.
queues.conf
```
[queue-out]
strategy=linear ; другой тип распределения звонков
; -в заданном порядке, всегда обрабатывается с начала списка, первый будет работать не разгибая спины-
autofill=yes
ringinuse=no
; 30 основных, 20 запасных - количество для примера, указывайте столько, сколько требуется вам
member => Local/prov1out01@dialout
member => Local/prov1out02@dialout
member => Local/prov1out03@dialout
---
member => Local/prov1out29@dialout
member => Local/prov1out30@dialout
member => Local/prov2out01@dialout
member => Local/prov2out02@dialout
member => Local/prov2out03@dialout
---
member => Local/prov2out19@dialout
member => Local/prov2out20@dialout
```
extensions.conf
```
exten => _X.,1,NoOp()
same => n,Set(_NEXTEN=${EXTEN}) ; передаем номер в очередь
same => n,Queue(queue-out,r)
same => n,Hangup
[dialout]
exten => _prov1outXX,1,Dial(SIP/provider1/${NEXTEN})
same => n,Hangup
exten => _prov2outXX,1,Dial(SIP/provider2/${NEXTEN})
same => n,Hangup
```
#### **Проблемы**
Не забываем перезапускать asterisk (`service asterisk restart` или `core restart now` из консоли) после изменения параметров очереди — `module reload` или `queue reload all` недостаточно — изменения будут показаны но не будут использоваться (статус Invalid в списке участников).
При стратегии `linear` участники очереди через короткое время становились неактивными (канал будто засыпает). Так и не выяснил в чем проблема, решил костылем в виде создания динамической очереди и периодическим пересозданием участников. Может кто то сталкивался и решил? Отпишите в комментах.
#### **Итог**
В принципе при наличии необходимости а также фантазии / смекалки можно делать интересные конструкции — контроль входящей / исходящей нагрузки, резервирование (двойное и более), различные варианты перебора каналов, ну и комбинации вышеперечисленного. Надеюсь кому-то пригодится. | https://habr.com/ru/post/324580/ | null | ru | null |
# Как заработать очки, даже не запуская игру
Как-то вечером, сидя за компьютером, я наткнулся на одну инди-игру под названием **«Shoot First»** (игру можно [скачать](http://teknopants.com/2011/05/shoot-first/) абсолютно бесплатно с сайта автора, а за донат любого размера вы получите специальную версию с двумя новыми видами оружия и ещё одним видом уровней). Геймплей её довольно незамысловат — игроку необходимо бегать по этажам в поисках прохода на следующий уровень, при необходимости собирая различные предметы (карты, ключи, etc) и попутно убивая встретившихся на его пути врагов. В общем, этакий action [roguelike](http://en.wikipedia.org/wiki/Roguelike). Несмотря на кажущуюся простоту, игра меня довольно сильно зацепила, и я потратил не один час, пытаясь добраться как можно дальше и заработать как можно больше очков.
Кстати, об очках. После смерти персонажа и ввода имени игра отображает онлайн-таблицу рекордов:
Наигравшись вдоволь, я решил разобраться, как она устроена и попытаться обмануть игру, сказав, что я заработал нереальное кол-во очков.
Как протекал процесс, и что из этого вышло, читайте под катом (осторожно, **много скриншотов**).
Первое, что приходит на ум, наверное, любому человеку, который хоть раз занимался нечестным получением денег в сигнл-плеерных играх, это [ArtMoney](http://www.artmoney.ru/rus.htm). Что ж, почему бы и нет?
Запускаем игру, зарабатываем какое-нибудь «необычное» кол-во очков, загружаем процесс в ArtMoney и ищем это самое значение. После долгих мучений мне так и не удалось найти целочисленное значение с набранным мною кол-вом очков, при изменении которого я бы достиг своей цели.
Что ж, ладно, пойдём другим путём.
Очевидно, что для получения таблицы рекордов игра лезет в сеть, а взаимодействие с сетью в Windows, как известно, лежит на плечах [WinSock](http://en.wikipedia.org/wiki/Winsock), реализация которой находится в **WS2\_32.dll**. Берём в руки WPE Pro (в отличие от, например, Wireshark'а, он умеет перехватывать пакеты конкретного приложения, что в нашем случае гораздо удобнее), указываем процесс нашей игры, умираем и смотрим на результат:
Как видите, игра шлёт на адрес teknopants.com GET-реквесты вида
/games/shootfirst/score12.php?alltime=15&monthly=15&weekly=15&daily=15&name=**%name%**&score=**%score%**&data=Floor%20**%floor%**%20%5b**%player%**P%5d&hash=**%hash%**
, где **%name%** — это имя игрока, **%score%** — кол-во очков, **%floor%** — этаж, на котором погиб игрок, **%player%** — номер игрока (за одним компьютером может играть одновременно два человека — **1P** и **2P** соответственно) и **%hash%** — хеш, необходимый, очевидно, для проверки корректности отправляемых данных.
Обратите внимание, что GET-реквест одновременно содержит информацию о том, какие данные необходимо получить (параметры alltime, weekly и daily), и о том, какие данные необходимо добавить (параметры name, score, data и hash).
Понятное дело, что просто так поменять в отправляемом GET-реквесте кол-во заработанных очков нельзя — для этого нам также потребуется сгенерировать новый хеш. Решать задачу путём проведения экспериментов практически бессмысленно, так что пора взяться за ещё один инструмент — на этот раз [OllyDbg](http://www.ollydbg.de/).
Но перед тем, как загрузить процесс в OllyDbg, давайте проверим, не запакована ли наша игра. Берём [DiE](https://github.com/horsicq/old-DIE), открываем исполняемый файл игры и видим следующую картину:
Получается, что с большой долей вероятности игра ничем не защищена.
Что ж, отлично. Тогда запускаем подопытного в OllyDbg и пытаемся найти место, где игра делает GET-реквесты. В WinSock есть две функции, отвечающие непосредственно за отправку данных — [send](https://msdn.microsoft.com/en-us/library/windows/desktop/ms740149(v=vs.85).aspx) и [WSASend](https://msdn.microsoft.com/en-us/library/windows/desktop/ms742203(v=vs.85).aspx). Переключаемся на модуль нашего исполняемого файла (Alt-E -> Shoot First %version%.exe) и ищем их в списке «Intermodular calls» (right-click по окну CPU -> Search For -> All intermodular calls). Как ни странно, но здесь нет ни одной, ни другой функции. На ум приходит сразу два варианта — разработчик мог скопировать их код из **WS2\_32.dll** напрямую в своё приложение или просто вызывать их из какого-то другого модуля. Второй вариант гораздо проще отследить, так что давайте начнём с него.
Смотрим на директорию с игрой на предмет каких-то дополнительный динамических библиотек. Находим одну, которая уже по названию намекает на то, что наши поиски будут недолгими:
Переключаемся на него (Alt-E -> plaidscores.dll) и также ищем вызовы **send** и **WSASend**. Находится только один:
Ставим на него софтварный бряк (left click -> F2), умираем (разумеется, в игре) и… останавливаемся перед вызовом функции **send**:
На стеке видны аргументы, самым интересным из которых для нас является **Data**. Если посмотреть, что находится по этому адресу (right click -> Follow in Dump), то мы увидим уже знакомый нам GET-реквест:
Таким образом, мы поняли, что отправка данных на сервер осуществляется в модуле **plaidscores.dll**. Очевидно, что модуль **Shoot First %version%.exe** должен каким-то образом сообщать dll некоторые данные (как минимум, это всё те же очки, в то время как хеш, например, может генерироваться уже в dll). Вариантов передачи данных тут, конечно, в общем случае целая масса (файлы, реестр, сокеты, etc), но в большинстве случаев разработчики просто вызывают экспортированную функцию из dll с соответствующими аргументами. Смотрим, откуда нас позвали (для этого надо открыть call stack при помощи Alt-K):
Как видите, для отправки данных exe-модуль зовёт нас из выделенного на скришоте места. Снимаем точку останова с функции send, прыгаем на вызов (right-click -> Show call) и ставим софтварный бряк при помощи F2. Снова умираем и смотрим на обстановку:
Что мы здесь видим?
Во-первых, имя экспортированной функции — **psSubmit**.
Во-вторых, состояние стека на момент её вызова.
К сожалению, гарантированно понять, сколько аргументов передаётся экспортированной функции, можно лишь в том случае, если их имена были декорированы (при желании можно почитать об этом, например, [тут](http://stackoverflow.com/questions/1548637/is-there-any-native-dll-export-functions-viewer)). Что ж, давайте проверим. Запускаем [Dependency Walker](http://www.dependencywalker.com/), открываем нашу dll и смотрим на список экспортированных функций:
К сожалению, их имена не декорированы. В таком случае нам придётся проанализировать код перед вызовом функции **psSubmit** в поисках PUSH'ей. Вероятнее всего, все 4 PUSH'а в case-блоке указанного выше скриншота и есть аргументы нашей исследуемой функции. Посмотрим на них ещё раз:
С первым и последним аргументами вопросов возникнуть не должно — это имя игрока, этаж, на котором он умер, и 1P / 2P. Скорее всего, один из оставшихся аргументов и есть наша цель — очки. Чтобы понять, какой это конкретно из них, давайте заработаем какое-нибудь их кол-во перед смертью (до этого я умирал без набора очков). Нажимаем F9, выполняем поставленную задачу, умираем и останавливаемся на том же самом месте, но уже с другими данными на стеке:
Я набрал 9 очков, и значение одного из аргументов действительно изменилось — теперь на его месте красуется 0x40220000. На 9 в hex'е это не очень-то смахивает, так что давайте проведём ещё несколько экспериментов:
Кол-во очков в игре — значение аргумента
6 — 0x40180000
7 — 0x401C0000
8 — 0x40200000
9 — 0x40220000
10 — 0x40240000
Как видите, значения увеличиваются неравномерно, так что гарантированно провести обратную конвертацию прямо сейчас у нас не получится. Но давайте хотя бы проверим, что при изменении этого значения перед вызовом **psSubmit** игра действительно думает, что мы набрали другое кол-во очков, и отправляет на сервер поддельные данные. Умираем без зарабатывания очков, останавливаемся перед вызовом **psSubmit** и изменяем (left click -> Ctrl-E) значение соответствующего аргумента на, предположим, 0x40220000, т.е. 9 очков. Нажимаем F9 и наблюдаем, что наше поддельное значение действительно отправилось на сервер.
Теперь у нас остались нерешёнными две проблемы:
* В каком формате хранятся заработанные очки
* Зачем нужен ещё один аргумент, который во всех проведённых экспериментах был равен нулю
Второй пункт не сказать, чтобы проблема, но никто ведь не любит, когда то, что он изучает, не поддаётся объяснению, верно? Однако давайте пока остановимся на первом пункте.
Раз **plaidscores.dll** формирует GET-реквест с «читаемым» кол-вом очков, а получает на вход «закодированный» вариант, она знает, как выполнить необходимое нам преобразование (в принципе, его знает и exe-модуль, раз он может отображать кол-во очков игроку). В связи с этим мы можем прямо сейчас взяться за изучение алгоритма декодирования, но что если есть способ проще? Мы забыли, что у нас есть хеш, который безумно напоминает MD5. Вспоминая, что в WinAPI есть функция для получения MD5-хеша (и некоторых других видов) для переданных ей данных, можно предположить, что игра просто вызывает её для получения этого хеша, так что мы сможем понять, от чего именно игра берёт хеш. Если такой вызов и есть, то он должен находиться в **plaidscores.dll**, ведь, как мы видели, в **psSubmit** передаются лишь четыре аргумента, каждый из которых не очень-то напоминает MD5-хеш.
Функция, о которой идёт речь, называется [CryptGetHashParam](https://msdn.microsoft.com/en-us/library/windows/desktop/aa379947(v=vs.85).aspx) (на самом деле, там целый ряд функций, которые необходимо позвать одна за другой, но всё ведёт именно к ней), так что давайте поищем её среди «Intermodular calls». К сожалению, такой функции не нашлось.
Что ж, ничего — снова останавливаемся перед вызовом **psSubmit**, прыгаем внутрь этой функции по нажатию F7 и ставим хардварный бряк на область памяти с нашими очками. Для этого ищем адрес, по которому хранятся очки, в «Memory Dump» (можно воспользоваться Ctrl-G) -> right-click по первому байту -> Breakpoint -> Hardware, on access -> Dword. Нажимаем F9 и попадаем в следующее место:
В отличие от софтварных, хардварные брейкпоинты останавливаются на инструкции, идущей после выполнения интересующих нас действий, так что смотрим на то, что находится по адресу 0x09F60195. Здесь можно увидеть инструкцию [FLD](http://x86.renejeschke.de/html/file_module_x86_id_100.html):
> Pushes the source operand onto the FPU register stack. The source operand can be in singleprecision, double-precision, or double extended-precision floating-point format
Так вот оно что! Получается, значение вовсе не закодировано, а всего лишь представлено в виде числа с плавающей точкой! Если посмотреть на регистр ST0, то мы действительно увидим кол-во наших очков:
Скажу честно, такого я не ожидал, ведь заработать в игре нецелое кол-во очков просто невозможно (по крайней мере, чисто визуально и по таблице рекордов).
Для окончательной проверки наших предположений можно воспользоваться каким-нибудь [онлайн-сервисом](http://gregstoll.dyndns.org/~gregstoll/floattohex/):
Более того, как вы видите, обращается FLD не только к исследуемому нами значению, но и к последнему неизвестному аргументу. Следовательно, это 8-байтовое число с плавающей точкой.
Оглядываясь назад, я понимаю, что Art Money мог бы помочь в этой ситуации сразу же, если бы я знал, что искать надо вовсе не целочисленное значение:
Впрочем, неужели это всё? Пользоваться таким решением не очень-то удобно, так что я принял решение написать отдельную программу, которая будет отправлять GET-реквест с заданными пользователем данными (для упрощения кода я убрал некоторые проверки):
```
#include
#define WIN32\_LEAN\_AND\_MEAN
#include
#include
#include
#include
typedef void(\_\_cdecl \*submit\_proc\_t)(const char\*, double, const char\*);
int main()
{
HMODULE scores\_dll = LoadLibraryA("PlaidScores.dll");
if (scores\_dll == NULL)
{
std::cerr << "Unable to load DLL \n";
return EXIT\_FAILURE;
}
BOOST\_SCOPE\_EXIT\_ALL(scores\_dll)
{
FreeLibrary(scores\_dll);
};
submit\_proc\_t submit\_proc = (submit\_proc\_t)GetProcAddress(scores\_dll, "psSubmit");
if (submit\_proc == NULL)
{
std::cerr << "Unable to find submit procedure \n";
return EXIT\_FAILURE;
}
std::cout << "Enter your name: ";
std::string name;
std::getline(std::cin, name);
std::cout << "Enter scores count: ";
int scores;
std::cin >> scores;
std::cout << "Enter floor: ";
int floor;
std::cin >> floor;
std::cout << "Enter player number: ";
int player\_number;
std::cin >> player\_number;
std::ostringstream osstr;
osstr << "Floor " << floor << "[" << player\_number << "P]";
submit\_proc(name.c\_str(), scores, osstr.str().c\_str());
std::cout << "Done \n";
}
```
Запускаем, взволнованно смотрим на таблицу рекордов, и… Ничего не происходит.
На первый взгляд выглядит всё так же, как и в случае с вызовом **plaidscores.dll** из игры. Что же пошло не так? Давайте попробуем разобраться.
Загружаем наш исполняемый файл в OllyDbg, ставим бряк на **psSubmit** и смотрим на стек:
Визуально всё выглядит точно так же, как и в случае с игрой. Может, мы ошиблись с кол-вом аргументов? Но прежде чем браться за анализ PUSH'ей перед вызовом **psSubmit** из exe-модуля игры, вспомните, как обычно происходит работа с динамическими библиотеками в Windows. Вы, наверное, не раз слышали, что **DllMain** — это функция, которая довольно сильно ограничена по тому, что в ней можно делать. Однако очень часто возникает ситуация, когда DLL необходимо инициализировать какие-то данные при запуске, чтобы не делать это постоянно при вызове каждой экспортированной функции. В связи с этим разработчики DLL зачастую предоставляют экспортированную функцию для инициализации (а также нередко и для деинициализации), в которой совершают все необходимые им действия. Посмотрим, нет ли такой функции в **plaidScores.dll** при помощи Ctrl-N:
Как видите, она действительно есть. Запускаем игру в OllyDbg, ставим бряк на **psInit**, смотрим откуда нас вызвали и видим, что, вероятнее всего, она принимает два аргумента:
Один из них — ссылка, на которую необходимо выполнять GET-реквест (http://teknopants.com/games/shootfirst/score12.php), а другой является строкой «5hoo7first12».
Основываясь на новых данных, немного изменим исходный код нашей программы:
```
#include
#define WIN32\_LEAN\_AND\_MEAN
#include
#include
#include
#include
typedef void(\_\_cdecl \*init\_proc\_t)(const char\*, const char\*);
typedef void(\_\_cdecl \*submit\_proc\_t)(const char\*, double, const char\*);
int main()
{
HMODULE scores\_dll = LoadLibraryA("PlaidScores.dll");
if (scores\_dll == NULL)
{
std::cerr << "Unable to load DLL \n";
return EXIT\_FAILURE;
}
BOOST\_SCOPE\_EXIT\_ALL(scores\_dll)
{
FreeLibrary(scores\_dll);
};
init\_proc\_t init\_proc = (init\_proc\_t)GetProcAddress(scores\_dll, "psInit");
if (init\_proc == NULL)
{
std::cerr << "Unable to find init procedure \n";
return EXIT\_FAILURE;
}
submit\_proc\_t submit\_proc = (submit\_proc\_t)GetProcAddress(scores\_dll, "psSubmit");
if (submit\_proc == NULL)
{
std::cerr << "Unable to find submit procedure \n";
return EXIT\_FAILURE;
}
std::cout << "Enter your name: ";
std::string name;
std::getline(std::cin, name);
std::cout << "Enter scores count: ";
int scores;
std::cin >> scores;
std::cout << "Enter floor: ";
int floor;
std::cin >> floor;
std::cout << "Enter player number: ";
int player\_number;
std::cin >> player\_number;
std::ostringstream osstr;
osstr << "Floor " << floor << "[" << player\_number << "P]";
init\_proc("http://teknopants.com/games/shootfirst/score12.php", "5hoo7first12");
submit\_proc(name.c\_str(), scores, osstr.str().c\_str());
std::cout << "Done \n";
}
```
Запускаем и наслаждаемся — на этот раз результат появился в таблице рекордов.
Как узнать, какое кол-во очков максимальное? Тут варианта два — либо автор производит необходимые проверки прямо в dll, либо на сервере. В обоих случаях проще всего поискать в модуле строки с похожим содержимым, так что делаем right-click по окну CPU -> Search for -> All referenced text strings и внимательно пробегаемся глазами по списку. Ваше внимание должны привлечь следующие строки:
Ставим бряки в местах обращения к ним, а также на вызов функции **send**, передаём огромное кол-во очков и видим, что приложение делает GET-реквест, но после его выполнения понимает, что что-то пошло не так, и действительно обращается к строке с описанием возможной причины ошибки. После этого можно провести ряд экспериментов и наконец выяснить, что максимальное допустимое значение — 2^31 − 1. Результаты экспериментов можно наблюдать на скриншоте:
Кстати, номер игрока можно сделать больше двух — например, 999P работает отлично.
### Послесловие
Я ни в коем случае не агитирую ломать игры, подделывать результаты и всячески мешать нормальному игровому процессу (удовольствие от игры в любом случае достигается другими вещами). Этой статьёй я хотел лишь продемонстрировать один из вариантов решения задачи, которая возникла на моём пути. Автору игры я уже написал.
Надеюсь, что статья показалась кому-то интересной. | https://habr.com/ru/post/257125/ | null | ru | null |
# Все ли вы знаете о React key?
Привет, Хабр!
Я время от времени провожу собеседования, и когда вопрос касается *React key*, чаще всего я вижу недоумевающий взгляд, намекающий “Да, там и спрашивать вроде нечего?”. Если Вам кажется *React key* понятным и простым, тогда давайте проведем мини собеседование ([данная статья является расшифровкой видео](https://youtu.be/OtAlPwW8DNU)).
Задачка разминка
----------------
### Постановка задачи
Представьте, что у нас есть массив из трех пользователей. Структура пользователя максимально примитивная, всего 2 поля, это id — уникальный идентификатор и второе поле name — собственно имя пользователя.
```
const users = [{
id: 1,
name: 'Alexander',
}, {
id: 2,
name: 'Dmitriy',
}, {
id: 3,
name: 'Anton',
}];
```
Попробуем отрисовать этих пользователей, для этого используем следующий код:
```
const Users = ({ users }) => {
return users.map((user) => {
return (
);
}
}
```
Давайте рассмотрим, что из себя представляем компонент **User**.
```
class User extends PureComponent {
componentDidMount() {
console.log("DID MOUNT ", this.props.name);
}
componentDidUpdate(prevProps) {
console.log("DID UPDATE ", prevProps.name, " -> ", this.props.name);
}
componentWillUnmount() {
console.log("WILL UNMOUNT ", this.props.name);
}
render() {
return (
{this.props.name}
);
}
}
```
Я написал этот компонент на классах, для лучшей наглядности жизненного цикла. И еще один момент на который хотелось бы обратить внимание это — **PureComponent**. Это значит, что компонент обновится, только в случае изменения свойств (props).
В итоге в браузере мы увидим примерно следующую картину:
Мы видим список из трех имен, а в консоли видим три записи, а именно DID MOUNT для каждого пользователя. Пока все логично и предсказуемо.
### Интрига задачи и Вопрос
А теперь перейдем собственно к интриге задачи. Допустим у первого пользователя изменилось имя, у второго пользователя как бы это странно не звучало изменилось id, а у третьего ничего не изменилось.
```
const users = [{
id: 1,
name: 'Maxim', // 'Alexander',
}, {
id: 4, // 2,
name: 'Dmitriy',
}, {
id: 3,
name: 'Anton',
}];
```
**Внимание вопрос!
Какие новые логи вы увидите в консоли?**
*Даем минутку подумать, можете поставить на паузу и попробовать ответить самостоятельно...*
### Осторожно Ответ!
Ну что, давайте сравнивать ответы. В браузере мы видим следующую картину:
На самой страничке мы видим, что *Alexander* изменился на *Maxim*, а *Dmitriy* и *Anton*, остались на первый взгляд без изменений. А в консоли мы видим следующие логи:
1. *WILL UNMOUNT Dmitriy*
2. *DID UPDATE Alexander* изменился на *Maxim*
3. *Dmitriy* снова вернулся в строй.
Напишите в комментарии, правильно ли вы ответили? И если нет, в чем была ошибка
### Разбор ответа
Давайте разберемся, почему мы получили именно такие результаты
В случае пользователя *Anton*, *key* и *name* до перерисовки, совпадают с *key* и *name* после перерисовки, а я напоминаю что сам компонент **User** это **PureComponent**. Соответственно никаких перерисовок компонента не произошло и следственно записей в консоли не появилось.
Пользователь *Alexander* изменил свойство *name* на *Maxim*, а при изменении *props* компонент перерисовывается и логично, что вызывается **componentDidUpdate**. Соответственно мы и увидели запись в консоли, о том что компонент обновился.
И самый непонятный пользователь *Dmitriy*, не смотря на то что компонент **User** это **PureComponent** и мы не меняли *name*, с компонентом все равно что-то происходило. А именно прошлый пользователь *Dmitriy* уничтожился и новый клон *Dmitriy* создался заново. О чем свидетельствуют записи в консоли *WILL UNMOUN и DID MOUNT*.
В этом и состоит суть *React key*. Если **ДО** обновлений, *key* существовал, а **ПОСЛЕ** обновлений *key* исчез, то не важно, чему был присвоен *key*, этот компонент в любом случае будет уничтожен. И наоборот, если **ДО** обновлений *key* не существовал, а **ПОСЛЕ** обновлений *key* появился, тогда этот компонент в любом случае будет создан с нуля. Хотя со стороны пользователя в данном примере вы не увидите никаких изменений, как был *Dmitriy* так он и остался, разница может быть видна только в более сложных компонентах, или при их большом количестве
Задачка посложнее
-----------------
Идею я думаю вы уловили, но любую теорию нужно закрепить более сложными примерами!
### Предыстория
Как вы знаете в *React* сообществе бытует один спор. Это стоит ли использовать *index* в качестве ключа. С одной стороны люди говорят, ни в коем случае и написали даже *eslint* правило, которое запрещает использовать *index* внутри *key*. С другой стороны ребята используют и особых проблем по этому поводу не испытывают.
Чтобы разобраться в этой проблеме, я бы для начала заглянул, что об этом говорит *React* документация:
А как именно негативно, рассмотрим в следующем примере.
### Постановка задачи
Возьмем все тех же пользователей, только теперь их будет 5 для лучшей наглядности.
```
const users = [{
id: 1,
name: 'Alexander',
}, {
id: 2,
name: 'Dmitriy',
}, {
id: 3,
name: 'Anton',
}, {
id: 4,
name: 'Artem',
}, {
id: 5,
name: 'Andrey',
}];
```
Для *key* будем использовать вместо *id* — *index*
```
const Users = ({ users }) => {
return users.map((user, index) => {
return (
);
}
}
```
А компонент **User** остался без изменений.
В итоге в браузере мы увидим 5 пользователей и в консоли по одной записи *DID MOUNT* для каждого пользователя. Далее происходит следующее, второго пользователя *Dmitriy* удалили из списка.
```
const users = [{
id: 1,
name: 'Alexander',
}/*, {
id: 2,
name: 'Dmitriy',
}*/, {
id: 3,
name: 'Anton',
}, {
id: 4,
name: 'Artem',
}, {
id: 5,
name: 'Andrey',
}];
```
### Вопрос
И тут возникает вопрос, какие логи появятся в консоли после обновлений?
Ставьте на паузу и подумайте над ответом.
### Осторожно Ответ!
И так результат будет следующим
Первый лог и самый спорный это *WILL UNMOUNT Andrey*, спорный он потому что, мы удаляли *Dmitriy*, а удалился *Andrey*. Следующие 3 лога уже немного поясняют, то что произошло на самом деле. Мы видим *DID UPDATE* для трех пользователей.
### Разбор ответа
Давайте еще раз разберемся, что именно произошло. Было 5 пользователей. И мы начинаем мыслить как пользователь, т.е. мы нажали кнопку удалить второго пользователя Dmitriy. Соответственно и ожидаем, что именно компонент второго пользователя будет удален, а остальные компоненты останутся без изменений.
А теперь давайте рассмотрим, как это видит *React*. До обновлений было 5 компонентов, каждому из них присвоили *key*. После обновлений стало 4 компонента. Каждому так же присвоен *key*. И *react*, с помощью одинакового *key*, соотносит компонент до рендера, с компонентом после рендера.
А теперь давайте посмотрим какие имена соответствуют этим ключам.
И тут начинаешь понимать, почему логи были именно такими. В компоненте, котором находился *Dmitriy*, теперь передали просто новый *props* *name* со значением *Anton*. Соответственно мы и увидели лог *DID UPDATE*. Тоже самое произошло и со следующими двумя компонентами, поэтому мы и увидели в консоли 3 раза *DID UPDATE*. А *key* равный 5, перестал существовать, собственно поэтому мы и увидели *WILL UNMOUNT Andrey*, а не *WILL UNMOUNT Dmitriy*.
### Подведем итог задаче
Если бы мы использовали *id*, а не *index* в качестве значения для *key*. Все было бы совсем по другому, и у нас действительно удалился бы только один компонент который содержал пользователя *Dmitriy*, а остальные остались бы без изменений. Именно про такие негативные последствия и предупреждали нас в *React* документации. И удаление элемента как вы понимаете, это не единственный случай, когда у нас могут быть лишние рендеры, так же при *drag and drop*, добавлении нового элемента в середину списка и даже более специфические ситуации.
Домашка
-------
Например представьте что у пользователей появились роли, обычный пользователь и администратор:
```
const users = [{
id: 1,
name: 'Alexander',
role: 'user',
}, {
id: 2,
name: 'Dmitriy',
role: 'admin',
}, {
id: 3,
name: 'Anton',
role: 'user',
}, {
id: 4,
name: 'Artem',
role: 'admin',
}, {
id: 5,
name: 'Andrey',
role: 'user',
}];
```
И в зависимости от роли рисуется, если это обычный пользователь, компонент **User**, а если это администратор, то компонент **Admin**. Для *key* мы по прежнему используем *index*.
```
const Users = ({ users }) => {
return users.map((user, index) => {
const Component = user.role === 'admin' ? Admin : User;
return (
);
}
}
```
И тут снова удалили пользователя *Dmitriy*.
Как думаете в этом случае какие логи будут в консоли?
Ответ я не буду раскрывать, оставлю это уже для самостоятельного изучения…
### Заключение
Особенного итога в данной статье нет. Надеюсь Вам было просто интересно и любопытно выполнять мои задачки и возможно вы открыли для себя, что то новое, а если Вам настолько понравилось и Вы хотите еще, ловите [ссылку](https://www.youtube.com/channel/UClgj-KWiNaOo9H1rz1ISO6Q). | https://habr.com/ru/post/527596/ | null | ru | null |
# О том, как мы писали асинхронного telegram-бота «ScipIO»
### Оглавление
* [Предисловие](#%D0%9F%D1%80%D0%B5%D0%B4%D0%B8%D1%81%D0%BB%D0%BE%D0%B2%D0%B8%D0%B5)
+ [Описание](#%D0%9E%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D0%B5)
+ [Откуда идея?](#%D0%9E%D1%82%D0%BA%D1%83%D0%B4%D0%B0_%D0%B8%D0%B4%D0%B5%D1%8F?)
+ [Почему я вообще решил, что нужна программа, разве обычной теории и простой тренировки не хватит?](#a)
+ [Почему Telegram бот?](#%D0%9F%D0%BE%D1%87%D0%B5%D0%BC%D1%83_Telegram_%D0%B1%D0%BE%D1%82?)
+ [Почему именно ScipIO?](#%D0%9F%D0%BE%D1%87%D0%B5%D0%BC%D1%83_%D0%B8%D0%BC%D0%B5%D0%BD%D0%BD%D0%BE_ScipIO?)
* [План](#%D0%9F%D0%BB%D0%B0%D0%BD)
+ [Почему без плана нельзя?](#%D0%9F%D0%BE%D1%87%D0%B5%D0%BC%D1%83_%D0%B1%D0%B5%D0%B7_%D0%BF%D0%BB%D0%B0%D0%BD%D0%B0_%D0%BD%D0%B5%D0%BB%D1%8C%D0%B7%D1%8F?)
+ [Сам план](#%D0%A1%D0%B0%D0%BC_%D0%BF%D0%BB%D0%B0%D0%BD)
+ [Инструмент для плана](#%D0%98%D0%BD%D1%81%D1%82%D1%80%D1%83%D0%BC%D0%B5%D0%BD%D1%82_%D0%B4%D0%BB%D1%8F_%D0%BF%D0%BB%D0%B0%D0%BD%D0%B0)
* [Подготовка](#%D0%9F%D0%BE%D0%B4%D0%B3%D0%BE%D1%82%D0%BE%D0%B2%D0%BA%D0%B0)
* [Основная часть](#%D0%9E%D1%81%D0%BD%D0%BE%D0%B2%D0%BD%D0%B0%D1%8F_%D1%87%D0%B0%D1%81%D1%82%D1%8C)
+ [База данных](#%D0%91%D0%B0%D0%B7%D0%B0_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85)
+ [Sqlite](#Sqlite)
+ [Mentally math](#Mentally_math)
+ [Task category](#Task_category)
+ [Flashcards](#Flashcards)
+ [Timer](#Timer)
+ [Статистика](#%D0%A1%D1%82%D0%B0%D1%82%D0%B8%D1%81%D1%82%D0%B8%D0%BA%D0%B0)
+ [admin](#admin)
+ [Сервер](#%D0%A1%D0%B5%D1%80%D0%B2%D0%B5%D1%80)
* [Заключение](#%D0%97%D0%B0%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B5)
+ [Что удалось сделать](#%D0%A7%D1%82%D0%BE_%D1%83%D0%B4%D0%B0%D0%BB%D0%BE%D1%81%D1%8C_%D1%81%D0%B4%D0%B5%D0%BB%D0%B0%D1%82%D1%8C)
+ [Будущее](#%D0%91%D1%83%D0%B4%D1%83%D1%89%D0%B5%D0%B5)
+ [Благодарности и пару красивых слов](#%D0%91%D0%BB%D0%B0%D0%B3%D0%BE%D0%B4%D0%B0%D1%80%D0%BD%D0%BE%D1%81%D1%82%D0%B8_%D0%B8_%D0%BF%D0%B0%D1%80%D1%83_%D0%BA%D1%80%D0%B0%D1%81%D0%B8%D0%B2%D1%8B%D1%85_%D1%81%D0%BB%D0%BE%D0%B2)
+ [Просьба о помощи](#%D0%9F%D1%80%D0%BE%D1%81%D1%8C%D0%B1%D0%B0_%D0%BE_%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D0%B8)
+ [Полезная литература](#%D0%9F%D0%BE%D0%BB%D0%B5%D0%B7%D0%BD%D0%B0%D1%8F_%D0%BB%D0%B8%D1%82%D0%B5%D1%80%D0%B0%D1%82%D1%83%D1%80%D0%B0)
### Предисловие
#### Описание
Scipio - это telegram-bot, который позволяет пользователям решать задачи по математике, логике, создавать свои собственные карточки, ставить запуск тренировки в определенное время - в общем, обучаться.
#### Откуда идея?
Летом 2020 года возникла идея, что нужно создать некую программу, которая помогала бы людям тренироваться решать примеры в уме (Например: перемножить числа 28 и 73 или возвести во вторую степень число 34) - это нужно, чтобы при решении математических и не только математических задач не отвлекаться на базовые примеры и решать их быстро и без проблем.
#### Почему я вообще решил, что нужна программа, разве обычной теории и простой тренировки не хватит?
Ответ на это - нет, не хватит. Чтобы получить любой навык и достичь в нём совершенства, нужна ежедневная, упорная **практика**.
Практика нужна в любом процессе обучения - без неё ваш навык утратит свою силу уже через несколько дней после изучения. И как раз для изучения навыка "Примеры для подсчёта в уме" я и решил создать этот проект, чтобы ежедневно решать примеры и тем самым тренироваться.
#### Почему Telegram бот?
Создание отдельный программы для телефона и для компьютера заняла бы слишком много времени. После размышления о различных вариантах появилась идея о создании telegram-бота.
Почему это было отличным решением? Потому что:
* Сам алгоритм бота будет общим для любого пользователя и работать как на компьютере, так и на любых телефонах
* Через ботов очень удобно взаимодействовать с пользователями. Если пользователю нужно получить какую-то информацию, ему нужно просто отправить боту сообщение
* Telegram в данный момент является одним из самых популярных, самых быстроразвивающихся и самых технологически хороших мессенджеров. + из-за последних событий популярность telegram устремилась вверх с огромными темпами
* 99% ботов в telegram написаны на языке python. Я не только активно применял данный язык в работе, но и хотел просто усовершенствовать свои навыки.
#### Почему именно ScipIO?
Название ScipIO не просто так. Cоздатель увлекается историей древнего Рима, а в ней Scipio (Сципион) был великим полководцем, который победил самого Ганнибала, а также в программировании (и в особенности в телеграмме) есть одно из основных понятий IO (input-output), которое значит ввод-вывод. Это способ взаимодействия программы с другими ее частями, или со внешним миром, а конкретнее с сервером.
### План
#### Почему без плана нельзя?
Если работать без плана, то вы будете принимать решения сумбурно, что может привести к тому, что:
* Уйдёт слишком много времени на создание проекта
* Вы сделали не то, что хотели или не сделали вовсе
* Вы, может, чему-то и научились, но без четкой иерархии и распределении знаний вся новая информация не сможет крепко закрепиться в вашей памяти.
#### Сам план
Первоначальный план бота состоял в том, чтобы сделать следующий функционал:
1. Mentally math (тренировка подсчета в уме)
2. category\_math, category\_logic (задачи по математике и логике)
3. Timer (Запуск тренировки в определенное время по желанию пользователя)
После выполнения данных пунктов, возникли идеи уже для следующих алгоритмов:
1. **flashcards** - тренировка по карточкам. С одной стороны написано слово и вы должны назвать слово с обратной стороны
2. **statistics** (для пользователей) - статистика решенных задач пользователя
3. **admin панель**:
* Отправка сообщения всем пользователям
* Статистика количества пользователей
#### Инструмент для плана
Чтобы не путаться в плане и задачах, я создал доску **trello**. Это отличный инструмент, т.к. он позволяет чётко и подробно составлять задачи, ставить цели и позволяет всей команде очень удобно просматривать задачи.
Если интересно, то таблица по-итогу выглядит так:![]()### Подготовка
Сесть за проект нельзя было так сразу и так просто, поэтому перед написанием была проведена подготовка:
* **Python** - тут проблем особенно не возникло, т.к. он уже был знаком мне. Тем не менее, для повторения (и укрепления) знаний была перечитана книжка Марка Лутца "Изучаем python".
> Также выдам ссылку на просмотр файла, в который я сохранял полезные ссылки и вырезки по python, пока повторял всё нужное (все ссылки находятся в Полезной литературе).
>
>
* **Асинхронность, а также многопроцессорность и многопоточность** - чтобы правильно работать с **aiogram**, нужно обязательно уметь взаимодействовать с асинхронностью (Не буду описывать что это значит и т.д., всё подробнее есть в полезных ссылках). Также я думал, что может пригодится уметь взаимодействовать с многопроцессорностью и многопоточностью, но пока в первых релизах бота оно не потребовалось
* **Aiogram** - это асинхронный python фреймворк для создания telegram-ботов. В качестве подготовки было написано несколько маленьких ботов, которые выполняли ту или иную функцию.
> И кстати, я всем советую так подготавливаться, поскольку при прочтении теории может сложиться впечатление, что вы всё знаете и понимаете, но сразу при создании основного бота будете сильно путаться и тупить. Избежать этого как раз и поможет создание маленьких ботов.
>
>
* **Sql, beatifulsoap, matplotlib, pillow** - все эти вещи были изучены или повторены уже при процессе написания бота. Это не те инструменты, для базового осознания которых требуется отдельно выделять время для изучения, и вы вполне можете их освоить уже в процессе.
### Основная часть
Далее рассказывается о самой работе наших алгоритмов и т.д. Тут не будет подробного технического объяснения функционала, т.к. всё более подробное содержится в [ReadMe](https://github.com/AndrewKentavr/ScipIO) нашего проекта или в комментариях кода.
#### База данных
Сначала БД нужна была нам, чтобы сохранять задачки по математике (category\_math) и логике. В дальнейшем база данных стала расширяться, т.к. появились потребности сохранять telegram\_id пользователей, карточки пользователей и т.д.
#### Sqlite
Sqlite был выбран, потому что это отличная СУБД для начала. Поддерживаются простые sql запросы (если хотите, можно также воспользоваться инструментом SQLAlchemy) и очень удобная программа на компьютере, позволяющая просматривать данные и взаимодействовать с БД.
> Но мы крайне не рекомендуем использовать Sqlite, когда вы уже запускаете проект для большого количества пользователей, т.к. Sqlite может быть и простой, но это локальная база данных и мерджить БД в git приходится вслепую.
> По возможности постарайтесь сразу изучить PostgreSQL, т.к. он технически более развит и намного функциональнее.
>
>
| Таблица | Описание |
| --- | --- |
| actions | Таблица действий пользователя. Например, при выполнении flc, выполняется функция *action\_add(message.from\_user.id, 'flc')*, которая добавляет данные в таблицу |
| category | Категории заданий |
| flashcards | Карточки пользователей |
| task\_logic | Задачи по категории логика |
| task\_math | Задачи по категории математика |
| time | Таймеры пользователей |
| users | Все пользователи, пользующиеся ботом |
Более подробное описание БД находиться в README
#### Mentally math
Как и говорилось, проект был изначально создан для алгоритма тренировки математических примеров, поэтому первой функцией **Scipio** стал /mentally\_math.
Функция работает так: у пользователя спрашивается готов ли он, а потом (если пользователь нажал “Да”) пользователю генерируется и присылается пример. Пользователь решает некоторое количество задач, и когда он нажимает на кнопку “Закончить примеры в уме”, бот присылает статистику (в неё входят id задач, правильные ответы на них, кол-во попыток понадобившихся на решение примера). Если пользователь хочет изучить или повторить теорию для решения примеров счета в уме, он должен прописать в бота /mell\_theory.
Кратное техническое описание алгоритма Mentally mathОсновной алгоритм очень схож с (flashcards\_training), но у него есть некоторое отличие, а именно алгоритм требует постоянно проверять ввод пользователя (ответ).
/mentally\_math - это тренировка счёта в уме. В зависимости от того, генерируется степень или умножение, диапазон чисел варьируется, но точнее он такой:
- Для умножения берётся 2 рандомных числа в диапазоне 11 - 99
- Для степени берётся 1 рандомное число от 11 - 99 и возводится в степень 2
#### Task category
Задачи по категориям - это функционал, с помощью которого пользователи могут сами решать задачи из выбранных категорий бота. Например, если пользователь зайдёт в *“категории по математике”* и выберет основную категорию *“Алгебра”*, а после выберет подкатегорию "Последовательности", то ему пришлёт задание из категории *“Последовательности”*, которое пользователь сам прорешивает, а потом сверяется с “Ответом”, а если непонятно, то смотрит на “Решение 1” или “Подсказка”.
Нам нужно было каким-то образом получить большое количество задач. И мы нашли решение - **парсинг**.
Парсинг всех заданий производился с помощью ряда библиотек:
1. **BeautifulSoup** - основная библиотека, с помощью которой происходил парсинг
2. **generate\_user\_agent** - библиотека каждый раз генерировала разный user\_agent, который помогал обходить блокировку со стороны сайта. После того, как задача была спарсена, мы добавляли её в json-файл.
После того, как задача была спарсена, мы добавляли её в json-файл. Делалось это для того, чтобы:
1. Если бы что-то случилось с БД, мы могли легко перенести всё обратно
2. При желании все эти json файлы можно было бы продать.
Когда json-файлы были созданы, всё было перенесено в БД
* Первая версия задач имела 631 математическую задачу
* Вторая версия задач имеет около 6000 мат. задач и около 1000 различных логических заданий
Кратное техническое описание алгоритма task category Функция работает так: бот проходится по таблице с математическими задачами и выводит все имеющиеся категории в виде inline кнопок. Когда пользователь выбирает категорию, программа берет из данной категории рандомную задачу и показывает её пользователю. При нажатии “Следующая задача” алгоритм срабатывает циклически, выводя другую задачу из той же категории.
#### Flashcards
Как объяснить концепцию карточек? Всё просто - вы когда-нибудь видели такие карточки, где на одной стороне например написано cat, а на другой стороне показан перевод слова? Вот такая же идея у этого функционала.
При создании пользователь вводит текст для лицевой стороны, далее для обратной стороны и будет ли карточка показываться с двух сторон при тренировке. Все эти данные потом заносятся в базу данных
Тренировка работает так. Если пользователь отметил “Правильно”, то при дальнейшей тренировке эта карточка показываться больше не будет , а если “Неправильно”, то наоборот будет показываться. Тренировка не закончится, пока пользователь или не закончит сам тренировку, или все карточки не будут отмечены “Правильно”.
Отличия 1 версии и 2 версии:
В первой версии карточки присылались в виде обычного текста.
 Во второй версии карточки приходят в виде фото.
Кратное техническое описание алгоритма flashcardsОсновная идея данного алгоритма в том, что из-за того что всё происходит в основной функции, то при нажатии "Правильно" и "Неправильно" следующее что делает функция flc\_game, это создаёт новую flashcard и вызывает саму себя. Из-за этого алгоритм после "Правильно"/"Неправильно" сразу создаёт новую flashcard и показывает её, не требуя ввести сообщение от пользователя.
Генерация карточек работает следующим образом: из базы данных берутся все карточки пользователя, если карточка показывается с двух сторон, то создается ее копия, где лицевая сторона становиться обратной, а обратная лицевой. После чего у нас есть список всех возможных карточек. Берется рандомная карточка, создается фотография этой карточки и отправляется пользователю
#### Timer
Сама идея таймера очень проста. Пользователю в назначенное им время должно приходить уведомление о том, что необходимо пройти “Ежедневное задание” по 1 из 4 выбранной им категорий заданий (категории логика, категории математика, карточки, примеры в уме).
Технически таймер выглядит так:
При запуске бота запускается таймер, который каждые 60 секунд проверяет по БД, есть ли какой-то таймер пользователя в данное время, и если есть, то отправляет сообщение с ежедневным заданием пользователю, который этот таймер и создал.
### 1 версия таймера
1 версия таймера была разработка вручную и основывалась на функции `asyncio.sleep(60)`, которая асинхронно ждала и запускала блок проверки времени now со таймерами пользователей.
Но у неё была основная проблема, которая заключалась в том, что таймер запускался только тогда, когда администратор пропишет специальную команду, а не одновременно с запуском команды.
> Почему нельзя было засовать эту функцию одновременно с запуском бота, то есть в `if __name__ == "__main__":`
>
> Потому что, если запустить функцию таймера до `asyncio.run(main())`, то она блокирует работу всего бота (т.к выполняется бесконечно), а если после, то таймер просто не запускается, т.к выполняется работа бота
>
>
### 2 версия таймера
2 версия таймера была намного лучше, т.к основывается на библиотеке apscheduler, которая удобно и гибко позволяет проводить настройки асинхронного таймера и решает проблему с одновременным запуском бота и таймера.
#### Статистика
Этот функционал создан, чтобы подробнее показывать статистику решёных задач пользователю. А именно:
* Пользователь запускает /statistics, которое показывает:
+ Количество показов flc, cat\_math, cat\_logic, ment\_math пользователя за всё время
+ Составляет круглую диаграмму по данным выше
+ 
+ Составляет диаграмму bar действий разных типов actions пользователя за неделю
+ 
Работа данного алгоритма основана на библиотеке matplotlib, которая позволяет строить подробные и функциональные графики.
\*более подробное техническое описание находится в коде проекта, а именно в файле `handlers/statistics/charts.py` \*
#### admin
Админ панель.
В нее входит две функции:
1. *Отправка сообщения всем* - для информирования пользователей telegram бота. Данная функция перебирает всех пользователей из базы данных и отправляет каждому сообщение, набранное админом
2. *Статистика пользователей* - показывает количество пользователей, сколько новых пользователей за день, за прошедшие 7 дней и за прошедшие 30 дней.
#### Сервер
Про устройство сервера и как мы отправляли заливали туда код, я рассказывать не буду, т.к с этим нужно разобраться каждому человеку, но расскажу впринципе про сервер бота
В качестве первого (тестирующего) сервера - был Raspberry Pi. Его плюсы заключались в том, что:
* Raspberry Pi - предназначен для начинающих, а соответственно вся настройка в нём происходила интуитивно понятно
* Это хоть и маленький, но достаточно мощный компьютер. Конкретно у меня raspberry Pi имеет 4 гб оперативной памяти, что очень хорошо
* То что оно было под рукой, уже тоже плюс
Но Raspberry нельзя было использовать в качестве постоянно сервера, потому что:
1. Зависело от электричество дома, в котором я живу
2. Могло перегреться или просто не выдержать нагрузки и полететь
3. Для серьёзного сервера и для дальнейшей работы не подходило
Raspberry Pi хоть и отлично справилось со своей задачей, но как и говорил, нужно было что-то более серьёзное, поэтому начался поиск сервиса, который смог бы помочь с этим вопросом.
Таким сервисом оказался Google Cloud. Почему именно он? Потому что:
1. Это серьезный инструмент, навык владения которым поможет в дальнейшей работе.
2. Сервера удаленные, и поэтому если ляжет мой сервер из-за электричества, то ляжет пол мира.
3. Есть гибкая настройка сервера, поэтому если не будет хватать мощностей, то можно будет просто обновить сервер
4. Google Cloud - оказался бесплатным на 3 месяца, что стало ещё одним отличным плюсом для нас.
В данный момент сам сервер выглядит вот так:
А это нагрузка сервера:
### Заключение
#### Что удалось сделать
На данный момент, наш бот имеет:
* более 4000 различных задач (категории логики и математики), которые можно решать пользователю
* функционал *flashcard*, который позволяет пользователям самим создавать все карточки и проходить тренировку по ним
* функционал *mentally\_math*, который позволяет тренировать подсчёт в уме.
* функционал *timer*, напоминающий о "Ежедневных тренировках"
* функционал *statistics*, показывающий статистику о прорешёных задачах пользователя
* Функционал *admin*, отправляющий сообщения всем пользователям, а также позволяющий просматривать администраторам статистику о новых и о всех имеющихся пользователях
* Понятный код и ReadMe файл, который позволяет разработчикам удобно повзаимодействовать с кодом
#### Будущее
В будущем наш проект будет развиваться и мы хотим сделать для него:
* Удобную Базу Данных. А именно полностью перейти на Postgresql
* Классный telegram-канал. Пока он хранит в себе лишь тестовые статьи, но уже скоро там будет активно публиковаться информация о боте, а также интересные статьи и полезные ссылки
* Удобную панель управления для администраторов и модераторов задач.
* Сделать различные наборы карточек(flashcards).
* И много чего другого
#### Благодарности и пару красивых слов
Отдельно хочется выразить благодарность MasterGroosha и сообществу aiogram, без них этого проекта не было бы.
Пользуйтесь нашим ботом: [t.me/scipio\_edu\_bot](http://t.me/scipio_edu_bot)
Переходите в [GitHub](https://github.com/AndrewKentavr/ScipIO#Mentaly_math), чтобы попробовать пошаманить с ботом или помочь нам
Переходите в наш telegram-канал (он будет развиваться, зуб даю): <https://t.me/scipio_edu_channel>
Команда разработчиков:
* Андрей Тощаков - создатель проекта, основной разработчик (ник в telegram: [@Endrey\_k](/users/Endrey_k))
* Ахмед Шагбанов - основной разработчик (ник в telegram: [@ShagbanovAhmed](/users/ShagbanovAhmed))
* Татьяна Самохвалова - многочисленная помощь в редактировании, коррекции данных и т.д
* Жанна Клыпо - за создание "оформления" бота (логотип, бэкграунды и т.п)
#### Просьба о помощи
Поскольку наш бот развивается и много чего там работает плохо или не работает вообще, то мы крайне ждём от вас помощи, советов и т.д. Для связи пишите в личку Андрея, Ахмеда или переходите на наш [GitHub](https://github.com/AndrewKentavr/ScipIO#Mentaly_math)
### Полезная литература
Есть список полезных ссылок от официального [aiogram](https://telegra.ph/aiogram-ru-01-28) сообщества и от [MasterGroosha](https://telegra.ph/faq-02-07-6)
* [Моя ссылка про python](https://docs.google.com/document/d/13p81NCkKTyvy0TiV3DAE44VGfxc1HdPao48_8u5TSs4/edit?usp=sharing)
* [Вводная статья на хабре про ботов](https://habr.com/ru/post/543676)
* Многопоточность и многопроцессорность:
+ [Отличная статья про многопоточность и многопроцессорность на анг](https://www.geeksforgeeks.org/difference-between-multithreading-vs-multiprocessing-in-python)
+ [Официальная документация про многопот. и многопроц.](https://docs.python.org/3/library/multiprocessing.html?source=post_page-----48b59bfcc89e----------------------)
+ [Видосы про многопроцес. и многопоточность (анг)](https://www.youtube.com/watch?v=fKl2JW_qrso)
* Асинхронность:
+ [Асинхронность в Python](https://botfather.dev/blog/async-in-python#asyncio-lib)
+ [Асинхронное программирование в Python: краткий обзор](https://habr.com/ru/company/ruvds/blog/475246)
+ [Видосы от Яндекса](https://www.youtube.com/watch?v=AXkOli6BsBY&list=PLQC2_0cDcSKBHamFYA6ncnc_fYuEQUy0s&index=10)
* Парсинг:
+ [Парсинг сайтов на Python: подробный видеокурс](https://www.youtube.com/watch?v=AFqYxaOyqy0&list=PLqGS6O1-DZLprgEaEeKn9BWKZBvzVi_la)
+ [Парсинг pdf файлов (pdfminer)](https://python-scripts.com/exporting-data-from-pdf)
* Дополнительно
+ [Учебник по git](https://githowto.com/ru)
+ Коды для matplotlib и ссылки
### Aiogram:
* [Mastergroosha - лучшая статья](https://mastergroosha.github.io/telegram-tutorial-2)
* [Плейлист tutorial по aiogram (Latand)](https://www.youtube.com/watch?v=wj1Vwq3IrL4&list=PLwVBSkoL97Q3phZRyInbM4lShvS1cBl-U)
* [Официальные примеры aiogram docs](https://docs.aiogram.dev/en/latest/examples/index.html)
* [Как сделать функции таймера в боте](https://botfather.dev/blog/zapusk-funkczij-v-bote-po-tajmeru)
* [Коды маленьких ботов](https://github.com/AndrewKentavr/bot_study_aiogram)
### Чаты
* [Официальный чат aiogram](https://t.me/aiogram_ru), где сидит главный разработчик aiogram
* [Чат MasterGroosha](https://t.me/joinchat/TsftDfnevFLQS1ts) | https://habr.com/ru/post/658115/ | null | ru | null |
# Прозрачный прокси сервер Squid с паролем на Ubuntu 11.04
Недавно появилась задача реализовать некоторые функции Kerio в linux, а именно авторизацию
пользователей прокси сервера Squid в режиме transparent. Это сделать довольно просто и на
просторах интернета много статей как это сделать, но появилась проблема в режиме transparent
(прозрачный прокси) авторизация не работает. Конечно если у Вас небольшое количество пользователей
это не является проблемой, отключил transparent прописал у всех прокси сервер в браузерах и все.
Но когда пользователей и компьютеров становиться много и прописывать прокси сервер у всех нет
возможности/времени, тут приходиться искать решения. Одно из решений это связка Squid+PHP+NAT.
Система на которой все это тестировалось и в дальнейшем работала Ubuntu 11.04.
Устанавливаем: MySQL, PHP5, Apache2, iptables, squid
`apt-get install squid mysql-server mysql-client php5 apache2`
Включаем режим transparent в Squid:
`nano /etc/squid/squid.conf
# NETWORK OPTIONS
http_port 192.168.0.1:3128 transparent`
Разрешаем прохождение трафика:
`echo "1" > /proc/sys/net/ipv4/ip_forward`
Настраиваем NAT в iptables:
`iptables -t nat -A POSTROUTING -s 192.168.0.0/24 -j MASQUERADE`
Заворачиваем 80 порт в Наш сервер:
`iptables -t nat -A PREROUTING -s 192.168.0.0/24 -p tcp -m tcp --dport 80 -j DNAT --to-destination 192.168.0.1:80`
В файл /etc/php5/apache2/php.ini добавляем:
`extension=pdo.so
extension=pdo_mysql.so`
Далее создаем базу данных где будут храниться у нас пользователи
`mysql -u root -p
CREATE DATABASE authphp CHARACTER SET utf8;`
Подключаемся к новой базе:
`\r authphp`
Создаем таблицу с полями login и password
`CREATE TABLE User (login CHAR(20), password CHAR(20));`
Добавляем данные в таблицу
`INSERT INTO User VALUES ('user','qwerty');`
Выходим из консоли mysql
`\q`
Таким образом мы создали базу данных и внесли туда пользователя «user» с паролем «qwerty»
Дальше настала очередь самого php скрипта который будет осуществлять авторизацию
Для работы с базой я использовал библиотеку RedBeanPHP, которую можно скачать в
[официального сайта](http://redbeanphp.com/)
Содержание файла index.php
`php<br/
require('rb.php');
$ip = getenv ("REMOTE_ADDR");
R::setup('mysql:host=localhost;dbname=authphp','root','qwerty');
if( $user = R::findOne('User',' login = ? and password = ?',
array( $_SERVER['PHP_AUTH_USER'], $_SERVER['PHP_AUTH_PW'] ) )
)
{
header('Location: next.html');
system("sudo iptables -t nat -D PREROUTING -s 192.168.0.0/24 -p tcp -m tcp --dport 80 -j DNAT --to-destination 192.168.0.1:80");
system("sudo iptables -t nat -D PREROUTING -s $ip -p tcp -m tcp --dport 80 -j REDIRECT --to-ports 3128");
system("sudo iptables -t nat -A PREROUTING -s $ip -p tcp -m tcp --dport 80 -j REDIRECT --to-ports 3128");
system("sudo iptables -t nat -A PREROUTING -s 192.168.0.0/24 -p tcp -m tcp --dport 80 -j DNAT --to-destination 192.168.0.1:80");
exit(0);
}
$title = "Squid Server";
{
header('WWW-Authenticate: Basic realm="'.$title.'"');
header('HTTP/1.0 401 Unauthorized');
die("Otkaz");
}
?>`
Содержание файла hext.html
`META HTTP-EQUIV="Refresh" CONTENT="0; URL=http://google.ru"`
Только поставьте перед META "<" и после URL=http://google.ru" ">"
Таким образом пользователя, который хочет выйти в интернет, с начало заворачивает на сервер где
выполняется php скрипт. После того как пользователь ввел свои логин и пароль, добавляются правила
в iptables, и 80 порт пользователя заворачивается в squid на порт 3128
Собственно вот и все, естественно можно навести красоту и сделать в обще что бы было
похоже на Kerio, так же можно добавить что бы подключение сбрасывалось через допустим час
и требовала снова авторизации. В общем есть поля для творчества.
Надеюсь это будет кому-нибудь полезно, удачи. | https://habr.com/ru/post/140052/ | null | ru | null |
# Советы по отладке в Visual Studio 2010
Это двадцать шестая публикация [в серии публикаций](http://weblogs.asp.net/scottgu/archive/2009/08/25/vs-2010-and-net-4-series.aspx) о VS 2010 и .NET 4.
Сегодняшняя публикация рассматривает некоторые полезные советы по отладке которые вы можете применять в Visual Studio. Мой друг Скот Кэйт (Scott Cate) (который опубликовал в [блоге](http://scottcate.com/Tricks/) дюжину великолепных советов и трюков по VS) недавно обратил мое внимание на несколько хороших советов о которых не знает много разработчиков использующих Visual Studio (даже при том, что многие из них работают с ней уже давно с более ранних версий).
Надеюсь эта публикация поможет вам узнать о них, если вы еще не знаете о них. Все они просты для изучения, а могут сэкономить вам кучу времени.
**Run to Cursor (Ctrl + F10) (Выполнить до курсора)**
Часто я наблюдаю людей отлаживающих приложения следующим образом: они устанавливают точку останова на много раньше того места которое их интересует, а затем постоянно пользуются F10/F11 чтобы пройти по коду пока не будет достигнуто то место, которое на самом деле они хотят исследовать. В некоторых случаях они внимательно осматривают каждое выражение, через которое они проходят (в таких случаях использование F10/F11 имеет смысл). Однако, чаще, люди просто пытаются быстро перейти к строке кода которая на самом деле их интересует — в таких случаях использование F10/F11 это не лучший способ для достижения такой цели.
Вместо этого, вы можете воспользоватся функцией “run to cursor” («выполнить до курсора») которая поддерживается отладчиком. Просто установите курсор на строке кода до которой вы хотите выполнить приложение, а затем нажмите вместе Ctrl + F10. Это приведет к выполнению приложения до этой строки и переходу в режим отладки сохраняя время которое могло быть потрачено на множественные нажатия F10/F11 для того, чтобы попасть сюда. Это работает даже в тех случаях, когда код в который вы хотите попасть находится в отдельном методе или класс по отношению к тому месту которое вы в данный момент отлаживаете.
**Conditional Breakpoints (Условные точки останова)**
Другой распространенной ситуацией которую мы часто наблюдаем являются случаи, когда разработчики устанавливают точки останова, выполняют приложение, проверяют определенный ввод, попадают на точку останова и затем вручную проверяют является ли условие истинным перед тем как принять решение о переходе к дальнейшему рассмотрению в режиме отладки. Если сценарий не соответствует, что они делают дальше, они жмут F5 для продолжения выполнения приложения, проверяют какой-нибудь другой ввод и повторяют процесс вручную.
Способность Visual Studio задания условных точек останова предоставляет намного, намного более легкий способ для того, чтобы этого добиться. Условные точки останова позволяют вам переходить в режим отладки только, если какое-то определенное условие которое было назначено достигнуто. Условные точки останова помогают вам избежать ручного изучения кода с его дальнейшим выполнением, а также могут сделать весь процесс отладки не требующим вашего ручного вмешательства и избавят вас от скучной работы.
Как включить Conditional Breakpoint (Условную точку останова)
Настройка условных точек останова в реальности проста. Нажмите в коде F9, чтобы установить точку на определенной строке (*прим. пер. вы также можете установить точку останова кликнув мышью на левой границе окна редактора ровно на уровне строки, где нужно поставить точку останова*):
Затем щелкните правой кнопкой мыши на красном кружке точки останова слева от окна редактора и выберите контекстное меню «Condition...» («Условие...»):
Это приведет к появлению диалогового окна, которое позволяет указать, что точка останова должна срабатывать только, если определенное условие истинно. Например, мы можем указать, что на нужно переходить в отладку, если размер локального списка paginatedDinners менее 10-и, вписав следующее выражение ниже:
Теперь, когда я перезапущу приложение и выполню поиск, отладчика будет включена только если я выполню поиск которые вернет меньше чем 10 обедов. Если будет больше 10-и обедов, тогда точка останова не будет достигнута.
Функция Hit Count (Число попаданий)
Иногда вам нужно, чтобы происходила остановка отладчика только при условии, что условие истинно N-раз.
Например, останавливаться только, если уже 5 раз поиск возвратил меньше чем 10 обедов.
Вы можете включить такое поведение правым щелчком на точке останова и выбором пункта меню «Hit count...» («Количество попаданий...»).
Это приведет к появлению диалогового окна, которое позволяет указать, что точка останова должна быть достигнута только N-раз, когда достигнуто условие или каждые N-раз, когда оно достигнуто, или каждый раз после N вхождений:
Фильтрация по Machine/Thread/Process (Имя машины/Поток/Процесс)
Вы можете также щелкнуть правой кнопкой на точке останова и выбрать пункт «Filter...» («Фильтр...») из контекстного меню, чтобы указать, что точка останова должна быть достигнута, если процесс отладки происходит на определенной машине или в определенном процессе или в определенной потоке.
**Точки трассировки (TracePoints) – пользовательские события при попадании в точку останова**
Функция отладчика о которой многие люди не знают это возможность использовать [TracePoints (Точки трассировки)](http://msdn.microsoft.com/en-us/library/232dxah7(v=VS.80).aspx). Точка трассировки это точка останова при достижении которой срабатывает пользовательское событие. Эта функциональность особенно полезна, когда вам нужно отследить поведение в вашем приложении без остановки в отладке.
Я использую простое консольное приложение (Console application), чтобы продемонстрировать как мы могли бы воспользоваться Точками трассировки. Ниже приведена рекурсивная реализация [ряда Фибоначчи](http://www.hanselman.com/blog/TheWeeklySourceCode13FibonacciEdition.aspx):
В приложении приведенном выше мы используем Console.WriteLine() чтобы выводить окончательные значение ряда для конкретного значения диапазона. Что если мы захотели отследить рекурсивную последовательность ряда Фибоначчи в действии одновременно с отладкой – без фактической его остановки или приостановки? Точки трассировки могут помочь нам легко это сделать.
Установка точки трассировки (TracePoint)
Вы можете включить точки трассировки воспользовавшись клавишей F9 для установки точки останова в строке кода и затем щелкнув правой кнопкой на точке останова и выбрав пункт «When Hit...» («Когда Попадает...») из контекстного меню:
Это приведет к появлению диалогового окна, которое позволяет вам указать, что должно произойти когда достигнута точка останова:
Выше мы указали, что хотим выводить трассировочное сообщение каждый раз, когда условие точки останова достигнуто. Заметьте, что мы указали, что мы хотим выводить значение локальной переменной «x» как части сообщения. На локальные переменные можно ссылаться используя синтаксис {variableName}. Также есть встроенные команды (такие как $CALLER, $CALLSTACK, $FUNCTION и т. д.) которые могу использоваться для вывода общих значений в ваши трассировочные сообщения.
Выше мы также поставили флажок напротив «continue execution» («продолжать выполнение») внизу, который указывает на то, что нам не нужно, чтобы приложение останавливалось в отладчике. Наоборот оно будет продолжать выполняться лишь с той разницей, что наше пользовательское сообщение трассировки будет выводится каждый раз, когда будут достигнуты условия точки останова.
А теперь, когда мы выполняем приложение, мы увидим, что наше пользовательское сообщение трассировки автоматически отображается в окне Visual Studio «output» («вывод») позволяя нам следить за рекурсивным поведением приложения:
Как альтернатива описанному выше методу вы можете создать слушатель пользовательской трассировки для вашего приложения, в этом случае, сообщения генерируемые в точках трассировки будет перенаправляться в него вместо окна вывода VS.
**Точки трассировки (TracePoints) – выполнение пользовательского макроса**
В разговоре который у меня состоялся на прошлой неделе в Лондоне, кто-то из аудитории спросил, возможно ли автоматически выводить локальные переменные, когда достигнута Точка останова (TracePoint).
Эта возможность не встроена в Visual Studio, но может быть включена при помощи пользовательского макроса и последующей настройки Точки трассировки для вызова макроса, когда эта точка достигнута. Чтобы это выполнить откройте интегрированную среду для макросов внутри Visual Studio (Tools->Macros->Macros IDE menu command). Далее под узлом MyMacros в обозревателе проекта выберите модуль или создайте новый (например: с именем “UsefulThings”). После этого вставьте следующий код макроса на VB в модуль и сохраните его:
**VB:**
``> Sub DumpLocals()
>
>
>
> Dim outputWindow As EnvDTE.OutputWindow
>
>
>
> outputWindow = DTE.Windows.Item(EnvDTE.Constants.vsWindowKindOutput).Object
>
>
>
> Dim currentStackFrame As EnvDTE.StackFrame
>
>
>
> currentStackFrame = DTE.Debugger.CurrentStackFrame
>
>
>
> outputWindow.ActivePane.OutputString("\*Dumping Local Variables\*" + vbCrLf)
>
>
>
> For Each exp As EnvDTE.Expression In currentStackFrame.Locals
>
>
>
> outputWindow.ActivePane.OutputString(exp.Name + " = " + exp.Value.ToString() + vbCrLf)
>
>
>
> Next
>
>
>
> End Sub
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**C#**
``> void DumpLocals() {
>
> EnvDTE.OutputWindow outputWindow;
>
> outputWindow = DTE.Windows.Item[EnvDTE.Constants.vsWindowKindOutput].Object;
>
> EnvDTE.StackFrame currentStackFrame;
>
> currentStackFrame = DTE.Debugger.CurrentStackFrame;
>
> outputWindow.ActivePane.OutputString(("\*Dumping Local Variables\*" + "\r\n"));
>
> foreach (EnvDTE.Expression exp in currentStackFrame.Locals) {
>
> outputWindow.ActivePane.OutputString((exp.Name + (" = "
>
> + (exp.Value.ToString() + "\r\n"))));
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Код макроса приведенный выше циклически проходит по текущему стеку и выводит все переменные в окно вывода.
Использование нашего пользовательского макроса DumpLocals
Затем мы можем использовать наш пользовательский макрос «DumpLocals» простое дополнительное приложение, которое приведено ниже:
Мы воспользуемся клавишей F9 для установки точки останова на возвращающее выражение в нашем методе
«Add» приведенном выше. Затем щелкнем правой кнопкой на точке останова и выберем из контекстного меню команду «When hit» («Когда останавливаться»):
Это приведет к появлению следующего диалогового окна. В отличие от предыдущего кода, где мы использовали флажок «Print a message» («Выводить сообщение») и в ручную определяли переменные которые мы хотим вывести, в этот раз вместо этого мы выберем флажок «Run a macro» («Выполнить макрос») и укажем макрос UsefulThings.DumpLocals который мы создали выше:
Мы оставим флажок «continue execution» («продолжить выполнение»), так чтобы программа продолжала выполняться даже после достижения Точки трассировки.
Запуск приложения
А теперь, когда мы нажмем клавишу F5 и запустим приложение мы увидим следующий вывод в окне «output» («вывод») Visual Studio, когда будет запущен наш метод Add. Заметьте как макрос автоматически выводит в списке имя и значение каждой переменной, когда достигается Точка трассировки:
**Итог**
Отладчик Visual Studio невообразимо богат функциями. Я настоятельно рекомендую выделить определенное время, чтобы по-настоящем изучить все его возможности. Описанные выше советы и трюки представляют лишь малую долю его возможностей о которых люди на самом деле не осведомлены.
В прошлый раз я написал в блоге о других улучшениях в отладчике VS 2010 (включающих вывод подсказки по типу данных (DataTip), Импорт/Экспорт точек останова, Сохранение последних значений переменных и многое другое). Я буду дальше писать в блоге о новых возможностях VS 2010: Intellitrace, а также поддержке Отладки файла дампа. Публикации буду описывать кучу дополнительных крутейших новых возможностей которые могут сделать отладку приложений еще легче.
Также не забудьте посмотреть превосходную серию Скота Кэйта Visual Studio 2010 Tips and Tricks, чтобы узнать как лучше использовать Visual Studio. У него есть бесподобный набор бесплатных видео и публикаций в блоге.
Надеюсь это поможет,
Scott
P.S. В дополнение к публикациям в блоге, я также теперь использую twitter для быстрых обновлений и обмена ссылками. Следуйте за мной: twitter.com/scottgu`` | https://habr.com/ru/post/102178/ | null | ru | null |
# Мониторинг служб systemd в реальном времени с помощью Chronograf
> Уже сегодня **стартуют занятия в новой группе курса** [**"Мониторинг и логирование: Zabbix, Prometheus, ELK"**](https://otus.pw/REqL/) **от OTUS**. В течении **ближайшей недели** у всех желающих будет возможность **присоединиться к курсу по** [**специальной цене**](https://otus.pw/REqL/). Ну а прямо сейчас мы делимся традиционным переводом полезного материала по теме**.**
>
>
---
С systemd знакомы все системные администраторы. Разработанный Леннартом Пёттерингом ([Lennart Poettering](https://fr.wikipedia.org/wiki/Lennart_Poettering)) и freedesktop.org, systemd представляет собой очень удобный инструмент для управления сервисами в Linux. Большинство современного программного обеспечения поставляется в виде systemd-служб.
Но что происходит, когда какая-нибудь служба падает? В большинстве случаев вы обнаружите это, когда уже нанесен какой-то ущерб.
Сегодня мы создадим дашборд для мониторинга служб systemd в реальном времени. На нем будут активные, неактивные и упавшие службы, а также реализована отправка сообщений в Slack!
Дашборд для systemd1. Несколько слов о D-Bus
-------------------------
Прежде чем перейдем к архитектурным вопросам и кодированию, давайте быстро вспомним, что такое D-Bus и как он может помочь в достижении цели (если вы эксперт по D-Bus, то можете смело переходить к разделу 2).
D-Bus — это шина межпроцессного взаимодействия, которая позволяет взаимодействовать нескольким приложениям, зарегистрированным на ней.
Приложения, использующие D-Bus, являются либо серверами, либо клиентами. Клиент подключается к серверу D-Bus, слушающему входящие подключения. При подключении к серверу D-Bus приложения регистрируются на шине и получают имя для их идентификации.
После этого приложения обмениваются сообщениями и сигналами, которые могут быть перехвачены клиентами, подключенными к шине.
Назначение D-Bus поначалу может показаться немного туманным, но это очень полезный инструмент для Linux-систем.
Например, служба UPower (отвечающая за мониторинг источников питания) может обмениваться данными со службой thermald (контролирующей общую температуру), чтобы снизить энергопотребление в случае обнаружения проблем перегрева (вы этого даже не заметите).
Но какая связь между D-Bus и мониторингом служб systemd? Systemd зарегистрирован на D-Bus как сервис org.freedesktop.systemd1. Кроме того, он отправляет некоторые сигналы клиентам, когда состояние systemd-служб изменяется. И именно это мы будем использовать для нашего мониторинга.
2. Получение сигналов D-Bus
---------------------------
В этой статье я использую машину с Xubuntu 18.04 и стандартным ядром. На ней должен быть запущен `dbus-daemon` и установлена утилита `busctl`.
Это можно проверить запустив:
`ps aux | grep dbus-daemon`
В результате должно быть как минимум две записи: одна системная шина и одна сессионная.
`busctl status`
Эта команда проверяет состояние шины и возвращает ее конфигурацию.
### Определение полезных сигналов D-Bus
Как было сказано ранее, служба systemd регистрируется на шине и отправляет сигналы, когда происходит что-то, связанное с systemd.
При запуске, остановке или падении службы systemd отправляет сигнал по шине всем доступным клиентам. Поскольку systemd отправляет очень много событий, то для их анализа мы перенаправим стандартный вывод в файл.
`sudo busctl monitor org.freedesktop.systemd1> systemd.output`
В файле мы видим множество сообщений, вызовов методов, возвратов методов и сигналов.
Сигналы на шине systemdОбратите внимание на строку "ActiveState" со значением "deactivating"? Это останавливается моя служба InfluxDB. Мы даже можем получить время, связанное с изменением!
Сервис **org.freedesktop.systemd** определяет шесть различных состояний: active (активное), reloading (перезагрузка), inactive (неактивное), failed (сбой), activating (активация), deactivating (деактивация). Очевидно, что нам особенно интересен failed-сигнал, поскольку он сообщает о сбое службы.
Теперь, когда у нас есть возможность вручную перехватывать сигналы systemd в системе, давайте создадим полностью автоматизированную систему мониторинга.
3. Архитектура и реализация
---------------------------
Для мониторинга служб systemd мы будем использовать следующую архитектуру:
Конечная архитектура мониторинга systemdАрхитектура довольно простая. Главное — убедиться, что запущен dbus-daemon.
Далее нам необходимо создать простого клиента D-Bus (на Go!), который будет подписываться на сигналы от systemd. Все входящие сигналы будут анализироваться и сохраняться в InfluxDB.
После сохранения данных в InfluxDB мы создадим дашборд в Chronograf, отображающий статистику по службам и их текущее состояние.
Когда служба падает, Kapacitor (движок потоковой обработки) подхватывает соответствующий сигнал и автоматически отправляет сообщение в Slack системным администраторам.
Все просто! Верно?
### Создание клиента D-Bus на Go
Первым шагом к перехвату сигналов, поступающих от systemd, является создание простого клиента, который будет:
1. Подключиться к шине
2. Подписываться на сигналы systemd
3. Парсить данные и отправлять их в InfluxDB
Примечание: вам может быть интересно, почему я выбрал Go для создания клиента D-Bus. Клиентские библиотеки [dbus](https://github.com/coreos/go-systemd) и [InfluxDB](https://github.com/influxdata/influxdb1-client) написаны на Go, что делает этот язык идеальным кандидатом для этого небольшого эксперимента.
Код клиента достаточно длинный для того, чтобы его можно было полностью привести в этой статье, но я приведу ниже основную функцию, которая выполняет большую часть работы. Полный код доступен на [Github](https://github.com/SCHKN/systemd-monitoring).
Для каждого отдельного сигнала от systemd в InfluxDB создается точка. Я выбрал такую реализацию, потому что хотел иметь полную историю всех изменений, происходящих в разных службах. Это может быть весьма полезно для расследования некоторых повторяющихся сбоев в течение определенного периода времени.
### Варианты реализации
Для структуры данных в InfluxDB в качестве тегов (меток) я выбрал имя службы (для целей индексации), а в качестве значения — состояние (failed, active, activating …).
Также я использую простой маппинг значений состояния в числа. Агрегатные функции IQL работают лучше с числовыми значениями, чем с текстовыми.
Примечание: в приведенном выше фрагменте кода можно заметить, что я получаю много свойств от systemd, но извлекаю только свойство "ActiveState", которое вы видели в первом разделе.
Теперь, когда у нас есть простой клиент на Go, давайте превратим его в службу, запустим и перейдем к Chronograf.
4. Дашборд для сисадминов
-------------------------
Когда у нас есть данные в InfluxDB, начинается самое интересное. Создадим дашборд в Chronograf отображающий статистику по службам и индикаторы для отдельных служб, которые мы хотим отслеживать.
Дашборд состоит из трех основных частей:
1. Количество активных, неактивных и упавших служб в данный момент времени.
2. Таблица, показывающая полную историю изменений состояния во времени по каждой службе.
3. 12 индикаторов, отображающих 12 различных служб systemd, на которые мы хотим обратить особое внимание.
Примечание: предполагается, что у вас есть некоторые предварительные знания Chronograf, вы знаете как его настроить и связать с InfluxDB. Документация доступна [здесь](https://docs.influxdata.com/chronograf/v1.7/).
### Количество активных, неактивных и упавших служб
Вот вариант создания блока с одной метрикой:
### Полная история изменений состояния
Похожим образом создаем таблицы истории:
### Индикаторы для отдельных служб
Конечно же, я призываю вас поиграть с виджетами и создавать свои собственные дашборды. Ваш дашборд не должен быть точной копией представленного выше.
Теперь, когда у нас есть дашборд, мы можем мониторить systemd-службы в реальном времени. Здорово!
Но что, если бы у нас еще были оповещения в реальном времени в Slack?
5. Отправка алертов при сбое службы
-----------------------------------
Мы будем использовать Kapacitor (движок потоковой обработки), который отвечает за создание и обработку алертов в случае сбоя служб.
После установки и запуска Kapacitor, давайте вернемся в Chronograf и перейдем к панели алертов.
При нажатии на кнопку "Manage Tasks" вы увидите два раздела: правила алертов (alert rules) и сценарии (tick scripts). Давайте создадим новый алерт, нажав на кнопку "Build Alert Rule".
Ниже приведена полная конфигурация алертов:
Этот алерт настроен на отправку оповещений на веб-хук Slack'а, если в течение пятнадцати минут служба не отвечает (т.е. значение состояния равно минус единице). На стороне Slack оповещение имеет следующий вид:
6. Заключение
-------------
Я многому научился, создавая этот маленький проект. Не имея опыта работы с D-Bus и Golang, этот эксперимент научил меня, что выход из зоны комфорта (даже в программировании) — это путь к развитию новых навыков.
Процесс создания подобного дашборда может показаться трудоемким, но после его развертывания он приносит реальную пользу группам эксплуатации и системным администраторам.
Если вам нравится создавать собственные решения для мониторинга, вы, безусловно, можете почерпнуть из этой статьи некоторые идеи. Но если вам больше нравится использовать готовые инструменты, то я бы определенно рекомендовал SignalFX или Telegraf. Это надежные и эффективные решения для вашей инфраструктуры.
> [Посмотреть специальное предложение](https://otus.pw/REqL/)
>
>
Рекомендуемые к прочтению статьи:
---------------------------------
* [Мониторинг Kubernetes с помощью Prometheus и Thanos](https://habr.com/ru/company/otus/blog/526618/)
* [Управление алертами с помощью Alerta.io](https://habr.com/ru/company/otus/blog/527918/) | https://habr.com/ru/post/529468/ | null | ru | null |
# Студенты, лабы и python: обработка данных
В своей [предыдущей заметке](https://habr.com/ru/post/546956/) на тему обработки данных лабораторных работ я написал об использовании пакета [gnuplot](http://gnuplot.info/) – простого и мощного инструмента для решения подобных задач и графического представления результатов. Однако довольно распространённым является мнение, что студенты, которым я советовал использовать gnuplot, вероятно, изучают программирование и способы визуализации данных, и что для них более естественным и полезным будет практическое применение уже полученных навыков в этой сфере. В этом коротком тексте мы рассмотрим применение [python](https://www.python.org/) с использованием библиотек [scipy](https://www.scipy.org/index.html) для обработки данных и [matplotlib](https://matplotlib.org/) для представления результатов.
---
Возьмём тот же пример, что и в [предыдущем тексте](https://habr.com/ru/post/546956/) (там нужно посмотреть формулировку задачи). С моделированием данных python, разумеется, легко справляется: определяем переменные, теоретическую функцию, записываем результаты в текстовый файл.
```
from random import normalvariate
from math import pi, cos
GtoR, Uo, To, D, B = pi/180., 0.7, 56.0, 1.0, 0.02
def U(T):
return Uo * cos(GtoR*(T + normalvariate(0.0, D) - To))**2 + B
with open('pyexp.dat', 'w') as fp:
for T in range(0,360,10):
fp.write('{:5.1f} {:5.3f}\n'.format(T, U(T)))
```
Ограничимся минимально достаточным набором импортируемых в python модулей. В частности, не будем использовать пакеты csv или pandas для записи/чтения табличных данных. Также воздержимся от прямого импорта [numpy](https://numpy.org/), несмотря на то, что numpy и так входит в библиотеку matplotlib. Получившийся в итоге python-сценарий для обработки данных выглядит так:
```
from math import pi, cos, sin # для вычислений
from scipy.optimize import curve_fit # алгоритм подгонки
from scipy.special import gammainc # чтобы определить p-value
from matplotlib import pyplot as plt # для рисования графиков
GtoR = pi/180.
angle, experiment = [], []
with open('pyexp.dat','r') as fp: data = fp.readlines()
for row in data:
a, u = row.strip().split()
angle.append(GtoR*float(a))
experiment.append(float(u))
def U(X, Uo, To, B): # Теоретическая функция
Y = []
for x in X: Y.append(Uo * cos(x - To)**2 + B )
return Y
def V(X, Uo, To, D): # Её производная
Y = []
for x in X: Y.append(abs(D*(Uo * sin(2*(To - x)))))
return Y
# Подгонка без учёта ошибок измерений
popt, pcov = curve_fit(U, angle, experiment, p0 = [0.7, 1.0, 0.01], bounds=(0.0, [1., 180., 0.5]))
# Переводим ошибки измерений углов (1 градус) в ошибки напряжений
errors = V(angle, popt[0], popt[1], 1.0*GtoR)
# Подгонка с учётом ошибок
popt, pcov = curve_fit(U, angle, experiment, p0 = popt, sigma=errors, absolute_sigma=True)
# "Вытаскиваем" результаты подгонки
theory = U(angle, *popt)
Chi2, NDF = 0.0, len(angle)-len(popt)
for p in range(len(angle)): Chi2 += ((theory[p]-experiment[p])/errors[p])**2
pvalue = 1 - gammainc(0.5*NDF, 0.5*Chi2) # gammainc - regularized upper incomplete gamma function
To, dTo = popt[1]/GtoR, pcov[1][1]**0.5/GtoR
tlabel = 'теория: '
tlabel += r'$\chi^2/NDF$ = {:.1f}/{:2d}'.format(Chi2,NDF)
tlabel += '\nP-value = {:.2f}%'.format(100*pvalue)
theta = [GtoR*i for i in range(0,360)] # чтобы рисовать функцию без изломов
plt.rc('grid', color='#316931', linewidth=0.5, linestyle='-.')
fig = plt.figure(figsize=(8, 8))
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], projection='polar', facecolor='#fffff0')
ax.set_title('Поворот оси поляроида: ' + r'$\theta_0={:.2f}^\circ\pm{:.2f}^\circ$'.format(To, dTo)+'\n')
ax.plot(angle, experiment, 'ro', label='эксперимент')
ax.plot(theta, U(theta, *popt), 'b-', label = tlabel)
ax.legend()
plt.show()
```
В результате выполнения программы matplotlib нарисует нам график результатов моделирования (или измерений) и теоретической функции в полярных координатах:
Выводы
------
Итак, для решения «старой» задачи мы выбрали другой «набор инструментов» –
«python + scipy + matplotlib» вместо gnuplot. И да, решение получено. Преимущества нового метода отчасти сформулированы во введении, кроме того, использование python расширяет границы «дозволенного» почти до бесконечности. Недостатки, по сравнению с gnuplot-версией, на мой взгляд, таковы:
1. Неподготовленному человеку понять смысл сценария труднее, чем это было в случае с gnuplot.
2. Библиотека scipy предоставляет необходимые алгоритмы для подгонки теоретической функции к экспериментальным данным. Однако, для доступа к результатам пришлось повозиться: ошибки определения параметров подгонки извлечь из ковариационной матрицы, – посчитать вручную, для определения p-value использовать регуляризованную гамма-функцию.
3. Библиотека matplotlib весьма лаконична, синтаксис – на любителя, и ещё – не смогла изобразить ошибки (усы) данных на графике в полярных координатах. Последнее обстоятельство, конечно же, можно преодолеть написанием дополнительного кода.
### Библиотека NumPy
Благодаря замечательным рецептам, полученным в комментарии [@masai](/users/masai) к вышеприведенному тексту, посмотрим, как изменится код если всё-таки использовать возможности библиотеки [numpy](https://numpy.org/).
```
import numpy as np # numeric python
from matplotlib import pyplot as plt # для рисования графиков
from scipy.optimize import curve_fit # алгоритм подгонки
from scipy.special import gammainc # чтобы определить p-value
data = np.loadtxt("pyexp.dat")
angle = np.radians(data[:, 0]) # Первый столбик, переводим в радианы
experiment = data[:, 1] # Второй столбик
# Теоретическая функция
def U(X, Uo, To, B): return Uo * np.cos(X - To)**2 + B
# Её производная
def V(X, Uo, To, D): return np.abs(D*(Uo * np.sin(2*(To - X))))
# Приблизительные значения параметров "на глазок"
[Uo, To, B] = 0.7, 1.0, 0.01
# Подгонка без учёта ошибок измерений
[Uo, To, B], pcov = curve_fit(U, angle, experiment, p0 = [Uo, To, B])
# Переводим ошибки измерений углов (1 градус) в ошибки напряжений
errors = V(angle, Uo, To, np.radians(1.0))
# Подгонка с учётом ошибок
[Uo, To, B], pcov = curve_fit(U, angle, experiment, p0 = [Uo, To, B], sigma=errors, absolute_sigma=True)
# "Вытаскиваем" результаты подгонки
theory = U(angle, Uo, To, B)
Chi2,NDF = np.sum(((theory-experiment)/errors)**2), len(angle)-len([Uo, To, B])
pvalue = 1 - gammainc(0.5*NDF, 0.5*Chi2) # gammainc - regularized upper incomplete gamma function
tlabel = f'теория: $\chi^2/NDF$ = {Chi2:.1f}/{NDF:2d}\nP-value = {100*pvalue:.2f}%'
theta = np.linspace(0, 2 * np.pi, 1000) # чтобы нарисовать функцию без изломов
gTo, dTo = np.degrees(To), np.degrees(pcov[1][1]**0.5)
# Рисуем график в полярных координатах
plt.rc('grid', color='#316931', linewidth=0.5, linestyle='-.')
fig = plt.figure(figsize=(8, 8))
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], projection='polar', facecolor='#fffff0')
ax.set_title(f'Поворот оси поляроида: $\\theta_0={gTo:.2f}^\circ\pm{dTo:.2f}^\circ$\n')
ax.plot(angle, experiment, 'ro', label='эксперимент')
ax.plot(theta, U(theta, Uo, To, B), 'b-', label = tlabel)
ax.legend()
plt.show()
```
Скрипт стал выглядеть лаконичнее, спору нет. В своей практике я что-то давно забросил numpy, так как в основном пользуюсь библиотеками [ROOT](https://root.cern.ch/), а смешивать разные идеологии внутри кода не очень удобно... | https://habr.com/ru/post/548280/ | null | ru | null |
# Как предсказать цену акций: Алгоритм адаптивной фильтрации
[](http://habrahabr.ru/company/itinvest/blog/274821/)
Группа бразильских ученых опубликовала [исследование](http://arxiv.org/pdf/1501.07504.pdf), посвященное созданию инструмента для предсказания поведения активов, торгующихся на фондовом рынке. В работе представлено подробное описание метода и способа расчетов для подобных прогнозов. Мы представляем вашему вниманию наиболее интересные моменты этого документа.
#### Что такое адаптивный фильтр
Адаптивный фильтр — это инструмент, способный к самообучению для достижения заданного уровня соответсвия выходных данных реальному положению вещей. Под адаптивностью понимается возможность реагировать на изменения входных данных в режиме реального времени для достижения более высокой производительности. На практике, адаптивные алгоритмы реализуются двумя классическими методами — методом градиента и наименьших квадратов (LMS и RLS). Подобный фильтр может быть использован для широкого спектра задач — фильтрации, спектрального анализа или поиска сигналов и т.д.
На рисунке 1 представлена универсальная схема применения адаптивного фильтра в предиктивном фреймворке, где k — это номер итерации, x(k ) — входящий сигнал, y(k) — вывод адаптивного фильтра, являющийся прогнозом желаемого ответа d(k), а e(k) — сигнал ошибки, определяемый как разница между желаемым ответом и выводом фильтра, то есть e(k) = d(k) — y(k).
Рекурсивный адаптивный алгоритм наименьших квадратов (RLS, recursive Least-Squares) позволяет добиваться высокой производительности и скорости сходимости при использовании в переменных во времени средах.
*Рис. 1. Общая блок-диаграмма адаптивного фильтра для предсказания сигналов*
Еще один важный параметр — это так называемое окно наблюдений, то есть временной период анализа, который обычно имеет прямоугольное или экспоненциальное соответствие. Параметр, контролирующий соответствие и длительность окна наблюдений называется коэффициентов забывания `λ` (он применяется к памяти алгоритма), `0 << λ < 1` и объектная функция выглядит так:
Эта функция выпукла в многомерном пространстве `w(k)`, то есть ξd(k) имеет лишь один глобальный минимум и ни одного локального минимума. Таким образом, мы можем достичь этой точки, установив градиент ξd(k) равным нулю, что приведет к такой формуле:
#### Использование адаптивного фильтра в фреймворке предсказаний цен акций
Цель данного исследования — понять, насколько жизнеспособен вариант с использованием адаптивной фильтрации в качестве инструмента для предсказания цен акций на реальных биржах. Адаптивный LMS-фильтр успешно применялся для предсказания трафика в беспроводных сетях [Liang (2002)]. В текущем случае адаптивная фильтрация использовалась для получения оценки возможной стоимости акций акций компании Petrobras, торгующихся на бразильской бирже Bovespa в Сан-Паулу (тикер PETR3).
Для создания модуля предсказания движения цены PETR3 был использован адаптивный цифровой FIR-фильтр со 100 реальными коэффициентами. В качестве алгоритма адаптации был использован RLS с коэффициентом забывания 0,98. Также было использовано окно предсказуемости размером в 16 дней. Симуляция производилась на платформе MATLAB, в качестве входных данных использовалась торговая информация в период с 01/03/2000 до 09/23/2009. Значения дневных цен акций соответствуют моменту закрытия торгов. На рисунке 2 показана сходимость коэффициентов адаптивного фильтра, использующегося в ходе создания предсказаний движения цены PETR3.
*Рис. 2. Сходимость коэффициентов адаптивного фильтра, запущенного для генерирования предсказаний цен акций компании Petrobras (PETR3 на бразильском фондовом рынке).*
Эволюция коэффициентов фильтрации ясно демонстрирует наличие сходимости в период, примерно совпадающий со временем предсказания. По оси абсцисс отмечено число торговых дней, участвующих в симуляции. Реальная оценка акций PETR3 на бразильском фондовом рынке в указанный период показана красной линией на рисунке 3. Там же черным отмечены значения предсказанных фильтром цен.
*Рис. 3. Цена акций PETR3 на бразильском фондовом рынке в период анализа для фильтрации. Красным показан реальный рыночный тренд, черным — оценка, сгенерированная адаптивным фильтром.*
Очевидно, что существует соответствие предсказанных цен и тем, как дела обстояли на рынке в действительности. Для подтверждения этого факта было проведено моделирование конкретного торгового дня — конкретно 2,450 день с начала наблюдений 1/3/2000 года. На рисунке 4 показан зум предсказания, сделанного адаптивным фильтром:
*Рис. 4. Предсказание цен акций в конкретный день*
#### Производительность адаптивного фильтра для предсказания цен выбранного актива
Рассмотрим стратегии инвестиций в акции PETR3 с использованием предсказаний, сгенерированных фильтром с момента 2473 (показан на рис. 5). Фильтрация осуществляется с помощью RLS-алгоритма с 100 коэффициентами и коэффициентом забывания λ = 0,98. Предполагаемый тренд движения цен акций PETR3 на основе фильтрации для 16-дневного окна отображен пунктирной линией на рисунке 5.
*Рис. 5. Поведение актива PETR3 в период с 08/18/2009 до 09/22/2009. Пунктир — предсказание адаптивного фильтра, красным — реальная цена акций на рынке.*
Кривая предсказания говорит о необходимости покупки актива в торговый день 09/02/2009 и продажи акций в момент 17/09/2009 — таким образом продажа должна прийтись на момент роста, предшествующего снижению цен. График реальных цен говорит о том, что если бы такая стратегия была реализована, то покупка акций прошла бы по цене 37,86, а продажа по 41,05, что дало бы прибыль в размере 8,43% от объёма инвестиций. Несмотря на то, что данный пример является лишь частным случаем, он иллюстрирует возможную эффективность предсказаний, основанных на адаптивной фильтрации. В дальнейшем были проведены испытания для других торговых дней, и результаты в общем были такими же.
#### Создание адаптивного фильтра и точность предсказаний
Несмотря на положительные результаты испытаний, предложенный метод оставляет некоторые вопросы. Один из них звучит так — для какого типа активов он работает лучше? Какое количество коэффициентов FIR следует использовать для повышения качества работы модуля предсказания? Влият ли на результат значение коэффициента забывания?
Для оценки качества предсказаний, сделанных с помощью адаптивной фильтрации, используется корреляция — это мера схожести для анализа качества совпадения между предсказанным сигналом и реальными котировками на бирже в рамках заданного окна предсказания.
Анализ точности осуществляется с помощью изучения значений корреляции, как функции числа коэффициентов фильтра и размером окна предсказания. На рисунке 5 показан 3D-график корреляции между 08/18/2009 и 09/22/2009:
*Рис. 6. Корреляционный 3D-график между предсказанными сигналами и реальными котировками акций.*
График 6 был конвертирован в трехмерный контурный график, представленный на рисунке 7. На нем лучше видна зона повышенной корреляции между сгенерированным предсказанным сигналом и реальными ценами акций на рынке.
Для изучения влияние числа коэффициентов фильтра для адаптивных предсказаний был создан боковой профиль пространства из рисунка 6 (изображен на рис. 8), на котором отмечены пики корреляции, видимые наблюдателю, находящемуся в правой части пространства. Очевидно, что участок между 30 и 100 коэффициентами представляет высокую корреляцию. Соответственно, использование 30 и меньшего числа коэффциентов недостаточно для получения точного предсказания.
*Рис. 8. Профиль корреляции, учитывающий число коэффициентов.*
Первый участок высокой корреляции не особенно полезен, поскольку его можно достигнуть только при очень маленьком окне предсказания. Наилучшим вариантом в данном конкретном сценарии является выбор числа коэффициентов между 60 и 100.
Затем для оценки влияния окна предсказания на качество получаемых прогнозов, был создан передний профиль трехмерного пространства из рисунка 6 (рис. 9). На нем показано поведение максимальной корреляции с учетом размеров окна предсказания. Очевидно, что выбор очень короткого окна ведет к высокой корреляции (действительно, цены акций идущих друг за другом торговых дней показывают высокую корреляцию). Однако это практически ничего не дает нам в плане создания стратегий инвестирования на фондовом рынке.
*Рис. 9. Профиль корреляции с учетом размером окна предсказания (от 1 до 30 торговых дней бразильского фондового рынка).*
Неожиданный результат — эксперименты показали, что выбор окна предсказания размером около 10 дней является крайне неэффективным. Напротив, предсказания на окне в примерно 15 рабочих дней показывают гораздо лучшие результаты. Точно также, как и предполагалось, слишком длинные окна предсказания приводят к снижению коррелюяции.
Таким образом, наиболее оптимальным окном предсказания в данном конкретном случае является 15-20 дней.
В таблице 1 представлена сводная информация о количестве использованных коэффициентов, длине окна предсказания, даты покупки и продажи акций согласно предложенной фильтром стратегии, цены сделок, а также общий профит транзакций.
Как видно, использование адаптивного фильтра позволило добиться получения прибыли, в среднем, в размере 7% от объёма инвестиций. | https://habr.com/ru/post/274821/ | null | ru | null |
# Как протестировать блокноты Jupyter с помощью pytest и nbmake
Файлы блокнотов Jupyter, в смысле количества одного из самых быстрорастущих типов файлов на Github, предоставляют простой интерфейс для итераций при решении визуальных задач, будь то анализ наборов данных или написание документов с большим объёмом кода. Однако популярность блокнотов Jupyter сопровождается проблемами: в репозитории накапливается большое количество файлов ipynb, многие из которых находятся в нерабочем состоянии. В результате другим людям трудно повторно запустить или даже понять ваши блокноты. В этом руководстве рассказывается, как для автоматизации сквозного (end-to-end) тестирования блокнотов можно воспользоваться плагином pytest [nbmake](https://github.com/treebeardtech/nbmake).
К старту [флагманского курса о Data Science](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=200521) — области, в которой блокноты Jupyter незаменимы — делимся переводом статьи из блога CI Semaphore о том, как при помощи Semaphore проверить, что ваши блокноты Jupyter находятся в рабочем состоянии и для этого больше не запускать блокноты вручную.
---
Предварительные требования
--------------------------
Это руководство предполагает владение основными навыками тестирования проектов на Python, о них рассказывается в [статье](https://semaphoreci.com/blog/python-continuous-integration-continuous-delivery)Непрерывная интеграция и развёртывание на Python с нуля. Прежде чем продолжить, пожалуйста, убедитесь, что вы знакомы с основами и на вашем компьютере установлен набор инструментов Python 3, таких как pip + virtualenv.
Демонстрационное приложение
---------------------------
Обычно проекты Python содержат папки с файлами блокнотов с расширением .ipynb, это может быть:
* код доказательства концепции;
* документация с примерами применения API;
* длинный научный туториал.
В этой статье мы разберём, как автоматизировать простые сквозные тесты некоторых блокнотов, содержащих упражнения на Python. Благодарим [pytudes](https://github.com/norvig/pytudes) за предоставленные для нашего примера материалы; воспользуемся [этим](https://github.com/treebeardtech/nbmake-examples) примером проекта, не стесняйтесь делать форк и клонировать его с GitHub:
fig:Внутри репозитория вы найдёте содержащую блокноты папку, она называется ipynb. Установите зависимости из requirements.txt, а при необходимости сначала создайте виртуальную среду.
Прежде чем перейти к следующему шагу, посмотрите, можно ли запустить эти блокноты в вашем редакторе.
Локальное тестирование блокнота
-------------------------------
Вполне вероятно, что до этого момента при тестировании вы запускали блокноты вручную через пользовательский интерфейс Jupyter Lab или аналогичный клиент. Однако этот подход отнимает много времени и подвержен ошибкам.
Давайте начнём автоматизировать этот процесс в вашей среде разработки; первым шагом в автоматизации станет nbmake. Nbmake — это пакет python и плагин к pytest. Он разработан автором этого руководства и используется известными научными организациями, такими как Dask, Quansight и Kitware. Вы можете установить nbmake с помощью pip:
```
pip install nbmake==0.5
```
Перед первым тестированием блокнотов давайте проверим, всё ли правильно настроено, указав pytest просто собрать (но не запускать) все тест-кейсы для блокнотов.
```
➜ pytest --collect-only --nbmake "./ipynb"
================================ test session starts =================================
platform darwin -- Python 3.8.2, pytest-6.2.4, py-1.10.0, pluggy-0.13.1
rootdir: /Users/a/git/alex-treebeard/semaphore-demo-python-jupyter-notebooks
plugins: nbmake-0.5
collected 3 items
============================= 3 tests collected in 0.01s =============================
```
Мы видим, что pytest собрал несколько элементов.
> **Примечание:** если вы получаете сообщение unrecognized arguments: --nbmake, оно означает, что плагин nbmake не установлен. Такое может произойти, если ваш CLI вызывает двоичный файл pytest за пределами текущей виртуальной среды. Проверьте, где находится ваш двоичный файл pytest, с помощью команды which pytest.
>
>
Теперь, когда мы проверили, что nbmake и pytest видят ваши блокноты и работают вместе, давайте выполним настоящие тесты:
```
➜ pytest --nbmake "./ipynb"
================================ test session starts =================================
platform darwin -- Python 3.8.2, pytest-6.2.4, py-1.10.0, pluggy-0.13.1
rootdir: /Users/a/git/alex-treebeard/semaphore-demo-python-jupyter-notebooks
plugins: nbmake-0.5
collected 3 items
ipynb/Boggle.ipynb . [ 33%]
ipynb/Cheryl-and-Eve.ipynb . [ 66%]
ipynb/Differentiation.ipynb . [100%]
================================= 3 passed in 37.65s =================================
```
Отлично, блокноты прошли тесты. Однако это простые блокноты в демонстрационном проекте. Очень маловероятно, что все ваши блокноты пройдут тесты с первого раза, поэтому давайте рассмотрим некоторые подходы к запуску сложных проектов.
Игнорирование ожидаемых ошибок в блокноте
-----------------------------------------
Не все блокноты можно легко протестировать автоматически. Некоторые из них будут содержать ячейки, требующие от пользователя ввода данных, или блокноты, которые для демонстрации некоторой функциональности вызывают необработанные исключения.
К счастью, чтобы указать nbmake, что такие блокноты нужно игнорировать и продолжать работу после возникновения ошибок, в метаданные нашего блокнота мы можем поместить директивы. Возможно, вы раньше не использовали метаданные блокнота, поэтому самое время упомянуть, что, несмотря на их расширение ipynb, блокноты — это просто JSON-файлы. Чтобы добиться от них нового поведения, добавьте новые поля:
* откройте файл .ipynb в простом текстовом редакторе, например Sublime;
* в метаданных блокнота найдите поле kernelspec;
* добавьте объект execution в качестве родственного элемента kernelspec.
Должно получиться что-то вроде этого:
```
{
"cells": [ ... ],
"metadata": {
"kernelspec": { ... },
"execution": {
"allow_errors": true,
"timeout": 300
}
}
}
```
Теперь можно перезапустить блокнот, чтобы проверить, что JSON валиден, а ошибки игнорируются.
Ускорение тестов с помощью pytest-xdist
---------------------------------------
В крупных проектах может быть много блокнотов, каждый из которых требует много времени на установку пакетов, извлечение данных из сети и выполнение анализа. Если ваши тесты занимают более нескольких секунд, стоит проверить, как на время выполнения повлияет распараллеливание. Сделать это можно с помощью другого плагина pytest — pytest-xdist. Сначала установите пакет xdist. Это похожий на nbmake плагин pytest, он добавит новые параметры командной строки:
```
pip install pytest-xdist
```
Запустите команду ниже с количеством рабочих процессов, равным auto:
```
pytest --nbmake -n=auto "./ipynb"
```
Запись выполненных блокнотов обратно в репозиторий
--------------------------------------------------
По умолчанию тесты доступны только для чтения, то есть ваш файл ipynb на диске остаётся неизменным. Обычно это хорошее значение по умолчанию, потому что во время выполнения блокнота ваш редактор может быть открыт. Однако в некоторых ситуациях может потребоваться сохранить результаты теста на диске. Например, если вам нужно:
* отладить неработающие блокноты путём просмотра выходных данных;
* создать коммит в вашем репозитории с блокнотами в воспроизводимом состоянии;
* встроить выполненные блокноты в сайт с документацией при помощи nbsphinx или jupyter book.
Мы можем направить nbmake на сохранение выполненных блокнотов на диск с помощью флага overwrite:
```
pytest --nbmake --overwrite "./ipynb"
```
### Исключение блокнотов из тестов
Некоторые блокноты может быть трудно протестировать автоматически из-за необходимости ввода данных через stdin самим пользователем или длительного времени запуска. Чтобы отменить выбор, воспользуйтесь флагом игнорирования pytest:
```
pytest --nbmake docs --overwrite --ignore=docs/landing-page.ipynb
```
> **Примечание:** это не сработает, если вы выбираете все блокноты с помощью шаблона поиска, например (\*ipynb), вручную переопределяющего флаги игнорирования pytest.
>
>
Автоматизация тестирования блокнотов на Semaphore CI
----------------------------------------------------
С помощью вышеописанных методов можно создать автоматизированный процесс тестирования с использованием [непрерывной интеграции](https://semaphoreci.com/continuous-integration) (CI) Semaphore. Ключ здесь — прагматизм: нужно найти способ протестировать большую часть ваших блокнотов и проигнорировать сложные блокноты; это хороший шаг к улучшению качества.
Начните с создания содержащего ваши блокноты проекта для репозитория. Выберите “Choose repository”:
Затем подключите Semaphore к репозиторию с вашими блокнотами:
Пока пропустите “Add People”, чтобы мы могли настроить рабочий процесс с нуля (даже если вы работаете с деморепозиторием). Semaphore предоставляет некоторую начальную конфигурацию, настроим её перед запуском:
Создайте простой рабочий процесс в один блок; ниже о процессе в деталях:
1. Названием блока будет Test*.*
2. Названием задачи — Test Notebooks*.*
3. В поле Commands введите команды ниже:
```
checkout
cache restore
pip install -r requirements.txt
pip install nbmake pytest-xdist
cache store
pytest --nbmake -n=auto ./ipynb
```
Чтобы лучше понять происходящее, давайте разберёмся, что делает каждая команда:
1. checkout клонирует репозиторий с GitHub;
2. cache restore загружает зависимости Python из кэша Semaphore. Это ускоряет процесс установки;
3. pip устанавливает зависимости и инструменты;
4. cache store сохраняет загруженные зависимости обратно в кэш;
5. pytest запускает тесты nbmake.
Теперь мы можем запустить рабочий процесс. Не беспокойтесь, если [конвейер](https://semaphoreci.com/blog/cicd-pipeline) выйдет из строя: далее мы рассмотрим распространённые проблемы.
Конвейер должен заработать сразу же:
Устранение некоторых распространённых ошибок
--------------------------------------------
### Добавление отсутствующего ядра Jupyter в среду CI
Если вы используете имя ядра, отличное от имени по умолчанию — python3, то при выполнении ноутбуков в свежей среде CI увидите сообщение об ошибке: Error - No such kernel: 'mycustomkernel'. Чтобы установить пользовательское ядро, воспользуйтесь командой ipykernel:
```
python -m ipykernel install --user --name mycustomkernel
```
Если в своих блокнотах вы работаете с другим языком, например С++, ваш процесс установки ядра может быть другим.
### Добавление недостающих секретов в среду CI
В некоторых случаях ваш блокнот получает данные от API, требующих токена или аутентифицированного CLI. Всё, что работает в вашей среде разработки, должно работать и на Semaphore. Чтобы увидеть, как настроить секреты, сначала посмотрите [этот пост](https://docs.semaphoreci.com/guided-tour/environment-variables-and-secrets/). Как только вы установили секреты в Semaphore, чтобы прочитать их из переменной среды в средах CI, вам может потребоваться настроить блокнот.
### Добавление недостающих зависимостей в среду CI
Стек Data Science на Python часто требует установки собственных библиотек. Если вы работаете с CONDA, вполне вероятно, что они будут присутствовать в вашем нормальном процессе установки. Если же вы используете стандартные библиотеки Python, их присутствие немного менее вероятно.
Если вы пытаетесь установить необходимые вам библиотеки, посмотрите на статью о [создании образа docker в CI](https://docs.semaphoreci.com/ci-cd-environment/custom-ci-cd-environment-with-docker/). С ним тестирование упрощается, и по сравнению со стандартными средами Semaphore этот подход стабильнее во времени.
Пожалуйста, помните совет о прагматизме; 90 % полезности часто можно достичь за 10 % времени. Следование совету может привести к компромиссам, таким как игнорирование блокнотов, на которых запускаются требующие GPU модели ML.
Заключение
----------
В этом руководстве показано, как можно автоматизировать тестирование блокнотов Jupyter, чтобы поддерживать их воспроизводимость. Блокноты оказались эффективным инструментом для построения технических нарративов. Однако из-за новизны некоторые команды разработчиков программного обеспечения исключают их использование до тех пор, пока не появятся более чёткие процессы для тестирования, ревью и повторного использования их содержимого.
Прежде чем технологии блокнотов органично впишутся в проекты ПО, предстоит пройти определённый путь, но сейчас самое время начать его. Возможно, вы захотите изучить некоторые из следующих пунктов дальнейшей работы, чтобы научиться лучше работать с блокнотами:
* для удаления громоздких выходных данных блокнота перед коммитом запустите [pre-commit](https://pre-commit.com/) и [nbstripout](https://pypi.org/project/nbstripout/);
* для компиляции ваших блокнотов в красивый сайт с документацией используйте [jupyter book](https://github.com/executablebooks/jupyter-book);
* для просмотра блокнотов в пул-реквестах используйте [ReviewNB](https://www.reviewnb.com/).
Действительно, процессы в разработке ПО и в научных исследованих всё дальше уходят с локальных компьютеров на арендуемые мощности самого разного рода, в том числе потому, что требуют всё больших ресурсов. То же касается и растущих объёмов данных, работа с которыми преобразилась в несколько смежных, но очень разных областей; среди них центральное место занимает Data Science. Если вам интересна эта сфера, вы можете присмотреться к [нашему курсу Data Science](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=200521), итог которого — это 16 проектов, то есть 2-3 года постоянного самостоятельного изучения науки о данных.
[Узнайте](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=200521), как прокачаться и в других специальностях или освоить их с нуля:
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=200521)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=200521)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=200521)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=200521)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=200521)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=200521)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=200521)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=200521)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=200521)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=200521)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=200521)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=200521)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=200521)
**КУРСЫ**
* [Курс по 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=200521)
* [Курс "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=200521)
* [Курс "Математика для 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=200521)
* [Курс "Математика и 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=200521)
* [Курс "Python для веб-разработки"](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=200521)
* [Курс "Алгоритмы и структуры данных"](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=200521)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=200521)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=200521) | https://habr.com/ru/post/558326/ | null | ru | null |
# Что нового в Angular 8 версии
Вот и вышел angular 8, он включает в себя превью Ivy, поддержку service workers, дифференциальную загрузку и несколько других завершающих штрихов. [Manfred Steyer](https://www.softwarearchitekt.at/) объясняет наиболее важные изменения в новейшем релизе.
Как и планировалось, сюрпризов не было: обновление фреймворка и CLI можно сделать с помощью ng update, а новые функции являются приятным дополнением в соответствии с девизом «эволюция вместо революции».
В этой статье автор рассказывает о наиболее важных новых функциях Angular 8 и Angular CLI 8. Примеры, используемые в статье, можно найти на [GitHub](https://github.com/manfredsteyer/angular8).
#### Под катом:
* Первый взгляд на Ivy
* Web workers
* Дифференциальная загрузка
* Ленивая загрузка модулей
* Критические изменения в ViewChild и ContentChild
* Новые фичи ngUpgrade
Первый взгляд на Ivy
--------------------
Следующая большая новость, которую ждет сообщество Angular — это Ivy, новый компилятор, а также новый движок рендеринга. Ivy может генерировать значительно меньшие бандлы, инкрементную компиляцию, а также является основой для будущих инноваций в Angular.
Поскольку многие базовые части Angular были изменены, команда Angular обратила особое внимание на совместимость с предыдущими версиями: после перехода на Ivy существующие приложения должны работать так же, как и раньше. В лучшем случае вы получите бандлы значительно меньшего размера. Это не бескорыстно, так как более 600 приложений в Google официально основаны на Angular – реальное число, по слухам, намного выше.
С Angular 8, предварительная версия Ivy доступна для тестирования. Цель этой версии — получить быструю обратную связь. Поэтому команда angular рекомендует не использовать Ivy в проде прямо сейчас, но продолжить использовать классический view engine (Рис. 1)
Спасибо дифференциальной загрузке (как видно ниже), размеры бандла могут быть оптимизированы прямо сейчас.
Как отмечает Брэд Грин, технический директор Angular team в Google, на ngconf 2019, Ivy позволит заметно улучшить размеры пакетов в режиме совместимости в сочетании с дифференциальной загрузкой. Таким образом, сорвиголовы уже могут опробовать будущий API Ivy. Этот режим, в частности, имеет большой потенциал для оптимизации. API по-прежнему помечен как приватный. Глядя на его классы и функции, вы можете сказать: они начинаются со специального символа ɵ.
Если вы уже хотите попробовать Ivy, вы можете создать новый проект с ключем enable-ivy:
```
ng new ivy-project --enable-ivy
```
Данный ключ говрит CLI сохранить следующую запись в конфигурации tsconfig.app.json:
```
"angularCompilerOptions": {
"enableIvy": true
}
```
Эта запись также может быть добавлена вручную после обновления до 8 версии, для тестирования существующего приложения с использованием Ivy.
Для запуска приложения в режиме отладки рекомендуется использовать AOT:
```
ng serve --aot
```
Кроме того, стоит обратить внимание на размер приложения, созданного с помощью ng build. С angular 9, Ivy должна быть активирована по умолчанию. До тех пор команда Angular планирует продолжать работу по обеспечению совместимости со старыми версиями.
Web workers
-----------
JavaScript является однопоточным по определению. Из-за этого трудоемкие задачи, такие как запрос данных, обычно выполняются асинхронно. Излишне говорить, что это не помогает в сложных расчетах. Они особенно становятся все более распространенными с обширными решениями JavaScript, поэтому мы поддерживаем web worker'ы почти всех веб-браузеров. Это скрипты, которые запускаются браузером в отдельном потоке. Связь с потоком на вкладке браузера осуществляется посредством сообщений.
Хотя web worker'ы не имеют отношения к Angular как таковому, они должны быть приняты во внимание при сборке. Целью является предоставление одного пакета для каждого web worker. Эта задача выполнена новым CLI.
Для демонстрации новой фичи, я покажу JavaScript реализацию так называемой ”проблемы N королев ([n queens problem](https://en.wikipedia.org/wiki/Eight_queens_puzzle))". Идея состоит в том, чтобы разместить по одной королеве в ряду на шахматной доске, не имея возможности угрожать друг другу. Это значит, что в той же строке, столбце или диагонали не должно быть другой королевы.
Алгоритм вычисления всех возможных решений на шахматной доске считается вычислительно сложным. Хотя вычисления для обычной шахматной доски с восемью рядами и восемью столбцами довольно быстры, обычные компьютеры достигнут предела, при рамере доски 12 х 12. Решение для доски размером 27 х 27 является текущим рекордом. Для этой задачи использовались российские суперкомпьютеры.
Чтобы перевести такой расчет в фон, мы должны сначала создать web worker'а с помощью CLI:
```
ng generate worker n-queens
```
Эта инструкция создает файл не только для работника, но и для файлов конфигурации, необходимых для процесса сборки и записей в существующих файлах. Если та же папка содержит компонент с тем же именем с общим расширением файла .component.ts, CLI также добавит код, для взаимодействия с web worker.
Сам worker состоит из прослушивателя для события:
```
import nQueens from './n-queens';
addEventListener('message', ({ data }) => {
const result = nQueens(data.count);
postMessage(result, undefined);
});
```
Событие выполняется, когда основной поток отправляет сообщение worker'у. Параметр содержит информацию, отправленную из основного потока. В рассматриваемом случае, он ограничен свойством count, которое задает размер шахматной доски. После вычисления функции nQueens, которая здесь опущена, eventListener отправляет результат обратно в основной поток через postMessage. Таким образом, браузер запускает message event.
Класс Worker применяется в использующем компоненте для взаимодействия с worker скриптом:
```
const count = parseInt(this.count, 10);
const worker = new Worker('../logic/n-queens.worker', {
type: 'module' // Worker uses EcmaScript modules
});
worker.postMessage({count});
worker.addEventListener('message', (event) => {
// tslint:disable-next-line: no-console
console.debug('worker result', event.data);
// Update chessboard
this.processResult(event.data);
});
```
Компонент отправляет сообщение с желаемым размером шахматной доски worker'у через postMessage и тем самым запускает вычисление там. Результат он получает через событие message.
В дальнейшем CLI заботится о правильной сборки worker скриптов. Компилятор TypeScript распознает их по окончанию .worker.ts, который зарегистрирован в tsconfig.worker.json созданном командой *ng generate worker*. Чтобы убедиться, что CLI не станет затрагивать эти файлы снова при сборке основного приложения, *ng generate worker* помещает тот же шаблон файла в секции exclude tsconfig.app.json.
Полная реализация есть в проекте с примерами автора. Для сравнения пример задачи N queens может быть решен как в основном потоке, так и в web worker. Когда вы попытаетесь решить задачу для шахматной доски 12 x 12, например, вы увидите, что UI зависает в первом случае, в то время как фоновый расчет с помощью web worker, не уменьшит производительность.
Дифференциальная загрузка
-------------------------
До сих пор было принято компилировать приложения в старый добрый ES 5, так как эта версия “JavaScript наших отцов” работает почти везде. Это означает, что и IE11 и веб-сканер поисковой системы Google могут выполнять этот код.
Однако новый ES 2015 и его последующие версии более эффективны: они позволяют создавать более компактные пакеты и браузер может также интерпретировать их более эффективно. Поскольку ранее было принято откатываться к ES 5 как наименьшему общему знаменателю, современные браузеры, к сожалению, не могли использовать преимущества новой версии языка.
Теперь с этим покончено: начиная с 8 версии, CLI имеет функцию, которая называется дифференциальной загрузкой. Идея заключается в том, чтобы предоставить две группы пакетов: один основан на ECMAScript 5 и предназначен для старых браузеров, другой основан на новой версии ECMAScript, например ECMAScript 2015, и предоставляет современным браузерам ранее упомянутые преимущества.
Вам не потребуется много работы, чтобы включить дифференциальную загрузку: все, что нужно, это установить верхнюю и нижнюю границу поддерживаемых версий ECMAScript. Верхняя граница указывается в tsconfig.json следующим образом:
```
"target": "es2015"
```
Нижняя граница определяется в файле browserslist. Этот файл включает браузеры, которые будут поддерживаться, в соответствии с определенными критериями, такими как доля рынка, например. Они могут быть сохранены, например, в файле browserslist, который CLI создает в корне проекта при создании нового проекта:
`> 0.5%
last 2 versions
Firefox ESR
not dead
IE 9-11`
В данном случае список браузеров включает браузеры ES 5 с записью IE 9-11. Таким образом, CLI определяет нижний порог как эту версию. Когда CLI получит команду ng build, процесс сборки будет выполняться для обеих версий:
Недостаток этого процесса заключается в следующем: время, необходимое для сборки удваивается.
Теперь браузеры могут решить, какую версию пакетов загружать. Для этого они получают ссылки на скрипты в дополнении index.html: те, кто указывает на пакеты ECMAScript 5, получают добавление nomodule. Таким образом браузеры с поддержкой модулей ECMAScript и, следовательно, поддержкой ECMAScript 2015+ не проигнорируют данный скрипт. С другой стороны, пакеты ECMAScript 2015+ реализуются CLI с type=”module”. Таким образом, старые браузеры будут игнорировать эти скрипты:
```
```
В отличие ng build, остальные команды CLI используют только (!) верхнюю границу поддержки ES. В нашем случае это ECMAScript 2015. Это происходит, в том числе, из соображений эффективности: во время отладки и тестирования разработчики обычно хотят увидеть результат как можно скорее, не дожидаясь второй сборки.
Ленивая загрузка модулей
------------------------
С первых дней Angular router поддерживает ленивую загрузку. До сих пор это достигалось магическим определением загружаемого модуля:
```
{
path: 'lazy',
loadChildren: () => './lazy/lazy.module#LayzModule'
}
```
Значение перед # описывает путь, ведущий к файлу с реализацией модуля; значение после означает содержащийся в нем класс. Этот стиль описания работает в Angular 8, но был признан устаревшим относительно динамического импорта ECMAScript:
```
{
path: 'lazy',
loadChildren: () => import('./lazy/lazy.module').then(m => m.LazyModule)
}
```
Новый вариант записи по-прежнему содержит имя файла как магическое значение. Однако, поскольку импорт поддерживается многими IDE, недопустимые значения немедленно вернут ошибку.
Критические изменения в ViewChild и ContentChild
------------------------------------------------
Есть критические изменения в использовании ViewChild и ContentChild, которые, к сожалению, в прошлом не всегда работали предсказуемо. Если в более ранних версиях они использовались компонентом для запроса элементов не находящихся внутри структурной директивы, такой как ngIf или ngFor, результат запроса уже был доступен в ngOnInit. Иначе мы могли получить доступ к ним не ранее ngAfterViewInit (или ngAfterContentInit для ContentChild). Для элементов, которые были загружены в DOM позже из-за привязки данных, программный код должен был иметь ngAfterViewChecked или, соответственно, ngAfterContentChecked.
Поскольку это поведение было запутанным, компонент теперь должен указывать, когда должно произойти разрешение:
```
@ViewChild('info', { static: false })
paragraph: ElementRef;
```
Если флаг static имеет значение true, Angular попытается найти элементы при инициализации компонента. Это работает, только если они не находятся в структурной директиве. При использовании static: false разрешение выполняется после инициализации или обновления представления.
ng update попытается автоматически ввести правильное значение, если это окажется невозможно, он добавит комментарий с TODO.
Это изменение не повлияет на запросы с декораторами ViewChildren и ContentChildren. Они всегда имели динамическое поведение, в новых терминах — в смысле static: false.
Новые фичи ngUpgrade
--------------------
До сих пор одна из проблем смешанной работы AngularJS 1.X и Angular с ngUpgrade заключалась в том, что маршрутизаторы обоих фреймворков конкурировали из-за URL. Это приводило к трудно объяснимым побочным эффектам. Чтобы избежать этого, была добавлена возможность использования единой службы локации доступа к URL-адресу в обеих версиях.
Для этого команда Angular расширила возможности служб локации Angular и тем самым обеспечила замену $location в AngularJS.
По этой причине в службу локации был добавлен новый метод onUrlChange для отслеживания изменений URL-адресов:
```
export class AppComponent {
constructor(loc: Location, pLoc: PlatformLocation) {
loc.onUrlChange((url) => console.debug('url change', url));
console.debug('hostname: ', pLoc.hostname);
}
}
```
Сервис PlatformLocation предлагает дополнительный доступ к отдельным частям URL-адреса. Подробное описание того, как замена $location, основанная на ней, используется для лучшей интеграции фреймворков, можно найти [здесь](https://next.angular.io/guide/upgrade#using-the-unified-angular-location-service). Кроме того, теперь вы можете найти решение для ленивой загрузки AngularJS, которая основана на вышеупомянутом динамическом импорте ECMAScript.
Заключение
----------
Снова команда Angular сдержала свое слово: переход на новую версию Angular прост и не включает больших изменений. Наоборот некоторые углы были сглажены, сделав работу с SPA-фреймворком от Google еще более комфортной. Дифференциальная загрузка дает возможности для дальнейшей оптимизации размеров пакетов, если старые браузеры либо не поддерживаются, либо поддерживаются отдельными пакетами. Поддержка Web worker показывает, что вычислительно емкие задачи находят путь на обработку в браузере. Энтузиасты теперь могут сделать свои первые шаги с Ivy.
PS: Это мой первый перевод, поэтому замечания, пожелания и ошибки прошу отметить в комментариях. | https://habr.com/ru/post/455493/ | null | ru | null |
# Метаклассы в C++
В этой статье мы поговорим о новом предложенном расширении языка С++ — метаклассах. Герб Саттер с коллегами работал над этим предложением около 2 лет и, наконец, этим летом [представил](https://herbsutter.files.wordpress.com/2017/07/p0707r1.pdf) его общественности.
Итак, что же такое «метакласс» с точки зрения Герба Саттера? Давайте вспомним наш С++ — самый прекрасный в мире язык программирования, в котором, однако, ~~веками~~ десятилетиями существуют примерно одни и те же сущности: переменные, функции, классы. Добавление чего-то фундаментально нового (вроде enum classes) занимает очень много времени и рассчитывать дождаться включения чего-то нужного вам здесь и сейчас в стандарт — не приходится. А ведь кое-чего и правда не хватает. Например, у нас всё ещё нет (да, наверное, и не будет) интерфейсов как таковых (приходится эмулировать их абстрактными классами с чисто виртуальными методами). Нет properties в полном их понимании, нет даже value-типов (чего-то такого, что можно было бы определить как набор переменных простых типов и сразу использовать во всяких там контейнерах/сортировках/словарях без определения для них разных там операций сравнения, копирования и хеширования). Да и вообще постоянно чего-то кому-то не хватает. Разработчикам Qt вот не хватает метаданных и кодогенерации, что заставляет их использовать moc. Разработчикам C++/CLI и C++/CX не хватило способов взаимодействия со сборщиком мусора и своими системами типов. Ну и т.д.
А давайте на секунду представим, что мы сами можем вводить в язык новые сущности. Ну или пусть не прямо «сущности», а правила проверки и модификации классов.
Как это всё будет работать. Герб предлагает ввести понятие «метакласса», как набора правил и кода, которые будут выполняться на этапе компиляции и на основе которых компилятор будет проверять классы в коде и/или создавать новые классы на основе вышеупомянутых правил.
Например, нам хочется иметь в языке классический интерфейс. Что такое «интерфейс»? Например, стандарт языка С# отвечает на этот вопрос на 18 страницах. И с этим есть целый ряд проблем:
1. Никто их не читает
2. Компилятор совершенно не гарантированно реализует именно то, что написано в тех 18 страницах текста
3. У нас нет возможности проверить соответствие работы компилятора и текста на английском языке
4. Для С++ пришлось бы написать такую же спецификацию и её реализацию в компиляторах (а зная С++ — так ещё и намного более сложную). А дальше см. пункты 1, 2 и 3.
Но, давайте скажем простыми словами, что такое «интерфейс» — это такой именованный набор публичных чисто-виртуальных методов, к которому в то же время не привязаны никакие приватные методы или члены данных. Всё! Да, может я сейчас упустил какую-то мелкую деталь из тех 18 страниц спецификации, но для 99.99% практического кода этого определения хватит. И вот для возможности описания в коде подобных определений и придуманы метаклассы.
Синтаксис ещё на этапе обсуждения, но вот примерно как может быть реализован метакласс «интерфейс»:
```
$class interface {
constexpr
{
compiler.require($interface.variables().empty(),
"Никаких данных-членов в интерфейсах!");
for (auto f : $interface.functions())
{
compiler.require(!f.is_copy() && !f.is_move(),
"Интерфейсы нельзя копировать или перемещать; используйте"
"virtual clone() вместо этого");
if (!f.has_access())
f.make_public(); // сделать все методы публичными!
compiler.require(f.is_public(), // проверить, что удалось
"interface functions must be public");
f.make_pure_virtual(); // сделать метод чисто виртуальным
}
}
// наш интерфейс в терминах С++ будет просто базовым классом,
// а значит ему нужен виртуальный деструктор
virtual ~interface() noexcept { }
};
```
Код интуитивно понятен — мы объявляем метакласс interface, в котором на этапе компиляции кода (блок constexpr) будут проведены определённые проверки и модификации конечного класса, который будет претендовать на то, чтобы считаться интерфейсом.
Применять это дело теперь можно вот так:
```
interface Shape
{
int area() const;
void scale_by(double factor);
};
```
Правда, очень похоже на C# или Java? При компиляции компилятор применит к Shape метакласс interface, что на выходе даст нам класс:
```
class Shape
{
public:
virtual int area() const =0;
virtual void scale_by(double factor) =0;
virtual ~Shape() noexcept { };
};
```
Плюс сгенерирует ошибку компиляции при попытке добавления данных-членов.
При этом обратите внимания, в полученном таким образом классе Shape нет больше никакой «мета-магии». Это просто класс, ровно такой же, как если бы он был написан руками — можно создавать его экземпляры, от него можно наследоваться и т.д.
Вот так мы смогли внести в язык новую сущность и использовать её, не прибегая к необходимости правок стандарта языка или компилятора.
Давайте теперь определим класс, который можно было бы использовать в упорядоченных контейнерах. Например, классическую точку для хранения в ordered-контейнере на практике приходится писать вот как-то так:
```
class Point
{
int x = 0;
int y = 0;
public:
Point() = default;
friend bool operator==(const Point& a, const Point& b)
{ return a.x == b.x && a.y == b.y; }
friend bool operator< (const Point& a, const Point& b)
{ return a.x < b.x || (a.x == b.x && a.y < b.y); }
friend bool operator!=(const Point& a, const Point& b) { return !(a == b); }
friend bool operator> (const Point& a, const Point& b) { return b < a; }
friend bool operator>=(const Point& a, const Point& b) { return !(a < b); }
friend bool operator<=(const Point& a, const Point& b) { return !(b < a); }
};
```
Но если на этапе компиляции у нас есть рефлексия, позволяющая перечислять данные-члены и добавлять в класс новые методы — мы можем вынести все эти сравнения в метакласс:
```
$class ordered {
constexpr {
if (! requires(ordered a) { a == a; }) ->
{
friend bool operator == (const ordered& a, const ordered& b)
{
constexpr
{
for (auto o : ordered.variables()) // for each member
-> { if (!(a.o.name$ == b.(o.name)$)) return false; }
}
return true;
}
}
if (! requires(ordered a) { a < a; }) ->
{
friend bool operator < (const ordered& a, const ordered& b)
{
for (auto o : ordered.variables()) ->
{
if (a.o.name$ < b.(o.name)$) return true;
if (b.(o.name$) < a.o.name$) return false; )
}
return false;
}
}
if (! requires(ordered a) { a != a; })
-> { friend bool operator != (const ordered& a, const ordered& b) { return !(a == b); } }
if (! requires(ordered a) { a > a; })
-> { friend bool operator > (const ordered& a, const ordered& b) { return b < a ; } }
if (! requires(ordered a) { a <= a; })
-> { friend bool operator <= (const ordered& a, const ordered& b) { return !(b < a); } }
if (! requires(ordered a) { a >= a; })
-> { friend bool operator >= (const ordered& a, const ordered& b) { return !(a < b); } }
}
};
```
Что? Выглядит сложно? Да, но вы не будете писать такой метакласс — он будет в стандартной библиотеке или в чём-то типа Boost. У себя в коде вы лишь определите точку, вот так:
```
ordered Point
{
int x;
int y;
};
```
И всё заработает!
Точно так же мы, наконец, сможем добиться того, чтобы вещи типа pair или tuple определялись тривиально:
```
template
literal\_value pair
{
T1 first;
T2 second;
};
```
Посмотрите, ради интереса, как банальная пара [определена сейчас](https://gcc.gnu.org/onlinedocs/gcc-4.6.3/libstdc++/api/a01060_source.html).
От открывающихся возможностей разбегаются глаза:
* Мы сможем явно определять в коде гайдлайны вроде «базовый класс должен всегда иметь чисто виртуальный деструктор» или "[правило трёх](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%BE_%D1%82%D1%80%D1%91%D1%85_(C%2B%2B_%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))"
* Мы сможем реализовать интерфейсы, value-типы, properties
* Мы сможем отказаться от Moc в Qt и от кастомных компиляторов для С++/CLI и C++/CX, поскольку все эти вещи можно будет описать метаклассами
* Мы сможем генерировать код не внешними кодогенераторами и не тупыми дефайнами, а встроенным мощным фреймворком
* Мы сможем реализовывать на этапе компиляции даже такие сложные проверки, как «во всех ли методах класса, обращающихся к некоторой переменной мы используем критическую секцию, контролирующую доступ к ней?»
Мета-уровень — это очень круто! Правда?
Вот вам ещё на закуску видео, где Герб об этом рассказывает детальнее:
А вот онлайн-компилятор, в котором это всё даже [можно попробовать](https://cppx.godbolt.org/). | https://habr.com/ru/post/334284/ | null | ru | null |
# Android Process: Я тебя породил, я тебя и …
Вы когда-нибудь задумывались о том, что происходит с вашим приложением после того, как система убила его процесс за ненадобностью? Печально, но многие об этом даже не беспокоятся, словно это будет происходить в параллельной вселенной и их это не касается. Особенно этому подвержены новички. Их слепая вера в непоколебимость статик ссылок просто поражает.
В этой статье я расскажу о некоторых ошибках, которые могут возникнуть в результате нарушения шестой заповеди (не убей) по отношению к процессу приложения, и о том как проверить на сколько качественно он возвращается с того света.
Ни для кого не секрет, что процесс может быть убит системой. А вы интересовались, реально ли сымитировать это? Можно попробовать“натравить” систему на свое приложение, запуская кучу других приложений, съедающих знатный кусок памяти, а затем надеяться, что система таки снизошла до нас убив нужное приложение. Прямо какой-то шаманизм получается, а это стезя админов, но никак не программистов. Меня заинтересовало, как можно легко и быстро убить приложение, да так, будто это сделала система для освобождения ресурсов. Ведь если получится повторить подобное поведение в “лабораторных условиях”, можно будет отлавливать множество ошибок ещё на стадии разработки, либо с лёгкостью воспроизвести их для выявления причин.
Как оказалось, нужный механизм уже имеется в SDK, и это… барабанная дробь… Кнопка «Terminate Application».
Нажатие на нее аналогично выполнению следующего кода:
```
// Код выхода здесь не играет большого значения.
// Однако, при нажатии "Terminate Application" используется именно “1”.
System.exit(1);
```
Это, собственно, и убивает процесс. Похожее действие происходит когда система пытается избавиться от ненужного процесса.
Для того, чтобы воспроизвести ситуацию с возобновлением работы приложения после его полной остановки, нужно проделать следующую последовательность действий:
1. Используя Android Stidio запустить приложение;
2. Свернуть приложение нажатием кнопки «Home»;
3. В Android Studio, перейти на вкладку Android, выбрать приложение и нажать кнопку «Terminate Application»;
4. Развернуть свернутое приложение.
Если Activity не совсем корректно обрабатывает восстановление после уничтожения, вы сразу это заметите. В лучшем случае оно упадёт, в худшем зависнет.
Итак, мы научились выманивать один из самых скрытных типов ошибок. Давайте научимся эти ошибки предвидеть. Начнем с самых очевидных случаев, а затем плавно перейдем к менее однозначным случаям.
Ситуация 1: Статик — это не надёжно
-----------------------------------
Представим такую ситуацию: В одной Activity мы вводим некий набор данных, например имя и фамилию. Эта Activity строго следит за правильностью ввода данных, поэтому можно с твёрдой уверенностью гарантировать их «корректность», и вообще то, что они были введены.
**Первая Activity**
```
public class StaticActivityFirst extends BaseActivity {
private EditText mEditFirstName;
private EditText mEditLastName;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.sit01_0_activity_first);
mEditFirstName = (EditText) findViewById(R.id.editFirstName);
mEditLastName = (EditText) findViewById(R.id.editLastName);
}
public void onNextClick(View view) {
String firstName = mEditFirstName.getText().toString().trim();
// Имя не должно быть пустым
if (TextUtils.isEmpty(firstName))
mEditFirstName.setError(getString(R.string.sit01_0_empty_text_error_message));
else {
mEditFirstName.setError(null);
String lastName = mEditLastName.getText().toString().trim();
// Фамилия не должна быть пустой
if (TextUtils.isEmpty(lastName))
mEditLastName.setError(getString(R.string.sit01_0_empty_text_error_message));
else {
mEditLastName.setError(null);
StaticActivitySecond.sPerson = new Person(firstName, lastName);
startActivity(new Intent(this, StaticActivitySecond.class));
}
}
}
}
```
После нажатия кнопки “Next” создается объект хранящий введенные данные и записывается в статик ссылку, а затем открывается вторая Activity, которая показывает эти данные в подобающем виде. Например, пишет: «Вас зовут Владимир Путин».
**Вторая Activity**
```
public class StaticActivitySecond extends BaseActivity {
public static Person sPerson;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.sit01_0_activity_second);
TextView txtSummary = (TextView) findViewById(R.id.txtSummary);
txtSummary.setText(String.format(getString(R.string.sit01_0_summary_message), sPerson.firstName, sPerson.lastName));
}
}
```
Как видно из кода, в первой Activity разработчик решил не “заморачиваться” и поместил данные в статические переменные. Это весьма соблазнительно, когда нужно передать достаточно неординарный объект, не поддающийся простой сериализации. Над второй Activity он тоже не долго думал и не сделал проверки на нул. Зачем, когда первая Activity всё уже сделала?
Проделываем описанную ранее последовательность по корректному уничтожению процесса на второй Activity. Приложение падает.
**Что случилось?**
Проблема тут не в отсутствии проверки на null. Самая страшная проблема — это потеря пользовательских данных. Статические объекты не должны быть хранилищем данных, особенно если это их единственное место. Касается это как обычных переменных так и синглтонов. Так что если в статике хранится что-то важное, будьте готовы это важное потерять в любой момент.
**Что делать?**
Наличие таких ошибок, зачастую, свидетельствует о низкой квалификации программиста, либо о слишком высоком чувстве лени. О том как делать правильно, написано огромное количество туториалов. В приведенном примере лучше всего подойдёт передача данных через бандл. Также можно писать эти данные в SharedPreferences, либо стоит задуматься о создании базы данных.
**Важно:** Не стоит забывать, что синглтон это тоже статик переменная. Если вы используете синглтон, то он должен выступать лишь как инструмент облегчающий доступ к данным, но ни как не быть единственным хранилищем для них.
**Волшебная сила Application**
Как часто я вижу советы использовать класс Application как синглтон либо инициализировать синглтон в методе onCreate() класса Application. Якобы после этого он станет круче чем Ленин, то есть будет живее всех живых при любых обстоятельствах. Возможно, это частный случай заблуждения встретившийся только мне. Причем, все публикации которые я находил, явно не заявляют о подобных свойствах синглтона. В некоторых из них говорится, что синглтон может быть уничтожен сборщиком мусора если инициировать его в классе Activity (что для меня звучит немного дико). В других пугают выгрузкой класса из класслоадера (а это уже похоже на правду).
Сейчас я не собираюсь выяснять, что тут правда а что домыслы. В любом случае это лишь снижает вероятность потери статик ссылки но ни как не спасает от остановки процесса. Остановка процесса приведет к полному уничтожению класслоадера, а вместе с ним и уничтожению всех классов, включая класс Application.
Ситуация 2: setRetainInstance как решение всех проблем
------------------------------------------------------
Допустим, некий программист решил повторить пример с именем и фамилией, но с использованием диалог фрагментов.
Итак, есть DialogFragment с текстовым полем для ввода фамилии и имени. Этому фрагменту можно установить слушатель на ввод данных. Для того что бы не потерять ссылку на слушатель в onCreate() вызывается setRetainInstance(true).
**Часть кода диалога**
```
public class Situation2DialogFragment extends DialogFragment {
private OnPersonChooseListener mListener;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setRetainInstance(true);
}
public void setListener(OnPersonChooseListener listener) {
mListener = listener;
}
public void invokePersonChoose(Person person) {
mListener.onPersonChoose(person);
}
public interface OnPersonChooseListener {
public void onPersonChoose(Person person);
}
// ...
}
```
На экране есть кнопка, при нажатии на которую этот диалог отображается.
**Вызов диалога из Activity**
```
public void onChoosePersonClick(View view) {
Situation2DialogFragment dialog = new Situation2DialogFragment();
dialog.setListener(new Situation2DialogFragment.OnPersonChooseListener() {
@Override
public void onPersonChoose(Person person) {
Toast.makeText(
Situation2Activity.this,
String.format(
getString(R.string.sit02_summary_message),
person.firstName,
person.lastName),
Toast.LENGTH_SHORT
).show();
}
});
dialog.show(getSupportFragmentManager(), Situation2DialogFragment.class.getName());
}
```
Такая реализация — стойка к любым вращениям экрана. Все будет работать как часы. До поры до времени…
Применим последовательность действий для хитрого уничтожения процесса, когда диалог открыт. При разворачивании ничего не произойдет. Однако, при вызове invokePersonChoose приложение вылетит с NullPointerException.
**Что случилось?**
setRetainInstance(true) не позволяло диалогу уничтожиться. После уничтожения процесса диалог все-таки был уничтожен. Activity восстанавливает фрагмент насколько это возможно. К сожалению, слушатель не восстанавливается, так как он был установлен совершенно в другом месте для совершенно другого объекта. Когда в диалоге, в методе invokePersonChoose, происходит обращение к слушателю, выбрасывается исключение. И беда тут не в отсутствии проверки на null. Поставить проверку на null без должной реакции на пустую ссылку будет еще более **худшим** решением.
**Что делать?**
В интернете описана куча способов передачи сообщений из фрагмента в Activity. К сожалению, не все из них правильные. Следующий способ правильный и один из моих любимых:
* Activity реализует нужный интерфейс:
**Часть кода Activity**
```
public class Situation2Activity extends Activity implements OnPersonChooseListener {
//…
@Override
public void onPersonChoose(Person person) {
Toast.makeText(
Situation2Activity.this,
String.format(
getString(R.string.sit02_summary_message),
person.firstName,
person.lastName),
Toast.LENGTH_SHORT
).show();
}
}
```
* Фрагмент получает ссылку на Activity через getActivity и приводит ее к соответствующему интерфейсу. Дальше вся работа осуществляется через интерфейс:
**Получение слушателя во фрагменте**
```
public void onAttach(Activity activity) {
super.onAttach(activity);
if (activity instanceof OnPersonChooseListener)
mListener = (OnPersonChooseListener) activity;
else
throw new RuntimeException("Activity must implement OnPersonChooseListener.");
}
```
Единственное, что не стоит забывать, Activity может быть уже уничтожена когда дело дойдет до отправки сообщения. Поэтому обязательно проверьте добавлен ли фрагмент на Activity.
По мимо Activity можно использовать родительский фрагмент или Target фрагмент.
**Еще пара слов про setRetainInstance**
Замечу, это лишь частный случай с setRetainInstance. Количество проблем которые он может скрыть(а не решить) немного больше. Вместе со слушателями также теряются и все остальные переменные. Все, что не было сохранено в методе onSaveInstanceState, будет потеряно.
Также, он скрывает проблему когда класс диалога анонимный. Допустим, в момент создания нового объекта диалога, переопределен какой либо метод, в этом случае создастся объект анонимного класса.
**Пример создания объекта с анонимным классом**
```
DialogFragment dialog = new DialogFragment() {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setRetainInstance(true);
}
};
```
Если этот диалог будет уничтожен и система попытается его восстановить выбросится исключение ClassNotFoundException.
Ситуация 3: Разорванные нити
----------------------------
Пусть суть приложения заключаться в следующем:
На экране кнопка. При нажатии на кнопку открывается диалог прогресса, блокирующий взаимодействие с UI.
**Код диалога прогресса**
```
public class ProgressDialogFragment extends DialogFragment {
public static final String DISMISS_ACTION = "ru.kamisempai.ProgressDialogFragment.DISMISS_ACTION";
private boolean isWaitingForDismiss = false;
private BroadcastReceiver mDismissActionReceiver;
@Override
public void onAttach(Activity activity) {
super.onAttach(activity);
mDismissActionReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
dismiss();
}
};
LocalBroadcastManager.getInstance(activity)
.registerReceiver(mDismissActionReceiver, new IntentFilter(DISMISS_ACTION));
}
@Override
public void onDetach() {
if (mDismissActionReceiver != null)
LocalBroadcastManager.getInstance(getActivity())
.unregisterReceiver(mDismissActionReceiver);
super.onDetach();
}
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
final android.app.ProgressDialog dialog = new android.app.ProgressDialog(getActivity()) {
@Override
public void onBackPressed() {
// do nothing
}
};
dialog.setMessage("Please wait...");
dialog.setCancelable(false);
dialog.setCanceledOnTouchOutside(false);
return dialog;
}
@Override
public void onResume() {
super.onResume();
if(isWaitingForDismiss)
dismiss();
}
@Override
public void dismiss() {
if(isResumed())
super.dismiss();
else
isWaitingForDismiss = true;
}
}
```
Как можно понять из кода, этот диалог может быть закрыт через посылку широковещательного сообщения. А это значит, что нет необходимости хранить ссылку на него, достаточно иметь контекст приложения.
Сразу после запуска диалога запускается поток, выполняющий что-то некоторое время. В самом конце своей работы поток посылает сообщение для закрытия диалога прогресса.
**Создание и запуск потока**
```
public void onStartActionClick(View view) {
new ProgressDialogFragment()
.show(getSupportFragmentManager(), ProgressDialogFragment.class.getName());
final Context context = getApplicationContext();
new Thread() {
@Override
public void run() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
LocalBroadcastManager.getInstance(context)
.sendBroadcast(new Intent(ProgressDialogFragment.DISMISS_ACTION));
}
}.start();
}
```
Если запустить этот код и не дожидаясь его завершения свернуть приложение, а затем вырубить процесс, то при разворачивании ничего не предвещает беды, приложение не падает, а диалог показывается. Ждём немножко… Ещё ждём… Потом ещё ждём… Диалог не закрывается, хоть и должен был сделать это уже давно.
**Что случилось?**
При уничтожении процесса останавливаются все его потоки, а при восстановлении запускается только главный поток. Так что если ваш поток работает слишком долго, будьте готовы к тому, что он будет остановлен. Причём не обязательно делать что-то долго, на эти грабли можно наступить и при использовании wait notify. Особенно забавно будет, если в качестве объекта для блокировки использовать public static final Object, ведь мы то уже знаем, что статик объекты не исключение при уничтожении процесса.
**Пример с wait notify**
```
private static final Object LOCK = new Object();
public void onStartWaitClick(View view) {
// ...
new Thread() {
@Override
public void run() {
synchronized (LOCK) {
try {
// Поток останавливается и ждет.
LOCK.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// Действия после ожидания
}
}.start();
}
public void onContinueClick(View view) {
new Thread() {
@Override
public void run() {
synchronized (LOCK) {
LOCK.notify();
}
}
}.start();
}
```
**Что делать?**
Если задача занимает много времени вынести ее в отдельный сервис и запустить в новом процессе, плюс вывести foreground Notification, иначе процесс все равно будет убит. В случае с wait notify все немного сложнее и зависит от конкретной ситуации. Вообще, тема работы с потоками достаточно обширна, и давать какой-то конкретный совет тут неуместно. Разве что не усложнять и не лезть в дебри, из которых не сможешь вылезти.
Ситуация 4: Письмо в никуда
---------------------------
Есть Activity с одной единственной View. Она подписана на получение широковещательных сообщений. Когда Activity получает такое сообщение, цвет View меняется в зависимости от содержимого этого сообщения. При клике на View открывается вторая Activity, через которую можно посылать те самые сообщения для смены цвета.
**Код первой Activity**
```
public class Situation4FirstActivity extends BaseActivity {
public static final String ACTION_SET_COLOR = "ru.kamisempai.Situation4FirstActivity.ACTION_SET_COLOR";
public static final String EXTRA_COLOR = "ru.kamisempai.Situation4FirstActivity.EXTRA_COLOR";
private View mView;
private BroadcastReceiver mSetColorActionReceiver;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mView = new View(this);
setContentView(mView);
mView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// Запуск второй Activity
startActivity(new Intent(Situation4FirstActivity.this, Situation4SecondActivity.class));
}
});
mSetColorActionReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, final Intent intent) {
// Менять цвет у view нужно в основном потоке
runOnUiThread(new Runnable() {
@Override
public void run() {
mView.setBackgroundColor(intent.getIntExtra(EXTRA_COLOR, Color.BLUE));
}
});
}
};
LocalBroadcastManager.getInstance(this)
.registerReceiver(mSetColorActionReceiver, new IntentFilter(ACTION_SET_COLOR));
}
@Override
protected void onDestroy() {
// При уничтожении Activity не забываем отписаться от получения сообщений
LocalBroadcastManager.getInstance(this)
.unregisterReceiver(mSetColorActionReceiver);
super.onDestroy();
}
}
```
Для того чтобы первая Activity не уничтожалась при поворотах экрана, в файл манифеста добавлены configChanges.
```
```
Во второй Activity есть кнопка, нажатие по которой шлет сообщение для смены цвета.
**Код второй Activity**
```
public class Situation4SecondActivity extends BaseActivity {
private Random mRandom;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.sit04_activity_second);
mRandom = new Random(System.currentTimeMillis());
}
public void onRandomizeColorClick(View view) {
Intent intent = new Intent(Situation4FirstActivity.ACTION_SET_COLOR);
intent.putExtra(
Situation4FirstActivity.EXTRA_COLOR,
Color.BLACK + mRandom.nextInt(0xFFFFFF));
LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
}
}
```
При возвращении на первую Activity цвет View будет изменен.
Однако, если перейти на вторую Activity, свернуть приложение, убить процесс, а затем развернуть приложение, случится кое-что не предвиденное. Сколько бы раз вы не нажимали на кнопку смены цвета, при возвращении на первую Activity ее View будет белоснежной.
**Что случилось?**
Не смотря на то, что стек активностей сохранился, после разворачивания приложения была восстановлена только вторая Activity. Фактически, сообщения о смене цвета уходили в никуда. Так как на тот момент не существовало объектов, подписанных на это событие. При возвращении на первую Activity она была восстановлена, но подписываться на событие смены цвета было уже поздно.
**Что делать?**
Первым делом нужно уяснить главное — если вы работаете с одной Activity, остальные для нее не существуют. Если нужно донести какую либо информацию, используйте предназначенный для этого setResult. Еще не следует слепо полагаться на жизненные циклы. Как видно из примера, если Activity 1 запустила Activity 2 то это еще не значит, что метод onCreate первой Activity был выполнен.
Также замечу, этот пример показывает не только на проблемы со стеком активностей, но и проблемы со всем, что связано с посылкой сообщений. Исключением будут только BroadcastReceiver-ы, прописанные в манифесте, либо запланированные через AlarmManager. Все остальное не дает 100% гарантии на доставку сообщения адресату.
Заключение
----------
“Бывалым кодерам” эти ситуации могут показаться очевидными, а примеры на столько не естественными, что просто воротит. Однако, все мы когда-то начинали с нуля и писали код от которого сейчас было бы стыдно. Знай я об этих граблях в самом начале своего пути, шишек на лбу было бы меньше. Надеюсь, эта статья поможет наставить на путь истинный большое количество начинающих Android программистов. От “Бывалых” буду рад увидеть комментарии. А еще лучше если вы дополните список или напишете, помогла ли эта статья в ловле багов из разряда “Как?! Такого не может быть!”.
На этом закончу. Спасибо за внимание. Напоследок замечу, в рукаве у меня еще остался один неординарный случай. Он еще не изучен мной до конца, но я надеюсь в скором времени расколоть этот крепкий орешек. Так что ждите продолжения. | https://habr.com/ru/post/261721/ | null | ru | null |
# Нескучный API
Как создать АПИ для умных? Такое апи, чтобы создание клиента для него было не скучным механическим процессом, а настоящим приключением с элементами детектива, хоррора и мистики? Такое апи, о котором пользователи будут взахлёб рассказываете коллегам? Апи взрывающее мозг, заставляющее смеяться, кричать и плакать? Я постарался отобрать лучшие практики, с которыми пришлось столкнуться.
### Делай так
1. Избегай очевидных названий. checkInDate лучше записать как start\_date, еще лучше как sd, еще лучше как d. Тогда длинное и некрасивое checkInDate/checkOutDate превратится в лаконичное d1/d2. Еще больше отличных идей по именованию можно почерпнуть в книге “Совершенный код” в главе “Сила имен переменных”
2. Не используй стандарты. ISO 8601? Чтобы преобразовывать дату с использованием стандартных библиотек, имеющихся в любом языке программирования и не написав ни одной регулярки? Скукота.
3. Не используй в названиях термины предметной области. Лучше придумай что-нибудь максимально абстрактное.
4. Придумай свою систему обозначения состояний. К примеру: 1,2,3 — есть, нет, под заказ. Не вздумай писать состояния напрямую и уж тем более, никогда не используй справочник состояний.
5. Передавай вложенные структуры как список плоских связанных через внутренние айдишники, сгенерированные специально под этот ответ.
```
{
Jacket: \[{MaterialsIds=”m1,m2”, Pockets: “p1”, Price: 12000}\],
Materials: \[{Name: “Stormscale”, Color: “Tear of Elune”, InnerId=”m1”},
{Name: “Feather of Valor”, Color: “unpredictable”, InnerId=”m2”}\],
Pockets:\[{Type: “Invisible”, Contents: “Soap”, InnerId="p1"}\]}
}
```
6. Не повторяйся.
a. Придумай разные системы для обозначения состояний разных объектов. К цифровой, описанной выше, можно добавить цветовую: green, red, yellow.
b. Меняй не только формат данных, но и формат записи названий полей — srart\_date: 25/12/05, endDay: 2012.11.23.
c. Не забудь про огромный выбор разделителей: запятая, точка, точка с запятой. Добавь в него что-нибудь нестандартное — знак процента или решетку.
j. Список можно продолжать, будь креативен.
7. Замени True/False на 1/0, а ещё лучше на 0/1. Превратив простое “has\_goods: True” в четыре вопроса — айдишник? количество? просто ‘да’? или, таки, “нет”?
8. Используй битовые флаги. Так ты продемонстрируешь свою исключительную образованность. Переведи их в десятичную форму для меньшей очевидности. Не передавай маску вместе с флагами, или даже в отдельном словаре. “flgs: 16” в структуре и список флагов в документации — прекрасный вариант.
9. Старайся засунуть в каждое поле как можно больше смыслов.
```
has_goods может принимать значения [-2, -1, 0, любое положительное число],
что значит: [уточните, нет в продаже, нет в наличии, количество товара в наличии]
```
10. Добавьте в запрос обязательный параметр, у которого может быть только одно значение.
11. Добавь в запрос параметр, смысл которого будет менять в зависимости от значения другого, необязательного, параметра.
```
http://example.com/myService?cloth_type=silk∧_better=1
Где "cloth_type" - обозначает конкретный тип ткани (тут, естественно, требуется название ткани строкой, даже если есть справочник тканей, в котором указаны их айдишники), а "and_better" делает его началом диапазона с константным концом. Для “большей гибкости” можно дать параметру "and_better" второе значение (-1, 0, false, not) или добавить необязательный параметр "and_worst" и обрабатывать тот, который стоит первым/последним, либо сначала проверять наличие первого, а при его отсутствии - второго.
```
12. Задавай диапазоны на перечислимых данных последовательным списком, а на данных, порядок которых определен только в твоём приложении, началом и концом диапазона, а еще лучше через дефис или другой разделитель по вкусу.
```
http://example.com/myService?d=11.12.05&d=12.12.05&d=13.12.05&colors=green;yellow
```
13. Используй однотипные названия для полей с разными типами данных.
```
http://example.com/myService?cats=5&dogs=4&hamsters=0 где cats и dogs интовые поля обозначающие количество, а hamsters битовое поле обозначающее наличие.
```
14. Не обрабатывай ошибки. Переданы несовместимые параметры? Пустой ответ должен стать достаточной подсказкой. Или отсутствие ответа. Или отправь эксепшн сгенерированный твоим приложением.
15. Документация не нужна.
a. Если пришлось документировать, пропусти наиболее “очевидные” места.
b. Не усложняй документацию примерами.
c. Задокументируй отсутствующий функционал, который ты обязательно допишешь потом.
d. Раздели документацию на несколько частей и каждую отдавай только тем пользователям, которые догадаются про неё спросить.
Этот список основан на реальных событиях, имена изменены в интересах конфиденциальности, все совпадения не случайны.
P.S. Напишите о своих героях и их былинных деяниях в комментариях. | https://habr.com/ru/post/344790/ | null | ru | null |
# Достать worklog из Jira
Всем привет, недвано я писал про api клиент для Jira. Разбираться с ним я начал, когда возникла необходимость автоматизировать формирование отчета по времени(отчеты нужны заказчику). В итоге получися небольшой инструмент который позволяет быстро и легко вытаскивать необходимые данные.
Изначально думалось, что подобный отчет можно вытащить из Jira. Но прошарив ее, так ничего и не нашли. Новый PM написал скрипт, который извлекал данные из уже готового excel файла, но все равно, время от времен приходилось что-то править руками. Когда я узнал об этой проблеме, я наткнулся на api клиент для нашего любимого трекера и принялся за работу.
Получился небольшой python-скрипт который выгружал данные в excel файл на компьютер.
После этого появилась необходимость хранить автаризационные данные. Добавил следующие строки:
```
config = configparser.ConfigParser()
config['DEFAULT'] = {'Login': login,
'ApiKey': api_key,
'Server': server}
with open('config.ini', 'w') as configfile:
config.write(configfile)
```
После этого утилитой стали пользоваться еще пару человек и пришлось добавить функционал выгрузки отчета за определенный период. В результате окно утилиты стало выглядеть так:
Конечно возникала мысль перевести все в графический интерфейс, но пока что алгоритм линейный и интерфейс не нужен.
Так же, если рядом с main.py (или же reporter.exe — собранным exe-шником) нет фала config.ini, утилита запустит процесс настройки. Спросит линк к Jira, пароль или api-key и логин:
Сам отчет формируется либо за неделю, либо за необходимый промежуток времени, указанный пользователем. Если кому будет просто интересно или даже захочется использовать, все исходники лежат здесь [Repo GIT](https://github.com/timoha199490/JiraTimeReport/).
Спасибо за внимание =) | https://habr.com/ru/post/458516/ | null | ru | null |
# Новое в Java 12: The Teeing Collector
В этой статье мы рассмотрим новый коллектор, представленный в Java 12. Эта новая функция не была анонсирована в официальном JEP, поскольку это был минорный change request с заголовком "[Create Collector, which merges the results of two other collectors](https://bugs.openjdk.java.net/browse/JDK-8209685)". Она предназначена для объединения результатов с двух коллекторов.
*Все интересное — под катом*
**Если вы еще не знаете, что такое коллекторы** Коллекторы, это специальные классы, использующиеся для преобразования стрима в другую структуру данных. Например, в `list`:
```
list = Stream.of(1,2,3).collect(Collectors.toList());
//в листе теперь находятся элементы 1, 2 и 3
```
Это бесполезный пример, потому что он создает новый стрим и сразу его преобразует. Он придуман для того, чтобы показать использование коллекторов
### Документация
[Нажмите сюда](https://docs.oracle.com/en/java/javase/12/docs/api/java.base/java/util/stream/Collectors.html), чтобы просмотреть `Collectors#teeing`. Согласно официальной документации:
> «… возвращает коллектор, составленный из двух нижестоящих коллекторов. Каждый элемент переданный в результирующий коллектор, обрабатывается обоими нижестоящими коллекторами, а затем их результаты объединяются с помощью специальной функции, которая соединяет их в конечный результат.»
>
> **Оригинал**"...returns a Collector that is a composite of two downstream collectors. Every element passed to the resulting collector is processed by both downstream collectors, then their results are merged using the specified merge function into the final result."
>
>
Заголовок метода:
```
static Collector teeing(
Collector super T, ?, R1 downstream1, Collector super T, ?, R2 downstream2, BiFunction super R1, ? super R2, R merger)
```
### Интересный факт
Это *тройник*(teeing с англ.):
`Teeing` произошел от тройника. Согласно Википедии, «тройник — самый распространенный фитинг(соединительная часть трубопровода, прим. переводчика) используемый для объединения[или разделения] потока жидкостей(в данном случае имеются ввиду стримы, stream — ручей/поток, прим. переводчика)».
> Предлагались и другие имена: bisecting(разделение\_на\_2\_части), duplexing, bifurcate(раздвоение), replicator, fanout(разветвление), tapping, unzipping, collectionToBothAndThen, biCollecting, expanding(расширение), forking, и т.д.
>
> Все альтернативы, оцененные разработчиками Core, [можно посмотреть здесь](http://mail.openjdk.java.net/pipermail/core-libs-dev/2018-June/053987.html).
### Примеры использования
Я собрал три примера использования кода с разными уровнями сложности.
#### Список гостей
Мы извлекаем два разных типа информации из списка объектов в потоке. Каждый гость должен принять приглашение и может привести семью. Мы хотим знать, **кто подтвердил бронирование** и **общее количество участников**(включая гостей и членов семьи).
```
var result =
Stream.of(
// Guest(String name, boolean participating, Integer participantsNumber)
new Guest("Marco", true, 3),
new Guest("David", false, 2),
new Guest("Roger",true, 6))
.collect(Collectors.teeing(
// Первый коллектор, мы выбираем только тех, кто подтвердил участие
Collectors.filtering(Guest::isParticipating,
// мы хотим взять только имя в списке
Collectors.mapping(o -> o.name, Collectors.toList())),
// второй коллектор, мы хотим найти общее количество участников
Collectors.summingInt(Guest::getParticipantsNumber),
// мы объединяем коллекторы в новый объект,
// значения передаются неявно
EventParticipation::new
));
System.out.println(result);
// Результат
// EventParticipation { guests = [Marco, Roger],
// total number of participants = 11 }
```
**Guest**
```
class Guest {
private String name;
private boolean participating;
private Integer participantsNumber;
public Guest(String name, boolean participating,
Integer participantsNumber) {
this.name = name;
this.participating = participating;
this.participantsNumber = participantsNumber;
}
public boolean isParticipating() {
return participating;
}
public Integer getParticipantsNumber() {
return participantsNumber;
}
}
```
**EventParticipation**
```
class EventParticipation {
private List guestNameList;
private Integer totalNumberOfParticipants;
public EventParticipation(List guestNameList,
Integer totalNumberOfParticipants) {
this.guestNameList = guestNameList;
this.totalNumberOfParticipants = totalNumberOfParticipants;
}
@Override
public String toString() {
return "EventParticipation { " +
"guests = " + guestNameList +
", total number of participants = " + totalNumberOfParticipants +
" }";
}}
```
#### Отфильтровать имена в двух разных списках
В этом примере мы разделяем поток имен на два списка в соответствии с фильтром.
```
var result =
Stream.of("Devoxx", "Voxxed Days", "Code One", "Basel One",
"Angular Connect")
.collect(Collectors.teeing(
// первый коллектор
Collectors.filtering(n -> n.contains("xx"), Collectors.toList()),
// второй коллектор
Collectors.filtering(n -> n.endsWith("One"), Collectors.toList()),
// слияние - автоматический вывод типа здесь не работает
(List list1, List list2) -> List.of(list1, list2)
));
System.out.println(result); // -> [[Devoxx, Voxxed Days], [Code One, Basel One]]
```
#### Посчитайте и сложите стрим из чисел
Возможно, вы видели похожий пример, появляющийся в блогах, которые соединяют sum и count для получения среднего. Этот пример не требует `Teeing`, и вы можете просто использовать `AverageInt` и простой коллектор.
В следующем примере используются функции из `Teeing` для возврата двух значений:
```
var result =
Stream.of(5, 12, 19, 21)
.collect(Collectors.teeing(
// первый коллектор
Collectors.counting(),
// второй коллектор
Collectors.summingInt(n -> Integer.valueOf(n.toString())),
// объединение: (count, sum) -> new Result(count, sum);
Result::new
));
System.out.println(result); // -> {count=4, sum=57}
```
**Result**
```
class Result {
private Long count;
private Integer sum;
public Result(Long count, Integer sum) {
this.count = count;
this.sum = sum;
}
@Override
public String toString() {
return "{" +
"count=" + count +
", sum=" + sum +
'}';
}}
```
### Возможная ловушка
##### Map.Entry
Многие примеры используют `Map.Entry` для хранения результата `BiFunction`. Пожалуйста, не делайте этого, потому что вы не сможете хранить последний аргумент в `Map`. В Java Core нет стандартного объекта для хранения двух значений — вы будете должны создать его самостоятельно.
### Все о новых фичах Java 12
Вы можете узнать больше информации и интересных фактов о Java 12 в этой [презентации](https://speakerdeck.com/marcomolteni/java-12-new-features-in-action).
Успешного коллекционирования! | https://habr.com/ru/post/445622/ | null | ru | null |
# Парсим 25TB с помощью AWK и R
***Как читать эту статью**: прошу прощения за то, что текст получился таким длинным и хаотичным. Чтобы сэкономить ваше время, я каждую главу начинаю со вступления «Чему я научился», в котором одним-двумя предложениями излагаю суть главы.
**«Просто покажи решение!»** Если вы хотите всего лишь увидеть, к чему я пришёл, то переходите к главе «Становлюсь изобретательнее», но я считаю, что интереснее и полезнее почитать про неудачи.*
Недавно мне поручили настроить процесс обработки большого объёма исходных последовательностей ДНК (технически это SNP-чип). Нужно было быстро получать данные о заданном генетическом местоположении (которое называется SNP) для последующего моделирования и прочих задач. С помощью R и AWK мне удалось очистить и организовать данные естественным образом, сильно ускорив обработку запросов. Далось мне это нелегко и потребовало многочисленных итераций. Эта статья поможет вам избежать некоторых моих ошибок и продемонстрирует, что же у меня в конце концов получилось.
Для начала некоторые вводные пояснения.
Данные
------
Наш университетский центр обработки генетической информации предоставил нам данные в виде TSV объёмом 25 Тб. Мне они достались разбитыми на 5 пакетов, сжатых Gzip, каждый из которых содержал около 240 четырёхгигабайтных файлов. Каждый ряд содержал данные для одного SNP одного человека. Всего были переданы данные по ~2,5 млн SNP и ~60 тыс. человек. Кроме SNP-информации в файлах были многочисленные колонки с числами, отражающими различные характеристики, такие как интенсивность чтения, частота разных аллелей и т.д. Всего было порядка 30 колонок с уникальными значениями.
#### Цель
Как и в любом проекте по управлению данными, самым важным было определить, как будут использоваться данные. В этом случае **мы по большей части будем подбирать модели и рабочие процессы для SNP на основе SNP**. То есть одновременно нам будут нужны данные только по одному SNP. Я должен был научиться как можно проще, быстрее и дешевле извлекать все записи, относящиеся к одному из 2,5 миллионов SNP.
Как этого не делать
===================
Процитирую подходящее клише:
> Я не терпел тысячу раз неудачу, я лишь открыл тысячу способов не парсить кучу данных в формате, удобном для запросов.
Первая попытка
--------------
**Чему я научился**: не существует дешёвого способа отпарсить 25 Тб за раз.
Прослушав в Университете Вандербильта предмет «Расширенные методы обработки больших данных», я был уверен, что дело в шляпе. Пожалуй, час-два уйдёт на настройку Hive-сервера, чтобы пробежать по всем данным и отчитаться о результате. Поскольку наши данные хранятся в AWS S3, я воспользовался сервисом [Athena](https://aws.amazon.com/athena/), который позволяет применять Hive SQL-запросы к S3-данным. Не надо настраивать/поднимать Hive-кластер, да ещё и платишь только за те данные, которые ищешь.
После того как я показал Athena свои данные и их формат, я прогнал несколько тестов с подобными запросами:
```
select * from intensityData limit 10;
```
И быстро получил хорошо структурированные результаты. Готово.
Пока мы не попробовали использовать данные в работе…
Меня попросили вытащить всю информацию по SNP, чтобы протестировать на ней модель. Я запустил запрос:
```
select * from intensityData
where snp = 'rs123456';
```
…и стал ждать. Спустя восемь минут и больше 4 Тб запрошенных данных я получил результат. Athena берёт плату за объём найденных данных, по $5 за терабайт. Так что этот единственный запрос обошёлся в $20 и восемь минут ожидания. Чтобы прогнать модель по всем данным, нужно было прождать 38 лет и заплатить $50 млн. Очевидно, что нам это не подходило.
Нужно было использовать Parquet…
--------------------------------
**Чему я научился**: будьте осторожны с размером ваших Parquet-файлов и их организацией.
Сначала я попытался исправить ситуацию, конвертировав все TSV в [Parquet-файлы](https://parquet.apache.org/). Они удобны для работы с большими наборами данных, потому что информация в них хранится в колоночном виде: каждая колонка лежит в собственном сегменте памяти/диска, в отличие от текстовых файлов, в которых строки содержат элементы каждой колонки. И если нужно что-то найти, то достаточно прочитать необходимую колонку. Кроме того, в каждом файле в колонке хранится диапазон значений, так что если искомое значение отсутствует в диапазоне колонки, Spark не будет тратить время на сканирование всего файла.
Я запустил простую задачу [AWS Glue](https://aws.amazon.com/glue/) для преобразования наших TSV в Parquet и забросил новые файлы в Athena. Это заняло около 5 часов. Но когда я запустил запрос, то на его выполнение ушло примерно столько же времени и чуть меньше денег. Дело в том, что Spark, пытаясь оптимизировать задачу, просто распаковал один TSV-чанк и положил его в собственный Parquet-чанк. И поскольку каждый чанк был достаточно велик и вмещал полные записи многих людей, то в каждом файле хранились все SNP, поэтому Spark’у приходилось открывать все файлы, чтобы извлечь нужную информацию.
Любопытно, что используемый по умолчанию (и рекомендуемый) тип компрессии в Parquet — snappy, — не является разделяемым (splitable). Поэтому каждый исполнитель (executor) залипал на задаче распаковки и загрузи полного датасета на 3,5 Гб.
Разбираемся в проблеме
----------------------
**Чему я научился**: сортировать сложно, особенно, если данные распределены.
Мне казалось, что теперь я понял суть проблемы. Мне нужно было лишь отсортировать данные по колонке SNP, а не по людям. Тогда в отдельном чанке данных будет храниться несколько SNP, и тогда себя во всей красе проявит «умная» функция Parquet «открывать только если значение находится в диапазоне». К сожалению, отсортировать миллиарды строк, раскиданных по кластеру, оказалось сложной задачей.
> Me taking algorithms class in college: "Ugh, no one cares about computational complexity of all these sorting algorithms"
>
> Me trying to sort on a column in a 20TB [#spark](https://twitter.com/hashtag/spark?src=hash&ref_src=twsrc%5Etfw) table: "Why is this taking so long?" [#DataScience](https://twitter.com/hashtag/DataScience?src=hash&ref_src=twsrc%5Etfw) struggles.
>
> — Nick Strayer (@NicholasStrayer) [March 11, 2019](https://twitter.com/NicholasStrayer/status/1105127759318319105?ref_src=twsrc%5Etfw)
AWS точно не хочет возвращать деньги по причине «Я рассеянный студент». После того, как я запустил сортировку на Amazon Glue, она проработала 2 дня и завершилась сбоем.
Что насчёт партиционирования?
-----------------------------
**Чему я научился**: партиции в Spark должны быть сбалансированы.
Затем мне пришла в голову идея партиционировать данные в хромосомах. Их 23 штуки (и ещё несколько, если учитывать митохондриальную ДНК и нерасшифрованные (unmapped) области).
Это позволит разделить данные на более мелкие порции. Если добавить в Spark-функцию экспорта в скрипте Glue всего лишь одну строку `partition_by = "chr"`, то данные должны быть разложены по бакетам (buckets).
*Геном состоит из многочисленных фрагментов, которые называются хромосомами.*
К сожалению, это не сработало. У хромосом разные размеры, а значит и разное количество информации. Это значит, задачи, которые Spark отправлял воркерам, не были сбалансированы и выполнялись медленно, потому что некоторые узлы заканчивали раньше и простаивали. Однако задачи были выполнены. Но при запросе одного SNP несбалансированность снова стала причиной проблем. Стоимость обработки SNP в более крупных хромосомах (то есть там, откуда мы и хотим получить данные) уменьшилась всего лишь примерно в 10 раз. Много, но не достаточно.
А если разделить на ещё более мелкие партиции?
----------------------------------------------
**Чему я научился**: вообще никогда не пытайтесь делать 2,5 миллиона партиций.
Я решил гулять по полной и партиционировал каждый SNP. Это гарантировало одинаковый размер партиций. **ПЛОХАЯ БЫЛА ИДЕЯ**. Я воспользовался Glue и добавил невинную строку `partition_by = 'snp'`. Задача запустилась и начала выполняться. День спустя я проверил, и увидел, что в S3 до сих пор ничего не записано, поэтому убил задачу. Похоже, Glue записывал промежуточные файлы в скрытое место в S3, и много файлов, возможно, пару миллионов. В результате моя ошибка обошлась более чем в тысячу долларов и не обрадовала моего наставника.
Партиционирование + сортировка
------------------------------
**Чему я научился**: сортировать всё ещё трудно, как и настраивать Spark.
Последняя попытка партиционирования заключалась в том, что я партиционировал хромосомы, а затем сортировал каждую партицию. В теории, это позволяло бы ускорить каждый запрос, потому что желаемые данные об SNP должны были находиться в пределах нескольких Parquet-чанков внутри заданного диапазона. Увы, сортировка даже партиционированных данных оказалась трудной задачей. В результате я перешёл на EMR для кастомного кластера и использовал восемь мощных инстансов (C5.4xl) и Sparklyr для создания более гибкого рабочего процесса…
```
# Sparklyr snippet to partition by chr and sort w/in partition
# Join the raw data with the snp bins
raw_data
group_by(chr) %>%
arrange(Position) %>%
Spark_write_Parquet(
path = DUMP_LOC,
mode = 'overwrite',
partition_by = c('chr')
)
```
…однако задача всё равно так и не была выполнена. Я настраивал по-всякому: увеличивал выделение памяти для каждого исполнителя запросов, использовал узлы с большим объёмом памяти, применял широковещательные переменные (broadcasting variable), но каждый раз это оказывались полумеры, и постепенно исполнители начинали сбоить, пока всё не остановилось.
> Update: so it begins. [pic.twitter.com/agY4GU2ru5](https://t.co/agY4GU2ru5)
>
> — Nick Strayer (@NicholasStrayer) [May 15, 2019](https://twitter.com/NicholasStrayer/status/1128703858610450434?ref_src=twsrc%5Etfw)
Становлюсь изобретательнее
==========================
**Чему я научился**: иногда особые данные требуют особых решений.
У каждого SNP есть значение позиции. Это число, соответствующее количеству оснований, лежащих вдоль его хромосомы. Это хороший и естественный способ организации наших данных. Сначала я хотел партиционировать по областям каждой хромосомы. Например, позиции 1 — 2000, 2001 — 4000 и т.д. Но проблема в том, что SNP распределены по хромосомам неравномерно, поэтому поэтому размер групп будет сильно различаться.
В результате я пришёл к разбиению по категориям (rank) позиций. По уже загруженным данным я прогнал запрос на получение списка уникальных SNP, их позиций и хромосом. Затем отсортировал данные внутри каждой хромосомы и собрал SNP в группы (bin) заданного размера. Скажем, по 1000 SNP. Это дало мне взаимосвязь SNP с группой-в-хромосоме.
В конце концов я сделал группы (bin) по 75 SNP, причину объясню ниже.
```
snp_to_bin <- unique_snps %>%
group_by(chr) %>%
arrange(position) %>%
mutate(
rank = 1:n()
bin = floor(rank/snps_per_bin)
) %>%
ungroup()
```
Первая попытка со Spark
-----------------------
**Чему я научился**: объединение в Spark работает быстро, но партиционирование всё ещё обходится дорого.
Я хотел прочитать этот маленький (2,5 млн строк) фрейм данных в Spark, объединить его с сырыми данными, а затем партиционировать по свежедобавленной колонке `bin`.
```
# Join the raw data with the snp bins
data_w_bin <- raw_data %>%
left_join(sdf_broadcast(snp_to_bin), by ='snp_name') %>%
group_by(chr_bin) %>%
arrange(Position) %>%
Spark_write_Parquet(
path = DUMP_LOC,
mode = 'overwrite',
partition_by = c('chr_bin')
)
```
Я использовал `sdf_broadcast()`, таким образом Spark узнаёт, что он должен отправить фрейм данных во все узлы. Это полезно, если данные небольшого размера и требуются для всех задач. Иначе Spark пытается быть умным и распределяет данные по мере надобности, что может стать причиной тормозов.
И опять моя задумка не сработала: задачи какое-то время работали, завершали объединение, а затем, как и запущенные партиционированием исполнители, начали сбоить.
Добавляю AWK
------------
**Чему я научился**: не спите, когда вам преподают основы. Наверняка кто-то уже решил вашу проблему ещё в 1980-х.
До этого момента причиной всех моих неудач со Spark была перемешанность данных в кластере. Возможно, ситуацию можно улучшить с помощью предварительной обработки. Я решил попробовать разделить сырые текстовые данные на колонки хромосом, так я надеялся предоставить Spark’у «предварительно партиционированные» данные.
Я поискал на StackOverflow, как разбивать по значениям колонок, и нашёл [такой прекрасный ответ.](https://unix.stackexchange.com/questions/114061/extract-data-from-a-file-and-place-in-different-files-based-on1-column-value) С помощью AWK вы можете разделить текстовый файл по значениям колонок, выполнив запись в скрипте, а не отправляя результаты в `stdout`.
Для пробы я написал Bash-скрипт. Скачал один из запакованных TSV, затем распаковал его с помощью `gzip` и отправил в `awk`.
```
gzip -dc path/to/chunk/file.gz |
awk -F '\t' \
'{print $1",..."$30">"chunked/"$chr"_chr"$15".csv"}'
```
Это сработало!
Заполнение ядер
---------------
**Чему я научился**: `gnu parallel` — это волшебная вещь, все должны её использовать.
Разделение проходило довольно медленно, и когда я запустил `htop`, чтобы проверить использование мощного (и дорогого) EC2-инстанса, то оказалось, что я задействую только одно ядро и примерно 200 Мб памяти. Чтобы решить задачу и не потерять кучу денег, нужно было придумать, как распараллелить работу. К счастью, в совершенно потрясающей книге [Data Science at the Command Line](https://www.datascienceatthecommandline.com/) Джерона Джанссенса я нашёл главу, посвящённую распараллеливанию. Из неё я узнал про `gnu parallel`, очень гибкий метод реализации многопоточности в Unix.
Когда я запустил разделение с помощью нового процесса, всё было прекрасно, но оставалось узкое место — скачивание S3-объектов на диск было не слишком быстрым и не полностью распараллеленным. Чтобы это исправить, я сделал вот что:
1. Выяснил, что можно прямо в конвейере реализовать этап S3-скачивания, полностью исключив промежуточное хранение на диске. Это означает, что я могу избежать записи сырых данных на диск и использовать ещё более маленькое, а значит и более дешёвое хранилище на AWS.
2. Командой `aws configure set default.s3.max_concurrent_requests 50` сильно увеличил количество потоков, которые использует AWS CLI (по умолчанию их 10).
3. Перешёл на оптимизированный по скорости сети инстанс EC2, с буквой n в названии. Я обнаружил, что потеря вычислительной мощности при использовании n-инстансов с лихвой компенсируется увеличением скорости загрузки. Для большинства задач я использовал c5n.4xl.
4. Поменял `gzip` на [`pigz`](https://linux.die.net/man/1/pigz), это gzip-инструмент, который умеет делать классные штуки для распараллеливания изначально не распараллеленной задачи распаковки файлов (это помогло меньше всего).
```
# Let S3 use as many threads as it wants
aws configure set default.s3.max_concurrent_requests 50
for chunk_file in $(aws s3 ls $DATA_LOC | awk '{print $4}' | grep 'chr'$DESIRED_CHR'.csv') ; do
aws s3 cp s3://$batch_loc$chunk_file - |
pigz -dc |
parallel --block 100M --pipe \
"awk -F '\t' '{print \$1\",...\"$30\">\"chunked/{#}_chr\"\$15\".csv\"}'"
# Combine all the parallel process chunks to single files
ls chunked/ |
cut -d '_' -f 2 |
sort -u |
parallel 'cat chunked/*_{} | sort -k5 -n -S 80% -t, | aws s3 cp - '$s3_dest'/batch_'$batch_num'_{}'
# Clean up intermediate data
rm chunked/*
done
```
Эти шаги скомбинированы друг с другом, чтобы всё работало очень быстро. Благодаря увеличению скорости скачивания и отказу от записи на диск я теперь мог обработать 5-терабайтный пакет всего за несколько часов.
> There's nothing sweeter than seeing all the cores you're paying for on AWS being used. Thanks to gnu-parallel I can unzip and split a 19gig csv just as fast as I can download it. I couldn't even get spark to run this. [#DataScience](https://twitter.com/hashtag/DataScience?src=hash&ref_src=twsrc%5Etfw) [#Linux](https://twitter.com/hashtag/Linux?src=hash&ref_src=twsrc%5Etfw) [pic.twitter.com/Nqyba2zqEk](https://t.co/Nqyba2zqEk)
>
> — Nick Strayer (@NicholasStrayer) [May 17, 2019](https://twitter.com/NicholasStrayer/status/1129416944233226240?ref_src=twsrc%5Etfw)
В этом твите должно было упоминаться ‘TSV’. Увы.
Использование заново отпарсенных данных
---------------------------------------
**Чему я научился**: Spark любит несжатые данные и не любит комбинировать партиции.
Теперь данные лежали в S3 в незапакованном (читай, разделяемом) и полуупорядоченном формате, и я мог снова вернуться к Spark’у. Меня ждал сюрприз: мне опять не удалось добиться желаемого! Было очень сложно точно сказать Spark’у, как партиционированы данные. И даже когда я это сделал, оказалось, что партиций слишком много (95 тыс.), и когда я с помощью `coalesce` уменьшил их количество до разумных пределов, это порушило моё партиционирование. Уверен, это можно исправить, но за пару дней поисков мне не удалось найти решение. В конце концов я доделал все задачи в Spark, хотя это заняло какое-то время, а мои разделённые Parquet-файлы были не очень маленькими (~200 Кб). Однако данные лежали там, где нужно.
*Слишком маленькие и неодинаковые, чудесно!*
Тестирование локальных Spark-запросов
-------------------------------------
**Чему я научился**: в Spark слишком много накладных расходов при решении простых задач.
Загрузив данные в продуманном формате, я смог протестировать скорость. Настроил скрипт на R для запуска локального Spark-сервера, а потом загрузил фрейм данных Spark из указанного хранилища Parquet-групп (bin). Я пытался загрузить все данные, но не смог заставить Sparklyr распознать партиционирование.
```
sc <- Spark_connect(master = "local")
desired_snp <- 'rs34771739'
# Start a timer
start_time <- Sys.time()
# Load the desired bin into Spark
intensity_data <- sc %>%
Spark_read_Parquet(
name = 'intensity_data',
path = get_snp_location(desired_snp),
memory = FALSE )
# Subset bin to snp and then collect to local
test_subset <- intensity_data %>%
filter(SNP_Name == desired_snp) %>%
collect()
print(Sys.time() - start_time)
```
Исполнение заняло 29,415 секунды. Гораздо лучше, но не слишком хорошо для массового тестирования чего-либо. Кроме того, я не мог ускорить работу с помощью кэширования, потому что когда я пытался кэшировать в памяти фрейм данных, Spark всегда падал, даже когда я выделил больше 50 Гб памяти для датасета, который весил меньше 15.
Возвращение к AWK
-----------------
**Чему я научился**: ассоциативные массивы в AWK очень эффективны.
Я понимал, что могу добиться более высокой скорости. Мне вспомнилось, что в замечательном [руководстве по AWK Брюса Барнетта](http://www.grymoire.com/Unix/Awk.html) я читал о клёвой фиче, которая называется «[ассоциативные массивы](http://www.grymoire.com/Unix/Awk.html#uh-22)». По сути, это пары ключ-значение, которые почему-то в AWK назвали иначе, и поэтому я как-то о них и не вспоминал особо. [Роман Чепляка](https://ro-che.info/) напомнил, что термин «ассоциативные массивы» гораздо старше термина «пара ключ-значение». Даже если вы [поищете ключ-значение в Google Ngram](https://books.google.com/ngrams/graph?content=key-value+store%2Cassociative+array&year_start=1800&year_end=2000&corpus=15&smoothing=3&share=&direct_url=t1%3B%2Cassociative%20array%3B%2Cc0#t1%3B%2Cassociative%20array%3B%2Cc0), этот термин вы там не увидите, зато найдёте ассоциативные массивы! К тому же «пара ключ-значение» чаще всего ассоциируется базами данных, поэтому гораздо логичнее сравнивать с hashmap. Я понял, что могу использовать эти ассоциативные массивы для связи моих SNP с таблицей групп (bin table) и сырыми данными без применения Spark.
Для этого в AWK-скрипте я использовал блок `BEGIN`. Это фрагмент кода, который исполняется до того, как первая строка данных будет передана в основное тело скрипта.
```
join_data.awk
BEGIN {
FS=",";
batch_num=substr(chunk,7,1);
chunk_id=substr(chunk,15,2);
while(getline < "snp_to_bin.csv") {bin[$1] = $2}
}
{
print $0 > "chunked/chr_"chr"_bin_"bin[$1]"_"batch_num"_"chunk_id".csv"
}
```
Команда `while(getline...)` загрузила все строки из CSV группы (bin), задала первую колонку (название SNP) в качестве ключа для ассоциативного массива `bin` и второе значение (группа) в качестве значения. Затем в блоке `{` `}`, который исполняется применительно ко всем строкам основного файла, каждая строка отправляется в выходной файл, получающий уникальное имя в зависимости от его группы (bin): `..._bin_"bin[$1]"_...`.
Переменные `batch_num` и `chunk_id` соответствовали данным, предоставленным конвейером, что позволило избежать состояния гонки, и каждый поток исполнения, запущенный `parallel`, писал в собственный уникальный файл.
Поскольку все сырые данные я раскидал по папкам по хромосомам, оставшимся после моего предыдущего эксперимента с AWK, теперь я мог написать другой Bash-скрипт, чтобы обрабатывать по хромосоме за раз и отдавать в S3 глубже партиционированные данные.
```
DESIRED_CHR='13'
# Download chromosome data from s3 and split into bins
aws s3 ls $DATA_LOC |
awk '{print $4}' |
grep 'chr'$DESIRED_CHR'.csv' |
parallel "echo 'reading {}'; aws s3 cp "$DATA_LOC"{} - | awk -v chr=\""$DESIRED_CHR"\" -v chunk=\"{}\" -f split_on_chr_bin.awk"
# Combine all the parallel process chunks to single files and upload to rds using R
ls chunked/ |
cut -d '_' -f 4 |
sort -u |
parallel "echo 'zipping bin {}'; cat chunked/*_bin_{}_*.csv | ./upload_as_rds.R '$S3_DEST'/chr_'$DESIRED_CHR'_bin_{}.rds"
rm chunked/*
```
В скрипте два раздела `parallel`.
В первом разделе считываются данные из всех файлов, содержащих информацию по нужной хромосоме, затем эти данные распределяются по потокам, которые раскидывают файлы по соответствующим группам (bin). Чтобы не возникало состояния гонки, когда несколько потоков записывают в один файл, AWK передаёт имена файлов для записи данных в разные места, например, `chr_10_bin_52_batch_2_aa.csv`. В результате на диске создаётся множество маленьких файлов (для этого я использовал терабайтные EBS-тома).
Конвейер из второго раздела `parallel` проходит по группам (bin) и объединяет их отдельные файлы в общие CSV c `cat`, а затем отправляет их на экспорт.
Транслирование в R?
-------------------
**Чему я научился**: можно обращаться к `stdin` и `stdout` из R-скрипта, а значит и использовать его в конвейере.
В Bash-скрипте вы могли заметить такую строку: `...cat chunked/*_bin_{}_*.csv | ./upload_as_rds.R...`. Она транслирует все конкатенированные файлы группы (bin) в нижеприведённый R-скрипт. `{}` является специальной методикой `parallel`, которая любые отправляемые ею в указанный поток данные вставляет в прямо в саму команду. Опция `{#}` предоставляет уникальный ID потока исполнения, а `{%}` представляет собой номер слота задания (повторяется, но никогда одновременно). Список всех опций можно найти в [документации.](https://www.gnu.org/software/parallel/parallel_tutorial.html#Replacement-strings)
```
#!/usr/bin/env Rscript
library(readr)
library(aws.s3)
# Read first command line argument
data_destination <- commandArgs(trailingOnly = TRUE)[1]
data_cols <- list(SNP_Name = 'c', ...)
s3saveRDS(
read_csv(
file("stdin"),
col_names = names(data_cols),
col_types = data_cols
),
object = data_destination
)
```
Когда переменная `file("stdin")` передаётся в `readr::read_csv`, данные, транслированные в R-скрипт, загружаются во фрейм, который потом в виде `.rds`-файла с помощью `aws.s3` записывается прямо в S3.
RDS — это что-то вроде младшей версии Parquet, без изысков колоночного хранилища.
После завершения Bash-скрипта я получил пачку `.rds`-файлов, лежащих в S3, что дало позволило мне использовать эффективное сжатие и встроенные типы.
Несмотря на использование тормозного R, всё работало очень быстро. Неудивительно, что фрагменты на R, отвечающие за чтение и запись данных, хорошо оптимизированы. После тестирования на одной хромосоме среднего размера, задание выполнилось на инстансе C5n.4xl примерно за два часа.
Ограничения S3
--------------
**Чему я научился**: благодаря умной реализации путей S3 может обрабатывать много файлов.
Я беспокоился, сможет ли S3 обработать множество переданных ей файлов. Я мог сделать имена файлов осмысленными, но как S3 будет по ним искать?
*Папки в S3 всего лишь для красоты, на самом деле систему не интересует символ `/`. [С FAQ-страницы S3.](https://aws.amazon.com/s3/faqs/)*
Похоже, S3 представляет путь до конкретного файла в виде простого ключа в своеобразной хеш-таблице или базе данных на основе документов. Бакет (bucket) можно считать таблицей, а файлы — записями в этой таблице.
Поскольку скорость и эффективность важны для получения прибыли в Amazon, неудивительно, что эта система «ключ-в-качестве-пути-к-файлу» офигенно оптимизирована. Я пытался найти баланс: чтобы не нужно было делать множество get-запросов, но чтобы при этом запросы выполнялись быстро. Оказалось, что лучше всего делать около 20 тыс. bin-файлов. Думаю, если продолжить оптимизировать, то можно добиться повышения скорости (например, делать специальный бакет только для данных, таким образом уменьшая размер поисковой таблицы). Но на дальнейшие эксперименты уже не было времени и денег.
Что насчёт перекрёстной совместимости?
--------------------------------------
Чему я научился: главная причина потери времени — преждевременная оптимизация вашего метода хранения.
В этот момент очень важно спросить себя: «Зачем использовать проприетарный формат файлов?» Причина кроется в скорости загрузки (запакованные gzip CSV-файлы грузились в 7 раз дольше) и совместимости с нашими рабочими процессами. Я могу пересмотреть своё решение, если R сможет легко загружать файлы Parquet (или Arrow) без нагрузки в виде Spark. У нас в лаборатории все используют R, и если мне понадобится преобразовать данные в другой формат, то у меня всё ещё остаются исходные текстовые данные, поэтому я могу просто снова запустить конвейер.
Разделение работы
-----------------
**Чему я научился**: не пытайтесь оптимизировать задания вручную, пусть это делает компьютер.
Я отладил рабочий процесс на одной хромосоме, теперь нужно обработать все остальные данные.
Хотелось поднять несколько инстансов EC2 для преобразования, но в то же время я опасался получить крайне несбалансированную нагрузку в разных заданиях на обработку (так же, как Spark страдал от несбалансированных партиций). Кроме того, мне не улыбалось поднимать по одному инстансу на каждую хромосому, потому что для AWS-аккаунтов есть ограничение по умолчанию в 10 инстансов.
Тогда я решил написать на R скрипт для оптимизации заданий на обработку.
Сначала попросил S3 вычислить, сколько места в хранилище занимает каждая хромосома.
```
library(aws.s3)
library(tidyverse)
chr_sizes <- get_bucket_df(
bucket = '...', prefix = '...', max = Inf
) %>%
mutate(Size = as.numeric(Size)) %>%
filter(Size != 0) %>%
mutate(
# Extract chromosome from the file name
chr = str_extract(Key, 'chr.{1,4}\\.csv') %>%
str_remove_all('chr|\\.csv')
) %>%
group_by(chr) %>%
summarise(total_size = sum(Size)/1e+9) # Divide to get value in GB
# A tibble: 27 x 2
chr total_size
1 0 163.
2 1 967.
3 10 541.
4 11 611.
5 12 542.
6 13 364.
7 14 375.
8 15 372.
9 16 434.
10 17 443.
# … with 17 more rows
```
Затем я написал функцию, которая берёт общий размер, перемешивает порядок хромосом, делит их на группы `num_jobs` и сообщает, насколько различаются размеры всех заданий на обработку.
```
num_jobs <- 7
# How big would each job be if perfectly split?
job_size <- sum(chr_sizes$total_size)/7
shuffle_job <- function(i){
chr_sizes %>%
sample_frac() %>%
mutate(
cum_size = cumsum(total_size),
job_num = ceiling(cum_size/job_size)
) %>%
group_by(job_num) %>%
summarise(
job_chrs = paste(chr, collapse = ','),
total_job_size = sum(total_size)
) %>%
mutate(sd = sd(total_job_size)) %>%
nest(-sd)
}
shuffle_job(1)
# A tibble: 1 x 2
sd data
1 153.
```
Потом я прогнал с помощью purrr тысячу перемешиваний и выбрал лучшее.
```
1:1000 %>%
map_df(shuffle_job) %>%
filter(sd == min(sd)) %>%
pull(data) %>%
pluck(1)
```
Так я получил набор заданий, очень похожих по размеру. Затем оставалось только обернуть мой предыдущий Bash-скрипт в большой цикл `for`. На написание этой оптимизации ушло около 10 минут. И это куда меньше, чем я потратил бы на ручное создание заданий в случае с их несбалансированностью. Поэтому считаю, что с этой предварительной оптимизацией я не прогадал.
```
for DESIRED_CHR in "16" "9" "7" "21" "MT"
do
# Code for processing a single chromosome
fi
```
В конце добавляю команду выключения:
```
sudo shutdown -h now
```
… и всё получилось! С помощью AWS CLI я поднимал инстансы и через опцию `user_data` передавал им Bash-скрипты их заданий на обработку. Они исполнялись и автоматически выключались, так что я не платил за излишнюю вычислительную мощность.
```
aws ec2 run-instances ...\
--tag-specifications "ResourceType=instance,Tags=[{Key=Name,Value=<>}]" \
--user-data file://<>
```
Упаковываем!
============
**Чему я научился**: API должен быть простым ради простоты и гибкости использования.
Наконец-то я получил данные в нужном месте и виде. Оставалось максимально упростить процесс использования данных, чтобы моим коллегам было легче. Я хотел сделать простой API для создания запросов. Если в будущем я решу перейти с `.rds` на Parquet-файлы, то это должно быть проблемой для меня, а не для коллег. Для этого я решил сделать внутренний R-пакет.
Собрал и задокументировал очень простой пакет, содержащий всего несколько функций для доступа к данным, собранных вокруг функции `get_snp`. Также я сделал для коллег сайт [pkgdown](https://pkgdown.r-lib.org/), чтобы они могли легко посмотреть примеры и документацию.
Интеллектуальное кэширование
----------------------------
**Чему я научился**: если ваши данные хорошо подготовлены, кэшировать будет просто!
Поскольку один из основных рабочих процессов применял к пакету SNP одну и ту же модель анализа, я решил использовать группирование (binning) в своих интересах. При передаче данных по SNP, к возвращаемому объекту прикрепляется и вся информация из группы (bin). То есть старые запросы могут (в теории) ускорять обработку новых запросов.
```
# Part of get_snp()
...
# Test if our current snp data has the desired snp.
already_have_snp <- desired_snp %in% prev_snp_results$snps_in_bin
if(!already_have_snp){
# Grab info on the bin of the desired snp
snp_results <- get_snp_bin(desired_snp)
# Download the snp's bin data
snp_results$bin_data <- aws.s3::s3readRDS(object = snp_results$data_loc)
} else {
# The previous snp data contained the right bin so just use it
snp_results <- prev_snp_results
}
...
```
При сборке пакета я прогнал много бенчмарков, чтобы сравнить скорость при использовании разных методов. Рекомендую этим не пренебрегать, потому что иногда результаты бывают неожиданными. Например, `dplyr::filter` оказался гораздо быстрее захвата строк с помощью фильтрации на основе индексирования, а получение одной колонки из отфильтрованного фрейма данных работало гораздо быстрее, чем применение синтаксиса индексирования.
Обратите внимание, что объект `prev_snp_results` содержит ключ `snps_in_bin`. Это массив всех уникальных SNP в группе (bin), позволяющий быстро проверять, есть ли уже данные из предыдущего запроса. Также он упрощает циклический проход по всем SNP в группе (bin) с помощью этого кода:
```
# Get bin-mates
snps_in_bin <- my_snp_results$snps_in_bin
for(current_snp in snps_in_bin){
my_snp_results <- get_snp(current_snp, my_snp_results)
# Do something with results
}
```
Результаты
==========
Теперь мы можем (и начали всерьёз) прогонять модели и сценарии, ранее нам недоступные. Самое лучшее, что моим коллегам по лаборатории не приходится думать о всяких сложностях. У них просто есть работающая функция.
И хотя пакет избавляет их от подробностей, я пытался сделать формат данных достаточно простым, чтобы в нём могли разобраться, если завтра я вдруг исчезну…
Скорость заметно выросла. Обычно мы сканируем функционально значимые фрагменты генома. Раньше мы не могли это делать (получалось слишком дорого), но теперь, благодаря групповой (bin) структуре и кэшированию, на запрос одного SNP уходит в среднем меньше 0,1 секунды, а использование данных такое низкое, что расходы на получаются S3 копеечные.
> Recently I got put in change of wrangling 25+ TB of raw genotyping data for my lab. When I started, using spark took 8 min & cost $20 to query a SNP. After using AWK + [#rstats](https://twitter.com/hashtag/rstats?src=hash&ref_src=twsrc%5Etfw) to process, it now takes less than a 10th of a second and costs $0.00001. My personal [#BigData](https://twitter.com/hashtag/BigData?src=hash&ref_src=twsrc%5Etfw) win. [pic.twitter.com/ANOXVGrmkk](https://t.co/ANOXVGrmkk)
>
> — Nick Strayer (@NicholasStrayer) [May 30, 2019](https://twitter.com/NicholasStrayer/status/1134151057385369600?ref_src=twsrc%5Etfw)
Заключение
----------
Эта статья — совсем не руководство. Решение получилось индивидуальное, и почти наверняка не оптимальное. Скорее, это рассказ о путешествии. Хочу, чтобы другие поняли, что подобные решения не возникают в голове полностью сформированными, это результат проб и ошибок. Кроме того, если вы ищете специалиста по анализу данных, то учитывайте, что для эффективного использования этих инструментов нужен опыт, а опыт требует денег. Я счастлив, что у меня были средства на оплату, но у многих других, кто может сделать ту же работу лучше меня, никогда не будет такой возможности из-за отсутствия денег даже на попытку.
Инструменты для больших данных универсальны. Если у вас есть время, то почти наверняка сможете написать более быстрое решение, применив «умную» очистку данных, хранилище и методики извлечения. В конечном счете все сводится к анализу расходов и выгод.
### Чему я научился:
* не существует дешёвого способа отпарсить 25 Тб за раз;
* будьте осторожны с размером ваших Parquet-файлов и их организацией;
* партиции в Spark должны быть сбалансированы;
* вообще никогда не пытайтесь делать 2,5 миллиона партиций;
* сортировать всё ещё трудно, как и настраивать Spark;
* иногда особые данные требуют особых решений;
* объединение в Spark работает быстро, но партиционирование всё ещё обходится дорого;
* не спите, когда вам преподают основы, наверняка кто-то уже решил вашу проблему ещё в 1980-х;
* `gnu parallel` — это волшебная вещь, все должны её использовать;
* Spark любит несжатые данные и не любит комбинировать партиции;
* в Spark слишком много накладных расходов при решении простых задач;
* ассоциативные массивы в AWK очень эффективны;
* можно обращаться к `stdin` и `stdout` из R-скрипта, а значит и использовать его в конвейере;
* благодаря умной реализации путей S3 может обрабатывать много файлов;
* главная причина потери времени — преждевременная оптимизация вашего метода хранения;
* не пытайтесь оптимизировать задания вручную, пусть это делает компьютер;
* API должен быть простым ради простоты и гибкости использования;
* если ваши данные хорошо подготовлены, кэшировать будет просто! | https://habr.com/ru/post/456392/ | null | ru | null |
# Иерархия исключений в современном PHP-приложении
Задача публикации: доступно изложить способ организации иерархии исключений и их обработки в приложении. Без привязки к фреймворкам и конкретной архитектуре. Описываемый способ является де-факто стандартом в сообществе: он используется во многих серьёзных библиотеках и фреймворках. В том числе Zend, Symfony. Не смотря на его логичность и универсальность, формального описания предлагаемого подхода на русском языке я не нашёл. После неоднократного устного изложения концепции коллегам, родилась мысль оформить её в виде публикации на Хабрахабр.
В языке PHP, начиная с 5-ой версии, доступен механизм исключений. В актуальной, 7-ой, версии этот механизм был улучшен и переработан с целью единнобразной обработки разных ошибок при помощи конструкции `try{} catch...`
В стандартной библиотеке (SPL) PHP предоставляет готовый набор базовых классов и интерфейсов для исключений. В 7-ой версии этот набор был расширен интерфейсом `Throwable`. Вот диаграмма всех имеющихся в версии 7 типов (изображение — ссылка):
[](https://habrastorage.org/web/b8e/00e/4f8/b8e00e4f8d1240e1bed53e63ab6cf023.png)
Для junior-разработчиков, может быть полезным предварительно уяснить все тонкости синтаксиса, логики работы исключений и обработки ошибок в целом. Могу порекоммендовать следующие статьи на русском языке:
* Евгений Пястолов: [Стандартные исключения в PHP. Когда какое применить.](http://langtoday.com/?p=354)
* Антон Шевчук (старожил Хабра a.k.a. [AntonShevchuk](https://habrahabr.ru/users/antonshevchuk/)) (перевод [Exceptional Code – PART 1](https://devzone.zend.com/268/exceptional-code_part-1/)): [“Исключительный” код – Часть 1](http://anton.shevchuk.name/php/exceptional-code-part-1/)
* @kotiara:
+ [Правильная обработка ошибок в PHP](https://habrahabr.ru/post/99431/)
+ [Правильная работа с исключениями в PHP](https://habrahabr.ru/post/100137/)
* @expolit: [Исключения. Где я их использую](https://habrahabr.ru/post/58702/)
Основные аспекты иерархии исключений вашего приложения.
-------------------------------------------------------
### Общий интерфейс
Используйте общий интерфейс (маркер) для всех исключений определяемых в вашем приложении. Это же правило применимо и к отдельным компонентам, модулям, пакетам, т.е. подпространствам имён вашего кода. Например `\YourVendor\YourApp\Exception\ExceptionInterface`, либо `\YourVendor\YourApp\SomeComponent\Exception\ExceptionInterface`, в соответствии с PSR-4.
[Пример](https://github.com/zendframework/zend-authentication/blob/master/src/Exception/ExceptionInterface.php) можно посмотреть в любом компоненте Symfony, Zend, etc.
### Для каждой ситуации — свой тип
Каждая новая исключительная ситуация должна приводить к созданию нового типа (класса) исключения. Имя класса должно семантично описывать эту ситуацию. Таким образом код с вызовом конструктора исключения, и его броском, будет: читаем, самодокументирован, прозрачен.
Симметрично и код с отловом исключения, будет явным. Код внутри `catch` не должен пытаться определить ситуацию по сообщению или другим косвенным признакам.
### Расширяйте базовые типы
Базовые типы служат для наследования от них собственных типов исключений вашего приложения. Об этом прямо сказано в [документации](http://php.net/manual/en/class.exception.php).
[Пример](https://github.com/symfony/symfony/blob/master/src/Symfony/Component/Asset/Exception/InvalidArgumentException.php) можно посмотреть в любом компоненте Symfony, либо Zend.
### Проброс и преобразование в соответствии с уровнем абстракции
Поскольку исключения всплывают по всему стеку вызовов, в приложении может быть несколько мест где они отлавливаются, пропускаются, или преобразуются. В качестве простого примера: стандартное PDOException логично поймать в слое DAL, либо в ORM, и пробросить дальше вместо него собственный `DataBaseException`, который в свою очередь уже ловить в слое выше, например, контроллере, где преобразовать в HttpException. Последний может быть перехвачен в коде диспетчера, на самом верхнем уровне.
Таким образом, контроллер не знает о существовании PDO — он работает с абстрактным хранилищем.
Решение, что должно быть проброшено, что преобразовано, а что обработано, в каждом случае лежит на программисте.
### Используете возможности стандартного конструктора
Не стоит переопределять стандартный конструктор `Exception` — он идеально спроектирован для своих задач. Просто не забывайте его использовать по назначению и вызывать родительский со всеми аргументами, если всё же потребовалась перегрузка. Суммируя этот пункт с предыдущим, код может выглядеть примерно так:
```
namespace Samizdam\HabrahabrExceptionsTutorial\DAL;
class SomeRepository
{
public function save(Model $model)
{
// .....
try {
$this->connection->query($data);
} catch (\PDOException $e) {
throw new DataBaseException(\i18n('Error on sql query execution: ' . $e->getMessage(), $e->getCode()), $e);
}
}
}
// .....
namespace Samizdam\HabrahabrExceptionsTutorial\SomeModule\Controller;
use Samizdam\HabrahabrExceptionsTutorial\Http\Exception;
class SomeController
{
public function saveAction()
{
// .....
try {
$this->repository->save($model);
} catch (DataBaseException $e) {
throw new HttpException(\i18n('Database error. '), HttpException::INTERNAL_SERVER_ERROR, $e);
}
}
}
// .....
namespace Samizdam\HabrahabrExceptionsTutorial\Http;
class Dispatcher
{
public function processRequest()
{
// .....
try {
$controller->{$action}();
} catch (HttpException $e) {
// упрощенно для примера
http_response_code($e->getCode());
echo $e->getMessage();
}
}
}
```
Резюме
------
Зачем построение целой иерархии, с участием интерфейсов, типов, подтипов и весь этот полиморфизм ради обработки ошибок? Каков смысл этой абстракции и чем оправдана её цена?
При проектировании приложения, абстракция — это то, что добавляет гибкости, и позволяет откладывать конкретные решения и детальную реализацию, пока не известны все нюансы, а требования к коду ещё не известны, либо могут поменяться. Это инвестиция, которая окупается со временем.
Когда ваши исключения обладают одновременно интерфейсом-маркером, супертипом SPL (как RuntimeException), конкретным типом соответствующим ситуации, вы можете полностью контролировать их обработку и гибко менять её стратегию в будущем. Закладывая на раннем этапе разработки эти абстракции, в будущем, по мере появления и ужесточения требований к обработке ошибок, вы будете иметь в распоряжении инструмент, который поможет эти требования реализовать.
На этапе прототипа достаточно показать надпись "опаньки", для этого достаточно поймать любой Throwable в index.php.
В альфа версии будет не лишним отличать ситуации 401, 404 и 500.
В бета-тестировании, вы вероятно захотите выводить трейсы всех предыдущих исключений для формирования баг-репортов.
К началу экплуатации вам понадобится единая точка для логирования исключительных ситуаций.
И всё время развития приложения вы будете всего лишь, по мере надобности, добавлять код с логикой обработки, **без необходимости внесения изменений в основной код**, где исключения генерируются. | https://habr.com/ru/post/329140/ | null | ru | null |
# Программирование под N900 на Python
Среди топиков на Хабре я нашел лишь руководство по программированию на Python для платформы S60. Являясь счастливым обладателем N900 и фанатом Python я решил это исправить.
##### Вступление
В данной статье предполагается знание синтаксиса языка Python, а также основной семантики. Для написания приложения под Maemo 5 необходимы следующие инструменты:
* OpenSSH server на N900
* IDE PluThon
* Пакеты PyQt4 и PyMaemo для N900
* Wi-Fi точка доступа
###### OpenSSH
Устанавливаем OpenSSH-server из репозитория Extras-Devel. В процессе установки нужно будет ввести логин и пароль: логин должен быть root,
пароль устанавливаем по своему усмотрению (я бы не советовал использовать кирилицу в пароле).
###### PluThon
Всем известно, что Maemo содержит интерпретатор Python «из коробки». Простенький скрипт можно написать на самом устройстве. Но, согласитесь, гораздо удобнее программировать в IDE с подчеркиванием синтаксиса, отладкой и прочими плюшками. Одним из лучших вариантов является использование IDE PluThon: она основана на Eclipse и позволяет разрабатывать приложение на компьютере, а затем передает его по SSH на N900 и выполняет там. Для установки PluThon нужно скачать два архива с [pluthon.garage.maemo.org/2nd\_edition/installation.html](http://pluthon.garage.maemo.org/2nd_edition/installation.html) для своей ОС.
После скачивания распаковываем оба архива в одну и ту же папку и запускаем:
* ./pluthon.sh (Linux)
* .\pluthon.exe (Windows)
* ./pluthon.app/Contents/MacOS/esbox (MacOS X)
Примечание: если вы используете Ubuntu 9.10+, Fedora 11 или другую систему, основанную на GTK+ 2.18, то возможны проблемы с запуском PluThon: запустится только пустое окно, которое будет невозможно закрыть. Для устранения этого найдите файл pluthon.ini в каталоге pluton'a и добавьте в конец файла строку:
***-Dorg.eclipse.swt.browser.XULRunnerPath=/dev/null***
Теперь PluThon готов к работе!
###### PyMaemo + PyQt4
Из коробки Python поставляется только со стандартными модулями, поэтому необходимо установить дополнительные библиотеки. Также для создания графического интерфейса необходимо установить библиотеку Qt для Python. Для этого выполяем следующие операции в терминале N900 (rootsh должен быть установлен):
**sudo gainroot
apt-get install python2.5-runtime
apt-get install python2.5-qt4-core python2.5-qt4-gui**
Соглашаемся на предложение установить и ждем конца установки. Теперь все готово для разработки!
##### Разработка
Как и полагается по старой доброй традиции первое наше приложение будет называться Hello World. Для этого запускаем OpenSSH сервер на N900:
**sudo gainroot
/etc/init.d/ssh start**
Далее запускаем PluThon и создаем новый проект (меню File -> Pluthon Project -> Empty Python Project), далее жмем Next и выбираем способ удаленного подключения к N900. Способ подключения: WLAN ad-hoc, также не поленитесь зайти в настройки. Здесь необходимо правильно указать IP-адрес девайса (его можно узнать командой ifconfig из-под рута), а также имя пользователя(root) для работы в системе. Во избежание проблем с правами доступа я обычно отлаживаю программы под рутом, хотя это и может быть небезопасно. Далее нажимаем кнопку Next и в появившемся окне можно выбрать версию Python. Лучше всего оставить 2.5, для лучшей совместимости с N900 (интерпретатор Python там версии 2.5.4. Далее нажатием на кнопку Finish мы создаем проект. В папку src добавляем новый модуль: ПКМ -> New -> Pydev Module. Указываем любое имя и нажимаем Finish.
> `*#Первым делом импортируем модули:*
>
> **import** **sys** *#Модуль будет использоваться для получения аргументов командной строки, которые необходимы Qt-приложению*
>
> **from** **PyQt4.QtCore** **import** \* *#Стандартные Qt-библиотеки ядра и графического интерфейса*
>
> **from** **PyQt4.QtGui** **import** \*
>
>
>
> *#Далее необходимо инициализировать окно нашего приложения. Делается это способом создания дочернего класса к QMainWindow.*
>
>
>
> **class** **MainWindow**(QMainWindow):
>
> **def** \_\_init\_\_(self, \*args):
>
> apply(QMainWindow.__init__, (self,) + args) *#Вызываем конструктор родительского класса с полученными аргументами*
>
> self.setWindowTitle('N900 Buttons!') *#Заголовок приложения*
>
> self.bn1=QPushButton("Hello World", self) *#Создаем кнопку с надписью 'Hello world' и в качестве*
>
> *#родительского виджета (окно в понятии Qt) указываем экземпляр класса (окно)*
>
> self.bn1.setFlat(1) *#Наша кнопка будет плоской*
>
> self.setCentralWidget(self.bn1) *#Указываем что кнопка является центральным виджетом приложения,*
>
> *#то есть она растянется на все окно*
>
> self.bn1.clicked.connect(exit) *#Указываем что должна делать при нажатии -*
>
> *#в данном случае выходить из приложения*
>
>
>
> *#После того, как окно инициализированно, остается лишь создать экземпляр приложения и экземпляр окна*
>
>
>
> app=QApplication(sys.argv) *#Создаем экземпляр приложения*
>
> win=MainWindow() *#И окно*
>
> win.show() *#Отображаем его на экране*
>
> sys.exit(app.exec_()) *#И собственно запускаем приложение*`
Теперь запускаем приложение Run -> Run As -> PluThon Application. Теперь глядим в наш N900 и там должно появиться чтото примерно такое:
На данную кнопку можно нажать, после чего приложение завершится. Не забудьте выключить SSH сервер после работы:
**root
/etc/init.d/ssh stop** | https://habr.com/ru/post/111370/ | null | ru | null |
# Установка и настройка CA Infrastructure Management. Часть первая. Performance Management
 В последнее время на хабре стали всё чаще и чаще попадаться статьи, связанные с мониторингом.
Описаны такие продукты как MS SCOM, IBM Tivoli, продукты от HP, Zabbix и даже The Dude, но почему-то я не смог найти ни одного описания (да и упоминаний почти нет) продуктов мониторинга от компании CA.
Что ж не так давно ко мне в руки попало одно из их решений для мониторинга инфраструктуры, предназначенное в первую очередь для телекома и крупных организаций *CA Infrastructure Management*.
1. Состав решения.
------------------
*Infrastructure Management* — состоит из следующих продуктов:
*CA Performance Management* — является главной точкой входа в систему и отвечает за мониторинг производительности инфраструктуры.
*CA Spectrum* — отвечает за мониторинг доступности, контроль конфигураций оборудования, реакцию системы на события, оповещение операторов и интеграцию с системами Service desk.
*CA Network Flow Analysis* — отвечает за контроль сетевого трафика проходящего через маршрутизаторы.
Также опционально в систему могут интегрироваться следующие продукты:
*CA Virtual Assurance for IM* — предназначенный для мониторинга виртуальной инфраструктуры.
*CA Unified Communications Monitor* — занимающийся мониторингом голосовой и видео телефонии.
*CA Application Delivery Analysis* и *CA Application Performance Management* — отвечающие за мониторинг приложений.
*Performance Management* построен на базе двух модулей, а именно: *CA Performance Center* и *CA Data Aggregator*.
*Performance Center* — веб-портал, являющийся «зонтиком» для непосредственно продуктов мониторинга, и отвечает за их интеграцию в единую систему, а также он
является единой точкой входа в систему мониторинга.
*Data Aggregator* — отвечает за обнаружение оборудования, добавление этого оборудования в контур мониторинга, опрос состояния и производительности оборудования по протоколу
SNMP, а также долговременное хранение этих данных.
*CA Data Aggregator* состоит из трёх компонентов:
*Data Collector* — отвечает за опрос оборудования и передачу этих данных в Data Aggregator.
*Data Aggregator* — отвечает за управление Data Collector, агрегирование получаемых данных, передачу полученных данных в Data Repository для хранения и предоставление запрашиваемых данных в Performance Center.
*Data Repository* — отвечает за долговременное хранение данных.
2. Установка.
-------------
Установка *Performance Management* должна происходить в следующем порядке:
1. Data Repository
2. Data Aggregator
3. Data Collector
4. Performance Center
Архитектура стенда будет выглядеть следующим образом:
В качестве ОС будет использоваться Red Hat Linux Enterprise 6.4-x86\_x64 (в качестве альтернативы можно использовать CentOS).
Устанавливаться будет Performance Management версии 2.3.4.
**Установка Data Repository**1. В требованиях к аппаратному обеспечению вендор рекомендует отказаться от использования Logical Volume Manager, и использовать Standard Partition.
2. Установить статический IP-адрес на сервере.
3. Указать в файле /etc/hosts имена и адреса всех серверов системы.
```
10.161.80.150 DA
10.161.80.151 DR
10.161.80.152 PC
10.161.80.153 DC
```
4. Конфигурируем iptables для открытия следующих портов:
* Port 22 (TCP protocol)
* Port 4033 (TCP and UDP protocol)
* Port 4803 (TCP and UDP protocol)
* Port 4804 (UDP protocol)
* Port 4805 (UDP protocol)
* Port 5444 (TCP protocol)
* Port 5450 (TCP protocol)
* Port 5433 (TCP protocol)Или же отключаем iptables:
```
service iptables stop
chkconfig iptables off
```
5. Переносим файл installDR.bin из архива с дистрибутивом Data Aggregator (GEN06092429M.tar.gz) на сервер в директорию /tmp/DR/
6. Выставляем права на выполнение
```
chmod u+x ./installDR.bin
```
7. Запускаем распаковку дистрибутива
```
./installDR.bin
```
8. В процессе распаковки выбираем язык, соглашаемся с лицензионным соглашением и указываем путь для распаковки (по умолчанию
/opt/CA/IMDataRepository\_vertica7).
9. Переходим в папку куда мы распаковали дистрибутив и редактируем файл /opt/CA/IMDataRepository\_vertica7/drinstall.properties
```
# Linux user created to serve as the database administrator
DbAdminLinuxUser=dradmin
# Home directory for database administrator Linux user
# Make sure the parent directory of the home directory exists
# before running dr_install.sh
DbAdminLinuxUserHome=/export/dradmin
# Location of Vertica's data directory
DbDataDir=/data
# Location of Vertica's catalog directory
DbCatalogDir=/catalog
# Comma-delimited list of hostnames for the Data Repository
# === Do NOT place any spaces in the list of host names ===
DbHostNames=DR
# Database name
DbName=drdata
# Database password
DbPwd=dbpass
```
10. В соответствии с настройками создаём необходимые каталоги:
```
mkdir /export
mkdir /data
mkdir /catalog
```
11. Создаём пользователя и указываем домашнюю папку в соответствии с конфигурационным файлом drinstall.properties
```
useradd dradmin -d /export/dradmin
passwd dradmin
```
12. После чего можем запускать скрипт преднастройки системы:
```
./dr_validate.sh -p ./drinstall.properties
```
13. Перезагружаем сервер.
14. Ещё раз запускам скрипт преднастройки и проверяем все ли пункты отработали.
15. В случае если что-то не отработало изменяем эти параметры вручную, после чего повторяем предыдущий пункт.
16. Далее запускаем скрипт установки
```
./dr_install.sh -p ./drinstall.properties
```
17. После чего проверяем корректность установки:
```
su – dradmin
/opt/vertica/bin/adminTools
```
В появившемся окне выбираем пункт View Database Cluster State смотрим состояние базы данных и если всё в порядке переходим к следующему серверу.
**Установка Data Aggregator**1. Устанавливаем статический IP-адрес на сервере.
2. Указываем в файле /etc/hosts имена и адреса всех серверов системы.
```
10.161.80.150 DA
10.161.80.151 DR
10.161.80.152 PC
10.161.80.153 DC
```
3. Конфигурируем iptables для открытия следующих портов:
* Port 22 (TCP protocol)
* Port 8581 (TCP and UDP protocol)
* Port 61616 (TCP and UDP protocol)
Или же отключаем iptables:
```
service iptables stop
chkconfig iptables off
```
4. Дописываем в файл /etc/security/limits.conf следующие строки:
```
# Added by Data Aggregator
* soft nofile 65536
# Added by Data Aggregator
* hard nofile 65536
```
5. Переносим файл installDA.bin из архива с дистрибутивом Data Aggregator (GEN06092429M.tar.gz) на сервер в директорию /tmp/DA/
6. Выставляем права на выполнение
```
chmod a+x ./installDA.bin
```
7. Запускаем установку дистрибутива
```
./installDA.bin –i console
```
8. В процессе распаковки выбираем язык, соглашаемся с лицензионным соглашением и указываем путь для распаковки (по умолчанию /opt/IMDataAggregator).
9. Указываем максимальное кол-во памяти, которое сможет использовать Data Aggregator (Минимум 2G).
10. Указываем максимальное кол-во памяти, которое сможет использовать ActiveMQ (Минимум 500M).
11. Указываем IP-адрес сервера Data Repository (На моём стенде 10.161.80.151).
12. Указываем порт для связи с Data Repository (по умолчанию 5433).
13. Указываем имя базы данных Data Repository (его мы указывали в файле drinstall.properties, в моём случае drdata).
14. Задаём имя пользователя и пароль для соединения с базой (я использую dauser и dapass).
15. Указываем имя пользователя и пароль администратора базы (их мы указывали в файле drinstall.properties, в моём случае dradmin и dbpass).
16. Указываем порт который будет использоваться для REST-запросов к серверу Data Aggregator (по умолчанию 8581).
17. Указываем порт который будет использоваться для SSH отладки ActiveMQ (по умолчанию 8501).
18. Проверяем корректность установки через web-браузер [Data\_AggregatorIP](http://Data_AggregatorIP):port/rest/ (в моём случае [10.161.80.150](http://10.161.80.150):8581/rest/, если что-то не работает # service activemq status)
**Установка Data Collector**1. Устанавливаем статический IP-адрес на сервере.
2. Указываем в файле /etc/hosts имена и адреса всех серверов системы.
```
10.161.80.150 DA
10.161.80.151 DR
10.161.80.152 PC
10.161.80.153 DC
```
3. Скачиваем дистрибутив Data Collector
```
wget http://Data_AggregatorIP:port/dcm/InstData/Linux/VM/install.bin
```
(в моём случае [10.161.80.150](http://10.161.80.150):8581/dcm/InstData/Linux/VM/install.bin)
4. Выставляем права на выполнение
```
chmod a+x ./install.bin
```
5. Запускаем установку дистрибутива
```
./install.bin –i console
```
6. В процессе распаковки выбираем язык, соглашаемся с лицензионным соглашением и указываем путь для распаковки (по умолчанию /opt/IMDataCollector).
7. Указываем максимальное кол-во памяти, которое сможет использовать Data Collector (минимум 1G).
8. Указываем IP-адрес сервера Data Aggregator (на моём стенде 10.161.80.150).
**Установка Performance Center**1. Устанавливаем статический IP-адрес на сервере.
2. Указываем в файле /etc/hosts имена и адреса всех серверов системы.
```
10.161.80.150 DA
10.161.80.151 DR
10.161.80.152 PC
10.161.80.153 DC
```
3. Конфигурируем iptables для открытия следующих портов:
* Port 22 (TCP protocol)
* Port 80 (TCP protocol)
* Port 3306(TCP protocol)
* Port 8181 (TCP protocol)
* Port 8281 (TCP protocol)
* Port 8381 (TCP protocol)
* Port 8481 (TCP protocol)
* Port 8581 (TCP protocol)
* Port 8681 (TCP protocol)
Или же отключаем iptables:
```
service iptables stop
[root@PC ~]# chkconfig iptables off
```
4. Включаем службу времени
```
chkconfig ntpd on
[root@PC ~]# service ntpd start
```
5. Дописываем в файл /etc/security/limits.conf следующие строки:
```
# Added by Data Aggregator
* soft nofile 65536
# Added by Data Aggregator
* hard nofile 65536
```
И вводим команду
```
ulimit -n 65536
```
6. Переносим файл CAPerfCenterSetup.bin из архива с дистрибутивом Performance Center(GEN06092502M.tar.gz) на сервер в директорию /tmp/PC/
7. Выставляем права на выполнение
```
chmod +x ./CAPerfCenterSetup.bin
```
8. Запускаем установку дистрибутива
```
./ CAPerfCenterSetup.bin –i console
```
9. В процессе распаковки выбираем язык, соглашаемся с лицензионным соглашением и указываем путь для распаковки (по умолчанию /opt/CA).
10. Указываем максимальное кол-во памяти, которое сможет использовать Console (минимум 1312M).
11. Указываем максимальное кол-во памяти, которое сможет использовать Device Manager (минимум 1312M).
12. Указываем максимальное кол-во памяти, которое сможет использовать Event Manager (минимум 1968M).
13. Указываем путь для установки MySQL (по умолчанию /opt/CA/MySql/data).
3. Первый запуск.
-----------------
После установки проверяем работоспособность всей системы.
1. В веб-браузере переходим на сервер с установленным Performance Center (10.161.80.152:8181).
2. Проходим авторизацию (Login: admin; Password: admin).
3. Переходим к управлению источниками данных (Admin-> Data Sources).
4. И добавляем наш Data Aggregator в качестве источника данных.
5. После чего переходим в настройки Data Aggregator и проверим наличие Data Collector.
6. После проверки Data Collector пробуем создать новый SNMP-профиль обнаружения.
(Admin -> SNMP Profiles).
7. И новый профиль обнаружения (Admin -> Data Aggregator -> Monitored Inventory -> Discovery Profile).
8. После завершения обнаружения переходим в Inventory -> Devices, и проверяем список обнаруженных устройств.
Заключение.
-----------
К сожалению сам по себе *Performance Management* хоть и является ключевым модулем *Infrastructure Management* не предоставляет всех необходимых данных необходимых для мониторинга сетевой инфраструктуры, для этого в систему необходимо включить CA Spectrum и CA Network Flow Analysis. Чем я и планирую заняться в следующей части статьи.
А пока-что информация о состоянии Маршрутизаторов и Серверов:
 | https://habr.com/ru/post/246021/ | null | ru | null |
# Пишем бота-кликера на Python для Lineage 2
### Предисловие
Как можно развлечься в новогодние праздники? Поиграть в компьютерные игры? Нет! Лучше написать бота, который это будет делать за тебя, а самому пойти лепить снеговика и пить глинтвейн.
Когда-то в школьные годы был увлечен одной из популярных MMORPG — Lineage 2. В игре можно объединяться в кланы, группы, заводить друзей и сражаться с соперниками, но в общем игра наполнена однообразными действиями: выполнением квестов и фармом (сбор ресурсов, получение опыта).
В итоге решил, что бот должен решать одну задачу: фарм. Для управления будут использоваться эмулированные клики мыши и нажатия клавиш клавиатуры, а для ориентирования в пространстве — компьютерное зрение, язык программирования — Python.
Вообще, создание бота для L2 дело не новое и их готовых есть довольно много. Делятся они на 2 основные группы: те, которые внедряются в работу клиента и кликеры.
Первые — это жёсткий чит, в плане игры пользоваться ими слишком уж неспортивно. Второй вариант интереснее, учитывая, что его можно будет с некоторыми доработками применить к любой другой игре, да и реализация будет интереснее. Те кликеры, которых я находил, по разным причинам не работали, либо работали нестабильно.
**Внимание: вся информация здесь изложена только в познавательных целях. Особенно для разработчиков игр, чтобы помочь им лучше бороться с ботами.**
Итак, к делу.
### Работа с окном
Тут все просто. Будем работать со скриншотами из окна с игрой.
Для этого определим координаты окна. С окном работаем с помощью модуля win32gui. Нужное окно определим по заголовку — “Lineage 2”.
**Код методов получения положения окна**
```
def get_window_info():
# set window info
window_info = {}
win32gui.EnumWindows(set_window_coordinates, window_info)
return window_info
# EnumWindows handler
# sets L2 window coordinates
def set_window_coordinates(hwnd, window_info):
if win32gui.IsWindowVisible(hwnd):
if WINDOW_SUBSTRING in win32gui.GetWindowText(hwnd):
rect = win32gui.GetWindowRect(hwnd)
x = rect[0]
y = rect[1]
w = rect[2] - x
h = rect[3] - y
window_info['x'] = x
window_info['y'] = y
window_info['width'] = w
window_info['height'] = h
window_info['name'] = win32gui.GetWindowText(hwnd)
win32gui.SetForegroundWindow(hwnd)
```
Получаем картинку нужного окна с помощью ImageGrab:
```
def get_screen(x1, y1, x2, y2):
box = (x1 + 8, y1 + 30, x2 - 8, y2)
screen = ImageGrab.grab(box)
img = array(screen.getdata(), dtype=uint8).reshape((screen.size[1], screen.size[0], 3))
return img
```
Теперь будем работать с содержимым.
### Поиск монстра
Самое интересное. Те реализации, которые я находил, мне не подошли. Например, в одном из популярных и даже платном это сделано через игровой макрос. И “игрок” должен для каждого типа монстра прописывать в макросе типа “/target Monster Name Bla Bla”.
В нашем случае мы последуем такой логике: в первую очередь найдём все тексты белого цвета на экране. Белый текст может быть не только названием монстра, но и именем самого персонажа, именем NPC или других игроков. Поэтому надо навести курсор на объект и если появится подсветка с нужным нам паттерном, то можно атаковать цель.
Вот исходная картинка, с который будем работать:
Закрасим черным своё имя, чтобы не мешало и переведем картинку в ч/б. Исходная картинка в RGB — каждый пиксель это массив из трёх значений от 0 до 255, когда ч/б — это одно значение. Так мы значительно уменьшим объем данных:
```
img[210:230, 350:440] = (0, 0, 0)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
```
Найдем все объекты белого цвета (это белый текст с названиями монстров)
```
ret, threshold1 = cv2.threshold(gray, 252, 255, cv2.THRESH_BINARY)
```
Морфологические преобразования:
1. Фильтровать будем по прямоугольнику размером 50x5. Такой прямоугольник подошел лучше всех.
2. Убираем шум внутри прямоугольников с текстом (по сути закрашиваем всё между букв белым)
3. Еще раз убираем шум, размывая и растягивая с применением фильтра
```
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (50, 5))
closed = cv2.morphologyEx(threshold1, cv2.MORPH_CLOSE, kernel)
closed = cv2.erode(closed, kernel, iterations=1)
closed = cv2.dilate(closed, kernel, iterations=1)
```
Находим середины получившихся пятен
```
(_, centers, hierarchy) = cv2.findContours(closed, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
```
Работает, но можно сделать прикольнее (например, для монстров, имена которых не видны, т.к. находятся далеко) — с помощью TensorFlow Object Detection, как [тут](https://www.youtube.com/watch?v=VRsmPvu0xj0), но когда-нибудь в следующей жизни.
Теперь наводим курсор на найденного монстра и смотрим, появилась ли подсветка с помощью метода cv2.matchTemplate. Осталось нажать ЛКМ и кнопку атаки.
### Клик
С поиском монстра разобрались, бот уже может найти цели на экране и навести на них мышь. Чтобы атаковать цель, нужно кликнуть левой кнопкой мыши и нажать «атаковать» (на кнопку «1» можно забиндить атаку). Клик правой кнопкой мыши нужен для того, чтобы вращать камеру.
На сервере, где я тестировал бота, я вызвал клик через AutoIt, но он почему-то не сработал.
Как оказалось, игры защищаются от автокликеров разными способами:
* поиск процессов, которые эмулируют клики
* запись кликов и определение, какого цвета объект, на который кликает бот
* определение паттернов кликов
* определение бота по периодичности кликов
А некоторые приложения, как клиент этого сервера, могут определять источник клика на уровне ОС. (будет здорово, если кто-нибудь подскажет как именно).
Были перепробованы некоторые фреймворки, которые могут кликать (в т.ч. pyautogui, robot framework и что-то еще), но ни один из вариантов не сработал. Проскользнула мысль соорудить устройство, которое будет нажимать кнопку (кто-то даже так делал). Похоже, что нужен клик максимально хардварный. В итоге стал смотреть в сторону написания своего драйвера.
На просторах интернета был найден способ решения проблемы: usb-устройство, которое можно запрограммировать на подачу нужного сигнала — Digispark.
Ждать несколько недель с Алиэкспресса не хочется, поэтому поиски продолжились.
В итоге была найдена [замечательная библиотека на C](https://github.com/oblitum/Interception)
Нашлась для неё и [обёртка на Python](https://github.com/dc740/AutoHotPy)
Библиотека у меня не завелась на питоне 3.6 — вываливалась ошибка Access violation что-то там. Поэтому пришлось соскочить на питон 2.7, там всё заработало like a charm.
### Движение курсора
Библиотека может посылать любые команды, в том числе, куда переместить мышь. Но выглядит это как телепортация курсора. Нужно сделать движение курсора плавным, чтобы нас не забанили.
По сути задача сводится к тому, чтобы перемещать курсор из точки A в точку B с помощью обертки AutoHotPy. Неужели придется вспоминать математику?
Немного поразмыслив, всё-таки решил погуглить. Оказалось, что ничего придумывать не надо — задачу решает алгоритм Брезенхэма, один из старейших алгоритмов в компьютерной графике:
Прямо с Википедии можно взять и [реализацию](https://ru.wikibooks.org/wiki/%D0%A0%D0%B5%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B8_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%BE%D0%B2/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%91%D1%80%D0%B5%D0%B7%D0%B5%D0%BD%D1%85%D1%8D%D0%BC%D0%B0)
### Логика работы
Все инструменты есть, осталось самое простое — написать сценарий.
1. Если монстр жив, продолжаем атаковать
2. Если нет цели, найти цель и начать атаковать
3. Если не удалось найти цель, немного повернемся
4. Если 5 раз никого не удалось найти — идём в сторону и начинаем заново
Из более-менее интересного опишу, как я получал статус здоровья жертвы. В общих чертах: находим по паттерну с помощью OpenCV элемент управления, показывающий статус здоровья цели, берём полоску высотой в один пиксель и считаем в процентах, сколько закрашено красным.
**Код метода получения уровня здоровья жертвы**
```
def get_targeted_hp(self):
"""
return victim's hp
or -1 if there is no target
"""
hp_color = [214, 24, 65]
target_widget_coordinates = {}
filled_red_pixels = 1
img = get_screen(
self.window_info["x"],
self.window_info["y"],
self.window_info["x"] + self.window_info["width"],
self.window_info["y"] + self.window_info["height"] - 190
)
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
template = cv2.imread('img/target_bar.png', 0)
# w, h = template.shape[::-1]
res = cv2.matchTemplate(img_gray, template, cv2.TM_CCOEFF_NORMED)
threshold = 0.8
loc = np.where(res >= threshold)
if count_nonzero(loc) == 2:
for pt in zip(*loc[::-1]):
target_widget_coordinates = {"x": pt[0], "y": pt[1]}
# cv2.rectangle(img, pt, (pt[0] + w, pt[1] + h), (255, 255, 255), 2)
if not target_widget_coordinates:
return -1
pil_image_hp = get_screen(
self.window_info["x"] + target_widget_coordinates['x'] + 15,
self.window_info["y"] + target_widget_coordinates['y'] + 31,
self.window_info["x"] + target_widget_coordinates['x'] + 164,
self.window_info["y"] + target_widget_coordinates['y'] + 62
)
pixels = pil_image_hp[0].tolist()
for pixel in pixels:
if pixel == hp_color:
filled_red_pixels += 1
percent = 100 * filled_red_pixels / 150
return percent
```
Теперь бот понимает, сколько HP у жертвы и жива ли она еще.
Основная логика готова, вот как теперь он выглядит в действии:
Для занятых я ускорил на [1.30](https://www.youtube.com/watch?v=vlV1oMwDLpQ&t=130)
### Остановка работы
Вся работа с курсором и клавиатурой ведется через объект autohotpy, работу которого в любой момент можно остановить нажатием кнопки ESC.
Проблема в том, что всё время бот занят выполнением цикла, отвечающим за логику действий персонажа и обработчики событий объекта и autohotpy не начинают слушать события, пока цикл не закончится. Работу программы не остановить и с помощью мыши, т.к. бот управляет ей и уводит курсор куда ему нужно.
Нам это не подходит, поэтому пришлось разделить бота на 2 потока: слушание событий и выполнение логики действий персонажа.
Создадим 2 потока
```
# init bot stop event
self.bot_thread_stop_event = threading.Event()
# init threads
self.auto_py_thread = threading.Thread(target=self.start_auto_py, args=(auto_py,))
self.bot_thread = threading.Thread(target=self.start_bot, args=(auto_py, self.bot_thread_stop_event, character_class))
# start threads
self.auto_py_thread.start()
self.bot_thread.start()
```
и теперь вешаем обработчик на ESC:
```
auto_py.registerExit(auto_py.ESC, self.stop_bot_event_handler)
```
при нажатии ESC устанавливаем событие
```
self.bot_thread_stop_event.set()
```
и в цикле логики персонажа проверяем, установлено ли событие:
```
while not stop_event.is_set():
```
Теперь спокойно останавливаем бота по кнопке ESC.
### Заключение
Казалось бы, зачем тратить время на продукт, который не приносит никакой практической пользы?
На самом деле компьютерная игра с точки зрения компьютерного зрения — почти то же самое, что и снятая на камеру реальность, а там возможности для применения огромны. Отличный пример описан в статье про подводных роботов, которые [лазером стреляют по лососям](https://geektimes.ru/post/287572/). Также статья может помочь разработчикам игр в борьбе с ботоводами.
Ну а я ознакомился с Python, прикоснулся к компьютерному зрению, написал свой первый слабоумный искусственный интеллект и получил массу удовольствия.
Надеюсь, было интересно и вам.
P.S. Ссылка на [репозиторий](https://github.com/maaaxim/bot) | https://habr.com/ru/post/346258/ | null | ru | null |
# Автоматизация загрузки изображений для товаров в интернет-каталогах
Занимаясь разработкой интернет-каталогов (или же интернет-магазинов) столкнулись с проблемой подбора картинок для товара. Не каждый заказчик может позволить внедрить в свои процессы фотографирование каждого товара (особенно когда их более 7000), да и есть ли смысл фотографировать товары когда их изображения уже есть в интернете, причем абсолютно легально на сайтах производителей. Вручную скачивать-заливать изображения — не вариант. За время работы испробовали массу способов «автоматизации» данного процесса:
* Выгрузка товаров из 1С и синхронизация картинок
* Загрузка картинок «оптом» через FTP
* Поиск картинок средствами Google API
#### Выгрузка товаров из 1С и синхронизация картинок
Ситуация: магазин торгует секонд-хенд и стоковой одеждой. Проблема заключается в том, что фотографий нет или найти их очень проблематично. Одежда приходит в баулах и в магазине даже не знают, что в них находится (покупают на развес).
Девушка-товаровед занимается приемкой, в базу 1С заносит данные о товаре. Эту вещь кладут на столик с белым фоном, над которым закреплена обычная цифровая фотокамера. Далее девушка нажимает специально обученную кнопочку в 1С, по нажатию на нее запускается внешнее приложение, которое фотографирует товар и сохраняет картинку в папку, называя файл по артикулу.
*Профит: фотка хранится и в 1С, продавцам удобно ориентироваться в товаре. Например, приходит покупатель с сайта и говорит что хочет товар такого-то артикула или названия, все забивается в поиск 1С и помимо сухого описания выдается и изображение. Теперь девушка знает товар в лицо и с легкостью может найти его в море других вещей. Секонд-хенд же...*
Вернемся к делу. Папка на локальном компьютере синхронизируется с сервером, на котором размещен сайт. Далее на сервере картинки ресайзятся до нужных размеров и сохраняются в нужным местах. Отдельная песня про то, как ресайзить 7000 картинок на обычном хостинге, поверьте это реально.
В итоге, получаем довольно высокую автоматизацию всего процесса, которая требует минимального участия человека. Ну и естественно все проводки, покупки, продажи в онлайне синхронизируются с 1С, раз начали с ней заигрывать.
#### Загрузка картинок «оптом» через FTP
Тут все проще, ситуация такая: у заказчика есть фирменные изображения, заливать в ручную через веб-интерфейс просто не реально, их очень много, этих картинок, на каждый товар есть более 5-6 дополнительных изображений. Не бойтесь, как правило производители товара предоставляют его изображения, именуя файлы уже по артикулу.
Картинки просто заливаются на FTP, а сайт знает где их искать. Все просто и понятно.
#### Поиск картинок средствами Google API
Теперь самое интересное, как нам кажется. Ситуация следующая: магазин, который торгует офлайн известными брендами (Grohe, Tarkett и прочее интерьерно-отделочный стафф) решил сделать для начала интернет-каталог своих товаров. Как вы понимаете, изображения там играют решающую роль. В магазине несколько тысяч наименований (около 15000) и синхронизировать сайт с базой продукции пока не предоставляется возможным. На занесение товара будет выделено несколько специально обученных обезьянок. И понятно, что человек часть изображений будет искать в интернете, сохранять их, загружать и т.д. Очень долго.
Мы нашли простой и изящный способ загрузки изображений. Google предоставляет свой [Google Search AJAX API](http://code.google.com/intl/ru-RU/apis/ajaxsearch/), грех им не воспользоваться. В техническую реализацию вдаваться нет смысла — там все просто.
В описание товара обязательно входит бренд и артикул, специфика данной продукции (строительный стафф) такова, что есть такое понятие как «Коллекция» — набор товаров. И после добавления этих данных отправляется запрос в API Google, а он возвращает JSON-массив с информацией о найденных изображениях. Изображения показываются «вбивателю» и он выбирает подходящую картинку для загрузки и приведения ее в необходимый формат. В 90% случаев картинки удовлетворяют потребности.
Все довольны…
Давайте не будем дискутировать на тему правомерности использования данных изображений, пусть выбор останется на совести «вбивателя», так как он выбирает источник загрузки и визуально может определить фирменная это картинка или нет. Также следует отметить, что продавец — официальный представитель этих брендов в нашем городе и он имеет право использовать изображения с сайтов производителей.
Ссылки на сайты давать не будем, боимся хабраэффекта, и пиар данных ресурсов тут неуместен. Кому интересно — стучитесь в личку.
**UPD**
В связи с большим количеством вопросов в ПМ выкладываю пример (наши разработки сделаны на ZendFramework, этот код всего лишь для примера)
Если вам не нужен AJAX, тогда все проще простого.
<http://ajax.googleapis.com/ajax/services/search/images?v=1.0&q=Филлипинский%20долгопят>
Существуют и дополнительные параметры фильтрации изображений.
PHP выполняет запрос и API возвращает вам объект в формате JSON:
> `$query = 'Филлипинский долгопят';
>
> $body = file\_get\_contents('http://ajax.googleapis.com/ajax/services/search/images?v=1.0 &q='.urlencode($query));
>
> $json = json\_decode($body);
>
> foreach ($json->responseData->results as $result) {
>
> echo ''" title="' . $result->contentNoFormatting . '"/>';
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В массиве result находится много полезной информации. Список самых нужных ключей массива:
* imageId – уникальный идентификатор картинки
* url – экранированный url картинки
* width, height – размеры картинки
* tbWidth, tbHeight – размеры превью
* tbUrl – ссылка на превью картинки
* title – описание картинки
Поиск по новостям, блогам и т.д. работает так же, но возвращает другие ключи массива.
Если вам все-таки нужен поиск с AJAX, то на эту тему уже есть [хорошие статьи](http://anton.shevchuk.name/javascript/jquery-and-google-search-api-or-yahoo-search-api-yahoo-search-api/) | https://habr.com/ru/post/91162/ | null | ru | null |
# «Продам гараж»: фронт и реклама в hh.ru
Если ваш публичный проект может похвастаться внушительной аудиторией, вашими пользователями точно заинтересуются рекламные системы. Бизнес рано или поздно это замечает и закономерно пытается извлечь некоторые профиты.
По стечению обстоятельств большую часть времени я занимался разработкой интерфейсов для рекламных сервисов в hh.ru. В этой статье вы не найдете описания каких-то прорывных технологий, данный материал скорее о том, как построить взаимодействие с подрядчиками (в контексте внутренней рекламной системы) и не посыпаться кукушечкой.
Как всё устроено
----------------
Итак, заказчик приходит к команде и произносит заветное слово "баннеры". Тимлид ищет время в своем календаре для очередной встречи, и начинают формироваться требования.
Баннер в web можно охарактеризовать как "независимый блок верстки рекламного характера", что звучит довольно размыто. Проще говоря, в блок может "прилететь" что угодно, и надо быть к этому готовым. Конечно, вы можете формализовать сущность баннера до состояния **url/image/description**. Мы так и сделали, но практика показала, что этого мало, поэтому в крутилке появился тип баннера **iframe**.
Sounds like a planПока backend-разработчик думал как держать большой RPS, frontend занимался внедрением новой логики в web-приложение. Время шло, WoW изменился до неузнаваемости, а реклама выделилась в отдельную команду Технического департамента. Так со временем мы пришли к следующей **архитектуре**:
Страница приложения представляет собой совокупность экранов для разных вьюпортов. В случае hh возможно наличие до 4-х экранов (условно обозначим экраны как **xs/s/m/l**). Брейкпоинты нас сейчас не интересуют, важен только факт наличия [сетки](https://developer.mozilla.org/ru/docs/Learn/CSS/CSS_layout/Grids) на CSS.
Главная hh.ruВ свою очередь, баннеры на разных экранах (на одной странице) могут быть разные, так как заказчик хочет детализировать трафик. Причем детализировать трафик нужно еще и в контексте пользовательской роли (очередное требование заказчика).
Изначально баннеры просто описали в шаблонах, но позже мы пошли в сторону декларативности, чтобы поддержка логики не причиняла боль и страдания. В итоге каждое баннерное место на экране получило свой уникальный идентификатор. В теории по неймингу можно понять, где находится место. К примеру, serp\_first\_l указывает на поисковую выдачу на L экране (serp - search engine result page).
Каждому месту был поставлен в соответствие идентификатор баннера, по которому и приходит статика из баннерной системы. Вся вышеописанная логика была спрятана в препроцессор страницы и снабжена конфигом.
```
banners.add(
pages=['vacancy_search_result'],
banner_ids={
BannerPlaces.SERP_FIRST_L: [1],
BannerPlaces.SERP_FIRST_M: [2],
BannerPlaces.SERP_FIRST_S: [3],
BannerPlaces.SERP_FIRST_XS: [4],
BannerPlaces.SERP_SECOND_L: [5],
BannerPlaces.SERP_SECOND_M: [6],
BannerPlaces.SERP_SECOND_S: [7],
BannerPlaces.SERP_SECOND_XS: [8],
},
)
```
Причем, конфиг — это единственное место, в котором указаны id баннеров, в коде мы оперируем только идентификаторами мест (пример выше, serp\_first\_l). Данная условность необходима, чтобы при смене id баннера не тратить время на разбор кода, а легким движением руки обновить конфигурацию.
В результате механизм работает следующим образом: пользователь заходит на страницу, препроцессор обрабатывает конфиг и пушит в global store баннерный setup, а на основе setup-а идем в баннерную систему и отрисовываем на клиенте ответ.
Как вы могли заметить, интерфейсная сетка на CSS. То есть ноды с баннерами для всех четырех экранов страницы будут находится в dom дереве сразу, что искажает статистику просмотров. А это уже проблема. Нужно явным образом учитывать видимость баннерного места и запрашивать баннер только в случае, если пользователь видит нужную ноду.
Проблема решается достаточно просто: подписываемся на ресайз окна и проверяем размеры нужного элемента (как вариант, callback можно задебаунсить, чтобы не срабатывал слишком часто). Если размеры элемента не нулевые, вызываем callback, в котором идем AJAX-ом за статикой баннера.
```
const visibilityWatcher = ({ element, onVisible }) => {
let visible = false;
const checkVisible = () => {
if (visible) {
return;
}
visible =
element.offsetWidth ||
element.offsetHeight ||
element.getClientRects().length;
if (visible) {
onVisible();
window.removeEventListener('resize', checkVisible);
element.dataset.listenersSetted = 'false';
}
};
if (element.dataset.listenersSetted !== 'true') {
window.addEventListener('resize', checkVisible);
element.dataset.listenersSetted = 'true';
}
checkVisible();
};
```
Вследствие внедрения данного кода появилась небольшая задержка в отрисовке рекламы (так как javascript рассчитывает видимость). И да, внимательный читатель заметит недостаток: происходит только расчет размеров элемента, но вообще пользователь может так и не доскролить до объявления.
Как уже упоминалось выше, верстка баннеров была отдана на аутсорс, либо клиенты сами могут присылать готовые баннеры. В связи с чем по соображениям безопасности вся статика из баннерки добавляется на hh.ru в iframe фиксированных размеров и предварительно проходит модерацию у отдела размещения.
Вышеописанная реализация работала достаточно долго и новых требований не поступало. Однако появлялись новые инструменты и заказчик пушил изменения.
Google Ad Manager
-----------------
Чтобы был понятен контекст, [Ad Manager](https://admanager.google.com/) — весьма развитый и распространенный инструмент для продажи трафика. Описывать преимущества площадки Google перед самописной системой, я думаю, бессмысленно (система аукционов, отчеты и т.д.). После пилотного проекта DFP (устаревшее название Ad Manager) показал себя неплохо, и было решено развивать данное направление силами команды рекламы.
Особых проблем подключения [GPT](https://developers.google.com/publisher-tag/reference) не было (GPT или Google Publisher Tags — javascript библиотека для работы с Ad Manager). Конфиг баннеров немного расширили и в него добавили новый параметр, так называемый ad unit (или рекламный блок).
Из интересного, в старой баннерной системе уже был настроен [водопад](https://oko.uk/blog/ad-waterfalls-explained) и переносить в DFP его хотели постепенно, а откладывать запуск в наши планы не входило. Решение было найдено достаточно быстро, в GPT реализовано событие отрисовки статики и среди параметров был [признак](https://developers.google.com/publisher-tag/reference#googletag.events.SlotRenderEndedEvent_isEmpty) того, что слот не заполнен. А если слот не заполнен, нужно просто сходить в старую "крутилку".
Результаты внедрения Ad Manager были впечатляющие: выручка с программатик-рекламы на целевой странице увеличилась почти на 20%. Внедрение DFP было самым большим обновлением view слоя hh.ru с точки зрения рекламы за последние несколько лет. Далее на очереди пара интересных случаев из практики сопровождения.
Где мой CPU, Chrome?!
---------------------
Все началось с обращения в техническую поддержку. Исходя из туманного описания было понятно, что у пользователя сайт работает непозволительно медленно. Более того, воспроизвести проблему если и удавалось, то в несвязанных местах и в случайных клиентах. Даже [har](https://en.wikipedia.org/wiki/HAR_(file_format)) файл не помог…
Однако позже стало понятно, объединяет проблемные места только одно обстоятельство — наличие рекламы. Проблема была в коде одной из внешних площадок. Javascript съедал весь CPU в силу отсутствия оптимизации. Код проблемных баннеров снесли, а разработчикам отправили репорт с проблемой.
Ждать очередного обращения мы не собирались, и во избежание дальнейших проблем с производительностью на свет появился [observer](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver). Длительные макро задачи отслеживались, а события отправлялись в нашу аналитику. На основании событий был собран график в [okmeter](https://okmeter.io/) и настроены alerts, если такие проблемы и возникают, на них реагируют быстрее.
Блокировщик, что ты делаешь, ахаха, прекрати
--------------------------------------------
Те же, там же: всё началось с пользовательской жалобы. Соискатель не мог отправить отклик на вакансию. На этот раз ситуацию прояснил архив har. Блокировщик рекламы (опустим его название) внедрял свой код и блокировал pop-up на странице, а отклик как раз работал через всплывающее окно.
Вообще, если вы разрабатываете админку для рекламной системы (к примеру), данный кейс не самый редкий, так как верстка вашего клиента условному adblock не понравится. Однако этот случай выделяется тем, что блокировщик реагировал на слово pop-up. Просить пользователей что-то отключать на клиенте — дело гиблое, поэтому проще было поправить свой клиент.
Так ли мешает реклама?
----------------------
Отношение к баннерному шуму у большинства пользователей скорее негативное (те же блокировщики появились не просто так). В свое время были проведены эксперименты с отключением рекламы на разных страницах. Несмотря на увеличение скорости рендера основного контента, метрики оставались серыми, изменения значений оставались в рамках погрешности.
Итог
----
На текущий момент основным инструментом продажи трафика является GAM (Google Ad Manager), внутренняя баннерная система используется для нестандартных продуктов, причем за март на нашу крутилку пришлось около полутора миллиардов запросов. Реклама прочно обосновалась в основном прайсе, за месяц отдел размещения обрабатывает порядка 300 обращений от клиентов. А это значит, что баннеры никуда не денутся и работа у команды рекламы будет всегда. | https://habr.com/ru/post/552288/ | null | ru | null |
# Работа с геозонами (geofences) в Android
Добрый день, хабровчане. Сегодня я хотел бы рассказать о [Location APIs](https://developer.android.com/google/play-services/location.html) в общем и о геозонах (geofences) в частности, которые были представлены на Google I/0 2013 ([видео](http://www.youtube.com/watch?v=Bte_GHuxUGc) и [презентация](http://commondatastorage.googleapis.com/io-2013/presentations/106 - Beyond the Blue Dot- New features in Android Location (1).pdf)). Не смотря на то, что событие произошло более полугода назад, на хабре до сих пор нет вменяемой информации об этом (только [одно упоминание](http://habrahabr.ru/post/191290/)). Постараюсь немного исправить ситуацию.
#### Что такое Location APIs?
Location APIs являются частью Google Play сервисов, которая предназначена для создания приложений работающих с местоположением устройства. В отличие от подобных функций в [LocationManager](http://developer.android.com/reference/android/location/LocationManager.html), данные API отличаются улучшенным энергосбережением. В данный момент доступна следующая функциональность: определение местоположения устройства, работа с геозонами и распознавание активности пользователя. Определение местоположения позволяет балансировать между точностью определения и потреблением энергии, а также предоставляет доступ к наиболее частым местоположениям. Распознавание активности позволяет узнать, что делает пользователь устройства: едет на машине, едет на велосипеде, идет пешком или находится на одном месте. Ну и, собственно, работа с геозонами позволяет посылать сообщения, когда пользователь устройства входит в конкретную зону, покидает её либо находится в зоне определенный период времени.
На мой взгляд [официальный пример](http://developer.android.com/shareables/training/GeofenceDetection.zip) довольно сложный и запутанный. Это связано с тем, что в нём:
* попытались показать все возможности Location APIs
* множество комментариев и обработок исключений, которые в примере можно было бы и упустить
* все действия выполняются из активити
Исходя из этого в данной статье я сфокусируюсь только на геозонах и опущу некоторые обработки исключений.
**Примечание**: Google Play сервисы могут быть отключены на устройстве. Это может нарушить работу многих приложений и система честно предупреждает пользователя об этом перед их отключением. Но всё же хорошим тоном будет проверять это в своем приложении с помощью [GooglePlayServicesUtil.isGooglePlayServicesAvailable](http://developer.android.com/reference/com/google/android/gms/common/GooglePlayServicesUtil.html#isGooglePlayServicesAvailable(android.content.Context)) и как-то предупреждать пользователя.
#### Задача
Итак, для примера напишем приложение, в котором можно явно указать координаты и радиус геозоны. При входе/выходе из неё в статус бар будет добавляться уведомление с id геозоны и типом перемещения. После выхода из геозоны мы её удалим.
**Исходники для нетерпеливых**[github](https://github.com/Ne4istb/AndroidGeofenceTest)
#### Алгоритм
В общем процесс выглядит следующим образом:
1. Из активити создаем сервис, в который передаем данные о геозоне.
2. Сервис инициализирует **LocationClient**.
3. Когда **LocationClient** инициализировался, добавляем в него геозоны (**Geofence**) и соответствующие им *PendingIntent*.
4. Когда геозоны добавлены, отключаемся от **LocationClient** и останавливаем сервис.
5. Далее вся надежда на *PendingIntent*, который запустит *IntentService* при входе в зону или выходе из зоны. Сервис добавляет уведомления в статус бар и создает сервис для удаления отработанных геозон.
6. Созданный сервис снова инициализирует **LocationClient**.
7. Когда **LocationClient** инициализировался, удаляем отработанные геозоны.
8. Когда геозоны удалены, отключаемся от **LocationClient** и останавливаем сервис.
9. Profit!
Как мы видим, главным действующим лицом является **LocationClient**. Он отвечает за доступ к API для определения местоположения и работы с геозонами.
#### К делу!
Для начала необходимо подключить Google Play сервисы. Как это сделать описано [здесь](http://developer.android.com/google/play-services/setup.html).
Далее в активити инициализируем элементы отображения. Из этой области нас интересует вызов сервиса при обработке нажатия на кнопку:
```
int transitionType = Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT;
MyGeofence myGeofence = new MyGeofence(mId, latitude, longitude, radius, transitionType);
Intent geofencingService = new Intent(activity, GeofencingService.class);
geofencingService.putExtra(GeofencingService.EXTRA_ACTION, GeofencingService.Action.ADD);
geofencingService.putExtra(GeofencingService.EXTRA_GEOFENCE, myGeofence);
activity.startService(geofencingService);
```
Тут мы создаем *Intent* для нашего сервиса (*GeofencingService*) и передаем в него необходимые данные. Так как *GeofencingService* отвечает за добавление и удаление геозон (в примере я решил не разделять эти действия на разные сервисы), то нам надо передать тип операции, которая должна быть выполнена сервисом. В данном случае это добавление (*GeofencingService.Action.ADD*). Также сервису нужны данные о геозоне. Их мы передаем в виде объекта класса MyGeofence, который по сути является оберткой над **Geofence.Builder** (о нём мы поговорим позже).
Итак, мы передаем координаты центра и радиус зоны, а также тип перемещения. Последний может быть трех видов: GEOFENCE\_TRANSITION\_ENTER, GEOFENCE\_TRANSITION\_EXIT и GEOFENCE\_TRANSITION\_DWELL. Если с первыми двумя все понятно, то к третьему необходимы разъяснения. GEOFENCE\_TRANSITION\_DWELL указывает на то, что пользователь вошел в зону и пробыл в ней некоторое время. Чтобы использовать этот сигнал, вы должны установить *setLoiteringDelay* при построении геозоны. В данном примере GEOFENCE\_TRANSITION\_DWELL не используется.
Перейдем к сервису. Сервис имплементирует **GooglePlayServicesClient.ConnectionCallbacks**, **GooglePlayServicesClient.OnConnectionFailedListener**, **LocationClient.OnAddGeofencesResultListener**, **LocationClient.OnRemoveGeofencesResultListener** интерфейсы. Это позволяет ему полностью отвечать за работу с **LocationClient**.
В *onStartCommand* мы получаем тип операции (ADD или REMOVE) и вытягиваем необходимые для выполнения этого действия данные. После этого инициализируем и запускаем **LocationClient**:
```
mAction = (Action) intent.getSerializableExtra(EXTRA_ACTION);
switch (mAction) {
case ADD:
MyGeofence newGeofence = (MyGeofence) intent.getSerializableExtra(EXTRA_GEOFENCE);
mGeofenceListsToAdd.add(newGeofence.toGeofence());
break;
case REMOVE:
mGeofenceListsToRemove = Arrays.asList(intent.getStringArrayExtra(EXTRA_REQUEST_IDS));
break;
}
mLocationClient = new LocationClient(this, this, this);
mLocationClient.connect();
```
Прежде чем добавить геозону *mGeofenceListsToAdd*, мы вызвали метод *toGeofence()* объекта класса *MyGeofence*. Я уже говорил, что *MyGeofence* является обёрткой над **Geofence.Builder**:
```
public MyGeofence(int id, double latitude, double longitude, float radius, int transitionType) {
this.id = id;
this.latitude = latitude;
this.longitude = longitude;
this.radius = radius;
this.transitionType = transitionType;
}
public Geofence toGeofence() {
return new Geofence.Builder()
.setRequestId(String.valueOf(id))
.setTransitionTypes(transitionType)
.setCircularRegion(latitude, longitude, radius)
.setExpirationDuration(ONE_MINUTE)
.build();
}
```
**Geofence.Builder** — это служебный класс для создания **Geofence**. Мы задаем необходимые параметры, а потом вызываем метод *build()* для создания объекта. Выше указан необходимый минимум параметров. Тут стоит обратить внимание на *setExpirationDuration*. Дело в том, что зарегистрированные геозоны могут быть удалены только в двух случаях: по истечении заданного времени или при явном удалении. Поэтому, если вы передаете в качестве параметра NEVER\_EXPIRE, то вы обязаны позаботиться об удалении объекта самостоятельно. Для **Location APIs** есть ограничение: максимум 100 геозон на одно приложение одновременно.
После того как **LocationClient** подключится, сработает *onConnected* колбэк интерфейса **GooglePlayServicesClient.ConnectionCallbacks**. В нем мы выполняем добавление либо удаление в зависимости от текущего типа действия:
```
@Override
public void onConnected(Bundle bundle) {
Log.d("GEO", "Location client connected");
switch (mAction) {
case ADD:
Log.d("GEO", "Location client adds geofence");
mLocationClient.addGeofences(mGeofenceListsToAdd, getPendingIntent(), this);
break;
case REMOVE:
Log.d("GEO", "Location client removes geofence");
mLocationClient.removeGeofences(mGeofenceListsToRemove, this);
break;
}
}
```
Как мы видим, **addGeofences** одним из параметров требует *PendingIntent*, который сработает при перемещении. В нашем случае *PendingIntent* будет запускать *IntentService*:
```
private PendingIntent getPendingIntent() {
Intent transitionService = new Intent(this, ReceiveTransitionsIntentService.class);
return PendingIntent.getService(this, 0, transitionService, PendingIntent.FLAG_UPDATE_CURRENT);
}
```
После выполнения действия у нас срабатывают **OnAddGeofencesResultListener** или **onRemoveGeofencesByRequestIdsResult** , в которых мы отключаемся от **LocationClient** и останавливаем сервис:
```
@Override
public void onAddGeofencesResult(int i, String[] strings) {
if (LocationStatusCodes.SUCCESS == i) {
Log.d("GEO", "Geofences added " + strings);
for (String geofenceId : strings)
Toast.makeText(this, "Geofences added: " + geofenceId, Toast.LENGTH_SHORT).show();
mLocationClient.disconnect();
stopSelf();
} else {
Log.e("GEO", "Error while adding geofence: " + strings);
}
}
@Override
public void onRemoveGeofencesByRequestIdsResult(int i, String[] strings) {
if (LocationStatusCodes.SUCCESS == i) {
Log.d("GEO", "Geofences removed" + strings);
mLocationClient.disconnect();
stopSelf();
} else {
Log.e("GEO", "Error while removing geofence: " + strings);
}
}
```
Последняя часть приложения – это *IntentService*, который запускается при пересечении границы геозоны пользователем устройства. Все действия выполняются в *onHandleIntent*:
```
@Override
protected void onHandleIntent(Intent intent) {
if (LocationClient.hasError(intent)) {
Log.e(TRANSITION_INTENT_SERVICE, "Location Services error: " + LocationClient.getErrorCode(intent));
return;
}
int transitionType = LocationClient.getGeofenceTransition(intent);
List triggeredGeofences = LocationClient.getTriggeringGeofences(intent);
List triggeredIds = new ArrayList();
for (Geofence geofence : triggeredGeofences) {
Log.d("GEO", "onHandle:" + geofence.getRequestId());
processGeofence(geofence, transitionType);
triggeredIds.add(geofence.getRequestId());
}
if (transitionType == Geofence.GEOFENCE\_TRANSITION\_EXIT)
removeGeofences(triggeredIds);
}
```
Здесь у нас фигурируют в основном статические методы **LocationClient**. Сначала мы делаем проверку на наличие ошибок с помощью *hasError*. Затем получаем тип перемещения и список сработавших геозон с помощью *getGeofenceTransition* и *getTriggeringGeofences* соответственно. Вызываем обработку каждой геозоны и сохраняем её id. Ну и напоследок, удаляем геозоны в случае, если данное перемещение было выходом из геозоны.
Для удаления геозон мы опять создаём сервис, в который передаём тип операции (REMOVE) и список id на удаление:
```
private void removeGeofences(List requestIds) {
Intent intent = new Intent(getApplicationContext(), GeofencingService.class);
String[] ids = new String[0];
intent.putExtra(GeofencingService.EXTRA\_REQUEST\_IDS, requestIds.toArray(ids));
intent.putExtra(GeofencingService.EXTRA\_ACTION, GeofencingService.Action.REMOVE);
startService(intent);
}
```
#### На этом всё!
Надеюсь пример получился понятным и интересным. Желаю всем хороших приложений!
**UPDATE:**
Статья и код сильно устарели за 2 года.
Спасибо [Vilkaman](https://habrahabr.ru/users/vilkaman/) за обновления кода в репозитории.
Подробнее о работе с обновленным Location API можно прочитать в его [статье](https://habrahabr.ru/post/282129/) | https://habr.com/ru/post/210162/ | null | ru | null |
# Проверяем исходный код Roslyn
Время от времени мы возвращаемся к проектам, которые уже проверяли ранее с помощью PVS-Studio и писали про это статьи. Делать это интересно по двум причинам. Во-первых, чтобы понять, насколько лучше стал наш анализатор. Во-вторых, чтобы отследить, обратили ли авторы проекта внимание на нашу статью, а также на отчет об ошибках, который мы им обычно предоставляем. Конечно, ошибки могут быть исправлены и без нашего участия. Но всегда приятно, когда именно наши усилия помогают сделать какой-то проект лучше. Не стал исключением и Roslyn. Предыдущая статья о проверке этого проекта датируется 23 декабря 2015 года. Это довольно давно, учитывая путь, который за это время проделал в своём развитии наш анализатор. Дополнительный интерес лично для нас Roslyn представляет ещё и тем, что на нём базируется ядро C# анализатора PVS-Studio. Таким образом, мы очень заинтересованы в качестве кода этого проекта. Устроим ему повторную проверку и выясним, что же нового и интересного (но будем надеяться, что ничего существенного) там сможет найти PVS-Studio.
Roslyn (или .NET Compiler Platform) наверняка знаком многим из наших читателей. Если кратко, то это набор компиляторов с открытым исходным кодом и API для анализа кода для языков C# и Visual Basic .NET от Microsoft. Исходный код проекта доступен на [GitHub](https://github.com/dotnet/roslyn).
Не буду приводить подробного описания этой платформы, а всем интересующимся рекомендую статью моего коллеги Сергея Васильева "[Введение в Roslyn. Использование для разработки инструментов статического анализа](https://www.viva64.com/ru/b/0399/)". Из этой статьи можно узнать не только об особенностях архитектуры Roslyn, но и как именно мы используем эту платформу.
Как я уже упоминал ранее, с момента написания последней статьи моего коллеги Андрея Карпова о проверке Roslyn "[Новогодний релиз PVS-Studio 6.00: проверяем Roslyn](https://www.viva64.com/ru/b/0363/)" прошло более трёх лет. За это время C# анализатор PVS-Studio обзавёлся многими новыми возможностями. Вообще, статья Андрея была неким «пробным шаром», ведь C# анализатор тогда только был добавлен в PVS-Studio. Несмотря на это, уже тогда в безусловно качественном проекте Roslyn удалось найти интересные ошибки. Что же изменилось в анализаторе для C# кода к настоящему времени, что потенциально позволит провести более глубокий анализ?
За прошедшее время развивались как ядро анализатора, так и инфраструктура. Была добавлена поддержка Visual Studio 2017 и Roslyn 2.0, а также осуществлена глубокая интеграция с MSBuild. Подробнее про наш подход к интеграции с MSBuild и про причины, которые побудили нас к его принятию, можно прочитать в статье моего коллеги Павла Еремеева "[Поддержка Visual Studio 2017 и Roslyn 2.0 в PVS-Studio: иногда использовать готовые решения не так просто, как кажется на первый взгляд](https://www.viva64.com/ru/b/0503/)".
Сейчас мы активно работаем над переходом на Roslyn 3.0 по той же схеме, по которой изначально поддержали Visual Studio 2017, то есть через свой собственный toolset, идущий в дистрибутиве PVS-Studio c «заглушкой» в виде пустого файла MSBuild.exe. Несмотря на то, что это выглядит как «костыль» (API MSBuild не очень дружелюбен для переиспользования в third-patry проектах из-за невысокой портабельности библиотек), такой подход уже помог нам относительно безболезненно пережить несколько обновлений Roslyn в течение жизни Visual Studio 2017, и сейчас, хотя и с большим количеством накладок, пережить обновление до Visual Studio 2019, а также сохранять полную обратную совместимость и работоспособность на системах с более старыми версиями MSBuild.
Ядро анализатора также претерпело ряд улучшений. Одно из главных нововведений — полноценный межпроцедурный анализ с учётом входных и выходных значений методов, с расчётом, в зависимости от этих параметров, достижимости веток выполнения и точек возврата.
Уже близка к завершению задача отслеживания параметров внутри методов, с сохранением авто-аннотаций для того, что с этими параметрами там происходит (например, потенциально опасное разыменование). Это позволит для любой диагностики, использующей механизм data-flow, учитывать опасные ситуации, происходящие при передаче параметра в метод. Раньше при анализе таких опасных мест предупреждение не генерировалось, так как мы не могли знать всех возможных входных значений в такой метод. Сейчас же мы можем обнаружить опасность, так как во всех местах вызова этого метода эти входные параметры будут учтены.
Замечание: вы можете ознакомиться с основными механизмами анализатора, такими как data-flow и другими, из статьи "[Технологии, используемые в анализаторе кода PVS-Studio для поиска ошибок и потенциальных уязвимостей](https://www.viva64.com/ru/b/0592/)".
Межпроцедурный анализ в PVS-Studio C# не ограничен ни входными параметрами, ни глубиной. Единственное ограничение — виртуальные методы в незакрытых для наследования классах и попадание в рекурсию (остановимся, когда увидели в стеке повторный вызов уже рассчитываемого метода). При этом сам рекурсивный метод в итоге будет посчитан с допущением, что возвращаемое значение его саморекурсии неизвестно.
Другим большим нововведением в C# анализаторе стал учёт возможности разыменования потенциально нулевого указателя. Раньше анализатор ругался на возможный null reference exception, если был уверен, что во всех ветках выполнения значение переменной будет принимать null. Конечно, он иногда ошибался, поэтому диагностика [V3080](https://www.viva64.com/ru/w/v3080/) уже раньше называлась potential null reference.
Теперь анализатор запоминает, что переменная могла быть null в одной из веток выполнения (например, при определённом условии в if). Если он увидит доступ к такой переменной без проверки, то выдаст сообщение V3080, но на более низком уровне важности, чем если он видит null во всех ветках. В сочетании с улучшенным межпроцедурным анализом, такой механизм позволяет находить очень сложно обнаруживаемые ошибки. Пример — длинная цепочка вызовов методов, последний из которых вам не знаком, и который, например, при определённых обстоятельствах в catch возвращает null, но вы не защитились от этого, так как этого просто не знали. В данном случае анализатор ругается только тогда, когда точно видит назначение null. На наш взгляд, это качественно отличает наш подход от такого нововведения C# 8.0, как nullable reference тип, которое, по факту, сводится к установке проверок на null в каждом методе. Мы же предлагаем альтернативу — делать проверки только там, где null может действительно прийти, и наш анализатор теперь умеет искать такие ситуации.
Итак, не откладывая в долгий ящик, перейдём к «разбору полётов» — анализу результатов проверки Roslyn. Сначала рассмотрим ошибки, найденные благодаря описанным выше нововведениям. Вообще, для кода Roslyn в этот раз было выдано довольно много предупреждений. Я думаю, это связано с тем, что платформа очень активно развивается (объем кодовой базы на данный момент составляет около 2 770 000 строк кода без учета пустых), а анализ этого проекта мы давно не делали. Тем не менее, критичных ошибок не так много, а именно они представляют интерес для статьи. И да, в Roslyn довольно много тестов, которые я, как обычно, исключил из проверки.
Начну с ошибок V3080, с уровнем критичности Medium, в которых анализатор обнаружил возможный доступ по нулевой ссылке, но не во всех возможных случаях (ветках кода).
**Possible null dereference — Medium**
V3080 Possible null dereference. Consider inspecting 'current'. CSharpSyntaxTreeFactoryService.PositionalSyntaxReference.cs 70
```
private SyntaxNode GetNode(SyntaxNode root)
{
var current = root;
....
while (current.FullSpan.Contains(....)) // <=
{
....
var nodeOrToken = current.ChildThatContainsPosition(....);
....
current = nodeOrToken.AsNode(); // <=
}
....
}
public SyntaxNode AsNode()
{
if (_token != null)
{
return null;
}
return _nodeOrParent;
}
```
Рассмотрим метод *GetNode*. Анализатор считает, что возможен доступ по нулевой ссылке в условии блока *while*. В теле блока *while* переменной *current* будет присвоено значение — результат выполнения метода *AsNode*. И это значение в ряде случаев будет *null*. Хороший пример межпроцедурного анализа в действии.
Теперь рассмотрим похожий случай, в котором межпроцедурный анализ был произведен через два вызова метода.
V3080 Possible null dereference. Consider inspecting 'directory'. CommonCommandLineParser.cs 911
```
private IEnumerable
ExpandFileNamePattern(string path, string baseDirectory, ....)
{
string directory = PathUtilities.GetDirectoryName(path);
....
var resolvedDirectoryPath = (directory.Length == 0) ? // <=
baseDirectory :
FileUtilities.ResolveRelativePath(directory, baseDirectory);
....
}
public static string GetDirectoryName(string path)
{
return GetDirectoryName(path, IsUnixLikePlatform);
}
internal static string GetDirectoryName(string path, bool isUnixLike)
{
if (path != null)
{
....
}
return null;
}
```
Переменная *directory* в теле метода *ExpandFileNamePattern* получает значение из метода *GetDirectoryName(string)*. Тот, в свою очередь, вернет результат работы перегруженного метода *GetDirectoryName(string, bool)*, значением которого может быть *null*. Так как далее в теле метода *ExpandFileNamePattern* переменная *directory* используется без предварительной проверки на равенство *null* — можно говорить о правомерности выдачи предупреждения анализатором. Это потенциально небезопасная конструкция.
Ещё один фрагмент кода с ошибкой V3080, точнее, сразу с двумя ошибками, выданными для одной строки кода. Здесь межпроцедурный анализ не понадобился.
V3080 Possible null dereference. Consider inspecting 'spanStartLocation'. TestWorkspace.cs 574
V3080 Possible null dereference. Consider inspecting 'spanEndLocationExclusive'. TestWorkspace.cs 574
```
private void MapMarkupSpans(....)
{
....
foreach (....)
{
....
foreach (....)
{
....
int? spanStartLocation = null;
int? spanEndLocationExclusive = null;
foreach (....)
{
if (....)
{
if (spanStartLocation == null &&
positionInMarkup <= markupSpanStart && ....)
{
....
spanStartLocation = ....;
}
if (spanEndLocationExclusive == null &&
positionInMarkup <= markupSpanEndExclusive && ....)
{
....
spanEndLocationExclusive = ....;
break;
}
....
}
....
}
tempMappedMarkupSpans[key].
Add(new TextSpan(
spanStartLocation.Value, // <=
spanEndLocationExclusive.Value - // <=
spanStartLocation.Value));
}
}
....
}
```
Переменные *spanStartLocation* и *spanEndLocationExclusive* имеют тип *nullable int* и инициализируются значением *null*. Далее в коде им могут быть присвоены значения, но только при выполнении определенных условий. В ряде случаев их значение останется равным *null*. Далее в коде происходит доступ к этим переменным по ссылке без предварительной проверки на равенство *null*, на что и указывает анализатор.
В коде Roslyn содержится довольно много подобных ошибок, более 100. Зачастую паттерн этих ошибок одинаков. Есть некий общий метод, который потенциально возвращает *null*. Результат работы данного метода используется в большом числе мест, иногда через десятки промежуточных вызовов методов или дополнительных проверок. Важно понимать, что эти ошибки не фатальны, но они потенциально могут приводить к доступу по нулевой ссылке. А обнаружить такие ошибки очень сложно. Поэтому в ряде случаев следует подумать о рефакторинге кода, при котором в случае возврата *null* методом выбрасывалось бы исключение. В противном случае вы сможете обезопасить свой код только тотальными проверками, что достаточно утомительно и ненадёжно. Конечно, в каждом конкретном случае решение должно приниматься исходя из особенностей проекта.
Примечание. Бывает, что на данный момент не существует ситуаций (входных данных), при которых метод вернёт *null* и никакой настоящей ошибки нет. Однако такой код всё равно не надёжен, так как всё может измениться при внесении изменений в код.
Чтобы закрыть тему с [V3080](https://www.viva64.com/ru/w/v3080/), давайте взглянем на очевидные ошибки с уровнем достоверности High, когда доступ по нулевой ссылке более вероятен или даже неизбежен.
**Possible null dereference — High**
V3080 Possible null dereference. Consider inspecting 'collectionType.Type'. AbstractConvertForToForEachCodeRefactoringProvider.cs 137
```
public override async Task
ComputeRefactoringsAsync(CodeRefactoringContext context)
{
....
var collectionType = semanticModel.GetTypeInfo(....);
if (collectionType.Type == null &&
collectionType.Type.TypeKind == TypeKind.Error)
{
return;
}
....
}
```
Вследствие опечатки в условии (вместо оператора *||* использовали *&&*), код работает совсем не так, как задумано, и доступ к переменной *collectionType.Type* будет выполнен при её равенстве *null*. Условие необходимо исправить следующим образом:
```
if (collectionType.Type == null ||
collectionType.Type.TypeKind == TypeKind.Error)
....
```
Кстати, возможен и второй вариант развития событий: в первой части условия перепутали операторы *==* и *!=*. Тогда исправленный код имел бы вид:
```
if (collectionType.Type != null &&
collectionType.Type.TypeKind == TypeKind.Error)
....
```
Этот вариант кода менее логичен, но также исправляет допущенную ошибку. Окончательное решение за авторами проекта.
Ещё одна подобная ошибка.
V3080 Possible null dereference. Consider inspecting 'action'. TextViewWindow\_InProc.cs 372
```
private Func GetLightBulbApplicationAction(....)
{
....
if (action == null)
{
throw new
InvalidOperationException(
$"Unable to find FixAll in {fixAllScope.ToString()}
code fix for suggested action '{action.DisplayText}'.");
}
....
}
```
Ошибка допущена при формировании сообщения для исключения. При этом производится попытка доступа к свойству *action.DisplayText* через переменную *action*, которая заведомо равна *null*.
И последняя ошибка V3080 уровня High.
V3080 Possible null dereference. Consider inspecting 'type'. ObjectFormatterHelpers.cs 91
```
private static bool IsApplicableAttribute(
TypeInfo type,
TypeInfo targetType,
string targetTypeName)
{
return type != null && AreEquivalent(targetType, type)
|| targetTypeName != null && type.FullName == targetTypeName;
}
```
Метод небольшой, поэтому я привожу его код целиком. Условие в блоке *return* некорректно. В ряде случаев возможен выброс исключения *NullReferenceException* при доступе *type.FullName*. Использую скобки (здесь они не будут менять поведения) для прояснения ситуации:
```
return (type != null && AreEquivalent(targetType, type))
|| (targetTypeName != null && type.FullName == targetTypeName);
```
Именно так, в соответствии с приоритетом операций, будет работать данный код. В случае, если переменная *type* будет равна *null*, мы попадём в else-проверку, где, убедившись в неравенстве *null* переменной *targetTypeName*, используем нулевую ссылку *type*. Исправить код можно, например, так:
```
return type != null &&
(AreEquivalent(targetType, type) ||
targetTypeName != null && type.FullName == targetTypeName);
```
Думаю, на этом можно завершить изучение ошибок V3080 и посмотреть, что еще интересного удалось найти анализатору PVS-Studio в коде Roslyn.
**Опечатка**
[V3005](https://www.viva64.com/ru/w/v3005/) The 'SourceCodeKind' variable is assigned to itself. DynamicFileInfo.cs 17
```
internal sealed class DynamicFileInfo
{
....
public DynamicFileInfo(
string filePath,
SourceCodeKind sourceCodeKind,
TextLoader textLoader,
IDocumentServiceProvider documentServiceProvider)
{
FilePath = filePath;
SourceCodeKind = SourceCodeKind; // <=
TextLoader = textLoader;
DocumentServiceProvider = documentServiceProvider;
}
....
}
```
Из-за неудачного названия переменных, в конструкторе класса *DynamicFileInfo* допустили опечатку. Полю *SourceCodeKind* присваивают его же собственное значение, вместо использования параметра *sourceCodeKind*. Для минимизации вероятности возникновения таких ошибок рекомендуется использовать префикс подчеркивания для имен параметров в таких случаях. Приведу пример исправленного варианта кода:
```
public DynamicFileInfo(
string _filePath,
SourceCodeKind _sourceCodeKind,
TextLoader _textLoader,
IDocumentServiceProvider _documentServiceProvider)
{
FilePath = _filePath;
SourceCodeKind = _sourceCodeKind;
TextLoader = _textLoader;
DocumentServiceProvider = _documentServiceProvider;
}
```
**Невнимательность**
[V3006](https://www.viva64.com/ru/w/v3006/) The object was created but it is not being used. The 'throw' keyword could be missing: throw new InvalidOperationException(FOO). ProjectBuildManager.cs 61
```
~ProjectBuildManager()
{
if (_batchBuildStarted)
{
new InvalidOperationException("ProjectBuilderManager.Stop()
not called.");
}
}
```
При определенном условии деструктор должен выбросить исключение, но этого не происходит, а объект исключения просто создается. Было пропущено ключевое слово *throw*. Исправленный вариант кода:
```
~ProjectBuildManager()
{
if (_batchBuildStarted)
{
throw new InvalidOperationException("ProjectBuilderManager.Stop()
not called.");
}
}
```
Вопрос работы с деструкторами в C# и выбросу из них исключений — тема отдельной дискуссии, которая выходит за рамки данной статьи.
**Когда результат не важен**
Некоторое количество предупреждений [V3009](https://www.viva64.com/ru/w/v3009/) было получено для методов, которые во всех случаях возвращают одинаковое значение. Иногда это не критично, или в вызывающем коде возвращаемое значение просто не проверяют. Такие предупреждения я пропустил. Но несколько фрагментов кода показались мне подозрительными. Приведу один из них:
V3009 It's odd that this method always returns one and the same value of 'true'. GoToDefinitionCommandHandler.cs 62
```
internal bool TryExecuteCommand(....)
{
....
using (context.OperationContext.AddScope(....))
{
if (....)
{
return true;
}
}
....
return true;
}
```
Метод *TryExecuteCommand* возвращает только *true*, и ничего кроме *true*. При этом в вызывающем коде возвращаемое значение участвует в каких-то проверках:
```
public bool ExecuteCommand(....)
{
....
if (caretPos.HasValue && TryExecuteCommand(....))
{
....
}
....
}
```
Трудно сказать, насколько такое поведение опасно. Но если результат не нужен, возможно, стоит заменить тип возвращаемого значения на void и внести минимальные правки в вызывающий метод. Это сделает код более понятным и безопасным.
Другие подобные предупреждения:
* V3009 It's odd that this method always returns one and the same value of 'true'. CommentUncommentSelectionCommandHandler.cs 86
* V3009 It's odd that this method always returns one and the same value of 'true'. RenameTrackingTaggerProvider.RenameTrackingCommitter.cs 99
* V3009 It's odd that this method always returns one and the same value of 'true'. JsonRpcClient.cs 138
* V3009 It's odd that this method always returns one and the same value of 'true'. AbstractFormatEngine.OperationApplier.cs 164
* V3009 It's odd that this method always returns one and the same value of 'false'. TriviaDataFactory.CodeShapeAnalyzer.cs 254
* V3009 It's odd that this method always returns one and the same value of 'true'. ObjectList.cs 173
* V3009 It's odd that this method always returns one and the same value of 'true'. ObjectList.cs 249
**Не то проверили**
[V3019](https://www.viva64.com/ru/w/v3019/) Possibly an incorrect variable is compared to null after type conversion using 'as' keyword. Check variables 'value', 'valueToSerialize'. RoamingVisualStudioProfileOptionPersister.cs 277
```
public bool TryPersist(OptionKey optionKey, object value)
{
....
var valueToSerialize = value as NamingStylePreferences;
if (value != null)
{
value = valueToSerialize.CreateXElement().ToString();
}
....
}
```
Переменную *value* приводят к типу *NamingStylePreferences*. Проблема в следующей за этим проверке. Даже если переменная *value* не нулевая, это не гарантирует, что приведение типа было успешным и *valueToSerialize* содержит не *null*. Возможен выброс исключения *NullReferenceException*. Код необходимо исправить следующим образом:
```
var valueToSerialize = value as NamingStylePreferences;
if (valueToSerialize != null)
{
value = valueToSerialize.CreateXElement().ToString();
}
```
И ещё одна похожая ошибка.
V3019 Possibly an incorrect variable is compared to null after type conversion using 'as' keyword. Check variables 'columnState', 'columnState2'. StreamingFindUsagesPresenter.cs 181
```
private void SetDefinitionGroupingPriority(....)
{
....
foreach (var columnState in ....)
{
var columnState2 = columnState as ColumnState2;
if (columnState?.Name == // <=
StandardTableColumnDefinitions2.Definition)
{
newColumns.Add(new ColumnState2(
columnState2.Name, // <=
....));
}
....
}
....
}
```
Переменную *columnState* приводят к типу *ColumnState2*. Однако результат операции, переменную *columnState2*, далее не проверяют на равенство *null*. Вместо этого проверяется переменная *columnState* при помощи оператора условного *null*. Чем опасен этот код? Как и в предыдущем примере, приведение типа при помощи оператора *as* может закончиться неудачей, и переменная *columnState2* будет равна *null*, что приведёт к дальнейшему выбросу исключения. Кстати, виновата здесь может быть и опечатка. Обратите внимание на условие в блоке *if*. Возможно, вместо *columnState?.Name* хотели написать *columnState2?.Name*. Это весьма вероятно, если учесть довольно неудачные имена переменных *columnState и columnState2.*
**Избыточные проверки**
Довольно большое количество предупреждений (более 100) было выдано на некритичные, но потенциально небезопасные конструкции, связанные с избыточными проверками. Для примера приведу одну из них.
[V3022](https://www.viva64.com/ru/w/v3022/) Expression 'navInfo == null' is always false. AbstractSyncClassViewCommandHandler.cs 101
```
public bool ExecuteCommand(....)
{
....
IVsNavInfo navInfo = null;
if (symbol != null)
{
navInfo = libraryService.NavInfoFactory.CreateForSymbol(....);
}
if (navInfo == null)
{
navInfo = libraryService.NavInfoFactory.CreateForProject(....);
}
if (navInfo == null) // <=
{
return true;
}
....
}
public IVsNavInfo CreateForSymbol(....)
{
....
return null;
}
public IVsNavInfo CreateForProject(....)
{
return new NavInfo(....);
}
```
Пожалуй, настоящей ошибки здесь нет. Просто хороший повод продемонстрировать связку технологий «межпроцедурный анализ + анализ потока данных» в действии. Анализатор считает, что вторая проверка *navInfo == null* избыточна. Действительно, перед этим значение для присвоения *navInfo* будет получено из метода *libraryService.NavInfoFactory.CreateForProject*, который сконструирует и вернет новый объект класса *NavInfo*. Но никак не *null*. Возникает вопрос, почему же анализатор не выдал предупреждение для первой проверки *navInfo == null*? Этому есть объяснение. Во-первых, в случае, если переменная *symbol* окажется равной *null*, то и значение *navInfo* останется нулевой ссылкой. Во-вторых, даже если *navInfo* получит значение из метода *libraryService.NavInfoFactory.CreateForSymbol*, это значение может быть равно *null*. Таким образом, первая проверка *navInfo == null* действительно необходима.
**Недостаточно проверок**
А теперь ситуация, обратная рассмотренной выше. Несколько предупреждений [V3042](https://www.viva64.com/ru/w/v3042/) было получено для кода, в котором возможен доступ по нулевой ссылке. При этом всего одна-две небольшие проверки могли бы всё исправить.
Рассмотрим один интересный фрагмент кода, в котором содержатся две подобные ошибки.
V3042 Possible NullReferenceException. The '?.' and '.' operators are used for accessing members of the 'receiver' object Binder\_Expressions.cs 7770
V3042 Possible NullReferenceException. The '?.' and '.' operators are used for accessing members of the 'receiver' object Binder\_Expressions.cs 7776
```
private BoundExpression GetReceiverForConditionalBinding(
ExpressionSyntax binding,
DiagnosticBag diagnostics)
{
....
BoundExpression receiver = this.ConditionalReceiverExpression;
if (receiver?.Syntax != // <=
GetConditionalReceiverSyntax(conditionalAccessNode))
{
receiver = BindConditionalAccessReceiver(conditionalAccessNode,
diagnostics);
}
var receiverType = receiver.Type; // <=
if (receiverType?.IsNullableType() == true)
{
....
}
receiver = new BoundConditionalReceiver(receiver.Syntax, 0, // <=
receiverType ?? CreateErrorType(),
hasErrors: receiver.HasErrors) // <=
{ WasCompilerGenerated = true };
return receiver;
}
```
Переменная *receiver* может быть равна *null*. Автор кода это знает, так как использует оператор условного *null* в условии блока *if* для доступа к *receiver?.Syntax*. Далее в коде переменная *receiver* используется без всяких проверок для доступа к *receiver.Type*, *receiver.Syntax* и *receiver.HasErrors*. Эти ошибки необходимо исправить:
```
private BoundExpression GetReceiverForConditionalBinding(
ExpressionSyntax binding,
DiagnosticBag diagnostics)
{
....
BoundExpression receiver = this.ConditionalReceiverExpression;
if (receiver?.Syntax !=
GetConditionalReceiverSyntax(conditionalAccessNode))
{
receiver = BindConditionalAccessReceiver(conditionalAccessNode,
diagnostics);
}
var receiverType = receiver?.Type;
if (receiverType?.IsNullableType() == true)
{
....
}
receiver = new BoundConditionalReceiver(receiver?.Syntax, 0,
receiverType ?? CreateErrorType(),
hasErrors: receiver?.HasErrors)
{ WasCompilerGenerated = true };
return receiver;
}
```
Также необходимо убедиться, что конструктор *BoundConditionalReceiver* поддерживает получение значений *null* для своих параметров, или провести дополнительный рефакторинг.
Другие подобные ошибки:
* V3042 Possible NullReferenceException. The '?.' and '.' operators are used for accessing members of the 'containingType' object SyntaxGeneratorExtensions\_Negate.cs 240
* V3042 Possible NullReferenceException. The '?.' and '.' operators are used for accessing members of the 'expression' object ExpressionSyntaxExtensions.cs 349
* V3042 Possible NullReferenceException. The '?.' and '.' operators are used for accessing members of the 'expression' object ExpressionSyntaxExtensions.cs 349
**Ошибка в условии**
[V3057](https://www.viva64.com/ru/w/v3057/) The 'Substring' function could receive the '-1' value while non-negative value is expected. Inspect the second argument. CommonCommandLineParser.cs 109
```
internal static bool TryParseOption(....)
{
....
if (colon >= 0)
{
name = arg.Substring(1, colon - 1);
value = arg.Substring(colon + 1);
}
....
}
```
В случае, если переменная *colon* будет равна 0, что допускает условие в коде, метод *Substring* выбросит исключение *ArgumentOutOfRangeException*. Необходимо исправление:
```
if (colon > 0)
```
**Возможна опечатка**
[V3065](https://www.viva64.com/ru/w/v3065/) Parameter 't2' is not utilized inside method's body. CSharpCodeGenerationHelpers.cs 84
```
private static TypeDeclarationSyntax
ReplaceUnterminatedConstructs(....)
{
....
var updatedToken = lastToken.ReplaceTrivia(lastToken.TrailingTrivia,
(t1, t2) =>
{
if (t1.Kind() == SyntaxKind.MultiLineCommentTrivia)
{
var text = t1.ToString();
....
}
else if (t1.Kind() == SyntaxKind.SkippedTokensTrivia)
{
return ReplaceUnterminatedConstructs(t1);
}
return t1;
});
....
}
```
В лямбда-выражение передают два параметра: t1 и t2. Однако используют только t1. Выглядит подозрительно, учитывая, как легко ошибиться при использовании переменных с такими именами.
**Невнимательность**
[V3083](https://www.viva64.com/ru/w/v3083/) Unsafe invocation of event 'TagsChanged', NullReferenceException is possible. Consider assigning event to a local variable before invoking it. PreviewUpdater.Tagger.cs 37
```
public void OnTextBufferChanged()
{
if (PreviewUpdater.SpanToShow != default)
{
if (TagsChanged != null)
{
var span = _textBuffer.CurrentSnapshot.GetFullSpan();
TagsChanged(this, new SnapshotSpanEventArgs(span)); // <=
}
}
}
```
Событие *TagsChanged* вызывают небезопасно. Между проверкой на равенство *null* и вызовом события, от него могут успеть отписаться, тогда будет выброшено исключение. Более того, в теле блока *if* непосредственно перед вызовом события делаются ещё какие-то операции. Я назвал эту ошибку «Невнимательность», потому что в других местах в коде с этим событием работают более аккуратно, например, так:
```
private void OnTrackingSpansChanged(bool leafChanged)
{
var handler = TagsChanged;
if (handler != null)
{
var snapshot = _buffer.CurrentSnapshot;
handler(this,
new SnapshotSpanEventArgs(snapshot.GetFullSpan()));
}
}
```
Использование дополнительной переменной *handler* исключает появление проблемы. В методе *OnTextBufferChanged* необходимо внести правки для такой же безопасной работы с событием.
**Пересекающиеся диапазоны**
[V3092](https://www.viva64.com/ru/w/v3092/) Range intersections are possible within conditional expressions. Example: if (A > 0 && A < 5) {… } else if (A > 3 && A < 9) {… }. ILBuilderEmit.cs 677
```
internal void EmitLongConstant(long value)
{
if (value >= int.MinValue && value <= int.MaxValue)
{
....
}
else if (value >= uint.MinValue && value <= uint.MaxValue)
{
....
}
else
{
....
}
}
```
Для лучшего понимания, перепишу данный фрагмент кода, заменив имена констант на их фактические значения:
```
internal void EmitLongConstant(long value)
{
if (value >= -2147483648 && value <= 2147483648)
{
....
}
else if (value >= 0 && value <= 4294967295)
{
....
}
else
{
....
}
}
```
Наверное, здесь нет настоящей ошибки, но условие выглядит странно. Вторая его часть (*else if*) будет выполняться только для диапазона значений от 2147483648 + 1 до 4294967295.
Ещё пара подобных предупреждений:
* V3092 Range intersections are possible within conditional expressions. Example: if (A > 0 && A < 5) {… } else if (A > 3 && A < 9) {… }. LocalRewriter\_Literal.cs 109
* V3092 Range intersections are possible within conditional expressions. Example: if (A > 0 && A < 5) {… } else if (A > 3 && A < 9) {… }. LocalRewriter\_Literal.cs 66
**Ещё о проверках на равенство null (или их отсутствии)**
Несколько ошибок [V3095](https://www.viva64.com/ru/w/v3095/) о проверке переменной на равенство *null* уже после использования. Первая неоднозначна, рассмотрим код.
V3095 The 'displayName' object was used before it was verified against null. Check lines: 498, 503. FusionAssemblyIdentity.cs 498
```
internal static IAssemblyName ToAssemblyNameObject(string displayName)
{
if (displayName.IndexOf('\0') >= 0)
{
return null;
}
Debug.Assert(displayName != null);
....
}
```
Предполагается, что ссылка *displayName* может быть нулевой. Для этого сделали проверку *Debug.Assert*. Непонятно только, почему она идёт уже после использования строки. Также следует учитывать, что для других, отличных от Debug конфигураций, компилятор уберёт *Debug.Assert* из кода вовсе. Значит ли это, что только для Debug возможно получение нулевой ссылки? И если это не так, то почему не была сделана проверка *string.IsNullOrEmpty(string)*, например. Это вопросы к авторам кода.
Следующая ошибка более очевидна.
V3095 The 'scriptArgsOpt' object was used before it was verified against null. Check lines: 321, 325. CommonCommandLineParser.cs 321
```
internal void FlattenArgs(...., List scriptArgsOpt, ....)
{
....
while (args.Count > 0)
{
....
if (parsingScriptArgs)
{
scriptArgsOpt.Add(arg); // <=
continue;
}
if (scriptArgsOpt != null)
{
....
}
....
}
}
```
Думаю, этот фрагмент кода не требует пояснений. Приведу исправленный вариант:
```
internal void FlattenArgs(...., List scriptArgsOpt, ....)
{
....
while (args.Count > 0)
{
....
if (parsingScriptArgs)
{
scriptArgsOpt?.Add(arg);
continue;
}
if (scriptArgsOpt != null)
{
....
}
....
}
}
```
В коде Roslyn нашлось еще 15 подобных ошибок:
* V3095 The 'LocalFunctions' object was used before it was verified against null. Check lines: 289, 317. ControlFlowGraphBuilder.RegionBuilder.cs 289
* V3095 The 'resolution.OverloadResolutionResult' object was used before it was verified against null. Check lines: 579, 588. Binder\_Invocation.cs 579
* V3095 The 'resolution.MethodGroup' object was used before it was verified against null. Check lines: 592, 621. Binder\_Invocation.cs 592
* V3095 The 'touchedFilesLogger' object was used before it was verified against null. Check lines: 111, 126. CSharpCompiler.cs 111
* V3095 The 'newExceptionRegionsOpt' object was used before it was verified against null. Check lines: 736, 743. AbstractEditAndContinueAnalyzer.cs 736
* V3095 The 'symbol' object was used before it was verified against null. Check lines: 422, 427. AbstractGenerateConstructorService.Editor.cs 422
* V3095 The '\_state.BaseTypeOrInterfaceOpt' object was used before it was verified against null. Check lines: 132, 140. AbstractGenerateTypeService.GenerateNamedType.cs 132
* V3095 The 'element' object was used before it was verified against null. Check lines: 232, 233. ProjectUtil.cs 232
* V3095 The 'languages' object was used before it was verified against null. Check lines: 22, 28. ExportCodeCleanupProvider.cs 22
* V3095 The 'memberType' object was used before it was verified against null. Check lines: 183, 184. SyntaxGeneratorExtensions\_CreateGetHashCodeMethod.cs 183
* V3095 The 'validTypeDeclarations' object was used before it was verified against null. Check lines: 223, 228. SyntaxTreeExtensions.cs 223
* V3095 The 'text' object was used before it was verified against null. Check lines: 376, 385. MSBuildWorkspace.cs 376
* V3095 The 'nameOrMemberAccessExpression' object was used before it was verified against null. Check lines: 206, 223. CSharpGenerateTypeService.cs 206
* V3095 The 'simpleName' object was used before it was verified against null. Check lines: 83, 85. CSharpGenerateMethodService.cs 83
* V3095 The 'option' object was used before it was verified against null. Check lines: 23, 28. OptionKey.cs 23
Рассмотрим ошибки [V3105](https://www.viva64.com/ru/w/v3105/). Здесь используется оператор условного *null* при инициализации переменной, а вот далее в коде переменная используется без проверок на равенство *null*.
О следующей ошибке сигнализируют сразу два предупреждения.
V3105 The 'documentId' variable was used after it was assigned through null-conditional operator. NullReferenceException is possible. CodeLensReferencesService.cs 138
V3105 The 'documentId' variable was used after it was assigned through null-conditional operator. NullReferenceException is possible. CodeLensReferencesService.cs 139
```
private static async Task
GetDescriptorOfEnclosingSymbolAsync(....)
{
....
var documentId = solution.GetDocument(location.SourceTree)?.Id;
return new ReferenceLocationDescriptor(
....
documentId.ProjectId.Id,
documentId.Id,
....);
}
```
Переменная *documentId* может быть инициализирована значением *null*. В результате, создание объекта *ReferenceLocationDescriptor* закончится выбросом исключения. Код необходимо исправить:
```
return new ReferenceLocationDescriptor(
....
documentId?.ProjectId.Id,
documentId?.Id,
....);
```
Также далее в коде необходимо предусмотреть возможность равенства *null* переменных, передаваемых в конструктор.
Другие похожие ошибки в коде:
* V3105 The 'symbol' variable was used after it was assigned through null-conditional operator. NullReferenceException is possible. SymbolFinder\_Hierarchy.cs 44
* V3105 The 'symbol' variable was used after it was assigned through null-conditional operator. NullReferenceException is possible. SymbolFinder\_Hierarchy.cs 51
**Приоритеты и скобки**
[V3123](https://www.viva64.com/ru/w/v3123/) Perhaps the '?:' operator works in a different way than it was expected. Its priority is lower than priority of other operators in its condition. Edit.cs 70
```
public bool Equals(Edit other)
{
return \_kind == other.\_kind
&& (\_oldNode == null) ? other.\_oldNode == null :
\_oldNode.Equals(other.\_oldNode)
&& (\_newNode == null) ? other.\_newNode == null :
\_newNode.Equals(other.\_newNode);
}
```
Условие в блоке return вычисляется совсем не так, как думал разработчик. Предполагалось, что первым условием будет *\_kind == other.\_kin*d (поэтому после этого условия сделан перенос строки), а затем последовательно будут вычислены блоки условий с оператором "*?*". На самом деле, первым условием будет *\_kind == other.\_kind && (\_oldNode == null)*. Это связано с тем, что оператор *&&* имеет более высокий приоритет, чем оператор "*?*". Для исправления ошибки, необходимо взять в скобки все выражения оператора "*?*":
```
return _kind == other._kind
&& ((_oldNode == null) ? other._oldNode == null :
_oldNode.Equals(other._oldNode))
&& ((_newNode == null) ? other._newNode == null :
_newNode.Equals(other._newNode));
```
На этом я завершаю описание найденных ошибок.
**Выводы**
Несмотря на значительное число ошибок, которые мне удалось обнаружить, в пересчете на размер кода проекта Roslyn (2 770 000 строк) это составит довольно незначительную величину. Как и Андрей в предыдущей статье, я также готов признать высокое качество этого проекта.
Хочу отметить, что подобные эпизодические проверки кода не имеют ничего общего с методологией статического анализа и практически не приносят пользы. Статический анализ должен применяться регулярно, а не от случая к случаю. Тогда многие ошибки будут исправлены на самых ранних этапах, а, следовательно, стоимость их исправления будет в десятки раз ниже. Более подробно эта мысль изложена в этой маленькой [заметке](https://www.viva64.com/ru/b/0534/), с которой я очень прошу ознакомиться.
Вы можете самостоятельно поискать ещё какие-то ошибки как в рассмотренном проекте, так и в любом другом. Для этого просто необходимо [скачать](https://www.viva64.com/ru/pvs-studio-download/) и попробовать наш анализатор.
[](https://habr.com/en/company/pvs-studio/blog/446588/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Sergey Khrenov. [Checking the Roslyn Source Code](https://habr.com/en/company/pvs-studio/blog/446588/). | https://habr.com/ru/post/446592/ | null | ru | null |
# Мой авторесайз IFRAME
Прочитав статейку Дмитрия Котерова о ресайзе ифрэймов решился поделиться своим решением.
Этим решением пользуемся на продуктивном сайте.
Итак, дано:
1. Нужно показывать в ифрэйме страницы с других доменов без скроллбара
2. Внутри ифрэйма могут совершаться переходы
3. Сайты в ифрэйме могут менять высоту без перегрузки (AJAX или просто раскрытие каких-нибудь невидимых элементов)
4. Во включаемые страницы должно включаться кода по минимуму
5. Решение не должно портить историю посещение браузера и должно работать в актуальных версиях популярных браузеров
6. Решение должно работать в обоих случаях master.site и www.master.site
Решение:
Нам нужно на основном сайте master.site создать два файлика iframe\_height.js и height.html.
На самой странице создаем ифрэйм с id=«iframe». Во включаемую страницу с домена slave.site в head добавляем ссылку на жаваскрипт http://master.site/iframe\_height.js
iframe\_height.js:
> `var \_\_hc = {
> i: null, // используется для периодической проверки высоты
> h: 0, // предыдущая установленная высота
> iframes: [null, null], // создаем два ифрэйма
> path: 'master.com/height.html#', // путь до height.html
> // созание невидимых ифрэймов для установки высоты
> setHeight: function(height) {
> var ifr,i;
> for (i=0;i<2;i++) {
> if (this.iframes[i]) this.iframes[i].parentNode.removeChild(this.iframes[i]);
> ifr = document.createElement('IFRAME');
> ifr.style.display = 'none';
> this.iframes[i] = ifr;
> document.body.appendChild(this.iframes[i]);
> ifr.src = 'http://' + (i ? 'www.' : '') + this.path + height;
> }
> },
> // выполняется после загрузки окна — устанавливаем высоту и запускаем периодическую проверку
> onLoad: function(full) {
> this.checkHeight();
> if (full) {
> this.i = window.setInterval(this.bind(this.checkHeight), 100);
> }
> },
> // проверка высоты, если не изменилась с прошлой проверки
> checkHeight: function() {
> var h = this.getDocHeight();
> if (this.h == h) return;
>
> this.h = h;
> this.setHeight(this.h);
> },
> // если определена функция для определения высоты используем ее, иначе ползуемся общей реализацией
> getDocHeight: function() {
> if (window.GetDocumentHeight) return window.GetDocumentHeight();
> var D = document;
> return Math.max(
> D.body.scrollHeight, D.documentElement.scrollHeight,
> D.body.offsetHeight, D.documentElement.offsetHeight,
> D.body.clientHeight, D.documentElement.clientHeight
> );
> },
> // служебные методы
> addEvent: function(o, t, h) {
> if (o.addEventListener) o.addEventListener(t, h, false);
> else if (o.attachEvent) o.attachEvent('on'+t, h);
> },
> bind: function (method) {
> var context = this, args = arguments;
> return function() {
> return method.apply(context, Array.prototype.slice.call(args, 1));
> };
> },
> // инициализация
> init: function(full) {
> this.addEvent(window, 'load', this.bind(this.onLoad, full));
> }
> };
>
> \_\_hc.init(true);
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/78845/ | null | ru | null |
# Улучшаем экспорт в Excel для SharePoint
Стандартная возможность экспорта в Excel в SharePoint работает довольно необычным образом. При нажатии на кнопку экспорта SharePoint отдает файл запроса в специальном формате, который открывается Excel, и уже сам Excel затягивает данные.
Преимущество такого подхода в том, что данные в Excel можно обновить, так как есть соединение. Но недостатков больше:
* Нужен установленный Excel на компьютер, чтобы получить данные.
* В полученном документе для названий колонок используется InternalName полей.
* В полученном документе используется “сырой” формат данных, что далеко не всегда подходит.
С помощью небольшого объема кода можно подменить стандартную функцию экспорта на свою так, что пользователи ничего не заметят.
#### Подмена кнопок экспорта
Чтобы заменить существующий элемент в Ribbon надо добавить новый `CommandUIDefinition` с параметром `Location` равным Id существующего элемента. Все стандартные элементы находятся в файле `C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\**14**\TEMPLATE\GLOBAL\XML\CMDUI.XML` для SharePoint 2010 (или **15** для SharePoint 2013).
Для того, чтобы подменить кнопки экспорта в Excel надо найти кнопки с Id равными `Ribbon.List.Actions.ExportToSpreadsheet` и `Ribbon.Library.Actions.ExportToSpreadsheet` и полностью скопировать в свой проект. В качестве `Location` для новых элементов надо указать эти Id.
**Много копипасты**
```
```
Есть еще отдельная кнопка для календаря с `Id="Ribbon.Calendar.Calendar.Actions.ExportToSpreadsheet"`, с ней можно сделать тоже самое.
#### Создание контрола
Кнопка должна вызывать некоторый серверный код. Чтобы поведение было аналогично стандартной кнопке, лучше всего сделать *DelegateControl*, который будет размещаться на каждой странице. Для этого есть контейнер с `Id="AdditionalPageHead"`:
```
```
Кастомная кнопка будет вызывать *PostBack*, обрабатываемый нашим контролом. Кнопка может быть нажата на странице представления списка, тогда не надо передавать дополнительных параметров. Также представления списков могут быть добавлены на обычные страницы как веб-части, тогда нужно передать Id списка и представления на сервер.
Увы, получение Id представления, в котором была нажата кнопка – нетривиальная задача. Поэтому я ограничусь только передачей Id списка.
```
```
Далее на сервере нужно проверить нажата ли кнопка на странице представления списка или на обычной странице:
```
protected override void OnLoad(EventArgs e) {
if (this.Page.Request["__EVENTTARGET"] == "ExportToSpreadsheet-Replacement")
{
var spContext = SPContext.Current;
SPList list;
SPView view;
if (spContext.ViewContext.View != null)
{
list = spContext.List;
view = spContext.ViewContext.View;
}
else
{
var listId = new Guid(this.Page.Request["__EVENTARGUMENT"]);
var web = spContext.Web;
list = web.Lists[listId];
view = list.DefaultView;
}
ExportData(list.Title + " - " + view.Title, GetDataTable(list, view));
}
}
```
Получение таблицы данных по представлению очень просто:
```
private static System.Data.DataTable GetDataTable(SPList list, SPView view)
{
var query = new SPQuery(view);
SPListItemCollectionPosition position;
var flags = SPListGetDataTableOptions.UseBooleanDataType | SPListGetDataTableOptions.UseCalculatedDataType;
var result = list.GetDataTable(query, flags, out position);
while (position != null)
{
list.AppendDataTable(query, flags, result, out position);
}
return result;
}
```
#### Генерация Excel файла
Последним шагом требуется сформировать Excel файл и отдать его клиенту. Один из самых простых способов сгенерировать Excel – использовать библиотеку ClosedXml (<http://closedxml.codeplex.com/>).
```
private void ExportData(string title, System.Data.DataTable table)
{
var wb = new XLWorkbook();
var ws = wb.Worksheets.Add(title);
ws.Cell(1, 1).InsertTable(table);
var response = this.Page.Response;
response.Clear();
response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
var filename = title+".xlsx";
response.AddHeader("content-disposition", GetContentDisposition(filename));
// Flush the workbook to the Response.OutputStream
using (var memoryStream = new MemoryStream())
{
wb.SaveAs(memoryStream);
memoryStream.WriteTo(response.OutputStream);
}
response.End();
}
```
Первые три строки метода собственно формируют Excel документ (спасибо ClosedXml), а все остальное – код для отдачи файла клиенту.
Заголовок ответа `content-disposition` очень по-разному воспринимается разными браузерами, поэтому отдать файл с корректным русским именем требует некоторых танцев с бубном.
Код для формирования корректного заголовка `content-disposition` я нашел на StackOverflow [stackoverflow.com/questions/93551/how-to-encode-the-filename-parameter-of-content-disposition-header-in-http](http://stackoverflow.com/questions/93551/how-to-encode-the-filename-parameter-of-content-disposition-header-in-http)
```
private string GetContentDisposition(string filename)
{
var request = this.Page.Request;
string contentDisposition;
if (request.Browser.Browser == "IE" && (request.Browser.Version == "7.0" || request.Browser.Version == "8.0"))
contentDisposition = "attachment; filename=" + Uri.EscapeDataString(filename);
else if (request.UserAgent != null && request.UserAgent.ToLowerInvariant().Contains("android")) // android built-in download manager (all browsers on android)
contentDisposition = "attachment; filename=\"" + MakeAndroidSafeFileName(filename) + "\"";
else
contentDisposition = "attachment; filename=\"" + filename + "\"; filename*=UTF-8''" + Uri.EscapeDataString(filename);
return contentDisposition;
}
private static readonly Dictionary AndroidAllowedChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.\_-+,@£$€!½§~'=()[]{}0123456789".ToDictionary(c => c);
private string MakeAndroidSafeFileName(string fileName)
{
char[] newFileName = fileName.ToCharArray();
for (int i = 0; i < newFileName.Length; i++)
{
if (!AndroidAllowedChars.ContainsKey(newFileName[i]))
newFileName[i] = '\_';
}
return new string(newFileName);
}
```
#### Заключение
Чтобы все заработало на Production надо добавить файлы ClosedXml.dll и DocumentFormat.OpenXml.dll в ваш пакет. Кнопки Ribbon и контрол поместить в одну фичу уровня Site или Web.
Весь проект можно посмотреть по ссылке — [spsamples.codeplex.com/SourceControl/latest#ExportToExcel](https://spsamples.codeplex.com/SourceControl/latest#ExportToExcel/)
Готовый WSP файл тут — [spsamples.codeplex.com/releases/view/117220](https://spsamples.codeplex.com/releases/view/117220)
Большая часть кода универсальна, и не зависит от SharePoint. Вы можете использовать аналогичный подход в любом проекте на ASP.NET. | https://habr.com/ru/post/208948/ | null | ru | null |
# Загрузка моделей, трейтов
Итак, узнал сегодня небольшую *фитчу Laravel/Eloquent*, которая практически не описана и лишь вскользь упомянута в документации фреймовика.
*Перейдите к **TL;DR,** если вы просто хотите увидеть эту фичу.*
Возможно, вы уже знаете, что можно добавлять статические *boot*()-методы к *Eloquent*-модели, которые будут выполнены при ее загрузке. Это можно использовать, например, привязываясь к событиям модели, если это необходимо. Например, вы можете организовать email-уведомление, каждый раз, когда будет создан новый пользователь(*неудачный пример*), но вы могли бы описать это следующим образом:
```
class User extends Eloquent {
public static function boot()
{
parent::boot();
static::created(function($user) {
// Send a mailing…
});
}
}
```
Но что если вы хотите поместить это с *trait*?
Рассмотрим такой сценарий; необходимо организовать поиск в диапазоне моделей. Конечно, можно создать новый класс *SearchableModel*, унаследовав его от *Eloquent\Model*, но хотелось бы написать таким образом, чтобы функционал был легко переносим в другие проекты, не привязываясь к конкретному приложению. Трейт здесь подойдет как-никак лучше, потому что он легко переносим и относительно ненавязчив, подключая который вы получаете дополнительный функционал, который может быть легко переопределен.
Итак, я создал SearchableTrait.
```
trait SearchableTrait {
public function search($query)
{
// ...
}
}
```
Довольно просто пока, мы вызываем метод *$model->search('query')*, возвращающий модели, соответствующие критериям запроса.
Тем не менее, вместо непосредственного поиска по базе данных я планирую использовать сторонний поиск по приложению(*если кому интересно,* [elasticsearch](https://www.elastic.co/products/elasticsearch)), использующий собственную индексацию, которая требует настройки индекса каждой строки вручную.
Но куда мне вставить этот код?
Я мог бы поместить его в *boot()*-метод модели, но там он может быть затерт, тем самым нарушая мой поиск и уничтожая любой шанс быть повторно использованным.
**TL; DR**
Ребята из Laravel явно предусмотрели, каким образом подгружать ваши трейты, определяя специальное метод, как в Eloquent-модели, к примеру:
```
trait SearchableTrait {
public function search($query)
{
// ...
}
public static function bootSearchableTrait()
{
static::created(function($item){
// Index the item
});
}
}
```
Таким образом, здесь присутствует небольшая классическая магия *Eloquent*. Если у вас есть статический метод в трейте, который называется по принципу **boot[*NameOfTrait]***, то он будет выполнен также, как статический *boot*()-метод модели. Какое удобное место для регистрации событий своей модели.
Пример в документации по Laravel, реализует этот трюк при [регистрации глобального скоупа](http://laravel.com/docs/5.0/eloquent#global-scopes), для перехвата всех запущенных запросов, при мягком удаление моделей.
Конечно же, кроме этой фичи, есть и другие хорошие способы для достижения того же результата, но всегда приятно держать плохо документированные тонкости в своем арсенале, чтобы воспользоваться ими в случае необходимости. | https://habr.com/ru/post/259589/ | null | ru | null |
# Kivy. Xamarin. React Native. Три фреймворка — один эксперимент
Приветствую всех! Как только дым от жаркой дискуссии в комментариях к моей статье [Kivy — фреймворк для кроссплатформенной разработки №1](https://habr.com/post/418839/) осел, и среди прочих пробился [достойный внимания комментарий](https://habr.com/post/418839/), мы ([Mirimon](https://habr.com/ru/users/mirimon/), [SeOd](https://habr.com/ru/users/seod/)), подумали, что было бы интересно и нам и читателям самостоятельно сравнить Kivy, Xamarin.Forms и React Native, написав на них одно и тоже приложение, сопроводить его соответствующей статьей на Хабре, [репой на GitHub](https://github.com/Mirimon/KivyXamarinReactComparison/tree/master/Kivy) и честно рассказать, кто с какими трудностями столкнулся при реализации. Собравшись в Телеграмме и обсудив детали, мы принялись за работу.
Для этого сравнения мы решили написать простой планировщик задач с тремя экранами. Делать некий срез состояния этих трех платформ на сегодняшний день на примере чего-то более объемного, чем пример, который мы выбрали, ввиду занятости каждого в своих проектах/на работе/дома, слишком долго. Несмотря на простоту нашего приложения, оно позволит наглядно показать принципы разработки приложения в каждой среде, работу с данными, UI и пр.
[Три фреймворка — один эксперимент. **Xamarin.Forms. Часть 2**](https://habr.com/company/devexpress/blog/420999/)
[Три фреймворка — один эксперимент. **React Native. Часть 3**](https://habr.com/company/devexpress/blog/421571/)
Данная статья является первой в цикле, поэтому начать хочется с ТЗ, который мы для себя набросали, чтобы результат получился похожий.
### Вариант ТЗ:
* Заметки должны быть структурированы по проектам
* Заметки могут добавляться разными людьми, так что должен быть указан автор заметки
* Заметки внутри проекта должны добавляться/удаляться/редактироваться
* Заметки должны быть размером по контенту, но не более 150 пикселей
* Удаление заметок должно быть как через контекстное меню самой заметки, так и через свайп
### Примерный UI должен выглядеть как-то так:
**Перед тем, как начать, небольшая справка по Kivy:**
*[Kivy](https://kivy.org/#home) — кросcплатформенный графический фреймворк, написанный на языке программирования Python/Cython, основанный на OpenGL ES 2, направленный на создание современных пользовательских интерфейсов, больше ориентированный на работу с сенсорными устройствами. Приложения на Kivy работают на таких платформах как Linux, OS X, Windows, Android, iOS и Rapberry Pi. В разработке вам доступен широкий спектр библиотек Python начиная от Requests и заканчивая NumPy и OpenCV. Kivy имеет доступ практически ко всем нативным мобильным API (GPS, Camera, Accelerometer, Google API, если речь идет об Android), посредством PyJNIus (Android) и PyOBJus (iOS), которые автоматически оборачивают код на Java/Objective-C в интерфейс Python.
Kivy быстр. Это относится как к разработке приложений, так и к скорости выполнения приложений. Все критически важные функции реализованы на уровне Cи. Также Kivy использует GPU везде, где это имеет смысл. GPU выполяет бОльшую часть работы, тем самым значительно увеличивая производительность.
Kivy очень гибкок. Это означает, что быстро развивающаяся разработка Kivy позволяет мгновенно адаптироваться к новым технологиям. Разработчики Kivy не раз добавляли поддержку новых внешних устройств и программных протоколов, иногда даже до их выпуска. Kivy можно использовать в сочетании с большим количеством различных сторонних решений. Например, в Windows Kivy поддерживает WM\_TOUCH, что означает, что любое устройство с драйверами Windows 7 Pen & Touch будет работать с Kivy. В OS X вы можете использовать устройства Apple с поддержкой Multi-Touch, такие как трекпады и мыши. В Linux вы можете использовать входные события ввода HID. В дополнение к этому Kivy поддерживает TUIO (Tangible User Interface Objects) и ряд других источников ввода.
Вы можете написать простое приложение с несколькими строками кода. Программы с Kivy создаются с использованием языка программирования Python, который является невероятно универсальным и мощным, но простым в использовании. Кроме того, разработчики Kivy создали собственный язык разметки графических интерфейсов, для создания сложных пользовательских GUI. Этот язык позволяет быстро настраивать, подключать и упорядочивать элементы приложения.
И, да, Kivy абсолютно бесплатен. Вы можете использовать его везде! В коммерческом продукте либо в Open Source.*
Я приведу весь код приложения и покажу достаточно подробно, как реализуются те или иные элементы при разработке под мобильные платформы. В качестве IDE я всегда использую *PyCharm*, который отлично поддерживает синтаксис **Kv Language** — специальный DSL язык, на котором пишется UI представление вашего приложения. Скелет приложения создан с помощью консольной утилиты [CreatorKivyProject](https://github.com/HeaTTheatR/CreatorKivyProject), которая предоставляет базовые экраны с использованием шаблона MVVM.
В папке **baseclass** содержится логика виджетов и контроллов, реализованная на языке программирования Python, в **kv** — файлы описания интерфейса на языке *Kv Language*. Директория **applibs** используется для сторонних библиотек, в папке **data** находятся медиаконтент, базы данных и прочие данные. Файл **main.py** — это точка входа приложения. Ничем он не занимается, кроме как запуском рендера UI **TodoList().run()**, отловом ошибки в случае ее возникновения и выводом окна для отправки баг репорта, создан автоматически утилитой *CreatorKivyProject*, не имеет отношения к написанию нашего приложения, а потому не рассматривается.
Файл **todolist.py** с программным кодом реализует класс **TodoList**, который загружает макеты интерфейса, инициализирует их инстансы, следит за событиями хард клавиш устройства и возвращает наш первый экран, которые перечислены в Activity менеджере. После **TodoList().run()** вызывается функция **build** и возвращает виджет, который будет отображен на экране.
Для примера, код простой программы, которая выводит один экран с изображением, будет выглядеть так:
А вот схема нашего класса приложения:
**todolist.py:**
```
# -*- coding: utf-8 -*-
import os
from kivy.app import App
from kivy.lang import Builder
from kivy.core.window import Window
from kivy.factory import Factory
from libs.applibs.kivymd.theming import ThemeManager
from libs.dataBase import DataBase
class TodoList(App, DataBase):
title = 'Todo List'
icon = 'icon.png'
theme_cls = ThemeManager()
theme_cls.primary_palette = 'BlueGrey'
def __init__(self, **kvargs):
super(TodoList, self).__init__(**kvargs)
Window.bind(on_keyboard=self.eventsProgram)
Window.softinput_mode = 'below_target'
self.Window = Window
self.pathToBase = '%s/data/dataProjects.json' % self.directory
self.nameAuthor = u'Иванов Юрий'
def build(self):
self.setDataProjects()
self.loadAllKvFiles(os.path.join(self.directory, 'libs', 'uix', 'kv'))
self.rootScreen = Factory.RootScreen() # стартовый экран программы
# Инстансы Activity.
self.activityManager = self.rootScreen.ids.activityManager
self.listProjectsActivity = self.rootScreen.ids.listProjectsActivity
self.listNotesActivity = self.rootScreen.ids.listNotesActivity
self.addNewNoteActivity = self.rootScreen.ids.addNewNoteActivity
return self.rootScreen
def loadAllKvFiles(self, directory_kv_files):
for kv_file in os.listdir(directory_kv_files):
kv_file = os.path.join(directory_kv_files, kv_file)
if os.path.isfile(kv_file):
Builder.load_file(kv_file)
def on_start(self):
self.listProjectsActivity.setListProjects(self)
def eventsProgram(self, instance, keyboard, keycode, text, modifiers):
if keyboard in (1001, 27):
if self.activityManager.current == 'add new note activity':
self.activityManager.backActivity(
'list notes activity', self.addNewNoteActivity.ids.floatingButton)
if self.activityManager.current == 'list notes activity':
self.activityManager.current = 'list project activity'
return True
```
Наше приложение состоит всего из трех Activity, переключением которых занимается менеджер экранов (*ScreenMenager*), который мы вернули в функции **build**:
```
#:import ListProjectsActivity libs.uix.baseclass.ListProjectsActivity.ListProjectsActivity
#:import ListNotesActivity libs.uix.baseclass.ListNotesActivity.ListNotesActivity
#:import AddNewNoteActivity libs.uix.baseclass.AddNewNoteActivity.AddNewNoteActivity
#:import ActivityManager libs.uix.baseclass.ActivityManager.ActivityManager
:
orientation: 'vertical'
spacing: dp(2)
ActivityManager:
id: activityManager
ListProjectsActivity:
id: listProjectsActivity
ListNotesActivity:
id: listNotesActivity
AddNewNoteActivity:
id: addNewNoteActivity
```
При старте приложения будет установлено то Activity, которое указано в ActivityManager первым. В нашем случае — это *ListProjectsActivity*. В приложении для списков проектов и задач я использовал *ScrollView*. Хотя правильнее было — *RecycleView*. Потому что первый, если постов и проектов будет за сотню, не справится. Точнее, будет очень долго рендерить списки. *RecycleView* позволяет вывести списки любой длины практически мгновенно. Но так как в любом случае при больших списках пришлось бы использовать либо динамическую подгрузку данных в список, либо разбиение на страницы, а в ТЗ это не обсуждалось, я использовал имеено *ScrollView*. Вторая причина состоит в том, что мне было лень переделывать списки под *RecycleView* (а он координально отличается в использовании от *ScrollView*), да и времени особо не было, потому что все приложение написано за четыре часа в перекурах и кофе брейках.
Стартовый экран со списком проектов (ListProjectsActivity.kv и ListProjectsActivity.py) выглядит следующим образом:
Поскольку разметка экрана ListProjectsActivity уже приведена на скрине, покажу, как выглядит его управляющий класс:
```
# -*- coding: utf-8 -*-
from kivy.app import App
from kivy.uix.screenmanager import Screen as Activity
from libs.uix.baseclass.InputDialog import InputDialog
from . ProjectItem import ProjectItem
class ListProjectsActivity(Activity):
objApp = App.get_running_app()
def setListProjects(self, objApp):
for nameProject in objApp.dataProjects.keys():
self.ids.layoutContainer.add_widget(ProjectItem(projectName=nameProject))
def createNewProject(self, projectName):
if projectName and not projectName.isspace():
self.ids.layoutContainer.add_widget(ProjectItem(projectName=projectName))
self.objApp.addProjectInBase(projectName)
def deleteProject(self, instance):
for projectName in self.objApp.dataProjects:
if instance.projectName == projectName:
self.objApp.deleteProjectFromBase(projectName)
break
def showDialogCreateProject(self, *args):
InputDialog(
title='Новый проект', hintText='Имя проекта',
textButtonCancel='Отмена', textTuttonOk='Да',
eventsCallback=self.createNewProject).show()
```
Вызов диологового окна:
В работе вызов окна и создание нового проекта будет выглядеть так:
| | |
| --- | --- |
| | |
На вопросе о данных приложения я не буду останавливаться, потому что данные представляют из себя обычный словарь вида
```
{"Name Project": [{"pathToAvatar": "", "nameDate": "", "nameAuthor": "", "textNote": ""}]}
```
и который хранится в директории **data** в виде простого json файла.
Посмотрим, что представляет из себя пункт с названием проекта и как в Kivy использовать удаление пункта из списка путем свайпа? Для этого мы должны наследовать поведение виджета в списке от класса *SwipeBehavior* библиотеки *SwipeToDelete*:
**ProjectItemActivity.py**
```
from kivy.properties import StringProperty
from kivy.uix.boxlayout import BoxLayout
from libs.applibs.swipetodelete import SwipeBehavior
class ProjectItemActivity(SwipeBehavior, BoxLayout):
projectName = StringProperty()
def on_touch_down(self, touch):
if self.collide_point(touch.x, touch.y):
self.move_to = self.x, self.y
return super(ProjectItemActivity, self).on_touch_down(touch)
def on_touch_move(self, touch):
if self.collide_point(touch.x, touch.y):
self.reduce_opacity()
return super(ProjectItemActivity, self).on_touch_move(touch)
def on_touch_up(self, touch):
if self.collide_point(touch.x, touch.y):
self.check_for_left()
self.check_for_right()
return super(ProjectItemActivity, self).on_touch_up(touch)
```
И описание пункта проекта в Kv разметке:
**ProjectItemActivity.kv**
```
:
swipe\_rectangle: self.x, self.y , self.width, self.height
swipe\_timeout: 1000000
swipe\_distance: 1
event\_after\_swipe: app.listActivity.deleteProject
OneLineListItem:
text: root.projectName
on\_press: app.listActivity.setNotesProject(root.projectName)
```
Вообще, у каждого виджета в Kivy есть метод ***on\_touch*** с помощью которого вы можете отловить любые события, происходящие на экране. Вот небольшая часть списка доступных событий:
```
['double_tap_time', 'grab_state', 'is_double_tap', 'is_mouse_scrolling', 'is_touch', 'is_triple_tap', 'move', 'push', 'push_attrs', 'push_attrs_stack', 'scale_for_screen', 'time_end', 'time_start', 'time_update', 'triple_tap_time', 'ungrab', 'update_time_end']
```
| | | | |
| --- | --- | --- | --- |
| | | | |
Реализация контекстного меню для Android…
Здесь тоже не возникло никаких проблем, так это всего лишь стандартный виджет DropDown. Благодоря тому, что все виджеты и контроллы в Kivy вы можете кастомизировать настолько, насколько вам позволяет ваша фантазия, я с легкостью получил симпотичную менюшку. Слева базовый DropDown, справа — мой:
| | |
| --- | --- |
| | |
Разметка списка контекстного меню:
**ContextMenuAndroidActivity.kv**
```
#:import MDSeparator libs.applibs.kivymd.card.MDSeparator
#:import MenuItem libs.applibs.animdropdown.MenuItem
:
MenuItem:
text: 'Редактировать'
menu: root
on\_press: root.tapOnItem(self.text)
MDSeparator:
MenuItem:
text: 'Удалить'
menu: root
on\_press: root.tapOnItem(self.text)
```
Программная часть контекстного меню:
**ContextMenuAndroidActivity.kv**
```
from kivy.app import App
from kivy.clock import Clock
from libs.applibs.animdropdown import AnimMenuDropDown
class ContextMenuAndroidActivity(AnimMenuDropDown):
def tapOnItem(self, textItem):
objApp = App.get_running_app()
if textItem == 'Удалить':
objApp.listActivity.deletePost()
else:
objApp.activityManager.current = 'add new note activity'
Clock.schedule_once(objApp.addNewNoteActivity.editNote, .5)
```
Далее мы импортируем кнопку *MenuDropDown* из библиотеки *animdropdown*, передаем ей в качестве параметра объект нашего контекстного меню и уже после добавляем эту кнопку в нужное нам месте нам экране. В нашем приложении это кнопка справа в карточке заметки:
Разметка Activity карточки заметки:
Базовый класс **NoteActivity**:
```
from kivy.app import App
from kivy.properties import StringProperty
from kivy.uix.boxlayout import BoxLayout
from libs.applibs.animdropdown import MenuButton
from libs.applibs.swipetodelete import SwipeBehavior
from . ContextMenu import ContextMenu
class NoteActivity(SwipeBehavior, BoxLayout):
nameDate = StringProperty()
textNote = StringProperty()
pathToAvatar = StringProperty()
def __init__(self, **kwargs):
super(NoteActivity, self).__init__(**kwargs)
self.objApp = App.get_running_app()
menuButton = MenuButton(
dropdown_cls=ContextMenu, icon='dots-vertical', _on_dropdown_fnc=self.setCurrentPost)
self.ids.titleBox.add_widget(menuButton)
def setCurrentPost(self, *args):
self.objApp.listNotesActivity.checkCurentPost = self
```
Программная реализация **ListNotesActivity**:
```
# -*- coding: utf-8 -*-
from kivy.app import App
from kivy.uix.screenmanager import Screen as Activity
from kivy.properties import ObjectProperty
from . NoteActivity import NoteActivity
class ListNotesActivity(Activity):
checkCurentPost = ObjectProperty()
objApp = App.get_running_app()
def clearList(self):
if self.objApp.activityManager.current == 'list project activity':
self.ids.layoutContainer.clear_widgets()
def addNewNote(self, objApp):
objApp.activityManager.current = 'add new note activity'
def setDefaultcheckCurentPost(self):
self.checkCurentPost = lambda x: None
def setNotesProject(self, nameProject):
self.ids.toolBar.title = nameProject
for dataProject in self.objApp.dataProjects[nameProject][1]:
self.ids.layoutContainer.add_widget(NoteActivity(
textNote=dataProject['textNote'],
nameDate=dataProject['nameDate'],
pathToAvatar=dataProject['pathToAvatar']))
def deletePost(self, instance=None):
# Удаление свайпом.
if not self.checkCurentPost:
checkCurentPost = instance
else:
checkCurentPost = self.checkCurentPost
self.ids.layoutContainer.remove_widget(self.checkCurentPost)
nameProject = self.ids.toolBar.title
self.objApp.deleteNoteFromBase(nameProject, checkCurentPost.textNote)
def checkScroll(self):
if self.checkCurentPost and type(self.checkCurentPost) is not NoteActivity:
self.checkCurentPost(self)
```
Как управлять Activity приложения? Для того чтобы переключится с одного Activity на другое, мы должны указать менеджеру экранов имя нового Activity:
```
class ListNotesActivity(Activity):
...
def addNewNote(self, *args):
self.objApp.activityManager.current = 'add new note activity'
```
… где ***'add new note activity'*** имя Activity для добавления новой заметки.
Экран и разметка Activity **AddNewNoteActivity**:
Базовый класс:
```
from kivy.app import App
from kivy.animation import Animation
from kivy.uix.screenmanager import Screen as Activity
from kivy.metrics import dp
from libs.uix.baseclass.NoteActivity import NoteActivity
class AddNewNoteActivity(Activity):
objApp = None
edit = False
oldTextNote = ''
def animationButton(self):
self.objApp = App.get_running_app()
self.ids.toolBar.title = self.objApp.listNotesActivity.ids.toolBar.title
Animation(size=(dp(56), dp(56)), d=.5, t='in_out_cubic').start(self.ids.floatingButton)
def addNewNotes(self, textNote):
if self.edit:
nameProject = self.ids.toolBar.title
self.objApp.addEditNoteInBase(nameProject, textNote, self.oldTextNote)
self.objApp.activityManager.backActivity('list notes activity', self.ids.floatingButton)
self.objApp.listNotesActivity.checkCurentPost.textNote = textNote
self.edit = False
return
self.objApp.listNotesActivity.ids.layoutContainer.add_widget(
NoteActivity(
textNote=textNote, nameDate='%s\n%s' % (
self.objApp.nameAuthor, self.objApp.getDate()),
pathToAvatar='data/images/avatar.png'))
self.objApp.addNoteInBase(self.ids.toolBar.title, textNote, 'data/images/avatar.png')
def editNote(self, interval):
self.edit = True
self.ids.textInput.text = self.objApp.listNotesActivity.checkCurentPost.textNote
self.oldTextNote = self.ids.textInput.text
```
Для анимации кнопки я использовал событие **on\_enter**, которое вызывается в момент установки Activity на экран:
В разметке:
```
on\_enter: root.animationButton()
```
В Python коде:
```
class AddNewNoteActivity(Activity):
def animationButton(self):
Animation(size=(dp(56), dp(56)), d=.5, t='in_out_cubic').start(self.ids.floatingButton)
```
В отличие от Xamarin.Forms UI в Kivy будет выглядеть везде одинаково. Так что, если вы пишите приложение для двух платформ (Android и iOS), вы должны учитывать это при разметке интерфейса и указании свойств виджетам. Или же делать две разметки для двух платформ (логика остается неизменной). Это плюс, так как рендер UI и события не зависят от особенностей платформы, вы не используете нативные API для управления этими действиями, что позволяет вашему приложению безболезнено выполнятся практически на любой платформе. Вся графика рендерится с помощью нативных вызовов OpenGL и SDL2 на GPU, что позволяет очень быстро рисовать менюшки, кнопки и прочие прелести графического интерфейса включая 2D и 3D графику.
Данное приложение использует Android UI MaterialDesign. Например, последний мой проект имел адаптивный интерфес:
А вот демонстрация возможностей в стиле Material Design:
Как я уже говорил, Kivy не использует нативные API для рендера UI, поэтому позволяет эмулировать различные модели устройств и платформ с помощью модуля ***screen***. Достаточно запустить ваш проект с нужными параметрами, чтобы на компьютере открылось окно тестируемого приложения так, как если бы оно было запущено на реальном устройстве. Звучит странно, но поскольку Kivy абстрагируется от платформы в отрисовке UI, это позволяет не использовать тяжелые и медленные эмуляторы для тестов. Это касается только UI. Например, тестовое приложение, описываемое в этой статье тестировалось с параметрами ***-m screen:droid2, portrait, scale=.75*** что один в один соответствует моему реальному устройству.
**Полный список параметров модуля screen:**
```
devices = {
# device: (name, width, height, dpi, density)
'onex': ('HTC One X', 1280, 720, 312, 2),
'one': ('HTC One', 1920, 1080, 468, 3),
'onesv': ('HTC One SV', 800, 480, 216, 1.5),
's3': ('Galaxy SIII', 1280, 720, 306, 2),
'note2': ('Galaxy Note II', 1280, 720, 267, 2),
'droid2': ('Motorola Droid 2', 854, 480, 240, 1.5),
'xoom': ('Motorola Xoom', 1280, 800, 149, 1),
'ipad': ('iPad (1 and 2)', 1024, 768, 132, 1),
'ipad3': ('iPad 3', 2048, 1536, 264, 2),
'iphone4': ('iPhone 4', 960, 640, 326, 2),
'iphone5': ('iPhone 5', 1136, 640, 326, 2),
'xperiae': ('Xperia E', 480, 320, 166, 1),
'nexus4': ('Nexus 4', 1280, 768, 320, 2),
'nexus7': ('Nexus 7 (2012 version)', 1280, 800, 216, 1.325),
'nexus7.2': ('Nexus 7 (2013 version)', 1920, 1200, 323, 2),
# taken from design.google.com/devices
# please consider using another data instead of
# a dict for autocompletion to work
# these are all in landscape
'phone_android_one': ('Android One', 854, 480, 218, 1.5),
'phone_htc_one_m8': ('HTC One M8', 1920, 1080, 432, 3.0),
'phone_htc_one_m9': ('HTC One M9', 1920, 1080, 432, 3.0),
'phone_iphone': ('iPhone', 480, 320, 168, 1.0),
'phone_iphone_4': ('iPhone 4', 960, 640, 320, 2.0),
'phone_iphone_5': ('iPhone 5', 1136, 640, 320, 2.0),
'phone_iphone_6': ('iPhone 6', 1334, 750, 326, 2.0),
'phone_iphone_6_plus': ('iPhone 6 Plus', 1920, 1080, 400, 3.0),
'phone_lg_g2': ('LG G2', 1920, 1080, 432, 3.0),
'phone_lg_g3': ('LG G3', 2560, 1440, 533, 3.0),
'phone_moto_g': ('Moto G', 1280, 720, 327, 2.0),
'phone_moto_x': ('Moto X', 1280, 720, 313, 2.0),
'phone_moto_x_2nd_gen': ('Moto X 2nd Gen', 1920, 1080, 432, 3.0),
'phone_nexus_4': ('Nexus 4', 1280, 768, 240, 2.0),
'phone_nexus_5': ('Nexus 5', 1920, 1080, 450, 3.0),
'phone_nexus_5x': ('Nexus 5X', 1920, 1080, 432, 2.6),
'phone_nexus_6': ('Nexus 6', 2560, 1440, 496, 3.5),
'phone_nexus_6p': ('Nexus 6P', 2560, 1440, 514, 3.5),
'phone_samsung_galaxy_note_4': ('Samsung Galaxy Note 4',
2560, 1440, 514, 3.0),
'phone_samsung_galaxy_s5': ('Samsung Galaxy S5', 1920, 1080, 372, 3.0),
'phone_samsung_galaxy_s6': ('Samsung Galaxy S6', 2560, 1440, 576, 4.0),
'phone_sony_xperia_c4': ('Sony Xperia C4', 1920, 1080, 400, 2.0),
'phone_sony_xperia_z_ultra': ('Sony Xperia Z Ultra', 1920, 1080, 348, 2.0),
'phone_sony_xperia_z1_compact': ('Sony Xperia Z1 Compact',
1280, 720, 342, 2.0),
'phone_sony_xperia_z2z3': ('Sony Xperia Z2/Z3', 1920, 1080, 432, 3.0),
'phone_sony_xperia_z3_compact': ('Sony Xperia Z3 Compact',
1280, 720, 313, 2.0),
'tablet_dell_venue_8': ('Dell Venue 8', 2560, 1600, 355, 2.0),
'tablet_ipad': ('iPad', 1024, 768, 132, 1.0),
'tablet_ipad_mini': ('iPad Mini', 1024, 768, 163, 1.0),
'tablet_ipad_mini_retina': ('iPad Mini Retina', 2048, 1536, 326, 2.0),
'tablet_ipad_pro': ('iPad Pro', 2732, 2048, 265, 2.0),
'tablet_ipad_retina': ('iPad Retina', 2048, 1536, 264, 2.0),
'tablet_nexus_10': ('Nexus 10', 2560, 1600, 297, 2.0),
'tablet_nexus_7_12': ('Nexus 7 12', 1280, 800, 216, 1.3),
'tablet_nexus_7_13': ('Nexus 7 13', 1920, 1200, 324, 2.0),
'tablet_nexus_9': ('Nexus 9', 2048, 1536, 288, 2.0),
'tablet_samsung_galaxy_tab_10': ('Samsung Galaxy Tab 10',
1280, 800, 148, 1.0),
'tablet_sony_xperia_z3_tablet': ('Sony Xperia Z3 Tablet',
1920, 1200, 282, 2.0),
'tablet_sony_xperia_z4_tablet': ('Sony Xperia Z4 Tablet',
2560, 1600, 297, 2.0)TodoList()
app.run()
}
```
Что можно сказать в заключение? Хорош ли Kivy? Бесспорно хорош! Если вы владеете замечательным языком программирования Python, вы без труда сможете делать приложения под мобильные (и не только) платформы с не менее замечательным фреймворком Kivy.
**Плюсы разработки приложений с использованием фреймворка Kivy:**
* Поскольку мы имеем дело с Python, скорость разработки приложений в разы превышает скорость разработки на любом другом языке программирования или фреймворке.
* Мегатонны уже готовых библиотек Python, которые вы можете использовать в своих проектах: **OpenCV, Django, Flask, NumPy, ffmpeg, sqlite3, lxml** и тысячи других.
* Поскольку Kivy для отрисовки графики использует OpenGL и GPU, а также собственные виджеты и контроллы, скорость рендера UI очень высока и вы полностью избавлены от головной боли, что присутствует в других фреймворках, которым нужно для реализации некоторых частей интерфейса лезть в нативную часть.
* Вы используете натив только там, где нужен доступ к специфическим функциям платформы, которых просто не может быть в действительно кроссплатформенном фреймворке: например, доступ к геолокации, доступ к камере, технологии BlueTooth…
Реализация доступа к нативному API Android для получения IMEI и модели устройства с помощью PyJnius:
```
def _get_model_android():
from jnius import autoclass
Build = autoclass('android.os.Build')
return str(Build.DEVICE)
def _get_imei_android():
from jnius import autoclass
Service = autoclass('org.renpy.android.PythonActivity').mActivity
Context = autoclass('android.content.Context')
TelephonyManager = Service.getSystemService(Context.TELEPHONY_SERVICE)
return str(TelephonyManager.getDeviceId())
```
Для примера — реализация нативного получения IMEI устройства на Java:
```
import android.content.Context;
import android.telephony.TelephonyManager;
public class GetImeiAndroid {
public String getImeiAndroid()
{
TelephonyManager tm = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
String IMEINumber = tm.getDeviceId();
return IMEINumber;
}
}
```
* Вы можете использовать сторонние jar библиотеки в своих проектах, если речь идет об Android.
* Вы полностью владеете всеми событиями происходящими на экране: тач, мультитач, свайп, продавливание и др. событиями без ухода в натив так это является неотъемлемой частью Kivy.
**Возможности Kivy в Touch устройствах:**
**Несмотря на все плюсы, Kivy имеет и ряд недостатков:**
* Скорость «холодного старта», то есть, первый запуск приложение от момента, когда все библиотеки будут развернуты, довольно долгий. Последующие — обычные, но дольше, чем натив, зависит от нагрузки процессора мобильного устройства.
* Работа со списками. Можно за пол секунды вывести список размером в 100 000 пунктов (например, карточки пользователей, витрина, цитаты), но с одним условием — все карточки должны быть одинаковой высоты. Если выводить список, например, цитат, с заранее неизвестным количеством текста, но целиком, то за один раз больше десяти пунктов нельзя показывать, так как это займет около 10-15 секунд. В этом случае придется подгружать по 10-15 элементов при прокрутке списка.
* Нельзя вывести текст размер которого превышает 6500 символов (3.5 страницы печатного текста) — получим черный экран. Это решается разбиением текста с последующим его склеиванием, что все равно кажется костыльным. Однако не понятно, кому может прийти в голову выводить такое количество текста за раз. Особенно если речь идет о мобильных платформах.
→ [Больше статей о Kivy](https://habr.com/users/heattheatr/posts/)
[Виртуальная машина](https://groups.google.com/forum/#!topic/kivy-users/24EG_f2h9RI) (первое сообщение от ZenCODE) от разработчиков Kivy готовая и настроеная для сборки проектов под обе ветки Python. | https://habr.com/ru/post/420691/ | null | ru | null |
# Новости из мира OpenStreetMap № 465 (11.06.2019-17.06.2019)
*Материалы конференции "[State of the Map France](https://wiki.openstreetmap.org/wiki/FR:State_of_the_Map_France_2019)" выложены в открытый доступ. [1](#wn465_20304) | Фотография Thomas Lombard, CC0*
Картографирование
-----------------
* Матеуш Кониечни [собирается](https://lists.openstreetmap.org/pipermail/talk/2019-June/082710.html) удалить дублирующие друг друга теги, такие как `sustenance=fast_food` и `amenity=fast_food` или `atm=yes` или `amenity=atm`. Как и все планы по массовому автоматическому редактированию OSM, этот тоже вызвал определенное обсуждение в списке рассылки «Тегирование».
* Джозеф Айзенберг [снова](https://lists.openstreetmap.org/pipermail/tagging/2019-June/046033.html) предлагает отмечать отдельные площадки в кемпинге тегом `tourism=camp_pitch`, который ранее он и придумал. Последняя разработанная им [схема](https://wiki.openstreetmap.org/wiki/Proposed_features/Tag:tourism%3Dcamp_pitch) тегирования, которая была отклонена, называлась `camp_site=camp_pitch`.
* Кристиан Айгер в австрийском списке рассылки «Talk» [поинтересовался](https://lists.openstreetmap.org/pipermail/talk-at/2019-June/009910.html) ([перевод](https://translate.google.com/translate?sl=auto&tl=RU&u=https://lists.openstreetmap.org/pipermail/talk-at/2019-June/009910.html)), как отмечать школы, где обучают шиацу (традиционная японская практическая терапия). Посколько он не нашел ничего подходящего в WikiOSM, спросил: можно ли ему использовать следующую пару тегов `amenity=education` и `education=shiatsu`. Ответ был отрицательным, поскольку `amenity=education` [устарел](https://wiki.openstreetmap.org/wiki/Tag:amenity%3Deducation). Ему предложили с этим вопросом обратиться на немецкий форум OSM.
* Принята уточненная схема тегирования пеленальных столиков ([changing\_table=\*](https://lists.openstreetmap.org/pipermail/tagging/2019-June/045995.html)). Она заменила собой ключ [`Key:diaper`](https://wiki.openstreetmap.org/wiki/Key:diaper). Автор этого предложения — [Вэлор Нарам](https://wiki.openstreetmap.org/wiki/User:Valor_Naram) — написал [руководство](https://wiki.openstreetmap.org/wiki/Key:changing_table#For_users_of_the_diaper.3D.2A_key) для картографов, которые могут быть знакомы со старым ключом.
* Geofabrik переписала отображение маршрутизации (Routing View) в онлайн-сервисе [OSM Inspector](http://tools.geofabrik.de/osmi/?view=routing&lon=34.71349&lat=-5.17547&zoom=7), которое используется многими картографами для поиска несвязанных дорог и иных проблем, связанных с маршрутизацией. Более подробно об изменениях можно [прочитать](https://blog.geofabrik.de/?p=522) в корпоративном блоге компании.
* Теперь в онлайн-сервисе OSMCha можно создавать [группы осмеров](https://www.openstreetmap.org/user/wille/diary/368839), а также фильтровать или скрывать изменения, сделанные членами такой группы.
Сообщество
----------
* 12 июня 2019 года сообщество OSM-UK (Великобритания) [запустило](https://lists.openstreetmap.org/pipermail/talk-gb/2019-June/023054.html) серию [суточных картотонов](https://wiki.openstreetmap.org/wiki/UK_24_hour_mapathons) для улучшения карты Великобритании. В качестве первой территории был выбран избирательный округ [Милтон-Кинс-Юг](https://wiki.openstreetmap.org/wiki/UK_24_hour_mapathons/Jun_2019_Milton_Keynes_South). В качестве единицы территориального деления парламентские избирательные округа были выбраны не случайно: на каждом из них проживает приблизительно одинакое количество жителей.
* Швейцарская Ассоциация OpenStreetMap [опубликовала](https://sosm.ch/2018-activity-report/) отчет о своей деятельности за 2018 год и план работы на ближайшее время.
Импорты
-------
* Алексис Атлан (Alexis Athlan) из французской организации по защите животных «L214» [заявил](https://lists.openstreetmap.org/pipermail/imports/2019-June/006015.html), что он собирается импортировать уточнения для 1400 ресторанов Франции, которые будут касаться наличия веганских и вегетарианских блюд.
* Давид Мораис Феррейра [ждет](https://lists.openstreetmap.org/pipermail/talk-lu/2019-June/000192.html) комментариев, так как он собирается выполнить импорт почти 500 значимых деревьев в Люксембурге.
* Пользователь Atakau [поделился](https://www.openstreetmap.org/user/Atakua/diary/368829) своими открытиями и наблюдениями, которые он сделал во время импорта данных о землепользовании и почвенно-растительном покрове в Швеции. Его детальный пост, который описывает достаточно много нюансов, должен быть прочитан всеми, кто интересуется этой темой (массовым импортом данных в OSM), поскольку в нем содержится много практических рекомендаций, а также он более содержательный, чем статья по этому вопросу в WikiOSM.
Фонд OpenStreetMap
------------------
* Фонд OSM [опубликовал](https://wiki.osmfoundation.org/w/images/9/92/FOSSGIS_annual_report_2019.pdf) годовой отчет (PDF) FOSSGIS e.В. — местного отделения OSM в Германии.
* Опубликован [протокол](https://wiki.osmfoundation.org/wiki/Licensing_Working_Group/Minutes/2019-05-09) заседания рабочей группы по лицензированию Совета OSMF от 9 мая 2019 года. Во время этой встречи обсуждался проект [«Руководства по атрибуции»](https://docs.google.com/document/d/1oEAxQHjUnZu57K-jq9ByDLNFX1OJMGkxBjMxZI1WoXI). Скорее всего, читатели помнят, что тема указания атрибуции OSM в последнее время стала все более обсуждаемой.
События
-------
* [1] Материалы конференции "[State of the Map France](https://wiki.openstreetmap.org/wiki/FR:State_of_the_Map_France_2019)" выложены в открытый [доступ](https://peertube.openstreetmap.fr/search?search=2019) .
* Инженеры французской железнодорожной компании [SNCF](https://www.sncf.com/en) представили совместную работу с Geofabrik — [Karlsruhe](https://www.geofabrik.de/projects/railway_routing/index.html), который представляет их себя инструмент маршрутизации для расчета путей движения поездов по европейской железнодорожной сети. Также многих на конференции SotM France впечатлила их [инновационная](https://twitter.com/overflorian/status/1139470862489456640?s=19) одежда.
* Осмер [ScubbX](https://hdyc.neis-one.org/?ScubbX) в австрийском списке рассылки «Talk» [написал](https://lists.openstreetmap.org/pipermail/talk-at/2019-June/009918.html), что на выставку AGIT-2019 по-прежнему доступны 10 бесплатных билетов. [AGIT](https://www.agit.at) (2-5 июля) — крупнейшая гео-выставка в немецкоязычном регионе. Сообщество OSM будет представлено стендом, для работы которого требуются волонтеры.
* Филиппинский участник OpenStreetMap [GOwin](http://hdyc.neis-one.org/?GOwin) сообщил, что с 1 по 3 августа в городе Думагет пройдет местная конференция [«Pista ng Mapa»](https://www.openstreetmap.org/user/GOwin/diary/368816). В рамках конференции планируются семинары, беседы об открытых геоданных, OpenStreetMap и дискуссии о проблемах местных картографических сообществ. Участие в конференции бесплатное, а потому она открыта всем желающим (требуется [RSVP](https://ti.to/PistaNgmapa/2019)).
Гуманитарный OSM
----------------
* HOT [приветствует](https://www.hotosm.org/updates/welcome-hots-new-voting-members-for-2019/) 38 новых членов организации [с правом голоса](https://www.hotosm.org/voting-members).
* Ежедневная немецкая газета Trierischer Volksfreund [сообщает](https://www.volksfreund.de/region/konz-saarburg-hochwald/berufsschueler-helfen-medizinern_aid-39464803) о прошедшем картатоне в городе Саарбрюккен. Студенты профессионально-технических училищ, которые научились картографированиию в редакторе JOSM в рамках проекте [Erasmus+](https://wiki.openstreetmap.org/wiki/EuYoutH_OSM), поддержали некоммерческую организацию [«Врачи без границ»](https://twitter.com/euYoutH_OSM/status/1138469798822723584). Ребята вместе улучшали карту Конго.
Образование
-----------
* Вдохновившись некоторыми выступлениями на конференции SotM-FR пользователь Polyglot [решил](https://listes.openstreetmap.fr/wws/arc/transport/2019-06/msg00023.html) провести серию стримов в Hangout на французском языке, чтобы рассказать всем желающим о том, как с помощью плагина PT\_Assistant редактировать маршруты общественного транспорта. Первый стрим будет в среду 26 июня в 19:30 по центральному европейскому времени.
Карты
-----
* Местное отделение OpenStreetMap в Бельгии [обновило](https://twitter.com/osm_be/status/1138169525176885253) метод отображения рельефа на своей [онлайн-карте](https://play.osm.be/historischekaart.html#14/50.2023/5.5638/OSMBelgium-SPWHillshadeWallonia-AIVHillshadesoftFlanders). В основу нового слоя легли общедоступные данные о высотах Фламандского региона и Валлонии.
* Использование сервиса по созданию онлайн-карт на базе OSM — uMap — становятся все более популярным. Местное отделение OSM в Германии (FOSSGIS e.В.) [профинансировало](https://lists.openstreetmap.org/pipermail/talk-de/2019-June/116193.html)  ([перевод](https://translate.google.com/translate?sl=de&tl=ru&u=https://lists.openstreetmap.org/pipermail/talk-de/2019-June/116193.html)) запуск собственного подобного сервиса на домене [openstreetmap.de](https://umap.openstreetmap.de/en/).
* С середины мая 2019 года Twitter-бот под названием “OSMTrekkingTips ( [@trending\_places](https://twitter.com/trending_places)) пишет твиты о швейцарских замках и дворцах с карты [“Castle Dossier Map”](https://castle-map.infs.ch/). Твиты выходят в 12 часов дня по вторникам и четвергам. Бот разработан лабораторией Геомета (профессор Стефан Келлер) с целью развития туризма в Швейцарии. ([Исходный код на Python](https://gitlab.com/geometalab/osmtrekkingtips/blob/master/README.md)).
Открытые данные
---------------
* На конференции "[State Of The Map France](https://twitter.com/sotmfr)" в городе Монпелье французское Геопространственное Агентство [IGN](http://www.ign.fr/) и местное отделение [OSM во Франции](https://www.openstreetmap.fr/) подписали [соглашение](https://twitter.com/IGNFrance/status/1139460904809062400?s=19) о партнерстве. IGN будет использовать стиль OSM-FR и его тайлы на своем официальном геопортале, а OSM-FR теперь разрешено использовать спутниковые снимки этого агенства (BD ORTHO) для редактирования OpenStreetMap.
* В настоящее время немецкая Википедия проводит опрос среди пользователей на предмет того, на каких областях технических усовершенствований ей следует сосредоточиться. Помимо прочего есть предложение об улучшении [поддержки геоинформации](https://de.wikipedia.org/wiki/Wikipedia:Umfragen/Technische_W%C3%BCnsche_2019_Themenschwerpunkte/Bessere_Unterst%C3%BCtzung_von_Geoinformationen)  ([перевод](https://translate.google.com/translate?sl=de&tl=ru&&u=https://de.wikipedia.org/wiki/Wikipedia:Umfragen/Technische_W%C3%BCnsche_2019_Themenschwerpunkte/Bessere_Unterst%C3%BCtzung_von_Geoinformationen)), суть которого состоит в более плотной интеграции OSM в проекты Викимедиа.
Лицензии
--------
* Рабочая группа по лицензированию Совета OSMF завершила [исследование](https://wiki.osmfoundation.org/w/images/2/24/LWG_evaluation_of_OSMF_map_tile_license_2019.pdf) (PDF), предметом которого был поиск более лучшей лицензии для тайлов, выполненных серверами OSMF, чем нынешняя CC-BY-SA 2.0.
Программное обеспечение
-----------------------
* Фредерик Родриго сделал форк онлайн-редактора iD, который сейчас доступен по адресу: [id.openstreetmap.fr](http://id.openstreetmap.fr). Он [убрал](https://github.com/frodrigo/iD/commits/compliance) спорные изменения, который до этого вызвали бурное обсуждение.
* Директора OSMAnd и Maps.Me [объединились](https://t.me/ruosm_news/1165) (ссылка ведет на пост в Telegram) и начали работу над новым проектом — [OpenPlaceReviews](https://openplacereviews.org/). Предполагается, что этот проект упростит внесение POI в OSM, а также будет хранить отзывы о них.
* С 21 по 30 июня на Азорских островах (Португалия), а именно в городе Ангра-ду-Эроишму на острове Терсейра, проходит достаточно крупный фестиваль. С помощь технологии [Azoid Eco](https://azoid.pt/) (автоматический [перевод](https://translate.google.com/translate?sl=auto&tl=RU&u=https://azoid.pt/)) собрано приложение и карта (на основе OSM) для каждого события. Приложение доступно для [iOS](https://apps.apple.com/us/app/sanjoaninas/id1400045287) и [Android](https://play.google.com/store/apps/details?id=com.azoid.sanjoaninas&hl=en_US). Чтобы узнать больше, перейдите на сайт [www.sanjoaninas.pt](https://www.sanjoaninas.pt) (автоматический [перевод](https://translate.google.com/translate?sl=auto&tl=EN&u=https://www.sanjoaninas.pt)). Может быть, в 2020 году они смогут правильно указать, откуда взяли данные.
* Онлайн-сервис MapOSMatic, который запущен на [osm-baustelle.de](https://osm-baustelle.de), теперь поддерживает файлы uMAP GeoJSON через API Umap без взаимодействия с браузером. Пользователь Хартмут в блоге проекта [рассказывает](https://blog.osm-baustelle.de/index.php/2019/06/16/umap-geojson-export-api-support/), как он это сделал.
Программирование
----------------
* Есть [предположение](https://www.reddit.com/r/openstreetmap/comments/c18hk1/has_mapbox_vector_tile_mvt_30_spec_development/), что компания Mapbox перестала работать над версией 3.0 своей спецификации векторных тайлов от Mapbox. Тем не менее, факт, что открытый Геопространственный консорциум [работает](https://www.opengeospatial.org/pressroom/pressreleases/2997) над спецификацией векторных тайлов.
* Пользователь JasonManoloudis в своем дненивке на сайте OSM [подробно](https://www.openstreetmap.org/user/JasonManoloudis/diary/368806) рассказывает о своем проекте на «Google Summer of Code». Он хочет «научить» 3D-рендер [OSM2World](http://osm2world.org/) визуализировать дорожные знаки с пользовательским текстом.
* Теперь процесс загрузки пользовательских правок в OSM обрабатывается cgimap (написана на C++), а не портом Rails (реализация Ruby on Rails API OSM), как это было ранее. Это позволило существенно увеличить скорость загрузки пользовательских правок из редакторов JOSM и iD. О деталях этого обновления [рассказывает](http://shtosm.ru/all/na-si-bystree/) Илья Зверев в своем блоге «ШТОСМ».
* Разработчик 2ГИС в корпортивном блоге на Хабре [рассказывает](https://habr.com/ru/company/2gis/blog/453182/), как можно с помощью opensource-решений и OSM буквально за пару дней сделать собственный навигатор.
Релизы
------
* В последней версии приложения [Maps 9.1.6](https://f-droid.org/packages/com.github.axet.maps) (форк Maps.Me от F-Droid) наконец-то исправлена давняя ошибка, которая не позволяла пользователям авторизоваться в OSM. Теперь с помощью этого приложения можно снова редактировать OSM.
* В своем дневнике Саймон Пул [подробно](https://www.openstreetmap.org/user/SimonPoole/diary/368821) рассказывает об изменениях, которые вошли в минорный релиз мобильного редактора [Vespucci](https://wiki.openstreetmap.org/wiki/Vespucci). В основном улучшения касаются пользовательского интерфейса.
* Разработчики онлайн-редактора iD [создали](https://github.com/openstreetmap/openstreetmap-website/pull/2267) запрос на включение кода, который отменит собой ряд спорных нововведений, спровоцировавших не так давно бурное обсуджение.
Знаете ли вы …
--------------
* …… как отметить общественный книжный шкаф для буккросинга? Это [`amenity=public_bookcase`](https://wiki.openstreetmap.org/wiki/Tag:amenity%3Dpublic_bookcase).
Другие «гео» события
--------------------
* Мир — это цветочный [шар](https://twitter.com/mainau/status/1139108671416393728) в прибрежном саду на цветочном острове [Майнау](https://www.openstreetmap.org/#map=17/47.70418/9.19781) в Боденском озере.
* На Всемирном Геопространственном форуме в Амстердаме был [представлен](https://www.directionsmag.com/pressrelease/8911) онлайновый картографический портал для европейских геоданных. Он был разработан [thinkWhere](https://thinkwhere.com), чтобы продемонстрировать удобство единой точки доступа к общедоступным данным.
---
Общение российских участников OpenStreetMap идёт в [чатике](https://t.me/ruosm) Telegram и на [форуме](http://forum.openstreetmap.org/viewforum.php?id=21). Также есть группы в социальных сетях [ВКонтакте](https://vk.com/openstreetmap), [Facebook](https://www.facebook.com/openstreetmap.ru), но в них в основном публикуются новости.
[Присоединяйтесь к OSM!](https://www.openstreetmap.org/user/new)
---
Предыдущие выпуски: [464](https://habr.com/ru/post/456606/), [463](https://habr.com/ru/post/455455/), [462](https://habr.com/ru/post/454556/), [461](https://habr.com/ru/post/453490/), [460](https://habr.com/ru/post/452700/) | https://habr.com/ru/post/457404/ | null | ru | null |
# Deferred: все подробности
В [предыдущей статье](http://habrahabr.ru/blogs/twisted/51762/ "Асинхронное программирование: концепция Deferred") были описаны основные принципы работы Deferred и его применение в асинхронном программировании. Сегодня мы постараемся рассмотреть в деталях функционирование Deferred и примеры его использования.
Итак, Deferred — это отложенный результат, результат выполнения, который станет известен через некоторое время. Результатом, хранящимся в Deferred, может быть произвольное значение (успешное выполнение) или ошибка (исключение), которое произошло в процессе выполнения асинхронной операции. Раз нас интересует результат операции и мы получили от некоторой асинхронной функции Deferred, мы хотим выполнить действия в тот момент, когда результат выполнения будет известен. Поэтому Deferred кроме результата хранит еще цепочку обработчиков: обработчиков результатов (callback) и обработчиков ошибок (errback).
Рассмотрим поподробнее цепочку обработчиков:
Обработчики располагаются по “слоям” или уровням, выполнение происходит четко по уровням сверху вниз. При этом на каждом уровне расположены обработчики callback и errback, один из элементов может отсутствовать. На каждом уровне может быть выполнен либо callback, либо errback, но не оба. Выполнение обработчиков происходит только один раз, повторного входа быть не может.
Функции-обработчики callback являются функциями с одним аргументом — результатом выполнения:
```
def callback(result):
…
```
Функции-обработчики errback принимают в качестве параметра исключение, “завернутое” в класс [Failure](http://twistedmatrix.com/documents/current/api/twisted.python.failure.Failure.html "API reference Failure"):
```
def errback(failure):
…
```
Выполнение Deferred начинается с того, что в Deferred появляется результат: успешное выполнение или исключение. В зависимости от результата выбирается соответствующая ветвь обработчиков: callback или errback. После этого происходит поиск ближайшего уровня обработчиков, в котором существует соответствующий обработчик. В нашем примере на рисунке был получен успешный результат выполнения и результат был передан обработчику `callback1`.
Дальнейшее выполнение приводит к вызову обработчиков на нижележащих уровнях. Если callback или errback завершается возвратом значения, которое не является Failure, выполнение считается успешным и полученный результат отправляется на вход callback-обработчику на следующем уровне. Если же в процессе выполнения обработчика было выкинуто исключение или возвращено значение типа Failure, управление будет передано errback на следующем уровне, который получит исключение в качестве параметра.
В нашем примере обработчик `callback1` выполнился успешно, его результат был передан обработчику `callback2`, в котором было выкинуто исключение, которое привело к переходу к цепочке errback-обработчиков, на третьем уровне обработчик errback отсутствовал и исключение было передано в `errback4`, который обработал исключение, вернул успешный результат выполнения, который теперь является результатом Deferred, однако больше обработчиков нет. Если к Deferred будет добавлен еще один уровень обработчиков, они смогут получить доступ к этому результату.
Как и все другие объекты Python, объект Deferred живет до тех пор, пока на него есть ссылки из других объектов. Обычно объект, вернувший Deferred, сохраняет его, т.к. ему надо по завершении асинхронной операции передать в Deferred полученный результат. Чаще всего другие участники (добавляющие обработчики событий) не сохраняют ссылки на Deferred, таким образом объект Deferred будет уничтожен по окончании цепочки обработчиков. Если происходит уничтожение Deferred, в котором осталось необработанное исключение (выполнение завершилось исключением и больше обработчиков нет), на экран печатается отладочное сообщение с traceback исключения. Эта ситуация аналогична “выскакиванию” необработанного исключения на верхний уровень в обычной синхронной программе.
Deferred в квадрате
-------------------
Возвращаемым значением callback и errback может быть также другой Deferred, тогда выполнение цепочки обработчиков текущего Deferred приостанавливается до окончания цепочки обработчиков вложенного Deferred.
В приведенном на рисунке примере обработчик callback2 возвращает не обычный результат, а другой Deferred — Deferred2. При этом выполнение текущего Deferred приостанавливается до получения результата выполнения Deferred2. Результат Deferred2 — успешный или исключение — становится результатом, передаваемым на следующий уровень обработчиков первого Deferred. В нашем примере Deferred2 завершился с исключением, которое будет передано на вход обработчику `errback2` первого Deferred.
Обработка исключений в errback
------------------------------
Каждый обработчик исключений errback является аналогом блока try..except, а блок except обычно реагирует на некоторый тип исключений, такое поведение очень просто воспроизвести с помощью [Failure](http://twistedmatrix.com/documents/current/api/twisted.python.failure.Failure.html "API reference Failure"):
```
def errback(failure):
"""
@param failure: ошибка (исключение), завернутое в failure
@type failure: C{Failure}
"""
failure.trap(KeyError)
print "Got key error: %r" % failure.value
return 0
```
Метод `trap` класса `Failure` проверяет, является ли завернутое в него исключение наследником или непосредственно классом `KeyError`. Если это не так, оригинальное исключение снова выбрасывается, прерывая выполнение текущего errback, что приведет к передаче управления следующему errback в цепочке обработчиков, что имитирует поведение блока `except` при несоответствии типа исключения (управление передается следующему блоку). В свойстве `value` хранится оригинальное исключение, которое можно использовать для получения дополнительной информации об ошибке.
Необходимо обратить внимание, что обработчик errback должен завершиться одним из двух способов:
1. Вернуть некоторое значение, которое станет входным значением следующего callback, что по смыслу означает, что исключение было обработано.
2. Выкинуть оригинальное или новое исключение — исключение не было обработано или было перевыброшено новое исключение, цепочка обработчиков errback продолжается.
Существует и третий вариант — вернуть Deferred, тогда дальнейшее выполнение обработчиков будет зависеть от результата Deferred.
В нашем примере мы исключение обработали и передали в качестве результата 0 (например, отсутствие некоторого ключа эквивалентно его нулевому значению).
Готовимся к асинхронности заранее
---------------------------------
Как только появляется асинхронность, то есть некоторая функция вместо непосредственного значения возвращает Deferred, асинхронность начинает распространяться по дереву функций выше, заставляя возвращать Deferred из функций, которые раньше были синхронными (возвращали результат непосредственно). Рассмотрим условный пример такого превращения:
```
def f():
return 33
def g():
return f()*2
```
Если по каким-то причинам функция `f` не сможет вернуть результат сразу, она начнет возвращать Deferred:
```
def f():
return Deferred().callback(33)
```
Но теперь и функция `g` вынуждена возращать Deferred, зацепляясь за цепочку обработчиков:
```
def g():
return f().addCallback(lambda result: result*2)
```
Аналогичная схема “превращения” происходит и с реальными функциями: мы получаем результаты в виде Deferred от нижележащих в дереве вызовов функции, навешиваем на их Deferred свои обработчики callback, которые соответствуют старому, синхронному коду нашей функции, если у нас были обработчики исключений, добавляются и обработчики errback.
На практике лучше сначала выявить те места кода, которые будут асинхронными и будут использовать Deferred, чем переделывать синхронный код в асинхронный. Асинхронный код начинается с тех вызовов, которые не могут построить результат непосредственно:
* сетевой ввод-вывод;
* обращение к сетевым сервисам СУБД, memcached;
* удаленные вызовы RPC;
* операции, выполнение которых будет выделено в нить в модели Worker и т.п.
В процессе написания приложения часто ясно, что в данной точке будет асинхронное обращение, но его еще нет (не реализован интерфейс с СУБД, например). В такой ситуации можно использовать функции `defer.success` или `defer.fail` для создания Deferred, в котором уже содержится результат. Вот как можно короче переписать функцию `f`:
```
from twisted.internet import defer
def f():
return defer.success(33)
```
Если мы не знаем, будет ли вызываемая функция возвращать результат синхронно или вернет Deferred, и не хотим зависеть от её поведения, мы можем завернуть обращение к ней в `defer.maybeDeferred`, которое любой вариант сделает эквивалентным вызову Deferred:
```
from twisted.internet import defer
def g():
return defer.maybeDeferred(f).addCallback(lambda result: result*2)
```
Такой вариант функции `g` будет работать как с синхронной, так и с асинхронной `f`.
Вместо заключения
-----------------
Рассказывать о Deferred можно еще очень долго, в качестве дополнительного чтения могу опять порекомендовать список материалов в конце [предыдущей статьи](http://habrahabr.ru/blogs/twisted/51762/ "Асинхронное программирование: концепция Deferred"). | https://habr.com/ru/post/52924/ | null | ru | null |
# Руководство по WebKit-атрибуту srcset в тэге img
Свободный движок WebKit теперь поддерживает srcset атрибут изображений, IMG элементов ([официальная спецификация от W3C](http://www.w3.org/html/wg/drafts/srcset/w3c-srcset/)). Это позволяет вам, как разработчику, использовать картинки с высоким разрешением для пользователей использующих ретина-дисплей без ущерба для остальных пользователей. Также важно отметить о наличие изящного решения для браузеров, которые еще не поддерживают данный функционал.
Обратите внимание, в необходимости использовать [последние ночные сборки WebKit](http://nightly.webkit.org/).
Возможно, вы знаете, что WebKit поддерживает -webkit-image-set CSS функцию чуть более года (Safari начиная с 6 версии и Google Chrome начиная с 21 версии). С помощью данной функции появилась возможность задавать в css-свойствах изображения в зависимости от разрешения экрана, или другого устройства воспроизведения, каждое с модификатором 1х, 2х.
```
.class {
/* задаем фоновое изображение, если браузер не поддерживает image-set */
background-image: url(image-set-not-supported.png);
/* задаем фоновые изображения, для различных разрешений */
background-image: -webkit-image-set(url(low-res-image.jpg) 1x, url(high-res-image.jpg) 2x);
}
```
Это позволит браузеру выбрать наилучший вариант для конкретного устройства пользователя. Прежде, для поддержки больших картинок у вас было несколько путей развития, каждый с определенными недостатками. Вы могли дублировать CSS код. Вы могли использовать JavaScript для запроса (window.devicePixelRatio) количества точек на px. (device pixel ratio) и обновлять картинки после загрузки страницы. Или вы могли всегда отдавать большие картинки, тем самым заставляя некоторых пользователей грузить лишнее. И если вам необходимы были картинки с разными разрешениями приходилось уточнять связанные CSS свойства, такие как background-size как часть border-image. Это раздражало.
К счастью, -webkit-image-set позволяет написать вам одно простое правило, тем самым заставив браузер самому определять более подходящую картинку и как следствие её и загружать.
Srcset атрибут очень похож на -webkit-image-set. В самом деле, можно подумать об атрибуте как об эквивалентной функции CSS. Аналогично списку картинок в -webkit-image-set, вы добавляете новый атрибут srcset к вашим графическим элементам. Поддерживается обратная совместимость, браузеры не поддерживающие srcset, игнорируют его и продолжают использовать src. А вся прелесть в том, что браузерный движок глянет на srcset и сам определит наилучшую картинку к загрузке. В большинстве случаев вам необходимо написать вот так:
```
```
Обратили внимание на “2x” после “better-image.jpg”? Это говорит браузеру, что для экранов устройств с devicePixelRatio = 2 и более, необходимо использовать better-image.jpg взамен normal-image.jpg. И если экран устройства не «ретина», браузер обратится к атрибуту src. Вы также можете задавать значение 1х атрибута srcset, как в примере ниже.
**Srcset атрибут**Ниже приведено изображение — img элемент с обоими атрибутами: src и srcset. Существует стиль устанавливающий размер картинки в 400x400px. В браузерах без поддержки srcset, будет использоваться значение src, а следовательно загрузится стандартная картинка:
Больше об srcset можно прочитать в [официальной спецификации](http://www.w3.org/html/wg/drafts/srcset/w3c-srcset/). Обратите внимание, что на данный момент только WebKit поддерживает «коэффициенты разрешений» — 1x, 2x, 3x. Как и любой новый функционал, WebKit может содержать ошибки, поэтому будьте бдительны. В частности, вы должны убедиться, что WebKit загружает минимальные ресурсы для страницы, потому что это одна из целей этой функции.
Особая благодарность членам сообщества WebKit Romain Perier и Yoav Weiss которые внесли важный вклад (r153624, r153733) в развитие данного функционала.
P.S. Замечания по переводу присылайте в личку. | https://habr.com/ru/post/190464/ | null | ru | null |
# Настройка и использование Web Optimizer
[](http://code.google.com/p/web-optimizator/)Пока выпуск версии 0.5 веб-приложения, автоматизирующего клиентскую оптимизацию для PHP-сайтов, отодвигается на некоторое неопределенное время, мы решили подготовить небольшой обзор текущих настроек и возможностей приложения.
### Особенности работы
Web Optimizer перехватывает выводимый HTML-документ и преобразовывает его к оптимальному виду. В частности, анализируется вся секция `head` на предмет CSS- и JavaScript-файлов, также при существовании статических хостов изображения распределяются по ним (меняются адреса у изображений), а блоки с рекламой и счетчиками переносятся перед (опять-таки только при включении соответствующей настройки). Также HTML подвергается минимизации (удаляются лишние переводы строк и отступы, могут удаляться комментарии и вообще все лишние символы, но это ресурсоемкие операции, и по умолчанию они выключены).
Загрузить приложение
[code.google.com/p/web-optimizator/downloads/list](http://code.google.com/p/web-optimizator/downloads/list)
### Настройка Web Optimizer
Ниже приведены настройки, доступные в Web Optimizer версии 0.4.9.7 (войдут в 0.5 без изменений):
* **Директории кэширования**. Здесь можно выставить пути к кэширующим директориям (на файловой системе), в которых будут записываться сохраненные уменьшенные CSS-, JavaScript- и HTML-файлы. Также здесь можно определить корневую директорию сайта (необходима для правильного расчета всех относительных путей). По умолчанию все кэширующие директории назначаются в папке `cache` в самом Web Optimizer.
* **Настройки сжатия**. Эта группа настроек отвечает за объединении и минимизацию JavaScript- и CSS-файлов. По умолчанию JavaScript-файлы объединяются и минимизируются при помощи JSMin (или YUI Compressor, если доступна `java`). Также можно сжимать JavaScript при помощи Dean Edwards Packer (является лучшим выбором при отсутствии `gzip`-сжатия). Здесь также можно настроить, каким образом минимизировать выводимый HTML-код (простое удаление лишних переводов строк и пробелов, «вытягивание» в одну строку и(ли) удаление комментариев). Условные комментарии для IE не затрагиваются ни в каком случае.
* **Включить внешние JavaScript-файлы**. Web Optimizer может загружать внешние JavaScript-файлы (вызываемые с других доменов), а также внутренний код (заключенный прямо в | https://habr.com/ru/post/62009/ | null | ru | null |
# Как сделать трансформер чат-бот на Trax?
Экспериментировать с библиотекой Trax и архитектурой трансформер оказалось крайне увлекательно. Предыдущая статья была про [саммаризатор](https://habr.com/ru/post/543278/). В этой хочу рассказать о том, как я учил трансформер общаться **на русском языке**.
Сравнительно простого чат-бота можно построить на базе языковой модели, которая умеет прогнозировать следующее слово по предыдущим, и которую несложно сделать, используя Трансформер-декодер по аналогии с GPT. В этом случае диалог формируется как связный неструктурированный текст. Чтобы превратить этот текст в чат, нужно вмешиваться в процесс генерации, добавляя реплики пользователя. Но обо всём по порядку.
В качестве фреймворка я использовал библиотеку Trax.[Trax](https://trax-ml.readthedocs.io/en/latest/) — библиотека глубокого обучения с фокусом на понятный код и быстрые вычисления. Библиотека активно развивается и поддерживается командой Google Brain. Trax использует tensorflow и является одной из библиотек в его экосистеме, работает на CPU, GPU и TPU. На Google Colab TPU проверил. Нужно следить, чтобы количество текстов в пакете при обучении было кратно восьми.
Для модели чат-бота я решил попробовать новую архитектуру — Reformer. Это трансформер, который может работать с длинными текстами размером с хорошую книгу буквально на одном ускорителе. Reformer кардинально снижает используемый объем памяти. Это достигается за счет двух вещей. Во-первых, у Reformer более эффективный в смысле памяти механизм внимания. Во-вторых, реверсивная схема вычислений, позволяющая отказаться от хранения значений активации для расчета градиента. Детали [здесь](https://towardsdatascience.com/reformer-the-efficient-transformer-dd9830164703) на английском, а [здесь](https://habr.com/ru/post/522622/) перевод заметки из Google AI Blog.
Мотивация: не то что бы у меня были какие-то гигантские диалоги, но очень хотелось посмотреть как Reformer ведет себя на [Google Colab](https://colab.research.google.com/notebooks/intro.ipynb) и как учится в сравнении с Transformer.
Оказалось, не зря.
"Танцы с бубном" вокруг ReformerВ Trax версии 1.3.7 (устанавливается через pip) в Reformer не удается загрузить веса предобученной модели. Это ошибка была исправлена в версии 1.3.4 и снова проявилась в 1.3.7. На [форуме](https://gitter.im/trax-ml/community) предложили пока использовать версию 1.3.6. Так и сделал, тут же возникла проблема с библиотекой T5, части которой Trax использует для работы с данными. Откатив и T5 к предыдущей версии, я «потерял» trax.data.tokenize, который отказался работать с последней версией sentencepiece. Тут я бросил путешествовать в историю пакетов и просто сегментировал всё заранее при помощи SentencePieceProcessor.
Данные
------
Нужный набор данных я скачал на [Яндекс.Толока](https://toloka.ai/ru/datasets). Он называется «Toloka Persona Chat Rus» и его можно использовать в некоммерческих целях с упоминанием источника. Упоминаю: Ребята из Яндекс.Толока — вы большие молодцы!
Набор содержит 10000 русскоязычных диалогов на общие темы с возможностью фильтрации по профилю пользователя. Можно было бы например отфильтровать диалоги, где один из пользователей женщина, но я посчитал, что их и так не очень много. Диалоги представлены в виде HTML-текста, пришлось потратить некоторое время на чистку.
Примеры текста в процессеВ наборе данных:
Пользователь 2: Привет) расскажи о себе
Пользователь 1: Привет) под вкусный кофеек настроение поболтать появилось
)
Пользователь 2: Что читаешь? Мне нравится классика
Пользователь 2: Я тоже люблю пообщаться
Пользователь 1: Люблю животных, просто обожаю, как и свою работу)
Пользователь 1: Я фантастику люблю
Пользователь 2: А я выращиваю фиалки
...
После очистки:
2: Привет) расскажи о себе
1: Привет) под вкусный кофеек настроение поболтать появилось )
2: Что читаешь? Мне нравится классика
2: Я тоже люблю пообщаться
1: Люблю животных, просто обожаю, как и свою работу)
1: Я фантастику люблю
2: А я выращиваю фиалки...
2: И веду здоровый и активный образ жизни!
После склейки реплик:
2: Привет) расскажи о себе
1: Привет) под вкусный кофеек настроение поболтать появилось )
2: Что читаешь? Мне нравится классика Я тоже люблю пообщаться
1: Люблю животных, просто обожаю, как и свою работу) Я фантастику люблю
2: А я выращиваю фиалки И веду здоровый и активный образ жизни!
Некоторые диалоги начинаются со второго пользователя, там нужна замена идентификаторов:
1: Привет) расскажи о себе
2: Привет) под вкусный кофеек настроение поболтать появилось )
1: Что читаешь? Мне нравится классика Я тоже люблю пообщаться
2: Люблю животных, просто обожаю, как и свою работу) Я фантастику люблю
1: А я выращиваю фиалки И веду здоровый и активный образ жизни!
Для обучения модели требуется неструктурированный текст, примерно такой:
'1: Привет) расскажи о себе 2: Привет) под вкусный кофеек настроение поболтать появилось ) 1: Что читаешь? Мне нравится классика Я тоже люблю пообщаться 2: Люблю животных, просто обожаю, как и свою работу) Я фантастику люблю 1: А я выращиваю фиалки И веду здоровый и активный образ жизни! 2: Ух ты, интересно. 1: Ты случайно не принц на белом коне? Я его очень жду.. 2: А у меня из хобби каждую неделю тусить с моим лучшим другом) STOP'
Два момента:
1. Идентификаторы «Пользователь 1:» и «Пользователь 2:» в исходном тексте пришлось сократить до «1:» и «2:», чтобы они не разбивались на два токена.
2. В конец каждого диалога я добавил слово STOP, которое кодируется одним токеном. Это нужно для остановки декодера при генерации диалога.
Справедливо решив, что для модели с несколькими десятками миллионов параметров десяти тысяч диалогов будет маловато, я сделал еще 36 тысяч, просто «откусывая» от начала диалогов по четному количеству реплик так, чтобы оставалось не меньше восьми. В общем, и этого не очень-то много, в связи с этим вопрос: где взять еще диалогов на русском?
Процесс подготовки данных представлен на схеме:
В качестве модели для сегментации текста, как и в эксперименте с саммаризатором, я использовал Byte Pair Encoding (BPE) из библиотеки [sentencepiece](https://github.com/google/sentencepiece). Размер словаря 10k токенов.
Пример текста после сегментации['▁1:', '▁Привет', ')', '▁расскажи', '▁о', '▁себе', '▁2:', '▁Привет', ')', '▁под', '▁вкусный', '▁кофе', 'ек', '▁настроение', '▁поболтать', '▁появи', 'лось', '▁)', '▁1:', '▁Что', '▁читаешь', '?', '▁Мне', '▁нравится', '▁класси', 'ка'...
... '▁Ты', '▁случайно', '▁не', '▁прин', 'ц', '▁на', '▁б', 'елом', '▁ко', 'не', '?', '▁Я', '▁его', '▁очень', '▁жду', '..', '▁2:', '▁А', '▁у', '▁меня', '▁из', '▁хобби', '▁каж', 'дую', '▁неделю', '▁ту', 'сить', '▁с', '▁моим', '▁луч', 'шим', '▁другом', ')', '▁STOP']
Размеры корзин для формирования пакетов фиксированной длинны выбирал по гистограмме. Решил отказаться от текстов короче шестидесяти четырех токенов.
Модель
------
Модель Reformer создается несколькими строчками кода:
```
def ReformerLM(vocab_size=vocab_size, n_layers=6, mode='train',
attention_type=tl.SelfAttention):
model = trax.models.ReformerLM(
vocab_size=vocab_size,
n_layers=n_layers,
mode = mode,
attention_type=attention_type
)
return model
ChatModel = ReformerLM()
```
У Reformer есть два собственных варианта реализации механизма внимания: Self Attention и LSH Attention. Первый экономит память, рассчитывая только отдельные сегменты матрицы весов внимания, хотя это по прежнему dot-product attention. Второй оценивает сходство векторов через локально-чувствительное хеширование (locality-sensitive hashing). LSH я еще не испытал, по идее должно работать быстрее, но нужно подбирать параметры хеширования.
За исключением размера словаря параметры модели взяты по умолчанию:
Шесть декодеров, в каждом восемь головок
Размер словаря: 10000
Размер векторного пространства: 512
Размер слоя прямого распространения: 2048
Вероятность выключения нейронов из обучения (dropout): 0.1
Схему модели можно вывести командой print(model).
Картинка в стиле «длиннокот» для одного декодер-блокаОбучение
--------
В моей модели 35 млн. параметров, обучал сериями по 20 тысяч шагов. Каждая серия чуть больше двух часов. Всего восемь серий или 160 тысяч итераций. Загрузка весов для модели после очередной серии является стрессом, качество в этот момент нестабильно. Заметил это только когда «прикрутил» TensorBoard. Оказалось совсем несложно, формат логов стандартный.
TensorBoard в colab-ноутбуке:
```
%load_ext tensorboard
%tensorboard --logdir ../root/model/ # folder where train and eval logs...
```
Кривые обучения для третьей и четвертой серии. Виден «стресс» на 40k.
До 100k с шагом обучения 2e-4 модель учится сравнительно ровно. Потом проявляются переобучение и зависания в локальных минимумах. Нужно снижать шаг обучения и увеличивать dropout. Не рекомендую dropout больше 0.2. Обучение сильно замедляется, а качество откатывается на пару серий назад. Кривые для шестой и седьмой серии:
За восемь серий кросс-энтропийная ошибка (cross entropy loss) упала с 10 до 1.6-1.8, доля правильных ответов (accuracy) выросла в среднем до 60%.
Чат-бот
-------
Для чат-бота нужен интерактивный декодер (не путать с декодер-блоком Reformer). Он должен принимать реплики пользователя и добавлять их в конец последовательности, на основе которой модель определяет следующий токен. В основе декодера — авторегрессионный генератор из библиотеки [trax](https://trax-ml.readthedocs.io/en/latest/trax.supervised.html#module-trax.supervised.decoding). Авторегрессионный означает, что следующий токен генерируется на основе текущего и всей предыдущей истории, а затем сам становится текущим. Чтобы очистить историю нужно установить исходное состояние модели, которое можно считать в переменную после инициализации и загрузки весов. Делается это простой инструкцией: STARTING\_STATE = model.state и также потом устанавливается: model.state = STARTING\_STATE.
Детали декодераДекодер использует генератор в виде следующей конструкции, где start\_sequence массив (id) токенов, с которого начинается генерация:
```
def output_gen(model, start_sequence, temperature, accelerate):
# Add batch dimension to array
input_batch = np.expand_dims(start_sequence, axis=0)
gen = trax.supervised.decoding.autoregressive_sample_stream(
model,
inputs=input_batch,
temperature=temperature,
accelerate=accelerate
)
return gen
```
Про температуру: temperature (float) — параметр, определяющий выбор следующего токена. Если 0, работает как argmax, выбирается наиболее вероятный токен (жадный декодер). Если больше нуля (до 1.) — семплирует из распределения вероятностей. Чем выше температура, тем более случайным будет выбор.
Про акселерацию: в Trax есть акселератор уровней. Он умеет обрабатывать пакетный ввод на нескольких устройствах ускорителя, если их больше одного. Если же устройство одно, использует JIT-компиляцию.
Упрощенно алгоритм декодера выглядит так (бот начинает первым):
**Вход:** модель, исходное состояние модели, параметры температуры и акселерации.
**Выход:** нет
....Инициировать start\_sequence токенами приветствия (например, '1: Привет 2:')
....Инициировать реплику пустым списком
....Присвоить значения переменным:
....P1 ← токен первого пользователя ('1:')
....P2 ← токен второго пользователя ('2:')
....STOP ← токен останова
....**Выполнять пока** в start\_sequence отсутствует токен STOP:
........Установить исходное состояние модели
........**Если** start\_sequence заканчивается на Р2:
............Печатать реплику между последними P1 и P2 в start\_sequence
............Принять и напечатать ввод от пользователя
............Добавить ввод пользователя к start\_sequence
............Добавить P1 к start\_sequence
........**Конец Если**........**Выполнять пока** в реплике не появится токен P2:
............Итерировать авторегрессионный генератор с параметрами темп. и акселерации
............Добавить новый токен в реплику
........**Конец цикла**
........Добавить реплику к start\_sequence
........Очистить реплику
....**Конец цикла**
Я сделал два декодера, бот — первый, пользователь — второй, и наоборот. Во всех примерах жадный декодер (температура = 0, см. спойлер "Детали декодера"). Если температура нулевая и вы пишите одни и те же реплики, диалог будет одним и тем же.
Пример почти идеального диалога:
(бот — первый, реплики выделены):
**1: Привет**
2: Привет
**1: Как дела?**
2: Отлично. А у вас?
**1: Тоже хорошо Чем занимаешься?**
2: Я фрилансер
**1: Я учитель младших классов**
2: Ух ты. Вам нравятся дети?
**1: Да, у меня трое детей**
2: Наверное нелегко с ними?
**1: Да, мы с ними часто ходим в походы**
2: Ого. Вы любите путешествовать?
**1: Да, люблю**
2: А я хочу в Японию. Это моя мечта
**1: Что ты любишь?**
2: Музыку и красное вино. А вы?
**1: Мне нравится**
2: Ладно. Мне пора бежать.
Менее удачные диалоги(бот — второй)
1: Добрый день
**2: Привет**
1: Как ваши дела?
**2: Хорошо, а у вас?**
1: Отлично. Чем занимаетесь?
**2: Я работаю в школе, а вы?**
1: Я архитектор
**2: Чем занимаетесь?** *(архитекторы модели видимо не знакомы)*
1: Я программист
**2: Это очень интересно**
1: Как вас зовут?
**2: Елена, а вас?**
1: Я Игорь. Вам нравятся дети?
**2: Нет, детей у меня нет**
1: Любите читать? Или готовить?
**2: Я люблю читать книги**
1: Что вам нравится читать?
**2: Я люблю психологию**
1: О, интересно. А какая ваша любимая книга?
**2: Я люблю русскую литературу, а вам?**
1: Мне нравится фантастика
**2: Я читала про любовь, мне немного нравится, спасибо за общение, но мне пора**
1: Пока
Тут я немного поиздевался
(бот — второй)
1: Приветище!!!
**2: Привет, как дела?**
1: Нормально. Чем занимаешься?
**2: Я работаю в школе, а ты?**
1: А как тебя зовут?
**2: Я люблю детей, поэтому я учитель младших классов, а ты?**
1: Я Игорь. А тебя как зовут?
**2: Я Ксюша, а ты?**
1: Чем занимаешься, Ксюша?
**2: Я люблю читать книги, а ты?**
1: Я тоже. Какая твоя любимая?
**2: Граф Монте Кристогова** *(из каких двух слов модель это склеила?)*
1: Интересно. А кто твой любимый актер?
**2: Да, я люблю детей, а ты?**
1: У меня есть дочь
**2: У меня есть дети, мальчики, мальчики**
1: А коты? Ты любишь котов?
**2: Да, очень, а ты?**
1: Нравятся. А дельфинов?
**2: Да, но я их люблю, а ты?**
1: Мне нравятся кошки, дельфины и лошади
**2: У тебя есть домашние животные?**
1: Был старый кот
**2: У меня кот**
1: Ясно. Мне пора работать.
**2: Пока**
1: Пока
Скринкаст. Ускорил в два раза.
В [коде](https://github.com/khmelkoff/TraxRuReformer/blob/main/TraxRuChat.ipynb) есть еще full text decoder. это генератор текста без пользователя. Он нужен, чтобы быстро оценить качество этапа.
Для декодеров использовал фрагменты кода из неоцениваемой части задания на курсе ["Natural Language Processing with Attention Models"](https://www.coursera.org/learn/attention-models-in-nlp). Курс великолепен. Рекомендую!
Ссылки
------
* Мой [**репозитарий**](https://github.com/khmelkoff/TraxRuReformer) с кодом эксперимента.
* Репозитарий [trax](https://github.com/google/trax)
* Статья на arxiv: ["Reformer: The Efficient Transformer"](https://arxiv.org/abs/2001.04451), вышла в начале 2020 года . | https://habr.com/ru/post/544494/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.